Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(dom): preserve AbortSignal dependency order during reentrant aborts

ldm03ea89722bc4a
diff --git a/moli-core/tests/fixtures/runtime/abort_signal_dependencies.js b/moli-core/tests/fixtures/runtime/abort_signal_dependencies.js
new file mode 100644
index 000000000..1c7e4e3fe
--- /dev/null
+++ b/moli-core/tests/fixtures/runtime/abort_signal_dependencies.js
@@ -0,0 +1,117 @@
+function runAbortSignalDependencyProbe(scenario) {
+ const errors = [];
+ const events = [];
+ const check = (condition, label) => { if (!condition) errors.push(label); };
+ const checkReason = (signal, reason, label) => {
+ check(signal.aborted && signal.reason === reason, label);
+ let caught = false;
+ try { signal.throwIfAborted(); }
+ catch (error) { caught = true; check(error === reason, label + ': thrown reason'); }
+ check(caught, label + ': throwIfAborted throws');
+ };
+
+ try {
+ if (scenario === 'graph') {
+ const first = new AbortController();
+ const second = new AbortController();
+ const empty = AbortSignal.any([]);
+ const emptyClone = AbortSignal.any([empty]);
+ const signals = [first.signal];
+ signals.push(AbortSignal.any([first.signal, second.signal]));
+ signals.push(AbortSignal.any([first.signal]));
+ signals.push(AbortSignal.any([signals[1]]));
+ signals.push(AbortSignal.any([signals[3], signals[1], first.signal, second.signal]));
+ signals.push(AbortSignal.any([emptyClone, first.signal]));
+ const reason = {source: 'first'};
+ signals.forEach((signal, index) => signal.addEventListener('abort', event => {
+ events.push(String(index));
+ check(event.target === signal, 'target ' + index);
+ signals.forEach((dependent, i) => checkReason(dependent, reason, index + '/' + i));
+ checkReason(AbortSignal.any([emptyClone, signals[4], second.signal]), reason, 'late composite');
+ }));
+ first.abort(reason);
+ second.abort({source: 'second'});
+ signals.forEach((signal, index) => checkReason(signal, reason, 'final ' + index));
+ check(!empty.aborted && empty.reason === undefined, 'empty signal stays pending');
+ check(!emptyClone.aborted && emptyClone.reason === undefined, 'empty composite stays pending');
+ } else if (scenario === 'reentrant') {
+ const first = new AbortController();
+ const second = new AbortController();
+ const shared = AbortSignal.any([first.signal, second.signal]);
+ const secondary = AbortSignal.any([second.signal]);
+ const nested = AbortSignal.any([shared, secondary]);
+ const firstReason = {source: 'first'};
+ const secondReason = {source: 'second'};
+ first.signal.addEventListener('abort', () => {
+ events.push('first');
+ checkReason(shared, firstReason, 'shared before reentry');
+ checkReason(nested, firstReason, 'nested before reentry');
+ second.abort(secondReason);
+ });
+ second.signal.addEventListener('abort', () => {
+ events.push('second');
+ checkReason(shared, firstReason, 'shared during reentry');
+ checkReason(nested, firstReason, 'nested during reentry');
+ checkReason(secondary, secondReason, 'secondary during reentry');
+ for (const [sources, reason] of [
+ [[secondary, shared], secondReason], [[shared, secondary], firstReason]
+ ]) {
+ const late = AbortSignal.any(sources);
+ checkReason(late, reason, 'already aborted input order');
+ late.onabort = () => errors.push('already aborted composite dispatched again');
+ }
+ });
+ secondary.onabort = () => {
+ events.push('secondary');
+ first.abort({source: 'repeat'});
+ };
+ shared.onabort = () => events.push('shared');
+ nested.onabort = () => events.push('nested');
+ first.abort(firstReason);
+ checkReason(shared, firstReason, 'shared final reason');
+ checkReason(nested, firstReason, 'nested final reason');
+ checkReason(secondary, secondReason, 'secondary final reason');
+ } else if (scenario === 'listeners') {
+ const controller = new AbortController();
+ const first = AbortSignal.any([controller.signal]);
+ const last = AbortSignal.any([first]);
+ const targets = [new EventTarget()];
+ if (typeof document !== 'undefined') targets.push(document.createElement('div'));
+ const counts = targets.map(() => 0);
+ targets.forEach((target, index) => target.addEventListener('probe', () => {
+ counts[index]++;
+ }, {signal: first}));
+ const dispatch = () => targets.forEach(target => target.dispatchEvent(new Event('probe')));
+ const removed = () => errors.push('removed dependent listener fired');
+ const removedLast = () => errors.push('removed nested listener fired');
+ first.addEventListener('abort', removed);
+ last.addEventListener('abort', removedLast);
+ last.addEventListener('abort', () => events.push('last'));
+ first.addEventListener('abort', () => {
+ events.push('first');
+ dispatch();
+ check(counts.every(count => count === 1), 'listener removal precedes dependent event');
+ last.removeEventListener('abort', removedLast);
+ last.addEventListener('abort', () => events.push('late-last'));
+ first.addEventListener('abort', () => errors.push('listener added to active dispatch fired'));
+ });
+ controller.signal.addEventListener('abort', () => {
+ events.push('source');
+ check(first.aborted && last.aborted, 'dependent state precedes source event');
+ dispatch();
+ check(counts.every(count => count === 1), 'dependent algorithms wait for source event');
+ first.removeEventListener('abort', removed);
+ first.addEventListener('abort', () => events.push('added'));
+ first.onabort = () => events.push('handler');
+ });
+ controller.abort('reason');
+ dispatch();
+ check(counts.every(count => count === 1), 'listeners remain removed');
+ } else {
+ errors.push('unknown scenario ' + scenario);
+ }
+ } catch (error) {
+ errors.push(String(error));
+ }
+ return {errors, events};
+}
diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rs
index e67c74ad9..6754f9316 100644
--- a/moli-core/tests/web_apis.rs
+++ b/moli-core/tests/web_apis.rs
@@ -16,6 +16,8 @@ use moli_fetch::FetchConfig;
use support::FixtureServer;
use tokio::time::Duration;
+#[path = "web_apis/abort_signal.rs"]
+mod abort_signal;
fn diagnostic_global<'a>(
page: &'a moli_core::page::Page,
name: &str,
diff --git a/moli-core/tests/web_apis/abort_signal.rs b/moli-core/tests/web_apis/abort_signal.rs
new file mode 100644
index 000000000..fd57f4395
--- /dev/null
+++ b/moli-core/tests/web_apis/abort_signal.rs
@@ -0,0 +1,51 @@
+use super::*;
+
+async fn assert_abort_signal_dependencies(scenario: &str, events: &[&str]) -> Result<()> {
+ let server = FixtureServer::spawn().await?;
+ let browser = Browser::new(AppConfig::default())?;
+ let source = format!(
+ "{}\nfinish(runAbortSignalDependencyProbe({}));",
+ include_str!("../fixtures/runtime/abort_signal_dependencies.js"),
+ serde_json::to_string(scenario)?,
+ );
+ for target in ["window", "child", "worker"] {
+ let observed = tokio::time::timeout(
+ Duration::from_secs(10),
+ super::pipe_disturbed::run_probe(&browser, &server, target, &source),
+ )
+ .await??;
+ assert_eq!(
+ observed,
+ serde_json::json!({"errors": [], "events": events}),
+ "{scenario}/{target}"
+ );
+ }
+ server.shutdown().await;
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn abort_signal_any_flattens_nested_sources_and_marks_all_dependents_before_events()
+-> Result<()> {
+ assert_abort_signal_dependencies("graph", &["0", "1", "2", "3", "4", "5"]).await
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn abort_signal_any_preserves_first_reason_and_event_order_during_reentrant_abort()
+-> Result<()> {
+ assert_abort_signal_dependencies(
+ "reentrant",
+ &["first", "second", "secondary", "shared", "nested"],
+ )
+ .await
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn abort_signal_any_runs_listener_removal_before_dispatch_and_snapshots_each_event()
+-> Result<()> {
+ assert_abort_signal_dependencies(
+ "listeners",
+ &["source", "first", "added", "handler", "last", "late-last"],
+ )
+ .await
+}
diff --git a/moli-renderer-v8/src/native_bridge/abort.rs b/moli-renderer-v8/src/native_bridge/abort.rs
index df8ae4051..686db7237 100644
--- a/moli-renderer-v8/src/native_bridge/abort.rs
+++ b/moli-renderer-v8/src/native_bridge/abort.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
use super::super::document_runtime::EventTargetHandle;
use super::super::util::{get_private_value, set_private_value};
@@ -53,6 +53,8 @@ struct AbortSignalState {
reason: Option<v8::Global<v8::Value>>,
abort_algorithms: Vec<v8::Global<v8::Function>>,
linked_target_listeners: Vec<AbortLinkedTargetListener>,
+ // None for a source; Some (including empty) for a dependent signal's ordered roots.
+ source_signals: Option<Vec<u32>>,
dependent_signals: Vec<u32>,
}
@@ -66,7 +68,6 @@ struct AbortLinkedTargetListener {
struct AbortSignalDispatch {
algorithms: Vec<v8::Global<v8::Function>>,
linked_target_listeners: Vec<AbortLinkedTargetListener>,
- dependent_signals: Vec<u32>,
}
impl AbortStore {
@@ -275,12 +276,12 @@ impl AbortStore {
}
}
- fn take_signal_abort<'s>(
+ fn prepare_signal_abort<'s>(
&mut self,
scope: &mut v8::PinScope<'s, '_>,
signal: v8::Local<'s, v8::Object>,
reason: v8::Local<'s, v8::Value>,
- ) -> Option<AbortSignalDispatch> {
+ ) -> Option<Vec<(u32, v8::Local<'s, v8::Object>)>> {
let signal_id = Self::signal_id_from_object(scope, signal)?;
let state = self.signal_state_mut(signal_id)?;
if state.aborted {
@@ -288,23 +289,61 @@ impl AbortStore {
}
state.aborted = true;
state.reason = Some(v8::Global::new(scope, reason));
+ let dependent_signals = state.dependent_signals.clone();
+ // Publish every reason before any author callback can reenter abort.
+ let mut signals = vec![(signal_id, signal)];
+ for dependent_signal_id in dependent_signals {
+ let Some(state) = self.signal_state_mut(dependent_signal_id) else {
+ continue;
+ };
+ if state.aborted {
+ continue;
+ }
+ state.aborted = true;
+ state.reason = Some(v8::Global::new(scope, reason));
+ if let Some(signal) = &state.signal {
+ signals.push((dependent_signal_id, v8::Local::new(scope, signal)));
+ }
+ }
+ Some(signals)
+ }
+
+ fn take_signal_abort_steps(&mut self, signal_id: u32) -> Option<AbortSignalDispatch> {
+ let state = self.signal_state_mut(signal_id)?;
Some(AbortSignalDispatch {
algorithms: std::mem::take(&mut state.abort_algorithms),
linked_target_listeners: std::mem::take(&mut state.linked_target_listeners),
- dependent_signals: state.dependent_signals.clone(),
})
}
- pub(super) fn link_dependent_signal(
+ fn set_signal_sources(
&mut self,
- source_signal_id: u32,
dependent_signal_id: u32,
+ input_signal_ids: impl IntoIterator<Item = u32>,
) {
- let Some(state) = self.signal_state_mut(source_signal_id) else {
- return;
- };
- if !state.dependent_signals.contains(&dependent_signal_id) {
- state.dependent_signals.push(dependent_signal_id);
+ let mut sources = Vec::new();
+ let mut seen = HashSet::new();
+ for input_signal_id in input_signal_ids {
+ let Some(state) = self.signal_state(input_signal_id) else {
+ continue;
+ };
+ let roots = state
+ .source_signals
+ .as_deref()
+ .unwrap_or(std::slice::from_ref(&input_signal_id));
+ for &source_signal_id in roots {
+ if seen.insert(source_signal_id) {
+ sources.push(source_signal_id);
+ }
+ }
+ }
+ for &source_signal_id in &sources {
+ if let Some(state) = self.signal_state_mut(source_signal_id) {
+ state.dependent_signals.push(dependent_signal_id);
+ }
+ }
+ if let Some(state) = self.signal_state_mut(dependent_signal_id) {
+ state.source_signals = Some(sources);
}
}
}
@@ -320,31 +359,32 @@ pub(crate) fn abort_signal<'s>(
let Some(host_ptr) = crate::util::context_host_ptr_from_global_bridge(scope) else {
return;
};
- let dispatch = unsafe { &mut *host_ptr }
+ let signals = unsafe { &mut *host_ptr }
.native_bridge_mut()
.abort
- .take_signal_abort(scope, signal, reason);
- let Some(dispatch) = dispatch else {
+ .prepare_signal_abort(scope, signal, reason);
+ let Some(signals) = signals else {
return;
};
- event::invoke_abort_algorithms(scope, signal, reason, dispatch.algorithms);
- abort_signal_events::dispatch_abort(scope, signal);
- for linked in dispatch.linked_target_listeners {
- unsafe { &mut *host_ptr }.remove_registered_event_listener_by_id(
- linked.target,
- &linked.event_type,
- linked.callback_id,
- linked.capture,
- );
- }
- for dependent_signal_id in dispatch.dependent_signals {
- let signal = unsafe { &mut *host_ptr }
+ for (signal_id, signal) in signals {
+ let dispatch = unsafe { &mut *host_ptr }
.native_bridge_mut()
.abort
- .signal_object(scope, dependent_signal_id);
- if let Some(signal) = signal {
- abort_signal(scope, signal, reason);
+ .take_signal_abort_steps(signal_id);
+ let Some(dispatch) = dispatch else {
+ continue;
+ };
+ event::invoke_abort_algorithms(scope, signal, reason, dispatch.algorithms);
+ for linked in dispatch.linked_target_listeners {
+ unsafe { &mut *host_ptr }.remove_registered_event_listener_by_id(
+ linked.target,
+ &linked.event_type,
+ linked.callback_id,
+ linked.capture,
+ );
}
+ // Snapshot listeners after earlier signals and abort algorithms.
+ abort_signal_events::dispatch_abort(scope, signal);
}
}
diff --git a/moli-renderer-v8/src/native_bridge/abort/statics.rs b/moli-renderer-v8/src/native_bridge/abort/statics.rs
index b62d7ad9a..3b8512b1b 100644
--- a/moli-renderer-v8/src/native_bridge/abort/statics.rs
+++ b/moli-renderer-v8/src/native_bridge/abort/statics.rs
@@ -110,14 +110,12 @@ pub(crate) fn abort_signal_any_callback<'s>(
return;
}
- for source_signal in signals {
- let Some(source_signal_id) = AbortStore::signal_id_from_object(scope, source_signal) else {
- continue;
- };
- host.native_bridge_mut()
- .abort
- .link_dependent_signal(source_signal_id, composite_signal_id);
- }
+ host.native_bridge_mut().abort.set_signal_sources(
+ composite_signal_id,
+ signals
+ .into_iter()
+ .filter_map(|signal| AbortStore::signal_id_from_object(scope, signal)),
+ );
rv.set(signal.into());
}
diff --git a/moli-renderer-v8/src/worker/abort.rs b/moli-renderer-v8/src/worker/abort.rs
index 503286ebc..eb34e1856 100644
--- a/moli-renderer-v8/src/worker/abort.rs
+++ b/moli-renderer-v8/src/worker/abort.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
use std::{cell::RefCell, rc::Rc};
use crate::exception_reporting::invoke_callback;
@@ -30,6 +30,8 @@ pub(super) struct WorkerAbortSignalState {
aborted: bool,
reason: Option<v8::Global<v8::Value>>,
abort_algorithms: Vec<v8::Global<v8::Function>>,
+ // None for a source; Some (including empty) for a dependent signal's ordered roots.
+ source_signals: Option<Vec<u32>>,
dependent_signals: Vec<u32>,
}
@@ -199,12 +201,34 @@ impl WorkerAbortStore {
true
}
- fn link_dependent_signal(&mut self, source_signal_id: u32, dependent_signal_id: u32) {
- let Some(state) = self.signal_state_mut(source_signal_id) else {
- return;
- };
- if !state.dependent_signals.contains(&dependent_signal_id) {
- state.dependent_signals.push(dependent_signal_id);
+ fn set_signal_sources(
+ &mut self,
+ dependent_signal_id: u32,
+ input_signal_ids: impl IntoIterator<Item = u32>,
+ ) {
+ let mut sources = Vec::new();
+ let mut seen = HashSet::new();
+ for input_signal_id in input_signal_ids {
+ let Some(state) = self.signal_state(input_signal_id) else {
+ continue;
+ };
+ let roots = state
+ .source_signals
+ .as_deref()
+ .unwrap_or(std::slice::from_ref(&input_signal_id));
+ for &source_signal_id in roots {
+ if seen.insert(source_signal_id) {
+ sources.push(source_signal_id);
+ }
+ }
+ }
+ for &source_signal_id in &sources {
+ if let Some(state) = self.signal_state_mut(source_signal_id) {
+ state.dependent_signals.push(dependent_signal_id);
+ }
+ }
+ if let Some(state) = self.signal_state_mut(dependent_signal_id) {
+ state.source_signals = Some(sources);
}
}
}
@@ -218,7 +242,7 @@ fn abort_worker_signal<'s>(
let Some(signal_id) = WorkerAbortStore::signal_id_from_object(scope, signal) else {
return;
};
- let Some((abort_algorithms, dependent_signals)) = ({
+ let signals_to_abort = {
let mut store = store.borrow_mut();
let Some(state) = store.signal_state_mut(signal_id) else {
return;
@@ -229,25 +253,50 @@ fn abort_worker_signal<'s>(
state.aborted = true;
state.reason = Some(v8::Global::new(scope, reason));
set_private_value(scope, signal, WORKER_ABORT_SIGNAL_REASON_SLOT, reason);
- let abort_algorithms = std::mem::take(&mut state.abort_algorithms);
- Some((abort_algorithms, state.dependent_signals.clone()))
- }) else {
- return;
+ let dependent_signals = state.dependent_signals.clone();
+
+ // Mark the complete dependency list before callbacks can reenter abort().
+ let mut signals_to_abort = vec![(signal_id, signal)];
+ for dependent_signal_id in dependent_signals {
+ let Some(state) = store.signal_state_mut(dependent_signal_id) else {
+ continue;
+ };
+ if state.aborted {
+ continue;
+ }
+ state.aborted = true;
+ state.reason = Some(v8::Global::new(scope, reason));
+ if let Some(signal) = &state.signal {
+ let signal = v8::Local::new(scope, signal);
+ set_private_value(scope, signal, WORKER_ABORT_SIGNAL_REASON_SLOT, reason);
+ signals_to_abort.push((dependent_signal_id, signal));
+ }
+ }
+ signals_to_abort
};
+ for (signal_id, signal) in signals_to_abort {
+ run_worker_abort_steps(store, scope, signal, signal_id, reason);
+ }
+}
+fn run_worker_abort_steps<'s>(
+ store: &Rc<RefCell<WorkerAbortStore>>,
+ scope: &mut v8::PinScope<'s, '_>,
+ signal: v8::Local<'s, v8::Object>,
+ signal_id: u32,
+ reason: v8::Local<'s, v8::Value>,
+) {
+ let abort_algorithms = {
+ let mut store = store.borrow_mut();
+ let Some(state) = store.signal_state_mut(signal_id) else {
+ return;
+ };
+ std::mem::take(&mut state.abort_algorithms)
+ };
reject_worker_fetches_for_signal(scope, signal_id, reason);
invoke_worker_abort_algorithms(scope, signal, reason, abort_algorithms);
+ // Snapshot listeners after earlier signals and abort algorithms.
abort_signal_events::dispatch_abort(scope, signal);
- for dependent_signal_id in dependent_signals {
- let dependent_signal = {
- let store = store.borrow();
- store.signal_object(scope, dependent_signal_id)
- };
- let Some(dependent_signal) = dependent_signal else {
- continue;
- };
- abort_worker_signal(store, scope, dependent_signal, reason);
- }
}
fn invoke_worker_abort_algorithms<'s>(
@@ -559,15 +608,12 @@ pub(crate) fn worker_abort_signal_any_callback<'s>(
rv.set(signal.into());
return;
}
- for source_signal in signals {
- let Some(source_signal_id) = WorkerAbortStore::signal_id_from_object(scope, source_signal)
- else {
- continue;
- };
- store
- .borrow_mut()
- .link_dependent_signal(source_signal_id, composite_signal_id);
- }
+ store.borrow_mut().set_signal_sources(
+ composite_signal_id,
+ signals
+ .into_iter()
+ .filter_map(|signal| WorkerAbortStore::signal_id_from_object(scope, signal)),
+ );
rv.set(signal.into());
}