desktop: Use async-task crate to manage Player-created futures

Instead of manually (and unsafely!) fiddling with `Waker` vtables and
implementing our own task "allocator" (a.k.a. the `SlotMap` in `AsyncExecutor`),
rip everything out and use heap-allocated `PlayerRunnable = async_task::Runnable`s
instead.

`async-task` takes care of all the nitty-gritty and provides an API we can directly
plug into the `winit` event loop.

Notes:
- This removes the internal queue of to-be-polled tasks; instead, `PlayerRunnable`s get
  pushed as individual winit events directly on the main event loop.
- To prevent polling tasks belonging to stale players, we tag each task with a `PlayerId`
  uniquely identifying each `Player` instance, and only poll the task if its ID matches
  the active `Player`.

Author: moulins

Cargo.lock

@@ -24,7 +24,7 @@ ruffle_render = { path = "../render", features = ["clap"] }
 ruffle_render_wgpu = { path = "../render/wgpu", features = ["clap"] }
 ruffle_video_software = { path = "../video/software", optional = true }
 ruffle_video_external = { path = "../video/external", features = ["openh264"], optional = true }
-ruffle_frontend_utils = { path = "../frontend-utils", features = ["cpal", "fs", "navigator", "executor"] }
+ruffle_frontend_utils = { path = "../frontend-utils", features = ["cpal", "fs", "navigator"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 tracing-appender = "0.2.3"
@@ -54,6 +54,7 @@ unicode-bidi = "0.3.18"
 fontconfig = { version = "0.10.0", optional = true, features = ["dlopen"]}
 memmap2.workspace = true
 walkdir.workspace = true
+async-task = "4.7.1"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 ashpd = "0.11.0"

desktop/Cargo.toml

@@ -534,7 +534,7 @@ impl ApplicationHandler<RuffleEvent> for App {
 
     fn user_event(&mut self, event_loop: &ActiveEventLoop, event: RuffleEvent) {
         match (&mut self.main_window, event) {
-            (Some(main_window), RuffleEvent::TaskPoll) => main_window.player.poll(),
+            (Some(main_window), RuffleEvent::TaskPoll(task)) => main_window.player.poll(task),
 
             (Some(main_window), RuffleEvent::OnMetadata(swf_header)) => {
                 main_window.on_metadata(swf_header)

desktop/src/app.rs

@@ -2,12 +2,13 @@
 
 use ruffle_core::events::PlayerNotification;
 
-use crate::{gui::DialogDescriptor, player::LaunchOptions};
+use crate::gui::DialogDescriptor;
+use crate::player::{LaunchOptions, PlayerRunnable};
 
 /// User-defined events.
 pub enum RuffleEvent {
-    /// Indicates that one or more tasks are ready to poll on our executor.
-    TaskPoll,
+    /// Indicates that a task is ready to be polled.
+    TaskPoll(PlayerRunnable),
 
     /// Indicates that an asynchronous SWF metadata load has been completed.
     OnMetadata(ruffle_core::swf::HeaderExt),

desktop/src/custom_event.rs

@@ -9,13 +9,12 @@ use crate::gui::{FilePicker, MovieView};
 use crate::preferences::GlobalPreferences;
 use crate::{CALLSTACK, RENDER_INFO, SWF_INFO};
 use anyhow::anyhow;
-use ruffle_core::backend::navigator::SocketMode;
+use ruffle_core::backend::navigator::{OwnedFuture, SocketMode};
 use ruffle_core::config::Letterbox;
 use ruffle_core::events::{GamepadButton, KeyCode};
 use ruffle_core::{DefaultFont, LoadBehavior, Player, PlayerBuilder, PlayerEvent};
 use ruffle_frontend_utils::backends::audio::CpalAudioBackend;
-use ruffle_frontend_utils::backends::executor::{AsyncExecutor, PollRequester};
-use ruffle_frontend_utils::backends::navigator::ExternalNavigatorBackend;
+use ruffle_frontend_utils::backends::navigator::{ExternalNavigatorBackend, FutureSpawner};
 use ruffle_frontend_utils::bundle::source::BundleSourceError;
 use ruffle_frontend_utils::bundle::{Bundle, BundleError};
 use ruffle_frontend_utils::content::PlayingContent;
@@ -105,22 +104,11 @@ impl From<&GlobalPreferences> for LaunchOptions {
     }
 }
 
-#[derive(Clone)]
-struct WinitWaker(EventLoopProxy<RuffleEvent>);
-
-impl PollRequester for WinitWaker {
-    fn request_poll(&self) {
-        if self.0.send_event(RuffleEvent::TaskPoll).is_err() {
-            tracing::error!("Couldn't request poll - event loop is closed");
-        }
-    }
-}
-
 /// Represents a current Player and any associated state with that player,
 /// which may be lost when this Player is closed (dropped)
 struct ActivePlayer {
+    id: PlayerId,
     player: Arc<Mutex<Player>>,
-    executor: Arc<AsyncExecutor<WinitWaker>>,
 
     #[cfg(target_os = "linux")]
     _gamemode_session: crate::dbus::GameModeSession,
@@ -139,6 +127,7 @@ impl ActivePlayer {
         preferences: GlobalPreferences,
         file_picker: FilePicker,
     ) -> Self {
+        let player_id = PlayerId::new();
         let mut builder = PlayerBuilder::new();
 
         match CpalAudioBackend::new(preferences.output_device_name().as_deref()) {
@@ -211,7 +200,10 @@ impl ActivePlayer {
             }
         };
 
-        let (executor, future_spawner) = AsyncExecutor::new(WinitWaker(event_loop.clone()));
+        let future_spawner = WinitExecutor {
+            event_loop: event_loop.clone(),
+            player_id,
+        };
         let movie_url = content.initial_swf_url().clone();
         let readable_name = content.name();
         let navigator = ExternalNavigatorBackend::new(
@@ -419,8 +411,8 @@ impl ActivePlayer {
         }
 
         Self {
+            id: player_id,
             player,
-            executor,
             #[cfg(target_os = "linux")]
             _gamemode_session: crate::dbus::GameModeSession::new(gamemode_enable),
         }
@@ -500,9 +492,67 @@ impl PlayerController {
         false
     }
 
-    pub fn poll(&self) {
-        if let Some(player) = &self.player {
-            player.executor.poll_all()
+    pub fn poll(&self, task: PlayerRunnable) {
+        // Only run the task if it matches our current player;
+        // otherwise it is stale, and should be cancelled (which
+        // happens implicitly on drop).
+        if let Some(player) = &self.player
+            && *task.0.metadata() == player.id
+        {
+            task.0.run();
         }
     }
 }
+
+/// A unique identifier for a given `Player` instance.
+/// Used to track which player any currently executing future is bound to.
+#[derive(Copy, Clone, Eq, PartialEq)]
+struct PlayerId(i64);
+
+impl PlayerId {
+    fn new() -> Self {
+        use std::sync::atomic::{AtomicI64, Ordering};
+
+        static NEXT: AtomicI64 = AtomicI64::new(0);
+        let id = NEXT.fetch_add(1, Ordering::Relaxed);
+        assert!(id >= 0, "PlayerId overflowed!");
+        Self(id)
+    }
+}
+
+/// A `Player`-bound future that is currently running.
+pub struct PlayerRunnable(async_task::Runnable<PlayerId>);
+
+/// A bare-bones executor that schedules tasks on the winit event loop.
+struct WinitExecutor {
+    event_loop: EventLoopProxy<RuffleEvent>,
+    player_id: PlayerId,
+}
+
+impl<E: std::error::Error + 'static> FutureSpawner<E> for WinitExecutor {
+    fn spawn(&self, future: OwnedFuture<(), E>) {
+        // Discard any errors.
+        let future = async {
+            if let Err(e) = future.await {
+                tracing::error!("Async error: {}", e);
+            }
+        };
+
+        let event_loop = self.event_loop.clone();
+        let scheduler = move |task| {
+            let event = RuffleEvent::TaskPoll(PlayerRunnable(task));
+            if event_loop.send_event(event).is_err() {
+                tracing::error!("Couldn't schedule task - event loop is closed");
+            }
+        };
+
+        let (runnable, task) = async_task::Builder::new()
+            .metadata(self.player_id)
+            .spawn_local(|_| future, scheduler);
+
+        // The future should run in the background.
+        task.detach();
+        // Immediately schedule the future to be polled for the first time.
+        runnable.schedule();
+    }
+}

desktop/src/player.rs

@@ -14,7 +14,6 @@ workspace = true
 cpal = ["dep:cpal", "dep:bytemuck", "ruffle_core/audio"]
 fs = []
 navigator = ["fs", "dep:async-io", "dep:tokio"]
-executor = ["dep:tokio"]
 
 [dependencies]
 toml_edit = { version = "0.23.6", features = ["parse"] }
@@ -26,7 +25,6 @@ urlencoding = "2.1.3"
 ruffle_core = { path = "../core", default-features = false }
 ruffle_render = { path = "../render", default-features = false }
 async-channel = { workspace = true }
-slotmap = { workspace = true }
 async-io = { version = "2.6.0", optional = true }
 futures-lite = "2.6.1"
 reqwest = { version = "0.12.24", default-features = false, features = [

frontend-utils/Cargo.toml

@@ -1,7 +1,5 @@
 #[cfg(feature = "cpal")]
 pub mod audio;
-#[cfg(feature = "executor")]
-pub mod executor;
 #[cfg(feature = "navigator")]
 pub mod navigator;
 #[cfg(feature = "fs")]