From db980fc347723dee7fd456dff83e3d5e474bdec8 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 26 Sep 2026 21:07:34 +0800 Subject: [PATCH] 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. --- .../src/observer_runtime/dom_access.rs | 26 +++- moli-renderer-v8/src/observer_runtime/mod.rs | 118 ++++++++---------- .../script_vm/tests/intersection_observers.rs | 96 ++++++++++++++ moli-renderer-v8/src/script_vm/tests/mod.rs | 1 + .../fixtures/intersection-observer-queues.js | 110 ++++++++++++++++ 5 files changed, 283 insertions(+), 68 deletions(-) create mode 100644 moli-renderer-v8/src/script_vm/tests/intersection_observers.rs create mode 100644 moli-renderer-v8/tests/fixtures/intersection-observer-queues.js diff --git a/moli-renderer-v8/src/observer_runtime/dom_access.rs b/moli-renderer-v8/src/observer_runtime/dom_access.rs index f1c539a61df..4792c9ddaae 100644 --- a/moli-renderer-v8/src/observer_runtime/dom_access.rs +++ b/moli-renderer-v8/src/observer_runtime/dom_access.rs @@ -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); + } + } } diff --git a/moli-renderer-v8/src/observer_runtime/mod.rs b/moli-renderer-v8/src/observer_runtime/mod.rs index b0bf4e13f68..fa1e99e52bd 100644 --- a/moli-renderer-v8/src/observer_runtime/mod.rs +++ b/moli-renderer-v8/src/observer_runtime/mod.rs @@ -262,7 +262,8 @@ enum QueuedMutationRecordKind { struct IntersectionObserverState { observer: v8::Global, 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, queued_entries: Vec, last_reported_entries: HashMap, @@ -634,39 +635,41 @@ impl ObserverStore { deliveries } - fn collect_intersection_deliveries<'s>( + fn intersection_notification_observers( + &self, + owner: crate::native_bridge::WindowExecutionContextOwner, + ) -> Vec { + 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> { - 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> { + 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>, + 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 { diff --git a/moli-renderer-v8/src/script_vm/tests/intersection_observers.rs b/moli-renderer-v8/src/script_vm/tests/intersection_observers.rs new file mode 100644 index 00000000000..359636f311b --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/intersection_observers.rs @@ -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('

replacement

'); + 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"); +} diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 9c7fcdb5697..44bb510e077 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -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; diff --git a/moli-renderer-v8/tests/fixtures/intersection-observer-queues.js b/moli-renderer-v8/tests/fixtures/intersection-observer-queues.js new file mode 100644 index 00000000000..ef8d7fbead7 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/intersection-observer-queues.js @@ -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; +})();