From ca5162732a143a0f7a67a1ff657a2b930b9cbaae Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 26 Sep 2026 20:46:44 +0800 Subject: [PATCH] fix(observers): align notifications with document rendering Run ResizeObserver after animation callbacks using depth-limited broadcasts and freshly published layout, then apply focus fixup and sample intersections. Deliver IntersectionObserver callbacks in a separate exact-Document task. Preserve constructor order and active observer lifetime in the native registry; validate Document and realm ownership across callbacks and bound reentrant work. Sample padding, logical axes, inline boxes and device-pixel zoom from frozen layout, including iframe geometry, and wake rendering after CSSOM changes. Validation: fmt and workspace Clippy passed; Nextest 20,240 passed, 16 skipped. Selected ResizeObserver WPT: 7 pages / 46 subtests passed. 153 original WPT pages have no new failures; focus and navigation probes passed 31 and 152 cases. --- .../intersection_observer_root_scope.html | 8 +- .../intersection_observer_thresholds.html | 52 +-- moli-core/tests/web_apis.rs | 17 +- moli-layout/src/layout_tree/pass_result.rs | 1 + moli-layout/src/layout_tree/query.rs | 16 + moli-layout/src/layout_tree/source_query.rs | 24 ++ moli-layout/src/lib.rs | 11 +- .../src/common_runtime/callback_registry.rs | 111 +++++- moli-renderer-v8/src/context_bootstrap.rs | 5 +- .../css_stylesheet_runtime/style_sheet.rs | 4 + .../resize_observer_runtime.rs | 346 +++++++---------- .../resize_observer_runtime/delivery.rs | 195 ++++++++++ .../src/context_bootstrap/shared/slots.rs | 7 +- .../context_host/animation_frames.rs | 97 ++++- .../context_host/layout_snapshot.rs | 6 +- .../context_host/rendering_updates.rs | 44 ++- .../document/css_state/accessors.rs | 2 + .../element/geometry/mock/queries.rs | 6 + .../element/shadow_dom/root_accessors.rs | 1 + .../src/observer_runtime/callback.rs | 4 + .../src/observer_runtime/dom_access.rs | 204 ++++++---- .../src/observer_runtime/intersection.rs | 12 +- moli-renderer-v8/src/observer_runtime/mod.rs | 86 ++--- .../src/observer_runtime/schedule.rs | 32 -- .../src/page_task_queue/rendering_update.rs | 1 + .../runtime/tests/extracted/input_dispatch.rs | 20 +- .../script_vm/dom_heavy_regression_tests.rs | 204 ++++++---- moli-renderer-v8/src/script_vm/layout.rs | 49 ++- .../src/script_vm/rendering_update.rs | 114 +++++- .../extracted/geometry_and_scrolling.rs | 181 ++++----- moli-renderer-v8/src/script_vm/tests/mod.rs | 1 + .../src/script_vm/tests/observer_callbacks.rs | 101 +++-- .../script_vm/tests/rendering_observers.rs | 357 ++++++++++++++++++ .../byte_streams_and_observers.rs | 71 ++-- moli-renderer-v8/src/v8_execution_watchdog.rs | 6 +- moli-webapi/src/resize_observer_entry.rs | 2 +- 36 files changed, 1729 insertions(+), 669 deletions(-) create mode 100644 moli-renderer-v8/src/context_bootstrap/resize_observer_runtime/delivery.rs create mode 100644 moli-renderer-v8/src/script_vm/tests/rendering_observers.rs diff --git a/moli-core/tests/fixtures/runtime/intersection_observer_root_scope.html b/moli-core/tests/fixtures/runtime/intersection_observer_root_scope.html index 76691dafbbc..d810a20a040 100644 --- a/moli-core/tests/fixtures/runtime/intersection_observer_root_scope.html +++ b/moli-core/tests/fixtures/runtime/intersection_observer_root_scope.html @@ -13,15 +13,13 @@ let seen = []; const observer = new IntersectionObserver((entries) => { seen = seen.concat(entries.map((entry) => entry.target.id)); + window.intersectionObserverRootScopedIds = seen.join(','); + window.intersectionObserverRootScopedCount = seen.length; + observer.disconnect(); }, { root }); observer.observe(outside); observer.observe(inside); - - setTimeout(() => { - window.intersectionObserverRootScopedIds = seen.join(','); - window.intersectionObserverRootScopedCount = seen.length; - }, 0); diff --git a/moli-core/tests/fixtures/runtime/intersection_observer_thresholds.html b/moli-core/tests/fixtures/runtime/intersection_observer_thresholds.html index 72f96f69e7a..5d551002d49 100644 --- a/moli-core/tests/fixtures/runtime/intersection_observer_thresholds.html +++ b/moli-core/tests/fixtures/runtime/intersection_observer_thresholds.html @@ -9,22 +9,19 @@ const observer = new IntersectionObserver((entries) => { const entry = entries[0]; capture.push(`${entry.isIntersecting}:${entry.intersectionRatio}`); + if (capture.length === 1) { + target.remove(); + } else if (capture.length === 2) { + document.body.appendChild(target); + } else { + window.intersectionThresholdCapture = capture.join("|"); + window.intersectionThresholdCount = capture.length; + observer.disconnect(); + } }, { threshold: [0, 1] }); observer.observe(target); - setTimeout(() => { - target.remove(); - setTimeout(() => { - document.body.appendChild(target); - setTimeout(() => { - window.intersectionThresholdCapture = capture.join("|"); - window.intersectionThresholdCount = capture.length; - observer.disconnect(); - }, 0); - }, 0); - }, 0); - const burstRoot = document.createElement("div"); burstRoot.setAttribute("style", "width: 100px; height: 100px; overflow: hidden"); const burstTarget = document.createElement("div"); @@ -32,23 +29,28 @@ burstRoot.appendChild(burstTarget); document.body.appendChild(burstRoot); - const burstObserver = new IntersectionObserver(() => {}, { + let burstCallbacks = 0; + const burstObserver = new IntersectionObserver(() => { + burstCallbacks++; + if (burstCallbacks !== 1) return; + // Removing and reinserting within one callback does not create an + // intermediate intersection observation before the next rendering update. + burstTarget.remove(); + burstRoot.appendChild(burstTarget); + requestAnimationFrame(() => requestAnimationFrame(() => { + const burstRecords = burstObserver.takeRecords(); + window.intersectionThresholdBurstCount = burstRecords.length; + window.intersectionThresholdBurstCapture = Array.from(burstRecords) + .map(entry => `${entry.isIntersecting}:${entry.intersectionRatio > 0}`) + .join("|"); + window.intersectionThresholdBurstCallbackCount = burstCallbacks; + burstObserver.disconnect(); + })); + }, { root: burstRoot, threshold: [0.5], }); burstObserver.observe(burstTarget); - - setTimeout(() => { - burstTarget.remove(); - burstRoot.appendChild(burstTarget); - - const burstRecords = burstObserver.takeRecords(); - window.intersectionThresholdBurstCount = burstRecords.length; - window.intersectionThresholdBurstCapture = Array.from(burstRecords) - .map(entry => `${entry.isIntersecting}:${entry.intersectionRatio > 0}`) - .join("|"); - burstObserver.disconnect(); - }, 0); diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rs index 103e479dce5..a33d94f0a36 100644 --- a/moli-core/tests/web_apis.rs +++ b/moli-core/tests/web_apis.rs @@ -1495,6 +1495,13 @@ async fn secondary_webapis_cover_file_file_list_and_resize_observer_basics() -> page.finish_capture_screenshot(captured)?; page.evaluate_runtime_expression_async("runGeometryProbe()") .await?; + browser + .wait_for_script_truthy( + &mut page, + "document.body.getAttribute('data-resize-target') === 'true'", + Duration::from_secs(2), + ) + .await?; assert!( page.serialize_html_async() @@ -6138,7 +6145,7 @@ async fn intersection_observer_threshold_crossings_report_exit_and_reentry() -> browser .wait_for_script_truthy( &mut page, - "globalThis.intersectionThresholdCount === 3 && globalThis.intersectionThresholdBurstCount === 2", + "globalThis.intersectionThresholdCount === 3 && globalThis.intersectionThresholdBurstCount === 0", Duration::from_secs(2), ) .await?; @@ -6153,11 +6160,15 @@ async fn intersection_observer_threshold_crossings_report_exit_and_reentry() -> ); assert_eq!( diagnostic_global(&page, "intersectionThresholdBurstCount"), - Some(&JsValueSnapshot::Number(2.0)) + Some(&JsValueSnapshot::Number(0.0)) ); assert_eq!( diagnostic_global(&page, "intersectionThresholdBurstCapture"), - Some(&JsValueSnapshot::String("false:false|true:true".to_owned())) + Some(&JsValueSnapshot::String(String::new())) + ); + assert_eq!( + diagnostic_global(&page, "intersectionThresholdBurstCallbackCount"), + Some(&JsValueSnapshot::Number(1.0)) ); server.shutdown().await; diff --git a/moli-layout/src/layout_tree/pass_result.rs b/moli-layout/src/layout_tree/pass_result.rs index 72c12dbf429..d0df64a5e0e 100644 --- a/moli-layout/src/layout_tree/pass_result.rs +++ b/moli-layout/src/layout_tree/pass_result.rs @@ -27,6 +27,7 @@ pub enum LayoutFlushReason { Print, Explicit, SynchronousGeometry, + RenderingUpdate, Test, } diff --git a/moli-layout/src/layout_tree/query.rs b/moli-layout/src/layout_tree/query.rs index be9234a2d25..38cf1522875 100644 --- a/moli-layout/src/layout_tree/query.rs +++ b/moli-layout/src/layout_tree/query.rs @@ -44,6 +44,9 @@ pub struct LayoutDocumentMetrics { /// second time. #[derive(Clone, Debug, PartialEq)] pub struct LayoutElementMetrics { + /// None for non-replaced inline boxes. These report zero ResizeObserver + /// sizes even when CSSOM offset geometry includes their line fragments. + pub resize_observer_box: Option, pub offset_parent: Option, pub offset_position: LayoutPoint, /// Border-box origin in viewport CSS pixels after layout placement and @@ -86,6 +89,19 @@ pub struct LayoutResizeObserverMetrics { pub border_box_size: LayoutResizeObserverSize, } +/// ResizeObserver's box interpretation sampled from the same immutable +/// geometry as ordinary CSSOM metrics, without consulting live style. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct LayoutResizeObserverBox { + /// Physical content dimensions, positioned at the used left/top padding. + pub content_rect: super::model::LayoutRect, + pub border_size: LayoutSize, + pub horizontal: bool, + /// CSS zoom is excluded from CSS-pixel box sizes, but participates in + /// device-pixel observations alongside the viewport's device pixel ratio. + pub effective_zoom: f32, +} + /// One scroll container on a target's layout ancestor chain. #[derive(Clone, Debug, PartialEq)] pub struct LayoutScrollContainerMetrics { diff --git a/moli-layout/src/layout_tree/source_query.rs b/moli-layout/src/layout_tree/source_query.rs index ad18f64f7de..631ba0ab6b9 100644 --- a/moli-layout/src/layout_tree/source_query.rs +++ b/moli-layout/src/layout_tree/source_query.rs @@ -251,6 +251,30 @@ where )) }; Some(LayoutElementMetrics { + resize_observer_box: self.boxes.get(box_id.index())?.css_sizing.map(|sizing| { + let size = unzoom.size(LayoutSize::new( + geometry.content_box.width, + geometry.content_box.height, + )); + let offset = unzoom.point(LayoutPoint::new( + geometry.content_box.x - geometry.padding_box.x, + geometry.content_box.y - geometry.padding_box.y, + )); + super::query::LayoutResizeObserverBox { + content_rect: super::model::LayoutRect::new( + offset.x, + offset.y, + size.width, + size.height, + ), + border_size: unzoom.size(LayoutSize::new( + geometry.border_box.width, + geometry.border_box.height, + )), + horizontal: sizing.horizontal, + effective_zoom: geometry.effective_zoom, + } + }), offset_parent, offset_position: unzoom.point(LayoutPoint::new( layout_origin.x - offset_parent_origin.x, diff --git a/moli-layout/src/lib.rs b/moli-layout/src/lib.rs index 5959383e59d..3d9af59caec 100644 --- a/moli-layout/src/lib.rs +++ b/moli-layout/src/lib.rs @@ -60,11 +60,12 @@ pub use layout_tree::{ LayoutFragmentBoxModel, LayoutFragmentId, LayoutFragmentKind, LayoutHit, LayoutIntersectionGeometry, LayoutNodeOutput, LayoutObjectGeometry, LayoutOutputBoxId, LayoutPaintedSurfaceHit, LayoutPassMetrics, LayoutPassResult, LayoutPoint, LayoutQuad, - LayoutQuery, LayoutQueryAnswer, LayoutQueryBatch, LayoutRect, LayoutResizeObserverMetrics, - LayoutResizeObserverSize, LayoutResolvedGridTrackList, LayoutResolvedGridTracks, - LayoutScrollContainerMetrics, LayoutScrollExtent, LayoutScrollIntoViewGeometry, LayoutSize, - LayoutTransform2D, LayoutTreeRetentionMetrics, LayoutUsedSize, LayoutViewport, - MAX_RETAINED_LAYOUT_BOXES, MAX_RETAINED_LAYOUT_FRAGMENTS, MAX_RETAINED_LAYOUT_TREE_BYTES, + LayoutQuery, LayoutQueryAnswer, LayoutQueryBatch, LayoutRect, LayoutResizeObserverBox, + LayoutResizeObserverMetrics, LayoutResizeObserverSize, LayoutResolvedGridTrackList, + LayoutResolvedGridTracks, LayoutScrollContainerMetrics, LayoutScrollExtent, + LayoutScrollIntoViewGeometry, LayoutSize, LayoutTransform2D, LayoutTreeRetentionMetrics, + LayoutUsedSize, LayoutViewport, MAX_RETAINED_LAYOUT_BOXES, MAX_RETAINED_LAYOUT_FRAGMENTS, + MAX_RETAINED_LAYOUT_TREE_BYTES, }; pub use list::{ListCounter, list_marker_text}; pub use normalize::{NormalizedBoxNode, NormalizedBoxTree, NormalizedFormattingContext}; diff --git a/moli-renderer-v8/src/common_runtime/callback_registry.rs b/moli-renderer-v8/src/common_runtime/callback_registry.rs index 01327101188..441d62b33fe 100644 --- a/moli-renderer-v8/src/common_runtime/callback_registry.rs +++ b/moli-renderer-v8/src/common_runtime/callback_registry.rs @@ -158,9 +158,10 @@ struct CallbackRegistryState { // Activation order is distinct from construction order. Disconnect // removes the root; observing again appends it to the registered set. active: IndexMap>>, + active_resize: HashMap>>, } -/// A weak identity table plus the explicitly active PerformanceObserver roots. +/// A weak identity table plus the explicitly active observer roots. /// Callback values remain V8-traced. Native finalizers use a weak reference to /// this table, avoiding raw host pointers and independent callback GC roots. #[derive(Default)] @@ -233,7 +234,11 @@ impl CallbackRegistry { if let Some(state) = state.upgrade() { let retired = { let mut state = state.borrow_mut(); - (state.bindings.remove(&id), state.active.shift_remove(&id)) + ( + state.bindings.remove(&id), + state.active.shift_remove(&id), + state.active_resize.remove(&id), + ) }; drop(retired); } @@ -312,6 +317,99 @@ impl CallbackRegistry { .map(|execution| execution.with_resource_initiator(initiator)) } + pub(crate) fn activate_resize_observer( + &self, + scope: &mut v8::PinScope<'_, '_>, + id: CallbackRegistrationId, + observer: v8::Local<'_, v8::Object>, + ) -> Option { + let binding = self.lookup( + scope, + id, + observer, + CallbackRegistrationKind::ResizeObserver, + )?; + if !binding.is_current(scope) { + return None; + } + let identity = binding.window_identities()[0]?; + let root = Rc::new(v8::Global::new(scope, observer)); + { + let mut state = self.state.borrow_mut(); + if !state.bindings.contains_key(&id) { + return None; + } + state + .active_resize + .entry(id) + .or_insert_with(|| Rc::clone(&root)); + } + Some(identity) + } + + pub(crate) fn deactivate_resize_observer(&self, id: CallbackRegistrationId) { + let retired = self.state.borrow_mut().active_resize.remove(&id); + drop(retired); + } + + pub(crate) fn active_resize_observers<'s>( + &self, + scope: &mut v8::PinScope<'s, '_>, + owner: Option, + ) -> Vec> { + let mut registrations: Vec<_> = { + let state = self.state.borrow(); + state + .active_resize + .iter() + .filter_map(|(id, root)| { + Some((*id, Rc::clone(root), state.bindings.get(id)?.clone())) + }) + .collect() + }; + registrations.sort_unstable_by_key(|(id, _, _)| id.as_u32()); + registrations + .into_iter() + .filter_map(|(_, root, binding)| { + let identity = binding.window_identities()[0]?; + if owner.is_some_and(|owner| owner != identity.owner()) + || !binding.is_current(scope) + { + return None; + } + Some(v8::Local::new(scope, root.as_ref())) + }) + .collect() + } + + pub(crate) fn resize_observer_identities(&self) -> Vec { + let bindings: Vec<_> = { + let state = self.state.borrow(); + state + .active_resize + .keys() + .filter_map(|id| state.bindings.get(id).cloned()) + .collect() + }; + let mut identities = Vec::new(); + for binding in bindings { + let Some(host_ptr) = binding.execution.window_host_ptr() else { + continue; + }; + let [Some(observer), Some(callback)] = binding.window_identities() else { + continue; + }; + let host = unsafe { &*host_ptr }; + if host.window_execution_context_identity_is_current(observer) + && host.window_execution_context_identity_is_current(callback) + && !identities.contains(&observer) + { + identities.push(observer); + } + } + identities + } + pub(crate) fn activate_performance_observer( &self, scope: &mut v8::PinScope<'_, '_>, @@ -392,7 +490,13 @@ impl CallbackRegistry { .filter_map(|(id, binding)| retire(binding).then_some(*id)) .collect(); ids.into_iter() - .map(|id| (state.bindings.remove(&id), state.active.shift_remove(&id))) + .map(|id| { + ( + state.bindings.remove(&id), + state.active.shift_remove(&id), + state.active_resize.remove(&id), + ) + }) .collect::>() }; retired.len() @@ -404,6 +508,7 @@ impl CallbackRegistry { ( std::mem::take(&mut state.bindings), std::mem::take(&mut state.active), + std::mem::take(&mut state.active_resize), ) }; drop(retired); diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 63b87998216..69addff0121 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -163,7 +163,10 @@ pub(crate) use range_algorithms::{ mod range_live; mod range_surface; mod resize_observer_runtime; -pub(crate) use resize_observer_runtime::queue_resize_observer_checks; +pub(crate) use resize_observer_runtime::{ + broadcast_document_resize_observers, queue_resize_observer_checks, + report_document_resize_observer_loop_error, +}; mod runtime_state; mod selection; mod selection_callbacks; diff --git a/moli-renderer-v8/src/context_bootstrap/css_stylesheet_runtime/style_sheet.rs b/moli-renderer-v8/src/context_bootstrap/css_stylesheet_runtime/style_sheet.rs index ecc691dba76..c420a37124d 100644 --- a/moli-renderer-v8/src/context_bootstrap/css_stylesheet_runtime/style_sheet.rs +++ b/moli-renderer-v8/src/context_bootstrap/css_stylesheet_runtime/style_sheet.rs @@ -853,6 +853,7 @@ pub(crate) fn sync_document_adopted_style_sheet_installations<'s>( let installations = adopted_style_sheet_installations_from_value(scope, sheets.into()); unsafe { &mut *host_ptr } .set_document_adopted_style_sheet_installations(style_document, installations); + crate::observer_runtime::queue_style_rendering_update(scope, host_ptr); crate::native_bridge::document::sync_document_fonts_for_handle( scope, unsafe { &*host_ptr }, @@ -872,6 +873,7 @@ pub(crate) fn sync_shadow_root_adopted_style_sheet_installations<'s>( let installations = adopted_style_sheet_installations_from_value(scope, sheets.into()); unsafe { &mut *host_ptr } .set_shadow_root_adopted_style_sheet_installations(root, installations); + crate::observer_runtime::queue_style_rendering_update(scope, host_ptr); } pub(crate) fn sync_css_style_sheet_change<'s>( @@ -911,6 +913,7 @@ fn notify_live_css_style_sheet_change<'s>( return; }; unsafe { &mut *host_ptr }.note_owner_live_stylesheet_mutation(owner, stylesheet.id()); + crate::observer_runtime::queue_style_rendering_update(scope, host_ptr); } pub(crate) fn sync_adopted_style_sheet_installations_for_sheet<'s>( @@ -1210,6 +1213,7 @@ fn notify_css_style_sheet_runtime_state_change<'s>( }; let stylesheet_id = require_css_style_sheet_live_stylesheet(scope, sheet).id(); unsafe { &mut *host_ptr }.note_owner_live_stylesheet_runtime_state_change(owner, stylesheet_id); + crate::observer_runtime::queue_style_rendering_update(scope, host_ptr); } pub(crate) fn css_import_rule_style_sheet_getter_callback<'s>( diff --git a/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs index 4db1e943c36..54946b556a8 100644 --- a/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs +++ b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs @@ -1,10 +1,14 @@ use super::*; +mod delivery; use crate::common_runtime::{ CallbackRegistrationId, CallbackRegistrationKind, CallbackResidence, CommonRuntimeState, }; use crate::util::{get_private_value, serialize_v8_iter_array, set_private_value}; use crate::web_api_interfaces; use crate::webidl; +pub(crate) use delivery::{ + broadcast_document_resize_observers, report_document_resize_observer_loop_error, +}; use entry::ResizeObserverEntryData; pub(super) use entry::install_resize_observer_entry_template_bindings; use moli_webapi::resize_observer_entry as entry; @@ -51,8 +55,8 @@ struct ResizeObserverObjectDeclaration<'s> { targets: (), #[webapi(slot = RESIZE_OBSERVER_PENDING_TARGETS_SLOT, init = "array")] pending_targets: (), - #[webapi(slot = RESIZE_OBSERVER_SCHEDULED_SLOT, init = false)] - scheduled: (), + #[webapi(slot = RESIZE_OBSERVER_DELIVERY_ACTIVE_SLOT)] + delivery_active: bool, } #[derive(WebApiObject)] @@ -127,6 +131,7 @@ pub(super) fn resize_observer_constructor_callback<'s>( callback, relevant_global, incumbent_global, + false, ) .initialize(scope, args.this()) .expect("ResizeObserver declaration should initialize object"); @@ -145,32 +150,35 @@ pub(super) fn resize_observer_observe_callback<'s>( rv.set_undefined(); return; }; - let record = if let Some(existing_index) = - observed_record_index(scope, targets, parsed.target.into()) + if let Some(index) = observed_record_index(scope, targets, parsed.target.into()) + && let Some(value) = targets.get_index(scope, index) + && let Ok(record) = v8::Local::::try_from(value) + && observed_record_box(scope, record) == Some(parsed.options.observed_box) { - let record = targets - .get_index(scope, existing_index) - .and_then(|value| v8::Local::::try_from(value).ok()); - if let Some(record) = record { - set_observed_record_box(scope, record, parsed.options.observed_box); - record - } else { - let record = build_observed_record(scope, parsed.target, parsed.options.observed_box); - let _ = targets.set_index(scope, existing_index, record.into()); - record - } - } else { - let record = build_observed_record(scope, parsed.target, parsed.options.observed_box); - let _ = targets.set_index(scope, targets.length(), record.into()); - record - }; - if let Some(pending_targets) = resize_observer_pending_targets(scope, args.this()) - && observed_record_index(scope, pending_targets, parsed.target.into()).is_none() + rv.set_undefined(); + return; + } + // Changing the observed box removes and appends the observation. This is + // also the order of entries delivered to the callback. + let targets = without_observed_target(scope, targets, parsed.target.into()); + let record = build_observed_record(scope, parsed.target, parsed.options.observed_box); + let _ = targets.set_index(scope, targets.length(), record.into()); + set_resize_observer_targets(scope, args.this(), targets); + if let Some(pending_targets) = resize_observer_pending_targets(scope, args.this()) { + let pending_targets = without_observed_target(scope, pending_targets, parsed.target.into()); + let _ = pending_targets.set_index(scope, pending_targets.length(), record.into()); + set_resize_observer_pending_targets(scope, args.this(), pending_targets); + } + if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) + && let Some(id) = resize_observer_callback_id(scope, args.this()) { - let _ = pending_targets.set_index(scope, pending_targets.length(), record.into()); + crate::observer_runtime::activate_resize_observer_callback( + scope, + host_ptr, + id, + args.this(), + ); } - push_object_to_global_registry(scope, RESIZE_OBSERVER_REGISTRY_SLOT, args.this()); - queue_resize_observer_delivery(scope, args.this()); rv.set_undefined(); } @@ -226,6 +234,13 @@ pub(super) fn resize_observer_disconnect_callback<'s>( set_resize_observer_targets(scope, args.this(), targets); let pending_targets = v8::Array::new(scope, 0); set_resize_observer_pending_targets(scope, args.this(), pending_targets); + let active = v8::Boolean::new(scope, false); + set_private_value( + scope, + args.this(), + RESIZE_OBSERVER_DELIVERY_ACTIVE_SLOT, + active.into(), + ); remove_resize_observer_from_registry(scope, args.this()); rv.set_undefined(); } @@ -251,67 +266,6 @@ pub(super) fn resize_observer_take_records_callback<'s>( rv.set(entries.into()); } -fn resize_observer_flush_callback<'s>( - scope: &mut v8::PinScope<'s, '_>, - _args: v8::FunctionCallbackArguments<'s>, - _rv: v8::ReturnValue<'_, v8::Value>, -) { - let Some(observer) = pop_first_object_from_global_queue(scope, RESIZE_OBSERVER_QUEUE_SLOT) - else { - return; - }; - set_resize_observer_scheduled(scope, observer, false); - let Some(pending_targets) = resize_observer_pending_targets(scope, observer) else { - return; - }; - if pending_targets.length() == 0 { - return; - } - let Some(callback_residence) = resize_observer_callback_residence(scope, observer) else { - return; - }; - let Some(common) = CommonRuntimeState::from_scope(scope) else { - return; - }; - let Some(callback) = common.callbacks.prepare( - scope, - observer, - CallbackRegistrationKind::ResizeObserver, - callback_residence, - ) else { - let pending_targets = v8::Array::new(scope, 0); - set_resize_observer_pending_targets(scope, observer, pending_targets); - return; - }; - let callback_context = callback.relevant_context(scope); - let result = { - let scope = &mut v8::ContextScope::new(scope, callback_context); - build_resize_observer_entries(scope, pending_targets) - }; - let entries = match result { - Ok(entries) => entries, - Err(error) => { - let pending_targets = v8::Array::new(scope, 0); - set_resize_observer_pending_targets(scope, observer, pending_targets); - throw_resize_observer_layout_error(scope, error); - return; - } - }; - let pending_targets = v8::Array::new(scope, 0); - set_resize_observer_pending_targets(scope, observer, pending_targets); - if entries.length() == 0 { - return; - } - let observer_value: v8::Local<'_, v8::Value> = observer.into(); - callback.invoke_and_report( - scope, - "resizeobserver", - "ResizeObserver callback", - observer_value, - &[entries.into(), observer_value], - ); -} - fn is_resize_observer_target<'s>( scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>, @@ -324,10 +278,33 @@ fn is_resize_observer_target<'s>( .is_some() } +struct SampledResizeObservation<'s> { + record: v8::Local<'s, v8::Object>, + handle: Option, + observed_size: (f64, f64), + entry: ResizeObserverEntryData<'s>, +} + fn build_resize_observer_entries<'s>( scope: &mut v8::PinScope<'s, '_>, observed_records: v8::Local<'s, v8::Array>, ) -> Result, moli_layout::LayoutError> { + let samples = sample_resize_observations(scope, observed_records)?; + let mut entries = Vec::new(); + for sample in samples { + if resize_observer_last_reported_size(scope, sample.record) == Some(sample.observed_size) { + continue; + } + set_resize_observer_last_reported_size(scope, sample.record, sample.observed_size); + entries.push(sample.entry.into_object(scope)); + } + Ok(serialize_v8_iter_array(scope, entries).unwrap_or_else(|| v8::Array::new(scope, 0))) +} + +fn sample_resize_observations<'s>( + scope: &mut v8::PinScope<'s, '_>, + observed_records: v8::Local<'s, v8::Array>, +) -> Result>, moli_layout::LayoutError> { struct PendingEntry<'s> { record: Option>, target: v8::Local<'s, v8::Value>, @@ -357,7 +334,7 @@ fn build_resize_observer_entries<'s>( let mut geometry = std::collections::HashMap::new(); let mut by_document = std::collections::HashMap::<_, Vec<_>>::new(); let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { - return Ok(v8::Array::new(scope, 0)); + return Ok(Vec::new()); }; let runtime = unsafe { &*host_ptr }; for handle in pending.iter().filter_map(|entry| entry.handle) { @@ -373,7 +350,7 @@ fn build_resize_observer_entries<'s>( handles .iter() .copied() - .map(|source| moli_layout::LayoutQuery::ResizeObserverMetrics { source }), + .map(|source| moli_layout::LayoutQuery::ElementMetrics { source }), ); let answers = match crate::native_bridge::element::published_geometry_batch( runtime, @@ -397,7 +374,7 @@ fn build_resize_observer_entries<'s>( } }; for (handle, answer) in handles.into_iter().zip(answers) { - let moli_layout::LayoutQueryAnswer::ResizeObserverMetrics(metrics) = answer else { + let moli_layout::LayoutQueryAnswer::ElementMetrics(metrics) = answer else { return Err(moli_layout::LayoutError::source_contract( "ResizeObserver geometry", "provider returned a mismatched ResizeObserver-metrics answer", @@ -413,53 +390,67 @@ fn build_resize_observer_entries<'s>( .handle .and_then(|handle| geometry.get(&handle).copied()) .and_then(|(metrics, dpr)| metrics.map(|metrics| (metrics, dpr))) - .unwrap_or((moli_layout::LayoutResizeObserverMetrics::default(), 1.0)); + .map(|(metrics, dpr)| (Some(metrics), dpr)) + .unwrap_or((None, 1.0)); + let box_geometry = metrics.and_then(|metrics| metrics.resize_observer_box); + let content_width = + box_geometry.map_or(0.0, |geometry| f64::from(geometry.content_rect.width)); + let content_height = + box_geometry.map_or(0.0, |geometry| f64::from(geometry.content_rect.height)); + let border_width = + box_geometry.map_or(0.0, |geometry| f64::from(geometry.border_size.width)); + let border_height = + box_geometry.map_or(0.0, |geometry| f64::from(geometry.border_size.height)); let rect = ( - 0.0, - 0.0, - f64::from(metrics.content_size.width), - f64::from(metrics.content_size.height), + box_geometry.map_or(0.0, |geometry| f64::from(geometry.content_rect.x)), + box_geometry.map_or(0.0, |geometry| f64::from(geometry.content_rect.y)), + content_width, + content_height, ); - let content_box_size = ( - f64::from(metrics.content_box_size.inline_size), - f64::from(metrics.content_box_size.block_size), - ); - let border_box_size = ( - f64::from(metrics.border_box_size.inline_size), - f64::from(metrics.border_box_size.block_size), - ); - // Preserve the existing device-pixel approximation, now on the same - // logical axes. Effective zoom and positional snapping are separate. - let device_pixel_content_box_size = ( - (content_box_size.0 * f64::from(dpr)).round(), - (content_box_size.1 * f64::from(dpr)).round(), + let logical_size = |width, height| { + if box_geometry.is_none_or(|geometry| geometry.horizontal) { + (width, height) + } else { + (height, width) + } + }; + let content_size = logical_size(content_width, content_height); + let border_size = logical_size(border_width, border_height); + let device_scale = f64::from(dpr) + * box_geometry.map_or(1.0, |geometry| f64::from(geometry.effective_zoom)); + let device_size = logical_size( + (content_width * device_scale).round(), + (content_height * device_scale).round(), ); + let content_box_size = content_size; + let border_box_size = border_size; + let device_pixel_content_box_size = device_size; let observed_size = match entry .record .and_then(|record| observed_record_box(scope, record)) { - Some(ResizeObserverBoxOptions::BorderBox) => border_box_size, - Some(ResizeObserverBoxOptions::DevicePixelContentBox) => device_pixel_content_box_size, - Some(ResizeObserverBoxOptions::ContentBox) | None => content_box_size, + Some(ResizeObserverBoxOptions::BorderBox) => border_size, + Some(ResizeObserverBoxOptions::DevicePixelContentBox) => device_size, + Some(ResizeObserverBoxOptions::ContentBox) | None => content_size, }; - if let Some(record) = entry.record { - let previous = resize_observer_last_reported_size(scope, record); - if previous == Some(observed_size) { - continue; - } - set_resize_observer_last_reported_size(scope, record, observed_size); - } - let entry = ResizeObserverEntryData { + let Some(record) = entry.record else { + continue; + }; + let declaration = ResizeObserverEntryData { target: entry.target, content_rect: rect, content_box_size, border_box_size, device_pixel_content_box_size, - } - .into_object(scope); - entries.push(entry); + }; + entries.push(SampledResizeObservation { + record, + handle: entry.handle, + observed_size, + entry: declaration, + }); } - Ok(serialize_v8_iter_array(scope, entries).unwrap_or_else(|| v8::Array::new(scope, 0))) + Ok(entries) } fn build_observed_record<'s>( @@ -477,17 +468,6 @@ fn build_observed_record<'s>( record } -fn set_observed_record_box<'s>( - scope: &mut v8::PinScope<'s, '_>, - record: v8::Local<'s, v8::Object>, - observed_box: ResizeObserverBoxOptions, -) { - ResizeObserverOptions { observed_box } - .initialize_snapshot(scope, record) - .expect("ResizeObserver options"); - reset_resize_observer_last_reported_size(scope, record); -} - fn observed_record_box<'s>( scope: &mut v8::PinScope<'s, '_>, record: v8::Local<'s, v8::Object>, @@ -665,64 +645,12 @@ fn resize_observer_callback_residence<'s>( )) } -fn resize_observer_scheduled<'s>( - scope: &mut v8::PinScope<'s, '_>, - observer: v8::Local<'s, v8::Object>, -) -> bool { - resize_observer_slot_value(scope, observer, RESIZE_OBSERVER_SCHEDULED_SLOT) - .is_some_and(|value| value.boolean_value(scope)) -} - -fn set_resize_observer_scheduled( - scope: &mut v8::PinScope<'_, '_>, - observer: v8::Local<'_, v8::Object>, - scheduled: bool, -) { - let value = v8::Boolean::new(scope, scheduled); - set_resize_observer_slot_value( - scope, - observer, - RESIZE_OBSERVER_SCHEDULED_SLOT, - value.into(), - ); -} - -fn queue_resize_observer_delivery<'s>( - scope: &mut v8::PinScope<'s, '_>, - observer: v8::Local<'s, v8::Object>, -) { - if resize_observer_scheduled(scope, observer) { - return; - } - let Some(callback_id) = resize_observer_callback_id(scope, observer) else { - return; - }; - let Some(common) = CommonRuntimeState::from_scope(scope) else { - return; - }; - if !common.callbacks.is_current( - scope, - callback_id, - observer, - CallbackRegistrationKind::ResizeObserver, - ) { - let pending_targets = v8::Array::new(scope, 0); - set_resize_observer_pending_targets(scope, observer, pending_targets); - return; - } - set_resize_observer_scheduled(scope, observer, true); - push_object_to_global_queue(scope, RESIZE_OBSERVER_QUEUE_SLOT, observer); - schedule_scope_callback(scope, resize_observer_flush_callback, None); -} - pub(crate) fn queue_resize_observer_checks(scope: &mut v8::PinScope<'_, '_>) { - let Some(registry) = global_queue_array(scope, RESIZE_OBSERVER_REGISTRY_SLOT) else { + let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { return; }; - let observers = (0..registry.length()) - .filter_map(|index| registry.get_index(scope, index)) - .filter_map(|value| v8::Local::::try_from(value).ok()) - .collect::>(); + let observers = + crate::observer_runtime::active_resize_observer_callbacks(scope, host_ptr, None); for observer in observers { let Some(targets) = resize_observer_targets(scope, observer) else { continue; @@ -744,29 +672,19 @@ pub(crate) fn queue_resize_observer_checks(scope: &mut v8::PinScope<'_, '_>) { } } set_resize_observer_pending_targets(scope, observer, pending); - queue_resize_observer_delivery(scope, observer); } + crate::observer_runtime::queue_resize_observer_rendering_updates(scope, host_ptr); } -fn remove_resize_observer_from_registry( - scope: &mut v8::PinScope<'_, '_>, - observer: v8::Local<'_, v8::Object>, +fn remove_resize_observer_from_registry<'s>( + scope: &mut v8::PinScope<'s, '_>, + observer: v8::Local<'s, v8::Object>, ) { - let Some(registry) = global_queue_array(scope, RESIZE_OBSERVER_REGISTRY_SLOT) else { - return; - }; - let next = v8::Array::new(scope, 0); - for index in 0..registry.length() { - let Some(candidate) = registry.get_index(scope, index) else { - continue; - }; - if candidate.strict_equals(observer.into()) { - continue; - } - let _ = next.set_index(scope, next.length(), candidate); + if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) + && let Some(id) = resize_observer_callback_id(scope, observer) + { + crate::observer_runtime::deactivate_resize_observer_callback(host_ptr, id); } - let global = scope.get_current_context().global(scope); - set_private_value(scope, global, RESIZE_OBSERVER_REGISTRY_SLOT, next.into()); } fn resize_observer_slot_value<'s>( @@ -785,3 +703,19 @@ fn set_resize_observer_slot_value( ) { set_private_value(scope, observer, slot, value); } + +fn without_observed_target<'s>( + scope: &mut v8::PinScope<'s, '_>, + records: v8::Local<'s, v8::Array>, + target: v8::Local<'s, v8::Value>, +) -> v8::Local<'s, v8::Array> { + let next = v8::Array::new(scope, 0); + for index in 0..records.length() { + if let Some(record) = records.get_index(scope, index) + && !observed_record_matches_target(scope, record, target) + { + let _ = next.set_index(scope, next.length(), record); + } + } + next +} diff --git a/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime/delivery.rs b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime/delivery.rs new file mode 100644 index 00000000000..f3f2fc231ed --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime/delivery.rs @@ -0,0 +1,195 @@ +//! One depth-limited ResizeObserver broadcast in a Document rendering update. +//! The ScriptVm publishes layout between broadcasts; this code only samples +//! the published geometry and never causes a layout pass while invoking JS. + +use super::*; +use crate::native_bridge::{PageScriptHost, WindowDocumentTaskTarget, WindowExecutionContextOwner}; + +#[derive(Default)] +pub(crate) struct ResizeObserverBroadcast { + pub(crate) shallowest_depth: Option, + pub(crate) skipped: bool, + pub(crate) invoked: bool, +} + +pub(crate) fn broadcast_document_resize_observers( + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, + target: WindowDocumentTaskTarget, + owner: WindowExecutionContextOwner, + depth: usize, +) -> Result { + let mut result = ResizeObserverBroadcast::default(); + let Some((_, context)) = + (unsafe { &mut *host_ptr }).resolve_current_rendering_update_context(scope, target) + else { + return Ok(result); + }; + let scope = &mut v8::ContextScope::new(scope, context); + let previous_scope = target.dispatch_scope().enter(scope); + let outcome = (|| { + let observers = + crate::observer_runtime::active_resize_observer_callbacks(scope, host_ptr, Some(owner)); + let mut deliveries = Vec::new(); + // Gather all observers before invoking any callbacks. Updating the + // last-reported size here would lose observations skipped by depth. + for observer in observers { + if scope.is_execution_terminating() { + break; + } + let Some(context) = observer.get_creation_context(scope) else { + continue; + }; + let scope = &mut v8::ContextScope::new(scope, context); + let Some(records) = resize_observer_targets(scope, observer) else { + continue; + }; + let mut active = Vec::new(); + for sample in sample_resize_observations(scope, records)? { + if resize_observer_last_reported_size(scope, sample.record) + == Some(sample.observed_size) + { + continue; + } + if flattened_target_depth(unsafe { &*host_ptr }, sample.handle) > depth { + active.push(sample); + } else { + result.skipped = true; + } + } + let delivery_active = v8::Boolean::new(scope, !active.is_empty()); + set_private_value( + scope, + observer, + RESIZE_OBSERVER_DELIVERY_ACTIVE_SLOT, + delivery_active.into(), + ); + if !active.is_empty() { + deliveries.push((observer, active)); + } + } + for (observer, samples) in deliveries { + if scope.is_execution_terminating() + || !(unsafe { &*host_ptr }).window_document_owner_is_current_for_dispatch_scope( + target.owner(), + target.dispatch_scope(), + ) + { + break; + } + // The native samples above own activeTargets. This private marker + // lets disconnect() in an earlier callback cancel their delivery; + // unobserve() only changes the next gather, as required by the API. + let active = get_private_value(scope, observer, RESIZE_OBSERVER_DELIVERY_ACTIVE_SLOT); + if !active.is_some_and(|value| value.is_true()) { + continue; + } + let Some(residence) = resize_observer_callback_residence(scope, observer) else { + continue; + }; + let Some(common) = CommonRuntimeState::from_scope(scope) else { + continue; + }; + let Some(callback) = common.callbacks.prepare( + scope, + observer, + CallbackRegistrationKind::ResizeObserver, + residence, + ) else { + continue; + }; + let context = callback.relevant_context(scope); + let scope = &mut v8::ContextScope::new(scope, context); + let mut entries = Vec::with_capacity(samples.len()); + for sample in samples { + let target_depth = flattened_target_depth(unsafe { &*host_ptr }, sample.handle); + result.shallowest_depth = Some( + result + .shallowest_depth + .map_or(target_depth, |current| current.min(target_depth)), + ); + set_resize_observer_last_reported_size(scope, sample.record, sample.observed_size); + entries.push(sample.entry.into_object(scope)); + } + let pending = v8::Array::new(scope, 0); + set_resize_observer_pending_targets(scope, observer, pending); + let entries = + serialize_v8_iter_array(scope, entries).unwrap_or_else(|| v8::Array::new(scope, 0)); + let receiver: v8::Local<'_, v8::Value> = observer.into(); + let execution_scope = crate::script_cleanup::ScriptExecutionScope::enter(scope); + callback.invoke_and_report( + scope, + "resizeobserver", + "ResizeObserver callback", + receiver, + &[entries.into(), receiver], + ); + drop(execution_scope); + crate::script_cleanup::perform_callback_cleanup_checkpoint(scope); + if !scope.is_execution_terminating() { + let active = v8::Boolean::new(scope, false); + set_private_value( + scope, + observer, + RESIZE_OBSERVER_DELIVERY_ACTIVE_SLOT, + active.into(), + ); + } + result.invoked = true; + } + Ok(result) + })(); + target.dispatch_scope().restore(scope, previous_scope); + outcome +} + +fn flattened_target_depth( + host: &PageScriptHost, + mut handle: Option, +) -> usize { + let mut depth = 0; + let dom = host.dom_host(); + while let Some(node) = handle { + depth += 1; + handle = if let Some(slot) = dom.assigned_slot_for_node(node) { + Some(slot) + } else if let Some(parent) = dom.parent_node(node) { + if dom.is_shadow_root(parent) { + dom.shadow_root_host(parent) + } else { + Some(parent) + } + } else { + None + }; + } + depth.max(1) +} + +pub(crate) fn report_document_resize_observer_loop_error( + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, + target: WindowDocumentTaskTarget, +) { + let Some((_, context)) = + (unsafe { &mut *host_ptr }).resolve_current_rendering_update_context(scope, target) + else { + return; + }; + let scope = &mut v8::ContextScope::new(scope, context); + let previous_scope = target.dispatch_scope().enter(scope); + (unsafe { &mut *host_ptr }).queue_document_observer_update(scope, target.dispatch_scope()); + let execution_scope = crate::script_cleanup::ScriptExecutionScope::enter(scope); + let _ = crate::context_bootstrap::dispatch_window_error_event_with_details( + scope, + host_ptr, + "ResizeObserver loop completed with undelivered notifications.", + "", + 0, + 0, + None, + ); + drop(execution_scope); + crate::script_cleanup::perform_callback_cleanup_checkpoint(scope); + target.dispatch_scope().restore(scope, previous_scope); +} diff --git a/moli-renderer-v8/src/context_bootstrap/shared/slots.rs b/moli-renderer-v8/src/context_bootstrap/shared/slots.rs index 49242b74a6a..01f42165215 100644 --- a/moli-renderer-v8/src/context_bootstrap/shared/slots.rs +++ b/moli-renderer-v8/src/context_bootstrap/shared/slots.rs @@ -4,8 +4,7 @@ pub(in crate::context_bootstrap) const WINDOW_CONSOLE_SLOT: &str = "__moliWindow pub(in crate::context_bootstrap) const WINDOW_ORIGINAL_CONSOLE_SLOT: &str = "__moliWindowOriginalConsole"; pub(in crate::context_bootstrap) const WINDOW_ONERROR_SLOT: &str = "__moliWindowOnError"; -pub(in crate::context_bootstrap) const WINDOW_BODY_ONERROR_COMPILED_SLOT: &str = - "__moliWindowBodyOnErrorCompiled"; + pub(in crate::context_bootstrap) const WINDOW_ONUNHANDLEDREJECTION_SLOT: &str = "__moliWindowOnUnhandledRejection"; pub(in crate::context_bootstrap) const WINDOW_ONREJECTIONHANDLED_SLOT: &str = @@ -68,8 +67,8 @@ pub(in crate::context_bootstrap) const RESIZE_OBSERVER_TARGETS_SLOT: &str = "__moliResizeObserverTargets"; pub(in crate::context_bootstrap) const RESIZE_OBSERVER_PENDING_TARGETS_SLOT: &str = "__moliResizeObserverPendingTargets"; -pub(in crate::context_bootstrap) const RESIZE_OBSERVER_SCHEDULED_SLOT: &str = - "__moliResizeObserverScheduled"; +pub(in crate::context_bootstrap) const RESIZE_OBSERVER_DELIVERY_ACTIVE_SLOT: &str = + "__moliResizeObserverDeliveryActive"; pub(in crate::context_bootstrap) const PERFORMANCE_OBSERVER_CALLBACK_ID_SLOT: &str = "__moliPerformanceObserverCallbackId"; pub(in crate::context_bootstrap) const PERFORMANCE_OBSERVER_CALLBACK_VALUE_SLOT: &str = diff --git a/moli-renderer-v8/src/native_bridge/context_host/animation_frames.rs b/moli-renderer-v8/src/native_bridge/context_host/animation_frames.rs index a5516fe7fdb..04417f411c7 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/animation_frames.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/animation_frames.rs @@ -1,6 +1,7 @@ //! Document-owned animation callbacks. A timer only wakes the rendering //! source; one rendering task snapshots and invokes a Document's callback map, -//! then applies focus fixup after callback cleanup. +//! followed by layout/observer processing and focus fixup at the ScriptVm +//! rendering boundary. Geometry readers never perform that layout work. use super::{ OwnerDispatchScope, PageScriptHost, RuntimeObservableContextToken, WindowDocumentTaskTarget, @@ -32,6 +33,7 @@ struct AnimationFrameProvider { next_handle: u32, wake_pending: bool, focus_fixup_target: Option, + observer_target: Option, handles: Vec, callbacks: HashMap, } @@ -83,6 +85,7 @@ impl AnimationFrameState { next_handle: 0, wake_pending: false, focus_fixup_target: None, + observer_target: None, handles: Vec::new(), callbacks: HashMap::new(), }); @@ -96,6 +99,29 @@ impl AnimationFrameState { } impl PageScriptHost { + /// A rendering body can yield to author code several times. Revalidate + /// its immutable Document target before resolving each later phase; the + /// initial Page authorization alone cannot survive document.open(). + pub(crate) fn resolve_current_rendering_update_context<'s>( + &mut self, + scope: &mut v8::PinScope<'s, '_>, + target: WindowDocumentTaskTarget, + ) -> Option<( + crate::document_runtime::DomHandle, + v8::Local<'s, v8::Context>, + )> { + if scope.is_execution_terminating() + || !self.window_document_owner_is_current_for_dispatch_scope( + target.owner(), + target.dispatch_scope(), + ) + { + return None; + } + let resolved = self.resolve_authorized_window_document_task_context(scope, target)?; + Some((resolved.document_handle, resolved.context)) + } + /// DOM changes and focus styling can make the focused element unavailable. /// Revalidate it at the end of a rendering update, using the same native /// wake and exact Document owner as animation callbacks. No author timer @@ -121,7 +147,39 @@ impl PageScriptHost { }; let provider = self.animation_frames.ensure_provider(owner, dispatch_scope); provider.focus_fixup_target = Some(target); - if provider.wake_pending { + self.ensure_document_rendering_wake(scope, owner, dispatch_scope); + } + + pub(crate) fn queue_document_observer_update( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + dispatch_scope: OwnerDispatchScope, + ) { + let Some(owner) = self.current_window_execution_context_owner(dispatch_scope) else { + return; + }; + let Some(target) = + self.current_window_document_task_target_for_dispatch_scope(dispatch_scope) + else { + return; + }; + self.animation_frames + .ensure_provider(owner, dispatch_scope) + .observer_target = Some(target); + self.ensure_document_rendering_wake(scope, owner, dispatch_scope); + } + + fn ensure_document_rendering_wake( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + owner: WindowExecutionContextOwner, + dispatch_scope: OwnerDispatchScope, + ) { + if self + .animation_frames + .ensure_provider(owner, dispatch_scope) + .wake_pending + { return; } let Some(binding) = @@ -223,7 +281,13 @@ impl PageScriptHost { // focus check must not survive document.open(). provider.focus_fixup_target = None; } - if provider.callbacks.is_empty() && provider.focus_fixup_target.is_none() { + if provider.observer_target != Some(target) { + provider.observer_target = None; + } + if provider.callbacks.is_empty() + && provider.focus_fixup_target.is_none() + && provider.observer_target.is_none() + { provider.wake_pending = false; provider.handles.clear(); return; @@ -270,6 +334,7 @@ impl PageScriptHost { .provider_mut(owner) .map(|provider| { provider.wake_pending = false; + provider.observer_target = None; std::mem::take(&mut provider.handles) }) .unwrap_or_default(); @@ -321,6 +386,26 @@ impl PageScriptHost { } invoked = true; } + dispatch_scope.restore(scope, previous_scope); + invoked + } + + pub(crate) fn finish_document_animation_frame( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, + target: WindowDocumentTaskTarget, + owner: WindowExecutionContextOwner, + ) -> bool { + let Some((document, context)) = + self.resolve_current_rendering_update_context(scope, target) + else { + return false; + }; + let scope = &mut v8::ContextScope::new(scope, context); + let dispatch_scope = target.dispatch_scope(); + let previous_scope = dispatch_scope.enter(scope); + let mut invoked = false; // A callback can replace its Document or move focus elsewhere. The // rendering entry must never clear focus in a replacement Document. if self.window_document_owner_is_current_for_dispatch_scope(target.owner(), dispatch_scope) @@ -336,11 +421,7 @@ impl PageScriptHost { } }) { - invoked |= super::super::element::apply_document_focus_fixup( - scope, - host_ptr, - resolved.document_handle, - ); + invoked |= super::super::element::apply_document_focus_fixup(scope, host_ptr, document); } dispatch_scope.restore(scope, previous_scope); invoked diff --git a/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs b/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs index 55e56c57c64..f0f60ffe758 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/layout_snapshot.rs @@ -12,9 +12,9 @@ struct LatestFrozenLayout { /// This owns exactly one recursively frozen snapshot. It has no separately /// keyed child tree, working layout world, source index, hit-test index, Taffy /// cache, style borrow, pass diagnostics, paint snapshot, timer, or invalidation -/// policy. The first geometry demand initializes it. Screenshots, screencast -/// frames and explicit layout refreshes replace -/// this published layout; print projections never enter this cache. +/// policy. The first geometry demand initializes it. Rendering updates, screenshots, +/// screencast frames and explicit layout refreshes replace this published layout; +/// print projections never enter this cache. #[derive(Default)] pub(super) struct LatestLayoutTreeCache { latest: Option, diff --git a/moli-renderer-v8/src/native_bridge/context_host/rendering_updates.rs b/moli-renderer-v8/src/native_bridge/context_host/rendering_updates.rs index 9a9011c07b9..663ed1165bd 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/rendering_updates.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/rendering_updates.rs @@ -14,6 +14,7 @@ pub(super) enum PendingRenderingUpdatePayload { /// The candidate is intentionally resolved at execution time. PostParseAutofocus, AnimationFrameCallbacks(super::WindowExecutionContextOwner), + IntersectionObserverDelivery(super::WindowExecutionContextOwner), EnvironmentChange(PendingEnvironmentChange), } @@ -43,6 +44,18 @@ pub(super) type RenderingUpdateState = ExactWindowDocumentTaskLedger< >; impl PageScriptHost { + pub(crate) fn queue_document_intersection_delivery( + &mut self, + target: WindowDocumentTaskTarget, + owner: super::WindowExecutionContextOwner, + ) { + self.queue_rendering_update( + target, + RendererPageRenderingUpdateTaskKind::IntersectionObserverDelivery, + PendingRenderingUpdatePayload::IntersectionObserverDelivery(owner), + ); + } + /// Publish post-parse autofocus as a rendering update for the exact main /// Document after DOMContentLoaded or a subsequent candidate insertion. /// @@ -246,12 +259,16 @@ impl PageScriptHost { task_id: RendererPageRenderingUpdateTaskId, target: WindowDocumentTaskTarget, kind: RendererPageRenderingUpdateTaskKind, - ) -> Option { + ) -> Option<(bool, Option)> { let payload = self .rendering_updates .remove_exact(task_id, target, kind)? .into_payload(); - Some(match payload { + let animation_owner = match payload { + PendingRenderingUpdatePayload::AnimationFrameCallbacks(owner) => Some(owner), + _ => None, + }; + let invoked = match payload { PendingRenderingUpdatePayload::DocumentScrollEvents => { self.dispatch_authorized_document_scroll_events(scope, host_ptr, target) } @@ -264,10 +281,31 @@ impl PageScriptHost { PendingRenderingUpdatePayload::AnimationFrameCallbacks(owner) => { self.dispatch_authorized_animation_frame_callbacks(scope, host_ptr, target, owner) } + PendingRenderingUpdatePayload::IntersectionObserverDelivery(owner) => { + let Some(resolved) = + self.resolve_authorized_window_document_task_context(scope, target) + else { + return Some((false, None)); + }; + let scope = &mut v8::ContextScope::new(scope, resolved.context); + let previous = target.dispatch_scope().enter(scope); + let watchdog = crate::v8_execution_watchdog::V8ExecutionWatchdog::arm( + crate::v8_execution_watchdog::V8ExecutionWatchdogKind::RenderingObservers, + scope.thread_safe_handle(), + crate::v8_execution_watchdog::SCRIPT_TURN_WATCHDOG_TIMEOUT, + ); + crate::observer_runtime::deliver_document_intersections( + scope, host_ptr, owner, target, + ); + watchdog.disarm(); + target.dispatch_scope().restore(scope, previous); + true + } PendingRenderingUpdatePayload::EnvironmentChange(change) => { self.dispatch_authorized_environment_change(scope, host_ptr, target, change) } - }) + }; + Some((invoked, animation_owner)) } pub(crate) fn discard_pending_rendering_update_task( diff --git a/moli-renderer-v8/src/native_bridge/document/css_state/accessors.rs b/moli-renderer-v8/src/native_bridge/document/css_state/accessors.rs index 03ebca53dbc..614d49bdd67 100644 --- a/moli-renderer-v8/src/native_bridge/document/css_state/accessors.rs +++ b/moli-renderer-v8/src/native_bridge/document/css_state/accessors.rs @@ -186,6 +186,7 @@ fn set_document_adopted_style_sheets_for_receiver<'s>( .set_document_adopted_style_sheet_installations(handle, installations); sync_css_style_sheet_document_adopted_owner_tracking(scope, next_array.into(), handle); super::sync_document_fonts_for_handle(scope, unsafe { &*runtime_ptr }, handle); + crate::observer_runtime::queue_style_rendering_update(scope, runtime_ptr); } pub(in crate::native_bridge) fn normalize_adopted_style_sheets_assignment<'s>( @@ -508,6 +509,7 @@ pub(in crate::native_bridge) fn sync_adopted_style_sheets_array_owner<'s>( } None => {} } + crate::observer_runtime::queue_style_rendering_update(scope, host_ptr); } fn adopted_style_sheets_array_is_current_owner<'s>( diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs b/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs index b8e14592c01..ad4f2eec3f4 100644 --- a/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs +++ b/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs @@ -221,6 +221,12 @@ fn mock_element_metrics( .unwrap_or(LayoutPoint::ZERO); let quad = quad_from_client_rect(rect); Some(LayoutElementMetrics { + resize_observer_box: Some(moli_layout::LayoutResizeObserverBox { + content_rect: moli_layout::LayoutRect::new(0.0, 0.0, size.width, size.height), + border_size: size, + horizontal: true, + effective_zoom: 1.0, + }), offset_parent: compute_mock_offset_parent(runtime, source), offset_position: LayoutPoint::new(rect.left as f32, rect.top as f32), border_origin_in_viewport_ignoring_css_transforms: LayoutPoint::new( diff --git a/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs b/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs index 5b5c7bf7c7d..46345bec294 100644 --- a/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs +++ b/moli-renderer-v8/src/native_bridge/element/shadow_dom/root_accessors.rs @@ -678,6 +678,7 @@ fn set_shadow_root_adopted_style_sheets_for_receiver<'s>( unsafe { &mut *runtime_ptr } .set_shadow_root_adopted_style_sheet_installations(handle, installations); sync_css_style_sheet_shadow_root_adopted_owner_tracking(scope, next_array.into(), handle); + crate::observer_runtime::queue_style_rendering_update(scope, runtime_ptr); } fn shadow_root_adopted_style_base_url( diff --git a/moli-renderer-v8/src/observer_runtime/callback.rs b/moli-renderer-v8/src/observer_runtime/callback.rs index 80bf570a0c0..05f7a6424f9 100644 --- a/moli-renderer-v8/src/observer_runtime/callback.rs +++ b/moli-renderer-v8/src/observer_runtime/callback.rs @@ -22,6 +22,10 @@ pub(super) struct ObserverCallback { } impl ObserverCallback { + pub(super) fn observer_identity(&self) -> Option { + self.observer_identity + } + pub(super) fn new( scope: &mut v8::PinScope<'_, '_>, host: &PageScriptHost, diff --git a/moli-renderer-v8/src/observer_runtime/dom_access.rs b/moli-renderer-v8/src/observer_runtime/dom_access.rs index 4145b0cd9b7..f1c539a61df 100644 --- a/moli-renderer-v8/src/observer_runtime/dom_access.rs +++ b/moli-renderer-v8/src/observer_runtime/dom_access.rs @@ -11,13 +11,69 @@ use super::{ ObserverMutationPlan, ObserverStore, build_intersection_entries_array, build_mutation_records_array, callback::ObserverCallback, - intersection::{self, IntersectionCheckBatch}, - invoke_intersection_deliveries, invoke_mutation_deliveries, node_is_intersection_root, - node_is_intersection_target, + intersection, invoke_intersection_deliveries, invoke_mutation_deliveries, + node_is_intersection_root, node_is_intersection_target, schedule::{self, ObserverTask}, target_is_intersection_observable, }; +pub(crate) fn activate_resize_observer_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + host_ptr: *mut PageScriptHost, + id: crate::common_runtime::CallbackRegistrationId, + observer: v8::Local<'s, v8::Object>, +) { + let mut access = ObserverHostAccess::new(host_ptr); + let common = access.read(|host| std::rc::Rc::clone(&host.common)); + if let Some(identity) = common + .callbacks + .activate_resize_observer(scope, id, observer) + { + access.mutate(|host| host.queue_document_observer_update(scope, identity.dispatch_scope())); + } +} + +pub(crate) fn deactivate_resize_observer_callback( + host_ptr: *mut PageScriptHost, + id: crate::common_runtime::CallbackRegistrationId, +) { + let common = ObserverHostAccess::new(host_ptr).read(|host| std::rc::Rc::clone(&host.common)); + common.callbacks.deactivate_resize_observer(id); +} + +pub(crate) fn active_resize_observer_callbacks<'s>( + scope: &mut v8::PinScope<'s, '_>, + host_ptr: *mut PageScriptHost, + owner: Option, +) -> Vec> { + let mut access = ObserverHostAccess::new(host_ptr); + let common = access.read(|host| std::rc::Rc::clone(&host.common)); + common.callbacks.active_resize_observers(scope, owner) +} + +pub(crate) fn queue_resize_observer_rendering_updates( + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, +) { + let mut access = ObserverHostAccess::new(host_ptr); + let common = access.read(|host| std::rc::Rc::clone(&host.common)); + let identities = common.callbacks.resize_observer_identities(); + for identity in identities { + access.mutate(|host| host.queue_document_observer_update(scope, identity.dispatch_scope())); + } +} + +/// CSSOM and adopted-sheet edits bypass DOM MutationRecords but invalidate +/// observer geometry and can make the focused element unavailable. +pub(crate) fn queue_style_rendering_update( + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, +) { + queue_resize_observer_rendering_updates(scope, host_ptr); + queue_intersection_checks(scope, host_ptr); + ObserverHostAccess::new(host_ptr).mutate(|host| host.queue_focused_document_fixup(scope)); +} + pub(crate) struct ObserverStoreAccessToken { _private: (), } @@ -144,11 +200,8 @@ pub(crate) fn queue_mutation_records( } match intersection { IntersectionMutationPlan::None => {} - IntersectionMutationPlan::CheckNow => { - queue_intersection_checks_with_dom(&mut access, scope, dom_host) - } IntersectionMutationPlan::ScheduleCheck => { - request_task_with_access(&mut access, scope, ObserverTask::IntersectionCheck) + queue_intersection_checks(scope, host_ptr); } } crate::context_bootstrap::queue_resize_observer_checks(scope); @@ -293,7 +346,7 @@ pub(super) fn observe_intersection_target( access.read(|host| target_is_intersection_observable(host.dom_host(), target, options)) }); if should_check { - request_task_with_access(&mut access, scope, ObserverTask::IntersectionCheck); + queue_intersection_checks(scope, host_ptr); } true } @@ -341,61 +394,86 @@ pub(crate) fn queue_intersection_checks( host_ptr: *mut PageScriptHost, ) { let mut access = ObserverHostAccess::new(host_ptr); - let Some(batch) = access.store(ObserverStore::take_intersection_check_batch) else { - return; - }; - let Ok(completed) = access.read(|runtime| { - intersection::compute_intersection_check_batch(runtime, runtime.dom_host(), batch) - }) else { - return; - }; - let queued_any = access.store(|store| store.apply_intersection_check_batch(completed)); - if queued_any { - request_task_with_access(&mut access, scope, ObserverTask::IntersectionDelivery); - } -} - -fn queue_intersection_checks_with_dom( - access: &mut ObserverHostAccess, - scope: &mut v8::PinScope<'_, '_>, - dom_host: &DomHost, -) { - let Some(batch): Option = - access.store(ObserverStore::take_intersection_check_batch) - else { - return; - }; - let Ok(completed) = access - .read(|runtime| intersection::compute_intersection_check_batch(runtime, dom_host, batch)) - else { - return; - }; - let queued_any = access.store(|store| store.apply_intersection_check_batch(completed)); - if queued_any { - request_task_with_access(access, scope, ObserverTask::IntersectionDelivery); - } -} - -pub(super) fn flush_intersection_checks( - scope: &mut v8::PinScope<'_, '_>, - host_ptr: *mut PageScriptHost, -) { - let mut access = ObserverHostAccess::new(host_ptr); - access.store(|store| store.begin_task(ObserverTask::IntersectionCheck)); - queue_intersection_checks(scope, host_ptr); -} - -pub(super) fn flush_intersection_observers( - scope: &mut v8::PinScope<'_, '_>, - host_ptr: *mut PageScriptHost, -) { - let deliveries = ObserverHostAccess::new(host_ptr).store(|store| { - store.begin_task(ObserverTask::IntersectionDelivery); - store.collect_intersection_deliveries(scope, host_ptr) + let identities = access.store(|store| { + let mut identities = Vec::new(); + for state in store.intersection_observers.values() { + if !state.observed_targets.is_empty() + && let Some(identity) = state.callback.observer_identity() + && !identities.contains(&identity) + { + identities.push(identity); + } + } + identities }); + for identity in identities { + if access.read(|host| host.window_execution_context_identity_is_current(identity)) { + access.mutate(|host| { + host.queue_document_observer_update(scope, identity.dispatch_scope()) + }); + } + } +} - // Blink likewise removes observers from its controller pending set before - // invoking `IntersectionObserver::Deliver`, so reentrant observe/disconnect - // updates fresh owner state instead of aliasing the delivery traversal. - invoke_intersection_deliveries(scope, host_ptr, deliveries); +pub(crate) fn document_has_rendering_observers( + host: &mut PageScriptHost, + owner: WindowExecutionContextOwner, +) -> bool { + let common = std::rc::Rc::clone(&host.common); + let store = host.observers_mut(&OBSERVER_STORE_ACCESS); + let has_intersection = store.intersection_observers.values().any(|state| { + !state.observed_targets.is_empty() + && state + .callback + .observer_identity() + .is_some_and(|identity| identity.owner() == owner) + }); + has_intersection + || common + .callbacks + .resize_observer_identities() + .iter() + .any(|identity| identity.owner() == owner) +} + +/// Sample intersections after the ResizeObserver loop and focus fixup. Delivery +/// receives its own exact-Document task, so callback cleanup cannot run it in +/// the middle of another rendering phase. +pub(crate) fn update_document_intersections( + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, + target: crate::native_bridge::WindowDocumentTaskTarget, + owner: WindowExecutionContextOwner, +) -> Result<(), moli_layout::LayoutError> { + let mut access = ObserverHostAccess::new(host_ptr); + if !access.read(|host| { + host.window_document_owner_is_current_for_dispatch_scope( + target.owner(), + target.dispatch_scope(), + ) + }) { + return Ok(()); + } + let Some(batch) = access.store(|store| store.take_intersection_check_batch(owner)) else { + return Ok(()); + }; + let completed = access.read(|host| { + intersection::compute_intersection_check_batch(host, host.dom_host(), batch) + })?; + if access.store(|store| store.apply_intersection_check_batch(completed)) { + access.mutate(|host| host.queue_document_intersection_delivery(target, owner)); + } + let _ = scope; + Ok(()) +} + +pub(crate) fn deliver_document_intersections( + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, + 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); } diff --git a/moli-renderer-v8/src/observer_runtime/intersection.rs b/moli-renderer-v8/src/observer_runtime/intersection.rs index 6f5dc8b9cf0..923b1dea770 100644 --- a/moli-renderer-v8/src/observer_runtime/intersection.rs +++ b/moli-renderer-v8/src/observer_runtime/intersection.rs @@ -42,12 +42,22 @@ pub(super) struct CompletedIntersectionCheckBatch { } impl ObserverStore { - pub(super) fn take_intersection_check_batch(&mut self) -> Option { + pub(super) fn take_intersection_check_batch( + &mut self, + owner: crate::native_bridge::WindowExecutionContextOwner, + ) -> Option { if self.intersection_observers.is_empty() { return None; } let mut observers = Vec::with_capacity(self.intersection_observers.len()); for (observer_id, state) in &self.intersection_observers { + if state + .callback + .observer_identity() + .is_none_or(|identity| identity.owner() != owner) + { + continue; + } observers.push(IntersectionObserverCheckInput { observer_id: *observer_id, options: state.options.clone(), diff --git a/moli-renderer-v8/src/observer_runtime/mod.rs b/moli-renderer-v8/src/observer_runtime/mod.rs index 594b4f3ad41..b0bf4e13f68 100644 --- a/moli-renderer-v8/src/observer_runtime/mod.rs +++ b/moli-renderer-v8/src/observer_runtime/mod.rs @@ -14,9 +14,12 @@ mod schedule; pub(crate) use mutation_record::install_template_bindings as install_mutation_record_template_bindings; pub(crate) use dom_access::{ - ObserverStoreAccessToken, coalesce_child_list_replacement_records, flush_slotchange_microtask, - queue_intersection_checks, queue_mutation_records, retire_context_token, - retire_execution_context_owner, + ObserverStoreAccessToken, activate_resize_observer_callback, active_resize_observer_callbacks, + coalesce_child_list_replacement_records, deactivate_resize_observer_callback, + deliver_document_intersections, document_has_rendering_observers, flush_slotchange_microtask, + queue_intersection_checks, queue_mutation_records, queue_resize_observer_rendering_updates, + queue_style_rendering_update, retire_context_token, retire_execution_context_owner, + update_document_intersections, }; use crate::web_api_interfaces; @@ -108,8 +111,6 @@ pub(super) struct ObserverStore { mutation_delivery_scheduled: bool, next_intersection_observer_id: u32, intersection_observers: HashMap, - intersection_check_scheduled: bool, - intersection_delivery_scheduled: bool, // Geometry facts are derived from the current DOM and shared by every // observation in one mutation generation. `queue_mutation_records` owns // invalidation, matching the observer controller's update lifecycle. @@ -237,7 +238,6 @@ struct ObserverMutationPlan { #[derive(Clone, Copy)] enum IntersectionMutationPlan { None, - CheckNow, ScheduleCheck, } @@ -470,18 +470,10 @@ impl ObserverStore { // are suppressed when no MutationObserver is registered, that proxy is // wrong: an IO-only page would never see threshold deliveries. // - // Most mutations only need one browser-style async intersection update - // before the JS turn ends. Keep synchronous checks for mutations that - // connect/disconnect an observed target subtree so remove/reinsert pairs - // still report exit/reentry transitions within the same turn, but avoid - // re-reading every observed target for each unrelated attribute/text - // mutation. - let intersection = if !self.intersection_observers.is_empty() { - if self.intersection_mutation_needs_sync(dom_host, effects) { - IntersectionMutationPlan::CheckNow - } else { - IntersectionMutationPlan::ScheduleCheck - } + // Sample once after rendering. Transient remove/reinsert operations + // within one script must not manufacture exit/reentry notifications. + let intersection = if !self.intersection_observers.is_empty() && effects.did_change() { + IntersectionMutationPlan::ScheduleCheck } else { IntersectionMutationPlan::None }; @@ -491,40 +483,6 @@ impl ObserverStore { } } - fn intersection_mutation_needs_sync( - &self, - dom_host: &DomHost, - effects: &DomMutationEffects, - ) -> bool { - if self.intersection_observers.is_empty() { - return false; - } - effects - .tree() - .disconnected_roots() - .iter() - .any(|removed_root| { - self.intersection_observers.values().any(|state| { - state - .observed_targets - .iter() - .any(|target| is_ancestor_or_self(dom_host, *removed_root, *target)) - }) - }) - || effects - .tree() - .connected_roots() - .iter() - .any(|connected_root| { - self.intersection_observers.values().any(|state| { - state - .observed_targets - .iter() - .any(|target| is_ancestor_or_self(dom_host, *connected_root, *target)) - }) - }) - } - pub(super) fn coalesce_child_list_replacement_records( &mut self, target: NativeNodeId, @@ -680,9 +638,19 @@ impl ObserverStore { &mut self, scope: &mut v8::PinScope<'s, '_>, host_ptr: *mut PageScriptHost, + owner: crate::native_bridge::WindowExecutionContextOwner, ) -> Vec> { let mut deliveries = Vec::new(); - for state in self.intersection_observers.values_mut() { + 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; } @@ -770,9 +738,18 @@ fn invoke_mutation_deliveries<'s>( fn invoke_intersection_deliveries<'s>( scope: &mut v8::PinScope<'s, '_>, host_ptr: *mut PageScriptHost, + target: crate::native_bridge::WindowDocumentTaskTarget, deliveries: Vec>, ) { 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; } @@ -785,6 +762,7 @@ fn invoke_intersection_deliveries<'s>( 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", @@ -792,6 +770,8 @@ fn invoke_intersection_deliveries<'s>( observer_value, &[entries.into(), observer_value], ); + drop(execution_scope); + crate::script_cleanup::perform_callback_cleanup_checkpoint(scope); } } diff --git a/moli-renderer-v8/src/observer_runtime/schedule.rs b/moli-renderer-v8/src/observer_runtime/schedule.rs index 65720419139..c43845990b3 100644 --- a/moli-renderer-v8/src/observer_runtime/schedule.rs +++ b/moli-renderer-v8/src/observer_runtime/schedule.rs @@ -5,8 +5,6 @@ use super::{ObserverStore, dom_access}; #[derive(Clone, Copy)] pub(super) enum ObserverTask { MutationDelivery, - IntersectionCheck, - IntersectionDelivery, } impl ObserverStore { @@ -30,8 +28,6 @@ impl ObserverStore { fn task_scheduled_mut(&mut self, task: ObserverTask) -> &mut bool { match task { ObserverTask::MutationDelivery => &mut self.mutation_delivery_scheduled, - ObserverTask::IntersectionCheck => &mut self.intersection_check_scheduled, - ObserverTask::IntersectionDelivery => &mut self.intersection_delivery_scheduled, } } } @@ -41,12 +37,6 @@ pub(super) fn enqueue(scope: &mut v8::PinScope<'_, '_>, task: ObserverTask) -> b ObserverTask::MutationDelivery => { v8::Function::builder(flush_mutation_observers_callback).build(scope) } - ObserverTask::IntersectionCheck => { - v8::Function::builder(flush_intersection_checks_callback).build(scope) - } - ObserverTask::IntersectionDelivery => { - v8::Function::builder(flush_intersection_observers_callback).build(scope) - } }; let Some(callback) = callback else { return false; @@ -65,25 +55,3 @@ fn flush_mutation_observers_callback( } rv.set_undefined(); } - -fn flush_intersection_checks_callback( - scope: &mut v8::PinScope<'_, '_>, - _args: v8::FunctionCallbackArguments<'_>, - mut rv: v8::ReturnValue<'_, v8::Value>, -) { - if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) { - dom_access::flush_intersection_checks(scope, host_ptr); - } - rv.set_undefined(); -} - -fn flush_intersection_observers_callback( - scope: &mut v8::PinScope<'_, '_>, - _args: v8::FunctionCallbackArguments<'_>, - mut rv: v8::ReturnValue<'_, v8::Value>, -) { - if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) { - dom_access::flush_intersection_observers(scope, host_ptr); - } - rv.set_undefined(); -} diff --git a/moli-renderer-v8/src/page_task_queue/rendering_update.rs b/moli-renderer-v8/src/page_task_queue/rendering_update.rs index 70d17228eef..7fc429e3411 100644 --- a/moli-renderer-v8/src/page_task_queue/rendering_update.rs +++ b/moli-renderer-v8/src/page_task_queue/rendering_update.rs @@ -37,6 +37,7 @@ pub(crate) enum RendererPageRenderingUpdateTaskKind { AnimationStartScan, PostParseAutofocus, AnimationFrameCallbacks, + IntersectionObserverDelivery, EnvironmentChange, } diff --git a/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs b/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs index 85245147f49..326e0744a53 100644 --- a/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs +++ b/moli-renderer-v8/src/runtime/tests/extracted/input_dispatch.rs @@ -335,10 +335,16 @@ addEventListener("wheel", event => { let (observer_installed, _) = page .run_async_command(RendererPageCommand::EvaluateExpression { expression: r#" +const initialIntersection = Promise.withResolvers(); +const changedIntersection = Promise.withResolvers(); +globalThis.__lmActionWindowInitialIntersection = initialIntersection.promise; +globalThis.__lmActionWindowChangedIntersection = changedIntersection.promise; globalThis.__lmActionWindowObserver = new IntersectionObserver(entries => { const entry = entries.find(candidate => candidate.target.id === "target"); if (!entry) return; __lmActionWindowIoLog.push(entry.isIntersecting); + initialIntersection.resolve(); + if (entry.isIntersecting) changedIntersection.resolve(); }); __lmActionWindowObserver.observe(document.getElementById("target")); addEventListener("scroll", () => fetch("/action-window-scroll-applied"), { once: true }); @@ -355,8 +361,8 @@ addEventListener("scroll", () => fetch("/action-window-scroll-applied"), { once: ); let (initial_intersection, _) = page .run_async_command(RendererPageCommand::EvaluateExpression { - expression: "JSON.stringify(__lmActionWindowIoLog)".to_owned(), - await_promise: false, + expression: "__lmActionWindowInitialIntersection.then(() => JSON.stringify(__lmActionWindowIoLog))".to_owned(), + await_promise: true, }) .await .expect("initial intersection state should be observable"); @@ -388,20 +394,20 @@ addEventListener("scroll", () => fetch("/action-window-scroll-applied"), { once: let (state, _) = page .run_async_command(RendererPageCommand::EvaluateExpression { - expression: r#"JSON.stringify({ + expression: r#"__lmActionWindowChangedIntersection.then(() => JSON.stringify({ scrollY, wheelLog: __lmActionWindowWheelLog, ioLog: __lmActionWindowIoLog -})"# - .to_owned(), - await_promise: false, +}))"# + .to_owned(), + await_promise: true, }) .await .expect("applied action-window state should remain observable"); assert_eq!( renderer_json_value(state), Some(serde_json::json!( - r#"{"scrollY":100,"wheelLog":["event:100","microtask:100","event:-100","microtask:-100","event:100","microtask:100"],"ioLog":[false]}"# + r#"{"scrollY":100,"wheelLog":["event:100","microtask:100","event:-100","microtask:-100","event:100","microtask:100"],"ioLog":[false,true]}"# )) ); diff --git a/moli-renderer-v8/src/script_vm/dom_heavy_regression_tests.rs b/moli-renderer-v8/src/script_vm/dom_heavy_regression_tests.rs index a19261199d6..19ee5b52fc5 100644 --- a/moli-renderer-v8/src/script_vm/dom_heavy_regression_tests.rs +++ b/moli-renderer-v8/src/script_vm/dom_heavy_regression_tests.rs @@ -238,11 +238,8 @@ fn live_range_offsets_shift_by_inserted_count_for_document_fragment_insert() { /// Bootstraps `` on the VM and then runs the caller-provided /// JS expression, returning whatever it evaluates to. Used by the -/// IntersectionObserver tests that need to interleave observer setup, -/// DOM mutation, and post-microtask state reads across multiple -/// `vm.eval` calls (each `eval` drains microtasks at the end, so -/// splitting steps across calls is how we let the IO delivery callback -/// actually fire between mutations). +/// Synchronous setup and state reads. Rendering-dependent tests explicitly +/// use `eval_with_rendering` to complete production Page tasks. fn eval_with_body(vm: &mut ScriptVm, expr: &str) -> String { let script = format!( r#" @@ -260,26 +257,43 @@ fn eval_with_body(vm: &mut ScriptVm, expr: &str) -> String { vm.eval(&script).expect("expression should evaluate") } -#[test] -fn intersection_observer_callback_fires_after_dom_mutation_without_mutation_observer() { +fn new_observer_regression_vm() -> crate::runtime::PageVmTaskExecutorTestHarness { + let loader = + crate::network::ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + crate::runtime::PageVmTaskExecutorTestHarness::new( + url::Url::parse("https://dom-heavy-regression.test/").unwrap(), + &loader, + ) +} + +/// Complete a rendering opportunity and its subsequent observer delivery task +/// using the same dispatcher as production, between geometry-test phases. +async fn eval_with_rendering( + vm: &mut crate::runtime::PageVmTaskExecutorTestHarness, + expr: &str, +) -> String { + let result = eval_with_body(vm, expr); + let loader = + crate::network::ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("render observer scene"); + result +} + +#[tokio::test(flavor = "current_thread")] +async fn intersection_observer_callback_fires_after_dom_mutation_without_mutation_observer() { // Regression for the queue_intersection_checks → records.is_empty() // implicit invariant break: with only an IntersectionObserver registered // (no MutationObserver), the mutation_records_enabled flag suppresses // record allocation, which used to mask the "DOM mutated" signal that // queue_mutation_records relied on to schedule intersection checks. // - // The test runs in three phases so we can drain microtasks between - // observer setup, DOM mutation, and the assertion read: - // 1. Register the IntersectionObserver; the initial-intersection - // microtask fires at eval-end and bumps the counter to 1. - // 2. Detach/reattach the target. Intersection checks must run - // synchronously inside the mutation pipeline, queue entries, and - // schedule a delivery microtask that drains at eval-end. - // 3. Read the counter. Pre-fix the counter stays at 1 because step 2 - // never queued any mutation-driven entries; post-fix the counter - // is strictly greater than 1. - let mut vm = new_dom_regression_vm(); - eval_with_body( + // Rendering samples the final state of each script, then a separate Page + // task delivers changes. Cover both a transient detach/reattach and the + // same mutations separated by actual rendering opportunities. + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoCallbacks = 0; @@ -293,24 +307,32 @@ fn intersection_observer_callback_fires_after_dom_mutation_without_mutation_obse window.__startPreparedObserver = () => window.__lmIoObserver.observe(window.__lmIoTarget); return 'observed'; })()"#, - ); + ).await; vm.publish_layout_for_test() .expect("publish observer fixture"); - eval_with_body(&mut vm, "window.__startPreparedObserver()"); - let after_initial = eval_with_body(&mut vm, "String(window.__lmIoCallbacks)"); + eval_with_rendering(&mut vm, "window.__startPreparedObserver()").await; + let after_initial = eval_with_rendering(&mut vm, "String(window.__lmIoCallbacks)").await; assert_eq!( after_initial, "1", "initial-intersection delivery should bring callback count to 1", ); - eval_with_body( + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoTarget.remove(); document.body.appendChild(window.__lmIoTarget); return 'mutated'; })()"#, + ) + .await; + assert_eq!( + eval_with_rendering(&mut vm, "String(window.__lmIoCallbacks)").await, + "1", + "detach/reattach within one script does not change the rendered intersection" ); - let after_mutation = eval_with_body(&mut vm, "String(window.__lmIoCallbacks)"); + eval_with_rendering(&mut vm, "window.__lmIoTarget.remove()").await; + eval_with_rendering(&mut vm, "document.body.appendChild(window.__lmIoTarget)").await; + let after_mutation = eval_with_rendering(&mut vm, "String(window.__lmIoCallbacks)").await; let after_mutation: i64 = after_mutation .parse() .expect("callback counter must parse as an integer"); @@ -321,10 +343,10 @@ fn intersection_observer_callback_fires_after_dom_mutation_without_mutation_obse ); } -#[test] -fn intersection_observer_callback_can_replace_its_observation_reentrantly() { - let mut vm = new_dom_regression_vm(); - eval_with_body( +#[tokio::test(flavor = "current_thread")] +async fn intersection_observer_callback_can_replace_its_observation_reentrantly() { + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoReentrantLog = []; @@ -349,13 +371,15 @@ fn intersection_observer_callback_can_replace_its_observation_reentrantly() { observer.observe(first); return 'observed'; })()"#, - ); + ) + .await; assert_eq!( - eval_with_body( + eval_with_rendering( &mut vm, "JSON.stringify([window.__lmIoReentrantLog, window.__lmIoTakeRecordsDuringCallback])", - ), + ) + .await, r#"[["first","second"],0]"#, "delivery must release observer owner state before callback reentrant disconnect/observe", ); @@ -436,14 +460,14 @@ fn mutation_observer_callback_can_replace_registration_and_mutate_reentrantly() ); } -#[test] -fn rootless_intersection_observer_keeps_plain_deep_spa_targets_viewport_visible() { +#[tokio::test(flavor = "current_thread")] +async fn rootless_intersection_observer_keeps_plain_deep_spa_targets_viewport_visible() { // Real block layout gives empty wrappers zero height, so a deep plain SPA // sentinel can remain in the first viewport and trigger the same lazy-chunk // callback as Chromium. The explicit Mock provider retains its older // bounded compatibility heuristic separately. - let mut vm = new_dom_regression_vm(); - eval_with_body( + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoEntries = []; @@ -462,19 +486,21 @@ fn rootless_intersection_observer_keeps_plain_deep_spa_targets_viewport_visible( window.__startPreparedObserver = () => observer.observe(target); return 'observed'; })()"#, - ); + ) + .await; vm.publish_layout_for_test() .expect("publish observer fixture"); - eval_with_body(&mut vm, "window.__startPreparedObserver()"); + eval_with_rendering(&mut vm, "window.__startPreparedObserver()").await; - let result = eval_with_body( + let result = eval_with_rendering( &mut vm, r#"JSON.stringify(window.__lmIoEntries.map((entry) => ({ isIntersecting: entry.isIntersecting, ratio: entry.ratio, top: entry.top })))"#, - ); + ) + .await; let entries: serde_json::Value = serde_json::from_str(&result).expect("IO entries should be JSON"); let first = entries @@ -489,13 +515,13 @@ fn rootless_intersection_observer_keeps_plain_deep_spa_targets_viewport_visible( ); } -#[test] -fn rootless_intersection_observer_does_not_promote_display_none_targets() { +#[tokio::test(flavor = "current_thread")] +async fn rootless_intersection_observer_does_not_promote_display_none_targets() { // Class names have no layout meaning on their own. The stylesheet result, // not a site-specific `hidden` token heuristic, must remove the target's // box from IntersectionObserver geometry. - let mut vm = new_dom_regression_vm(); - eval_with_body( + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoEntries = []; @@ -519,9 +545,10 @@ fn rootless_intersection_observer_does_not_promote_display_none_targets() { observer.observe(target); return 'observed'; })()"#, - ); + ) + .await; - let result = eval_with_body(&mut vm, "JSON.stringify(window.__lmIoEntries)"); + let result = eval_with_rendering(&mut vm, "JSON.stringify(window.__lmIoEntries)").await; let entries: serde_json::Value = serde_json::from_str(&result).expect("IO entries should be JSON"); let first = entries @@ -536,14 +563,14 @@ fn rootless_intersection_observer_does_not_promote_display_none_targets() { assert_eq!(first["left"], 0.0); } -#[test] -fn rootless_intersection_observer_keeps_inline_sized_deep_targets_outside_viewport() { +#[tokio::test(flavor = "current_thread")] +async fn rootless_intersection_observer_keeps_inline_sized_deep_targets_outside_viewport() { // Chromium GUI keeps a sentinel below the viewport after preceding siblings // with real authored height. The rootless IO correction should only erase // mock height from empty wrapper trees; inline geometry hints still // contribute to flow distance. - let mut vm = new_dom_regression_vm(); - eval_with_body( + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoEntries = []; @@ -564,12 +591,13 @@ fn rootless_intersection_observer_keeps_inline_sized_deep_targets_outside_viewpo window.__startPreparedObserver = () => observer.observe(target); return 'observed'; })()"#, - ); + ) + .await; vm.publish_layout_for_test() .expect("publish observer fixture"); - eval_with_body(&mut vm, "window.__startPreparedObserver()"); + eval_with_rendering(&mut vm, "window.__startPreparedObserver()").await; - let result = eval_with_body(&mut vm, "JSON.stringify(window.__lmIoEntries)"); + let result = eval_with_rendering(&mut vm, "JSON.stringify(window.__lmIoEntries)").await; let entries: serde_json::Value = serde_json::from_str(&result).expect("IO entries should be JSON"); let first = entries @@ -584,14 +612,14 @@ fn rootless_intersection_observer_keeps_inline_sized_deep_targets_outside_viewpo ); } -#[test] -fn rootless_intersection_observer_counts_text_content_flow_units() { +#[tokio::test(flavor = "current_thread")] +async fn rootless_intersection_observer_counts_text_content_flow_units() { // Flight result cards and similar list rows often get most of their real // height from text/content rather than inline styles. Rootless IO should // not collapse those content-bearing rows as if they were empty wrappers, // otherwise infinite-list sentinels become visible too early. - let mut vm = new_dom_regression_vm(); - eval_with_body( + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoEntries = []; @@ -612,12 +640,13 @@ fn rootless_intersection_observer_counts_text_content_flow_units() { window.__startPreparedObserver = () => observer.observe(target); return 'observed'; })()"#, - ); + ) + .await; vm.publish_layout_for_test() .expect("publish observer fixture"); - eval_with_body(&mut vm, "window.__startPreparedObserver()"); + eval_with_rendering(&mut vm, "window.__startPreparedObserver()").await; - let result = eval_with_body(&mut vm, "JSON.stringify(window.__lmIoEntries)"); + let result = eval_with_rendering(&mut vm, "JSON.stringify(window.__lmIoEntries)").await; let entries: serde_json::Value = serde_json::from_str(&result).expect("IO entries should be JSON"); let first = entries @@ -632,15 +661,15 @@ fn rootless_intersection_observer_counts_text_content_flow_units() { ); } -#[test] -fn intersection_observer_and_mutation_observer_coexist_during_dom_mutations() { +#[tokio::test(flavor = "current_thread")] +async fn intersection_observer_and_mutation_observer_coexist_during_dom_mutations() { // Regression guard for the fix to queue_mutation_records: the IO // scheduling must run whether or not records actually got pushed, but // MutationObserver delivery must continue to work when records *are* // present. Register both, mutate the DOM, and verify both pipelines // fire. - let mut vm = new_dom_regression_vm(); - eval_with_body( + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoTarget = document.createElement('div'); @@ -657,23 +686,33 @@ fn intersection_observer_and_mutation_observer_coexist_during_dom_mutations() { window.__lmMoObserver.observe(document.body, { childList: true, subtree: true }); return 'observed'; })()"#, - ); + ).await; vm.publish_layout_for_test() .expect("publish observer fixture"); - eval_with_body(&mut vm, "window.__startPreparedObserver()"); - eval_with_body(&mut vm, "String(window.__lmIoCount)"); - eval_with_body( + eval_with_rendering(&mut vm, "window.__startPreparedObserver()").await; + eval_with_rendering(&mut vm, "String(window.__lmIoCount)").await; + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoTarget.remove(); document.body.appendChild(window.__lmIoTarget); return 'mutated'; })()"#, + ) + .await; + assert_eq!( + eval_with_rendering(&mut vm, "String(window.__lmIoCount)").await, + "1", + "detach/reattach within one script does not change the rendered intersection" ); - let io_count: i64 = eval_with_body(&mut vm, "String(window.__lmIoCount)") + eval_with_rendering(&mut vm, "window.__lmIoTarget.remove()").await; + eval_with_rendering(&mut vm, "document.body.appendChild(window.__lmIoTarget)").await; + let io_count: i64 = eval_with_rendering(&mut vm, "String(window.__lmIoCount)") + .await .parse() .expect("IO callback counter must parse"); - let mo_count: i64 = eval_with_body(&mut vm, "String(window.__lmMoCount)") + let mo_count: i64 = eval_with_rendering(&mut vm, "String(window.__lmMoCount)") + .await .parse() .expect("MO records counter must parse"); assert!( @@ -688,8 +727,8 @@ fn intersection_observer_and_mutation_observer_coexist_during_dom_mutations() { ); } -#[test] -fn mutation_observer_disconnect_does_not_starve_intersection_observer() { +#[tokio::test(flavor = "current_thread")] +async fn mutation_observer_disconnect_does_not_starve_intersection_observer() { // The mutation_records_enabled flag flips off when the last // MutationObserver disconnects. If queue_intersection_checks were // gated on the flag (or on records being non-empty), an IO registered @@ -697,8 +736,8 @@ fn mutation_observer_disconnect_does_not_starve_intersection_observer() { // receiving mutation-driven entries. This test pins the lifecycle: // attach MO → disconnect MO → register IO → mutate → IO must still // see deliveries. - let mut vm = new_dom_regression_vm(); - eval_with_body( + let mut vm = new_observer_regression_vm(); + eval_with_rendering( &mut vm, r#"(() => { const transient = new MutationObserver(() => {}); @@ -713,20 +752,29 @@ fn mutation_observer_disconnect_does_not_starve_intersection_observer() { window.__startPreparedObserver = () => window.__lmIoObserver.observe(window.__lmIoTarget); return 'observed'; })()"#, - ); + ).await; vm.publish_layout_for_test() .expect("publish observer fixture"); - eval_with_body(&mut vm, "window.__startPreparedObserver()"); - eval_with_body(&mut vm, "String(window.__lmIoCount)"); - eval_with_body( + eval_with_rendering(&mut vm, "window.__startPreparedObserver()").await; + eval_with_rendering(&mut vm, "String(window.__lmIoCount)").await; + eval_with_rendering( &mut vm, r#"(() => { window.__lmIoTarget.remove(); document.body.appendChild(window.__lmIoTarget); return 'mutated'; })()"#, + ) + .await; + assert_eq!( + eval_with_rendering(&mut vm, "String(window.__lmIoCount)").await, + "1", + "detach/reattach within one script does not change the rendered intersection" ); - let count: i64 = eval_with_body(&mut vm, "String(window.__lmIoCount)") + eval_with_rendering(&mut vm, "window.__lmIoTarget.remove()").await; + eval_with_rendering(&mut vm, "document.body.appendChild(window.__lmIoTarget)").await; + let count: i64 = eval_with_rendering(&mut vm, "String(window.__lmIoCount)") + .await .parse() .expect("IO callback counter must parse"); assert!( diff --git a/moli-renderer-v8/src/script_vm/layout.rs b/moli-renderer-v8/src/script_vm/layout.rs index 7f8c525cc9b..37bc09804ea 100644 --- a/moli-renderer-v8/src/script_vm/layout.rs +++ b/moli-renderer-v8/src/script_vm/layout.rs @@ -214,7 +214,8 @@ impl ScriptVm { &mut moli_layout::LayoutPassResult, ) -> Result, ) -> Result, moli_layout::LayoutError> { - self.with_fresh_layout_pass_in_environment(request, None, consume) + let document = self._context_host.borrow().document_handle(); + self.with_fresh_document_layout_pass(document, request, consume) } fn with_fresh_layout_pass_in_environment( @@ -224,6 +225,35 @@ impl ScriptVm { consume: impl FnOnce( &mut moli_layout::LayoutPassResult, ) -> Result, + ) -> Result, moli_layout::LayoutError> { + let document = self._context_host.borrow().document_handle(); + self.with_fresh_document_layout_pass_in_environment( + document, + request, + environment_override, + consume, + ) + } + + fn with_fresh_document_layout_pass( + &mut self, + document: DomHandle, + request: moli_layout::LayoutPassRequest, + consume: impl FnOnce( + &mut moli_layout::LayoutPassResult, + ) -> Result, + ) -> Result, moli_layout::LayoutError> { + self.with_fresh_document_layout_pass_in_environment(document, request, None, consume) + } + + fn with_fresh_document_layout_pass_in_environment( + &mut self, + document: DomHandle, + request: moli_layout::LayoutPassRequest, + environment_override: Option, + consume: impl FnOnce( + &mut moli_layout::LayoutPassResult, + ) -> Result, ) -> Result, moli_layout::LayoutError> { // Font resources are reconciled by the document resource lifecycle. // Layout consumes registered data and performs no font loading work. @@ -231,10 +261,10 @@ impl ScriptVm { // Printing consumes a temporary projection. Screenshots, screencast // frames and explicit refreshes publish geometry for subsequent reads. let publishes_layout = request.reason != moli_layout::LayoutFlushReason::Print; - let (document, result) = { + let rendering_update = request.reason == moli_layout::LayoutFlushReason::RenderingUpdate; + let result = { let context_host = self._context_host.borrow(); - let document = context_host.document_handle(); - let result = context_host + context_host .build_layout_pass_for_document_in_environment( document, request, @@ -254,8 +284,7 @@ impl ScriptVm { context_host.publish_layout_pass_for_document(document, pass); } Ok(Some((value, css_images))) - }); - (document, result) + }) }; let (result, css_images) = match result { Ok(Some((value, css_images))) => (Ok(Some(value)), css_images), @@ -266,7 +295,13 @@ impl ScriptVm { if publishes_layout && matches!(&result, Ok(Some(_))) && let Err(error) = self.with_current_main_world_scope(|scope, runtime_ptr| { - crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr); + if !rendering_update { + crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr); + crate::observer_runtime::queue_resize_observer_rendering_updates( + scope, + runtime_ptr, + ); + } crate::native_bridge::element::queue_revealed_lazy_image_loads( scope, runtime_ptr, diff --git a/moli-renderer-v8/src/script_vm/rendering_update.rs b/moli-renderer-v8/src/script_vm/rendering_update.rs index 9b8bf430dfd..1b01643af27 100644 --- a/moli-renderer-v8/src/script_vm/rendering_update.rs +++ b/moli-renderer-v8/src/script_vm/rendering_update.rs @@ -58,16 +58,112 @@ impl ScriptVm { ) -> Result { let task = authorization.into_task(); let owner = task.owner(); + let (mut invoked, animation_owner) = + self.with_default_context_scope(|scope, host_ptr| { + unsafe { &mut *host_ptr } + .apply_authorized_rendering_update( + scope, + host_ptr, + task.task_id(), + owner.target(), + task.kind(), + ) + .ok_or_else(|| anyhow!("authorized rendering update lost its exact payload")) + })?; + let Some(animation_owner) = animation_owner else { + return Ok(invoked); + }; + let target = owner.target(); + if crate::observer_runtime::document_has_rendering_observers( + &mut self._context_host.borrow_mut(), + animation_owner, + ) { + // Keep a single deadline across callbacks, their microtasks, error + // reporting and repeated layout. A callback can keep adding deeper + // targets indefinitely even though each individual broadcast ends. + let watchdog = self.with_default_context_scope(|scope, _| { + Ok(crate::v8_execution_watchdog::V8ExecutionWatchdog::arm( + crate::v8_execution_watchdog::V8ExecutionWatchdogKind::RenderingObservers, + scope.thread_safe_handle(), + crate::v8_execution_watchdog::SCRIPT_TURN_WATCHDOG_TIMEOUT, + )) + })?; + let mut depth = 0; + loop { + let current = self.with_default_context_scope(|scope, host_ptr| { + if scope.is_execution_terminating() { + return Ok(None); + } + let host = unsafe { &mut *host_ptr }; + Ok(host + .resolve_current_rendering_update_context(scope, target) + .map(|(document, _)| { + host.top_level_document_for_document(document) + .unwrap_or(document) + })) + })?; + let Some(document) = current else { + break; + }; + let request = { + let host = self._context_host.borrow(); + host.layout_policy().uses_real_layout().then(|| { + moli_layout::LayoutPassRequest::new( + host.layout_viewport_for_document(document), + moli_layout::LayoutFlushReason::RenderingUpdate, + ) + }) + }; + if let Some(request) = request { + self.with_fresh_document_layout_pass(document, request, |_| Ok(()))?; + } + let broadcast = self.with_default_context_scope(|scope, host_ptr| { + Ok( + crate::context_bootstrap::broadcast_document_resize_observers( + scope, + host_ptr, + target, + animation_owner, + depth, + )?, + ) + })?; + invoked |= broadcast.invoked; + if let Some(next_depth) = broadcast.shallowest_depth { + depth = next_depth; + } else { + if broadcast.skipped { + self.with_default_context_scope(|scope, host_ptr| { + if !scope.is_execution_terminating() { + crate::context_bootstrap::report_document_resize_observer_loop_error(scope, host_ptr, target); + } + Ok(()) + })?; + invoked = true; + } + break; + } + } + if watchdog.disarm() + == crate::v8_execution_watchdog::V8ExecutionWatchdogOutcome::TimedOut + { + tracing::warn!("rendering observers exceeded their execution deadline"); + } + } self.with_default_context_scope(|scope, host_ptr| { - unsafe { &mut *host_ptr } - .apply_authorized_rendering_update( - scope, - host_ptr, - task.task_id(), - owner.target(), - task.kind(), - ) - .ok_or_else(|| anyhow!("authorized rendering update lost its exact payload")) + invoked |= unsafe { &mut *host_ptr }.finish_document_animation_frame( + scope, + host_ptr, + target, + animation_owner, + ); + crate::observer_runtime::update_document_intersections( + scope, + host_ptr, + target, + animation_owner, + )?; + Ok(invoked) }) } diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/geometry_and_scrolling.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/geometry_and_scrolling.rs index 72a09fe66b2..5039a582fa9 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/geometry_and_scrolling.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/geometry_and_scrolling.rs @@ -104,93 +104,7 @@ fn wheel_default_action_scrolls_unless_canceled() { "120" ); } -#[test] -fn intersection_checks_after_scroll_reuse_geometry_until_fresh_paint() { - let mut vm = new_storage_test_vm("https://scroll-intersection-observer.test/"); - vm.set_viewport_surface(Some(crate::protocol_types::ViewportSurface { - inner_width: 800, - inner_height: 600, - device_pixel_ratio: 1.0, - ..Default::default() - })) - .expect("intersection observer viewport should match the layout fixture"); - vm.eval( - r#" - (() => { - if (!document.documentElement) { - document.appendChild(document.createElement("html")); - } - if (!document.body) { - document.documentElement.appendChild(document.createElement("body")); - } - document.documentElement.style.margin = "0"; - document.body.style.margin = "0"; - document.body.innerHTML = - '
' + - '
' + - '
'; - })() - "#, - ) - .expect("intersection scroll fixture should initialize"); - publish_layout_for_test(&mut vm); - vm.eval( - r#" - (() => { - window.__intersectionStates = []; - window.__intersectionObserver = new IntersectionObserver(entries => { - window.__intersectionStates.push(entries[0].isIntersecting); - }); - window.__intersectionObserver.observe( - document.getElementById("lazy-target") - ); - })() - "#, - ) - .expect("intersection observer should register"); - assert_eq!( - vm.eval("JSON.stringify(window.__intersectionStates)") - .expect("initial intersection state should flush"), - "[false]" - ); - - let mut previous = "[false]"; - for (scroll_y, reason, expected) in [ - ( - 400, - moli_layout::LayoutFlushReason::Screenshot, - "[false,true]", - ), - ( - 0, - moli_layout::LayoutFlushReason::Screencast, - "[false,true,false]", - ), - ] { - let passes_before = vm.layout_pass_observability_for_test().1; - vm.eval(&format!("window.scrollTo(0, {scroll_y})")) - .expect("window scroll should evaluate"); - assert_eq!( - vm.eval("JSON.stringify(window.__intersectionStates)") - .expect("scroll should retain the published intersection geometry"), - previous - ); - assert_eq!(vm.layout_pass_observability_for_test().1, passes_before); - vm.paint_layout_snapshot(moli_layout::PaintViewport::new(800, 600, 1.0), reason) - .expect("fresh paint publishes the scrolled geometry") - .expect("document layout"); - vm.eval("void 0") - .expect("complete the turn and deliver queued observers"); - assert_eq!( - vm.eval("JSON.stringify(window.__intersectionStates)") - .expect("publication should queue observer delivery without another mutation"), - expected - ); - assert_eq!(vm.layout_pass_observability_for_test().1, passes_before + 1); - previous = expected; - } -} #[cfg(feature = "devtools")] #[test] fn wheel_default_action_scrolls_the_innermost_container_then_chains_to_the_root() { @@ -1457,3 +1371,98 @@ fn single_line_text_input_preserves_programmatic_scroll_across_select() { "33" ); } + +#[tokio::test(flavor = "current_thread")] +async fn intersection_checks_after_scroll_wait_for_rendering_and_reuse_published_geometry() { + let mut vm = + new_storage_page_task_executor_test_vm("https://scroll-intersection-observer.test/"); + vm.set_viewport_surface(Some(crate::protocol_types::ViewportSurface { + inner_width: 800, + inner_height: 600, + device_pixel_ratio: 1.0, + ..Default::default() + })) + .expect("intersection observer viewport should match the layout fixture"); + vm.eval( + r#" + (() => { + if (!document.documentElement) { + document.appendChild(document.createElement("html")); + } + if (!document.body) { + document.documentElement.appendChild(document.createElement("body")); + } + document.documentElement.style.margin = "0"; + document.body.style.margin = "0"; + document.body.innerHTML = + '
' + + '
' + + '
'; + })() + "#, + ) + .expect("intersection scroll fixture should initialize"); + vm.publish_layout_for_test() + .expect("publish observer fixture"); + + vm.eval( + r#" + (() => { + window.__intersectionStates = []; + window.__intersectionObserver = new IntersectionObserver(entries => { + window.__intersectionStates.push(entries[0].isIntersecting); + }); + window.__intersectionObserver.observe( + document.getElementById("lazy-target") + ); + })() + "#, + ) + .expect("intersection observer should register"); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!( + vm.eval("JSON.stringify(window.__intersectionStates)") + .expect("initial intersection state should flush"), + "[false]" + ); + + let mut previous = "[false]"; + for (scroll_y, reason, expected) in [ + ( + 400, + moli_layout::LayoutFlushReason::Screenshot, + "[false,true]", + ), + ( + 0, + moli_layout::LayoutFlushReason::Screencast, + "[false,true,false]", + ), + ] { + let passes_before = vm.layout_pass_observability_for_test().1; + vm.eval(&format!("window.scrollTo(0, {scroll_y})")) + .expect("window scroll should evaluate"); + assert_eq!( + vm.eval("JSON.stringify(window.__intersectionStates)") + .expect("scroll should retain the published intersection geometry"), + previous + ); + assert_eq!(vm.layout_pass_observability_for_test().1, passes_before); + vm.paint_layout_snapshot(moli_layout::PaintViewport::new(800, 600, 1.0), reason) + .expect("fresh paint publishes the scrolled geometry") + .expect("document layout"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("render and deliver observers"); + assert_eq!( + vm.eval("JSON.stringify(window.__intersectionStates)") + .expect("publication should queue observer delivery without another mutation"), + expected + ); + assert_eq!(vm.layout_pass_observability_for_test().1, passes_before + 2); + previous = expected; + } +} diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 5b4a95c56e5..9c7fcdb5697 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -2438,6 +2438,7 @@ mod svg_gradient_native_receivers; mod readable_algorithm_arrays; mod remote_playback_interface; +mod rendering_observers; mod rendering_update; mod rtc_configuration; diff --git a/moli-renderer-v8/src/script_vm/tests/observer_callbacks.rs b/moli-renderer-v8/src/script_vm/tests/observer_callbacks.rs index 3efc2fb602d..417da1e6b7a 100644 --- a/moli-renderer-v8/src/script_vm/tests/observer_callbacks.rs +++ b/moli-renderer-v8/src/script_vm/tests/observer_callbacks.rs @@ -305,8 +305,8 @@ fn mutation_observer_observe_accepts_registered_native_proxy_targets_and_receive })()"#).unwrap(), "true"); } -fn observer_callback_test_vm(url: &str) -> StandaloneScriptVmHarness { - let mut vm = new_storage_test_vm(url); +async fn observer_callback_test_vm(url: &str) -> crate::runtime::PageVmTaskExecutorTestHarness { + let mut vm = new_storage_page_task_executor_test_vm(url); vm.eval( r#" (() => { @@ -321,13 +321,17 @@ fn observer_callback_test_vm(url: &str) -> StandaloneScriptVmHarness { "#, ) .expect("observer callback child-realm setup should evaluate"); - materialize_single_child_default_realm_for_test(&mut vm, "observer callback child-realm setup"); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("materialize observer callback child realm"); vm } -#[test] -fn borrowed_performance_methods_use_receiver_timeline_and_entry_realms() { - let mut vm = observer_callback_test_vm("https://performance-borrowed-method-realms.test/"); +#[tokio::test(flavor = "current_thread")] +async fn borrowed_performance_methods_use_receiver_timeline_and_entry_realms() { + let mut vm = + observer_callback_test_vm("https://performance-borrowed-method-realms.test/").await; let source = format!( "({})(window, __observerCallbackFrame.contentWindow).then(result => globalThis.__borrowedTimeline = result, error => globalThis.__borrowedTimeline = {{ error: String(error) }});", include_str!("performance_timeline_borrowed_methods.js"), @@ -340,9 +344,10 @@ fn borrowed_performance_methods_use_receiver_timeline_and_entry_realms() { ); } -#[test] -fn borrowed_performance_observe_reads_and_delivers_the_observers_own_buffer() { - let mut vm = observer_callback_test_vm("https://performance-borrowed-buffered-observe.test/"); +#[tokio::test(flavor = "current_thread")] +async fn borrowed_performance_observe_reads_and_delivers_the_observers_own_buffer() { + let mut vm = + observer_callback_test_vm("https://performance-borrowed-buffered-observe.test/").await; vm.eval( r#" (() => { @@ -368,9 +373,10 @@ fn borrowed_performance_observe_reads_and_delivers_the_observers_own_buffer() { ); } -#[test] -fn borrowed_performance_delivery_survives_retirement_of_the_method_realm() { - let mut vm = observer_callback_test_vm("https://performance-method-realm-retirement.test/"); +#[tokio::test(flavor = "current_thread")] +async fn borrowed_performance_delivery_survives_retirement_of_the_method_realm() { + let mut vm = + observer_callback_test_vm("https://performance-method-realm-retirement.test/").await; vm.eval( r#" (() => { @@ -421,9 +427,10 @@ new PerformanceObserver(list => { assert_eq!(common.finalizer_count(), 0); } -#[test] -fn performance_observer_registration_uses_its_own_global_with_a_foreign_callback_realm() { - let mut vm = observer_callback_test_vm("https://performance-observer-global-isolation.test/"); +#[tokio::test(flavor = "current_thread")] +async fn performance_observer_registration_uses_its_own_global_with_a_foreign_callback_realm() { + let mut vm = + observer_callback_test_vm("https://performance-observer-global-isolation.test/").await; vm.eval( r#" (() => { @@ -452,9 +459,9 @@ fn performance_observer_registration_uses_its_own_global_with_a_foreign_callback ); } -#[test] -fn document_preinsert_validation_precedes_mutation_and_adoption() { - let mut vm = observer_callback_test_vm("https://document-preinsert.test/"); +#[tokio::test(flavor = "current_thread")] +async fn document_preinsert_validation_precedes_mutation_and_adoption() { + let mut vm = observer_callback_test_vm("https://document-preinsert.test/").await; assert_eq!( vm.eval(include_str!("document_preinsert_validation.js")) .expect("Document pre-insert validation should precede mutation and adoption"), @@ -462,9 +469,9 @@ fn document_preinsert_validation_precedes_mutation_and_adoption() { ); } -#[test] -fn windowless_fragment_insertions_preserve_native_mutation_records() { - let mut vm = observer_callback_test_vm("https://windowless-fragments.test/"); +#[tokio::test(flavor = "current_thread")] +async fn windowless_fragment_insertions_preserve_native_mutation_records() { + let mut vm = observer_callback_test_vm("https://windowless-fragments.test/").await; assert_eq!( vm.eval(include_str!("windowless_fragment_mutations.js")) .expect("fragment insertion should preserve native mutation records"), @@ -472,9 +479,10 @@ fn windowless_fragment_insertions_preserve_native_mutation_records() { ); } -#[test] -fn observer_callbacks_use_webidl_callback_function_realm_receiver_and_proxy_semantics() { - let mut vm = observer_callback_test_vm("https://observer-callback-function-semantics.test/"); +#[tokio::test(flavor = "current_thread")] +async fn observer_callbacks_use_webidl_callback_function_realm_receiver_and_proxy_semantics() { + let mut vm = + observer_callback_test_vm("https://observer-callback-function-semantics.test/").await; let queued = vm .eval( @@ -542,6 +550,10 @@ fn observer_callbacks_use_webidl_callback_function_realm_receiver_and_proxy_sema .expect("observer callback-function semantics should queue"); assert_eq!(queued, "queued"); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("deliver rendering observers"); let result = vm .eval( r#" @@ -566,7 +578,7 @@ async fn intersection_entries_use_the_borrowed_callback_realm_in_both_layout_mod moli_page_types::LayoutPolicy::Mock, moli_page_types::LayoutPolicy::OnDemand, ] { - let mut vm = observer_callback_test_vm("https://intersection-entry-realm.test/"); + let mut vm = observer_callback_test_vm("https://intersection-entry-realm.test/").await; vm.set_layout_policy(policy); vm.eval( r#" @@ -618,6 +630,11 @@ async fn intersection_entries_use_the_borrowed_callback_realm_in_both_layout_mod "#, ) .unwrap(); + let loader = + ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("deliver Document intersection task"); assert_eq!( vm.eval("JSON.stringify(rows)").unwrap(), r#"[{"callbackRealm":true,"observerRealm":true,"receiver":true,"arrayRealm":true,"entryRealm":true,"rectRealm":true,"target":true,"count":1,"argc":2}]"#, @@ -640,7 +657,8 @@ async fn intersection_entries_project_targets_into_the_isolated_callback_world() moli_page_types::LayoutPolicy::Mock, moli_page_types::LayoutPolicy::OnDemand, ] { - let mut vm = new_storage_test_vm("https://intersection-isolated-world.test/"); + let mut vm = + new_storage_page_task_executor_test_vm("https://intersection-isolated-world.test/"); vm.set_layout_policy(policy); vm.eval( r#" @@ -676,6 +694,11 @@ async fn intersection_entries_project_targets_into_the_isolated_callback_world() "#, ) .unwrap(); + let loader = + ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("deliver Document intersection task"); assert_eq!( vm.eval_in_isolated_context(isolated, "JSON.stringify(rows)") .unwrap(), @@ -690,9 +713,9 @@ async fn intersection_entries_project_targets_into_the_isolated_callback_world() } } -#[test] -fn observer_callback_exceptions_are_reported_to_the_callback_relevant_window() { - let mut vm = observer_callback_test_vm("https://observer-callback-exception-realm.test/"); +#[tokio::test(flavor = "current_thread")] +async fn observer_callback_exceptions_are_reported_to_the_callback_relevant_window() { + let mut vm = observer_callback_test_vm("https://observer-callback-exception-realm.test/").await; vm.eval( r#" @@ -737,6 +760,10 @@ fn observer_callback_exceptions_are_reported_to_the_callback_relevant_window() { ) .expect("observer exception projection should queue"); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("deliver rendering observers"); let result = vm .eval( "JSON.stringify(globalThis.__observerCallbackErrors.sort((a, b) => a.message.localeCompare(b.message)))", @@ -748,9 +775,9 @@ fn observer_callback_exceptions_are_reported_to_the_callback_relevant_window() { ); } -#[test] -fn observer_deliveries_retire_with_the_exact_observer_or_callback_realm() { - let mut vm = observer_callback_test_vm("https://observer-callback-retirement.test/"); +#[tokio::test(flavor = "current_thread")] +async fn observer_deliveries_retire_with_the_exact_observer_or_callback_realm() { + let mut vm = observer_callback_test_vm("https://observer-callback-retirement.test/").await; let queued = vm .eval( @@ -820,6 +847,10 @@ fn observer_deliveries_retire_with_the_exact_observer_or_callback_realm() { .expect("observer retirement should queue"); assert_eq!(queued, "true"); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("deliver rendering observers"); let result = vm .eval("JSON.stringify(globalThis.__retiredObserverCallbacks)") .expect("retired observer callbacks should remain suppressed"); @@ -842,6 +873,10 @@ fn js_owned_observer_callback_cycles_remain_v8_collectable() { for (let index = 0; index < 128; index++) { let resizeObserver; resizeObserver = new ResizeObserver(() => resizeObserver.disconnect()); + const target = document.createElement('div'); + resizeObserver.observe(target); + if (index % 2) resizeObserver.unobserve(target); + else resizeObserver.disconnect(); let performanceObserver; performanceObserver = new PerformanceObserver( @@ -913,7 +948,7 @@ fn performance_observer_disconnect_retires_and_reobserve_restores_delivery() { #[tokio::test(flavor = "current_thread")] async fn mutation_record_node_lists_are_native_readonly_snapshots() { - let mut vm = observer_callback_test_vm("https://mutation-record-node-lists.test/"); + let mut vm = observer_callback_test_vm("https://mutation-record-node-lists.test/").await; vm.eval(include_str!("mutation_record_node_lists.js")) .expect("MutationRecord NodeList fixture should evaluate"); let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); diff --git a/moli-renderer-v8/src/script_vm/tests/rendering_observers.rs b/moli-renderer-v8/src/script_vm/tests/rendering_observers.rs new file mode 100644 index 00000000000..ce7168fc9ba --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/rendering_observers.rs @@ -0,0 +1,357 @@ +use super::*; + +#[tokio::test(flavor = "current_thread")] +async fn resize_observer_delivery_ignores_inherited_array_index_accessors() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-array-prototype.test/"); + vm.eval( + r#" +const target = document.body.appendChild(document.createElement('div')); +target.style.cssText = 'width:10px;height:20px'; +globalThis.log = ''; +let traps = 0; +const observer = new ResizeObserver(entries => { + const entry = entries[0]; + log = entries.length + ':' + (entry.target === target) + ':' + entry.contentRect.width + ':' + + entry.contentBoxSize[0].blockSize + ':' + entry.borderBoxSize[0].inlineSize + ':' + traps; + observer.disconnect(); +}); +observer.observe(target); +Object.defineProperty(Array.prototype, '0', { + configurable: true, + get() { traps++; return undefined; }, + set() { traps++; } +}); +// Avoid serializing Array.prototype as the evaluation result in the test host. +void 0; +"#, + ) + .unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!( + vm.eval("delete Array.prototype[0]; log").unwrap(), + "1:true:10:20:10:0" + ); +} + +#[tokio::test(flavor = "current_thread")] +async fn rendering_observers_follow_animation_callbacks_and_precede_focus_fixup() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://rendering-observers.test/"); + vm.eval(r#" +const target = document.body.appendChild(document.createElement('button')); +target.style.cssText = 'width:40px;height:30px;padding:0;border:0'; +target.focus(); +globalThis.log = []; +target.addEventListener('blur', () => log.push('blur')); +const resize = new ResizeObserver(entries => { + log.push('resize:' + entries[0].contentRect.width + ':' + (document.activeElement === target)); + resize.disconnect(); + queueMicrotask(() => log.push('resize-microtask')); +}); +const intersection = new IntersectionObserver(() => { + log.push('intersection:' + (document.activeElement === document.body)); + intersection.disconnect(); +}); +intersection.observe(target); +resize.observe(target); +queueMicrotask(() => log.push('microtask')); +requestAnimationFrame(() => { + log.push('frame'); + target.style.width = '90px'; + target.disabled = true; +}); +for (const name of ['requestAnimationFrame', 'setTimeout', 'setInterval']) { + Object.defineProperty(window, name, {configurable: true, get() { throw new Error('author ' + name); }}); +} +"#).unwrap(); + assert_eq!(vm.eval("log.join('|')").unwrap(), "microtask"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!( + vm.eval("log.join('|')").unwrap(), + "microtask|frame|resize:90:true|resize-microtask|blur|intersection:true" + ); +} + +#[tokio::test(flavor = "current_thread")] +async fn resize_observer_depth_loop_refreshes_layout_and_defers_skipped_targets() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-depth-loop.test/"); + vm.eval(r#" +const shallow = document.body.appendChild(document.createElement('div')); +const middle = shallow.appendChild(document.createElement('div')); +const deep = middle.appendChild(document.createElement('div')); +const targets = [shallow, middle, deep]; +targets.forEach((target, i) => { target.id = String(i); target.style.cssText = 'width:10px;height:10px'; }); +globalThis.log = []; +let frame = 0; +requestAnimationFrame(() => { frame = 1; requestAnimationFrame(() => { frame = 2; }); }); +addEventListener('error', event => { + if (event.message === 'ResizeObserver loop completed with undelivered notifications.') { + log.push('error:' + frame); + event.preventDefault(); + } +}); +let calls = 0; +const observer = new ResizeObserver(entries => { + calls++; + log.push(frame + ':' + entries.map(entry => entry.target.id + '=' + entry.contentRect.width).join(',')); + queueMicrotask(() => log.push('microtask:' + calls)); + if (calls < 4) targets.forEach(target => { target.style.width = (10 + calls) + 'px'; }); + else observer.disconnect(); +}); +targets.forEach(target => observer.observe(target)); +"#).unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!( + vm.eval("log.join('|')").unwrap(), + "1:0=10,1=10,2=10|microtask:1|1:1=11,2=11|microtask:2|1:2=12|microtask:3|error:1|2:0=13,1=13,2=13|microtask:4" + ); +} + +#[tokio::test(flavor = "current_thread")] +async fn resize_observer_uses_constructor_order_and_disconnect_cancels_active_delivery() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-registration-order.test/"); + vm.eval(r#" +const target = document.body.appendChild(document.createElement('div')); +target.style.cssText = 'width:10px;height:10px'; +globalThis.log = []; +const first = new ResizeObserver(() => { log.push('first'); last.disconnect(); first.disconnect(); }); +const second = new ResizeObserver(() => { log.push('second'); second.disconnect(); }); +const last = new ResizeObserver(() => log.push('last')); +last.observe(target); +second.observe(target); +first.observe(target); +first.disconnect(); +first.observe(target); +"#).unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("log.join('|')").unwrap(), "first|second"); +} + +#[tokio::test(flavor = "current_thread")] +async fn resize_observer_samples_flattened_shadow_depth_for_reentrant_observers() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-shadow-depth.test/"); + vm.eval(r#" +const host = document.body.appendChild(document.createElement('div')); +host.style.cssText = 'width:10px;height:10px'; +globalThis.log = []; +let frame = 0; +requestAnimationFrame(() => { frame = 1; requestAnimationFrame(() => { frame = 2; }); }); +addEventListener('error', event => { log.push('error'); event.preventDefault(); }); +const first = new ResizeObserver(() => { + log.push('host:' + frame); + first.disconnect(); + const root = host.attachShadow({mode:'open'}); + const child = root.appendChild(document.createElement('div')); + child.style.cssText = 'width:5px;height:5px'; + const second = new ResizeObserver(entries => { log.push('child:' + frame + ':' + entries[0].contentRect.width); second.disconnect(); }); + second.observe(child); +}); +first.observe(host); +"#).unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("log.join('|')").unwrap(), "host:1|child:1:5"); +} + +#[tokio::test(flavor = "current_thread")] +async fn rendering_observers_do_not_continue_a_replaced_document_or_retired_callback() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-exact-document.test/"); + vm.eval( + r#" +const target = document.body.appendChild(document.createElement('div')); +globalThis.log = []; +let phase = 'old'; +const first = new ResizeObserver(() => { + log.push('first'); + first.disconnect(); + document.open(); + document.write(''); + document.close(); + const replacement = document.getElementById('new'); + replacement.focus(); + replacement.disabled = true; + requestAnimationFrame(() => { phase = 'replacement'; log.push('replacement-frame:' + document.activeElement.id); }); +}); +const second = new ResizeObserver(() => { 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|replacement-frame:new|second:replacement" + ); + vm.eval( + r#" +const iframe = document.body.appendChild(document.createElement('iframe')); +const child = iframe.contentWindow; +child.document.body.innerHTML = '
'; +const observer = new ResizeObserver(child.Function("parent.log.push('retired')")); +observer.observe(child.document.getElementById('target')); +iframe.remove(); +"#, + ) + .unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("log.includes('retired')").unwrap(), "false"); +} + +#[tokio::test(flavor = "current_thread")] +async fn rendering_observer_watchdog_bounds_callbacks_and_microtasks() { + use crate::v8_execution_watchdog::{V8ExecutionWatchdog, V8ExecutionWatchdogKind}; + let _budget = V8ExecutionWatchdog::override_timeout_for_test( + V8ExecutionWatchdogKind::RenderingObservers, + std::time::Duration::from_millis(100), + ); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + for observer in ["ResizeObserver", "IntersectionObserver"] { + for runaway in [ + "while (true) {}", + "queueMicrotask(() => { while (true) {} });", + ] { + let mut vm = + new_storage_page_task_executor_test_vm("https://rendering-observer-watchdog.test/"); + vm.eval(&format!( + r#" +const target = document.body.appendChild(document.createElement('div')); +globalThis.calls = 0; +const observer = new {observer}(() => {{ calls++; observer.disconnect(); {runaway} }}); +observer.observe(target); +"# + )) + .unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!( + vm.eval("[calls, 6 * 7].join('|')").unwrap(), + "1|42", + "{observer}: {runaway}" + ); + } + } +} + +#[tokio::test(flavor = "current_thread")] +async fn rendering_observers_wake_for_cssom_and_adopted_sheet_changes() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-cssom.test/"); + vm.eval( + r#" +const style = document.head.appendChild(document.createElement('style')); +style.textContent = '.probe { width:10px;height:10px }'; +const target = document.body.appendChild(document.createElement('div')); +target.className = 'probe'; +globalThis.log = []; +const observer = new ResizeObserver(entries => log.push(entries[0].contentRect.width)); +observer.observe(target); +"#, + ) + .unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("log.join('|')").unwrap(), "10"); + for (script, expected) in [ + ("style.sheet.cssRules[0].style.width = '20px'", "10|20"), + ( + "style.sheet.deleteRule(0); style.sheet.insertRule('.probe { width:30px;height:10px }')", + "10|20|30", + ), + ( + "globalThis.sheet = new CSSStyleSheet(); sheet.replaceSync('.probe { width:40px;height:10px }'); document.adoptedStyleSheets = [sheet]", + "10|20|30|40", + ), + ( + "sheet.replaceSync('.probe { width:50px;height:10px }')", + "10|20|30|40|50", + ), + ] { + vm.eval(script).unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("log.join('|')").unwrap(), expected, "{script}"); + } +} + +#[tokio::test(flavor = "current_thread")] +async fn resize_observer_tracks_cross_document_targets_without_relying_on_the_mutator_realm() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-cross-document.test/"); + vm.eval( + r#" +const iframe = document.body.appendChild(document.createElement('iframe')); +const child = iframe.contentWindow; +child.document.body.innerHTML = '
'; +const target = child.document.getElementById('target'); +globalThis.log = []; +const observer = new ResizeObserver(entries => log.push(entries[0].contentRect.width)); +observer.observe(target); +"#, + ) + .unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + vm.eval("child.eval(\"document.getElementById('target').style.width = '20px'\")") + .unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("log.join('|')").unwrap(), "10|20"); + vm.eval("ResizeObserver.prototype.disconnect.call(observer); target.style.width = '30px'") + .unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("log.join('|')").unwrap(), "10|20"); +} + +#[tokio::test(flavor = "current_thread")] +async fn resize_observer_boxes_use_frozen_padding_axes_and_zoom_and_ignore_inline_fragments() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm("https://resize-box-geometry.test/"); + vm.eval(r#" +document.body.innerHTML = '
texttext'; +for (const target of document.body.children) target.style.cssText = 'width:41px;height:23px;padding:2px 3px;border:1px solid'; +vertical.style.writingMode = 'vertical-rl'; +document.getElementById('inline-block').style.display = 'inline-block'; +document.body.style.zoom = 2; +globalThis.log = []; +const observer = new ResizeObserver(entries => { + log = entries.map(entry => [entry.target.id, entry.contentRect.x, entry.contentRect.y, entry.contentRect.width, entry.contentRect.height, + entry.contentBoxSize[0].inlineSize, entry.contentBoxSize[0].blockSize, + entry.borderBoxSize[0].inlineSize, entry.borderBoxSize[0].blockSize, + entry.devicePixelContentBoxSize[0].inlineSize, entry.devicePixelContentBoxSize[0].blockSize].join(':')); + observer.disconnect(); +}); +for (const target of document.body.children) observer.observe(target, {box:'device-pixel-content-box'}); +"#).unwrap(); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .unwrap(); + assert_eq!( + vm.eval("log.join('|')").unwrap(), + "block:3:2:41:23:41:23:49:29:82:46|vertical:3:2:41:23:23:41:29:49:46:82|inline:0:0:0:0:0:0:0:0:0:0|inline-block:3:2:41:23:41:23:49:29:82:46" + ); +} diff --git a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs index a3de7254dc6..6bacdf7874c 100644 --- a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs +++ b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs @@ -1669,37 +1669,6 @@ yield; // Publish this scene before reading its geometry. ); } -#[test] -fn resize_observer_callback_runs_after_microtask_checkpoint() { - let mut vm = new_storage_test_vm("https://resize-observer-delivery.test/"); - - let result = vm - .eval( - r#" -(() => { - const html = document.documentElement || document.appendChild(document.createElement('html')); - const body = document.body || html.appendChild(document.createElement('body')); - globalThis.__resizeObserverLog = []; - const target = document.createElement('div'); - target.style.cssText = 'width: 10px; height: 20px'; - body.appendChild(target); - const observer = new ResizeObserver((entries, instance) => { - globalThis.__resizeObserverLog.push(`${entries.length}:${instance === observer}:${entries[0].target === target}`); - }); - observer.observe(target); - return 'scheduled'; -})() -"#, - ) - .expect("ResizeObserver delivery setup should evaluate"); - - assert_eq!(result, "scheduled"); - let delivered = vm - .eval("globalThis.__resizeObserverLog.join('|')") - .expect("ResizeObserver delivery log should evaluate"); - assert_eq!(delivered, "1:true:true"); -} - #[test] fn resize_observer_declared_slots_ignore_prototype_spoofing() { let mut vm = new_storage_test_vm("https://resize-observer-declared-slots.test/"); @@ -2234,3 +2203,43 @@ fn intersection_observer_margins_follow_css_token_syntax() { .expect("IntersectionObserver margins should use CSS token syntax"); assert_eq!(result, "ok"); } + +#[tokio::test(flavor = "current_thread")] +async fn resize_observer_callback_runs_during_rendering_after_microtasks() { + let mut vm = new_storage_page_task_executor_test_vm("https://resize-observer-delivery.test/"); + + let result = vm + .eval( + r#" +(() => { + const html = document.documentElement || document.appendChild(document.createElement('html')); + const body = document.body || html.appendChild(document.createElement('body')); + globalThis.__resizeObserverLog = []; + const target = document.createElement('div'); + target.style.cssText = 'width: 10px; height: 20px'; + body.appendChild(target); + const observer = new ResizeObserver((entries, instance) => { + globalThis.__resizeObserverLog.push(`${entries.length}:${instance === observer}:${entries[0].target === target}`); + }); + observer.observe(target); + return 'scheduled'; +})() +"#, + ) + .expect("ResizeObserver delivery setup should evaluate"); + + assert_eq!(result, "scheduled"); + assert_eq!( + vm.eval("__resizeObserverLog.length").unwrap(), + "0", + "a microtask checkpoint must not deliver resize observations" + ); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + vm.advance_timers_until_deadline_for_test(&loader) + .await + .expect("rendering update"); + let delivered = vm + .eval("globalThis.__resizeObserverLog.join('|')") + .expect("ResizeObserver delivery log should evaluate"); + assert_eq!(delivered, "1:true:true"); +} diff --git a/moli-renderer-v8/src/v8_execution_watchdog.rs b/moli-renderer-v8/src/v8_execution_watchdog.rs index 3f56f6e7ae7..c42dfc5dccb 100644 --- a/moli-renderer-v8/src/v8_execution_watchdog.rs +++ b/moli-renderer-v8/src/v8_execution_watchdog.rs @@ -29,6 +29,7 @@ pub(crate) enum V8ExecutionWatchdogKind { AnimationFrameCallback, LifecycleEvent, FocusFixup, + RenderingObservers, } #[cfg(test)] @@ -40,6 +41,7 @@ impl V8ExecutionWatchdogKind { Self::LifecycleEvent => 2, Self::AnimationFrameCallback => 3, Self::FocusFixup => 4, + Self::RenderingObservers => 5, } } } @@ -47,8 +49,8 @@ impl V8ExecutionWatchdogKind { #[cfg(test)] std::thread_local! { static V8_EXECUTION_WATCHDOG_TIMEOUT_OVERRIDES: - std::cell::Cell<[Option; 5]> = - const { std::cell::Cell::new([None, None, None, None, None]) }; + std::cell::Cell<[Option; 6]> = + const { std::cell::Cell::new([None; 6]) }; } #[cfg(test)] diff --git a/moli-webapi/src/resize_observer_entry.rs b/moli-webapi/src/resize_observer_entry.rs index c6c6744bb35..a8357f4f02e 100644 --- a/moli-webapi/src/resize_observer_entry.rs +++ b/moli-webapi/src/resize_observer_entry.rs @@ -155,7 +155,7 @@ use moli_webidl as webidl; pub const RESIZE_OBSERVER_RECORD_BOX_SLOT: &str = "__moliResizeObserverRecordBox"; -#[derive(Clone, Copy, Default, webidl::WebIdlEnum)] +#[derive(Clone, Copy, Default, PartialEq, webidl::WebIdlEnum)] #[webidl(name = "ResizeObserverBoxOptions", rename_all = "kebab-case")] pub enum ResizeObserverBoxOptions { #[default]