Ensure AudioContext close_sync blocks control thread until completed

Author: orottier

src/context/online.rs

@@ -274,7 +274,7 @@ impl AudioContext {
         } else {
             // Acquire the audio graph from the current render thread, shutting it down
             let (graph_send, graph_recv) = crossbeam_channel::bounded(1);
-            let message = ControlMessage::Shutdown { sender: graph_send };
+            let message = ControlMessage::CloseAndRecycle { sender: graph_send };
             ctrl_msg_send.send(message).unwrap();
             if original_state == AudioContextState::Suspended {
                 // We must wake up the render thread to be able to handle the shutdown.
@@ -442,8 +442,23 @@ impl AudioContext {
     /// Will panic when this function is called multiple times
     #[allow(clippy::missing_const_for_fn, clippy::unused_self)]
     pub fn close_sync(&self) {
+        // First, stop rendering via a control message
+        let (sender, receiver) = crossbeam_channel::bounded(0);
+        let notify = OneshotNotify::Sync(sender);
+        let suspend_msg = ControlMessage::Close { notify };
+        self.base.send_control_msg(suspend_msg);
+
+        // Wait for the render thread to have processed the suspend message.
+        // The AudioContextState will be updated by the render thread.
+        receiver.recv().ok();
+
+        // Then ask the audio host to close the stream
         self.backend_manager.lock().unwrap().close();
+
+        // Stop the AudioRenderCapacity collection thread
         self.render_capacity.stop();
+
+        // TODO stop the event loop <https://github.com/orottier/web-audio-api-rs/issues/421>
     }
 
     /// Creates a [`MediaStreamAudioSourceNode`](node::MediaStreamAudioSourceNode) from a

src/message.rs

@@ -40,7 +40,7 @@ pub(crate) enum ControlMessage {
     MarkCycleBreaker { id: AudioNodeId },
 
     /// Shut down and recycle the audio graph
-    Shutdown {
+    CloseAndRecycle {
         sender: crossbeam_channel::Sender<Graph>,
     },
 
@@ -53,6 +53,9 @@ pub(crate) enum ControlMessage {
     /// Resume audio processing after suspending
     Resume { notify: OneshotNotify },
 
+    /// Stop audio processing
+    Close { notify: OneshotNotify },
+
     /// Generic message to be handled by AudioProcessor
     NodeMessage {
         id: AudioNodeId,

src/render/thread.rs

@@ -156,7 +156,7 @@ impl RenderThread {
                 MarkCycleBreaker { id } => {
                     self.graph.as_mut().unwrap().mark_cycle_breaker(id);
                 }
-                Shutdown { sender } => {
+                CloseAndRecycle { sender } => {
                     self.set_state(AudioContextState::Suspended);
                     let _ = sender.send(self.graph.take().unwrap());
                     self.receiver = None;
@@ -193,6 +193,11 @@ impl RenderThread {
                     self.set_state(AudioContextState::Running);
                     notify.send();
                 }
+                Close { notify } => {
+                    self.suspended = true;
+                    self.set_state(AudioContextState::Closed);
+                    notify.send();
+                }
             }
         }
     }
@@ -445,12 +450,6 @@ impl RenderThread {
 
 impl Drop for RenderThread {
     fn drop(&mut self) {
-        // If the audio graph is still there, this is an actual shutdown.
-        // When the graph is None, this means we are only changing the sink - not shutting down.
-        if self.graph.is_some() {
-            self.set_state(AudioContextState::Closed);
-        }
-
         if let Some(gc) = self.garbage_collector.as_mut() {
             gc.push(llq::Node::new(Box::new(TerminateGarbageCollectorThread)))
         }

tests/online.rs

@@ -114,9 +114,6 @@ fn test_none_sink_id() {
     assert_eq!(state_changes.load(Ordering::Relaxed), 3); // resumed
 
     context.close_sync();
-
-    // give event thread some time to pick up events
-    std::thread::sleep(std::time::Duration::from_millis(20));
     assert_eq!(context.state(), AudioContextState::Closed);
     assert!(sink_stable.load(Ordering::SeqCst));
     assert_eq!(state_changes.load(Ordering::Relaxed), 4); // closed