On Web, Window now implements Send + Sync

Author: daxpedda

CHANGELOG.md

@@ -11,7 +11,8 @@ And please only add new entries to the top of this list, right below the `# Unre
 - Bump MSRV from `1.60` to `1.64`.
 - Fix macOS memory leaks.
 - On Web: fix `Window::request_redraw` not waking the event loop when called from outside the loop.
-- On Web, `EventLoopProxy` now implements `Send`.
+- On Web, `EventLoopProxy` now implements `Send` and `Sync`.
+- On Web, `Window` now implements `Send` and `Sync`.
 
 # 0.28.2
 

Cargo.toml

@@ -149,6 +149,8 @@ features = [
 ]
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
+atomic-waker = "1.1.0"
+js-sys = "0.3.22"
 wasm-bindgen = "0.2.45"
 wasm-bindgen-futures = "0.4.31"
 

clippy.toml

@@ -0,0 +1,3 @@
+disallowed-methods = [
+    { path = "web_sys::window", reason = "is not available in every context" },
+]

examples/web.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::single_match)]
+#![allow(clippy::disallowed_methods, clippy::single_match)]
 
 use winit::{
     event::{Event, WindowEvent},
@@ -52,7 +52,7 @@ mod wasm {
     pub fn insert_canvas_and_create_log_list(window: &Window) -> web_sys::Element {
         use winit::platform::web::WindowExtWebSys;
 
-        let canvas = window.canvas();
+        let canvas = window.canvas().unwrap();
 
         let window = web_sys::window().unwrap();
         let document = window.document().unwrap();

examples/web_aspect_ratio.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::disallowed_methods)]
+
 pub fn main() {
     println!("This example must be run with cargo run-wasm --example web_aspect_ratio")
 }
@@ -66,7 +68,7 @@ This example demonstrates the desired future functionality which will possibly b
         let body = document.body().unwrap();
 
         // Set a background color for the canvas to make it easier to tell the where the canvas is for debugging purposes.
-        let canvas = window.canvas();
+        let canvas = window.canvas().unwrap();
         canvas
             .style()
             .set_css_text("display: block; background-color: crimson; margin: auto; width: 50%; aspect-ratio: 4 / 1;");

src/platform/web.rs

@@ -12,7 +12,8 @@ use crate::window::WindowBuilder;
 use web_sys::HtmlCanvasElement;
 
 pub trait WindowExtWebSys {
-    fn canvas(&self) -> HtmlCanvasElement;
+    /// Only returns the canvas if called from inside the window.
+    fn canvas(&self) -> Option<HtmlCanvasElement>;
 
     /// Whether the browser reports the preferred color scheme to be "dark".
     fn is_dark_mode(&self) -> bool;

src/platform_impl/web/async.rs

@@ -0,0 +1,266 @@
+use atomic_waker::AtomicWaker;
+use once_cell::unsync::Lazy;
+use std::cell::{Ref, RefCell, RefMut};
+use std::future;
+use std::mem::ManuallyDrop;
+use std::ops::{Deref, DerefMut};
+use std::rc::{Rc, Weak};
+use std::sync::mpsc::{self, Receiver, RecvError, SendError, Sender, TryRecvError};
+use std::sync::{Arc, Condvar, Mutex};
+use std::task::Poll;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsCast, JsValue};
+
+// Unsafe wrapper type that allows us to use `T` when it's not `Send` from other threads.
+// `value` must *only* be accessed on the main thread.
+pub struct MainThreadSafe<T: 'static, E: 'static> {
+    value: ManuallyDrop<Weak<RefCell<T>>>,
+    handler: fn(&RefCell<T>, E),
+    sender: AsyncSender<E>,
+}
+
+impl<T, E> MainThreadSafe<T, E> {
+    thread_local! {
+        static MAIN_THREAD: Lazy<bool> = Lazy::new(|| {
+            #[wasm_bindgen]
+            extern "C" {
+                #[derive(Clone)]
+                pub(crate) type Global;
+
+                #[wasm_bindgen(method, getter, js_name = Window)]
+                fn window(this: &Global) -> JsValue;
+            }
+
+            let global: Global = js_sys::global().unchecked_into();
+            !global.window().is_undefined()
+        });
+    }
+
+    #[track_caller]
+    pub fn new(value: T, handler: fn(&RefCell<T>, E)) -> Option<Self> {
+        Self::MAIN_THREAD.with(|safe| {
+            if !*safe.deref() {
+                panic!("only callable from inside the `Window`")
+            }
+        });
+
+        let value = Rc::new(RefCell::new(value));
+        let weak = Rc::downgrade(&value);
+
+        let (sender, receiver) = channel::<E>();
+
+        wasm_bindgen_futures::spawn_local({
+            async move {
+                while let Ok(event) = receiver.next().await {
+                    handler(&value, event)
+                }
+
+                // An error was returned because the channel was closed, which
+                // happens when the window get dropped, so we can stop now.
+                match Rc::try_unwrap(value) {
+                    Ok(value) => drop(value),
+                    Err(_) => panic!("couldn't enforce that value is dropped on the main thread"),
+                }
+            }
+        });
+
+        Some(Self {
+            value: ManuallyDrop::new(weak),
+            handler,
+            sender,
+        })
+    }
+
+    pub fn send(&self, event: E) -> Result<(), SendError<E>> {
+        Self::MAIN_THREAD.with(|is_main_thread| {
+            if *is_main_thread.deref() {
+                (self.handler)(&self.value.upgrade().unwrap(), event);
+                Ok(())
+            } else {
+                self.sender.send(event)
+            }
+        })
+    }
+
+    fn is_main_thread(&self) -> bool {
+        Self::MAIN_THREAD.with(|is_main_thread| *is_main_thread.deref())
+    }
+
+    pub fn with<R>(&self, f: impl FnOnce(Ref<'_, T>) -> R) -> Option<R> {
+        Self::MAIN_THREAD.with(|is_main_thread| {
+            if *is_main_thread.deref() {
+                Some(f(self.value.upgrade().unwrap().borrow()))
+            } else {
+                None
+            }
+        })
+    }
+
+    fn with_mut<R>(&self, f: impl FnOnce(RefMut<'_, T>) -> R) -> Option<R> {
+        Self::MAIN_THREAD.with(|is_main_thread| {
+            if *is_main_thread.deref() {
+                Some(f(self.value.upgrade().unwrap().borrow_mut()))
+            } else {
+                None
+            }
+        })
+    }
+}
+
+impl<T, E> Clone for MainThreadSafe<T, E> {
+    fn clone(&self) -> Self {
+        Self {
+            value: self.value.clone(),
+            handler: self.handler,
+            sender: self.sender.clone(),
+        }
+    }
+}
+
+unsafe impl<T, E> Send for MainThreadSafe<T, E> {}
+unsafe impl<T, E> Sync for MainThreadSafe<T, E> {}
+
+pub struct Dispatcher<T: 'static>(MainThreadSafe<T, Closure<T>>);
+
+pub enum Closure<T> {
+    Ref(Box<dyn FnOnce(&T) + Send>),
+    RefMut(Box<dyn FnOnce(&mut T) + Send>),
+}
+
+impl<T> Dispatcher<T> {
+    #[track_caller]
+    pub fn new(value: T) -> Option<Self> {
+        MainThreadSafe::new(value, |value, closure| {
+            match closure {
+                Closure::Ref(f) => f(value.borrow().deref()),
+                Closure::RefMut(f) => f(value.borrow_mut().deref_mut()),
+            }
+
+            // An error was returned because the channel was closed, which
+            // happens when the window get dropped, so we can stop now.
+        })
+        .map(Self)
+    }
+
+    pub fn dispatch(&self, f: impl 'static + FnOnce(&T) + Send) -> Result<(), SendError<()>> {
+        if self.is_main_thread() {
+            self.0.with(|value| f(value.deref())).unwrap();
+            Ok(())
+        } else {
+            self.0
+                .send(Closure::Ref(Box::new(f)))
+                .map_err(|_| SendError(()))
+        }
+    }
+
+    pub fn dispatch_mut(
+        &self,
+        f: impl 'static + FnOnce(&mut T) + Send,
+    ) -> Result<(), SendError<()>> {
+        if self.is_main_thread() {
+            self.0.with_mut(|mut value| f(value.deref_mut())).unwrap();
+            Ok(())
+        } else {
+            self.0
+                .send(Closure::RefMut(Box::new(f)))
+                .map_err(|_| SendError(()))
+        }
+    }
+
+    pub fn queue<R: 'static + Send>(
+        &self,
+        f: impl 'static + FnOnce(&T) -> R + Send,
+    ) -> Result<R, SendError<()>> {
+        if self.is_main_thread() {
+            Ok(self.0.with(|value| f(value.deref())).unwrap())
+        } else {
+            let pair = Arc::new((Mutex::new(None), Condvar::new()));
+            let closure = Closure::Ref(Box::new({
+                let pair = pair.clone();
+                move |value| {
+                    *pair.0.lock().unwrap() = Some(f(value));
+                    pair.1.notify_one();
+                }
+            }));
+
+            self.0.send(closure).map_err(|_| SendError(()))?;
+
+            let mut started = pair.0.lock().unwrap();
+
+            while started.is_none() {
+                started = pair.1.wait(started).unwrap();
+            }
+
+            Ok(started.take().unwrap())
+        }
+    }
+}
+
+impl<T> Deref for Dispatcher<T> {
+    type Target = MainThreadSafe<T, Closure<T>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+fn channel<T: 'static>() -> (AsyncSender<T>, AsyncReceiver<T>) {
+    let (sender, receiver) = mpsc::channel();
+    let sender = Mutex::new(sender);
+    let waker = Arc::new(AtomicWaker::new());
+
+    let sender = AsyncSender {
+        sender,
+        waker: Arc::clone(&waker),
+    };
+    let receiver = AsyncReceiver { receiver, waker };
+
+    (sender, receiver)
+}
+
+struct AsyncSender<T: 'static> {
+    sender: Mutex<Sender<T>>,
+    waker: Arc<AtomicWaker>,
+}
+
+impl<T: 'static> AsyncSender<T> {
+    pub fn send(&self, event: T) -> Result<(), SendError<T>> {
+        self.sender.lock().unwrap().send(event)?;
+        self.waker.wake();
+
+        Ok(())
+    }
+}
+
+impl<T: 'static> Clone for AsyncSender<T> {
+    fn clone(&self) -> Self {
+        Self {
+            sender: Mutex::new(self.sender.lock().unwrap().clone()),
+            waker: self.waker.clone(),
+        }
+    }
+}
+
+struct AsyncReceiver<T: 'static> {
+    receiver: Receiver<T>,
+    waker: Arc<AtomicWaker>,
+}
+
+impl<T: 'static> AsyncReceiver<T> {
+    pub async fn next(&self) -> Result<T, RecvError> {
+        future::poll_fn(|cx| match self.receiver.try_recv() {
+            Ok(event) => Poll::Ready(Ok(event)),
+            Err(TryRecvError::Empty) => {
+                self.waker.register(cx.waker());
+
+                match self.receiver.try_recv() {
+                    Ok(event) => Poll::Ready(Ok(event)),
+                    Err(TryRecvError::Empty) => Poll::Pending,
+                    Err(TryRecvError::Disconnected) => Poll::Ready(Err(RecvError)),
+                }
+            }
+            Err(TryRecvError::Disconnected) => Poll::Ready(Err(RecvError)),
+        })
+        .await
+    }
+}