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): validate observer receivers and isolate native state

ldm0edd0057eeddc
diff --git a/moli-core/tests/fixtures/runtime/performance_measure_observer.html b/moli-core/tests/fixtures/runtime/performance_measure_observer.html
index 8aa359835..d76cbf8f7 100644
--- a/moli-core/tests/fixtures/runtime/performance_measure_observer.html
+++ b/moli-core/tests/fixtures/runtime/performance_measure_observer.html
@@ -56,6 +56,9 @@
window.performanceMeasureObservedCount = callbackEntries && callbackEntries.length;
window.performanceMeasureObservedName =
callbackEntries && callbackEntries[0] && callbackEntries[0].name;
+ window.performanceMeasureObservedChronological = callbackEntries &&
+ callbackEntries.every((entry, index) => index === 0 ||
+ callbackEntries[index - 1].startTime <= entry.startTime);
window.performanceMeasureObservedType =
callbackEntries && callbackEntries[0] && callbackEntries[0].entryType;
window.performanceMeasureObservedByTypeCount =
diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rs
index 6754f9316..f7e364a79 100644
--- a/moli-core/tests/web_apis.rs
+++ b/moli-core/tests/web_apis.rs
@@ -1383,7 +1383,11 @@ async fn performance_measure_entries_are_observable_and_clearable() -> Result<()
);
assert_eq!(
diagnostic_global(&page, "performanceMeasureObservedName"),
- Some(&JsValueSnapshot::String("duration".to_owned()))
+ Some(&JsValueSnapshot::String("legacy-duration".to_owned()))
+ );
+ assert_eq!(
+ diagnostic_global(&page, "performanceMeasureObservedChronological"),
+ Some(&JsValueSnapshot::Bool(true))
);
assert_eq!(
diagnostic_global(&page, "performanceMeasureObservedType"),
@@ -5698,7 +5702,7 @@ async fn intersection_observer_options_reflect_root_margin_and_thresholds() -> R
);
assert_eq!(
diagnostic_global(&page, "intersectionObserverThresholds"),
- Some(&JsValueSnapshot::String("[0.25,0.75]".to_owned()))
+ Some(&JsValueSnapshot::String("[0.25,0.75,0.75]".to_owned()))
);
assert_eq!(
diagnostic_global(&page, "intersectionObserverEntryPrototypeShape"),
diff --git a/moli-renderer-v8/src/context_bootstrap/observer_template.rs b/moli-renderer-v8/src/context_bootstrap/observer_template.rs
index c30045731..da2c66f0b 100644
--- a/moli-renderer-v8/src/context_bootstrap/observer_template.rs
+++ b/moli-renderer-v8/src/context_bootstrap/observer_template.rs
@@ -16,7 +16,7 @@ use crate::web_api_interfaces;
use moli_webapi_declare::WebApiFunctionTemplate;
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::MutationObserver, enumerable)]
+#[webapi(interface = web_api_interfaces::MutationObserver, enumerable, receiver)]
struct MutationObserverTemplateMethodsDeclaration {
#[webapi(method, length = 2, callback = observer_runtime::mutation_observer_observe_callback)]
observe: (),
@@ -37,7 +37,7 @@ struct MutationObserverTemplateMethodsDeclaration {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::IntersectionObserver, enumerable)]
+#[webapi(interface = web_api_interfaces::IntersectionObserver, enumerable, receiver)]
struct IntersectionObserverTemplateMethodsDeclaration {
#[webapi(
method,
@@ -79,7 +79,7 @@ struct MediaQueryListTemplateMethodsDeclaration {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::ResizeObserver, enumerable)]
+#[webapi(interface = web_api_interfaces::ResizeObserver, enumerable, receiver)]
struct ResizeObserverTemplateMethodsDeclaration {
#[webapi(method, length = 1, callback = resize_observer_observe_callback)]
observe: (),
@@ -95,9 +95,9 @@ struct ResizeObserverTemplateMethodsDeclaration {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::PerformanceObserver, enumerable)]
+#[webapi(interface = web_api_interfaces::PerformanceObserver, enumerable, receiver)]
struct PerformanceObserverTemplateMethodsDeclaration {
- #[webapi(method, length = 1, callback = performance_observer_observe_callback)]
+ #[webapi(method, length = 0, callback = performance_observer_observe_callback)]
observe: (),
#[webapi(method, length = 0, callback = performance_observer_disconnect_callback)]
@@ -108,7 +108,7 @@ struct PerformanceObserverTemplateMethodsDeclaration {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::PerformanceObserverEntryList, enumerable)]
+#[webapi(interface = web_api_interfaces::PerformanceObserverEntryList, enumerable, receiver)]
struct PerformanceObserverEntryListTemplateMethodsDeclaration {
#[webapi(method, length = 0, callback = performance_entry_list_get_entries_callback)]
get_entries: (),
@@ -122,7 +122,7 @@ struct PerformanceObserverEntryListTemplateMethodsDeclaration {
#[webapi(
method,
- length = 2,
+ length = 1,
callback = performance_entry_list_get_entries_by_name_callback
)]
get_entries_by_name: (),
diff --git a/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/entry_list.rs b/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/entry_list.rs
index 672f15237..4fb98bb99 100644
--- a/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/entry_list.rs
+++ b/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/entry_list.rs
@@ -24,7 +24,7 @@ pub(in crate::context_bootstrap) fn performance_entry_list_get_entries_callback<
) {
let entries = performance_entry_list_entries(scope, args.this())
.unwrap_or_else(|| v8::Array::new(scope, 0));
- rv.set(entries.into());
+ rv.set(filtered_entry_list_entries(scope, entries, None, None).into());
}
pub(in crate::context_bootstrap) fn performance_entry_list_get_entries_by_type_callback<'s>(
diff --git a/moli-renderer-v8/src/observer_runtime/mod.rs b/moli-renderer-v8/src/observer_runtime/mod.rs
index 28f97c228..eabc581fc 100644
--- a/moli-renderer-v8/src/observer_runtime/mod.rs
+++ b/moli-renderer-v8/src/observer_runtime/mod.rs
@@ -49,7 +49,7 @@ use super::{
util::{
callback_data_index_value, callback_data_item, context_host_ptr_from_global_bridge,
get_private_object, get_private_value, serialize_v8_array, serialize_v8_iter_array,
- throw_range_error, throw_type_error, v8_string, v8str,
+ set_private_value, throw_range_error, throw_type_error, v8_string, v8str,
},
window_webidl_callback::WindowWebIdlCallbackFunctionOutcome,
};
@@ -123,7 +123,7 @@ struct IntersectionObserverEntryDeclaration<'scope> {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::IntersectionObserver, enumerable)]
+#[webapi(interface = web_api_interfaces::IntersectionObserver, enumerable, receiver)]
struct IntersectionObserverPrototypeAccessorsDeclaration {
#[webapi(accessor_property, getter = intersection_observer_attribute_getter_callback, data = callback_data_index_value(scope, 0))]
root: (),
@@ -480,7 +480,7 @@ impl ObserverStore {
queued_records: Vec::new(),
},
);
- define_hidden_value(
+ set_private_value(
scope,
observer,
MUTATION_OBSERVER_ID_SLOT,
@@ -671,7 +671,7 @@ impl ObserverStore {
options,
},
);
- define_hidden_value(
+ set_private_value(
scope,
observer,
INTERSECTION_OBSERVER_ID_SLOT,
@@ -1207,14 +1207,10 @@ pub(super) fn intersection_observer_constructor_callback<'s>(
return;
}
};
- dom_access::init_intersection_observer(
- scope,
- host_ptr,
- args.this(),
- parsed.callback,
- options.clone(),
- );
- define_intersection_observer_slots(scope, host_ptr, args.this(), &options);
+ if define_intersection_observer_slots(scope, host_ptr, args.this(), &options).is_none() {
+ return;
+ }
+ dom_access::init_intersection_observer(scope, host_ptr, args.this(), parsed.callback, options);
rv.set(args.this().into());
}
@@ -1679,7 +1675,6 @@ fn threshold_option<'s>(
vec![threshold_number(scope, value)?]
};
thresholds.sort_by(|left, right| left.partial_cmp(right).unwrap_or(Ordering::Equal));
- thresholds.dedup_by(|left, right| left.total_cmp(right) == Ordering::Equal);
if thresholds.is_empty() {
thresholds.push(0.0);
}
@@ -1729,15 +1724,15 @@ fn define_intersection_observer_slots(
host_ptr: *mut JsContextHost,
observer: v8::Local<'_, v8::Object>,
options: &IntersectionObserverOptions,
-) {
+) -> Option<()> {
let root_value = options
.root
.and_then(|handle| wrap_node_handle(scope, host_ptr, handle))
.map(v8::Local::<v8::Value>::from)
.unwrap_or_else(|| v8::null(scope).into());
- define_hidden_value(scope, observer, INTERSECTION_OBSERVER_ROOT_SLOT, root_value);
+ set_private_value(scope, observer, INTERSECTION_OBSERVER_ROOT_SLOT, root_value);
if let Some(root_margin) = v8_string(scope, &options.root_margin) {
- define_hidden_value(
+ set_private_value(
scope,
observer,
INTERSECTION_OBSERVER_ROOT_MARGIN_SLOT,
@@ -1745,33 +1740,36 @@ fn define_intersection_observer_slots(
);
}
if let Some(scroll_margin) = v8_string(scope, &options.scroll_margin) {
- define_hidden_value(
+ set_private_value(
scope,
observer,
INTERSECTION_OBSERVER_SCROLL_MARGIN_SLOT,
scroll_margin.into(),
);
}
- let thresholds = crate::util::serialize_v8_array(scope, options.thresholds.as_slice())
- .unwrap_or_else(|| v8::Array::new(scope, 0));
- define_hidden_value(
+ let thresholds = crate::util::serialize_v8_array(scope, options.thresholds.as_slice())?;
+ if thresholds.set_integrity_level(scope, v8::IntegrityLevel::Frozen) != Some(true) {
+ return None;
+ }
+ set_private_value(
scope,
observer,
INTERSECTION_OBSERVER_THRESHOLDS_SLOT,
thresholds.into(),
);
- define_hidden_value(
+ set_private_value(
scope,
observer,
INTERSECTION_OBSERVER_DELAY_SLOT,
v8::Integer::new(scope, options.delay).into(),
);
- define_hidden_value(
+ set_private_value(
scope,
observer,
INTERSECTION_OBSERVER_TRACK_VISIBILITY_SLOT,
v8::Boolean::new(scope, options.track_visibility).into(),
);
+ Some(())
}
#[derive(Clone, Copy, Default)]
@@ -2426,44 +2424,31 @@ fn mutation_observer_id_from_object(
scope: &mut v8::PinScope<'_, '_>,
object: v8::Local<'_, v8::Object>,
) -> Option<u32> {
- hidden_numeric_id(scope, object, MUTATION_OBSERVER_ID_SLOT)
+ observer_id_from_private_slot(scope, object, MUTATION_OBSERVER_ID_SLOT)
}
fn intersection_observer_id_from_object(
scope: &mut v8::PinScope<'_, '_>,
object: v8::Local<'_, v8::Object>,
) -> Option<u32> {
- hidden_numeric_id(scope, object, INTERSECTION_OBSERVER_ID_SLOT)
+ observer_id_from_private_slot(scope, object, INTERSECTION_OBSERVER_ID_SLOT)
}
-fn hidden_numeric_id(
+fn observer_id_from_private_slot(
scope: &mut v8::PinScope<'_, '_>,
object: v8::Local<'_, v8::Object>,
key: &str,
) -> Option<u32> {
- let key = v8_string(scope, key)?;
- object
- .get(scope, key.into())
+ let object = v8::Local::new(scope, object);
+ get_private_value(scope, object, key)
.and_then(|value| value.number_value(scope))
.filter(|value| value.is_finite() && *value >= 1.0)
.map(|value| value as u32)
}
-fn define_hidden_value(
- scope: &mut v8::PinScope<'_, '_>,
- object: v8::Local<'_, v8::Object>,
- key: &str,
- value: v8::Local<'_, v8::Value>,
-) {
- let Some(key) = v8_string(scope, key) else {
- return;
- };
- let _ = object.define_own_property(scope, key.into(), value, v8::PropertyAttribute::DONT_ENUM);
-}
-
-fn intersection_observer_attribute_getter_callback(
- scope: &mut v8::PinScope<'_, '_>,
- args: v8::FunctionCallbackArguments<'_>,
+fn intersection_observer_attribute_getter_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(name) = callback_data_item(
@@ -2488,9 +2473,7 @@ fn intersection_observer_attribute_getter_callback(
}
};
rv.set(
- args.this()
- .get(scope, v8str(scope, slot).into())
- .unwrap_or_else(|| v8::undefined(scope).into()),
+ get_private_value(scope, args.this(), slot).unwrap_or_else(|| v8::undefined(scope).into()),
);
}
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index bf96eff0b..0288ac195 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -2144,6 +2144,7 @@ mod lazy_window_surfaces;
mod mouse_snapshot;
mod no_cors_header_fill;
mod observer_callbacks;
+mod observer_receivers;
mod post_parse;
mod queue_microtask;
mod rendering_update;
diff --git a/moli-renderer-v8/src/script_vm/tests/observer_receivers.rs b/moli-renderer-v8/src/script_vm/tests/observer_receivers.rs
new file mode 100644
index 000000000..59b21d87f
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/observer_receivers.rs
@@ -0,0 +1,44 @@
+use super::*;
+
+#[tokio::test(flavor = "current_thread")]
+async fn observer_bindings_validate_native_receivers_before_author_code() {
+ let mut vm = new_storage_page_task_executor_test_vm("https://observer-receivers.test/");
+ let result = vm
+ .eval(include_str!(
+ "../../../tests/fixtures/observer-receiver-state.js"
+ ))
+ .unwrap();
+ assert_eq!(result, r#"{"total":393,"failures":[]}"#);
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn observer_callbacks_and_entry_lists_preserve_native_state() {
+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
+ let mut vm = new_storage_page_task_executor_test_vm("https://observer-native-state.test/");
+ let count: usize = vm
+ .eval(include_str!(
+ "../../../tests/fixtures/observer-native-state-lifecycle.js"
+ ))
+ .unwrap()
+ .parse()
+ .unwrap();
+ assert_eq!(count, 5);
+ for index in 0..count {
+ let name = vm
+ .eval(&format!("__observerNativeState.start({index})"))
+ .unwrap();
+ advance_page_task_executor_until_eval_equals(
+ &mut vm,
+ &loader,
+ "String(__observerNativeState.result !== null)",
+ "true",
+ &name,
+ )
+ .await;
+ assert_eq!(
+ vm.eval("__observerNativeState.result").unwrap(),
+ "pass",
+ "{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 fba0a55da..2ab56a90d 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
@@ -1389,7 +1389,7 @@ fn performance_observer_declared_slots_ignore_prototype_spoofing() {
PerformanceObserver.prototype.__moliPerformanceObserverScheduled = true;
const fake = Object.create(PerformanceObserver.prototype);
- const fakeRecords = PerformanceObserver.prototype.takeRecords.call(fake);
+ const fakeRecords = probe(() => PerformanceObserver.prototype.takeRecords.call(fake));
const fakeObserve = probe(() => PerformanceObserver.prototype.observe.call(fake, {
entryTypes: ['measure'],
}));
@@ -1401,10 +1401,10 @@ fn performance_observer_declared_slots_ignore_prototype_spoofing() {
observer.takeRecords().length
].join('|'),
fake: [
- fakeRecords.length,
- fakeRecords[0],
+ fakeRecords,
fakeObserve,
- fake.takeRecords().length
+ probe(() => fake.takeRecords()),
+ probe(() => fake.disconnect())
].map(value => value === undefined ? 'undefined' : String(value)).join('|'),
ownSlots
});
@@ -1415,7 +1415,7 @@ fn performance_observer_declared_slots_ignore_prototype_spoofing() {
assert_eq!(
result,
- r#"{"real":"1|mark|declared-observer|0","fake":"0|undefined|undefined|0","ownSlots":[]}"#
+ r#"{"real":"1|mark|declared-observer|0","fake":"throw:TypeError|throw:TypeError|throw:TypeError|throw:TypeError","ownSlots":[]}"#
);
}
@@ -1707,6 +1707,13 @@ fn resize_observer_declared_slots_ignore_prototype_spoofing() {
const html = document.documentElement || document.appendChild(document.createElement('html'));
const body = document.body || html.appendChild(document.createElement('body'));
const stringify = value => value === undefined ? 'undefined' : String(value);
+ const probe = callback => {
+ try {
+ return stringify(callback());
+ } catch (error) {
+ return `throw:${error && error.name}`;
+ }
+ };
const target = document.createElement('div');
target.style.cssText = 'width: 10px; height: 20px';
body.appendChild(target);
@@ -1723,9 +1730,9 @@ fn resize_observer_declared_slots_ignore_prototype_spoofing() {
ResizeObserver.prototype.__moliResizeObserverScheduled = true;
const fake = Object.create(ResizeObserver.prototype);
- const fakeRecords = ResizeObserver.prototype.takeRecords.call(fake);
- const fakeObserve = ResizeObserver.prototype.observe.call(fake, target);
- const fakeAfterObserve = fake.takeRecords();
+ const fakeRecords = probe(() => ResizeObserver.prototype.takeRecords.call(fake));
+ const fakeObserve = probe(() => ResizeObserver.prototype.observe.call(fake, target));
+ const fakeAfterObserve = probe(() => fake.takeRecords());
return JSON.stringify({
real: [
records.length,
@@ -1734,11 +1741,11 @@ fn resize_observer_declared_slots_ignore_prototype_spoofing() {
observer.takeRecords().length
].join('|'),
fake: [
- fakeRecords.length,
- fakeRecords[0],
+ fakeRecords,
fakeObserve,
- fakeAfterObserve.length,
- fakeAfterObserve[0]
+ fakeAfterObserve,
+ probe(() => fake.unobserve(target)),
+ probe(() => fake.disconnect())
].map(stringify).join('|'),
ownSlots
});
@@ -1749,7 +1756,7 @@ fn resize_observer_declared_slots_ignore_prototype_spoofing() {
assert_eq!(
result,
- r#"{"real":"1|true|1|0","fake":"0|undefined|undefined|0|undefined","ownSlots":[]}"#
+ r#"{"real":"1|true|1|0","fake":"throw:TypeError|throw:TypeError|throw:TypeError|throw:TypeError|throw:TypeError","ownSlots":[]}"#
);
}
diff --git a/moli-renderer-v8/tests/fixtures/observer-native-state-lifecycle.js b/moli-renderer-v8/tests/fixtures/observer-native-state-lifecycle.js
new file mode 100644
index 000000000..88e863f71
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/observer-native-state-lifecycle.js
@@ -0,0 +1,111 @@
+(() => {
+ const assert = (condition, message) => { if (!condition) throw new Error(message); };
+ const afterRendering = () => new Promise(resolve =>
+ requestAnimationFrame(() => requestAnimationFrame(() => setTimeout(resolve, 0))));
+ const withEntryList = async (owner, check) => {
+ const frame = document.body.appendChild(document.createElement('iframe'));
+ const other = frame.contentWindow;
+ const realm = owner === 'child' ? other : window;
+ let observer;
+ try {
+ const list = await new Promise(resolve => {
+ observer = new realm.PerformanceObserver(resolve);
+ observer.observe({entryTypes: ['mark']});
+ realm.performance.mark('observer-late', {startTime: 20});
+ realm.performance.mark('observer-early', {startTime: 10});
+ });
+ observer.disconnect();
+ check(list, other);
+ } finally {
+ if (observer) observer.disconnect();
+ realm.performance.clearMarks('observer-late');
+ realm.performance.clearMarks('observer-early');
+ frame.remove();
+ }
+ };
+ const cases = [
+ {
+ name: 'IntersectionObserver IDs stay attached to their native receiver after author assignment',
+ async run() {
+ const left = document.body.appendChild(document.createElement('div'));
+ const right = document.body.appendChild(document.createElement('div'));
+ left.style.cssText = right.style.cssText = 'width:20px;height:20px';
+ const firstEntries = [], secondEntries = [];
+ const first = new IntersectionObserver((entries, observer) => {
+ firstEntries.push(...entries.map(entry => entry.target === left && observer === first));
+ });
+ const second = new IntersectionObserver((entries, observer) => {
+ secondEntries.push(...entries.map(entry => entry.target === right && observer === second));
+ });
+ const slot = '__lmIntersectionObserverId';
+ const saved = Object.getOwnPropertyDescriptor(second, slot);
+ try {
+ second[slot] = first[slot];
+ first.observe(left);
+ second.observe(right);
+ await afterRendering();
+ assert(firstEntries.join(',') === 'true', 'first callback and entry identity');
+ assert(secondEntries.join(',') === 'true', 'second callback and entry identity');
+ } finally {
+ if (saved) Object.defineProperty(second, slot, saved); else Reflect.deleteProperty(second, slot);
+ first.disconnect(); second.disconnect(); left.remove(); right.remove();
+ }
+ }
+ },
+ ...['main', 'child'].flatMap(owner => [{
+ name: `${owner} PerformanceObserverEntryList validates native receivers before conversion`,
+ run() {
+ return withEntryList(owner, (list, other) => {
+ let reads = 0;
+ const poison = () => { reads++; throw new Error('author conversion or Proxy trap'); };
+ const revoked = Proxy.revocable(list, {}); revoked.revoke();
+ for (const callee of [window, other]) {
+ const prototype = callee.PerformanceObserverEntryList.prototype;
+ for (const method of ['getEntries', 'getEntriesByType', 'getEntriesByName']) {
+ const fn = prototype[method];
+ const args = method === 'getEntries' ? [] : [{toString: poison}];
+ for (const invalid of [null, undefined, {}, prototype, Object.create(list),
+ new Proxy(list, {get: poison, getPrototypeOf: poison}), revoked.proxy]) {
+ reads = 0;
+ let error;
+ try { fn.apply(invalid, args); } catch (caught) { error = caught; }
+ assert(error instanceof callee.TypeError, `${method} must reject in its binding realm`);
+ assert(reads === 0, `${method} receiver validation must precede conversion`);
+ }
+ const input = method === 'getEntries' ? [] : [method === 'getEntriesByType' ? 'mark' : 'observer-early'];
+ const entries = fn.apply(list, input);
+ const expected = method === 'getEntriesByName' ? 'observer-early' : 'observer-early,observer-late';
+ assert(entries.map(entry => entry.name).join(',') === expected, `${method} accepts cross-realm native list`);
+ }
+ }
+ });
+ }
+ }, {
+ name: `${owner} PerformanceObserverEntryList returns independent sorted sequences`,
+ run() {
+ return withEntryList(owner, list => {
+ const expected = list.getEntriesByType('mark');
+ const original = list.getEntries();
+ assert(!Object.isFrozen(original), 'sequence result remains mutable');
+ original.reverse(); original.pop(); original.push({name: 'author entry'});
+ const again = list.getEntries();
+ assert(again !== original, 'each sequence conversion produces a new Array');
+ assert(again.map(entry => entry.name).join(',') === 'observer-early,observer-late', 'entries are sorted by startTime');
+ assert(again.length === 2 && again.every((entry, i) => entry === expected[i]), 'list retains original entry identities and order');
+ assert(list.getEntriesByType('mark').length === 2, 'mutating a returned Array cannot alter filtering');
+ assert(list.getEntriesByName('observer-early')[0] === expected[0], 'getEntriesByName retains native snapshot');
+ });
+ }
+ }])
+ ];
+ globalThis.__observerNativeState = {
+ result: null,
+ start(index) {
+ this.result = null;
+ cases[index].run().then(() => { this.result = 'pass'; }, error => { this.result = String(error); });
+ return cases[index].name;
+ },
+ snapshot() { return {actual: this.result, expected: 'pass'}; }
+ };
+ return cases.length;
+})();
diff --git a/moli-renderer-v8/tests/fixtures/observer-receiver-state.js b/moli-renderer-v8/tests/fixtures/observer-receiver-state.js
new file mode 100644
index 000000000..c7991f425
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/observer-receiver-state.js
@@ -0,0 +1,173 @@
+(() => {
+ const rows = [];
+ const check = (name, test) => {
+ try { test(); rows.push({name, passed: true}); }
+ catch (error) { rows.push({name, passed: false, error: String(error)}); }
+ };
+ const assert = (condition, message) => { if (!condition) throw new Error(message); };
+ const frame = document.body.appendChild(document.createElement('iframe'));
+ const realms = [['main', window], ['child', frame.contentWindow]];
+ const target = document.createElement('div');
+ let reads = 0;
+ const poison = () => { reads++; throw new Error('author code ran before receiver validation'); };
+ const interfaces = [
+ ['MutationObserver', ['observe', 'disconnect', 'takeRecords']],
+ ['IntersectionObserver', ['observe', 'unobserve', 'disconnect', 'takeRecords']],
+ ['ResizeObserver', ['observe', 'unobserve', 'disconnect']],
+ ['PerformanceObserver', ['observe', 'disconnect', 'takeRecords']],
+ ];
+ const observers = [];
+ const argsFor = (name, method, observable) => {
+ if (method === 'observe') {
+ if (name === 'MutationObserver') return [target, observable ? {get childList() { return poison(); }} : {childList: true}];
+ if (name === 'ResizeObserver') return [target, observable ? {get box() { return poison(); }} : {box: 'content-box'}];
+ if (name === 'PerformanceObserver') return [observable ? {get entryTypes() { return poison(); }} : {entryTypes: []}];
+ return [target];
+ }
+ return method === 'unobserve' ? [target] : [];
+ };
+ const invalidReceivers = (prototype, real) => {
+ const revoked = Proxy.revocable(real, {});
+ revoked.revoke();
+ return [
+ ['null', null], ['undefined', undefined], ['plain', {}], ['prototype', prototype],
+ ['inherited native object', Object.create(real)],
+ ['copied own properties', Object.create(prototype, Object.getOwnPropertyDescriptors(real))],
+ ['author Proxy', new Proxy(real, {get: poison, getPrototypeOf: poison, has: poison})],
+ ['revoked Proxy', revoked.proxy],
+ ];
+ };
+ const rejects = (realm, call) => {
+ reads = 0;
+ let error;
+ try { call(); } catch (caught) { error = caught; }
+ assert(error instanceof realm.TypeError, 'must throw the binding realm TypeError');
+ assert(reads === 0, 'receiver validation must precede author getters and Proxy traps');
+ };
+ try {
+ for (const [name, methods] of interfaces) {
+ const instances = realms.map(([label, realm]) => {
+ const instance = new realm[name](() => {});
+ observers.push(instance);
+ return [label, instance];
+ });
+ for (const [calleeName, realm] of realms) {
+ const prototype = realm[name].prototype;
+ for (const method of methods) {
+ const fn = prototype[method];
+ for (const [receiverName, receiver] of invalidReceivers(prototype, instances[0][1])) {
+ check(`${calleeName} ${name}.${method} rejects ${receiverName}`, () => {
+ rejects(realm, () => fn.apply(receiver, argsFor(name, method, true)));
+ });
+ }
+ for (const [receiverRealm, receiver] of instances) {
+ check(`${calleeName} ${name}.${method} accepts ${receiverRealm} native receiver`, () => {
+ fn.apply(receiver, argsFor(name, method, false));
+ });
+ }
+ }
+ for (const [, instance] of instances) instance.disconnect();
+ }
+ }
+
+ const attributes = ['root', 'rootMargin', 'scrollMargin', 'thresholds', 'delay', 'trackVisibility'];
+ const instances = realms.map(([label, realm]) => [label, new realm.IntersectionObserver(() => {}, {
+ root: target, rootMargin: '1px 2%', scrollMargin: '3px', threshold: [1, 0.5, 0.5, 0], delay: 123,
+ })]);
+ observers.push(...instances.map(([, observer]) => observer));
+ for (const [calleeName, realm] of realms) {
+ for (const attribute of attributes) {
+ const getter = Object.getOwnPropertyDescriptor(realm.IntersectionObserver.prototype, attribute).get;
+ for (const [receiverName, receiver] of invalidReceivers(realm.IntersectionObserver.prototype, instances[0][1])) {
+ check(`${calleeName} IntersectionObserver.${attribute} rejects ${receiverName}`, () => {
+ rejects(realm, () => getter.call(receiver));
+ });
+ }
+ for (const [receiverRealm, observer] of instances) {
+ check(`${calleeName} IntersectionObserver.${attribute} accepts ${receiverRealm} native receiver`, () => {
+ const actual = getter.call(observer);
+ if (attribute === 'root') assert(actual === target, 'root identity');
+ else if (attribute === 'thresholds') assert(JSON.stringify(actual) === '[0,0.5,0.5,1]', 'sorted thresholds with duplicates');
+ else assert(actual === ({rootMargin: '1px 2% 1px 2%', scrollMargin: '3px 3px 3px 3px', delay: 123, trackVisibility: false})[attribute], attribute);
+ });
+ }
+ }
+ }
+ for (const [label, observer] of instances) {
+ check(`${label} thresholds are a frozen Array`, () => {
+ const array = observer.thresholds;
+ assert(Array.isArray(array) && Object.isFrozen(array), 'FrozenArray binding');
+ assert(!Reflect.set(array, '0', 1), 'element mutation must fail');
+ assert(!Reflect.set(array, 'length', 0), 'length mutation must fail');
+ assert(!Reflect.defineProperty(array, 'extra', {value: 1}), 'extension must fail');
+ assert(JSON.stringify(observer.thresholds) === '[0,0.5,0.5,1]', 'state must remain unchanged');
+ });
+ check(`${label} IntersectionObserver has no exposed internal state`, () => {
+ assert(Reflect.ownKeys(observer).length === 0, 'observer own keys must not expose native slots');
+ });
+ }
+
+ for (const [name] of interfaces.slice(0, 2)) {
+ check(`${name} ignores author properties shadowing its native ID`, () => {
+ const observer = new window[name](() => {});
+ const slot = `__lm${name}Id`;
+ const saved = Object.getOwnPropertyDescriptor(observer, slot);
+ try {
+ Object.defineProperty(observer, slot, {get: poison, configurable: true});
+ reads = 0;
+ observer.observe(target, {childList: true});
+ observer.takeRecords();
+ if (name === 'IntersectionObserver') observer.unobserve(target);
+ observer.disconnect();
+ assert(reads === 0, 'native identity must not read author properties');
+ } finally {
+ if (saved) Object.defineProperty(observer, slot, saved);
+ else Reflect.deleteProperty(observer, slot);
+ observer.disconnect();
+ }
+ });
+ }
+ check('MutationObserver native queues cannot be redirected between genuine instances', () => {
+ const first = new MutationObserver(() => {}), second = new MutationObserver(() => {});
+ const left = document.createElement('div'), right = document.createElement('div');
+ const slot = '__lmMutationObserverId';
+ const saved = Object.getOwnPropertyDescriptor(second, slot);
+ try {
+ first.observe(left, {childList: true}); second.observe(right, {childList: true});
+ second[slot] = first[slot];
+ left.appendChild(document.createElement('span'));
+ right.appendChild(document.createElement('span'));
+ const a = first.takeRecords(), b = second.takeRecords();
+ assert(a.length === 1 && a[0].target === left, 'first observer queue');
+ assert(b.length === 1 && b[0].target === right, 'second observer queue');
+ } finally {
+ if (saved) Object.defineProperty(second, slot, saved); else Reflect.deleteProperty(second, slot);
+ first.disconnect(); second.disconnect();
+ }
+ });
+ for (const suffix of ['Root', 'RootMargin', 'ScrollMargin', 'Thresholds', 'Delay', 'TrackVisibility']) {
+ check(`IntersectionObserver metadata ignores author __lmIntersectionObserver${suffix}`, () => {
+ const observer = new IntersectionObserver(() => {}, {root: target});
+ const slot = `__lmIntersectionObserver${suffix}`;
+ const saved = Object.getOwnPropertyDescriptor(observer, slot);
+ try {
+ Object.defineProperty(observer, slot, {get: poison, configurable: true});
+ reads = 0;
+ assert(observer.root === target, 'root');
+ assert(observer.rootMargin === '0px 0px 0px 0px', 'rootMargin');
+ assert(observer.scrollMargin === '0px 0px 0px 0px', 'scrollMargin');
+ assert(JSON.stringify(observer.thresholds) === '[0]', 'thresholds');
+ assert(observer.delay === 0 && observer.trackVisibility === false, 'visibility options');
+ assert(reads === 0, 'metadata must not read author properties');
+ } finally {
+ if (saved) Object.defineProperty(observer, slot, saved); else Reflect.deleteProperty(observer, slot);
+ observer.disconnect();
+ }
+ });
+ }
+ } finally {
+ observers.forEach(observer => observer.disconnect());
+ frame.remove();
+ }
+ return JSON.stringify({total: rows.length, failures: rows.filter(row => !row.passed)});
+})();
diff --git a/moli-wpt-compat/fixtures/wpt/ported/idl/performanceobserver-idlharness.html b/moli-wpt-compat/fixtures/wpt/ported/idl/performanceobserver-idlharness.html
index 291890dcc..7cdeb0f65 100644
--- a/moli-wpt-compat/fixtures/wpt/ported/idl/performanceobserver-idlharness.html
+++ b/moli-wpt-compat/fixtures/wpt/ported/idl/performanceobserver-idlharness.html
@@ -9,9 +9,15 @@
idl_test([`
callback PerformanceObserverCallback = undefined (PerformanceObserverEntryList entries, PerformanceObserver observer);
+dictionary PerformanceObserverInit {
+ sequence<DOMString> entryTypes;
+ DOMString type;
+ boolean buffered;
+};
+
interface PerformanceObserver {
constructor(PerformanceObserverCallback callback);
- undefined observe(object options);
+ undefined observe(optional PerformanceObserverInit options = {});
undefined disconnect();
sequence<PerformanceEntry> takeRecords();
};