Skip to main content

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