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.
This commit is contained in:
ldm0
2026-11-20 22:47:43 +08:00
parent e841514a35
commit ca5162732a
36 changed files with 1729 additions and 669 deletions
@@ -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);
</script>
</body>
</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);
</script>
</body>
</html>
+14 -3
View File
@@ -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;
@@ -27,6 +27,7 @@ pub enum LayoutFlushReason {
Print,
Explicit,
SynchronousGeometry,
RenderingUpdate,
Test,
}
+16
View File
@@ -44,6 +44,9 @@ pub struct LayoutDocumentMetrics {
/// second time.
#[derive(Clone, Debug, PartialEq)]
pub struct LayoutElementMetrics<N> {
/// 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<LayoutResizeObserverBox>,
pub offset_parent: Option<N>,
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<N> {
@@ -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,
+6 -5
View File
@@ -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};
@@ -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<CallbackRegistrationId, Rc<v8::Global<v8::Object>>>,
active_resize: HashMap<CallbackRegistrationId, Rc<v8::Global<v8::Object>>>,
}
/// 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<WindowExecutionContextIdentity> {
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<WindowExecutionContextOwner>,
) -> Vec<v8::Local<'s, v8::Object>> {
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<WindowExecutionContextIdentity> {
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::<Vec<_>>()
};
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);
+4 -1
View File
@@ -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;
@@ -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>(
@@ -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::<v8::Object>::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::<v8::Object>::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<crate::document_runtime::DomHandle>,
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<v8::Local<'s, v8::Array>, 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<Vec<SampledResizeObservation<'s>>, moli_layout::LayoutError> {
struct PendingEntry<'s> {
record: Option<v8::Local<'s, v8::Object>>,
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::<v8::Object>::try_from(value).ok())
.collect::<Vec<_>>();
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
}
@@ -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<usize>,
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<ResizeObserverBroadcast, moli_layout::LayoutError> {
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<crate::document_runtime::DomHandle>,
) -> 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);
}
@@ -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 =
@@ -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<WindowDocumentTaskTarget>,
observer_target: Option<WindowDocumentTaskTarget>,
handles: Vec<u32>,
callbacks: HashMap<u32, WindowWebIdlCallbackFunction>,
}
@@ -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
@@ -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<LatestFrozenLayout>,
@@ -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<bool> {
) -> Option<(bool, Option<super::WindowExecutionContextOwner>)> {
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(
@@ -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>(
@@ -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(
@@ -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(
@@ -22,6 +22,10 @@ pub(super) struct ObserverCallback {
}
impl ObserverCallback {
pub(super) fn observer_identity(&self) -> Option<WindowExecutionContextIdentity> {
self.observer_identity
}
pub(super) fn new(
scope: &mut v8::PinScope<'_, '_>,
host: &PageScriptHost,
@@ -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<WindowExecutionContextOwner>,
) -> Vec<v8::Local<'s, v8::Object>> {
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<IntersectionCheckBatch> =
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);
}
@@ -42,12 +42,22 @@ pub(super) struct CompletedIntersectionCheckBatch {
}
impl ObserverStore {
pub(super) fn take_intersection_check_batch(&mut self) -> Option<IntersectionCheckBatch> {
pub(super) fn take_intersection_check_batch(
&mut self,
owner: crate::native_bridge::WindowExecutionContextOwner,
) -> Option<IntersectionCheckBatch> {
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(),
+33 -53
View File
@@ -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<u32, IntersectionObserverState>,
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<IntersectionObserverDelivery<'s>> {
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<IntersectionObserverDelivery<'s>>,
) {
for delivery in deliveries {
if scope.is_execution_terminating()
|| !(unsafe { &*host_ptr }).window_document_owner_is_current_for_dispatch_scope(
target.owner(),
target.dispatch_scope(),
)
{
break;
}
if !delivery.callback.is_current(scope) {
continue;
}
@@ -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);
}
}
@@ -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();
}
@@ -37,6 +37,7 @@ pub(crate) enum RendererPageRenderingUpdateTaskKind {
AnimationStartScan,
PostParseAutofocus,
AnimationFrameCallbacks,
IntersectionObserverDelivery,
EnvironmentChange,
}
@@ -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]}"#
))
);
@@ -238,11 +238,8 @@ fn live_range_offsets_shift_by_inserted_count_for_document_fragment_insert() {
/// Bootstraps `<html><body>` 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!(
+42 -7
View File
@@ -214,7 +214,8 @@ impl ScriptVm {
&mut moli_layout::LayoutPassResult<DomHandle>,
) -> Result<T, moli_layout::LayoutError>,
) -> Result<Option<T>, 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<T>(
@@ -224,6 +225,35 @@ impl ScriptVm {
consume: impl FnOnce(
&mut moli_layout::LayoutPassResult<DomHandle>,
) -> Result<T, moli_layout::LayoutError>,
) -> Result<Option<T>, 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<T>(
&mut self,
document: DomHandle,
request: moli_layout::LayoutPassRequest,
consume: impl FnOnce(
&mut moli_layout::LayoutPassResult<DomHandle>,
) -> Result<T, moli_layout::LayoutError>,
) -> Result<Option<T>, moli_layout::LayoutError> {
self.with_fresh_document_layout_pass_in_environment(document, request, None, consume)
}
fn with_fresh_document_layout_pass_in_environment<T>(
&mut self,
document: DomHandle,
request: moli_layout::LayoutPassRequest,
environment_override: Option<crate::style_engine::StyloStyleEnvironment>,
consume: impl FnOnce(
&mut moli_layout::LayoutPassResult<DomHandle>,
) -> Result<T, moli_layout::LayoutError>,
) -> Result<Option<T>, 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,
@@ -58,16 +58,112 @@ impl ScriptVm {
) -> Result<bool> {
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)
})
}
@@ -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 =
'<div style="height: 800px"></div>' +
'<div id="lazy-target" style="height: 20px"></div>' +
'<div style="height: 1000px"></div>';
})()
"#,
)
.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 =
'<div style="height: 800px"></div>' +
'<div id="lazy-target" style="height: 20px"></div>' +
'<div style="height: 1000px"></div>';
})()
"#,
)
.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;
}
}
@@ -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;
@@ -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");
@@ -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('<!doctype html><button id="new">new</button>');
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 = '<div id="target" style="width:10px;height:10px"></div>';
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 = '<div id="target" style="width:10px;height:10px"></div>';
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 = '<div id="block"></div><div id="vertical"></div><span id="inline">text</span><span id="inline-block">text</span>';
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"
);
}
@@ -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");
}
@@ -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<Duration>; 5]> =
const { std::cell::Cell::new([None, None, None, None, None]) };
std::cell::Cell<[Option<Duration>; 6]> =
const { std::cell::Cell::new([None; 6]) };
}
#[cfg(test)]
+1 -1
View File
@@ -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]