1use 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#[derive(Clone, JSTraceable, MallocSizeOf)]
45#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
46pub(crate) enum AbortAlgorithm {
47 DomEventListener(RemovableDomEventListener),
49 StreamPiping(PipeTo),
51 Fetch(Dom<Request>),
53 FetchLater(#[no_trace] DeferredFetchRecordId),
55 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#[dom_struct]
70pub(crate) struct AbortSignal {
71 eventtarget: EventTarget,
72
73 #[ignore_malloc_size_of = "mozjs"]
75 abort_reason: Heap<JSVal>,
76
77 abort_algorithms: RefCell<Vec<AbortAlgorithm>>,
79
80 dependent: Cell<bool>,
82
83 #[no_trace]
85 #[ignore_malloc_size_of = "WeakRef"]
86 source_signals: DomRefCell<IndexSet<WeakRef<AbortSignal>>>,
87
88 #[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 pub(crate) fn signal_abort(&self, cx: &mut CurrentRealm, reason: HandleValue) {
121 let global = self.global();
122
123 if self.Aborted() {
125 return;
126 }
127
128 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 let mut dependent_signals_to_abort = vec![];
141
142 for weak in self.dependent_signals.borrow().iter() {
144 if let Some(dependent_signal) = weak.root() {
145 if !dependent_signal.aborted() {
147 dependent_signal.abort_reason.set(self.abort_reason.get());
149 dependent_signals_to_abort.push(dependent_signal);
151 }
152 }
153 }
154
155 self.run_the_abort_steps(cx, &global);
157
158 for dependent_signal in dependent_signals_to_abort.iter() {
160 dependent_signal.run_the_abort_steps(cx, &global);
161 }
162 }
163
164 pub(crate) fn add(&self, algorithm: &AbortAlgorithm) {
166 if self.aborted() {
168 return;
169 }
170
171 self.abort_algorithms.borrow_mut().push(algorithm.clone());
173
174 if self.dependent.get() {
176 self.global().register_dependent_abort_signal(self);
177 }
178 }
179
180 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 fn run_the_abort_steps(&self, cx: &mut CurrentRealm, global: &GlobalScope) {
219 for algo in self.abort_algorithms.borrow().iter() {
221 self.run_abort_algorithm(cx, global, algo);
222 }
223 self.abort_algorithms.borrow_mut().clear();
225
226 self.upcast::<EventTarget>().fire_event(cx, atom!("abort"));
228 }
229
230 pub(crate) fn aborted(&self) -> bool {
232 !self.abort_reason.get().is_undefined()
234 }
235
236 pub(crate) fn create_dependent_abort_signal(
238 cx: &mut JSContext,
239 signals: Vec<DomRoot<AbortSignal>>,
240 global: &GlobalScope,
241 ) -> DomRoot<AbortSignal> {
242 let result_signal = Self::new_with_proto(cx, global, None);
244 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 result_signal.dependent.set(true);
254 for signal in signals.iter() {
256 if !signal.dependent.get() {
258 result_signal
260 .source_signals
261 .safe_borrow_mut(cx.no_gc())
262 .insert(WeakRef::new(signal));
263 signal
265 .dependent_signals
266 .safe_borrow_mut(cx.no_gc())
267 .insert(WeakRef::new(&*result_signal));
268 } else {
269 for source_signal_weak in signal.source_signals.borrow().iter() {
271 if let Some(source_signal) = source_signal_weak.root() {
272 assert!(!source_signal.aborted() && !source_signal.dependent.get());
274 result_signal
276 .source_signals
277 .safe_borrow_mut(cx.no_gc())
278 .insert(WeakRef::new(&*source_signal));
279 source_signal
281 .dependent_signals
282 .safe_borrow_mut(cx.no_gc())
283 .insert(WeakRef::new(&*result_signal));
284 }
285 }
286 }
287 }
288 global.register_dependent_abort_signal(&result_signal);
290 result_signal
291 }
292
293 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 fn has_abort_algorithms(&self) -> bool {
301 !self.abort_algorithms.borrow().is_empty()
302 }
303
304 fn has_abort_listeners(&self) -> bool {
306 self.upcast::<EventTarget>()
307 .has_listeners_for(&atom!("abort"))
308 }
309
310 pub(crate) fn must_keep_alive_for_gc(&self) -> bool {
316 self.prune_dead_weak_refs();
318
319 if self.aborted() {
321 return false;
322 }
323
324 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 fn Aborted(&self) -> bool {
339 self.aborted()
341 }
342
343 fn Abort(
345 cx: &mut JSContext,
346 global: &GlobalScope,
347 reason: HandleValue,
348 ) -> DomRoot<AbortSignal> {
349 let signal = AbortSignal::new_with_proto(cx, global, None);
351
352 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 signal
365 }
366
367 fn Timeout(
369 cx: &mut JSContext,
370 global: &GlobalScope,
371 milliseconds: u64,
372 ) -> DomRoot<AbortSignal> {
373 let signal = AbortSignal::new_with_proto(cx, global, None);
375
376 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 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 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_for_task.signal_abort(
412 &mut realm,
413 reason.handle(),
414 );
415 }));
416 },
417 );
418
419 signal
421 }
422
423 fn Any(
425 cx: &mut JSContext,
426 global: &GlobalScope,
427 signals: Vec<DomRoot<AbortSignal>>,
428 ) -> DomRoot<AbortSignal> {
429 Self::create_dependent_abort_signal(cx, signals, global)
432 }
433
434 fn Reason(&self, mut rval: MutableHandleValue) {
436 rval.set(self.abort_reason.get());
438 }
439
440 #[expect(unsafe_code)]
442 fn ThrowIfAborted(&self, cx: &mut JSContext) -> Fallible<()> {
443 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 event_handler!(abort, GetOnabort, SetOnabort);
454}