stash

Author: mjameswh

packages/core-bridge/src/helpers/abort_controller.rs

@@ -50,18 +50,38 @@ impl AbortController {
         }
     }
 
-    pub fn abort(&self, reason: impl Into<String>) {
-        let inner = &*self.inner;
-        let mutex = inner.state;
-
-        let mutex.lock().abort(reason);
-    }
-
+    /// Get an associated `AbortSignal` object for this controller. This method can
+    /// be called at any time (i.e. even after the controller has been cancelled),
+    /// any number of times (i.e. to pass a same signal to multiple JS functions),
+    /// and from any thread.
     pub fn signal(&self) -> AbortSignal {
         AbortSignal {
             inner: self.inner.clone(),
         }
     }
+
+    /// Abort the controller, causing the JS side `signal` to fire.
+    ///
+    /// This method can be called at any time (i.e. even before the controller has been armed,
+    /// or after it has been disarmed), and from any thread.
+    pub fn abort(&self, reason: impl Into<String>) {
+        let call_abort = self.inner.lock().abort(reason);
+        if let Some(call_abort) = call_abort {
+            call_abort
+                .abort_cb
+                .call_on_js_thread((call_abort.abort_reason,));
+        }
+    }
+
+    /// Disarm the controller, so that it can no longer be aborted.
+    ///
+    /// Once a controller has been disarmed, it's abort status will not change anymore. It is
+    /// recommended to call this method once it is known that the signal is no longer needed
+    /// on the JS side, e.g. when the called JS function has returned, as this will prevent the
+    /// overhead of implicit abortion when the controller is dropped.
+    pub fn disarm(&self) {
+        self.inner.lock().disarm();
+    }
 }
 
 impl Drop for AbortController {
@@ -118,7 +138,7 @@ impl AbortControllerInner {
                         // immediately and synchronously propagate the abort to the JS controller object.
 
                         // ... but let's not hold on to the state mutex while calling the abort callback
-                        *state = AbortControllerInnerState::Disabled;
+                        *state = AbortControllerInnerState::Disarmed;
                         mem::drop(state);
 
                         // Call the abort callback
@@ -207,18 +227,88 @@ enum AbortControllerInnerState {
     /// Transitions:
     /// - Calling `abort()` will result in calling the abort callback, and move to the `Disabled` state
     /// - Calling `disable()` is a no-op
-    Armed(JsCallback<(String,), ()>),
+    Armed(Root<JsAbortController>, JsCallback<(String,), ()>),
+
+    /// The `AbortController` has been disarmed, though it was actually never armed.
+    ///
+    /// Transitions:
+    /// - Calling `abort()` is a no-op
+    /// - Initializing the JS counterpart will move to the `Disarmed` state
+    UninitializedDisarmed,
 
     /// The `AbortController` has been disabled, either by being aborted or by calling `disable()`.
     /// It is still possible to obtain a `signal` from the controller, but it's abort status
     /// will not change anymore.
     ///
     /// Any transitions from this state is a no-op.
-    Disabled,
+    Disarmed(Root<JsAbortController>),
 }
 
 impl AbortControllerInnerState {
-    fn abort(self, reason: impl Into<String>) -> Self {
-        todo!()
+    fn arm(
+        &mut self,
+        js_controller: Root<JsAbortController>,
+        abort_cb: JsCallback<(String,), ()>,
+    ) -> Option<CallAbortDetails> {
+        match self {
+            Self::Uninitialized => {
+                *self = Self::Armed(js_controller, abort_cb);
+                None
+            }
+            Self::AbortedBeforeArmed(abort_reason) => {
+                let abort_reason = abort_reason.clone();
+                *self = Self::Disarmed(js_controller);
+                Some(CallAbortDetails {
+                    abort_reason,
+                    abort_cb,
+                })
+            }
+            Self::UninitializedDisarmed => {
+                *self = Self::Disarmed(js_controller);
+                None
+            }
+            _ => None,
+        }
+    }
+
+    fn abort(&mut self, reason: impl Into<String>) -> Option<CallAbortDetails> {
+        let current = mem::replace(self, Self::Uninitialized);
+        match current {
+            Self::Uninitialized => {
+                *self = Self::AbortedBeforeArmed(reason.into());
+                None
+            }
+            Self::Armed(js_controller, abort_cb) => {
+                *self = Self::Disarmed(js_controller);
+                Some(CallAbortDetails {
+                    abort_reason: reason.into(),
+                    abort_cb,
+                })
+            }
+            other => {
+                *self = other;
+                None
+            }
+        }
     }
+
+    fn disarm(&mut self) {
+        let current = mem::replace(self, Self::Uninitialized);
+        match current {
+            Self::Uninitialized => {
+                *self = Self::UninitializedDisarmed;
+            }
+            Self::Armed(js_controller, _) => {
+                *self = Self::Disarmed(js_controller);
+            }
+            other => {
+                *self = other;
+            }
+        }
+    }
+}
+
+struct CallAbortDetails {
+    abort_reason: String,
+    abort_cb: JsCallback<(String,), ()>,
 }