Switch to gloo-timers

Author: expenses

Cargo.toml

@@ -13,19 +13,13 @@ Timeouts for futures.
 """
 
 [dependencies]
-wasm-timer = { version = "0.2.4", optional = true }
-wasm-bindgen-crate = { package = "wasm-bindgen", version = "0.2.55", optional = true }
-futures = { version = "0.3.1", optional = true }
-web-sys = { version = "0.3.32", optional = true }
+gloo-timers = { version = "0.2.0", features = ["futures"], optional = true }
 
 [dev-dependencies]
 async-std = { version = "1.0.1", features = ["attributes"] }
 futures = "0.3.1"
 
 [features]
 wasm-bindgen = [
-	"wasm-timer",
-	"wasm-bindgen-crate",
-	"futures",
-	"web-sys"
+	"gloo-timers"
 ]

src/delay.rs

@@ -3,15 +3,14 @@
 //! 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;
+use std::time::{Duration, Instant};
 
 use crate::arc_list::Node;
 use crate::AtomicWaker;

src/delay_wasm.rs

@@ -0,0 +1,22 @@
+//! A version of `Delay` that works on wasm.
+
+use gloo_timers::future::TimeoutFuture;
+use std::{time::Duration, pin::Pin, task::{Context, Poll}, future::Future};
+
+#[derive(Debug)]
+pub struct Delay(TimeoutFuture);
+
+impl Delay {
+	#[inline]
+	pub fn new(dur: Duration) -> Delay {
+		Self(TimeoutFuture::new(dur.as_millis() as u32))
+	}
+}
+
+impl Future for Delay {
+	type Output = ();
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		Pin::new(*self.0).poll(cx)
+	}
+}

src/global_native.rs renamed to src/global.rs

@@ -1,4 +1,3 @@
-use crate::Instant;
 use std::future::Future;
 use std::io;
 use std::mem::{self, ManuallyDrop};
@@ -8,6 +7,7 @@ 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};
 
@@ -84,7 +84,7 @@ static VTABLE: RawWakerVTable = RawWakerVTable::new(raw_clone, raw_wake, raw_wak
 
 fn raw_clone(ptr: *const ()) -> RawWaker {
     let me = ManuallyDrop::new(unsafe { Arc::from_raw(ptr as *const Thread) });
-    mem::forget(me);
+    mem::forget(me.clone());
     RawWaker::new(ptr, &VTABLE)
 }
 

src/global_wasm.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/heap_timer.rs

@@ -18,11 +18,11 @@
 
 mod arc_list;
 mod atomic_waker;
+#[cfg(not(all(target_arch = "wasm32", feature = "wasm-bindgen")))]
 mod delay;
-#[cfg(not(target_arch = "wasm32"))]
-mod global_native;
-#[cfg(feature = "wasm-bindgen")]
-mod global_wasm;
+#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
+mod delay_wasm;
+mod global;
 mod heap;
 mod heap_timer;
 mod timer;
@@ -33,8 +33,7 @@ use heap::{Heap, Slot};
 use heap_timer::HeapTimer;
 use timer::{ScheduledTimer, Timer, TimerHandle};
 
+#[cfg(not(all(target_arch = "wasm32", feature = "wasm-bindgen")))]
 pub use self::delay::Delay;
-#[cfg(not(feature = "wasm-bindgen"))]
-use std::time::Instant;
-#[cfg(feature = "wasm-bindgen")]
-use wasm_timer::Instant;
+#[cfg(all(target_arch = "wasm32", feature = "wasm-bindgen"))]
+pub use self::delay_wasm::Delay;

src/lib.rs

@@ -1,15 +1,16 @@
-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::{ArcList, Heap, HeapTimer, Node, Slot};
+use crate::{global, ArcList, Heap, HeapTimer, Node, Slot};
 
 /// A "timer heap" used to power separately owned instances of `Delay`.
 ///
@@ -277,39 +278,23 @@ impl Default for TimerHandle {
         // handle which will return errors when timer objects are attempted to
         // be associated.
         if fallback == 0 {
-            #[cfg(not(target_arch = "wasm32"))]
-            {
-                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(feature = "wasm-bindgen", target_arch = "wasm32"))]
-            {
-                let handle = crate::global_wasm::run();
+            let helper = match global::HelperThread::new() {
+                Ok(helper) => helper,
+                Err(_) => return TimerHandle { inner: Weak::new() },
+            };
 
-                // Same as above.
-                if handle.clone().set_as_global_fallback().is_ok() {
-                    return handle;
-                }
+            // 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(not(feature = "wasm-bindgen"), target_arch = "wasm32"))]
-            compile_error!("The `wasm-bindgen` feature must be used when compiling to wasm.");
-
             fallback = HANDLE_FALLBACK.load(SeqCst);
         }