Support for wasm32-unknown-unknown

Cargo.toml

@@ -14,6 +14,13 @@ Timeouts for futures.
 
 [dependencies]
 
+[target.wasm32-unknown-unknown.dependencies]
+instant = { version = "0.1.2", features = ["wasm-bindgen"] }
+wasm-bindgen = "0.2.55"
+futures = "0.3.1"
+web-sys = "0.3.32"
+parking_lot = "0.10.0"
+
 [dev-dependencies]
 async-std = { version = "1.0.1", features = ["attributes"] }
 futures = "0.3.1"

src/delay.rs

@@ -3,14 +3,15 @@
 //! This module contains the `Delay` type which is a future that will resolve
 //! at a particular point in the future.
 
+use crate::Instant;
 use std::fmt;
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;
 use std::sync::{Arc, Mutex};
 use std::task::{Context, Poll};
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 use crate::arc_list::Node;
 use crate::AtomicWaker;

src/global.rs → src/global_native.rs

@@ -1,3 +1,4 @@
+use crate::Instant;
 use std::future::Future;
 use std::io;
 use std::mem::{self, ManuallyDrop};
@@ -7,7 +8,6 @@ use std::sync::Arc;
 use std::task::{Context, RawWaker, RawWakerVTable, Waker};
 use std::thread;
 use std::thread::Thread;
-use std::time::Instant;
 
 use crate::{Timer, TimerHandle};
 

src/global_wasm.rs

@@ -0,0 +1,82 @@
+use futures::task::{self, ArcWake};
+use parking_lot::Mutex;
+use std::convert::TryFrom;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::Context;
+use std::time::Duration;
+use wasm_bindgen::{closure::Closure, JsCast};
+
+use crate::{Instant, Timer, TimerHandle};
+
+/// Starts a background task, creates a `Timer`, and returns a handle to it.
+///
+/// > **Note**: Contrary to the native implementation, we don't have
+/// >           any `forget()` method, as the task is automatically considered
+/// >           as "forgotten".
+pub(crate) fn run() -> TimerHandle {
+    let timer = Timer::new();
+    let handle = timer.handle();
+    schedule_callback(Arc::new(Mutex::new(timer)), Duration::new(0, 0));
+    handle
+}
+
+/// Calls `Window::setTimeout` with the given `Duration`. The callback wakes up the timer and
+/// processes everything.
+fn schedule_callback(timer: Arc<Mutex<Timer>>, when: Duration) {
+    let window = web_sys::window().expect("Unable to access Window");
+    let _ = window
+        .set_timeout_with_callback_and_timeout_and_arguments_0(
+            &Closure::once_into_js(move || {
+                let mut timer_lock = timer.lock();
+
+                // We start by polling the timer. If any new `Delay` is created, the waker will be used
+                // to wake up this task pre-emptively. As such, we pass a `Waker` that calls
+                // `schedule_callback` with a delay of `0`.
+                let waker = task::waker(Arc::new(Waker {
+                    timer: timer.clone(),
+                }));
+                let _ = Future::poll(Pin::new(&mut *timer_lock), &mut Context::from_waker(&waker));
+
+                // Notify the timers that are ready.
+                let now = Instant::now();
+                timer_lock.advance_to(now);
+
+                // Each call to `schedule_callback` calls `schedule_callback` again, but also leaves
+                // the possibility for `schedule_callback` to be called in parallel. Since we don't
+                // want too many useless callbacks, we...
+                // TODO: ugh, that's a hack
+                if Arc::strong_count(&timer) > 20 {
+                    return;
+                }
+
+                // We call `schedule_callback` again for the next event.
+                let sleep_dur = timer_lock
+                    .next_event()
+                    .map(|next_event| {
+                        if next_event > now {
+                            next_event - now
+                        } else {
+                            Duration::new(0, 0)
+                        }
+                    })
+                    .unwrap_or(Duration::from_secs(5));
+                drop(timer_lock);
+                schedule_callback(timer, sleep_dur);
+            })
+            .unchecked_ref(),
+            i32::try_from(when.as_millis()).unwrap_or(0),
+        )
+        .unwrap();
+}
+
+struct Waker {
+    timer: Arc<Mutex<Timer>>,
+}
+
+impl ArcWake for Waker {
+    fn wake_by_ref(arc_self: &Arc<Self>) {
+        schedule_callback(arc_self.timer.clone(), Duration::new(0, 0));
+    }
+}

src/heap_timer.rs

@@ -1,6 +1,6 @@
+use crate::Instant;
 use std::cmp::Ordering;
 use std::sync::Arc;
-use std::time::Instant;
 
 use crate::{Node, ScheduledTimer};
 

src/lib.rs

@@ -19,7 +19,10 @@
 mod arc_list;
 mod atomic_waker;
 mod delay;
-mod global;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+mod global_native;
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+mod global_wasm;
 mod heap;
 mod heap_timer;
 mod timer;
@@ -31,3 +34,7 @@ use heap_timer::HeapTimer;
 use timer::{ScheduledTimer, Timer, TimerHandle};
 
 pub use self::delay::Delay;
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+use instant::Instant;
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use std::time::Instant;

src/timer.rs

@@ -1,16 +1,15 @@
+use crate::Instant;
 use std::fmt;
+use std::future::Future;
 use std::mem;
 use std::pin::Pin;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;
 use std::sync::{Arc, Mutex, Weak};
 use std::task::{Context, Poll};
-use std::time::Instant;
-
-use std::future::Future;
 
 use crate::AtomicWaker;
-use crate::{global, ArcList, Heap, HeapTimer, Node, Slot};
+use crate::{ArcList, Heap, HeapTimer, Node, Slot};
 
 /// A "timer heap" used to power separately owned instances of `Delay`.
 ///
@@ -278,23 +277,37 @@ impl Default for TimerHandle {
         // handle which will return errors when timer objects are attempted to
         // be associated.
         if fallback == 0 {
-            let helper = match global::HelperThread::new() {
-                Ok(helper) => helper,
-                Err(_) => return TimerHandle { inner: Weak::new() },
-            };
+            #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+            {
+                let helper = match crate::global_native::HelperThread::new() {
+                    Ok(helper) => helper,
+                    Err(_) => return TimerHandle { inner: Weak::new() },
+                };
+
+                // If we successfully set ourselves as the actual fallback then we
+                // want to `forget` the helper thread to ensure that it persists
+                // globally. If we fail to set ourselves as the fallback that means
+                // that someone was racing with this call to
+                // `TimerHandle::default`.  They ended up winning so we'll destroy
+                // our helper thread (which shuts down the thread) and reload the
+                // fallback.
+                if helper.handle().set_as_global_fallback().is_ok() {
+                    let ret = helper.handle();
+                    helper.forget();
+                    return ret;
+                }
+            }
+
+            #[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+            {
+                let handle = crate::global_wasm::run();
 
-            // If we successfully set ourselves as the actual fallback then we
-            // want to `forget` the helper thread to ensure that it persists
-            // globally. If we fail to set ourselves as the fallback that means
-            // that someone was racing with this call to
-            // `TimerHandle::default`.  They ended up winning so we'll destroy
-            // our helper thread (which shuts down the thread) and reload the
-            // fallback.
-            if helper.handle().set_as_global_fallback().is_ok() {
-                let ret = helper.handle();
-                helper.forget();
-                return ret;
+                // Same as above.
+                if handle.clone().set_as_global_fallback().is_ok() {
+                    return handle;
+                }
             }
+
             fallback = HANDLE_FALLBACK.load(SeqCst);
         }