diff --git a/moli-renderer-v8/src/document_runtime/dom_facade.rs b/moli-renderer-v8/src/document_runtime/dom_facade.rs index 1c81ab51b77..0d918ed8af4 100644 --- a/moli-renderer-v8/src/document_runtime/dom_facade.rs +++ b/moli-renderer-v8/src/document_runtime/dom_facade.rs @@ -751,7 +751,7 @@ impl DocumentRuntime { &plan.custom_elements().registry_retargets, ); if previous_owner_document != new_document { - self.queue_image_loads_after_owner_document_change(scope, host_ptr, root); + self.queue_resource_loads_after_owner_document_change(scope, host_ptr, root); } custom_elements::enqueue_adopted_callbacks( scope, @@ -786,7 +786,7 @@ impl DocumentRuntime { runtime.note_style_subtree_context_change(handle); } - fn queue_image_loads_after_owner_document_change( + fn queue_resource_loads_after_owner_document_change( &self, scope: &mut v8::PinScope<'_, '_>, host_ptr: *mut PageScriptHost, @@ -794,6 +794,7 @@ impl DocumentRuntime { ) { let mut stack = vec![root]; let mut images = Vec::new(); + let mut media = Vec::new(); while let Some(handle) = stack.pop() { if self .dom_host @@ -802,6 +803,10 @@ impl DocumentRuntime { .is_some_and(|element| element.is_image_resource_element()) { images.push(handle); + } else if self.dom_host.is_html_element_named(handle, "audio") + || self.dom_host.is_html_element_named(handle, "video") + { + media.push(handle); } if let Some(shadow_root) = self.dom_host.shadow_root_handle(handle) { stack.push(shadow_root); @@ -817,6 +822,9 @@ impl DocumentRuntime { scope, host_ptr, image, ); } + for handle in media { + crate::native_bridge::element::queue_media_load_if_needed(scope, host_ptr, handle); + } } pub(crate) fn get_element_by_id(&self, id: &str) -> Option { diff --git a/moli-renderer-v8/src/document_runtime/mutation_commands/tree/resources.rs b/moli-renderer-v8/src/document_runtime/mutation_commands/tree/resources.rs index 6570ed93629..c9e4888f98d 100644 --- a/moli-renderer-v8/src/document_runtime/mutation_commands/tree/resources.rs +++ b/moli-renderer-v8/src/document_runtime/mutation_commands/tree/resources.rs @@ -348,6 +348,10 @@ impl DocumentRuntime { crate::native_bridge::element::queue_media_canplay_after_text_tracks( scope, host_ptr, followup, ); + } else if self.dom_host.is_html_element_named(handle, "audio") + || self.dom_host.is_html_element_named(handle, "video") + { + unsafe { &mut *host_ptr }.schedule_media_pause_if_removed(scope, handle); } } diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs index c5f786f825d..13387b7004f 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/core.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs @@ -550,6 +550,7 @@ impl PageScriptHost { view_transition_updates: super::view_transition_updates::ViewTransitionUpdateState::default(), media_element_events: super::media_element_events::MediaElementEventState::default(), + media_playback: super::media_playback::MediaPlaybackState::default(), webrtc_tasks: super::webrtc_tasks::WebRtcTaskState::default(), element_toggle_events: super::element_toggle_events::ElementToggleEventState::default(), form_navigations: super::form_navigations::FormNavigationState::default(), 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 2212d58d5f4..2419d44c50c 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 @@ -10,6 +10,7 @@ pub(super) enum PendingMediaElementEventPayload { VolumeChange { media_handle: DomHandle, }, + Playback(super::media_playback::MediaPlaybackTask), Seeking { media_handle: DomHandle, }, @@ -135,7 +136,7 @@ impl PageScriptHost { ) } - fn queue_media_element_event_for_node( + pub(super) fn queue_media_element_event_for_node( &mut self, scope: &mut v8::PinScope<'_, '_>, node: DomHandle, @@ -146,6 +147,15 @@ impl PageScriptHost { self.retire_media_element_event_payload(payload); return false; }; + self.queue_media_element_event_for_target(target, kind, payload) + } + + pub(super) fn queue_media_element_event_for_target( + &mut self, + target: WindowDocumentTaskTarget, + kind: RendererPageMediaElementEventTaskKind, + payload: PendingMediaElementEventPayload, + ) -> bool { let task_id = self .media_element_events .allocate_task_id(RendererPageMediaElementEventTaskId::from_raw); @@ -184,6 +194,11 @@ impl PageScriptHost { RendererPageMediaElementEventTaskKind, )> { let pending = self.media_element_events.pending(task_id)?; + if let PendingMediaElementEventPayload::Playback(task) = pending.payload() + && !task.is_current(self) + { + return None; + } let current_target = self.current_window_document_task_target_for_dispatch_scope( pending.target().dispatch_scope(), )?; @@ -220,6 +235,7 @@ impl PageScriptHost { media_handle, ) } + PendingMediaElementEventPayload::Playback(task) => task.dispatch(scope, host_ptr), PendingMediaElementEventPayload::RemotePlaybackAvailability(callback) => { callback.invoke(scope, host_ptr) } @@ -297,6 +313,7 @@ impl PageScriptHost { } PendingMediaElementEventPayload::VolumeChange { .. } | PendingMediaElementEventPayload::Seeking { .. } + | PendingMediaElementEventPayload::Playback(_) | PendingMediaElementEventPayload::RemotePlaybackAvailability(_) | PendingMediaElementEventPayload::SeekCompletion { .. } | PendingMediaElementEventPayload::TextTrackListEvent { .. } => {} diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_loads.rs b/moli-renderer-v8/src/native_bridge/context_host/media_loads.rs index dddcb5c9f21..db7edf9603b 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_loads.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_loads.rs @@ -333,6 +333,7 @@ impl PageScriptHost { &mut self, document_handle: DomHandle, ) -> usize { + self.retire_media_playback_for_document(document_handle); let handles = self .pending_media_load_sequences .iter() diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs b/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs new file mode 100644 index 00000000000..161ec1ccb07 --- /dev/null +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs @@ -0,0 +1,639 @@ +//! Pending play requests and playback tasks share the media element's native +//! identity. Promise realms belong to media objects; task ownership belongs to the +//! element's Window and exact Document. + +use std::{ + cell::Cell, + collections::HashMap, + rc::{Rc, Weak}, +}; + +use super::{PageScriptHost, WindowDocumentTaskTarget}; +use crate::{ + document_runtime::DomHandle, native_bridge::element, + page_task_queue::RendererPageMediaElementEventTaskKind, +}; + +#[derive(Clone, Copy)] +pub(crate) enum MediaPlayError { + Abort, + NotSupported, + NotAllowed, +} + +impl MediaPlayError { + fn name(self) -> &'static str { + match self { + Self::Abort => "AbortError", + Self::NotSupported => "NotSupportedError", + Self::NotAllowed => "NotAllowedError", + } + } +} + +struct PlayPromise { + resolver: v8::Global, + realm: v8::Global, + settled: Cell, + queued_result: Cell>>, +} + +impl PlayPromise { + fn settle(&self, scope: &mut v8::PinScope<'_, '_>, error: Option) { + if self.settled.replace(true) { + return; + } + let realm = v8::Local::new(scope, &self.realm); + let scope = &mut v8::ContextScope::new(scope, realm); + let resolver = v8::Local::new(scope, &self.resolver); + if let Some(error) = error { + let value = crate::context_bootstrap::new_dom_exception_value( + scope, + "The media playback request could not complete.", + error.name(), + ); + let _ = resolver.reject(scope, value); + } else { + let undefined = v8::undefined(scope); + let _ = resolver.resolve(scope, undefined.into()); + } + } +} + +struct PlaybackElementState { + document: DomHandle, + target: Option, + task_document: Option, + epoch: u64, + can_autoplay: bool, + pending: Vec>, + outstanding: Vec>, + selection: Option, +} + +impl PlaybackElementState { + fn new(document: DomHandle, epoch: u64) -> Self { + Self { + document, + target: None, + task_document: None, + epoch, + can_autoplay: true, + pending: Vec::new(), + outstanding: Vec::new(), + selection: None, + } + } +} + +#[derive(Default)] +pub(super) struct MediaPlaybackState { + elements: HashMap, + stable_work: HashMap, + next_stable_id: u64, +} + +#[derive(Clone, Copy)] +enum StableOperation { + Select { explicit: bool }, + PauseIfRemoved, +} + +struct StableWork { + media: DomHandle, + document: DomHandle, + task_document: DomHandle, + target: WindowDocumentTaskTarget, + epoch: u64, + operation: StableOperation, +} + +enum PlaybackOperation { + Emptied, + Play, + Waiting, + Playing, + Resolve, + Pause, + Reject(MediaPlayError), +} + +pub(crate) struct MediaPlaybackTask { + media: DomHandle, + document: DomHandle, + epoch: u64, + operation: PlaybackOperation, + promises: Vec>, +} + +impl PageScriptHost { + fn media_playback_state_for(&mut self, media: DomHandle) -> Option<&mut PlaybackElementState> { + let document = self.dom_host().node(media)?.owner_document()?; + let entry = self + .media_playback + .elements + .entry(media) + .or_insert_with(|| PlaybackElementState::new(document, 1)); + if entry.document != document { + *entry = PlaybackElementState::new( + document, + entry.epoch.checked_add(1).expect("media epoch overflow"), + ); + } + Some(entry) + } + + fn playback_is_current(&self, media: DomHandle, document: DomHandle, epoch: u64) -> bool { + self.media_playback + .elements + .get(&media) + .is_some_and(|state| state.document == document && state.epoch == epoch) + && self + .dom_host() + .node(media) + .and_then(crate::dom::native::Node::owner_document) + == Some(document) + } + + pub(crate) fn reset_media_after_document_move( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + let document = self + .dom_host() + .node(media) + .and_then(crate::dom::native::Node::owner_document); + let moved = self + .pending_media_load_sequence(media) + .is_some_and(|load| Some(load.owner_document_handle()) != document) + || self + .media_playback + .elements + .get(&media) + .is_some_and(|state| Some(state.document) != document); + if moved { + self.reset_media_playback_for_load(scope, media); + let _ = self.cancel_pending_media_load_sequence(media); + let _ = self.set_media_paused(media, true); + let _ = self.set_media_error_code(media, None); + let _ = self.set_media_ready_state(media, 0); + let _ = self.set_media_network_state(media, 0); + let _ = self.set_media_current_time(media, 0.0); + let _ = self.set_media_seeking(media, false); + } + } + + pub(crate) fn reset_media_playback_for_load( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + let promises = self + .media_playback + .elements + .get_mut(&media) + .map(|state| { + state + .outstanding + .drain(..) + .filter_map(|value| value.upgrade()) + .collect::>() + }) + .unwrap_or_default(); + let Some(state) = self.media_playback_state_for(media) else { + return; + }; + state.pending.clear(); + state.selection = None; + state.can_autoplay = true; + state.epoch = state.epoch.checked_add(1).expect("media epoch overflow"); + for promise in promises { + // Complete settlements already queued by play or pause before + // discarding their tasks. Requests still pending receive AbortError. + let result = promise + .queued_result + .get() + .unwrap_or(Err(MediaPlayError::Abort)); + promise.settle(scope, result.err()); + } + } + + pub(crate) fn retire_media_playback_for_document(&mut self, document: DomHandle) { + self.media_playback + .elements + .retain(|_, state| state.document != document && state.task_document != Some(document)); + self.media_playback + .stable_work + .retain(|_, work| work.document != document && work.task_document != document); + } + + pub(crate) fn bind_media_playback_global<'s>( + &mut self, + scope: &mut v8::PinScope<'s, '_>, + media: DomHandle, + receiver: v8::Local<'s, v8::Object>, + ) -> bool { + self.reset_media_after_document_move(scope, media); + let target = match self.owner_dispatch_scope_for_node(media) { + Some(dispatch_scope) => { + self.current_window_document_task_target_for_dispatch_scope(dispatch_scope) + } + None => { + // A windowless Document is not an active browsing context, but its + // platform objects still have a relevant global for event tasks. + let Some(context) = receiver.get_creation_context(scope) else { + return false; + }; + let scope = &mut v8::ContextScope::new(scope, context); + self.current_renderer_window_document_source(scope) + .map(|source| source.0) + } + }; + let Some(target) = target else { + return false; + }; + let Some(resolved) = self.resolve_authorized_window_document_task_context(scope, target) + else { + return false; + }; + let Some(state) = self.media_playback_state_for(media) else { + return false; + }; + state.target = Some(target); + state.task_document = Some(resolved.document_handle); + true + } + + fn media_playback_target( + &self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) -> Option { + if let Some(dispatch_scope) = self.owner_dispatch_scope_for_node(media) { + return self.current_window_document_task_target_for_dispatch_scope(dispatch_scope); + } + self.media_playback + .elements + .get(&media) + .and_then(|state| state.target) + .or_else(|| self.current_window_document_task_target(scope)) + } + + fn queue_playback( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + operation: PlaybackOperation, + promises: Vec>, + ) { + let Some(task) = self.capture_media_playback_task(media, operation, promises) else { + return; + }; + let target = self.media_playback_target(scope, media); + if let Some(target) = target { + let _ = self.queue_media_element_event_for_target( + target, + RendererPageMediaElementEventTaskKind::Playback, + super::media_element_events::PendingMediaElementEventPayload::Playback(task), + ); + } + } + + fn capture_media_playback_task( + &mut self, + media: DomHandle, + operation: PlaybackOperation, + promises: Vec>, + ) -> Option { + let result = match operation { + PlaybackOperation::Playing | PlaybackOperation::Resolve => Some(Ok(())), + PlaybackOperation::Pause => Some(Err(MediaPlayError::Abort)), + PlaybackOperation::Reject(error) => Some(Err(error)), + _ => None, + }; + for promise in &promises { + promise.queued_result.set(result); + } + let state = self.media_playback_state_for(media)?; + Some(MediaPlaybackTask { + media, + document: state.document, + epoch: state.epoch, + operation, + promises, + }) + } + + pub(crate) fn request_media_play<'s>( + &mut self, + scope: &mut v8::PinScope<'s, '_>, + media: DomHandle, + resolver: v8::Local<'s, v8::PromiseResolver>, + ) { + let request = Rc::new(PlayPromise { + resolver: v8::Global::new(scope, resolver), + realm: v8::Global::new(scope, scope.get_current_context()), + settled: Cell::new(false), + queued_result: Cell::new(None), + }); + if self + .media_playback + .elements + .get(&media) + .and_then(|state| state.target) + .is_none() + { + request.settle(scope, Some(MediaPlayError::NotAllowed)); + return; + } + if self + .dom_host() + .node(media) + .and_then(crate::dom::native::Node::as_element) + .is_some_and(|element| element.media_error_code() == Some(4)) + { + request.settle(scope, Some(MediaPlayError::NotSupported)); + return; + } + let Some(state) = self.media_playback_state_for(media) else { + return; + }; + state.outstanding.retain(|value| value.strong_count() > 0); + state.outstanding.push(Rc::downgrade(&request)); + state.pending.push(request); + state.can_autoplay = false; + element::queue_media_load_for_explicit_request(scope, self, media); + let changed = self.set_media_paused(media, false); + let ready = self + .dom_host() + .node(media) + .and_then(crate::dom::native::Node::as_element) + .map_or(0, |element| element.media_ready_state()); + if changed { + self.queue_playback(scope, media, PlaybackOperation::Play, Vec::new()); + } + if ready >= 3 { + if changed { + self.notify_media_playing(scope, media); + } else { + let promises = self.take_media_play_promises(media); + self.queue_playback(scope, media, PlaybackOperation::Resolve, promises); + } + } else if changed { + self.queue_playback(scope, media, PlaybackOperation::Waiting, Vec::new()); + } + } + + fn take_media_play_promises(&mut self, media: DomHandle) -> Vec> { + self.media_playback + .elements + .get_mut(&media) + .map(|state| std::mem::take(&mut state.pending)) + .unwrap_or_default() + } + + pub(crate) fn pause_media_playback( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + if let Some(state) = self.media_playback_state_for(media) { + state.can_autoplay = false; + } + if self.set_media_paused(media, true) { + let promises = self.take_media_play_promises(media); + self.queue_playback(scope, media, PlaybackOperation::Pause, promises); + } + } + + pub(crate) fn queue_media_emptied( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + self.queue_playback(scope, media, PlaybackOperation::Emptied, Vec::new()); + } + + pub(crate) fn notify_media_playing( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + let promises = self.take_media_play_promises(media); + self.queue_playback(scope, media, PlaybackOperation::Playing, promises); + } + + pub(crate) fn capture_media_play_failure( + &mut self, + media: DomHandle, + ) -> Option { + let promises = self.take_media_play_promises(media); + self.capture_media_playback_task( + media, + PlaybackOperation::Reject(MediaPlayError::NotSupported), + promises, + ) + } + + pub(crate) fn start_media_autoplay( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + let can_autoplay = self + .media_playback + .elements + .get(&media) + .is_none_or(|state| state.can_autoplay); + let eligible = can_autoplay + && self + .dom_host() + .node(media) + .and_then(crate::dom::native::Node::as_element) + .is_some_and(|element| { + element.media_paused() && element.attribute("autoplay").is_some() + }); + if eligible && self.set_media_paused(media, false) { + self.queue_playback(scope, media, PlaybackOperation::Play, Vec::new()); + self.notify_media_playing(scope, media); + } + } + + pub(crate) fn schedule_media_selection( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + explicit: bool, + ) { + if let Some(token) = self + .media_playback_state_for(media) + .and_then(|state| state.selection) + && let Some(work) = self.media_playback.stable_work.get_mut(&token) + { + if let StableOperation::Select { explicit: previous } = &mut work.operation { + *previous |= explicit; + } + return; + } + let token = + self.queue_media_stable_work(scope, media, StableOperation::Select { explicit }); + if let Some(state) = self.media_playback.elements.get_mut(&media) { + state.selection = token; + } + } + + pub(crate) fn schedule_media_pause_if_removed( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + let _ = self.queue_media_stable_work(scope, media, StableOperation::PauseIfRemoved); + } + + fn queue_media_stable_work( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + operation: StableOperation, + ) -> Option { + let target = self.media_playback_target(scope, media)?; + let resolved = self.resolve_authorized_window_document_task_context(scope, target)?; + let task_document = resolved.document_handle; + let state = self.media_playback_state_for(media)?; + let (document, epoch) = (state.document, state.epoch); + self.media_playback.next_stable_id = self + .media_playback + .next_stable_id + .checked_add(1) + .expect("media stable work id overflow"); + let token = self.media_playback.next_stable_id; + let scope = &mut v8::ContextScope::new(scope, resolved.context); + let data = v8::BigInt::new_from_u64(scope, token); + let callback = v8::Function::builder(media_stable_work_callback) + .data(data.into()) + .build(scope)?; + self.media_playback.stable_work.insert( + token, + StableWork { + media, + document, + task_document, + target, + epoch, + operation, + }, + ); + scope.enqueue_microtask(callback); + Some(token) + } + + fn apply_media_stable_work(&mut self, scope: &mut v8::PinScope<'_, '_>, token: u64) { + let Some(work) = self.media_playback.stable_work.remove(&token) else { + return; + }; + if !self.playback_is_current(work.media, work.document, work.epoch) + || self.current_window_document_task_target_for_dispatch_scope( + work.target.dispatch_scope(), + ) != Some(work.target) + { + return; + } + match work.operation { + StableOperation::Select { explicit } => { + let state = self + .media_playback + .elements + .get_mut(&work.media) + .expect("current media state"); + if state.selection != Some(token) { + return; + } + state.selection = None; + element::apply_media_resource_selection(scope, self, work.media, explicit); + } + StableOperation::PauseIfRemoved => { + if self + .dom_host() + .node(work.media) + .is_some_and(|node| !node.is_connected()) + { + self.pause_media_playback(scope, work.media); + } + } + } + } +} + +impl MediaPlaybackTask { + pub(super) fn is_current(&self, host: &PageScriptHost) -> bool { + host.playback_is_current(self.media, self.document, self.epoch) + } + + pub(crate) fn dispatch( + self, + scope: &mut v8::PinScope<'_, '_>, + host: *mut PageScriptHost, + ) -> bool { + if !unsafe { &*host }.playback_is_current(self.media, self.document, self.epoch) { + return false; + } + let error = match self.operation { + PlaybackOperation::Emptied => { + fire(scope, host, self.media, "emptied"); + None + } + PlaybackOperation::Play => { + fire(scope, host, self.media, "play"); + None + } + PlaybackOperation::Waiting => { + fire(scope, host, self.media, "waiting"); + None + } + PlaybackOperation::Playing => { + fire(scope, host, self.media, "playing"); + None + } + PlaybackOperation::Resolve => None, + PlaybackOperation::Pause => { + fire(scope, host, self.media, "timeupdate"); + if !unsafe { &*host }.playback_is_current(self.media, self.document, self.epoch) { + return true; + } + fire(scope, host, self.media, "pause"); + Some(MediaPlayError::Abort) + } + PlaybackOperation::Reject(error) => Some(error), + }; + if unsafe { &*host }.playback_is_current(self.media, self.document, self.epoch) { + for promise in self.promises { + promise.settle(scope, error); + } + } + true + } +} + +fn fire(scope: &mut v8::PinScope<'_, '_>, host: *mut PageScriptHost, media: DomHandle, name: &str) { + if let Some(event) = element::construct_simple_event(scope, name, false, false, false) { + let _ = element::dispatch_public_event(scope, host, media, event); + } +} + +fn media_stable_work_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let Ok(token) = v8::Local::::try_from(args.data()) else { + return; + }; + let (token, lossless) = token.u64_value(); + if !lossless { + return; + } + if let Some(host) = crate::util::context_host_ptr_from_global_bridge(scope) { + unsafe { &mut *host }.apply_media_stable_work(scope, token); + } +} diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs index 9f317c2c30a..2b2aecc610d 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs @@ -129,6 +129,7 @@ mod live_ranges; mod main_document_lifecycle; mod media_element_events; mod media_loads; +mod media_playback; mod misc_platform_api_tasks; mod webrtc_tasks; pub(crate) use media_loads::PendingMediaLoadTerminalFollowup; @@ -1065,6 +1066,7 @@ pub(crate) struct PageScriptHost { scroll_observable_effect_batch: interaction_batch::ScrollObservableEffectBatchState, view_transition_updates: view_transition_updates::ViewTransitionUpdateState, media_element_events: media_element_events::MediaElementEventState, + media_playback: media_playback::MediaPlaybackState, webrtc_tasks: webrtc_tasks::WebRtcTaskState, element_toggle_events: element_toggle_events::ElementToggleEventState, form_navigations: form_navigations::FormNavigationState, diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs index 8635da333a3..d4c8bae0023 100644 --- a/moli-renderer-v8/src/native_bridge/element.rs +++ b/moli-renderer-v8/src/native_bridge/element.rs @@ -606,13 +606,14 @@ pub(in crate::native_bridge) use images::{ }; pub(in crate::native_bridge) use media::queue_text_track_load_if_source; pub(crate) use media::{ - MediaLoadEventPhase, apply_default_text_track_mode_for_track, apply_text_track_load_task, - dispatch_media_load_event_phase, dispatch_media_seek_completion, dispatch_media_seeking_event, - dispatch_media_volume_change, dispatch_text_track_list_event, + MediaLoadEventPhase, apply_default_text_track_mode_for_track, apply_media_resource_selection, + apply_text_track_load_task, dispatch_media_load_event_phase, dispatch_media_seek_completion, + dispatch_media_seeking_event, dispatch_media_volume_change, dispatch_text_track_list_event, queue_default_text_track_mode_if_needed, queue_media_canplay_after_text_tracks, - queue_media_load_if_needed, queue_media_load_if_source_or_loading_change, - queue_media_load_network_terminal_followup, queue_revealed_lazy_media_loads, - queue_text_track_load_if_needed, queue_text_track_terminal_followup, + queue_media_load_for_explicit_request, queue_media_load_if_needed, + queue_media_load_if_source_or_loading_change, queue_media_load_network_terminal_followup, + queue_revealed_lazy_media_loads, queue_text_track_load_if_needed, + queue_text_track_terminal_followup, }; pub(super) use media::{ apply_default_text_track_modes_for_media, media_add_text_track_callback, diff --git a/moli-renderer-v8/src/native_bridge/element/media.rs b/moli-renderer-v8/src/native_bridge/element/media.rs index 0bf8a93dd9e..370ed9b1658 100644 --- a/moli-renderer-v8/src/native_bridge/element/media.rs +++ b/moli-renderer-v8/src/native_bridge/element/media.rs @@ -10,7 +10,8 @@ pub(super) use attributes::{ }; pub(crate) use attributes::{ - MediaLoadEventPhase, dispatch_media_load_event_phase, queue_media_canplay_after_text_tracks, + MediaLoadEventPhase, apply_media_resource_selection, dispatch_media_load_event_phase, + queue_media_canplay_after_text_tracks, queue_media_load_for_explicit_request, queue_media_load_if_needed, queue_media_load_if_source_or_loading_change, queue_media_load_network_terminal_followup, queue_revealed_lazy_media_loads, }; 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 d3fe3802efa..e207d600a8a 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs @@ -237,7 +237,7 @@ pub(crate) fn queue_media_load_if_needed( runtime_ptr: *mut PageScriptHost, handle: crate::document_runtime::DomHandle, ) { - queue_media_load(scope, runtime_ptr, handle, MediaLoadTrigger::Automatic); + schedule_media_selection(scope, runtime_ptr, handle, false); } pub(crate) fn queue_media_load_for_explicit_request( @@ -245,7 +245,59 @@ pub(crate) fn queue_media_load_for_explicit_request( runtime_ptr: *mut PageScriptHost, handle: crate::document_runtime::DomHandle, ) { - queue_media_load(scope, runtime_ptr, handle, MediaLoadTrigger::Explicit); + schedule_media_selection(scope, runtime_ptr, handle, true); +} + +fn schedule_media_selection( + scope: &mut v8::PinScope<'_, '_>, + runtime_ptr: *mut PageScriptHost, + handle: crate::document_runtime::DomHandle, + explicit: bool, +) { + unsafe { &mut *runtime_ptr }.reset_media_after_document_move(scope, handle); + let runtime = unsafe { &mut *runtime_ptr }; + let Some(element) = runtime + .dom_host() + .node(handle) + .and_then(crate::dom::native::Node::as_element) + else { + return; + }; + if (!element.is_html_element("audio") && !element.is_html_element("video")) + || runtime.pending_media_load_sequence(handle).is_some() + || element.media_ready_state() > 0 + { + return; + } + if !explicit + && element + .attribute("loading") + .is_some_and(|value| value.eq_ignore_ascii_case("lazy")) + { + // Candidate discovery belongs to the mutation owner. Resource selection + // still waits for stable state before observing the source or fetching. + register_lazy_media_load_candidate_if_media(runtime, handle); + } + let _ = runtime.set_media_network_state(handle, 3); + runtime.schedule_media_selection(scope, handle, explicit); +} + +pub(crate) fn apply_media_resource_selection( + scope: &mut v8::PinScope<'_, '_>, + runtime_ptr: *mut PageScriptHost, + handle: crate::document_runtime::DomHandle, + explicit: bool, +) { + queue_media_load( + scope, + runtime_ptr, + handle, + if explicit { + MediaLoadTrigger::Explicit + } else { + MediaLoadTrigger::Automatic + }, + ); } fn queue_media_load( @@ -254,23 +306,8 @@ fn queue_media_load( handle: crate::document_runtime::DomHandle, trigger: MediaLoadTrigger, ) { + unsafe { &mut *runtime_ptr }.reset_media_after_document_move(scope, handle); let runtime = unsafe { &mut *runtime_ptr }; - let current_owner_document = runtime - .dom_host() - .node(handle) - .and_then(crate::dom::native::Node::owner_document); - if runtime - .pending_media_load_sequence(handle) - .is_some_and(|pending| current_owner_document != Some(pending.owner_document_handle())) - { - // Chromium restarts media selection after DidMoveToNewDocument. Retire - // the old document's exact delay before accepting the new owner below; - // the queued callback remains harmless because the new sequence gets a - // different id. - let _ = runtime.cancel_pending_media_load_sequence(handle); - let _ = runtime.set_media_ready_state(handle, 0); - let _ = runtime.set_media_network_state(handle, 0); - } let Some(element) = runtime .dom_host() .node(handle) @@ -286,7 +323,10 @@ fn queue_media_load( } let selected_source = match selected_media_source(runtime, handle) { Ok(Some(selected_source)) => selected_source, - Ok(None) => return, + Ok(None) => { + let _ = runtime.set_media_network_state(handle, 0); + return; + } Err(()) => { start_media_load(scope, runtime_ptr, handle, None); return; @@ -325,7 +365,10 @@ pub(crate) fn queue_media_load_if_source_or_loading_change( }; if attribute_name.eq_ignore_ascii_case("src") { let runtime = unsafe { &mut *runtime_ptr }; + runtime.reset_media_playback_for_load(scope, target); let _ = runtime.cancel_pending_media_load_sequence(target); + let _ = runtime.set_media_paused(target, true); + let _ = runtime.set_media_error_code(target, None); let _ = runtime.set_media_ready_state(target, 0); let _ = runtime.set_media_network_state(target, 0); } @@ -644,6 +687,11 @@ pub(crate) fn dispatch_media_load_event_phase( .cancel_pending_media_load_sequence_if_matches(handle, sequence); return false; } + let play_failure = if phase == MediaLoadEventPhase::Error { + unsafe { &mut *runtime_ptr }.capture_media_play_failure(handle) + } else { + None + }; match phase { MediaLoadEventPhase::LoadStart | MediaLoadEventPhase::CanPlayThrough => {} MediaLoadEventPhase::LoadedMetadata => { @@ -655,6 +703,14 @@ pub(crate) fn dispatch_media_load_event_phase( MediaLoadEventPhase::CanPlay => { let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 4); let _ = unsafe { &mut *runtime_ptr }.set_media_network_state(handle, 1); + if unsafe { &*runtime_ptr } + .dom_host() + .node(handle) + .and_then(crate::dom::native::Node::as_element) + .is_some_and(|element| !element.media_paused()) + { + unsafe { &mut *runtime_ptr }.notify_media_playing(scope, handle); + } } MediaLoadEventPhase::Error => { let _ = unsafe { &mut *runtime_ptr }.set_media_error_code(handle, Some(4)); @@ -670,6 +726,9 @@ pub(crate) fn dispatch_media_load_event_phase( } else { false }; + if let Some(failure) = play_failure { + failure.dispatch(scope, runtime_ptr); + } if matches!( phase, MediaLoadEventPhase::LoadedData | MediaLoadEventPhase::Error @@ -688,9 +747,6 @@ pub(crate) fn dispatch_media_load_event_phase( queue_media_load_terminal_followup_if_ready(scope, runtime_ptr, handle, sequence, followup); return dispatched; } - if phase == MediaLoadEventPhase::CanPlay { - dispatch_media_autoplay_if_needed(scope, runtime_ptr, handle); - } if phase == MediaLoadEventPhase::LoadedData && unsafe { &mut *runtime_ptr } .defer_pending_media_canplay_for_text_tracks(handle, sequence) @@ -706,6 +762,9 @@ pub(crate) fn dispatch_media_load_event_phase( let _ = unsafe { &mut *runtime_ptr } .cancel_pending_media_load_sequence_if_matches(handle, sequence); } + if phase == MediaLoadEventPhase::CanPlay { + unsafe { &mut *runtime_ptr }.start_media_autoplay(scope, handle); + } dispatched } @@ -761,33 +820,6 @@ fn queue_media_load_terminal_followup_if_ready( } } -fn dispatch_media_autoplay_if_needed( - scope: &mut v8::PinScope<'_, '_>, - runtime_ptr: *mut PageScriptHost, - handle: crate::document_runtime::DomHandle, -) { - let should_autoplay = { - let runtime = unsafe { &mut *runtime_ptr }; - let should_autoplay = runtime - .dom_host() - .node(handle) - .and_then(crate::dom::native::Node::as_element) - .is_some_and(|element| { - element.attribute("autoplay").is_some() && element.media_paused() - }); - should_autoplay && runtime.set_media_paused(handle, false) - }; - if !should_autoplay { - return; - } - if let Some(event) = construct_simple_event(scope, "play", false, false, false) { - let _ = dispatch_public_event(scope, runtime_ptr, handle, event); - } - if let Some(event) = construct_simple_event(scope, "playing", false, false, false) { - let _ = dispatch_public_event(scope, runtime_ptr, handle, event); - } -} - fn media_load_target_for_source_change( runtime: &PageScriptHost, handle: crate::document_runtime::DomHandle, diff --git a/moli-renderer-v8/src/native_bridge/element/media/methods.rs b/moli-renderer-v8/src/native_bridge/element/media/methods.rs index d899bf5ac3b..dc1e0d99f52 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/methods.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/methods.rs @@ -3,8 +3,7 @@ use crate::webidl; use moli_web_mime::media_mime_support; use super::super::{ - apply_default_text_track_modes_for_media, construct_simple_event, dispatch_public_event, - dispatch_text_control_event, html_media_element_method_receiver, + apply_default_text_track_modes_for_media, html_media_element_method_receiver, refresh_media_active_text_track_cues, }; use super::attributes::queue_media_load_for_explicit_request; @@ -31,24 +30,20 @@ pub(in crate::native_bridge) fn media_play_callback<'s>( rv.set_undefined(); return; }; - let runtime = unsafe { &mut *runtime_ptr }; - let changed = runtime.set_media_paused(handle, false); - let _ = runtime.set_media_ready_state(handle, 4); - let _ = runtime.set_media_network_state(handle, 1); - apply_default_text_track_modes_for_media(scope, runtime_ptr, handle); - refresh_media_active_text_track_cues(scope, runtime_ptr, handle); - if changed { - dispatch_text_control_event(scope, runtime_ptr, handle, "play"); - dispatch_text_control_event(scope, runtime_ptr, handle, "playing"); - } + let Some(realm) = args.this().get_creation_context(scope) else { + return; + }; + let scope = &mut v8::ContextScope::new(scope, realm); let Some(resolver) = v8::PromiseResolver::new(scope) else { rv.set_undefined(); return; }; let promise = resolver.get_promise(scope); - let undefined = v8::undefined(scope); - let _ = resolver.resolve(scope, undefined.into()); rv.set(promise.into()); + let _ = unsafe { &mut *runtime_ptr }.bind_media_playback_global(scope, handle, args.this()); + unsafe { &mut *runtime_ptr }.request_media_play(scope, handle, resolver); + apply_default_text_track_modes_for_media(scope, runtime_ptr, handle); + refresh_media_active_text_track_cues(scope, runtime_ptr, handle); } pub(in crate::native_bridge) fn media_pause_callback<'s>( @@ -62,11 +57,16 @@ pub(in crate::native_bridge) fn media_pause_callback<'s>( rv.set_undefined(); return; }; - let runtime = unsafe { &mut *runtime_ptr }; - let changed = runtime.set_media_paused(handle, true); - if changed { - dispatch_text_control_event(scope, runtime_ptr, handle, "pause"); + let _ = unsafe { &mut *runtime_ptr }.bind_media_playback_global(scope, handle, args.this()); + let empty = unsafe { &*runtime_ptr } + .dom_host() + .node(handle) + .and_then(crate::dom::native::Node::as_element) + .is_some_and(|element| element.media_network_state() == 0); + if empty { + queue_media_load_for_explicit_request(scope, runtime_ptr, handle); } + unsafe { &mut *runtime_ptr }.pause_media_playback(scope, handle); rv.set_undefined(); } @@ -82,6 +82,8 @@ pub(in crate::native_bridge) fn media_load_callback<'s>( return; }; let runtime = unsafe { &mut *runtime_ptr }; + let _ = runtime.bind_media_playback_global(scope, handle, args.this()); + runtime.reset_media_playback_for_load(scope, handle); let _ = runtime.cancel_pending_media_load_sequence(handle); let error_changed = runtime.set_media_error_code(handle, None); let paused_changed = runtime.set_media_paused(handle, true); @@ -89,15 +91,14 @@ pub(in crate::native_bridge) fn media_load_callback<'s>( let seeking_changed = runtime.set_media_seeking(handle, false); let ready_changed = runtime.set_media_ready_state(handle, 0); let network_changed = runtime.set_media_network_state(handle, 0); - if (error_changed + if error_changed || paused_changed || time_changed || seeking_changed || ready_changed - || network_changed) - && let Some(event) = construct_simple_event(scope, "emptied", false, false, false) + || network_changed { - let _ = dispatch_public_event(scope, runtime_ptr, handle, event); + runtime.queue_media_emptied(scope, handle); } queue_media_load_for_explicit_request(scope, runtime_ptr, handle); rv.set_undefined(); 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 3123f06ac8d..9bdefed45f7 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 @@ -26,6 +26,7 @@ impl RendererPageMediaElementEventTaskId { /// manipulation, not media-element event delivery. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub(crate) enum RendererPageMediaElementEventTaskKind { + Playback, Seeking, VolumeChange, SeekCompletion, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs b/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs index d24eb74fb54..efc5da0d915 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs @@ -4,6 +4,183 @@ use crate::page_task_queue::{ PageMediaElementEventTargetEffect, RendererPageMediaElementEventTaskKind, }; +#[tokio::test(flavor = "current_thread")] +async fn media_playback_requests_preserve_realms_tasks_readiness_and_cancellation() { + run_page_vm_async_test(async move { + use base64::Engine as _; + let paths = [ + "/unsupported/main-main-audio", "/unsupported/main-main-video", + "/unsupported/main-iframe-audio", "/unsupported/main-iframe-video", + "/unsupported/iframe-main-audio", "/unsupported/iframe-main-video", + "/unsupported/iframe-iframe-audio", "/unsupported/iframe-iframe-video", + ]; + let responses = paths.into_iter().map(|path| { + (path, "HTTP/1.1 404 Not Found", "missing".to_owned(), Duration::ZERO) + }).collect(); + let (base_url, server) = spawn_path_response_http_server(responses).await; + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader"); + loader.set_optional_resource_fetch_enabled(crate::types::SubresourceResourceType::Video, true); + loader.set_optional_resource_fetch_enabled(crate::types::SubresourceResourceType::Audio, true); + let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake(&loader, Url::parse(&base_url)?); + page.vm_mut().set_layout_policy(moli_page_types::LayoutPolicy::Mock); + let sources = serde_json::json!({ + "video":format!("data:video/webm;base64,{}",base64::engine::general_purpose::STANDARD.encode(include_bytes!("../../../../tests/fixtures/media/movie_5.webm"))), + "audio":format!("data:audio/ogg;base64,{}",base64::engine::general_purpose::STANDARD.encode(include_bytes!("../../../../tests/fixtures/media/sound_5.oga"))), + }); + page.vm_mut().eval(&format!("document.body.innerHTML='';globalThis.__mediaPlaybackSources={sources};globalThis.__mediaPlaybackUnsupportedURL={:?};",format!("{base_url}/unsupported")))?; + page.vm_mut().eval(include_str!("../../../../tests/fixtures/media-playback-state.js"))?; + let deadline = Instant::now() + Duration::from_secs(45); + while page.vm_mut().eval("typeof __uiEventResults")? == "undefined" { + let _ = page.run_next_child_frame_task_source_for_semantic_test().await; + for selector in [PageSelectedTaskTestSelector::ResourceCompletion, PageSelectedTaskTestSelector::MediaElementEvent] { + let _ = page.run_exact_selected_page_task_for_test(selector, &loader).await?; + } + // Only the fixture's explicit watchdog uses timers. Playback itself + // must be driven by media-element tasks, as the isolation tests prove. + let _ = page.run_one_due_timer_selected_task_for_test(&loader).await?; + anyhow::ensure!(Instant::now() < deadline, "playback fixture did not finish: {}", page.vm_mut().eval("__mediaPlaybackProgress.stage")?); + tokio::time::sleep(Duration::from_millis(1)).await; + } + server.abort(); + let result: serde_json::Value = serde_json::from_str(&page.vm_mut().eval("JSON.stringify(__uiEventResults)")?)?; + let failures: Vec<_> = result["checks"].as_array().unwrap().iter().filter(|r| r["passed"] != true).collect(); + assert!(failures.is_empty(), "{failures:#?}"); + assert_eq!(result["total"], 112, "all source and callee realm pairs and both media kinds must run"); + Ok::<_, anyhow::Error>(()) + }).await.expect("native media playback requests and owned task semantics"); +} + +#[tokio::test(flavor = "current_thread")] +async fn media_failure_settles_play_requests_in_the_error_task_even_when_reloaded() { + run_page_vm_async_test(async move { + for reload in [false, true] { + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()) + .expect("loader"); + let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, + Url::parse("https://media-play-failure.test/")?, + ); + page.vm_mut() + .set_layout_policy(moli_page_types::LayoutPolicy::Mock); + page.vm_mut() + .eval(&format!("globalThis.reloadOnError = {reload};"))?; + page.vm_mut().eval( + r#" +globalThis.failureEvents = []; +globalThis.media = document.createElement('video'); +document.body.append(media); +media.onplay = () => failureEvents.push('play'); +media.onplaying = () => failureEvents.push('playing'); +media.onerror = () => { + failureEvents.push('error'); + if (reloadOnError) { + media.removeAttribute('src'); + media.load(); + } +}; +media.src = 'http://['; +media.play().then( + () => failureEvents.push('fulfilled'), + error => failureEvents.push(error.name) +); +"#, + )?; + for _ in 0..3 { + assert!( + page.run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, + &loader, + ) + .await? + ); + } + assert_eq!(page.vm_mut().eval("failureEvents.join('|')")?, "play"); + assert!( + page.run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, + &loader, + ) + .await?, + "run the error task without selecting any followup task" + ); + assert_eq!( + page.vm_mut().eval("failureEvents.join('|')")?, + "play|error|NotSupportedError", + "failure must settle after error in the same owned task" + ); + assert!( + !page.vm().has_ready_timeout(), + "media rejection must not use a timer" + ); + } + Ok::<_, anyhow::Error>(()) + }) + .await + .expect("media error tasks own pending play rejection and reload settlement"); +} + +#[tokio::test(flavor = "current_thread")] +async fn media_captured_playing_tasks_settle_before_load_and_retire_without_checkpoints() { + run_page_vm_async_test(async move { + use base64::Engine as _; + let source = format!("data:video/webm;base64,{}", base64::engine::general_purpose::STANDARD.encode( + include_bytes!("../../../../tests/fixtures/media/movie_5.webm"), + )); + for retire_document in [false, true] { + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader"); + let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, Url::parse("https://captured-media-playback.test/")?, + ); + page.vm_mut().set_layout_policy(moli_page_types::LayoutPolicy::Mock); + page.vm_mut().eval(&format!( + "globalThis.media = document.createElement('video'); document.body.append(media); media.src = {source:?};" + ))?; + for _ in 0..5 { + assert!(page.run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, &loader, + ).await?, "prepare the source through all media load phases"); + } + page.vm_mut().eval(r#" +globalThis.playbackEvents = []; +media.onplay = () => playbackEvents.push('play'); +media.onplaying = () => playbackEvents.push('playing'); +media.play().then( + () => playbackEvents.push('fulfilled'), + error => playbackEvents.push(error.name) +); +"#)?; + assert!(page.run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, &loader, + ).await?); + assert_eq!(page.vm_mut().eval("playbackEvents.join('|')")?, "play"); + let captured = page.claim_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, + ).expect("capture playing after it has taken the pending play requests"); + page.vm_mut().eval(if retire_document { + "document.open(); document.write('replacement'); document.close();" + } else { + "media.load()" + })?; + let expected = if retire_document { "play" } else { "play|fulfilled" }; + assert_eq!(page.vm_mut().eval("playbackEvents.join('|')")?, expected); + page.vm_mut().eval_without_microtask_checkpoint_for_test(r#" +globalThis.unrelatedPlaybackWork = []; +Promise.resolve().then(() => unrelatedPlaybackWork.push('microtask')); +setTimeout(() => unrelatedPlaybackWork.push('timer'), 0); +"#)?; + page.vm_mut().enqueue_test_pending_runtime_source_load(); + page.run_claimed_selected_page_task_for_test(captured, &loader).await?; + assert_eq!(page.vm_mut().eval_without_microtask_checkpoint_for_test( + "playbackEvents.join('|') + ':' + unrelatedPlaybackWork.join('|')", + )?, format!("{expected}:"), "a stale playing task must neither dispatch nor checkpoint"); + assert!(page.vm().has_ready_timeout(), "stale media work must leave unrelated timers queued"); + assert_eq!(page.vm().document_runtime.runtime_script_work().dynamic_scripts + .pending_source_load_count_for_test(), 1, "stale media work must not advance script work"); + } + Ok::<_, anyhow::Error>(()) + }).await.expect("captured playing requests obey load epochs and exact Document ownership"); +} + #[tokio::test(flavor = "current_thread")] async fn media_canplaythrough_runs_in_a_separate_owned_task_after_canplay_microtasks() { run_page_vm_async_test(async move { diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs index e723a6511d4..0ee01564e94 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs @@ -271,6 +271,12 @@ async fn media_invalid_request_url_fails_before_load() { "error|0|3|true|4|true|true|true" ); + run_next_page_media_element_event_for_test( + &mut vm, + &loader, + "reloaded invalid-URL media emptied turn", + ) + .await; run_next_page_media_element_event_for_test( &mut vm, &loader, @@ -450,22 +456,41 @@ async fn media_dangling_markup_still_dispatches_report_only_csp() { ); } -#[test] -fn media_play_returns_a_fulfilled_promise() { - let mut vm = new_storage_test_vm("https://media-play-promise.test/"); - +#[tokio::test] +async fn media_play_returns_a_fulfilled_promise() { + use base64::Engine as _; + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + let mut vm = new_storage_page_task_executor_test_vm_with_loader( + "https://media-play-promise.test/", + &loader, + ); + let source = format!( + "data:video/webm;base64,{}", + base64::engine::general_purpose::STANDARD.encode(include_bytes!( + "../../../../tests/fixtures/media/movie_5.webm" + ),) + ); + vm.eval(&format!("globalThis.video = document.createElement('video'); document.body.append(video); video.src = {source:?};")) + .expect("media source should load through its owned tasks"); + for phase in [ + "loadstart", + "loadedmetadata", + "loadeddata", + "canplay", + "canplaythrough", + ] { + run_next_page_media_element_event_for_test(&mut vm, &loader, phase).await; + } vm.exec( r#" (() => { - const video = document.createElement("video"); - const events = []; + const events = globalThis.__mediaPlayEvents = []; video.addEventListener("play", () => events.push("play")); video.addEventListener("playing", () => events.push("playing")); const promise = video.play(); globalThis.__mediaPlayPromiseProbe = { promiseTag: Object.prototype.toString.call(promise), paused: video.paused, - events: events.join(","), outcome: "pending" }; promise.then(value => { @@ -479,13 +504,26 @@ fn media_play_returns_a_fulfilled_promise() { ) .expect("media play promise probe should execute"); - let result = vm - .eval("JSON.stringify(globalThis.__mediaPlayPromiseProbe)") - .expect("media play promise probe should evaluate"); - assert_eq!( - result, - r#"{"promiseTag":"[object Promise]","paused":false,"events":"play,playing","outcome":"fulfilled:undefined"}"# + vm.eval( + "JSON.stringify({...__mediaPlayPromiseProbe, events: __mediaPlayEvents.join(',')})" + ) + .expect("play must not fulfill synchronously"), + r#"{"promiseTag":"[object Promise]","paused":false,"outcome":"pending","events":""}"# + ); + run_next_page_media_element_event_for_test(&mut vm, &loader, "play event turn").await; + assert_eq!( + vm.eval("__mediaPlayEvents.join(',') + ':' + __mediaPlayPromiseProbe.outcome") + .unwrap(), + "play:pending" + ); + run_next_page_media_element_event_for_test(&mut vm, &loader, "playing event turn").await; + assert_eq!( + vm.eval( + "JSON.stringify({...__mediaPlayPromiseProbe, events: __mediaPlayEvents.join(',')})" + ) + .expect("play promise must fulfill after playing"), + r#"{"promiseTag":"[object Promise]","paused":false,"outcome":"fulfilled:undefined","events":"play,playing"}"# ); } @@ -686,6 +724,10 @@ async fn media_pseudo_classes_update_has_ancestor_styles() { vm.eval("[__lmMediaPseudo.counts.volumeEvents, __lmMediaPseudo.counts.seekingEvents, __lmMediaPseudo.counts.seekedEvents].join(',')").unwrap(), "1,0,0", ); + for event in ["play", "waiting"] { + run_next_page_media_element_event_for_test(&mut vm, &loader, event).await; + assert_eq!(vm.eval("[__lmMediaPseudo.counts.seekingEvents, __lmMediaPseudo.counts.seekedEvents].join(',')").unwrap(), "0,0"); + } run_next_page_media_element_event_for_test(&mut vm, &loader, "media seeking event turn").await; diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/detached_document_and_element_surfaces.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/detached_document_and_element_surfaces.rs index bb7bfdc73ab..7fb4a69fb75 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/detached_document_and_element_surfaces.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/detached_document_and_element_surfaces.rs @@ -658,9 +658,13 @@ fn detached_scroll_offsets_use_element_prototype_accessors_and_methods() { assert_eq!(result, "ok"); } -#[test] -fn detached_specialized_method_brand_checks_accept_standard_prototype_methods() { - let mut vm = new_storage_test_vm("https://detached-specialized-method-brand-check.test/"); +#[tokio::test] +async fn detached_specialized_method_brand_checks_accept_standard_prototype_methods() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + let mut vm = new_storage_page_task_executor_test_vm_with_loader( + "https://detached-specialized-method-brand-check.test/", + &loader, + ); let result = vm .eval( @@ -672,7 +676,7 @@ fn detached_specialized_method_brand_checks_accept_standard_prototype_methods() const submitter = doc.createElement("button"); const textarea = doc.createElement("textarea"); const audio = doc.createElement("audio"); - const mediaEvents = []; + const mediaEvents = globalThis.__detachedMediaEvents = []; const formEvents = []; input.name = "q"; @@ -708,7 +712,9 @@ fn detached_specialized_method_brand_checks_accept_standard_prototype_methods() HTMLTextAreaElement.prototype.setRangeText.call(textarea, "XY", 2, 5, "select"); HTMLTextAreaElement.prototype.select.call(textarea); - HTMLMediaElement.prototype.play.call(audio); + HTMLMediaElement.prototype.play.call(audio).catch(error => { + globalThis.__detachedPlayError = error.name; + }); const pausedAfterPlay = audio.paused; HTMLMediaElement.prototype.pause.call(audio); const pausedAfterPause = audio.paused; @@ -743,7 +749,21 @@ fn detached_specialized_method_brand_checks_accept_standard_prototype_methods() assert_eq!( result, - r#"{"afterStepUp":"3","afterStepDown":"1","invalidCustom":true,"invalidForm":true,"validControl":true,"validForm":true,"submitEvents":"true","textareaValue":"abXYf","textareaSelection":"0,5","pausedAfterPlay":false,"pausedAfterPause":true,"mediaEvents":"play,pause,emptied","inputOwn":false,"textareaOwn":false,"formOwn":false,"mediaOwn":false}"# + r#"{"afterStepUp":"3","afterStepDown":"1","invalidCustom":true,"invalidForm":true,"validControl":true,"validForm":true,"submitEvents":"true","textareaValue":"abXYf","textareaSelection":"0,5","pausedAfterPlay":false,"pausedAfterPause":true,"mediaEvents":"","inputOwn":false,"textareaOwn":false,"formOwn":false,"mediaOwn":false}"# + ); + // load() discards the queued play/pause events, settles their requests, and + // delivers emptied asynchronously through the media element task source. + for _ in 0..4 { + run_next_page_media_element_event_for_test(&mut vm, &loader, "windowless media task").await; + } + assert_eq!( + vm.eval("__detachedMediaEvents.join(',')").unwrap(), + "emptied" + ); + assert_eq!(vm.eval("__detachedPlayError").unwrap(), "AbortError"); + assert!( + !vm.has_ready_timeout(), + "media events must not require a timer" ); } diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs b/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs index 8222ef83dc4..e04aa4faa94 100644 --- a/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs +++ b/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs @@ -1367,6 +1367,8 @@ async fn main_static_media_load_delays_complete_until_loadeddata_owner_turn() { .expect("parser EOF should prepare interactive"); vm.apply_main_document_interactive_lifecycle_action(interactive) .expect("interactive transition should register static media"); + vm.eval("void 0") + .expect("static media selection should reach stable state"); let pending = vm ._context_host .borrow() @@ -1859,6 +1861,8 @@ async fn main_media_source_children_reselect_through_parent_sequence() { .expect("parser EOF should prepare interactive"); vm.apply_main_document_interactive_lifecycle_action(interactive) .expect("interactive should select the source child"); + vm.eval("void 0") + .expect("source child selection should reach stable state"); let media = vm .document_runtime .get_element_by_id("clip") diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs b/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs index 434902aa113..504820a8a98 100644 --- a/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs +++ b/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs @@ -917,6 +917,8 @@ fn media_preload_none_defers_automatic_load_until_explicit_load() { .expect("parser EOF should prepare interactive"); vm.apply_main_document_interactive_lifecycle_action(interactive) .expect("interactive transition should apply"); + vm.eval("void 0") + .expect("automatic media selection should reach stable state"); assert!( vm._context_host .borrow() diff --git a/moli-renderer-v8/tests/fixtures/media-playback-state.js b/moli-renderer-v8/tests/fixtures/media-playback-state.js new file mode 100644 index 00000000000..7705c66e983 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media-playback-state.js @@ -0,0 +1,152 @@ +(async () => { + const checks=[]; + const progress=globalThis.__mediaPlaybackProgress={stage:'setup',checks}; + const assert=(ok,message)=>{if(!ok)throw Error(message);}; + function play(callee,media) { + const promise=callee.HTMLMediaElement.prototype.play.call(media); + promise.catch(()=>{}); + return promise; + } + const pause=(callee,media)=>callee.HTMLMediaElement.prototype.pause.call(media); + const source=kind=>__mediaPlaybackSources[kind]; + const once=(media,event,action)=>new Promise((resolve,reject)=>{ + media.addEventListener(event,resolve,{once:true}); + if(event!=='error')media.addEventListener('error',()=>reject(Error('unexpected media error')),{once:true}); + action(); + }); + async function abort(owner,promise) { + let error;try{await promise;}catch(value){error=value;} + assert(error instanceof owner.DOMException && error.name==='AbortError','expected media-realm AbortError, got '+error); + } + async function ready(media,kind) { + await once(media,'canplaythrough',()=>{media.src=source(kind);}); + assert(media.readyState===4,'loaded media must have enough data'); + } + const cases=[ + ['same-task pause',async(owner,callee,media,kind)=>{ + const events=[];for(const name of ['play','playing','pause'])media.addEventListener(name,()=>events.push(name)); + media.src=source(kind); + const promise=play(callee,media); + assert(promise instanceof owner.Promise,'media Promise realm'); + assert(!media.paused && media.readyState<3,'play must change paused without inventing ready data'); + assert(events.length===0,'play events must be asynchronous'); + pause(owner,media); + assert(media.paused && events.length===0,'pause state is synchronous, its event is not'); + await abort(owner,promise); + assert(events.join('|')==='play|pause','no playing event before aborted playback: '+events); + }], + ['pause from play listener',async(owner,callee,media)=>{ + const events=[]; + media.addEventListener('play',()=>{events.push('play');pause(owner,media);}); + media.addEventListener('pause',()=>events.push('pause')); + await abort(owner,play(callee,media)); + assert(events.join('|')==='play|pause','pause from play callback must abort the request'); + }], + ['load aborts pending promise',async(owner,callee,media,kind)=>{ + media.src=source(kind);const promise=play(callee,media);media.load(); + await abort(owner,promise);assert(media.paused,'load must pause the element'); + }], + ['source replacement aborts pending promise',async(owner,callee,media,kind)=>{ + media.src=source(kind);const promise=play(callee,media);media.src=source(kind)+'#replacement'; + await abort(owner,promise);assert(media.paused,'source replacement must pause the element'); + }], + ['loaded play resolves after playing',async(owner,callee,media,kind)=>{ + await ready(media,kind);const events=[]; + for(const name of ['play','playing'])media.addEventListener(name,()=>events.push(name)); + const promise=play(callee,media); + assert(events.length===0,'loaded play events must still be queued'); + const result=await promise;events.push('resolved'); + assert(result===undefined && events.join('|')==='play|playing|resolved','playing must precede fulfillment: '+events); + }], + ['multiple loaded play requests',async(owner,callee,media,kind)=>{ + await ready(media,kind);let plays=0,playing=0; + media.onplay=()=>plays++;media.onplaying=()=>playing++; + const first=play(callee,media),second=play(callee,media); + assert(first!==second && first instanceof owner.Promise && second instanceof owner.Promise,'each call returns its own media-realm Promise'); + const results=await Promise.all([first,second]); + assert(results.every(value=>value===undefined) && plays===1 && playing===1,'already playing must not duplicate events'); + }], + ['pause from playing preserves captured promise',async(owner,callee,media,kind)=>{ + await ready(media,kind); + const paused=once(media,'pause',()=>{}); + media.onplaying=()=>pause(owner,media); + const result=await play(callee,media); + assert(result===undefined && media.paused,'pause must not reject a request already captured by playing'); + await paused; + }], + ['load from play fulfills captured playing promise',async(owner,callee,media,kind)=>{ + await ready(media,kind);let playing=0; + media.onplay=()=>media.load();media.onplaying=()=>playing++; + const result=await play(callee,media); + assert(result===undefined && playing===0 && media.paused,'load must fulfill an already captured request before discarding its playing event'); + }], + ['removal pauses at stable state',async(owner,callee,media,kind)=>{ + await ready(media,kind);await play(callee,media); + const paused=once(media,'pause',()=>media.remove()); + assert(!media.paused,'removal must not pause synchronously'); + await paused;assert(media.paused,'detached media must pause'); + }], + ['move within document keeps playing',async(owner,callee,media,kind)=>{ + await ready(media,kind);await play(callee,media);let pauses=0;media.onpause=()=>pauses++; + const container=owner.document.createElement('div');owner.document.body.appendChild(container); + container.appendChild(media); + await Promise.resolve();await Promise.resolve(); + assert(!media.paused && pauses===0,'reinserted media must remain playing'); + owner.document.body.appendChild(media);container.remove(); + }], + ['adoption restarts loaded media for the new document',async(owner,callee,media,kind,ownerName)=>{ + await ready(media,kind);await play(callee,media); + const destination=ownerName==='main'?document.querySelector('iframe').contentWindow:globalThis; + destination.document.adoptNode(media); + assert(media.ownerDocument===destination.document && media.paused && media.readyState===0,'adoption must reset playback before returning'); + await once(media,'canplaythrough',()=>destination.document.body.appendChild(media)); + const promise=play(callee,media); + assert(promise instanceof owner.Promise,'adoption must retain the media object realm'); + assert(await promise===undefined && !media.paused,'playback must restart under the new document owner'); + }], + ['shadow tree adoption resets media playback',async(owner,callee,media,kind,ownerName)=>{ + const host=owner.document.createElement('div');owner.document.body.appendChild(host); + host.attachShadow({mode:'open'}).appendChild(media); + try{ + await ready(media,kind);await play(callee,media); + const destination=ownerName==='main'?document.querySelector('iframe').contentWindow:globalThis; + destination.document.adoptNode(host); + assert(media.ownerDocument===destination.document && media.paused && media.readyState===0,'adoption must reset media in shadow trees before returning'); + await once(media,'canplaythrough',()=>destination.document.body.appendChild(host)); + assert(await play(callee,media)===undefined && !media.paused,'shadow media must load under its new owner'); + }finally{host.remove();} + }], + ['windowless media keeps its relevant global',async(owner,callee,media,kind)=>{ + const detached=owner.document.implementation.createHTMLDocument(''); + const inactive=detached.createElement(kind);detached.body.appendChild(inactive); + const eventRealms=[]; + for(const name of ['play','pause'])inactive.addEventListener(name,event=>eventRealms.push(event instanceof owner.Event)); + const promise=play(callee,inactive);let settled=false;promise.then(()=>settled=true,()=>settled=true); + await Promise.resolve(); + assert(!settled && !inactive.paused && inactive.readyState===0,'play without a resource must remain pending without inventing readiness'); + assert(detached.defaultView===null && detached.hidden,'play must not associate a synthetic visible Window'); + pause(callee,inactive);await abort(owner,promise); + assert(eventRealms.length===2 && eventRealms.every(Boolean),'windowless events must use the media object global'); + }], + ['unsupported source rejects play',async(owner,callee,media,kind,ownerName,calleeName)=>{ + await once(media,'error',()=>{media.src=__mediaPlaybackUnsupportedURL+'/'+ownerName+'-'+calleeName+'-'+kind;}); + assert(media.error && media.error.code===4,'unsupported source must expose its native media error'); + let error;try{await play(callee,media);}catch(value){error=value;} + assert(error instanceof owner.DOMException && error.name==='NotSupportedError','unsupported source must reject in media realm'); + assert(media.paused,'rejected unsupported play must retain paused state'); + }], + ]; + try { + const realms=[['main',globalThis],['iframe',document.querySelector('iframe').contentWindow]]; + for(const [ownerName,owner] of realms)for(const [calleeName,callee] of realms)for(const kind of ['audio','video']) + for(const [name,body] of cases){ + const media=owner.document.createElement(kind);media.muted=true;owner.document.body.appendChild(media); + const label=`${ownerName}/${calleeName}/${kind}/${name}`;progress.stage=label; + let timeout; + try{await Promise.race([body(owner,callee,media,kind,ownerName,calleeName),new Promise((_,reject)=>{timeout=setTimeout(()=>reject(Error('playback case timeout')),2500);})]);checks.push({name:label,passed:true});} + catch(error){checks.push({name:label,passed:false,detail:String(error)});} + finally{clearTimeout(timeout);media.remove();media.removeAttribute('src');media.load();} + } + }catch(error){checks.push({name:'media playback setup',passed:false,detail:String(error)});} + globalThis.__uiEventResults={checks,total:checks.length}; +})() diff --git a/moli-renderer-v8/tests/fixtures/media/LICENSE.md b/moli-renderer-v8/tests/fixtures/media/LICENSE.md new file mode 100644 index 00000000000..39c46d03ac2 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media/LICENSE.md @@ -0,0 +1,11 @@ +# The 3-Clause BSD License + +Copyright © web-platform-tests contributors + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/moli-renderer-v8/tests/fixtures/media/README.md b/moli-renderer-v8/tests/fixtures/media/README.md new file mode 100644 index 00000000000..416f860967d --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media/README.md @@ -0,0 +1,3 @@ +These two unmodified media samples come from web-platform-tests/media at snapshot db95fafd1fcef8428805e41eb5705d444e8c67ce, under the WPT three-clause BSD license. They exercise real media sources in the shared native/Chromium playback contract. + +Source: https://github.com/web-platform-tests/wpt/tree/db95fafd1fcef8428805e41eb5705d444e8c67ce/media diff --git a/moli-renderer-v8/tests/fixtures/media/movie_5.webm b/moli-renderer-v8/tests/fixtures/media/movie_5.webm new file mode 100644 index 00000000000..9ae12e84ea5 Binary files /dev/null and b/moli-renderer-v8/tests/fixtures/media/movie_5.webm differ diff --git a/moli-renderer-v8/tests/fixtures/media/sound_5.oga b/moli-renderer-v8/tests/fixtures/media/sound_5.oga new file mode 100644 index 00000000000..239ad2bd08c Binary files /dev/null and b/moli-renderer-v8/tests/fixtures/media/sound_5.oga differ