Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(webidl): expose readonly ResizeObserver result snapshots

ldm0ea94f86c700b
diff --git a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs
index 603c6fa14..747f33c5f 100644
--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs
+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs
@@ -737,6 +737,8 @@ pub(in crate::context_bootstrap) fn build_constructor_template<'s>(
.build(scope)
}
ConstructorKind::PerformanceEntry
+ | ConstructorKind::ResizeObserverEntry
+ | ConstructorKind::ResizeObserverSize
| ConstructorKind::PerformanceNavigationTiming
| ConstructorKind::PerformanceMeasure
| ConstructorKind::PerformanceResourceTiming
diff --git a/moli-renderer-v8/src/context_bootstrap/dom_rect.rs b/moli-renderer-v8/src/context_bootstrap/dom_rect.rs
index 7f5558583..3b465ce82 100644
--- a/moli-renderer-v8/src/context_bootstrap/dom_rect.rs
+++ b/moli-renderer-v8/src/context_bootstrap/dom_rect.rs
@@ -289,7 +289,7 @@ pub(crate) fn build_dom_rect_object<'s>(
.expect("DOMRect declaration should bind")
}
-fn build_dom_rect_readonly_object<'s>(
+pub(super) fn build_dom_rect_readonly_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
x: f64,
y: f64,
diff --git a/moli-renderer-v8/src/context_bootstrap/observer_template.rs b/moli-renderer-v8/src/context_bootstrap/observer_template.rs
index da2c66f0b..7fa69de2c 100644
--- a/moli-renderer-v8/src/context_bootstrap/observer_template.rs
+++ b/moli-renderer-v8/src/context_bootstrap/observer_template.rs
@@ -152,6 +152,11 @@ pub(super) fn install_observer_template_bindings<'s>(
let proto = template.prototype_template(scope);
ResizeObserverTemplateMethodsDeclaration::initialize_prototype_template(scope, proto);
}
+ "ResizeObserverEntry" | "ResizeObserverSize" => {
+ super::resize_observer_runtime::install_resize_observer_entry_template_bindings(
+ scope, template, spec_name,
+ );
+ }
"PerformanceObserver" => {
let proto = template.prototype_template(scope);
PerformanceObserverTemplateMethodsDeclaration::initialize_prototype_template(
diff --git a/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs
index 176158db6..6210f2bf6 100644
--- a/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs
+++ b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime.rs
@@ -1,3 +1,4 @@
+mod entry;
use super::*;
use crate::host::report_event_callback_exception;
use crate::observer_runtime::ObserverCallbackId;
@@ -5,6 +6,8 @@ use crate::util::{get_private_value, serialize_v8_iter_array, set_private_value}
use crate::web_api_interfaces;
use crate::webidl;
use crate::window_webidl_callback::WindowWebIdlCallbackFunctionOutcome;
+use entry::ResizeObserverEntryData;
+pub(super) use entry::install_resize_observer_entry_template_bindings;
use moli_webapi_declare::WebApiObject;
#[derive(WebApiObject)]
@@ -26,21 +29,6 @@ struct ResizeObserverObjectDeclaration<'s> {
scheduled: (),
}
-#[derive(WebApiObject)]
-#[webapi(interface = web_api_interfaces::ResizeObserverEntry, prototype = "Object")]
-struct ResizeObserverEntryDeclaration<'scope> {
- #[webapi(data_property, enumerable)]
- target: v8::Local<'scope, v8::Value>,
- #[webapi(data_property, enumerable)]
- content_rect: v8::Local<'scope, v8::Object>,
- #[webapi(data_property, enumerable)]
- content_box_size: Vec<ResizeObserverSizeDeclaration>,
- #[webapi(data_property, enumerable)]
- border_box_size: Vec<ResizeObserverSizeDeclaration>,
- #[webapi(data_property, enumerable)]
- device_pixel_content_box_size: Vec<ResizeObserverSizeDeclaration>,
-}
-
#[derive(WebApiObject)]
#[webapi(plain)]
struct ResizeObserverObservedRecordDeclaration<'scope> {
@@ -50,15 +38,6 @@ struct ResizeObserverObservedRecordDeclaration<'scope> {
observed_box: String,
}
-#[derive(WebApiObject)]
-#[webapi(interface = web_api_interfaces::ResizeObserverSize, prototype = "Object")]
-struct ResizeObserverSizeDeclaration {
- #[webapi(data_property, enumerable)]
- inline_size: f64,
- #[webapi(data_property, enumerable)]
- block_size: f64,
-}
-
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "ResizeObserver")]
struct ResizeObserverConstructorArgs {
@@ -297,7 +276,14 @@ fn resize_observer_flush_callback<'s>(
set_resize_observer_pending_targets(scope, observer, pending_targets);
return;
};
- let entries = match build_resize_observer_entries(scope, pending_targets) {
+ let Some(callback_context) = callback.relevant_context(scope) else {
+ return;
+ };
+ 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);
@@ -453,10 +439,10 @@ fn build_resize_observer_entries<'s>(
.as_ref()
.map(|metrics| f64::from(metrics.offset_size.height))
.unwrap_or(0.0);
- let rect = build_dom_rect_object(scope, 0.0, 0.0, content_width, content_height);
- let content_box_size = resize_observer_box_size_list(content_width, content_height);
- let border_box_size = resize_observer_box_size_list(border_width, border_height);
- let device_pixel_content_box_size = resize_observer_box_size_list(
+ let rect = (0.0, 0.0, content_width, content_height);
+ let content_box_size = (content_width, content_height);
+ let border_box_size = (border_width, border_height);
+ let device_pixel_content_box_size = (
(content_width * f64::from(dpr)).round(),
(content_height * f64::from(dpr)).round(),
);
@@ -478,15 +464,14 @@ fn build_resize_observer_entries<'s>(
}
set_resize_observer_last_reported_size(scope, record, observed_size);
}
- let entry = ResizeObserverEntryDeclaration {
+ let entry = ResizeObserverEntryData {
target: entry.target,
content_rect: rect,
content_box_size,
border_box_size,
device_pixel_content_box_size,
}
- .bind(scope)
- .expect("ResizeObserverEntry declaration should bind");
+ .into_object(scope);
entries.push(entry);
}
Ok(serialize_v8_iter_array(scope, entries).unwrap_or_else(|| v8::Array::new(scope, 0)))
@@ -605,16 +590,6 @@ fn observed_record_index<'s>(
})
}
-fn resize_observer_box_size_list(
- inline_size: f64,
- block_size: f64,
-) -> Vec<ResizeObserverSizeDeclaration> {
- vec![ResizeObserverSizeDeclaration {
- inline_size,
- block_size,
- }]
-}
-
fn throw_resize_observer_layout_error(
scope: &mut v8::PinScope<'_, '_>,
error: moli_layout::LayoutError,
diff --git a/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime/entry.rs b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime/entry.rs
new file mode 100644
index 000000000..2844fec89
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/resize_observer_runtime/entry.rs
@@ -0,0 +1,152 @@
+use crate::context_bootstrap::dom_rect::build_dom_rect_readonly_object;
+use crate::util::{callback_data_index_value, callback_data_item, get_private_value};
+use crate::web_api_interfaces;
+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
+
+const TARGET_SLOT: &str = "__moliResizeObserverEntryTarget";
+const CONTENT_RECT_SLOT: &str = "__moliResizeObserverEntryContentRect";
+const CONTENT_BOX_SIZE_SLOT: &str = "__moliResizeObserverEntryContentBoxSize";
+const BORDER_BOX_SIZE_SLOT: &str = "__moliResizeObserverEntryBorderBoxSize";
+const DEVICE_PIXEL_CONTENT_BOX_SIZE_SLOT: &str =
+ "__moliResizeObserverEntryDevicePixelContentBoxSize";
+const INLINE_SIZE_SLOT: &str = "__moliResizeObserverSizeInlineSize";
+const BLOCK_SIZE_SLOT: &str = "__moliResizeObserverSizeBlockSize";
+
+const ATTRIBUTE_SLOTS: &[&str] = &[
+ TARGET_SLOT,
+ CONTENT_RECT_SLOT,
+ CONTENT_BOX_SIZE_SLOT,
+ BORDER_BOX_SIZE_SLOT,
+ DEVICE_PIXEL_CONTENT_BOX_SIZE_SLOT,
+ INLINE_SIZE_SLOT,
+ BLOCK_SIZE_SLOT,
+];
+
+// Sampling retains native dimensions. JS wrappers are created only for active
+// observations, in the callback's relevant realm when they are delivered.
+pub(super) struct ResizeObserverEntryData<'s> {
+ pub(super) target: v8::Local<'s, v8::Value>,
+ pub(super) content_rect: (f64, f64, f64, f64),
+ pub(super) content_box_size: (f64, f64),
+ pub(super) border_box_size: (f64, f64),
+ pub(super) device_pixel_content_box_size: (f64, f64),
+}
+
+impl<'s> ResizeObserverEntryData<'s> {
+ pub(super) fn into_object(self, scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Object> {
+ let (x, y, width, height) = self.content_rect;
+ let content_rect = build_dom_rect_readonly_object(scope, x, y, width, height);
+ let content_box_size = frozen_box_size(scope, self.content_box_size);
+ let border_box_size = frozen_box_size(scope, self.border_box_size);
+ let device_pixel_content_box_size =
+ frozen_box_size(scope, self.device_pixel_content_box_size);
+ ResizeObserverEntryDeclaration {
+ target: self.target,
+ content_rect,
+ content_box_size,
+ border_box_size,
+ device_pixel_content_box_size,
+ }
+ .bind(scope)
+ .expect("ResizeObserverEntry declaration should bind")
+ }
+}
+
+#[derive(WebApiObject)]
+#[webapi(interface = web_api_interfaces::ResizeObserverEntry)]
+struct ResizeObserverEntryDeclaration<'s> {
+ #[webapi(slot = TARGET_SLOT)]
+ target: v8::Local<'s, v8::Value>,
+ #[webapi(slot = CONTENT_RECT_SLOT)]
+ content_rect: v8::Local<'s, v8::Object>,
+ #[webapi(slot = CONTENT_BOX_SIZE_SLOT)]
+ content_box_size: v8::Local<'s, v8::Array>,
+ #[webapi(slot = BORDER_BOX_SIZE_SLOT)]
+ border_box_size: v8::Local<'s, v8::Array>,
+ #[webapi(slot = DEVICE_PIXEL_CONTENT_BOX_SIZE_SLOT)]
+ device_pixel_content_box_size: v8::Local<'s, v8::Array>,
+}
+
+#[derive(WebApiObject)]
+#[webapi(interface = web_api_interfaces::ResizeObserverSize)]
+struct ResizeObserverSizeDeclaration {
+ #[webapi(slot = INLINE_SIZE_SLOT)]
+ inline_size: f64,
+ #[webapi(slot = BLOCK_SIZE_SLOT)]
+ block_size: f64,
+}
+
+fn frozen_box_size<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ (inline_size, block_size): (f64, f64),
+) -> v8::Local<'s, v8::Array> {
+ let size = ResizeObserverSizeDeclaration::new(inline_size, block_size)
+ .bind(scope)
+ .expect("ResizeObserverSize declaration should bind");
+ let array = v8::Array::new_with_elements(scope, &[size.into()]);
+ assert_eq!(
+ array.set_integrity_level(scope, v8::IntegrityLevel::Frozen),
+ Some(true),
+ "new ResizeObserver box-size array should freeze"
+ );
+ array
+}
+
+#[derive(WebApiFunctionTemplate)]
+#[webapi(interface = web_api_interfaces::ResizeObserverEntry, enumerable, receiver)]
+struct ResizeObserverEntryPrototypeDeclaration {
+ #[webapi(accessor_property, getter = result_attribute_getter, data = callback_data_index_value(scope, 0))]
+ target: (),
+ #[webapi(accessor_property, getter = result_attribute_getter, data = callback_data_index_value(scope, 1))]
+ content_rect: (),
+ #[webapi(accessor_property, getter = result_attribute_getter, data = callback_data_index_value(scope, 2))]
+ content_box_size: (),
+ #[webapi(accessor_property, getter = result_attribute_getter, data = callback_data_index_value(scope, 3))]
+ border_box_size: (),
+ #[webapi(accessor_property, getter = result_attribute_getter, data = callback_data_index_value(scope, 4))]
+ device_pixel_content_box_size: (),
+}
+
+#[derive(WebApiFunctionTemplate)]
+#[webapi(interface = web_api_interfaces::ResizeObserverSize, enumerable, receiver)]
+struct ResizeObserverSizePrototypeDeclaration {
+ #[webapi(accessor_property, getter = result_attribute_getter, data = callback_data_index_value(scope, 5))]
+ inline_size: (),
+ #[webapi(accessor_property, getter = result_attribute_getter, data = callback_data_index_value(scope, 6))]
+ block_size: (),
+}
+
+pub(in crate::context_bootstrap) fn install_resize_observer_entry_template_bindings<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ template: v8::Local<'s, v8::FunctionTemplate>,
+ name: &str,
+) {
+ let prototype = template.prototype_template(scope);
+ match name {
+ "ResizeObserverEntry" => {
+ ResizeObserverEntryPrototypeDeclaration::initialize_prototype_template(
+ scope, prototype,
+ );
+ }
+ "ResizeObserverSize" => {
+ ResizeObserverSizePrototypeDeclaration::initialize_prototype_template(scope, prototype);
+ }
+ _ => {}
+ }
+}
+
+fn result_attribute_getter<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ let Some(slot) =
+ callback_data_item(scope, &args, ATTRIBUTE_SLOTS, "ResizeObserver result slots")
+ else {
+ return;
+ };
+ rv.set(
+ get_private_value(scope, args.this(), slot)
+ .expect("branded ResizeObserver result should retain its attributes"),
+ );
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs b/moli-renderer-v8/src/context_bootstrap/runtime_state.rs
index e68766dee..b3046dd2d 100644
--- a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs
+++ b/moli-renderer-v8/src/context_bootstrap/runtime_state.rs
@@ -1981,6 +1981,8 @@ pub(crate) fn finish_context_bootstrap(
("IntersectionObserver", "IntersectionObserver"),
("IntersectionObserverEntry", "IntersectionObserverEntry"),
("ResizeObserver", "ResizeObserver"),
+ ("ResizeObserverEntry", "ResizeObserverEntry"),
+ ("ResizeObserverSize", "ResizeObserverSize"),
("PerformanceObserver", "PerformanceObserver"),
(
"PerformanceObserverEntryList",
diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
index 57bafd054..2101e00d2 100644
--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
@@ -1203,6 +1203,14 @@ const CONSTRUCTOR_SPECS_AFTER_STREAMS: &[ConstructorSpec] = &[
interface: web_api_interfaces::ResizeObserver::DESCRIPTOR,
kind: ConstructorKind::ResizeObserver,
},
+ ConstructorSpec {
+ interface: web_api_interfaces::ResizeObserverEntry::DESCRIPTOR,
+ kind: ConstructorKind::ResizeObserverEntry,
+ },
+ ConstructorSpec {
+ interface: web_api_interfaces::ResizeObserverSize::DESCRIPTOR,
+ kind: ConstructorKind::ResizeObserverSize,
+ },
ConstructorSpec {
interface: web_api_interfaces::PerformanceObserver::DESCRIPTOR,
kind: ConstructorKind::PerformanceObserver,
diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rs
index 04f1f05ca..5c889f274 100644
--- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs
+++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs
@@ -123,6 +123,8 @@ pub(in crate::context_bootstrap) enum ConstructorKind {
DomPoint,
DomMatrix,
ResizeObserver,
+ ResizeObserverEntry,
+ ResizeObserverSize,
PerformanceObserver,
PerformanceObserverEntryList,
PerformanceEntry,
diff --git a/moli-renderer-v8/src/observer_runtime/callback.rs b/moli-renderer-v8/src/observer_runtime/callback.rs
index 9655634af..f1c966655 100644
--- a/moli-renderer-v8/src/observer_runtime/callback.rs
+++ b/moli-renderer-v8/src/observer_runtime/callback.rs
@@ -324,6 +324,13 @@ pub(crate) struct PreparedObserverCallback {
}
impl PreparedObserverCallback {
+ pub(crate) fn relevant_context<'s>(
+ &self,
+ scope: &mut v8::PinScope<'s, '_>,
+ ) -> Option<v8::Local<'s, v8::Context>> {
+ self.callback.relevant_context(scope)
+ }
+
pub(crate) fn is_current(&self, host: &JsContextHost) -> bool {
self.observer_identity
.is_some_and(|identity| host.window_execution_context_identity_is_current(identity))
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs
index 7c53f41d7..0fc0dc9f6 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/misc.rs
@@ -1763,7 +1763,7 @@ fn geometry_rect_objects_expose_domrect_to_json() {
rangeRect instanceof DOMRect,
typeof rangeRect.toJSON,
rangeRects[0] instanceof DOMRect,
- contentRect instanceof DOMRect,
+ Object.getPrototypeOf(contentRect) === DOMRectReadOnly.prototype,
typeof contentRect.toJSON,
Object.hasOwn(DOMRectReadOnly.prototype, 'toJSON'),
Object.hasOwn(DOMRect.prototype, 'toJSON')
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index 50fc9f050..d2cf0ea49 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -2214,3 +2214,5 @@ mod media_device_interfaces;
mod dom_rect_factory_descriptors;
mod dom_rect_structured_clone;
mod domrect_receiver_consolidation;
+
+mod resize_observer_entries;
diff --git a/moli-renderer-v8/src/script_vm/tests/resize_observer_entries.rs b/moli-renderer-v8/src/script_vm/tests/resize_observer_entries.rs
new file mode 100644
index 000000000..1bc4fafb9
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/resize_observer_entries.rs
@@ -0,0 +1,56 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn resize_observer_entries_preserve_webidl_snapshots_and_callback_realms() {
+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
+ let mut vm = new_storage_page_task_executor_test_vm("https://resize-entries.test/");
+ let count: usize = vm
+ .eval(include_str!(
+ "../../../tests/fixtures/resize-observer-entry-webidl.js"
+ ))
+ .unwrap()
+ .parse()
+ .unwrap();
+ assert_eq!(count, 12);
+ vm.eval(
+ "__resizeEntryChecks.resumeAfterLayout = null;
+ __resizeEntryChecks.publishLayout = () => new Promise(resolve => {
+ __resizeEntryChecks.resumeAfterLayout = resolve;
+ });",
+ )
+ .unwrap();
+ for index in 0..count {
+ let name = vm
+ .eval(&format!("__resizeEntryChecks.start({index})"))
+ .unwrap();
+ let mut publications = 0;
+ loop {
+ advance_page_task_executor_until_eval_equals(
+ &mut vm,
+ &loader,
+ "String(__resizeEntryChecks.result !== null || __resizeEntryChecks.resumeAfterLayout !== null)",
+ "true",
+ &name,
+ )
+ .await;
+ if vm.eval("__resizeEntryChecks.result !== null").unwrap() == "true" {
+ break;
+ }
+ publications += 1;
+ assert!(publications <= 2, "{name}: unexpected layout request");
+ vm.publish_layout_for_test().unwrap();
+ vm.eval(
+ "(() => {
+ const resume = __resizeEntryChecks.resumeAfterLayout;
+ __resizeEntryChecks.resumeAfterLayout = null;
+ resume();
+ })()",
+ )
+ .unwrap();
+ }
+ let result = vm.eval("__resizeEntryChecks.result").unwrap();
+ let result: serde_json::Value = serde_json::from_str(&result).unwrap();
+ assert!(result["total"].as_u64().unwrap() > 0, "{name}");
+ assert_eq!(result["failures"], serde_json::json!([]), "{name}");
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs
index 2ab56a90d..92d9e4659 100644
--- a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs
+++ b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/byte_streams_and_observers.rs
@@ -1652,7 +1652,12 @@ yield; // Publish this scene before reading its geometry.
first.borderBoxSize[0].blockSize,
second.devicePixelContentBoxSize[0].inlineSize,
second.devicePixelContentBoxSize[0].blockSize,
- Object.keys(first.contentBoxSize[0]).join(',')
+ Object.keys(first.contentBoxSize[0]).length,
+ Object.keys(ResizeObserverSize.prototype).join(','),
+ first instanceof ResizeObserverEntry,
+ first.contentBoxSize[0] instanceof ResizeObserverSize,
+ ['contentBoxSize', 'borderBoxSize', 'devicePixelContentBoxSize']
+ .every(name => Object.isFrozen(first[name]))
].join('|');
})()
"#,
@@ -1661,7 +1666,7 @@ yield; // Publish this scene before reading its geometry.
assert_eq!(
result,
- "true|true|true|true|1|41|23|41|23|41|23|inlineSize,blockSize"
+ "true|true|true|true|1|41|23|41|23|41|23|0|inlineSize,blockSize|true|true|true"
);
}
diff --git a/moli-renderer-v8/src/window_webidl_callback.rs b/moli-renderer-v8/src/window_webidl_callback.rs
index f94bc83fb..0434f7579 100644
--- a/moli-renderer-v8/src/window_webidl_callback.rs
+++ b/moli-renderer-v8/src/window_webidl_callback.rs
@@ -180,6 +180,16 @@ pub(crate) enum PreparedWindowWebIdlCallbackFunctionOutcome<R, E> {
}
impl PreparedWindowWebIdlCallbackFunction {
+ pub(crate) fn relevant_context<'s>(
+ &self,
+ scope: &mut v8::PinScope<'s, '_>,
+ ) -> Option<v8::Local<'s, v8::Context>> {
+ match self {
+ Self::Live { callback, .. } => Some(callback.relevant_context(scope)),
+ Self::Retired => None,
+ }
+ }
+
pub(crate) const fn relevant_identity(&self) -> Option<WindowExecutionContextIdentity> {
match self {
Self::Live {
diff --git a/moli-renderer-v8/tests/fixtures/resize-observer-entry-webidl.js b/moli-renderer-v8/tests/fixtures/resize-observer-entry-webidl.js
new file mode 100644
index 000000000..d37815a77
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/resize-observer-entry-webidl.js
@@ -0,0 +1,257 @@
+(() => {
+ const assert = (condition, message) => { if (!condition) throw new Error(message); };
+ const entryAttributes = ['target', 'contentRect', 'contentBoxSize', 'borderBoxSize', 'devicePixelContentBoxSize'];
+ const boxAttributes = entryAttributes.slice(2);
+ const sizeAttributes = ['inlineSize', 'blockSize'];
+ const withFrame = async run => {
+ const frame = document.body.appendChild(document.createElement('iframe'));
+ try { await run(frame.contentWindow); }
+ finally { frame.remove(); }
+ };
+ const withEntry = async (creator, callbackRealm, targetRealm, run) => {
+ const target = targetRealm.document.body.appendChild(targetRealm.document.createElement('div'));
+ target.style.cssText = 'width:31px;height:17px;padding:2px;border:1px solid';
+ target.getBoundingClientRect();
+ let observer;
+ try {
+ const delivery = await new Promise(resolve => {
+ const callback = callbackRealm.Function('deliver', `return function(entries, observer) {
+ deliver({entry: entries[0], entries, observer, receiver: this});
+ };`)(resolve);
+ observer = new creator.ResizeObserver(callback);
+ observer.observe(target);
+ });
+ observer.disconnect();
+ await run(delivery, target, observer);
+ } finally { observer?.disconnect(); target.remove(); }
+ };
+ const cases = [];
+ for (const creatorName of ['main', 'child']) for (const callbackName of ['main', 'child']) {
+ for (const targetName of ['main', 'child']) {
+ cases.push({
+ name: `entry from ${creatorName} observer, ${callbackName} callback, ${targetName} target`,
+ run: check => withFrame(other => {
+ const realms = {main: window, child: other};
+ const owner = realms[callbackName];
+ return withEntry(realms[creatorName], owner, realms[targetName], ({entry, entries, observer, receiver}, target, expectedObserver) => {
+ const size = entry.contentBoxSize[0];
+ check('callback arguments retain identities and use the callback Array', () => {
+ assert(observer === expectedObserver && receiver === observer, 'observer argument and callback this');
+ assert(Object.getPrototypeOf(entries) === owner.Array.prototype, 'callback sequence realm');
+ assert(!Object.isFrozen(entries), 'sequence remains mutable');
+ assert(entry.target === target, 'observed target identity');
+ });
+ for (const [name, value, attributes] of [
+ ['ResizeObserverEntry', entry, entryAttributes],
+ ['ResizeObserverSize', size, sizeAttributes],
+ ]) {
+ check(`${name} native wrapper shape`, () => {
+ assert(Object.getPrototypeOf(value) === owner[name].prototype, 'callback realm prototype');
+ assert(Object.prototype.toString.call(value) === `[object ${name}]`, 'interface toStringTag');
+ assert(Object.getOwnPropertyNames(value).length === 0, 'attributes are not own properties');
+ assert(Object.isExtensible(value), 'native wrapper remains extensible');
+ });
+ for (const attribute of attributes) {
+ check(`${name}.${attribute} is readonly`, () => {
+ const saved = value[attribute];
+ const written = Reflect.set(value, attribute, null);
+ if (written) Reflect.set(value, attribute, saved);
+ assert(!written, 'assignment must fail');
+ assert(value[attribute] === saved, 'assignment must retain the snapshot');
+ });
+ for (const [calleeName, realm] of Object.entries(realms)) {
+ const label = `${calleeName} ${name}.${attribute}`;
+ const getter = () => Object.getOwnPropertyDescriptor(realm[name].prototype, attribute).get;
+ check(`${label} descriptor and genuine receiver`, () => {
+ const descriptor = Object.getOwnPropertyDescriptor(realm[name].prototype, attribute);
+ assert(descriptor.enumerable && descriptor.configurable && descriptor.set === undefined, 'readonly WebIDL descriptor');
+ assert(descriptor.get.length === 0 && descriptor.get.name === `get ${attribute}`, 'getter signature');
+ assert(Object.getPrototypeOf(descriptor.get) === realm.Function.prototype, 'getter realm');
+ assert(getter().call(value) === value[attribute], 'borrowed getter retains native value');
+ });
+ let reads = 0;
+ const poison = () => { reads++; throw new Error('author trap ran'); };
+ const revoked = Proxy.revocable(value, {}); revoked.revoke();
+ const fake = Object.create(Object.getPrototypeOf(value));
+ Object.defineProperty(fake, attribute, {get: poison});
+ const invalid = [null, undefined, {}, Object.getPrototypeOf(value), Object.create(value),
+ Object.create(Object.getPrototypeOf(value), Object.getOwnPropertyDescriptors(value)),
+ new Proxy(value, {get: poison, getPrototypeOf: poison, has: poison}), revoked.proxy,
+ name === 'ResizeObserverEntry' ? size : entry, fake];
+ invalid.forEach((receiver, index) => check(`${label} rejects receiver ${index}`, () => {
+ const get = getter();
+ reads = 0;
+ let error;
+ try { get.call(receiver); } catch (caught) { error = caught; }
+ assert(error instanceof realm.TypeError, 'binding realm TypeError');
+ assert(reads === 0, 'brand validation must not invoke author code');
+ }));
+ check(`${label} survives public shadowing and prototype mutation`, () => {
+ const get = getter(), original = get.call(value), prototype = Object.getPrototypeOf(value);
+ reads = 0;
+ try {
+ Object.defineProperty(value, attribute, {get: poison, configurable: true});
+ Object.setPrototypeOf(value, null);
+ assert(get.call(value) === original && reads === 0, 'private state is independent of public properties');
+ } finally {
+ Object.setPrototypeOf(value, prototype);
+ Reflect.deleteProperty(value, attribute);
+ }
+ });
+ }
+ }
+ check(`${name} cannot be structured cloned`, () => {
+ let error;
+ try { structuredClone(value); } catch (caught) { error = caught; }
+ assert(error instanceof DOMException && error.name === 'DataCloneError', 'native interface has no clone codec');
+ });
+ }
+ check('contentRect is a readonly native snapshot in the callback realm', () => {
+ const rect = entry.contentRect;
+ assert(Object.getPrototypeOf(rect) === owner.DOMRectReadOnly.prototype, 'DOMRectReadOnly realm and type');
+ assert(Object.getOwnPropertyNames(rect).length === 0, 'private geometry');
+ for (const key of ['x', 'y', 'width', 'height']) {
+ const original = rect[key];
+ const written = Reflect.set(rect, key, 900);
+ if (written) Reflect.set(rect, key, original);
+ assert(!written && rect[key] === original, `${key} is readonly`);
+ }
+ });
+ for (const attribute of boxAttributes) check(`${attribute} is a stable FrozenArray of native sizes`, () => {
+ const array = entry[attribute], first = array[0];
+ assert(Object.getPrototypeOf(array) === owner.Array.prototype, 'array realm');
+ assert(array === entry[attribute] && array.length === 1, 'stable snapshot array');
+ assert(Object.isFrozen(array), 'FrozenArray');
+ assert(Object.getPrototypeOf(first) === owner.ResizeObserverSize.prototype, 'size realm');
+ assert(!Reflect.set(array, '0', null) && !Reflect.set(array, 'length', 0), 'index and length are readonly');
+ assert(!Reflect.deleteProperty(array, '0') && !Reflect.defineProperty(array, 'extra', {value: 1}), 'array cannot shrink or grow');
+ assert(array[0] === first && array.length === 1, 'failed changes retain contents');
+ });
+ check('box snapshots are independent objects', () => {
+ const arrays = boxAttributes.map(attribute => entry[attribute]);
+ assert(new Set(arrays).size === 3 && new Set(arrays.map(array => array[0])).size === 3, 'boxes must not share mutable wrappers');
+ });
+ });
+ })
+ });
+ }
+ }
+ for (const owner of ['main', 'child']) cases.push({
+ name: `${owner} interface exposure and intrinsic factories`,
+ run: check => withFrame(async other => {
+ const realm = owner === 'main' ? window : other;
+ for (const name of ['ResizeObserverEntry', 'ResizeObserverSize']) {
+ check(`${name} interface object`, () => {
+ const constructor = realm[name];
+ assert(typeof constructor === 'function' && constructor.name === name && constructor.length === 0, 'interface function');
+ assert(Object.getPrototypeOf(constructor.prototype) === realm.Object.prototype, 'interface prototype parent');
+ assert(constructor.prototype.constructor === constructor, 'prototype constructor');
+ const tag = Object.getOwnPropertyDescriptor(constructor.prototype, Symbol.toStringTag);
+ assert(tag.value === name && !tag.writable && !tag.enumerable && tag.configurable, 'toStringTag descriptor');
+ for (const call of [() => constructor(), () => new constructor()]) {
+ let error;
+ try { call(); } catch (caught) { error = caught; }
+ assert(error instanceof realm.TypeError, 'no public construction algorithm');
+ }
+ });
+ }
+ const names = ['ResizeObserverEntry', 'ResizeObserverSize', 'DOMRectReadOnly', 'Array'];
+ const saved = names.map(name => [name, realm[name], Object.getOwnPropertyDescriptor(realm, name)]);
+ let reads = 0;
+ try {
+ for (const name of names) Object.defineProperty(realm, name, {
+ configurable: true, get() { reads++; throw new Error('public constructor getter ran'); }
+ });
+ await withEntry(realm, realm, realm, ({entry, entries}) => check('factories use intrinsics after global shadowing', () => {
+ const originals = Object.fromEntries(saved.map(([name, value]) => [name, value]));
+ assert(Object.getPrototypeOf(entry) === originals.ResizeObserverEntry.prototype, 'entry intrinsic prototype');
+ assert(Object.getPrototypeOf(entry.contentRect) === originals.DOMRectReadOnly.prototype, 'rect intrinsic prototype');
+ assert(Object.getPrototypeOf(entry.contentBoxSize[0]) === originals.ResizeObserverSize.prototype, 'size intrinsic prototype');
+ assert(Object.getPrototypeOf(entry.contentBoxSize) === originals.Array.prototype, 'array intrinsic prototype');
+ assert(Object.getPrototypeOf(entries) === originals.Array.prototype && reads === 0, 'author constructors are not consulted');
+ }));
+ } finally {
+ for (const [name, , descriptor] of saved) {
+ if (descriptor) Object.defineProperty(realm, name, descriptor); else Reflect.deleteProperty(realm, name);
+ }
+ }
+ })
+ });
+ cases.push({
+ name: 'successive deliveries keep retained snapshots independent',
+ async run(check) {
+ const target = document.body.appendChild(document.createElement('div'));
+ target.style.cssText = 'width:31px;height:17px';
+ let deliver;
+ const observer = new ResizeObserver(entries => deliver(entries[0]));
+ const sample = async () => {
+ // The native fixture publishes layout explicitly; browser runs can
+ // use the next rendering opportunity.
+ await (__resizeEntryChecks.publishLayout?.() ?? new Promise(requestAnimationFrame));
+ return new Promise(resolve => {
+ deliver = resolve;
+ observer.observe(target);
+ });
+ };
+ try {
+ const first = await sample();
+ assert(first, 'initial notification');
+ observer.unobserve(target);
+ target.style.width = '47px';
+ const second = await sample();
+ check('old dimensions and object identities survive the resize', () => {
+ assert(first !== second, 'a new observation creates a fresh snapshot');
+ assert(first.contentRect.width === 31 && first.contentBoxSize[0].inlineSize === 31, 'old dimensions');
+ assert(second.contentRect.width === 47 && second.contentBoxSize[0].inlineSize === 47, 'new dimensions');
+ for (const attribute of ['contentRect', ...boxAttributes]) assert(first[attribute] !== second[attribute], 'fresh nested snapshot');
+ });
+ observer.disconnect(); target.remove();
+ check('snapshot remains readable after observer disconnect and target removal', () => {
+ assert(first.target === target && second.target === target, 'target identity remains');
+ assert(first.contentRect.width === 31 && second.contentRect.width === 47, 'retained dimensions');
+ });
+ } finally { observer.disconnect(); target.remove(); }
+ }
+ });
+ cases.push({
+ name: 'Window-only result interfaces remain absent from Dedicated Workers',
+ async run(check) {
+ const source = `postMessage(['ResizeObserver', 'ResizeObserverEntry', 'ResizeObserverSize'].map(name => typeof globalThis[name]).join(','));`;
+ const url = URL.createObjectURL(new Blob([source], {type: 'text/javascript'}));
+ const worker = new Worker(url);
+ try {
+ const result = await new Promise((resolve, reject) => {
+ worker.onmessage = event => resolve(event.data);
+ worker.onerror = event => reject(new Error(event.message));
+ });
+ check('exposure set', () => assert(result === 'undefined,undefined,undefined', result));
+ } finally { worker.terminate(); URL.revokeObjectURL(url); }
+ }
+ });
+ globalThis.__resizeEntryChecks = {
+ result: null,
+ start(index) {
+ this.result = null;
+ const rows = [];
+ const check = (name, run) => {
+ try { run(); rows.push({name, passed: true}); }
+ catch (error) { rows.push({name, passed: false, error: String(error)}); }
+ };
+ const finish = () => { this.result = JSON.stringify({total: rows.length, failures: rows.filter(row => !row.passed)}); };
+ this.pending = cases[index].run(check).then(finish, error => {
+ check('scenario completes', () => { throw error; }); finish();
+ });
+ return cases[index].name;
+ },
+ async all() {
+ const results = [];
+ for (let index = 0; index < cases.length; index++) {
+ const name = this.start(index);
+ await this.pending;
+ results.push({name, ...JSON.parse(this.result)});
+ }
+ return JSON.stringify(results);
+ }
+ };
+ return cases.length;
+})();