From ca284c1092a98059cd849bb3cb95297b38f48905 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Thu, 15 Oct 2026 15:38:29 +0800 Subject: [PATCH] fix(media): queue playback events and preserve pending play requests Keep pending play requests in native element state and settle them through owned media tasks. Preserve media object Promise realms and complete queued settlements before load discards events. Reject failed requests in the error task, and reject stale playback epochs before any task-end checkpoint. Defer resource selection and removal checks to stable state and restart media when its Document changes. Cover main/iframe calls, windowless media, shadow-tree adoption, and captured-task cancellation without draining timers or unrelated script work. --- .../src/document_runtime/dom_facade.rs | 12 +- .../mutation_commands/tree/resources.rs | 4 + .../src/native_bridge/context_host/core.rs | 1 + .../context_host/media_element_events.rs | 19 +- .../native_bridge/context_host/media_loads.rs | 1 + .../context_host/media_playback.rs | 639 ++++++++++++++++++ .../src/native_bridge/context_host/mod.rs | 2 + moli-renderer-v8/src/native_bridge/element.rs | 13 +- .../src/native_bridge/element/media.rs | 3 +- .../native_bridge/element/media/attributes.rs | 130 ++-- .../native_bridge/element/media/methods.rs | 45 +- .../page_task_queue/media_element_event.rs | 1 + .../page_vm/tests/media_element_event.rs | 177 +++++ .../src/script_vm/tests/browser_api/media.rs | 68 +- .../detached_document_and_element_surfaces.rs | 32 +- .../extracted/main_document_lifecycle.rs | 4 + .../tests/extracted/resources_and_media.rs | 2 + .../tests/fixtures/media-playback-state.js | 152 +++++ .../tests/fixtures/media/LICENSE.md | 11 + .../tests/fixtures/media/README.md | 3 + .../tests/fixtures/media/movie_5.webm | Bin 0 -> 44447 bytes .../tests/fixtures/media/sound_5.oga | Bin 0 -> 18541 bytes 22 files changed, 1219 insertions(+), 100 deletions(-) create mode 100644 moli-renderer-v8/src/native_bridge/context_host/media_playback.rs create mode 100644 moli-renderer-v8/tests/fixtures/media-playback-state.js create mode 100644 moli-renderer-v8/tests/fixtures/media/LICENSE.md create mode 100644 moli-renderer-v8/tests/fixtures/media/README.md create mode 100644 moli-renderer-v8/tests/fixtures/media/movie_5.webm create mode 100644 moli-renderer-v8/tests/fixtures/media/sound_5.oga 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 0000000000000000000000000000000000000000..9ae12e84ea5874b4bdc858373a9857a242c8fc82 GIT binary patch literal 44447 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 G^Zx+4%(09B literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..239ad2bd08c21ca783b83cd0245951fecdab6a64 GIT binary patch literal 18541 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 literal 0 HcmV?d00001