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; +})();