Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(performance): validate observer options and retain observe mode

ldm0225c7d36eda6
diff --git a/moli-core/tests/fixtures/runtime/performance_measure_observer.html b/moli-core/tests/fixtures/runtime/performance_measure_observer.html
index d76cbf8f7..01661e503 100644
--- a/moli-core/tests/fixtures/runtime/performance_measure_observer.html
+++ b/moli-core/tests/fixtures/runtime/performance_measure_observer.html
@@ -30,7 +30,7 @@
const markEntries = performance.getEntriesByType("mark");
const namedEntries = performance.getEntriesByName("named-mark");
const multiTypeObserver = new PerformanceObserver(() => {});
- multiTypeObserver.observe({ entryTypes: ["mark", "measure", "mark"], buffered: true });
+ multiTypeObserver.observe({ entryTypes: ["mark", "measure", "mark"] });
const multiTypeRecords = multiTypeObserver.takeRecords();
multiTypeObserver.disconnect();
const bufferedMarkObserver = new PerformanceObserver(() => {});
diff --git a/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/observer.rs b/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/observer.rs
index dacad489b..47ae589b8 100644
--- a/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/observer.rs
+++ b/moli-renderer-v8/src/context_bootstrap/performance_observer_runtime/observer.rs
@@ -24,6 +24,8 @@ struct PerformanceObserverObjectDeclaration<'s> {
pending: (),
#[webapi(slot = PERFORMANCE_OBSERVER_TYPE_SLOT, init = "null")]
observed_type: (),
+ #[webapi(slot = PERFORMANCE_OBSERVER_MODE_SLOT, init = 0)]
+ observe_mode: (),
#[webapi(slot = PERFORMANCE_OBSERVER_ENTRY_TYPES_SLOT, init = "array")]
entry_types: (),
#[webapi(slot = PERFORMANCE_OBSERVER_ACTIVE_SLOT, init = false)]
@@ -45,20 +47,29 @@ struct PerformanceObserverConstructorArgs {
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "PerformanceObserver.observe")]
-struct PerformanceObserverObserveArgs<'s> {
- #[webidl(required)]
- options: v8::Local<'s, v8::Object>,
+struct PerformanceObserverObserveArgs {
+ #[webidl(required, dictionary)]
+ options: PerformanceObserverInit,
}
#[derive(Default, webidl::WebIdlDictionary)]
#[webidl(prefix = "PerformanceObserverInit")]
struct PerformanceObserverInit {
- #[webidl(name = "type")]
- observed_type: Option<String>,
+ buffered: Option<bool>,
+ #[webidl(converter = "double")]
+ duration_threshold: Option<f64>,
#[webidl(converter = "raw")]
entry_types: Option<webidl::Sequence<webidl::DomString>>,
- #[webidl(default = false)]
- buffered: bool,
+ #[webidl(name = "type")]
+ observed_type: Option<String>,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+#[repr(u32)]
+enum ObserveMode {
+ Undefined = 0,
+ Single = 1,
+ Multiple = 2,
}
pub(in crate::context_bootstrap) fn performance_observer_constructor_callback<'s>(
@@ -102,20 +113,15 @@ pub(in crate::context_bootstrap) fn performance_observer_observe_callback<'s>(
let Some(parsed) = webidl::parse_args::<PerformanceObserverObserveArgs>(scope, &args) else {
return;
};
- let init =
- match webidl::parse_dictionary_object::<PerformanceObserverInit>(scope, parsed.options) {
- Ok(init) => init,
- Err(error) => {
- webidl::throw_error(scope, &error);
- return;
- }
- };
+ let init = parsed.options;
let has_entry_types_member = init.entry_types.is_some();
let has_type_member = init.observed_type.is_some();
- if has_entry_types_member && has_type_member {
+ if has_entry_types_member
+ && (has_type_member || init.buffered.is_some() || init.duration_threshold.is_some())
+ {
throw_type_error(
scope,
- "PerformanceObserver.observe options must not include both type and entryTypes.",
+ "PerformanceObserver.observe entryTypes must not be combined with other options.",
);
return;
}
@@ -127,11 +133,13 @@ pub(in crate::context_bootstrap) fn performance_observer_observe_callback<'s>(
return;
}
- let current_type_mode = performance_observer_type_slot_is_set(scope, args.this());
- let current_entry_types_mode = !current_type_mode
- && performance_observer_entry_types(scope, args.this())
- .is_some_and(|entry_types| entry_types.length() > 0);
- if has_entry_types_member && current_type_mode {
+ let requested_mode = if has_entry_types_member {
+ ObserveMode::Multiple
+ } else {
+ ObserveMode::Single
+ };
+ let current_mode = performance_observer_mode(scope, args.this());
+ if current_mode == ObserveMode::Single && requested_mode == ObserveMode::Multiple {
webidl::throw_dom_exception(
scope,
"InvalidModificationError",
@@ -139,7 +147,7 @@ pub(in crate::context_bootstrap) fn performance_observer_observe_callback<'s>(
);
return;
}
- if has_type_member && current_entry_types_mode {
+ if current_mode == ObserveMode::Multiple && requested_mode == ObserveMode::Single {
webidl::throw_dom_exception(
scope,
"InvalidModificationError",
@@ -147,6 +155,16 @@ pub(in crate::context_bootstrap) fn performance_observer_observe_callback<'s>(
);
return;
}
+ if current_mode == ObserveMode::Undefined {
+ // Choosing a mode precedes support filtering, which may abort registration.
+ let value = v8::Integer::new_from_unsigned(scope, requested_mode as u32);
+ set_performance_observer_slot_value(
+ scope,
+ args.this(),
+ PERFORMANCE_OBSERVER_MODE_SLOT,
+ value.into(),
+ );
+ }
let observed_entry_types = if let Some(observed_type) = init.observed_type.as_deref() {
if !performance_observer_entry_type_supported(observed_type) {
@@ -225,7 +243,7 @@ pub(in crate::context_bootstrap) fn performance_observer_observe_callback<'s>(
return;
}
set_performance_observer_active(scope, args.this(), true);
- if init.buffered && has_type_member {
+ if init.buffered.unwrap_or(false) && has_type_member {
enqueue_buffered_performance_entries(scope, args.this());
queue_performance_observer_delivery(scope, args.this());
}
@@ -245,6 +263,9 @@ pub(in crate::context_bootstrap) fn performance_observer_disconnect_callback<'s>
}
let pending = v8::Array::new(scope, 0);
set_performance_observer_pending(scope, args.this(), pending);
+ let entry_types = v8::Array::new(scope, 0);
+ set_performance_observer_entry_types(scope, args.this(), entry_types);
+ set_performance_observer_type(scope, args.this(), v8::null(scope).into());
rv.set_undefined();
}
@@ -274,12 +295,18 @@ fn performance_entry_types_array_from_strings<'s>(
serialize_v8_iter_array(scope, entry_types).unwrap_or_else(|| v8::Array::new(scope, 0))
}
-fn performance_observer_type_slot_is_set<'s>(
+fn performance_observer_mode<'s>(
scope: &mut v8::PinScope<'s, '_>,
observer: v8::Local<'s, v8::Object>,
-) -> bool {
- performance_observer_slot_value(scope, observer, PERFORMANCE_OBSERVER_TYPE_SLOT)
- .is_some_and(|value| !value.is_null_or_undefined())
+) -> ObserveMode {
+ match performance_observer_slot_value(scope, observer, PERFORMANCE_OBSERVER_MODE_SLOT)
+ .and_then(|value| v8::Local::<v8::Uint32>::try_from(value).ok())
+ .map(|value| value.value())
+ {
+ Some(1) => ObserveMode::Single,
+ Some(2) => ObserveMode::Multiple,
+ _ => ObserveMode::Undefined,
+ }
}
fn performance_observer_entry_type_supported(entry_type: &str) -> bool {
diff --git a/moli-renderer-v8/src/context_bootstrap/shared/slots.rs b/moli-renderer-v8/src/context_bootstrap/shared/slots.rs
index 4f153a42b..7b3802ddd 100644
--- a/moli-renderer-v8/src/context_bootstrap/shared/slots.rs
+++ b/moli-renderer-v8/src/context_bootstrap/shared/slots.rs
@@ -121,6 +121,8 @@ pub(in crate::context_bootstrap) const PERFORMANCE_OBSERVER_PENDING_SLOT: &str =
"__moliPerformanceObserverPending";
pub(in crate::context_bootstrap) const PERFORMANCE_OBSERVER_TYPE_SLOT: &str =
"__moliPerformanceObserverType";
+pub(in crate::context_bootstrap) const PERFORMANCE_OBSERVER_MODE_SLOT: &str =
+ "__moliPerformanceObserverMode";
pub(in crate::context_bootstrap) const PERFORMANCE_OBSERVER_ENTRY_TYPES_SLOT: &str =
"__moliPerformanceObserverEntryTypes";
pub(in crate::context_bootstrap) const PERFORMANCE_OBSERVER_ACTIVE_SLOT: &str =
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index e48295209..bcc5edf26 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -2149,6 +2149,7 @@ mod headers_list;
mod http_fixture;
mod media_owner_playback_interfaces;
mod media_recorder_shell;
+mod performance_observer_contract;
mod svg_animation_interfaces;
mod svg_computed_path_precision;
mod svg_transform_sync_consolidation;
diff --git a/moli-renderer-v8/src/script_vm/tests/performance_observer_contract.js b/moli-renderer-v8/src/script_vm/tests/performance_observer_contract.js
new file mode 100644
index 000000000..84bf17531
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/performance_observer_contract.js
@@ -0,0 +1,136 @@
+(function observerContract(owner, callee, tag) {
+ const checks = [];
+ const record = (name, callback) => {
+ try { checks.push({name: 'observer/' + tag + '/' + name, passed: callback() === true}); }
+ catch (error) { checks.push({name: 'observer/' + tag + '/' + name, passed: false, error: String(error)}); }
+ };
+ const observe = callee.PerformanceObserver.prototype.observe;
+ const disconnect = callee.PerformanceObserver.prototype.disconnect;
+ const make = () => new owner.PerformanceObserver(() => {});
+ const run = (options, callback) => {
+ const observer = make();
+ try { return callback(observer, () => observe.call(observer, options)); }
+ finally { disconnect.call(observer); }
+ };
+ const thrown = callback => { try { callback(); } catch (error) { return error; } };
+ const typeError = error => error instanceof callee.TypeError;
+ const invalidMode = callback => {
+ const error = thrown(callback);
+ return error instanceof callee.DOMException && error.name === 'InvalidModificationError';
+ };
+ for (const kind of ['own', 'inherited', 'proxy']) {
+ for (const mode of ['type', 'entries']) {
+ record('dictionary-order/' + kind + '/' + mode, () => {
+ const trace = [], target = {};
+ for (const name of ['buffered', 'durationThreshold', 'entryTypes', 'type']) {
+ Object.defineProperty(target, name, {get() {
+ trace.push(name);
+ if (name === 'durationThreshold' && mode === 'type') return {valueOf() {trace.push('number'); return 16;}};
+ if (name === 'type' && mode === 'type') return {toString() {trace.push('string'); return 'mark';}};
+ if (name === 'entryTypes' && mode === 'entries') return ['mark'];
+ return undefined;
+ }});
+ }
+ const input = kind === 'inherited' ? Object.create(target) : kind === 'proxy' ? new Proxy(target, {}) : target;
+ return run(input, (_, call) => {
+ call();
+ const expected = mode === 'type' ? ['buffered','durationThreshold','number','entryTypes','type','string'] : ['buffered','durationThreshold','entryTypes','type'];
+ return trace.join() === expected.join();
+ });
+ });
+ }
+ for (const key of ['buffered', 'durationThreshold', 'entryTypes', 'type']) {
+ record('getter-throws/' + kind + '/' + key, () => {
+ const trace = [], sentinel = {}, target = {};
+ const names = ['buffered','durationThreshold','entryTypes','type'];
+ for (const name of names) Object.defineProperty(target, name, {get() {
+ trace.push(name); if (name === key) throw sentinel; return undefined;
+ }});
+ const value = kind === 'inherited' ? Object.create(target) : kind === 'proxy' ? new Proxy(target, {}) : target;
+ return run(value, (_, call) => thrown(call) === sentinel && trace.join() === names.slice(0,names.indexOf(key)+1).join());
+ });
+ }
+ }
+ for (const mode of ['type', 'entries', 'invalid']) {
+ for (const [label, value] of [['nan',NaN], ['positive-infinity',Infinity], ['negative-infinity',-Infinity], ['symbol',Symbol()], ['bigint',1n]]) {
+ record('restricted-double/' + mode + '/' + label, () => {
+ let later = 0;
+ return run({durationThreshold:value, get entryTypes() {later++; return mode === 'entries' ? ['mark'] : undefined;}, get type() {later++; return mode === 'type' ? 'mark' : undefined;}}, (_,call) => typeError(thrown(call)) && later === 0);
+ });
+ }
+ record('number-throws/' + mode, () => {
+ const sentinel = {}; let later = 0;
+ return run({durationThreshold:{[Symbol.toPrimitive]() {throw sentinel;}}, get entryTypes() {later++;return mode === 'entries' ? ['mark'] : undefined;}, get type() {later++;return mode === 'type' ? 'mark' : undefined;}}, (_,call) => thrown(call) === sentinel && later === 0);
+ });
+ }
+ for (const [name, value] of [['absent',undefined],['null',null],['false',false],['true',true],['zero',0],['fraction',0.25],['negative',-10],['large',1e100],['string','16'],['object',{valueOf(){return 16;}}]]) {
+ record('type-threshold/' + name, () => run({type:'mark',durationThreshold:value}, (_,call) => {call();return true;}));
+ record('entries-threshold/' + name, () => run({entryTypes:['mark'],durationThreshold:value}, (_,call) => value === undefined ? (call(),true) : typeError(thrown(call))));
+ }
+ for (const [name,value] of [['absent',undefined],['null',null],['false',false],['true',true],['zero',0],['empty-string',''],['object',{}]]) {
+ record('entries-buffered/' + name, () => run({entryTypes:['mark'],buffered:value}, (_,call) => value === undefined ? (call(),true) : typeError(thrown(call))));
+ }
+ record('boolean-no-primitive', () => {
+ let calls = 0;
+ return run({type:'mark',buffered:{[Symbol.toPrimitive]() {calls++;throw Error('must not convert');}}},(_,call) => {call();return calls === 0;});
+ });
+ for (const [name, first, second] of [
+ ['empty-multiple',{entryTypes:[]},{type:'mark'}],
+ ['unsupported-multiple',{entryTypes:['unknown-observer-type']},{type:'mark'}],
+ ['unsupported-single',{type:'unknown-observer-type'},{entryTypes:['mark']}],
+ ['supported-multiple',{entryTypes:['mark']},{type:'measure'}],
+ ['supported-single',{type:'mark'},{entryTypes:['measure']}],
+ ]) {
+ for (const disconnected of [false,true]) record('mode/' + name + '/' + disconnected, () => {
+ const observer = make();
+ try { observe.call(observer,first); if (disconnected) disconnect.call(observer); return invalidMode(() => observe.call(observer,second)); }
+ finally { disconnect.call(observer); }
+ });
+ }
+ for (const [name, first] of [
+ ['empty-options',{}],['mixed-type',{entryTypes:['mark'],type:'mark'}],['mixed-buffered',{entryTypes:['mark'],buffered:false}],['mixed-threshold',{entryTypes:['mark'],durationThreshold:0}],
+ ]) for (const second of [{type:'mark'},{entryTypes:['mark']}]) record('failed-options-do-not-select-mode/' + name + '/' + ('type' in second), () => {
+ const observer = make();
+ try { if (!typeError(thrown(() => observe.call(observer,first)))) return false; observe.call(observer,second); return true; }
+ finally { disconnect.call(observer); }
+ });
+ record('conversion-failure-does-not-select-mode', () => {
+ const observer = make(), sentinel = {};
+ try {
+ if (thrown(() => observe.call(observer,{type:'mark',durationThreshold:{valueOf(){throw sentinel;}}})) !== sentinel) return false;
+ observe.call(observer,{entryTypes:['mark']}); return true;
+ } finally { disconnect.call(observer); }
+ });
+ for (const [name, forge] of [
+ ['ordinary',() => ({})], ['prototype',() => Object.create(owner.PerformanceObserver.prototype)],
+ ['inherited-native', value => Object.create(value)], ['author-proxy', value => new Proxy(value,{})],
+ ['revoked',value => {const proxy=Proxy.revocable(value,{});proxy.revoke();return proxy.proxy;}],
+ ]) record('receiver/' + name, () => {
+ const observer = make(); let gets=0;
+ try { const error=thrown(() => observe.call(forge(observer),new Proxy({},{get(){gets++;return undefined;}})));return typeError(error) && gets===0; }
+ finally { disconnect.call(observer); }
+ });
+ // Subscription changes are tested in the observer's own realm so the marks
+ // have the same relevant global as the observer.
+ if (owner === callee) {
+ for (const kind of ['single','multiple']) record('disconnect-clears-subscriptions/' + kind, () => {
+ const observer = make(), unique='observer-contract-' + tag + '-' + kind;
+ try {
+ observe.call(observer,kind==='single' ? {type:'mark'} : {entryTypes:['mark']});
+ owner.performance.mark(unique+'-before');
+ disconnect.call(observer);
+ if (observer.takeRecords().length !== 0) return false;
+ observe.call(observer,kind==='single' ? {type:'measure'} : {entryTypes:['measure']});
+ owner.performance.mark(unique+'-mark');owner.performance.measure(unique+'-measure');
+ const entries=observer.takeRecords();
+ return entries.length===1 && entries[0].name===unique+'-measure' && entries[0].entryType==='measure';
+ } finally {disconnect.call(observer);owner.performance.clearMarks(unique+'-before');owner.performance.clearMarks(unique+'-mark');owner.performance.clearMeasures(unique+'-measure');}
+ });
+ record('unsupported-call-preserves-registration', () => {
+ const observer=make(),unique='observer-contract-'+tag+'-registration';
+ try {observe.call(observer,{type:'mark'});observe.call(observer,{type:'unsupported-observer-type'});owner.performance.mark(unique);return observer.takeRecords().some(entry=>entry.name===unique);}
+ finally {disconnect.call(observer);owner.performance.clearMarks(unique);}
+ });
+ }
+ return checks;
+})
diff --git a/moli-renderer-v8/src/script_vm/tests/performance_observer_contract.rs b/moli-renderer-v8/src/script_vm/tests/performance_observer_contract.rs
new file mode 100644
index 000000000..13b691e19
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/performance_observer_contract.rs
@@ -0,0 +1,26 @@
+use super::*;
+
+#[test]
+fn performance_observer_options_and_modes_follow_webidl_and_timeline_algorithms() {
+ let mut vm = new_storage_page_task_executor_test_vm("https://observer-contract.test/");
+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")
+ .unwrap();
+ let source = format!(
+ r#"(() => {{
+ const probe = {};
+ const realms = [globalThis, document.getElementById('child').contentWindow];
+ const checks = [];
+ for (let owner = 0; owner < 2; owner++) for (let callee = 0; callee < 2; callee++)
+ checks.push(...probe(realms[owner], realms[callee], 'window-' + owner + '-' + callee));
+ globalThis.__observerContractChecks = checks;
+ return checks.length;
+ }})()"#,
+ include_str!("performance_observer_contract.js"),
+ );
+ assert_eq!(vm.eval(&source).unwrap(), "358");
+ assert_eq!(
+ vm.eval("JSON.stringify(__observerContractChecks.filter(row => !row.passed))")
+ .unwrap(),
+ "[]"
+ );
+}