script/dom/
abortsignal.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::cell::{Cell, RefCell};
6use std::rc::Rc;
7use std::sync::{Arc, Mutex};
8
9use dom_struct::dom_struct;
10use indexmap::IndexSet;
11use js::context::JSContext;
12use js::jsapi::{ExceptionStackBehavior, Heap};
13use js::jsval::{JSVal, UndefinedValue};
14use js::rust::wrappers2::JS_SetPendingException;
15use js::rust::{HandleObject, HandleValue, MutableHandleValue};
16use script_bindings::inheritance::Castable;
17use script_bindings::weakref::WeakRef;
18
19use crate::dom::bindings::cell::DomRefCell;
20use crate::dom::bindings::codegen::Bindings::AbortSignalBinding::AbortSignalMethods;
21use crate::dom::bindings::codegen::Bindings::EventListenerBinding::EventListener;
22use crate::dom::bindings::codegen::Bindings::EventTargetBinding::EventListenerOptions;
23use crate::dom::bindings::error::{Error, ErrorToJsval, Fallible};
24use crate::dom::bindings::refcounted::Trusted;
25use crate::dom::bindings::reflector::{DomGlobal, reflect_dom_object_with_proto};
26use crate::dom::bindings::root::{Dom, DomRoot};
27use crate::dom::bindings::str::DOMString;
28use crate::dom::eventtarget::EventTarget;
29use crate::dom::globalscope::GlobalScope;
30use crate::dom::readablestream::PipeTo;
31use crate::fetch::{DeferredFetchRecord, FetchContext};
32use crate::realms::{InRealm, enter_realm};
33use crate::script_runtime::{CanGc, JSContext as SafeJSContext};
34
35impl js::gc::Rootable for AbortAlgorithm {}
36
37/// <https://dom.spec.whatwg.org/#abortcontroller-api-integration>
38/// TODO: implement algorithms at call point,
39/// in order to integrate the abort signal with its various use cases.
40#[derive(Clone, JSTraceable, MallocSizeOf)]
41#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
42pub(crate) enum AbortAlgorithm {
43    /// <https://dom.spec.whatwg.org/#add-an-event-listener>
44    DomEventListener(RemovableDomEventListener),
45    /// <https://streams.spec.whatwg.org/#readable-stream-pipe-to>
46    StreamPiping(PipeTo),
47    /// <https://fetch.spec.whatwg.org/#dom-global-fetch>
48    Fetch(
49        #[no_trace]
50        #[conditional_malloc_size_of]
51        Arc<Mutex<Option<FetchContext>>>,
52    ),
53    /// <https://fetch.spec.whatwg.org/#dom-window-fetchlater>
54    FetchLater(
55        #[no_trace]
56        #[conditional_malloc_size_of]
57        Arc<Mutex<DeferredFetchRecord>>,
58    ),
59}
60
61#[derive(Clone, JSTraceable, MallocSizeOf)]
62#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
63pub(crate) struct RemovableDomEventListener {
64    pub(crate) event_target: Dom<EventTarget>,
65    pub(crate) ty: DOMString,
66    #[conditional_malloc_size_of]
67    pub(crate) listener: Option<Rc<EventListener>>,
68    pub(crate) options: EventListenerOptions,
69}
70
71/// <https://dom.spec.whatwg.org/#abortsignal>
72#[dom_struct]
73pub(crate) struct AbortSignal {
74    eventtarget: EventTarget,
75
76    /// <https://dom.spec.whatwg.org/#abortsignal-abort-reason>
77    #[ignore_malloc_size_of = "mozjs"]
78    abort_reason: Heap<JSVal>,
79
80    /// <https://dom.spec.whatwg.org/#abortsignal-abort-algorithms>
81    abort_algorithms: RefCell<Vec<AbortAlgorithm>>,
82
83    /// <https://dom.spec.whatwg.org/#abortsignal-dependent>
84    dependent: Cell<bool>,
85
86    /// <https://dom.spec.whatwg.org/#abortsignal-source-signals>
87    #[no_trace]
88    #[ignore_malloc_size_of = "WeakRef"]
89    source_signals: DomRefCell<IndexSet<WeakRef<AbortSignal>>>,
90
91    /// <https://dom.spec.whatwg.org/#abortsignal-dependent-signals>
92    #[no_trace]
93    #[ignore_malloc_size_of = "WeakRef"]
94    dependent_signals: DomRefCell<IndexSet<WeakRef<AbortSignal>>>,
95}
96
97impl AbortSignal {
98    fn new_inherited() -> AbortSignal {
99        AbortSignal {
100            eventtarget: EventTarget::new_inherited(),
101            abort_reason: Default::default(),
102            abort_algorithms: Default::default(),
103            dependent: Default::default(),
104            source_signals: Default::default(),
105            dependent_signals: Default::default(),
106        }
107    }
108
109    pub(crate) fn new_with_proto(
110        global: &GlobalScope,
111        proto: Option<HandleObject>,
112        can_gc: CanGc,
113    ) -> DomRoot<AbortSignal> {
114        reflect_dom_object_with_proto(
115            Box::new(AbortSignal::new_inherited()),
116            global,
117            proto,
118            can_gc,
119        )
120    }
121
122    /// <https://dom.spec.whatwg.org/#abortsignal-signal-abort>
123    #[cfg_attr(crown, allow(crown::unrooted_must_root))] // TODO(39333): Remove when all iterators are marked as safe
124    pub(crate) fn signal_abort(
125        &self,
126        cx: SafeJSContext,
127        reason: HandleValue,
128        realm: InRealm,
129        can_gc: CanGc,
130    ) {
131        let global = self.global();
132
133        // Step 1. If signal is aborted, then return.
134        if self.Aborted() {
135            return;
136        }
137
138        // Step 2. Set signal’s abort reason to reason if it is given;
139        // otherwise to a new "AbortError" DOMException.
140        let abort_reason = reason.get();
141        if !abort_reason.is_undefined() {
142            self.abort_reason.set(abort_reason);
143        } else {
144            rooted!(in(*cx) let mut rooted_error = UndefinedValue());
145            Error::Abort(None).to_jsval(cx, &global, rooted_error.handle_mut(), can_gc);
146            self.abort_reason.set(rooted_error.get())
147        }
148
149        // Step 3. Let dependentSignalsToAbort be a new list.
150        let mut dependent_signals_to_abort = vec![];
151
152        // Step 4. For each dependentSignal of signal’s dependent signals:
153        for weak in self.dependent_signals.borrow().iter() {
154            if let Some(dependent_signal) = weak.root() {
155                // Step 4.1. If dependentSignal is not aborted:
156                if !dependent_signal.aborted() {
157                    // Step 4.1.1. Set dependentSignal’s abort reason to signal’s abort reason.
158                    dependent_signal.abort_reason.set(self.abort_reason.get());
159                    // Step 4.1.2. Append dependentSignal to dependentSignalsToAbort.
160                    dependent_signals_to_abort.push(dependent_signal);
161                }
162            }
163        }
164
165        // Step 5. Run the abort steps for signal.
166        self.run_the_abort_steps(cx, &global, realm, can_gc);
167
168        // Step 6. For each dependentSignal of dependentSignalsToAbort, run the abort steps for dependentSignal.
169        for dependent_signal in dependent_signals_to_abort.iter() {
170            dependent_signal.run_the_abort_steps(cx, &global, realm, can_gc);
171        }
172    }
173
174    /// <https://dom.spec.whatwg.org/#abortsignal-add>
175    pub(crate) fn add(&self, algorithm: &AbortAlgorithm) {
176        // Step 1. If signal is aborted, then return.
177        if self.aborted() {
178            return;
179        }
180
181        // Step 2. Append algorithm to signal’s abort algorithms.
182        self.abort_algorithms.borrow_mut().push(algorithm.clone());
183
184        // if this is a dependent signal, it may now need to be kept alive.
185        if self.dependent.get() {
186            self.global().register_dependent_abort_signal(self);
187        }
188    }
189
190    /// Run a specific abort algorithm.
191    pub(crate) fn run_abort_algorithm(
192        &self,
193        cx: SafeJSContext,
194        global: &GlobalScope,
195        algorithm: &AbortAlgorithm,
196        realm: InRealm,
197        can_gc: CanGc,
198    ) {
199        match algorithm {
200            AbortAlgorithm::StreamPiping(pipe) => {
201                rooted!(in(*cx) let mut reason = UndefinedValue());
202                reason.set(self.abort_reason.get());
203                pipe.abort_with_reason(cx, global, reason.handle(), realm, can_gc);
204            },
205            AbortAlgorithm::Fetch(fetch_context) => {
206                rooted!(in(*cx) let mut reason = UndefinedValue());
207                reason.set(self.abort_reason.get());
208                if let Some(fetch_context) = &mut *fetch_context.lock().unwrap() {
209                    fetch_context.abort_fetch(reason.handle(), cx, can_gc);
210                }
211            },
212            AbortAlgorithm::FetchLater(deferred_fetch_record) => {
213                deferred_fetch_record.lock().unwrap().abort();
214            },
215            AbortAlgorithm::DomEventListener(removable_listener) => {
216                removable_listener.event_target.remove_event_listener(
217                    removable_listener.ty.clone(),
218                    &removable_listener.listener,
219                    &removable_listener.options,
220                );
221            },
222        }
223    }
224
225    /// <https://dom.spec.whatwg.org/#run-the-abort-steps>
226    fn run_the_abort_steps(
227        &self,
228        cx: SafeJSContext,
229        global: &GlobalScope,
230        realm: InRealm,
231        can_gc: CanGc,
232    ) {
233        // Step 1. For each algorithm of signal’s abort algorithms: run algorithm.
234        for algo in self.abort_algorithms.borrow().iter() {
235            self.run_abort_algorithm(cx, global, algo, realm, can_gc);
236        }
237        // Step 2. Empty signal’s abort algorithms.
238        self.abort_algorithms.borrow_mut().clear();
239
240        // Step 3. Fire an event named abort at signal.
241        self.upcast::<EventTarget>()
242            .fire_event(atom!("abort"), can_gc);
243    }
244
245    /// <https://dom.spec.whatwg.org/#abortsignal-aborted>
246    pub(crate) fn aborted(&self) -> bool {
247        // An AbortSignal object is aborted when its abort reason is not undefined.
248        !self.abort_reason.get().is_undefined()
249    }
250
251    /// <https://dom.spec.whatwg.org/#create-a-dependent-abort-signal>
252    #[cfg_attr(crown, allow(crown::unrooted_must_root))] // TODO(39333): Remove when all iterators are marked as safe
253    pub(crate) fn create_dependent_abort_signal(
254        signals: Vec<DomRoot<AbortSignal>>,
255        global: &GlobalScope,
256        can_gc: CanGc,
257    ) -> DomRoot<AbortSignal> {
258        // Step 1. Let resultSignal be a new object implementing signalInterface using realm.
259        let result_signal = Self::new_with_proto(global, None, can_gc);
260        // Step 2. For each signal of signals: if signal is aborted,
261        // then set resultSignal’s abort reason to signal’s abort reason and return resultSignal.
262        for signal in signals.iter() {
263            if signal.aborted() {
264                result_signal.abort_reason.set(signal.abort_reason.get());
265                return result_signal;
266            }
267        }
268        // Step 3. Set resultSignal’s dependent to true.
269        result_signal.dependent.set(true);
270        // Step 4. For each signal of signals:
271        for signal in signals.iter() {
272            // Step 4.1. If signal’s dependent is false:
273            if !signal.dependent.get() {
274                // Step 4.1.1. Append signal to resultSignal’s source signals.
275                result_signal
276                    .source_signals
277                    .borrow_mut()
278                    .insert(WeakRef::new(signal));
279                // Step 4.1.2. Append resultSignal to signal’s dependent signals.
280                signal
281                    .dependent_signals
282                    .borrow_mut()
283                    .insert(WeakRef::new(&*result_signal));
284            } else {
285                // Step 4.2. Otherwise, for each sourceSignal of signal’s source signals:
286                for source_signal_weak in signal.source_signals.borrow().iter() {
287                    if let Some(source_signal) = source_signal_weak.root() {
288                        // Step 4.2.1. Assert: sourceSignal is not aborted and not dependent.
289                        assert!(!source_signal.aborted() && !source_signal.dependent.get());
290                        // Step 4.2.2. Append sourceSignal to resultSignal’s source signals.
291                        result_signal
292                            .source_signals
293                            .borrow_mut()
294                            .insert(WeakRef::new(&*source_signal));
295                        // Step 4.2.3. Append resultSignal to sourceSignal’s dependent signals.
296                        source_signal
297                            .dependent_signals
298                            .borrow_mut()
299                            .insert(WeakRef::new(&*result_signal));
300                    }
301                }
302            }
303        }
304        // Step 5. Return resultSignal.
305        global.register_dependent_abort_signal(&result_signal);
306        result_signal
307    }
308
309    /// Remove weak references whose target has been collected.
310    fn prune_dead_weak_refs(&self) {
311        self.source_signals.borrow_mut().retain(|w| w.is_alive());
312        self.dependent_signals.borrow_mut().retain(|w| w.is_alive());
313    }
314
315    /// Whether this signal still has abort algorithms registered.
316    fn has_abort_algorithms(&self) -> bool {
317        !self.abort_algorithms.borrow().is_empty()
318    }
319
320    /// Whether this signal has any listeners for its "abort" event.
321    fn has_abort_listeners(&self) -> bool {
322        self.upcast::<EventTarget>()
323            .has_listeners_for(&atom!("abort"))
324    }
325
326    /// <https://dom.spec.whatwg.org/#abort-signal-garbage-collection>
327    /// A non-aborted dependent AbortSignal object must not be garbage
328    /// collected while its source signals is non-empty and it has
329    /// registered event listeners for its abort event or its abort
330    /// algorithms is non-empty.
331    pub(crate) fn must_keep_alive_for_gc(&self) -> bool {
332        // Treat dead weak entries as removed.
333        self.prune_dead_weak_refs();
334
335        // Only care about non-aborted signals.
336        if self.aborted() {
337            return false;
338        }
339
340        // If it has no live source signals left, it doesn’t need to be kept.
341        if self.source_signals.borrow().is_empty() {
342            return false;
343        }
344
345        let has_algos = self.has_abort_algorithms();
346        let has_listeners = self.has_abort_listeners();
347
348        has_algos || has_listeners
349    }
350}
351
352impl AbortSignalMethods<crate::DomTypeHolder> for AbortSignal {
353    /// <https://dom.spec.whatwg.org/#dom-abortsignal-aborted>
354    fn Aborted(&self) -> bool {
355        // The aborted getter steps are to return true if this is aborted; otherwise false.
356        self.aborted()
357    }
358
359    /// <https://dom.spec.whatwg.org/#dom-abortsignal-abort>
360    fn Abort(
361        cx: SafeJSContext,
362        global: &GlobalScope,
363        reason: HandleValue,
364        can_gc: CanGc,
365    ) -> DomRoot<AbortSignal> {
366        // Step 1. Let signal be a new AbortSignal object.
367        let signal = AbortSignal::new_with_proto(global, None, can_gc);
368
369        // Step 2. Set signal’s abort reason to reason if it is given;
370        // otherwise to a new "AbortError" DOMException.
371        let abort_reason = reason.get();
372        if !abort_reason.is_undefined() {
373            signal.abort_reason.set(abort_reason);
374        } else {
375            rooted!(in(*cx) let mut rooted_error = UndefinedValue());
376            Error::Abort(None).to_jsval(cx, global, rooted_error.handle_mut(), can_gc);
377            signal.abort_reason.set(rooted_error.get())
378        }
379
380        // Step 3. Return signal.
381        signal
382    }
383
384    /// <https://dom.spec.whatwg.org/#dom-abortsignal-timeout>
385    fn Timeout(global: &GlobalScope, milliseconds: u64, can_gc: CanGc) -> DomRoot<AbortSignal> {
386        // Step 1. Let signal be a new AbortSignal object.
387        let signal = AbortSignal::new_with_proto(global, None, can_gc);
388
389        // Step 2. Let global be signal’s relevant global object.
390        // We already have `global`.
391
392        let signal_keepalive: Trusted<AbortSignal> = Trusted::new(&signal);
393
394        let ms_i64 = if milliseconds > i64::MAX as u64 {
395            i64::MAX
396        } else {
397            milliseconds as i64
398        };
399
400        // Step 3. Run steps after a timeout given global, "AbortSignal-timeout", milliseconds, and the following step:
401        global.run_steps_after_a_timeout(
402            DOMString::from("AbortSignal-timeout"),
403            ms_i64,
404            move |global, _can_gc| {
405                let task_source = global.task_manager().timer_task_source().to_sendable();
406
407                // Step 3.1. Queue a global task on the timer task source given global to signal abort given signal and a new "TimeoutError" DOMException.
408                // For the duration of this timeout, if signal has any event listeners registered for its abort event,
409                // there must be a strong reference from global to signal.
410                task_source.queue(task!(abortsignal_timeout: move || {
411                    let signal_for_task = signal_keepalive.root();
412
413                    let cx = GlobalScope::get_cx();
414                    rooted!(in(*cx) let mut reason = UndefinedValue());
415                    Error::Timeout(None).to_jsval(
416                        cx,
417                        &signal_for_task.global(),
418                        reason.handle_mut(),
419                        CanGc::note(),
420                    );
421
422                    let realm = enter_realm(&*signal_for_task.global());
423                    let comp = InRealm::Entered(&realm);
424
425                    // “signal abort given signal and a new "TimeoutError" DOMException.”
426                    signal_for_task.signal_abort(
427                        cx,
428                        reason.handle(),
429                        comp,
430                        CanGc::note(),
431                    );
432                }));
433            },
434        );
435
436        // Step 4. Return signal.
437        signal
438    }
439
440    /// <https://dom.spec.whatwg.org/#dom-abortsignal-any>
441    fn Any(
442        global: &GlobalScope,
443        signals: Vec<DomRoot<AbortSignal>>,
444        can_gc: CanGc,
445    ) -> DomRoot<AbortSignal> {
446        // The static any(signals) method steps are to return the result
447        // of creating a dependent abort signal from signals using AbortSignal and the current realm.
448        Self::create_dependent_abort_signal(signals, global, can_gc)
449    }
450
451    /// <https://dom.spec.whatwg.org/#dom-abortsignal-reason>
452    fn Reason(&self, _cx: SafeJSContext, mut rval: MutableHandleValue) {
453        // The reason getter steps are to return this’s abort reason.
454        rval.set(self.abort_reason.get());
455    }
456
457    /// <https://dom.spec.whatwg.org/#dom-abortsignal-throwifaborted>
458    #[expect(unsafe_code)]
459    fn ThrowIfAborted(&self, cx: &mut JSContext) -> Fallible<()> {
460        // The throwIfAborted() method steps are to throw this’s abort reason, if this is aborted.
461        if self.aborted() {
462            unsafe {
463                JS_SetPendingException(
464                    cx,
465                    HandleValue::from_raw(self.abort_reason.handle()),
466                    ExceptionStackBehavior::Capture,
467                )
468            };
469            return Err(Error::JSFailed);
470        }
471        Ok(())
472    }
473
474    // <https://dom.spec.whatwg.org/#dom-abortsignal-onabort>
475    event_handler!(abort, GetOnabort, SetOnabort);
476}
script/dom/abortsignal.rs

script/dom/
abortsignal.rs
