mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
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:
@@ -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>
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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!(
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
+95
-86
@@ -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)]
|
||||
|
||||
@@ -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]
|
||||
|
||||
Reference in New Issue
Block a user