Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.htmlindex 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.rsindex 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.rsindex 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.rsindex 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.jsnew file mode 100644index 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.rsnew file mode 100644index 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(),+ "[]"+ );+}