Bug 1530715 - P22: Replace device_changed_callback_lock by standard Rust mutex. r=padenot

The registration, unregistration, and notification for the device
property changed is done in a critical section created by locking our
own custom mutex. To replace our own custom mutex by standard Rust
mutex, the critical section should be created by locking a standard Rust
mutex. This can be done by simply merging device_changed_callback and
device_changed_callback_lock into a Rust mutex variable.

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

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

media/libcubeb/cubeb-coreaudio-rs/README_MOZILLA

@@ -3,4 +3,4 @@ git repository using the update.sh script.
 
 The cubeb-coreaudio-rs git repository is: https://github.com/ChunMinChang/cubeb-coreaudio-rs
 
-The git commit ID used was 3c14e6a17f8b931950941326eecc8a1132f13cae (2019-06-21 15:51:40 -0700)
+The git commit ID used was 3608c1dfc46466df5de8f03eca148f16a5dcd732 (2019-06-21 15:51:40 -0700)

media/libcubeb/cubeb-coreaudio-rs/src/backend/mod.rs

@@ -735,8 +735,8 @@ extern "C" fn audiounit_property_listener_callback(
     }
 
     for _addr in addrs.iter() {
-        let _dev_cb_lock = AutoLock::new(&mut stm.device_changed_callback_lock);
-        if let Some(device_changed_callback) = stm.device_changed_callback {
+        let callback = stm.device_changed_callback.lock().unwrap();
+        if let Some(device_changed_callback) = *callback {
             unsafe {
                 device_changed_callback(stm.user_ptr);
             }
@@ -2923,8 +2923,7 @@ struct AudioUnitStream<'ctx> {
 
     data_callback: ffi::cubeb_data_callback,
     state_callback: ffi::cubeb_state_callback,
-    device_changed_callback: ffi::cubeb_device_changed_callback,
-    device_changed_callback_lock: OwnedCriticalSection,
+    device_changed_callback: Mutex<ffi::cubeb_device_changed_callback>,
     // Stream creation parameters
     input_stream_params: StreamParams,
     output_stream_params: StreamParams,
@@ -2991,8 +2990,7 @@ impl<'ctx> AudioUnitStream<'ctx> {
             user_ptr,
             data_callback,
             state_callback,
-            device_changed_callback: None,
-            device_changed_callback_lock: OwnedCriticalSection::new(),
+            device_changed_callback: Mutex::new(None),
             input_stream_params: StreamParams::from(ffi::cubeb_stream_params {
                 format: ffi::CUBEB_SAMPLE_FLOAT32NE,
                 rate: 0,
@@ -3044,7 +3042,6 @@ impl<'ctx> AudioUnitStream<'ctx> {
     }
 
     fn init_mutex(&mut self) {
-        self.device_changed_callback_lock.init();
         self.mutex.init();
     }
 
@@ -4371,11 +4368,11 @@ impl<'ctx> StreamOps for AudioUnitStream<'ctx> {
         &mut self,
         device_changed_callback: ffi::cubeb_device_changed_callback,
     ) -> Result<()> {
-        let _dev_cb_lock = AutoLock::new(&mut self.device_changed_callback_lock);
+        let mut callback = self.device_changed_callback.lock().unwrap();
         // Note: second register without unregister first causes 'nope' error.
         // Current implementation requires unregister before register a new cb.
-        assert!(device_changed_callback.is_none() || self.device_changed_callback.is_none());
-        self.device_changed_callback = device_changed_callback;
+        assert!(device_changed_callback.is_none() || callback.is_none());
+        *callback = device_changed_callback;
         Ok(())
     }
 }