wasm: Use wasmtimer for all delaying needs

Author: felinira

Cargo.lock

@@ -73,6 +73,7 @@ tracing = "0.1"
 tracing-subscriber = "0.3"
 test-log = "0.2"
 zxcvbn = "3.1.0"
+wasmtimer = "0.4"
 
 [package]
 name = "magic-wormhole"
@@ -159,6 +160,7 @@ if-addrs = { version = "0.14", optional = true }
 [target.'cfg(target_family = "wasm")'.dependencies]
 ws_stream_wasm = "0.7.3"
 getrandom = { version = "0.2.5", features = ["js"] }
+wasmtimer = { workspace = true }
 
 # for some tests
 [dev-dependencies]

Cargo.toml

@@ -864,7 +864,7 @@ mod tar_helper {
     }
 
     #[cfg(any(windows, target_arch = "wasm32"))]
-    pub(crate) fn path2bytes(p: &str) -> Cow<[u8]> {
+    pub(crate) fn path2bytes(p: &str) -> Cow<'_, [u8]> {
         let bytes = p.as_bytes();
         if bytes.contains(&b'\\') {
             // Normalize to Unix-style path separators

src/transfer/v1.rs

@@ -1307,7 +1307,7 @@ impl TransitConnector {
                                     .map(move |(i, u)| (i, u, name.clone()))
                             })
                             .map(|(index, url, name)| async move {
-                                async_io::Timer::after(std::time::Duration::from_secs(
+                                crate::util::sleep(std::time::Duration::from_secs(
                                     index as u64 * 5,
                                 ))
                                 .await;

src/transit.rs

@@ -123,23 +123,31 @@ pub fn hashcash(resource: String, bits: u32) -> String {
 #[error("Timed out")]
 pub(crate) struct TimeoutError;
 
+/// Utility function to call async timer implementations for WASM and others
+pub(crate) async fn sleep(timeout: std::time::Duration) {
+    #[cfg(target_family = "wasm")]
+    wasmtimer::tokio::sleep(timeout).await;
+    #[cfg(not(target_family = "wasm"))]
+    async_io::Timer::after(timeout).await;
+}
+
 /// Utility function to add a timeout to a future
 ///
 /// This behaves the same as async std timeout, but with async-io
-#[cfg(not(target_family = "wasm"))]
 pub(crate) fn timeout<'a, R, F: std::future::Future<Output = R> + 'a>(
     timeout: std::time::Duration,
     future: F,
 ) -> impl Future<Output = Result<R, TimeoutError>> + 'a {
     let timeout_future = async move {
-        async_io::Timer::after(timeout).await;
+        sleep(timeout).await;
         Err(TimeoutError)
     };
 
     futures_lite::future::or(async { Ok(future.await) }, timeout_future)
 }
 
 /// Utility function to spawn a future. We don't use crate::util::spawn, because not the entirety of smol compiles on WASM
+#[allow(dead_code)]
 pub(crate) fn spawn<T: Send + 'static>(
     future: impl Future<Output = T> + Send + 'static,
 ) -> async_task::Task<T> {