Add more threading utilities (#283)

## 🎟️ Tracking

<!-- Paste the link to the Jira or GitHub issue or otherwise describe /
point to where this change is coming from. -->

## 📔 Objective

Add sleep and cancellation token 

## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

Author: coroiu

Cargo.lock

@@ -16,8 +16,10 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { features = ["sync", "time", "rt"], workspace = true }
+tokio-util = { version = "0.7.15" }
 
 [target.'cfg(target_arch="wasm32")'.dependencies]
+gloo-timers = { version = "0.3.0", features = ["futures"] }
 js-sys = { workspace = true }
 tsify-next = { workspace = true }
 wasm-bindgen = { workspace = true }

crates/bitwarden-threading/Cargo.toml

@@ -0,0 +1,74 @@
+pub use tokio_util::sync::CancellationToken;
+
+#[cfg(target_arch = "wasm32")]
+pub mod wasm {
+    use wasm_bindgen::prelude::*;
+
+    use super::*;
+
+    #[wasm_bindgen]
+    extern "C" {
+        #[wasm_bindgen]
+        #[derive(Clone)]
+        pub type AbortController;
+
+        #[wasm_bindgen(constructor)]
+        pub fn new() -> AbortController;
+
+        #[wasm_bindgen(method, getter)]
+        pub fn signal(this: &AbortController) -> AbortSignal;
+
+        #[wasm_bindgen(method, js_name = abort)]
+        pub fn abort(this: &AbortController, reason: JsValue);
+
+        #[wasm_bindgen]
+        pub type AbortSignal;
+
+        #[wasm_bindgen(method, getter)]
+        pub fn aborted(this: &AbortSignal) -> bool;
+
+        #[wasm_bindgen(method, js_name = addEventListener)]
+        pub fn add_event_listener(
+            this: &AbortSignal,
+            event_type: &str,
+            callback: &Closure<dyn FnMut()>,
+        );
+    }
+
+    pub trait AbortControllerExt {
+        /// Converts an `AbortController` to a `CancellationToken`.
+        /// The signal only travels in one direction: `AbortController` -> `CancellationToken`,
+        /// i.e. the `CancellationToken` will be cancelled when the `AbortController` is aborted
+        /// but not the other way around.
+        fn to_cancellation_token(&self) -> CancellationToken;
+    }
+
+    impl AbortControllerExt for AbortController {
+        fn to_cancellation_token(&self) -> CancellationToken {
+            self.signal().to_cancellation_token()
+        }
+    }
+
+    pub trait AbortSignalExt {
+        /// Converts an `AbortSignal` to a `CancellationToken`.
+        /// The signal only travels in one direction: `AbortSignal` -> `CancellationToken`,
+        /// i.e. the `CancellationToken` will be cancelled when the `AbortSignal` is aborted
+        /// but not the other way around.
+        fn to_cancellation_token(&self) -> CancellationToken;
+    }
+
+    impl AbortSignalExt for AbortSignal {
+        fn to_cancellation_token(&self) -> CancellationToken {
+            let token = CancellationToken::new();
+
+            let token_clone = token.clone();
+            let closure = Closure::new(move || {
+                token_clone.cancel();
+            });
+            self.add_event_listener("abort", &closure);
+            closure.forget(); // Transfer ownership to the JS runtime
+
+            token
+        }
+    }
+}

crates/bitwarden-threading/src/cancellation_token.rs

@@ -1,3 +1,5 @@
+pub mod cancellation_token;
 mod thread_bound_runner;
+pub mod time;
 
 pub use thread_bound_runner::ThreadBoundRunner;

crates/bitwarden-threading/src/lib.rs

@@ -0,0 +1,55 @@
+use std::time::Duration;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn sleep(duration: Duration) {
+    tokio::time::sleep(duration).await;
+}
+
+#[cfg(target_arch = "wasm32")]
+pub async fn sleep(duration: Duration) {
+    use gloo_timers::future::sleep;
+
+    sleep(duration).await;
+}
+
+#[cfg(test)]
+mod test {
+    use wasm_bindgen_test::wasm_bindgen_test;
+
+    #[wasm_bindgen_test]
+    #[allow(dead_code)] // Not actually dead, but rust-analyzer doesn't understand `wasm_bindgen_test`
+    async fn should_sleep_wasm() {
+        use js_sys::Date;
+
+        use super::*;
+
+        console_error_panic_hook::set_once();
+        let start = Date::now();
+
+        sleep(Duration::from_millis(100)).await;
+
+        let end = Date::now();
+        let elapsed = end - start;
+
+        assert!(elapsed >= 90.0, "Elapsed time was less than expected");
+    }
+
+    #[tokio::test]
+    async fn should_sleep_tokio() {
+        use std::time::Instant;
+
+        use super::*;
+
+        let start = Instant::now();
+
+        sleep(Duration::from_millis(100)).await;
+
+        let end = Instant::now();
+        let elapsed = end.duration_since(start);
+
+        assert!(
+            elapsed >= Duration::from_millis(90),
+            "Elapsed time was less than expected"
+        );
+    }
+}

crates/bitwarden-threading/src/time.rs

@@ -0,0 +1,2 @@
+#[cfg(target_arch = "wasm32")]
+mod wasm;

crates/bitwarden-threading/tests/cancellation_token/mod.rs

@@ -0,0 +1,52 @@
+#![allow(unused_imports)] // Rust analyzer doesn't understand the `wasm_bindgen_test` macro
+use std::time::Duration;
+
+use bitwarden_threading::{
+    cancellation_token::wasm::{AbortController, AbortControllerExt},
+    time::sleep,
+};
+use wasm_bindgen_test::wasm_bindgen_test;
+
+mod to_cancellation_token {
+    use super::*;
+
+    #[wasm_bindgen_test]
+    #[allow(dead_code)] // Not actually dead, but rust-analyzer doesn't understand `wasm_bindgen_test`
+    #[cfg(target_arch = "wasm32")]
+    async fn rust_cancel_does_not_propagate_to_js() {
+        console_error_panic_hook::set_once();
+
+        let controller = AbortController::new();
+        let token = controller.clone().to_cancellation_token();
+
+        assert!(!token.is_cancelled());
+        assert!(!controller.signal().aborted());
+
+        token.cancel();
+        // Give the cancellation some time to propagate
+        sleep(Duration::from_millis(100)).await;
+
+        assert!(token.is_cancelled());
+        assert!(!controller.signal().aborted());
+    }
+
+    #[wasm_bindgen_test]
+    #[allow(dead_code)] // Not actually dead, but rust-analyzer doesn't understand `wasm_bindgen_test`
+    #[cfg(target_arch = "wasm32")]
+    async fn js_abort_propagate_to_rust() {
+        console_error_panic_hook::set_once();
+
+        let controller = AbortController::new();
+        let token = controller.clone().to_cancellation_token();
+
+        assert!(!token.is_cancelled());
+        assert!(!controller.signal().aborted());
+
+        controller.abort(wasm_bindgen::JsValue::from("Test reason"));
+        // Give the cancellation some time to propagate
+        sleep(Duration::from_millis(100)).await;
+
+        assert!(token.is_cancelled());
+        assert!(controller.signal().aborted());
+    }
+}

crates/bitwarden-threading/tests/cancellation_token/wasm.rs

@@ -1,2 +1,2 @@
-mod standard_tokio;
-mod wasm;
+mod cancellation_token;
+mod thread_bound_runner;

crates/bitwarden-threading/tests/mod.rs

@@ -0,0 +1,2 @@
+mod standard_tokio;
+mod wasm;