desktop: Properly shutdown the tokio runtime before exiting the winit event loop

Fixes issue #22308.

Author: moulins

desktop/src/app.rs

@@ -388,16 +388,23 @@ impl MainWindow {
 
 pub struct App {
     main_window: Option<MainWindow>,
+    runtime: Option<tokio::runtime::Runtime>,
     gilrs: Option<Gilrs>,
     event_loop_proxy: EventLoopProxy<RuffleEvent>,
     preferences: GlobalPreferences,
     font_database: fontdb::Database,
 }
 
+/// Enters the tokio runtime context.
+/// This cannot be a method, as the borrow-checker would complain.
+macro_rules! enter_runtime {
+    ($this:expr) => {
+        let _guard = $this.runtime.as_ref().map(|runtime| runtime.enter());
+    };
+}
+
 impl App {
-    pub async fn new(
-        preferences: GlobalPreferences,
-    ) -> Result<(Self, EventLoop<RuffleEvent>), Error> {
+    pub fn new(preferences: GlobalPreferences) -> Result<(Self, EventLoop<RuffleEvent>), Error> {
         let event_loop = EventLoop::with_user_event().build()?;
 
         let mut font_database = fontdb::Database::default();
@@ -409,10 +416,12 @@ impl App {
             })
             .ok();
         let event_loop_proxy = event_loop.create_proxy();
+        let runtime = tokio::runtime::Runtime::new()?;
 
         Ok((
             Self {
                 main_window: None,
+                runtime: Some(runtime),
                 gilrs,
                 event_loop_proxy,
                 font_database,
@@ -425,6 +434,8 @@ impl App {
 
 impl ApplicationHandler<RuffleEvent> for App {
     fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        enter_runtime!(self);
+
         if cause == StartCause::Init {
             let movie_url = self.preferences.cli.movie_url.clone();
             let icon_bytes = include_bytes!("../assets/favicon-32.rgba");
@@ -533,6 +544,8 @@ impl ApplicationHandler<RuffleEvent> for App {
     fn resumed(&mut self, _event_loop: &ActiveEventLoop) {}
 
     fn user_event(&mut self, event_loop: &ActiveEventLoop, event: RuffleEvent) {
+        enter_runtime!(self);
+
         match (&mut self.main_window, event) {
             (Some(main_window), RuffleEvent::TaskPoll(task)) => main_window.player.poll(task),
 
@@ -636,12 +649,16 @@ impl ApplicationHandler<RuffleEvent> for App {
         _window_id: WindowId,
         event: WindowEvent,
     ) {
+        enter_runtime!(self);
+
         if let Some(main_window) = &mut self.main_window {
             main_window.window_event(event_loop, event);
         }
     }
 
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        enter_runtime!(self);
+
         if let Some(main_window) = &mut self.main_window {
             main_window.about_to_wait(self.gilrs.as_mut());
 
@@ -655,6 +672,21 @@ impl ApplicationHandler<RuffleEvent> for App {
             }
         }
     }
+
+    fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
+        // `MainWindow` needs a tokio context to properly drop.
+        {
+            enter_runtime!(self);
+            let _ = self.main_window.take();
+        }
+
+        // Manually stop the tokio runtime: this makes sure that any pending Player-bound futures
+        // are properly cancelled and put back on the winit event loop before it closes, preventing
+        // them from being dropped on the wrong thread and causing a panic.
+        if let Some(runtime) = self.runtime.take() {
+            runtime.shutdown_timeout(std::time::Duration::from_secs(1));
+        }
+    }
 }
 
 enum LoadingState {

desktop/src/main.rs

@@ -151,8 +151,7 @@ fn shutdown() {
     }
 }
 
-#[tokio::main]
-async fn main() -> Result<(), Error> {
+fn main() -> Result<(), Error> {
     init();
 
     let opt = Opt::parse();
@@ -191,11 +190,9 @@ async fn main() -> Result<(), Error> {
 
     subscriber.init();
 
-    let result = App::new(preferences)
-        .await
-        .and_then(|(mut app, event_loop)| {
-            event_loop.run_app(&mut app).context("Event loop failure")
-        });
+    let result = App::new(preferences).and_then(|(mut app, event_loop)| {
+        event_loop.run_app(&mut app).context("Event loop failure")
+    });
 
     #[cfg(windows)]
     if let Err(error) = &result {