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

script/dom/
abortsignal.rs
