Bug 1612044 - Error rather than panic when passed an invalid stream token. r=chunmin

Differential Revision: https://phabricator.services.mozilla.com/D61319

--HG--
extra : moz-landing-system : lando

media/audioipc/README_MOZILLA

@@ -5,4 +5,4 @@ Makefile.in build files for the Mozilla build system.
 
 The audioipc-2 git repository is: https://github.com/djg/audioipc-2.git
 
-The git commit ID used was 86d49ddfca8b016a4b60b0b3fef76052194b8aa3 (2020-01-25 20:43:03 +1300)
+The git commit ID used was bc369ec35d2e40544c5273beb935e23d3fe60e04 (2020-01-30 21:25:48 +0100)

media/audioipc/server/src/server.rs

@@ -242,7 +242,7 @@ impl ServerStreamCallbacks {
                 frames
             }
             _ => {
-                error!("Unexpected message {:?} during data_callback", r);
+                debug!("Unexpected message {:?} during data_callback", r);
                 // TODO: Return a CUBEB_ERROR result here once
                 // https://github.com/kinetiknz/cubeb/issues/553 is
                 // fixed.
@@ -334,6 +334,18 @@ impl rpc::Server for CubebServer {
     }
 }
 
+// Debugging for BMO 1594216/1612044.
+macro_rules! try_stream {
+    ($self:expr, $stm_tok:expr) => {
+        if $self.streams.contains($stm_tok) {
+            &mut $self.streams[$stm_tok]
+        } else {
+            error!("{}:{}:{} - Stream({}): invalid token", file!(), line!(), column!(), $stm_tok);
+            return error(cubeb::Error::invalid_parameter());
+        }
+    };
+}
+
 impl CubebServer {
     pub fn new(handle: current_thread::Handle) -> Self {
         CubebServer {
@@ -407,54 +419,60 @@ impl CubebServer {
                 .unwrap_or_else(|_| error(cubeb::Error::error())),
 
             ServerMessage::StreamDestroy(stm_tok) => {
+                if self.streams.contains(stm_tok) {
+                    debug!("Unregistering stream {:?}", stm_tok);
                     self.streams.remove(stm_tok);
+                } else {
+                    // Debugging for BMO 1594216/1612044.
+                    error!("StreamDestroy({}): invalid token", stm_tok);
+                    return error(cubeb::Error::invalid_parameter());
+                }
                 ClientMessage::StreamDestroyed
             }
 
-            ServerMessage::StreamStart(stm_tok) => self.streams[stm_tok]
+            ServerMessage::StreamStart(stm_tok) => try_stream!(self, stm_tok)
                 .stream
                 .start()
                 .map(|_| ClientMessage::StreamStarted)
                 .unwrap_or_else(error),
 
-            ServerMessage::StreamStop(stm_tok) => self.streams[stm_tok]
+            ServerMessage::StreamStop(stm_tok) => try_stream!(self, stm_tok)
                 .stream
                 .stop()
                 .map(|_| ClientMessage::StreamStopped)
                 .unwrap_or_else(error),
 
-            ServerMessage::StreamResetDefaultDevice(stm_tok) => self.streams[stm_tok]
+            ServerMessage::StreamResetDefaultDevice(stm_tok) => try_stream!(self, stm_tok)
                 .stream
                 .reset_default_device()
                 .map(|_| ClientMessage::StreamDefaultDeviceReset)
                 .unwrap_or_else(error),
 
-            ServerMessage::StreamGetPosition(stm_tok) => self.streams[stm_tok]
+            ServerMessage::StreamGetPosition(stm_tok) => try_stream!(self, stm_tok)
                 .stream
                 .position()
                 .map(ClientMessage::StreamPosition)
                 .unwrap_or_else(error),
 
-            ServerMessage::StreamGetLatency(stm_tok) => self.streams[stm_tok]
+            ServerMessage::StreamGetLatency(stm_tok) => try_stream!(self, stm_tok)
                 .stream
                 .latency()
                 .map(ClientMessage::StreamLatency)
                 .unwrap_or_else(error),
 
-            ServerMessage::StreamSetVolume(stm_tok, volume) => self.streams[stm_tok]
+            ServerMessage::StreamSetVolume(stm_tok, volume) => try_stream!(self, stm_tok)
                 .stream
                 .set_volume(volume)
                 .map(|_| ClientMessage::StreamVolumeSet)
                 .unwrap_or_else(error),
 
-            ServerMessage::StreamGetCurrentDevice(stm_tok) => self.streams[stm_tok]
+            ServerMessage::StreamGetCurrentDevice(stm_tok) => try_stream!(self, stm_tok)
                 .stream
                 .current_device()
                 .map(|device| ClientMessage::StreamCurrentDevice(Device::from(device)))
                 .unwrap_or_else(error),
 
-            ServerMessage::StreamRegisterDeviceChangeCallback(stm_tok, enable) => self.streams
-                [stm_tok]
+            ServerMessage::StreamRegisterDeviceChangeCallback(stm_tok, enable) => try_stream!(self, stm_tok)
                 .stream
                 .register_device_changed_callback(if enable {
                     Some(device_change_cb_c)