Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(media): bind native PictureInPicture event payloads
ldm06e78b7cd8ba7
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rsindex 128423d86..d2d7a922a 100644--- a/moli-renderer-v8/src/context_bootstrap.rs+++ b/moli-renderer-v8/src/context_bootstrap.rs@@ -28,6 +28,9 @@ mod form_data_runtime;mod geometry_runtime;mod history_mutation;mod history_runtime;+mod picture_in_picture;+#[cfg(test)]+pub(crate) use picture_in_picture::closed_window_for_test as closed_picture_in_picture_window_for_test;mod time_ranges;pub(crate) mod web_mcp;pub(crate) use history_runtime::state::bind_isolated_window_history_owner;diff --git a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rsindex a9718ec3b..55e627bff 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs@@ -115,6 +115,9 @@ pub(in crate::context_bootstrap) fn build_constructor_template<'s>(}ConstructorKind::BlobEvent => build_value_event_template(scope, ValueEventKind::Blob),ConstructorKind::GamepadEvent => build_value_event_template(scope, ValueEventKind::Gamepad),+ ConstructorKind::PictureInPictureEvent => {+ build_value_event_template(scope, ValueEventKind::PictureInPicture)+ }ConstructorKind::WebGLContextEvent => {build_value_event_template(scope, ValueEventKind::WebGlContext)}diff --git a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rsindex f527a4a43..99ba84d8b 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs@@ -426,6 +426,7 @@ pub(super) fn install_constructor_template_bindings<'s>(}install_media_cue_template_bindings(scope, template, spec.interface.name());install_media_source_template_bindings(scope, template, spec.interface.name());+ super::super::picture_in_picture::install(scope, template, spec.interface.name());super::super::video_codecs::install_video_codec_template_bindings(scope,template,diff --git a/moli-renderer-v8/src/context_bootstrap/events/value.rs b/moli-renderer-v8/src/context_bootstrap/events/value.rsindex 37af5c543..9f2edbc97 100644--- a/moli-renderer-v8/src/context_bootstrap/events/value.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/value.rs@@ -19,6 +19,7 @@ const STATUS_MESSAGE_SLOT: &str = "__moliWebGlContextEventStatusMessage";const TIMECODE_SLOT: &str = "__moliValueEventTimecode";const TOOL_NAME_SLOT: &str = "__moliToolEventName";const GAMEPAD_SLOT: &str = "__moliValueEventGamepad";+const PICTURE_IN_PICTURE_WINDOW_SLOT: &str = "__moliPictureInPictureEventWindow";#[derive(Clone, Copy)]pub(in crate::context_bootstrap) enum ValueEventKind {@@ -29,6 +30,7 @@ pub(in crate::context_bootstrap) enum ValueEventKind {ToolActivated,ToolCancel,Gamepad,+ PictureInPicture,}impl ValueEventKind {@@ -41,12 +43,13 @@ impl ValueEventKind {Self::ToolActivated => "ToolActivatedEvent",Self::ToolCancel => "ToolCancelEvent",Self::Gamepad => "GamepadEvent",+ Self::PictureInPicture => "PictureInPictureEvent",}}fn length(self) -> i32 {match self {- Self::Blob => 2,+ Self::Blob | Self::PictureInPicture => 2,_ => 1,}}@@ -200,6 +203,22 @@ struct BlobEventInit<'s> {timecode: Option<f64>,}+#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::PictureInPictureEvent, enumerable, receiver)]+struct PictureInPictureEventPrototype {+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, PICTURE_IN_PICTURE_WINDOW_SLOT))]+ picture_in_picture_window: (),+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "PictureInPictureEventInit")]+struct PictureInPictureEventInit<'s> {+ #[webidl(inherit)]+ base: EventInit,+ #[webidl(required, interface = web_api_interfaces::PictureInPictureWindow)]+ picture_in_picture_window: v8::Local<'s, v8::Object>,+}+fn string_member<'s>(scope: &mut v8::PinScope<'s, '_>,object: v8::Local<'s, v8::Object>,@@ -240,6 +259,9 @@ pub(in crate::context_bootstrap) fn install_value_event_template_bindings<'s>("ToolCancelEvent" => {ToolCancelEventPrototypeDeclaration::initialize_prototype_template(scope, prototype)}+ "PictureInPictureEvent" => {+ PictureInPictureEventPrototype::initialize_prototype_template(scope, prototype)+ }"GamepadEvent" => {GamepadEventPrototypeDeclaration::initialize_prototype_template(scope, prototype)}@@ -253,7 +275,9 @@ fn payload_getter<'s>(mut rv: v8::ReturnValue<'_, v8::Value>,) {let key = args.data().to_rust_string_lossy(scope);- if let Some(value) = event_private_value(scope, args.this(), &key) {+ let target = moli_webapi_declare::web_api_object_target(scope, args.this())+ .expect("validated value event receiver");+ if let Some(value) = event_private_value(scope, target, &key) {rv.set(value);}}@@ -281,6 +305,7 @@ fn value_event_constructor<'s>(Some(4) => ValueEventKind::ToolActivated,Some(5) => ValueEventKind::ToolCancel,Some(6) => ValueEventKind::Gamepad,+ Some(7) => ValueEventKind::PictureInPicture,_ => return,};if !args.is_construct_call() {@@ -386,6 +411,22 @@ fn value_event_constructor<'s>(parsed.base.composed,)}+ ValueEventKind::PictureInPicture => {+ let parsed = webidl::parse_dictionary_object::<PictureInPictureEventInit>(+ scope, dictionary,+ )?;+ set_event_private_value(+ scope,+ state,+ PICTURE_IN_PICTURE_WINDOW_SLOT,+ parsed.picture_in_picture_window.into(),+ );+ (+ parsed.base.bubbles,+ parsed.base.cancelable,+ parsed.base.composed,+ )+ }ValueEventKind::Gamepad => {let parsed =webidl::parse_dictionary_object::<GamepadEventInit>(scope, dictionary)?;diff --git a/moli-renderer-v8/src/context_bootstrap/picture_in_picture.rs b/moli-renderer-v8/src/context_bootstrap/picture_in_picture.rsnew file mode 100644index 000000000..b056dfcd0--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/picture_in_picture.rs@@ -0,0 +1,106 @@+//! Picture-in-Picture interface members. Opening a native window still requires+//! a presentation backend; these bindings do not manufacture a successful request.++use super::media_queries;+use crate::{+ util::{get_private_value, set_private_value, v8str},+ web_api_interfaces,+};+use moli_webapi_declare::WebApiFunctionTemplate;++const WIDTH: &str = "__moliPictureInPictureWindowWidth";+const HEIGHT: &str = "__moliPictureInPictureWindowHeight";+const ON_RESIZE: &str = "__moliPictureInPictureWindowOnresize";+const LISTENERS: &str = "__moliPictureInPictureWindowListeners";++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::PictureInPictureWindow, enumerable, receiver)]+struct PictureInPictureWindowPrototype {+ #[webapi(accessor_property, getter = dimension_getter, data = v8str(scope, WIDTH))]+ width: (),+ #[webapi(accessor_property, getter = dimension_getter, data = v8str(scope, HEIGHT))]+ height: (),+ #[webapi(accessor_property, getter = resize_handler_getter, setter = resize_handler_setter)]+ onresize: (),+}++pub(super) fn install<'s>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ template: v8::Local<'s, v8::FunctionTemplate>,+ name: &str,+) {+ if name == "PictureInPictureWindow" {+ PictureInPictureWindowPrototype::initialize_prototype_template(+ scope,+ template.prototype_template(scope),+ );+ }+}++fn target<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ receiver: v8::Local<'s, v8::Object>,+) -> v8::Local<'s, v8::Object> {+ moli_webapi_declare::web_api_object_target(scope, receiver)+ .expect("PictureInPictureWindow receiver was validated")+}++fn dimension_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ let window = target(scope, args.this());+ let slot = args.data().to_rust_string_lossy(scope);+ // Closed windows have zero dimensions. No presentation backend currently+ // produces an opened PictureInPictureWindow.+ rv.set(+ get_private_value(scope, window, &slot)+ .unwrap_or_else(|| v8::Integer::new(scope, 0).into()),+ );+}++fn resize_handler_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ let window = target(scope, args.this());+ rv.set(get_private_value(scope, window, ON_RESIZE).unwrap_or_else(|| v8::null(scope).into()));+}++fn resize_handler_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let window = target(scope, args.this());+ let active = args.get(0).is_object();+ let handler = if active {+ args.get(0)+ } else {+ v8::null(scope).into()+ };+ set_private_value(scope, window, ON_RESIZE, handler);+ media_queries::simple_object_event_set_ordered_handler(+ scope, window, LISTENERS, "resize", ON_RESIZE, active,+ );+}++/// A closed native window for binding tests, never a production PiP request.+#[cfg(test)]+pub(crate) fn closed_window_for_test<'s>(+ scope: &mut v8::PinScope<'s, '_>,+) -> v8::Local<'s, v8::Object> {+ #[derive(Default, moli_webapi_declare::WebApiObject)]+ #[webapi(interface = web_api_interfaces::PictureInPictureWindow)]+ struct ClosedWindow {+ #[webapi(slot = super::shared::SIMPLE_EVENT_TARGET_SLOT, value = LISTENERS)]+ event_target: (),+ #[webapi(slot = super::shared::SIMPLE_EVENT_TARGET_ORDERED_HANDLERS_SLOT, init = true)]+ ordered_handlers: (),+ }+ ClosedWindow::default()+ .bind(scope)+ .expect("closed native PiP window")+}diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rsindex 4c7c3354f..569ef1c8c 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs@@ -4,6 +4,14 @@ use crate::web_api_interfaces;use std::collections::HashSet;const CONSTRUCTOR_SPECS_BEFORE_STREAMS: &[ConstructorSpec] = &[+ ConstructorSpec {+ interface: web_api_interfaces::PictureInPictureEvent::DESCRIPTOR,+ kind: ConstructorKind::PictureInPictureEvent,+ },+ ConstructorSpec {+ interface: web_api_interfaces::PictureInPictureWindow::DESCRIPTOR,+ kind: ConstructorKind::Illegal,+ },ConstructorSpec {interface: web_api_interfaces::AuthenticatorAssertionResponse::DESCRIPTOR,kind: ConstructorKind::Illegal,diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rsindex d972eda25..81aa49b06 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs@@ -14,6 +14,7 @@ pub(in crate::context_bootstrap) enum ConstructorKind {ToolActivatedEvent,ToolCancelEvent,GamepadEvent,+ PictureInPictureEvent,UiEvent,FocusEvent,CompositionEvent,diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rsindex 06891f017..9f893058d 100644--- a/moli-renderer-v8/src/script_vm/tests/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs@@ -1,5 +1,6 @@mod credential_container;mod credential_json_options;+mod picture_in_picture_interfaces;mod writable_stream_native_receivers;use super::post_parse::dynamic_script_execute_is_runnable_before_dom_content_loaded;use super::{diff --git a/moli-renderer-v8/src/script_vm/tests/picture_in_picture_interfaces.js b/moli-renderer-v8/src/script_vm/tests/picture_in_picture_interfaces.jsnew file mode 100644index 000000000..afaed7609--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/picture_in_picture_interfaces.js@@ -0,0 +1,99 @@+(() => {+ const checks = [];+ function check(name, action) {+ try { checks.push({name, passed: action() === true}); }+ catch (error) { checks.push({name, passed: false, error: String(error)}); }+ }+ const caught = action => { try { action(); return null; } catch (error) { return error; } };+ const frame = document.createElement('iframe');+ document.body.appendChild(frame);+ // Standalone lightweight popup shells do not provide a full Window realm.+ // Exercise the root and child realms that install native interface templates.+ const owners = [window, frame.contentWindow];+ try {+ for (const [realm, owner] of owners.entries()) {+ const Window = owner.PictureInPictureWindow;+ const Event = owner.PictureInPictureEvent;+ const typeError = error => error !== null && Object.getPrototypeOf(error) === owner.TypeError.prototype;+ check(`${realm}/Window constructor and inheritance`, () => Window.name === 'PictureInPictureWindow' && Window.length === 0 &&+ Object.getPrototypeOf(Window.prototype) === owner.EventTarget.prototype &&+ Object.getOwnPropertyDescriptor(Window.prototype, Symbol.toStringTag).value === 'PictureInPictureWindow');+ check(`${realm}/event constructor and inheritance`, () => Event.name === 'PictureInPictureEvent' && Event.length === 2 &&+ Object.getPrototypeOf(Event.prototype) === owner.Event.prototype &&+ Object.getOwnPropertyDescriptor(Event.prototype, Symbol.toStringTag).value === 'PictureInPictureEvent');+ let traps = 0;+ const proxy = new Proxy({}, {get() { traps++; throw Error('get trap'); }, getPrototypeOf() { traps++; throw Error('prototype trap'); }});+ const revoked = Proxy.revocable({}, {}); revoked.revoke();+ const invalidReceivers = [undefined, null, {}, new owner.EventTarget(), new owner.Event('x'), Window.prototype,+ Object.create(Window.prototype), Object.create(Event.prototype), proxy, revoked.proxy];+ for (const [name, prototype, setter] of [['width', Window.prototype, false], ['height', Window.prototype, false],+ ['onresize', Window.prototype, true], ['pictureInPictureWindow', Event.prototype, false]]) {+ const descriptor = Object.getOwnPropertyDescriptor(prototype, name);+ check(`${realm}/${name}/own enumerable configurable accessor`, () => !!descriptor && descriptor.enumerable && descriptor.configurable &&+ typeof descriptor.get === 'function' && descriptor.get.length === 0 &&+ (setter ? typeof descriptor.set === 'function' && descriptor.set.length === 1 : descriptor.set === undefined));+ for (const [index, receiver] of invalidReceivers.entries()) {+ check(`${realm}/${name}/invalid getter receiver ${index}`, () => typeError(caught(() => descriptor.get.call(receiver))));+ if (setter) {+ check(`${realm}/${name}/invalid setter receiver ${index}`, () => {+ let conversions = 0;+ const value = {toString() { conversions++; throw Error('unexpected conversion'); }};+ return typeError(caught(() => descriptor.set.call(receiver, value))) && conversions === 0;+ });+ }+ }+ }+ for (const construct of [false, true]) {+ check(`${realm}/Window illegal constructor/${construct}`, () => {+ let conversions = 0;+ const value = {toString() { conversions++; throw Error('unexpected conversion'); }};+ const error = caught(() => construct ? new Window(value) : Window(value));+ return typeError(error) && conversions === 0;+ });+ }+ for (const count of [0, 1]) {+ check(`${realm}/event requires two arguments before type conversion/${count}`, () => {+ let conversions = 0;+ const value = {toString() { conversions++; throw Error('unexpected conversion'); }};+ return typeError(caught(() => Reflect.construct(Event, count ? [value] : []))) && conversions === 0;+ });+ }+ check(`${realm}/event requires new before argument conversion`, () => {+ let conversions = 0;+ return typeError(caught(() => Event({toString() { conversions++; throw Error('unexpected conversion'); }}, {}))) && conversions === 0;+ });+ for (const [index, dictionary] of [undefined, null, {}, false, 1, 'x', 1n, Symbol('dictionary')].entries()) {+ check(`${realm}/invalid or incomplete dictionary/${index}`, () => typeError(caught(() => new Event('x', dictionary))));+ }+ for (const [index, value] of [undefined, null, false, 1, 'x', 1n, Symbol('window'), {}, Window.prototype,+ Object.create(Window.prototype), Object.create(new owner.EventTarget()), proxy, revoked.proxy].entries()) {+ check(`${realm}/required native window brand/${index}`, () => typeError(caught(() => new Event('x', {pictureInPictureWindow: value}))));+ }+ for (const throwingMember of ['type', 'bubbles', 'cancelable', 'composed', 'pictureInPictureWindow', 'none']) {+ check(`${realm}/dictionary conversion order and exception identity/${throwingMember}`, () => {+ const log = [], marker = {};+ const read = name => {+ log.push(name);+ if (name === throwingMember) throw marker;+ return name === 'type' ? 'resize' : name === 'pictureInPictureWindow' ? {} : false;+ };+ const type = {toString() { return read('type'); }};+ const dictionary = {};+ for (const name of ['bubbles', 'cancelable', 'composed', 'pictureInPictureWindow']) {+ Object.defineProperty(dictionary, name, {get() { return read(name); }});+ }+ const error = caught(() => new Event(type, dictionary));+ const names = ['type', 'bubbles', 'cancelable', 'composed', 'pictureInPictureWindow'];+ const expected = throwingMember === 'none' ? names : names.slice(0, names.indexOf(throwingMember) + 1);+ return JSON.stringify(log) === JSON.stringify(expected) && (throwingMember === 'none' ? typeError(error) : error === marker);+ });+ }+ check(`${realm}/author and revoked Proxy brand checks do not invoke traps`, () => traps === 0);+ }+ } finally {+ frame.remove();+ }+ const facts = {complete: true, total: checks.length, passed: checks.filter(row => row.passed).length, checks};+ globalThis.__uiEventResults = facts;+ return facts.passed === facts.total;+})()diff --git a/moli-renderer-v8/src/script_vm/tests/picture_in_picture_interfaces.rs b/moli-renderer-v8/src/script_vm/tests/picture_in_picture_interfaces.rsnew file mode 100644index 000000000..0ee0dfbee--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/picture_in_picture_interfaces.rs@@ -0,0 +1,134 @@+use super::*;++#[test]+fn picture_in_picture_interfaces_validate_descriptors_receivers_and_required_dictionary_members() {+ let mut vm = new_storage_page_task_executor_test_vm("https://picture-in-picture.test/");+ assert_eq!(+ vm.eval(include_str!("picture_in_picture_interfaces.js"))+ .unwrap(),+ "true",+ "{}",+ vm.eval("JSON.stringify(__uiEventResults.checks.filter(row => !row.passed))")+ .unwrap()+ );+}++fn install_closed_window(vm: &mut ScriptVm) {+ let context_ptr = &vm.page_default_runtime.context as *const _;+ vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {+ let global = scope.get_current_context().global(scope);+ let window = crate::context_bootstrap::closed_picture_in_picture_window_for_test(scope);+ let handler = crate::util::new_null_prototype_object(scope);+ let proxy = v8::Proxy::new(scope, window, handler).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ for (name, value) in [+ ("nativeWindow", window.into()),+ ("nativeProxy", proxy.into()),+ ] {+ assert_eq!(+ global.create_data_property(scope, crate::util::v8str(scope, name).into(), value),+ Some(true)+ );+ }+ Ok(())+ })+ .unwrap();+}++#[test]+fn picture_in_picture_events_retain_native_window_identity_across_realms_and_author_mutations() {+ let mut vm = new_storage_page_task_executor_test_vm("https://picture-in-picture-events.test/");+ vm.eval("document.body.innerHTML = '<iframe></iframe>'")+ .unwrap();+ install_closed_window(&mut vm);+ assert_eq!(vm.eval(r#"(() => {+ const assert = (ok, name) => {if (!ok) throw Error(name)};+ const other = document.querySelector('iframe').contentWindow;+ const payload = Object.getOwnPropertyDescriptor(other.PictureInPictureEvent.prototype, 'pictureInPictureWindow').get;+ const width = Object.getOwnPropertyDescriptor(other.PictureInPictureWindow.prototype, 'width').get;+ assert(nativeWindow.width === 0 && nativeWindow.height === 0 && nativeProxy.width === 0, 'closed dimensions');+ for (const window of [nativeWindow, nativeProxy]) {+ const event = new other.PictureInPictureEvent('enterpictureinpicture', {pictureInPictureWindow: window, bubbles:true, cancelable:true, composed:true});+ assert(event instanceof other.PictureInPictureEvent && event instanceof other.Event && !(event instanceof PictureInPictureEvent), 'constructor realm');+ assert(event.pictureInPictureWindow === window && event.pictureInPictureWindow === event.pictureInPictureWindow, 'SameObject preserves original argument');+ assert(event.type === 'enterpictureinpicture' && event.bubbles && event.cancelable && event.composed && !event.isTrusted, 'inherited EventInit');+ Object.defineProperty(event, 'pictureInPictureWindow', {value: {}, configurable:true});+ assert(payload.call(event) === window, 'author payload expando does not alter native state');+ const proxy = Proxy.revocable(window, {}); proxy.revoke();+ let traps = 0;+ const author = new Proxy(window, {get() {traps++; throw Error('get')}, getPrototypeOf() {traps++; throw Error('prototype')}});+ for (const bad of [Object.create(window), author, proxy.proxy]) {+ let error; try {new other.PictureInPictureEvent('x', {pictureInPictureWindow:bad})} catch (caught) {error=caught}+ assert(Object.getPrototypeOf(error) === other.TypeError.prototype, 'author wrapper rejected in callee realm');+ }+ assert(traps === 0, 'native brand does not invoke author traps');+ }+ class Derived extends other.PictureInPictureEvent {}+ const derived = new Derived('x', {pictureInPictureWindow:nativeWindow});+ assert(derived instanceof Derived && payload.call(derived) === nativeWindow, 'subclass native brand');+ Object.defineProperty(nativeWindow, 'width', {get() {throw Error('public dimension read')}});+ Object.setPrototypeOf(nativeWindow, null);+ assert(width.call(nativeWindow) === 0 && payload.call(derived) === nativeWindow, 'private identity survives prototype and expando changes');+ return true;+ })()"#).unwrap(), "true");+}++#[test]+fn picture_in_picture_resize_handlers_share_listener_order_and_cancellation_state() {+ let mut vm = new_storage_page_task_executor_test_vm("https://picture-in-picture-resize.test/");+ install_closed_window(&mut vm);+ assert_eq!(vm.eval(r#"(() => {+ const assert = (ok, name) => {if (!ok) throw Error(name)};+ const target = nativeWindow, order = [];+ const descriptor = Object.getOwnPropertyDescriptor(PictureInPictureWindow.prototype, 'onresize');+ assert(target.onresize === null, 'initial handler');+ target.addEventListener('resize', event => {order.push('before'); assert(event.target === target, 'native target')});+ target.onresize = function(event) {order.push('original'); assert(this === target && event.currentTarget === target, 'callback this and currentTarget')};+ target.addEventListener('resize', () => order.push('after'));+ nativeProxy.onresize = function(event) {order.push('replacement'); assert(this === target, 'native proxy updates same handler'); return false};+ const event = new Event('resize', {cancelable:true});+ assert(target.dispatchEvent(event) === false && event.defaultPrevented, 'handler cancellation');+ assert(order.join() === 'before,replacement,after' && target.onresize === nativeProxy.onresize, 'replacement preserves listener position');+ for (const value of [undefined, null, false, 3, 'x', 1n, Symbol('handler')]) {+ descriptor.set.call(target, value);+ assert(target.onresize === null, 'primitive handler becomes null');+ }+ order.length = 0;+ descriptor.set.call(nativeProxy, () => order.push('last'));+ assert(target.dispatchEvent(new Event('resize')) && order.join() === 'before,after,last', 'cleared handler is appended when set again');+ assert(event.currentTarget === null && target.width === 0 && target.height === 0, 'dispatch does not open a window');+ return true;+ })()"#).unwrap(), "true");+}++#[test]+fn picture_in_picture_native_event_proxies_read_the_original_private_payload() {+ let mut vm =+ new_storage_page_task_executor_test_vm("https://picture-in-picture-event-proxy.test/");+ install_closed_window(&mut vm);+ vm.eval("globalThis.nativeEvent = new PictureInPictureEvent('enterpictureinpicture', {pictureInPictureWindow:nativeWindow})").unwrap();+ let context_ptr = &vm.page_default_runtime.context as *const _;+ vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {+ let global = scope.get_current_context().global(scope);+ let key = crate::util::v8str(scope, "nativeEvent");+ let event =+ v8::Local::<v8::Object>::try_from(global.get(scope, key.into()).unwrap()).unwrap();+ let handler = crate::util::new_null_prototype_object(scope);+ let proxy = v8::Proxy::new(scope, event, handler).unwrap();+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();+ let key = crate::util::v8str(scope, "eventProxy");+ assert_eq!(+ global.create_data_property(scope, key.into(), proxy.into()),+ Some(true)+ );+ Ok(())+ })+ .unwrap();+ assert_eq!(vm.eval(r#"(() => {+ const get = Object.getOwnPropertyDescriptor(PictureInPictureEvent.prototype, 'pictureInPictureWindow').get;+ if (get.call(eventProxy) !== nativeWindow) throw Error('native event Proxy payload');+ let error; try {get.call(new Proxy(eventProxy, {}))} catch(caught) {error=caught}+ if (!(error instanceof TypeError)) throw Error('author event Proxy accepted');+ return true;+ })()"#).unwrap(), "true");+}diff --git a/moli-renderer-v8/src/web_api_interfaces.rs b/moli-renderer-v8/src/web_api_interfaces.rsindex d8245aeac..d04e5b252 100644--- a/moli-renderer-v8/src/web_api_interfaces.rs+++ b/moli-renderer-v8/src/web_api_interfaces.rs@@ -192,6 +192,8 @@ interfaces! {Gamepad;GamepadButton;GamepadEvent: Event;+ PictureInPictureEvent: Event;+ PictureInPictureWindow: EventTarget;GamepadHapticActuator;HTMLAllCollection;HTMLAnchorElement: HTMLElement;