add wasm global

Author: expenses

Cargo.toml

@@ -16,6 +16,10 @@ Timeouts for futures.
 
 [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"] }

src/global_wasm.rs

@@ -0,0 +1,77 @@
+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::{JsCast, closure::Closure};
+
+use crate::{Instant, Timer, TimerHandle};
+
+/// Starts a background task, creates a `Timer`, and returns a handle to it.
+///
+/// > **Note**: Contrary to the original `futures-timer` crate, 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/lib.rs

@@ -23,6 +23,8 @@ mod global;
 mod heap;
 mod heap_timer;
 mod timer;
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+mod global_wasm;
 
 use arc_list::{ArcList, Node};
 use atomic_waker::AtomicWaker;

src/timer.rs

@@ -277,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 global::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;
+                }
+            }
 
-            // 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 handle.clone().set_as_global_fallback().is_ok() {
+                    return handle;
+                }
             }
+
             fallback = HANDLE_FALLBACK.load(SeqCst);
         }