diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index a2327334739..82a6fc27388 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -52,6 +52,7 @@ pub(crate) use picture_in_picture_tests::closed_window_for_test as closed_pictur mod media_metadata; mod media_recorder; mod media_streams; +pub(crate) mod remote_playback; #[cfg(test)] pub(crate) use media_streams::inert_track_for_test; mod video_color_space; diff --git a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs index 398ce9b52c6..edbe010aa39 100644 --- a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs +++ b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs @@ -40,6 +40,7 @@ use super::super::{ opfs::install_opfs_constructor_template_bindings, performance_runtime::install_performance_template_bindings, range_surface::install_range_template_bindings, + remote_playback::install as install_remote_playback_template_bindings, selection_surface::install_selection_template_bindings, shared::{ install_abort_template_bindings, install_attr_template_bindings, @@ -421,6 +422,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()); + install_remote_playback_template_bindings(scope, template, spec.interface.name()); super::super::picture_in_picture::install(scope, template, spec.interface.name()); super::super::media_streams::install(scope, template, spec.interface.name()); super::super::media_recorder::install(scope, template, spec.interface.name()); diff --git a/moli-renderer-v8/src/context_bootstrap/remote_playback.rs b/moli-renderer-v8/src/context_bootstrap/remote_playback.rs new file mode 100644 index 00000000000..dfd54e54d96 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/remote_playback.rs @@ -0,0 +1,330 @@ +//! Remote Playback frontend for a UA without device discovery or a connection +//! backend. The specification's lifetime-unavailable branch resolves a watch +//! without an id, then queues one false availability notification. + +use super::{media_queries, shared}; +use crate::{ + document_runtime::DomHandle, + host::report_event_callback_exception, + native_bridge::{ + PageScriptHost, document::document_is_fully_active, + node_runtime_and_handle_from_object_or_detached, throw_dom_exception, + }, + util::{get_private_object, get_private_value, set_private_value, v8str}, + web_api_interfaces, webidl, + window_webidl_callback::{ + WindowWebIdlCallbackFunction, WindowWebIdlCallbackFunctionOutcome, + invoke_window_webidl_callback_function, + }, +}; +use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject}; + +const ASSOCIATED: &str = "__moliMediaRemotePlayback"; +const MEDIA: &str = "__moliRemotePlaybackMedia"; +const LISTENERS: &str = "__moliRemotePlaybackListeners"; + +#[derive(WebApiObject)] +#[webapi(interface = web_api_interfaces::RemotePlayback, require_prototype)] +struct RemotePlaybackObject<'s> { + #[webapi(slot = MEDIA)] + media: v8::Local<'s, v8::Object>, + #[webapi(slot = shared::SIMPLE_EVENT_TARGET_SLOT, value = LISTENERS)] + event_target: (), + #[webapi(slot = shared::SIMPLE_EVENT_TARGET_ORDERED_HANDLERS_SLOT, init = true)] + ordered_handlers: (), +} + +#[derive(WebApiFunctionTemplate)] +#[webapi(interface = web_api_interfaces::RemotePlayback, enumerable)] +struct RemotePlaybackPrototype { + #[webapi(method, returns_promise, length = 1, callback = watch_availability)] + watch_availability: (), + #[webapi(method, returns_promise, length = 0, callback = cancel_watch_availability)] + cancel_watch_availability: (), + #[webapi(method, returns_promise, length = 0, callback = prompt)] + prompt: (), + #[webapi(accessor_property, getter = state)] + state: (), + #[webapi(accessor_property, getter = handler_getter, setter = handler_setter, data = v8str(scope, "connecting"))] + onconnecting: (), + #[webapi(accessor_property, getter = handler_getter, setter = handler_setter, data = v8str(scope, "connect"))] + onconnect: (), + #[webapi(accessor_property, getter = handler_getter, setter = handler_setter, data = v8str(scope, "disconnect"))] + ondisconnect: (), +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "RemotePlayback.watchAvailability")] +struct WatchArgs { + #[webidl(required, converter = "callback_function")] + callback: webidl::WebIdlCallbackFunction, +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "RemotePlayback.cancelWatchAvailability")] +struct CancelArgs { + #[webidl(converter = "long")] + id: Option, +} + +pub(super) fn install<'s>( + scope: &mut v8::PinScope<'s, '_, ()>, + template: v8::Local<'s, v8::FunctionTemplate>, + name: &str, +) { + if name == "RemotePlayback" { + RemotePlaybackPrototype::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("RemotePlayback receiver was validated") +} + +pub(crate) fn media_remote_getter<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let media = target(scope, args.this()); + if let Some(remote) = get_private_object(scope, media, ASSOCIATED) { + rv.set(remote.into()); + return; + } + let context = media + .get_creation_context(scope) + .expect("native media element has a creation realm"); + let scope = &mut v8::ContextScope::new(scope, context); + let remote = RemotePlaybackObject::new(media) + .bind(scope) + .expect("native RemotePlayback object should bind"); + set_private_value(scope, media, ASSOCIATED, remote.into()); + rv.set(remote.into()); +} + +fn media_owner<'s>( + scope: &mut v8::PinScope<'s, '_>, + receiver: v8::Local<'s, v8::Object>, +) -> Option<(*mut PageScriptHost, DomHandle)> { + let remote = target(scope, receiver); + let media = get_private_object(scope, remote, MEDIA) + .expect("RemotePlayback retains its native media element"); + node_runtime_and_handle_from_object_or_detached(scope, media).ok() +} + +fn enabled_media_owner<'s>( + scope: &mut v8::PinScope<'s, '_>, + receiver: v8::Local<'s, v8::Object>, +) -> Option<(*mut PageScriptHost, DomHandle)> { + let Some((host_ptr, media)) = media_owner(scope, receiver) else { + throw_dom_exception( + scope, + "InvalidStateError", + 11, + "The media element is no longer available.", + ); + return None; + }; + if unsafe { &*host_ptr } + .dom_host() + .node(media) + .and_then(|node| node.as_element()) + .is_some_and(|element| element.has_attribute("disableremoteplayback")) + { + throw_dom_exception( + scope, + "InvalidStateError", + 11, + "Remote playback is disabled for this media element.", + ); + return None; + } + Some((host_ptr, media)) +} + +fn resolved_undefined<'s>(scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Promise> { + let resolver = v8::PromiseResolver::new(scope).expect("RemotePlayback promise should allocate"); + resolver.resolve(scope, v8::undefined(scope).into()); + resolver.get_promise(scope) +} + +fn watch_availability<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + let Some((host_ptr, media)) = enabled_media_owner(scope, args.this()) else { + return; + }; + let host = unsafe { &mut *host_ptr }; + let callback = RemotePlaybackAvailabilityTask { + callback: WindowWebIdlCallbackFunction::new(scope, host, parsed.callback), + }; + // The lifetime-unavailable algorithm does not register a callback or + // allocate an id. Exact Window/Document admission handles retired owners. + host.queue_remote_playback_availability(scope, media, callback); + rv.set(resolved_undefined(scope).into()); +} + +fn cancel_watch_availability<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + if enabled_media_owner(scope, args.this()).is_none() { + return; + } + // There are no registered monitors in the lifetime-unavailable branch. + if parsed.id.is_some() { + throw_dom_exception( + scope, + "NotFoundError", + 8, + "No availability callback has this id.", + ); + return; + } + rv.set(resolved_undefined(scope).into()); +} + +fn prompt<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some((host_ptr, media)) = enabled_media_owner(scope, args.this()) else { + return; + }; + let host = unsafe { &*host_ptr }; + let active_owner = host.owner_dispatch_scope_for_node(media).filter(|_| { + host.dom_host() + .node(media) + .and_then(|node| node.owner_document()) + .is_some_and(|document| document_is_fully_active(host, document)) + }); + if active_owner.is_none_or(|owner| { + !host.window_has_transient_user_activation(owner) + && !host.protocol_user_gesture_activation() + }) { + throw_dom_exception( + scope, + "InvalidAccessError", + 15, + "Remote playback requires an active window with transient user activation.", + ); + return; + } + throw_dom_exception( + scope, + "NotSupportedError", + 9, + "Remote playback connections are unavailable on this platform.", + ); +} + +fn state<'s>( + scope: &mut v8::PinScope<'s, '_>, + _args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + rv.set(v8str(scope, "disconnected").into()); +} + +fn handler_getter<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let remote = target(scope, args.this()); + let event = args.data().to_rust_string_lossy(scope); + rv.set( + get_private_value(scope, remote, handler_slot(&event)) + .unwrap_or_else(|| v8::null(scope).into()), + ); +} + +fn handler_setter<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let remote = target(scope, args.this()); + let event = args.data().to_rust_string_lossy(scope); + let slot = handler_slot(&event); + let active = args.get(0).is_object(); + let handler = if active { + args.get(0) + } else { + v8::null(scope).into() + }; + set_private_value(scope, remote, slot, handler); + media_queries::simple_object_event_set_ordered_handler( + scope, remote, LISTENERS, &event, slot, active, + ); +} + +fn handler_slot(event: &str) -> &'static str { + match event { + "connecting" => "__moliRemotePlaybackOnconnecting", + "connect" => "__moliRemotePlaybackOnconnect", + "disconnect" => "__moliRemotePlaybackOndisconnect", + _ => unreachable!("RemotePlayback handler callback data"), + } +} + +/// One initial unavailable notification, on the media element event task +/// source. Callback realm/incumbent context and retired-realm checks use the +/// shared Web IDL callback infrastructure. +pub(crate) struct RemotePlaybackAvailabilityTask { + callback: WindowWebIdlCallbackFunction, +} + +impl RemotePlaybackAvailabilityTask { + pub(crate) fn invoke( + &self, + scope: &mut v8::PinScope<'_, '_>, + host_ptr: *mut PageScriptHost, + ) -> bool { + let callback = self.callback.prepare(scope); + let relevant_identity = callback.relevant_identity(); + let receiver = v8::undefined(scope).into(); + let available = v8::Boolean::new(scope, false).into(); + match invoke_window_webidl_callback_function( + scope, + host_ptr, + "RemotePlaybackAvailabilityCallback", + "RemotePlayback availability callback threw", + "RemotePlayback availability callback", + &callback, + receiver, + &[available], + ) { + WindowWebIdlCallbackFunctionOutcome::Returned => true, + WindowWebIdlCallbackFunctionOutcome::Threw(report) => { + report_event_callback_exception( + scope, + host_ptr, + "remoteplayback", + relevant_identity, + None, + &report, + ); + true + } + WindowWebIdlCallbackFunctionOutcome::Retired => false, + } + } +} diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs b/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs index cabc56afc1c..2212d58d5f4 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs @@ -27,6 +27,9 @@ pub(super) enum PendingMediaElementEventPayload { track: v8::Global, event_type: String, }, + RemotePlaybackAvailability( + crate::context_bootstrap::remote_playback::RemotePlaybackAvailabilityTask, + ), } pub(super) type MediaElementEventState = ExactWindowDocumentTaskLedger< @@ -49,6 +52,20 @@ impl PageScriptHost { ) } + pub(crate) fn queue_remote_playback_availability( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + callback: crate::context_bootstrap::remote_playback::RemotePlaybackAvailabilityTask, + ) -> bool { + self.queue_media_element_event_for_node( + scope, + media, + RendererPageMediaElementEventTaskKind::RemotePlaybackAvailability, + PendingMediaElementEventPayload::RemotePlaybackAvailability(callback), + ) + } + pub(crate) fn queue_media_seeking_event( &mut self, scope: &mut v8::PinScope<'_, '_>, @@ -203,6 +220,9 @@ impl PageScriptHost { media_handle, ) } + PendingMediaElementEventPayload::RemotePlaybackAvailability(callback) => { + callback.invoke(scope, host_ptr) + } PendingMediaElementEventPayload::Seeking { media_handle } => { crate::native_bridge::element::dispatch_media_seeking_event( scope, @@ -277,6 +297,7 @@ impl PageScriptHost { } PendingMediaElementEventPayload::VolumeChange { .. } | PendingMediaElementEventPayload::Seeking { .. } + | PendingMediaElementEventPayload::RemotePlaybackAvailability(_) | PendingMediaElementEventPayload::SeekCompletion { .. } | PendingMediaElementEventPayload::TextTrackListEvent { .. } => {} } diff --git a/moli-renderer-v8/src/native_bridge/element/media.rs b/moli-renderer-v8/src/native_bridge/element/media.rs index 4aba4101ddc..0bf8a93dd9e 100644 --- a/moli-renderer-v8/src/native_bridge/element/media.rs +++ b/moli-renderer-v8/src/native_bridge/element/media.rs @@ -5,6 +5,10 @@ mod text_tracks; mod time_ranges; mod video; +pub(super) use attributes::{ + media_disable_remote_playback_getter, media_disable_remote_playback_setter, +}; + pub(crate) use attributes::{ MediaLoadEventPhase, dispatch_media_load_event_phase, queue_media_canplay_after_text_tracks, queue_media_load_if_needed, queue_media_load_if_source_or_loading_change, diff --git a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs index aca4c8894b2..8c9d80b830e 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs @@ -1,4 +1,5 @@ use super::super::geometry::read_bounding_client_rect; +use super::super::reflection::element_reflection_receiver_or_throw; use super::super::{ canonical_cross_origin_value, canonical_loading_value, canonical_preload_value, construct_simple_event, dispatch_public_event, has_reflected_attribute, @@ -16,6 +17,40 @@ use crate::native_bridge::{ use crate::util::v8_string; use anyhow::Context; +pub(in crate::native_bridge::element) fn media_disable_remote_playback_getter<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'s, v8::Value>, +) { + let Some((runtime_ptr, handle)) = element_reflection_receiver_or_throw(scope, args.this()) + else { + return; + }; + rv.set_bool(has_reflected_attribute( + unsafe { &*runtime_ptr }, + handle, + "disableremoteplayback", + )); +} + +pub(in crate::native_bridge::element) fn media_disable_remote_playback_setter<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'s, v8::Value>, +) { + let Some((runtime_ptr, handle)) = element_reflection_receiver_or_throw(scope, args.this()) + else { + return; + }; + set_reflected_boolean_attribute( + scope, + runtime_ptr, + handle, + "disableremoteplayback", + args.get(0).boolean_value(scope), + ); +} + pub(in crate::native_bridge) fn media_autoplay_getter_function<'s>( scope: &mut v8::PinScope<'s, '_>, args: v8::FunctionCallbackArguments<'s>, diff --git a/moli-renderer-v8/src/native_bridge/element/media_elements.rs b/moli-renderer-v8/src/native_bridge/element/media_elements.rs index 48bf9c7c164..181f2d28af6 100644 --- a/moli-renderer-v8/src/native_bridge/element/media_elements.rs +++ b/moli-renderer-v8/src/native_bridge/element/media_elements.rs @@ -15,6 +15,10 @@ pub(super) struct HtmlHtmlElementPrototypeDeclaration { #[derive(WebApiFunctionTemplate)] #[webapi(interface = web_api_interfaces::HTMLMediaElement, enumerable)] pub(super) struct HtmlMediaElementPrototypeDeclaration { + #[webapi(accessor_property, getter = crate::context_bootstrap::remote_playback::media_remote_getter)] + remote: (), + #[webapi(accessor_property, getter = media::media_disable_remote_playback_getter, setter = media::media_disable_remote_playback_setter)] + disable_remote_playback: (), #[webapi(accessor_property, getter = media_buffered_getter_function)] buffered: (), #[webapi(accessor_property, getter = media_played_getter_function)] diff --git a/moli-renderer-v8/src/page_task_queue/media_element_event.rs b/moli-renderer-v8/src/page_task_queue/media_element_event.rs index 98f22a863f9..3123f06ac8d 100644 --- a/moli-renderer-v8/src/page_task_queue/media_element_event.rs +++ b/moli-renderer-v8/src/page_task_queue/media_element_event.rs @@ -31,6 +31,7 @@ pub(crate) enum RendererPageMediaElementEventTaskKind { SeekCompletion, LoadEventPhase, TextTrackListEvent, + RemotePlaybackAvailability, } pub(crate) type RendererPageMediaElementEventOwner = RendererPageWindowDocumentTaskOwner; diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 62082412c19..4cedfd42053 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -2462,6 +2462,7 @@ mod svg_gradient_native_receivers; mod readable_algorithm_arrays; mod remote_playback_interface; +mod remote_playback_members; mod rendering_observers; mod rendering_update; mod rtc_configuration; diff --git a/moli-renderer-v8/src/script_vm/tests/remote_playback_members.js b/moli-renderer-v8/src/script_vm/tests/remote_playback_members.js new file mode 100644 index 00000000000..ce0c2cb728f --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/remote_playback_members.js @@ -0,0 +1,164 @@ +(async () => { + const checks = [], watches = []; + async function check(name, action) { + try { checks.push({name, passed: (await action()) === true}); } + catch (error) { checks.push({name, passed: false, error: String(error)}); } + } + const caught = action => {try {action(); return null;} catch (error) {return error;}}; + const rejected = async action => {try {await action(); return null;} catch (error) {return error;}}; + const frame = document.createElement('iframe'); document.body.appendChild(frame); + const popup = window.open('about:blank', '_blank'); + try { + for (const [realm, owner] of [window, frame.contentWindow, popup].entries()) { + const C = owner.RemotePlayback, P = C.prototype, M = owner.HTMLMediaElement.prototype; + const typeError = error => error !== null && Object.getPrototypeOf(error) === owner.TypeError.prototype; + const domError = (error, name) => error?.name === name && Object.getPrototypeOf(error) === owner.DOMException.prototype; + const media = owner.document.createElement('video'); + const remoteDescriptor = Object.getOwnPropertyDescriptor(M, 'remote'); + let remote; + await check(`${realm}/associated native object`, () => { + remote = remoteDescriptor.get.call(media); + return remote instanceof C && remote instanceof owner.EventTarget && Object.getPrototypeOf(remote) === P && + remote === remoteDescriptor.get.call(media) && remote !== owner.document.createElement('audio').remote; + }); + await check(`${realm}/constructor inheritance and descriptors`, () => C.name === 'RemotePlayback' && C.length === 0 && + Object.getPrototypeOf(C) === owner.EventTarget && Object.getPrototypeOf(P) === owner.EventTarget.prototype && + Object.getOwnPropertyDescriptor(P, Symbol.toStringTag).value === 'RemotePlayback'); + for (const construct of [false, true]) { + await check(`${realm}/illegal constructor/${construct}`, () => typeError(caught(() => construct ? new C() : C()))); + } + let traps = 0; + const author = new Proxy(remote ?? {}, {get() {traps++; throw Error('get');}, getPrototypeOf() {traps++; throw Error('prototype');}}); + const revoked = Proxy.revocable(remote ?? {}, {}); revoked.revoke(); + const invalid = [undefined, null, {}, P, Object.create(P), Object.create(remote ?? {}), author, revoked.proxy, + new owner.EventTarget(), media]; + for (const name of ['state', 'onconnecting', 'onconnect', 'ondisconnect']) { + const d = Object.getOwnPropertyDescriptor(P, name), setter = name !== 'state'; + await check(`${realm}/${name}/descriptor`, () => d?.enumerable === true && d.configurable && typeof d.get === 'function' && d.get.length === 0 && + (setter ? typeof d.set === 'function' && d.set.length === 1 : d.set === undefined)); + for (const [index, value] of invalid.entries()) { + await check(`${realm}/${name}/getter receiver ${index}`, () => typeError(caught(() => d.get.call(value)))); + if (setter) await check(`${realm}/${name}/setter receiver ${index}`, () => typeError(caught(() => d.set.call(value, () => {})))); + } + } + for (const [name, length] of [['watchAvailability', 1], ['cancelWatchAvailability', 0], ['prompt', 0]]) { + const d = Object.getOwnPropertyDescriptor(P, name); + await check(`${realm}/${name}/descriptor`, () => d?.writable === true && d.enumerable && d.configurable && + typeof d.value === 'function' && d.value.length === length && d.value.name === name); + for (const [index, value] of invalid.entries()) { + await check(`${realm}/${name}/Promise receiver ${index}`, async () => { + let conversions = 0, promise; + const arg = name === 'watchAvailability' ? () => {} : {valueOf() {conversions++; throw Error('conversion');}}; + const synchronous = caught(() => {promise = d.value.call(value, arg);}); + return synchronous === null && promise instanceof owner.Promise && typeError(await rejected(() => promise)) && conversions === 0; + }); + } + } + for (const [name, setter] of [['remote', false], ['disableRemotePlayback', true]]) { + const d = Object.getOwnPropertyDescriptor(M, name); + await check(`${realm}/media/${name}/descriptor`, () => d?.enumerable === true && d.configurable && d.get.length === 0 && + (setter ? typeof d.set === 'function' && d.set.length === 1 : d.set === undefined)); + const badMedia = [undefined, null, {}, M, Object.create(M), Object.create(media), + new Proxy(media, {}), revoked.proxy, owner.document.createElement('div')]; + for (const [index, value] of badMedia.entries()) { + await check(`${realm}/media/${name}/getter receiver ${index}`, () => typeError(caught(() => d.get.call(value)))); + if (setter) await check(`${realm}/media/${name}/setter receiver ${index}`, () => typeError(caught(() => d.set.call(value, {})))); + } + } + await check(`${realm}/native disabled state ignores public expandos`, async () => { + media.setAttribute('disableremoteplayback', ''); + Object.defineProperty(media, 'disableRemotePlayback', {value: false, configurable: true}); + const error = await rejected(() => P.prompt.call(remote)); + delete media.disableRemotePlayback; media.removeAttribute('disableremoteplayback'); + return domError(error, 'InvalidStateError'); + }); + const disabled = Object.getOwnPropertyDescriptor(M, 'disableRemotePlayback'); + for (const [index, value] of [undefined, null, false, true, 0, 1, '', 'false', {}, Symbol('flag'), 0n, 1n].entries()) { + await check(`${realm}/boolean reflection/${index}`, () => { + disabled.set.call(media, value); + return disabled.get.call(media) === Boolean(value) && media.hasAttribute('disableremoteplayback') === Boolean(value); + }); + } + await check(`${realm}/boolean reflection does not coerce objects`, () => { + let conversions = 0; + disabled.set.call(media, {valueOf() {conversions++; throw Error('valueOf');}, toString() {conversions++; throw Error('toString');}}); + return disabled.get.call(media) && conversions === 0; + }); + for (const [index, callback] of [undefined, null, false, 1, 'x', 1n, Symbol('callback'), {}, {handleEvent() {}}].entries()) { + await check(`${realm}/callback conversion before disabled check/${index}`, async () => + typeError(await rejected(() => P.watchAvailability.call(remote, callback)))); + } + await check(`${realm}/required callback is a rejected Promise`, async () => typeError(await rejected(() => P.watchAvailability.call(remote)))); + await check(`${realm}/disabled watch`, async () => domError(await rejected(() => P.watchAvailability.call(remote, () => {})), 'InvalidStateError')); + for (const id of [undefined, 0, 1]) { + await check(`${realm}/disabled cancel/${id}`, async () => domError(await rejected(() => P.cancelWatchAvailability.call(remote, id)), 'InvalidStateError')); + } + await check(`${realm}/conversion exception identity before disabled cancel`, async () => { + const marker = {}, log = []; + const error = await rejected(() => P.cancelWatchAvailability.call(remote, {valueOf() {log.push('valueOf'); throw marker;}})); + return error === marker && log.join() === 'valueOf'; + }); + for (const id of [Symbol('id'), 1n]) { + await check(`${realm}/invalid long before disabled cancel/${typeof id}`, async () => typeError(await rejected(() => P.cancelWatchAvailability.call(remote, id)))); + } + await check(`${realm}/disabled prompt`, async () => domError(await rejected(() => P.prompt.call(remote)), 'InvalidStateError')); + if (disabled) disabled.set.call(media, false); + for (const id of [null, 0, -1, 1, 2**32 + 1, NaN, Infinity, -Infinity, '1']) { + await check(`${realm}/unknown callback id/${String(id)}`, async () => domError(await rejected(() => P.cancelWatchAvailability.call(remote, id)), 'NotFoundError')); + } + await check(`${realm}/cancel omitted and undefined`, async () => await P.cancelWatchAvailability.call(remote) === undefined && + await P.cancelWatchAvailability.call(remote, undefined) === undefined); + await check(`${realm}/long conversion occurs once`, async () => { + let count = 0; + const error = await rejected(() => P.cancelWatchAvailability.call(remote, {valueOf() {count++; return 1;}})); + return count === 1 && domError(error, 'NotFoundError'); + }); + await check(`${realm}/initial disconnected state`, () => remote.state === 'disconnected'); + for (const eventType of ['connecting', 'connect', 'disconnect']) { + await check(`${realm}/ordered EventHandler/${eventType}`, () => { + const target = remote, log = [], before = () => log.push('before'), after = () => log.push('after'); + const name = 'on' + eventType; + target.addEventListener(eventType, before); + target[name] = () => log.push('old'); + target.addEventListener(eventType, after); + target[name] = function(event) {log.push(this === target && event.currentTarget === target ? 'handler' : 'wrong'); return false;}; + const event = new owner.Event(eventType, {cancelable:true}); + const result = !target.dispatchEvent(event) && event.defaultPrevented && log.join() === 'before,handler,after'; + target[name] = null; target.removeEventListener(eventType, before); target.removeEventListener(eventType, after); + return result && target.state === 'disconnected'; + }); + for (const [index, value] of [undefined, null, false, 1, 'x', 1n, Symbol('handler')].entries()) { + await check(`${realm}/handler primitive/${eventType}/${index}`, () => {remote['on'+eventType] = value; return remote['on'+eventType] === null;}); + } + } + await check(`${realm}/availability resolves before one boolean callback`, async () => { + const log = []; + let count = 0, thisValue, resolveCallback; + const callback = new Promise(resolve => {resolveCallback = resolve;}); + const pending = P.watchAvailability.call(remote, function(available) {'use strict'; count++; thisValue = this; log.push('callback'); resolveCallback(available);}); + const value = await pending.then(value => {log.push('resolved'); return value;}); + const available = await callback; + watches.push({realm, resolvedType:typeof value, resolvedValue:value ?? null, available, count, order:log, + undefinedThis:thisValue === undefined, remoteThis:thisValue === remote}); + // The lifetime-unavailable branch has no id; monitoring-capable UAs + // instead return a positive id. Original WPT id checks stay separate. + return (value === undefined || Number.isInteger(value) && value > 0) && available === false && count === 1 && + thisValue === undefined && log.join() === 'resolved,callback'; + }); + await check(`${realm}/borrowed media getter keeps owner realm`, () => { + const foreign = window.document.createElement('audio'); + const result = remoteDescriptor.get.call(foreign); + return result instanceof window.RemotePlayback && result === foreign.remote && (owner === window || !(result instanceof C)); + }); + await check(`${realm}/author and revoked Proxy checks execute no traps`, () => traps === 0); + await check(`${realm}/public constructor replacement preserves native source`, () => { + const original = owner.RemotePlayback; + try {owner.RemotePlayback = function() {throw Error('author constructor');}; return owner.document.createElement('audio').remote instanceof original;} + finally {owner.RemotePlayback = original;} + }); + } + } finally {popup.close(); frame.remove();} + const facts = {complete:true, total:checks.length, passed:checks.filter(row => row.passed).length, checks, watches}; + globalThis.__uiEventResults = facts; + return facts.passed === facts.total; +})() diff --git a/moli-renderer-v8/src/script_vm/tests/remote_playback_members.rs b/moli-renderer-v8/src/script_vm/tests/remote_playback_members.rs new file mode 100644 index 00000000000..36f008db0a6 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/remote_playback_members.rs @@ -0,0 +1,112 @@ +use super::*; + +#[tokio::test] +async fn remote_playback_members_preserve_receivers_realms_and_unavailable_callback_order() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = + new_storage_page_task_executor_test_vm_with_loader("https://remote-members.test/", &loader); + vm.eval(include_str!("remote_playback_members.js")).unwrap(); + for realm in ["main", "iframe", "popup"] { + run_next_page_media_element_event_for_test(&mut vm, &loader, realm).await; + } + assert_eq!(vm.eval("__uiEventResults.complete").unwrap(), "true"); + assert_eq!( + vm.eval("JSON.stringify(__uiEventResults.checks.filter(row => !row.passed))") + .unwrap(), + "[]" + ); + assert_eq!(vm.eval("__uiEventResults.watches.every(row => row.resolvedType === 'undefined' && row.available === false && row.count === 1)").unwrap(), "true"); +} + +#[test] +fn remote_playback_registered_native_proxies_share_media_and_handler_identity() { + let mut vm = new_storage_page_task_executor_test_vm("https://remote-native-proxy.test/"); + vm.eval("globalThis.media = document.createElement('video'); globalThis.remote = media.remote") + .unwrap(); + let context_ptr = &vm.current_main_world().unwrap().context as *const _; + vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| { + let global = scope.get_current_context().global(scope); + for (original, alias) in [("media", "mediaProxy"), ("remote", "remoteProxy")] { + let key = crate::util::v8str(scope, original); + let object = + v8::Local::::try_from(global.get(scope, key.into()).unwrap()).unwrap(); + let handler = crate::util::new_null_prototype_object(scope); + let proxy = v8::Proxy::new(scope, object, handler).unwrap(); + moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap(); + let key = crate::util::v8str(scope, alias); + assert_eq!( + global.create_data_property(scope, key.into(), proxy.into()), + Some(true) + ); + } + Ok(()) + }) + .unwrap(); + assert_eq!(vm.eval(r#"(() => { + const assert = (ok, name) => {if (!ok) throw Error(name)}; + assert(mediaProxy.remote === remote && remoteProxy.state === 'disconnected', 'native identity'); + mediaProxy.disableRemotePlayback = true; + assert(media.hasAttribute('disableremoteplayback') && mediaProxy.disableRemotePlayback, 'native proxy boolean reflection'); + const log = []; + remote.addEventListener('connect', () => log.push('before')); + remoteProxy.onconnect = () => log.push('original'); + remote.addEventListener('connect', () => log.push('after')); + remoteProxy.onconnect = () => {log.push('replacement'); return false}; + assert(remote.onconnect === remoteProxy.onconnect, 'handler native identity'); + assert(!remote.dispatchEvent(new Event('connect', {cancelable:true})), 'EventHandler cancellation'); + assert(log.join() === 'before,replacement,after' && remote.state === 'disconnected', 'ordered handler without a connection'); + Object.setPrototypeOf(remote, null); + assert(Object.getOwnPropertyDescriptor(RemotePlayback.prototype, 'state').get.call(remoteProxy) === 'disconnected', 'brand survives prototype replacement'); + let error; try {Object.getOwnPropertyDescriptor(RemotePlayback.prototype, 'state').get.call(new Proxy(remoteProxy, {}))} catch (caught) {error=caught} + assert(error instanceof TypeError, 'author wrapping native Proxy is rejected'); + return true; + })()"#).unwrap(), "true"); +} + +#[tokio::test] +async fn remote_playback_callback_exceptions_do_not_reject_watches_or_stop_media_tasks() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = + new_storage_page_task_executor_test_vm_with_loader("https://remote-errors.test/", &loader); + vm.eval(r#" + globalThis.order = []; globalThis.errors = 0; + window.onerror = () => {errors++; return true}; + const remote = document.createElement('video').remote; + remote.watchAvailability(() => {order.push('throwing'); throw Error('availability callback')}).then(value => order.push(String(value))); + remote.watchAvailability(available => order.push(String(available))).then(() => order.push('resolved')); + "#).unwrap(); + assert_eq!(vm.eval("order.join()").unwrap(), "undefined,resolved"); + for _ in 0..2 { + run_next_page_media_element_event_for_test(&mut vm, &loader, "availability notification") + .await; + } + assert_eq!( + vm.eval("order.join()").unwrap(), + "undefined,resolved,throwing,false" + ); + assert_eq!(vm.eval("errors").unwrap(), "1"); +} + +#[tokio::test] +async fn remote_playback_retired_iframe_discards_callbacks_and_rejects_prompt() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut vm = new_storage_page_task_executor_test_vm_with_loader( + "https://remote-retirement.test/", + &loader, + ); + vm.eval(r#" + globalThis.called = 0; globalThis.promptResult = ''; + const frame = document.createElement('iframe'); document.body.appendChild(frame); + const other = frame.contentWindow; + const media = other.document.createElement('video'); other.document.body.appendChild(media); + const remote = media.remote; + remote.watchAvailability(() => {called++}); + frame.remove(); + remote.prompt().catch(error => {promptResult = error.name + ':' + (error instanceof other.DOMException)}); + "#).unwrap(); + vm.run_one_media_element_event_executor_turn(&loader) + .await + .unwrap(); + assert_eq!(vm.eval("called").unwrap(), "0"); + assert_eq!(vm.eval("promptResult").unwrap(), "InvalidAccessError:true"); +}