mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 08:02:59 +00:00
fix(observers): preserve intersection notification ordering
Keep targets in observe() order across duplicates, unobserve/reobserve and DOM reordering. Remove targets without changing the relative order of survivors. Snapshot only the observer list when notifying. Drain each queue immediately before its callback so earlier callbacks and microtasks can takeRecords() or cancel pending observations. Revalidate Document and callback realm ownership between deliveries. Validation: fmt and workspace Clippy passed; Nextest 20,242 passed, 16 skipped. Original multiple-targets WPT passed 20/20 repetitions (baseline 2/20); 14 related WPT pages have no new failures. Shared behavior probes match Chromium.
This commit is contained in:
@@ -11,7 +11,7 @@ use super::{
|
||||
ObserverMutationPlan, ObserverStore, build_intersection_entries_array,
|
||||
build_mutation_records_array,
|
||||
callback::ObserverCallback,
|
||||
intersection, invoke_intersection_deliveries, invoke_mutation_deliveries,
|
||||
intersection, invoke_intersection_delivery, invoke_mutation_deliveries,
|
||||
node_is_intersection_root, node_is_intersection_target,
|
||||
schedule::{self, ObserverTask},
|
||||
target_is_intersection_observable,
|
||||
@@ -473,7 +473,25 @@ pub(crate) fn deliver_document_intersections(
|
||||
owner: WindowExecutionContextOwner,
|
||||
target: crate::native_bridge::WindowDocumentTaskTarget,
|
||||
) {
|
||||
let deliveries = ObserverHostAccess::new(host_ptr)
|
||||
.store(|store| store.collect_intersection_deliveries(scope, host_ptr, owner));
|
||||
invoke_intersection_deliveries(scope, host_ptr, target, deliveries);
|
||||
let mut access = ObserverHostAccess::new(host_ptr);
|
||||
let observers = access.store(|store| store.intersection_notification_observers(owner));
|
||||
for id in observers {
|
||||
if scope.is_execution_terminating()
|
||||
|| !access.read(|host| {
|
||||
host.window_document_owner_is_current_for_dispatch_scope(
|
||||
target.owner(),
|
||||
target.dispatch_scope(),
|
||||
)
|
||||
})
|
||||
{
|
||||
break;
|
||||
}
|
||||
// Snapshot the notification list, but drain each queue immediately
|
||||
// before its callback. Earlier callbacks and their microtasks can
|
||||
// takeRecords(), cancel targets, or retire an observer's realm.
|
||||
let delivery = access.store(|store| store.take_intersection_delivery(scope, host_ptr, id));
|
||||
if let Some(delivery) = delivery {
|
||||
invoke_intersection_delivery(scope, host_ptr, delivery);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -262,7 +262,8 @@ enum QueuedMutationRecordKind {
|
||||
struct IntersectionObserverState {
|
||||
observer: v8::Global<v8::Object>,
|
||||
callback: callback::ObserverCallback,
|
||||
// Preserve observation order; duplicate observe() leaves the position unchanged.
|
||||
// ObservationTargets is an ordered list; repeated observe() is a no-op,
|
||||
// and unobserve()/observe() moves only that target to the end.
|
||||
observed_targets: IndexSet<NativeNodeId>,
|
||||
queued_entries: Vec<QueuedIntersectionEntry>,
|
||||
last_reported_entries: HashMap<NativeNodeId, LastReportedIntersection>,
|
||||
@@ -634,39 +635,41 @@ impl ObserverStore {
|
||||
deliveries
|
||||
}
|
||||
|
||||
fn collect_intersection_deliveries<'s>(
|
||||
fn intersection_notification_observers(
|
||||
&self,
|
||||
owner: crate::native_bridge::WindowExecutionContextOwner,
|
||||
) -> Vec<u32> {
|
||||
let mut ids: Vec<_> = self
|
||||
.intersection_observers
|
||||
.iter()
|
||||
.filter_map(|(id, state)| {
|
||||
state
|
||||
.callback
|
||||
.observer_identity()
|
||||
.is_some_and(|identity| identity.owner() == owner)
|
||||
.then_some(*id)
|
||||
})
|
||||
.collect();
|
||||
ids.sort_unstable();
|
||||
ids
|
||||
}
|
||||
|
||||
fn take_intersection_delivery<'s>(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
owner: crate::native_bridge::WindowExecutionContextOwner,
|
||||
) -> Vec<IntersectionObserverDelivery<'s>> {
|
||||
let mut deliveries = Vec::new();
|
||||
let mut states: Vec<_> = self.intersection_observers.iter_mut().collect();
|
||||
states.sort_unstable_by_key(|(id, _)| **id);
|
||||
for (_, state) in states {
|
||||
if state
|
||||
.callback
|
||||
.observer_identity()
|
||||
.is_none_or(|identity| identity.owner() != owner)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if state.queued_entries.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let entries = mem::take(&mut state.queued_entries);
|
||||
let Some(callback) = state.callback.prepare(scope, host_ptr) else {
|
||||
continue;
|
||||
};
|
||||
let observer = v8::Local::new(scope, &state.observer);
|
||||
deliveries.push(IntersectionObserverDelivery {
|
||||
observer,
|
||||
callback,
|
||||
entries,
|
||||
options: state.options.clone(),
|
||||
});
|
||||
id: u32,
|
||||
) -> Option<IntersectionObserverDelivery<'s>> {
|
||||
let state = self.intersection_observers.get_mut(&id)?;
|
||||
if state.queued_entries.is_empty() {
|
||||
return None;
|
||||
}
|
||||
deliveries
|
||||
Some(IntersectionObserverDelivery {
|
||||
observer: v8::Local::new(scope, &state.observer),
|
||||
callback: state.callback.prepare(scope, host_ptr)?,
|
||||
entries: mem::take(&mut state.queued_entries),
|
||||
options: state.options.clone(),
|
||||
})
|
||||
}
|
||||
|
||||
fn retire_execution_context_owner(
|
||||
@@ -735,44 +738,31 @@ fn invoke_mutation_deliveries<'s>(
|
||||
}
|
||||
}
|
||||
|
||||
fn invoke_intersection_deliveries<'s>(
|
||||
fn invoke_intersection_delivery<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
target: crate::native_bridge::WindowDocumentTaskTarget,
|
||||
deliveries: Vec<IntersectionObserverDelivery<'s>>,
|
||||
delivery: IntersectionObserverDelivery<'s>,
|
||||
) {
|
||||
for delivery in deliveries {
|
||||
if scope.is_execution_terminating()
|
||||
|| !(unsafe { &*host_ptr }).window_document_owner_is_current_for_dispatch_scope(
|
||||
target.owner(),
|
||||
target.dispatch_scope(),
|
||||
)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if !delivery.callback.is_current(scope) {
|
||||
continue;
|
||||
}
|
||||
let callback_context = delivery.callback.relevant_context(scope);
|
||||
// Web IDL argument conversion uses the callback's relevant Realm,
|
||||
// which can differ from the observer's creation Realm. Enter it before
|
||||
// projecting native targets and binding the entry/rect/array wrappers.
|
||||
let entries = {
|
||||
let scope = &mut v8::ContextScope::new(scope, callback_context);
|
||||
build_intersection_entries_array(scope, host_ptr, &delivery.options, &delivery.entries)
|
||||
};
|
||||
let observer_value: v8::Local<'_, v8::Value> = delivery.observer.into();
|
||||
let execution_scope = crate::script_cleanup::ScriptExecutionScope::enter(scope);
|
||||
delivery.callback.invoke_and_report(
|
||||
scope,
|
||||
"intersectionobserver",
|
||||
"IntersectionObserver callback",
|
||||
observer_value,
|
||||
&[entries.into(), observer_value],
|
||||
);
|
||||
drop(execution_scope);
|
||||
crate::script_cleanup::perform_callback_cleanup_checkpoint(scope);
|
||||
if !delivery.callback.is_current(scope) {
|
||||
return;
|
||||
}
|
||||
let callback_context = delivery.callback.relevant_context(scope);
|
||||
// Web IDL entry conversion belongs to the callback's relevant Realm.
|
||||
let entries = {
|
||||
let scope = &mut v8::ContextScope::new(scope, callback_context);
|
||||
build_intersection_entries_array(scope, host_ptr, &delivery.options, &delivery.entries)
|
||||
};
|
||||
let observer_value: v8::Local<'_, v8::Value> = delivery.observer.into();
|
||||
let execution_scope = crate::script_cleanup::ScriptExecutionScope::enter(scope);
|
||||
delivery.callback.invoke_and_report(
|
||||
scope,
|
||||
"intersectionobserver",
|
||||
"IntersectionObserver callback",
|
||||
observer_value,
|
||||
&[entries.into(), observer_value],
|
||||
);
|
||||
drop(execution_scope);
|
||||
crate::script_cleanup::perform_callback_cleanup_checkpoint(scope);
|
||||
}
|
||||
|
||||
impl MutationObserverState {
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn intersection_observer_queues_preserve_target_order_and_reentrant_operations() {
|
||||
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://intersection-queues.test/");
|
||||
let count: usize = vm
|
||||
.eval(include_str!(
|
||||
"../../../tests/fixtures/intersection-observer-queues.js"
|
||||
))
|
||||
.unwrap()
|
||||
.parse()
|
||||
.unwrap();
|
||||
assert_eq!(count, 2);
|
||||
for index in 0..count {
|
||||
let name = vm
|
||||
.eval(&format!("__intersectionQueues.start({index})"))
|
||||
.unwrap();
|
||||
vm.advance_timers_until_deadline_for_test(&loader)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
vm.eval("__intersectionQueues.result").unwrap(),
|
||||
vm.eval("__intersectionQueues.expected").unwrap(),
|
||||
"{name}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn intersection_observer_rechecks_document_and_callback_realm_between_deliveries() {
|
||||
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://intersection-document.test/");
|
||||
vm.eval(
|
||||
r#"
|
||||
const target = document.body.appendChild(document.createElement('div'));
|
||||
target.style.cssText = 'width:20px;height:20px';
|
||||
globalThis.log = [];
|
||||
let phase = 'old';
|
||||
const first = new IntersectionObserver(() => {
|
||||
log.push('first');
|
||||
first.disconnect();
|
||||
document.open();
|
||||
document.write('<!doctype html><p>replacement</p>');
|
||||
document.close();
|
||||
requestAnimationFrame(() => { phase = 'new'; log.push('frame'); });
|
||||
});
|
||||
const second = new IntersectionObserver(() => {
|
||||
log.push('second:' + phase);
|
||||
second.disconnect();
|
||||
});
|
||||
first.observe(target);
|
||||
second.observe(target);
|
||||
"#,
|
||||
)
|
||||
.unwrap();
|
||||
vm.advance_timers_until_deadline_for_test(&loader)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(vm.eval("log.join('|')").unwrap(), "first|frame|second:new");
|
||||
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://intersection-realm.test/");
|
||||
vm.eval(
|
||||
"globalThis.frame = document.body.appendChild(document.createElement('iframe')); void 0",
|
||||
)
|
||||
.unwrap();
|
||||
vm.advance_timers_until_deadline_for_test(&loader)
|
||||
.await
|
||||
.unwrap();
|
||||
vm.eval(
|
||||
r#"
|
||||
const child = frame.contentWindow;
|
||||
const target = document.body.appendChild(document.createElement('div'));
|
||||
target.style.cssText = 'width:20px;height:20px';
|
||||
globalThis.log = [];
|
||||
const first = new IntersectionObserver(() => {
|
||||
log.push('first');
|
||||
first.disconnect();
|
||||
frame.remove();
|
||||
});
|
||||
const retired = new IntersectionObserver(child.Function("parent.log.push('retired')"));
|
||||
const surviving = new IntersectionObserver(() => {
|
||||
log.push('surviving');
|
||||
surviving.disconnect();
|
||||
});
|
||||
first.observe(target);
|
||||
retired.observe(target);
|
||||
surviving.observe(target);
|
||||
"#,
|
||||
)
|
||||
.unwrap();
|
||||
vm.advance_timers_until_deadline_for_test(&loader)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(vm.eval("log.join('|')").unwrap(), "first|surviving");
|
||||
}
|
||||
@@ -2391,6 +2391,7 @@ mod import_meta;
|
||||
mod indexed_db;
|
||||
mod indexed_db_gc;
|
||||
mod inspector_unwrap;
|
||||
mod intersection_observers;
|
||||
mod javascript_url_origin;
|
||||
mod joint_history;
|
||||
mod lazy_storage;
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
(() => {
|
||||
const cases = [
|
||||
{
|
||||
name: 'observation order survives duplicates, removals, DOM reordering and disconnect',
|
||||
expected: '8,3,10,0,9,2,11,1,6,4,7,5:111111111111|8,10,0,9,2,11,1,4,7,5,3,6:000000000000|8,10,0,9,2,11,1,4,7,5,3,6:111111111111|6,8,0:111',
|
||||
run: () => new Promise(resolve => {
|
||||
const targets = Array.from({length: 12}, (_, index) => {
|
||||
const target = document.body.appendChild(document.createElement('div'));
|
||||
target.id = String(index);
|
||||
target.style.cssText = 'width:20px;height:20px';
|
||||
return target;
|
||||
});
|
||||
const log = [];
|
||||
const observer = new IntersectionObserver(entries => {
|
||||
log.push(entries.map(entry => entry.target.id).join(',') + ':' +
|
||||
entries.map(entry => Number(entry.isIntersecting)).join(''));
|
||||
if (log.length === 1) {
|
||||
targets.forEach(target => { target.style.display = 'none'; });
|
||||
observer.unobserve(targets[3]);
|
||||
observer.unobserve(targets[6]);
|
||||
observer.observe(targets[3]);
|
||||
observer.observe(targets[6]);
|
||||
} else if (log.length === 2) {
|
||||
document.body.prepend(targets[5]);
|
||||
targets.forEach(target => { target.style.display = 'block'; });
|
||||
observer.observe(targets[8]);
|
||||
observer.observe(targets[6]);
|
||||
} else if (log.length === 3) {
|
||||
observer.disconnect();
|
||||
[6, 8, 0].forEach(index => observer.observe(targets[index]));
|
||||
} else {
|
||||
observer.disconnect();
|
||||
resolve(log.join('|'));
|
||||
}
|
||||
});
|
||||
[8, 3, 10, 0, 9, 2, 11, 1, 6, 4, 7, 5].forEach(index => observer.observe(targets[index]));
|
||||
observer.observe(targets[3]);
|
||||
})
|
||||
},
|
||||
{
|
||||
name: 'callbacks honor pending queue reads and cancellation for later observers',
|
||||
expected: 'own:0|drain:b,a,c|unobserve-drain:a,c|disconnect-drain:|microtask-drain:b,a,c|unobserve:a,c|later:1:b,a,c',
|
||||
run: () => new Promise(resolve => {
|
||||
const targets = ['a', 'b', 'c'].map(id => {
|
||||
const target = document.body.appendChild(document.createElement('div'));
|
||||
target.id = id;
|
||||
target.style.cssText = 'width:20px;height:20px';
|
||||
return target;
|
||||
});
|
||||
const ids = entries => entries.map(entry => entry.target.id).join(',');
|
||||
const log = [];
|
||||
const subjects = [];
|
||||
let frame = 0;
|
||||
const controller = new IntersectionObserver(() => {
|
||||
log.push('own:' + controller.takeRecords().length);
|
||||
controller.disconnect();
|
||||
for (const [mode, observer] of subjects) {
|
||||
// Preserve Moli's existing cancellation behavior, also used by
|
||||
// Chromium; the spec discussion remains open in IO issue #356.
|
||||
if (mode.startsWith('unobserve')) observer.unobserve(targets[1]);
|
||||
if (mode.startsWith('disconnect')) observer.disconnect();
|
||||
if (mode === 'microtask-drain') {
|
||||
queueMicrotask(() => log.push(mode + ':' + ids(observer.takeRecords())));
|
||||
} else if (mode.includes('drain')) {
|
||||
log.push(mode + ':' + ids(observer.takeRecords()));
|
||||
}
|
||||
}
|
||||
const later = new IntersectionObserver(entries => {
|
||||
log.push('later:' + frame + ':' + ids(entries));
|
||||
later.disconnect();
|
||||
});
|
||||
[1, 0, 2].forEach(index => later.observe(targets[index]));
|
||||
requestAnimationFrame(() => {
|
||||
frame = 1;
|
||||
requestAnimationFrame(() => {
|
||||
subjects.forEach(([, observer]) => observer.disconnect());
|
||||
later.disconnect();
|
||||
resolve(log.join('|'));
|
||||
});
|
||||
});
|
||||
});
|
||||
for (const mode of ['drain', 'microtask-drain', 'unobserve-drain', 'disconnect-drain', 'unobserve', 'disconnect']) {
|
||||
const observer = new IntersectionObserver(entries => {
|
||||
log.push(mode + ':' + ids(entries));
|
||||
observer.disconnect();
|
||||
});
|
||||
subjects.push([mode, observer]);
|
||||
[1, 0, 2].forEach(index => observer.observe(targets[index]));
|
||||
}
|
||||
controller.observe(targets[0]);
|
||||
})
|
||||
}
|
||||
];
|
||||
globalThis.__intersectionQueues = {
|
||||
result: null,
|
||||
expected: null,
|
||||
start(index) {
|
||||
document.body.replaceChildren();
|
||||
const test = cases[index];
|
||||
this.result = null;
|
||||
this.expected = test.expected;
|
||||
test.run().then(result => { this.result = result; });
|
||||
return test.name;
|
||||
},
|
||||
snapshot() {
|
||||
return {actual: this.result, expected: this.expected};
|
||||
}
|
||||
};
|
||||
return cases.length;
|
||||
})();
|
||||
Reference in New Issue
Block a user