diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/document.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/document.rs index 89e6f9a36b8..85023d4b84e 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/document.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/child_frame_runtime/document.rs @@ -706,7 +706,7 @@ impl PageScriptHost { host.cancel_child_meta_refresh_navigation(child_handle); host.cancel_stylesheet_subresource_fetches_for_document_owner(retired_owner); host.retire_image_state_for_document(document_handle); - host.cancel_pending_media_loads_for_document(document_handle); + host.cancel_pending_media_load_sequences_for_document(document_handle); host.cancel_pending_text_track_loads_for_document(document_handle); host.cancel_child_document_script_work_for_owner(child_handle, retired_owner); host.child_document_parsers 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 13387b7004f..50d6841ba11 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/core.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs @@ -747,7 +747,7 @@ impl PageScriptHost { let retired_image_event_count = self.retire_image_state_for_document(retired_document_handle); let retired_media_load_count = - self.cancel_pending_media_loads_for_document(retired_document_handle); + self.cancel_pending_media_load_sequences_for_document(retired_document_handle); let retired_text_track_load_count = self.cancel_pending_text_track_loads_for_document(retired_document_handle); let retired_stylesheet_subresource_count = self 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 8f4689b39ce..7b1f3646b42 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 @@ -1,5 +1,5 @@ -use super::window_document_tasks::{ExactWindowDocumentTaskLedger, PendingExactWindowDocumentTask}; -use super::{MediaLoadSequenceId, PageScriptHost, WindowDocumentTaskTarget}; +use super::window_document_tasks::{PendingWindowTask, WindowTaskLedger}; +use super::{MediaLoadSequenceId, PageScriptHost, WindowTaskTarget}; use crate::{ document_runtime::DomHandle, native_bridge::element::MediaLoadEventPhase, @@ -31,10 +31,18 @@ pub(super) enum PendingMediaElementEventPayload { ), } -pub(super) type MediaElementEventState = ExactWindowDocumentTaskLedger< +pub(super) type MediaElementEventState = WindowTaskLedger< RendererPageMediaElementEventTaskId, RendererPageMediaElementEventTaskKind, PendingMediaElementEventPayload, + WindowTaskTarget, +>; + +pub(super) type PendingMediaElementEvent = PendingWindowTask< + RendererPageMediaElementEventTaskId, + RendererPageMediaElementEventTaskKind, + PendingMediaElementEventPayload, + WindowTaskTarget, >; impl PageScriptHost { @@ -137,7 +145,7 @@ impl PageScriptHost { pub(super) fn queue_media_element_event_for_target( &mut self, - target: WindowDocumentTaskTarget, + target: WindowTaskTarget, kind: RendererPageMediaElementEventTaskKind, payload: PendingMediaElementEventPayload, ) -> bool { @@ -145,7 +153,7 @@ impl PageScriptHost { .media_element_events .allocate_task_id(RendererPageMediaElementEventTaskId::from_raw); self.media_element_events - .push(PendingExactWindowDocumentTask::new( + .push(PendingMediaElementEvent::new( task_id, target, kind, payload, )); if self @@ -174,10 +182,7 @@ impl PageScriptHost { pub(crate) fn current_pending_media_element_event_task( &self, task_id: RendererPageMediaElementEventTaskId, - ) -> Option<( - WindowDocumentTaskTarget, - RendererPageMediaElementEventTaskKind, - )> { + ) -> Option<(WindowTaskTarget, RendererPageMediaElementEventTaskKind)> { let pending = self.media_element_events.pending(task_id)?; if let PendingMediaElementEventPayload::Playback(task) = pending.payload() && !task.is_current(self) @@ -189,6 +194,15 @@ impl PageScriptHost { { return None; } + if let PendingMediaElementEventPayload::LoadEventPhase { + media_handle, + sequence, + .. + } = pending.payload() + && !self.pending_media_load_sequence_is_current(*media_handle, *sequence) + { + return None; + } if let PendingMediaElementEventPayload::SeekCompletion { media_handle, seek_token, @@ -202,10 +216,11 @@ impl PageScriptHost { { return None; } - let current_target = self.current_window_document_task_target_for_dispatch_scope( + self.window_execution_context_owner_is_current( + pending.target().owner(), pending.target().dispatch_scope(), - )?; - Some((current_target, pending.kind())) + ) + .then_some((pending.target(), pending.kind())) } /// Consume one already-authorized event before dispatch. Reentrant media @@ -215,15 +230,14 @@ impl PageScriptHost { scope: &mut v8::PinScope<'_, '_>, host_ptr: *mut PageScriptHost, task_id: RendererPageMediaElementEventTaskId, - target: WindowDocumentTaskTarget, + target: WindowTaskTarget, kind: RendererPageMediaElementEventTaskKind, ) -> Option { let payload = self .media_element_events .remove_exact(task_id, target, kind)? .into_payload(); - let Some(resolved) = self.resolve_authorized_window_document_task_context(scope, target) - else { + let Some(resolved) = self.resolve_media_element_task_context(scope, target) else { self.retire_media_element_event_payload(payload); return Some(false); }; 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 6e787257305..af4dc9ff11e 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 @@ -97,7 +97,11 @@ impl PageScriptHost { } } }; - let task_target = self.media_element_task_target(scope, media_handle); + let task_target = self + .media_element_task_target(scope, media_handle) + .and_then(|target| { + self.current_window_document_task_target_for_dispatch_scope(target.dispatch_scope()) + }); let task_document_handle = task_target.and_then(|target| { self.resolve_authorized_window_document_task_context(scope, target) .map(|resolved| resolved.document_handle) @@ -345,6 +349,13 @@ impl PageScriptHost { document_handle: DomHandle, ) -> usize { self.retire_media_playback_for_document(document_handle); + self.cancel_pending_media_load_sequences_for_document(document_handle) + } + + pub(crate) fn cancel_pending_media_load_sequences_for_document( + &mut self, + document_handle: DomHandle, + ) -> usize { let handles = self .pending_media_load_sequences .iter() @@ -355,6 +366,16 @@ impl PageScriptHost { }) .collect::>(); for handle in &handles { + // Metadata selects a resource independently of its queued load phases. + // A ready event can reenter document.open() before its sequence retires. + if self + .dom_host() + .node(*handle) + .and_then(Node::as_element) + .is_none_or(|element| element.media_ready_state() == 0) + { + self.retire_media_playback_for_element(*handle); + } if let Some(pending) = self.take_pending_media_load_sequence(*handle) { let _ = self.settle_pending_media_load_sequence(pending, false); } 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 index d25f6f1dcc4..00f8f0380b9 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs @@ -1,6 +1,6 @@ //! 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. +//! element's LocalWindow, independently of parser replacement. use std::{ cell::Cell, @@ -8,7 +8,7 @@ use std::{ rc::{Rc, Weak}, }; -use super::{PageScriptHost, WindowDocumentTaskTarget}; +use super::{PageScriptHost, WindowTaskTarget}; use crate::{ document_runtime::DomHandle, native_bridge::element, @@ -72,7 +72,7 @@ impl PlayPromise { struct PlaybackElementState { document: DomHandle, - target: Option, + target: Option, task_document: Option, epoch: u64, can_autoplay: bool, @@ -124,7 +124,7 @@ struct StableWork { media: DomHandle, document: DomHandle, task_document: DomHandle, - target: WindowDocumentTaskTarget, + target: WindowTaskTarget, epoch: u64, operation: StableOperation, } @@ -294,6 +294,21 @@ impl PageScriptHost { } } + pub(super) fn retire_media_playback_for_element(&mut self, media: DomHandle) { + self.stop_media_clock(media); + self.cancel_media_video_resource(media); + if let Some(state) = self.media_playback.elements.get_mut(&media) { + // Keep the epoch monotonic if author code immediately reuses this node. + *state = PlaybackElementState::new( + state.document, + state.epoch.checked_add(1).expect("media epoch overflow"), + ); + } + self.media_playback + .stable_work + .retain(|_, work| work.media != media); + } + pub(crate) fn retire_media_playback_for_document(&mut self, document: DomHandle) { let clocks = self .media_playback @@ -324,9 +339,7 @@ impl PageScriptHost { ) -> 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) - } + Some(dispatch_scope) => self.current_media_window_task_target(dispatch_scope), None => { // A windowless Document is not an active browsing context, but its // platform objects still have a relevant global for event tasks. @@ -334,15 +347,16 @@ impl PageScriptHost { return false; }; let scope = &mut v8::ContextScope::new(scope, context); - self.current_renderer_window_document_source(scope) - .map(|source| source.0) + self.current_runtime_window_execution_context_identity(scope) + .map(|identity| { + WindowTaskTarget::new(identity.dispatch_scope(), identity.owner()) + }) } }; let Some(target) = target else { return false; }; - let Some(resolved) = self.resolve_authorized_window_document_task_context(scope, target) - else { + let Some(resolved) = self.resolve_media_element_task_context(scope, target) else { return false; }; let Some(state) = self.media_playback_state_for(media) else { @@ -353,13 +367,37 @@ impl PageScriptHost { true } + pub(super) fn current_media_window_task_target( + &self, + dispatch_scope: super::OwnerDispatchScope, + ) -> Option { + Some(WindowTaskTarget::new( + dispatch_scope, + self.current_window_execution_context_owner(dispatch_scope)?, + )) + } + + pub(super) fn resolve_media_element_task_context<'s>( + &mut self, + scope: &mut v8::PinScope<'s, '_>, + target: WindowTaskTarget, + ) -> Option> { + if !self.window_execution_context_owner_is_current(target.owner(), target.dispatch_scope()) + { + return None; + } + let document_target = + self.current_window_document_task_target_for_dispatch_scope(target.dispatch_scope())?; + self.resolve_authorized_window_document_task_context(scope, document_target) + } + pub(super) fn media_element_task_target( &mut self, scope: &mut v8::PinScope<'_, '_>, media: DomHandle, - ) -> Option { + ) -> 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); + return self.current_media_window_task_target(dispatch_scope); } if let Some(target) = self .media_playback @@ -372,8 +410,8 @@ impl PageScriptHost { let context = crate::native_bridge::node_owner_document_relevant_context(scope, self, media)?; let scope = &mut v8::ContextScope::new(scope, context); - self.current_renderer_window_document_source(scope) - .map(|source| source.0) + self.current_runtime_window_execution_context_identity(scope) + .map(|identity| WindowTaskTarget::new(identity.dispatch_scope(), identity.owner())) } fn queue_playback( @@ -647,7 +685,7 @@ impl PageScriptHost { operation: StableOperation, ) -> Option { let target = self.media_element_task_target(scope, media)?; - let resolved = self.resolve_authorized_window_document_task_context(scope, target)?; + let resolved = self.resolve_media_element_task_context(scope, target)?; let task_document = resolved.document_handle; let state = self.media_playback_state_for(media)?; state.target = Some(target); @@ -684,9 +722,8 @@ impl PageScriptHost { 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) + || self.current_media_window_task_target(work.target.dispatch_scope()) + != Some(work.target) { return; } diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs b/moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs index 62ebef2c0e4..9c55768c5bb 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs @@ -2,8 +2,8 @@ use super::*; use crate::{ document_runtime::DocumentRuntime, native_bridge::context_host::{ + media_element_events::PendingMediaElementEvent, media_element_events::PendingMediaElementEventPayload, - window_document_tasks::PendingExactWindowDocumentTask, }, }; use std::time::{Duration, Instant}; @@ -202,12 +202,12 @@ impl PageScriptHost { let Some(target) = state.target else { return; }; - if self.current_window_document_task_target_for_dispatch_scope(target.dispatch_scope()) - != Some(target) - { + if self.current_media_window_task_target(target.dispatch_scope()) != Some(target) { return; } - let Some(loader) = self.document_resource_loader_for_window_owner(target.owner()) else { + let Some(loader) = + self.document_resource_loader_for_dispatch_scope(target.dispatch_scope()) + else { return; }; let task_id = self @@ -222,7 +222,7 @@ impl PageScriptHost { }; let kind = RendererPageMediaElementEventTaskKind::Playback; self.media_element_events - .push(PendingExactWindowDocumentTask::new( + .push(PendingMediaElementEvent::new( task_id, target, kind, diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs b/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs index 8422f266bbb..6221048d341 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs @@ -3,8 +3,8 @@ use super::super::{ decode_budget::{DecodeJobPermit, DecodedBytesPermit}, + media_element_events::PendingMediaElementEvent, media_element_events::PendingMediaElementEventPayload, - window_document_tasks::PendingExactWindowDocumentTask, }; use super::*; use parking_lot::Mutex; @@ -56,7 +56,7 @@ struct DecodeRequest { position: f64, cancelled: Arc, completion: Completion, - target: WindowDocumentTaskTarget, + target: WindowTaskTarget, id: RendererPageMediaElementEventTaskId, } @@ -221,7 +221,7 @@ pub(in crate::native_bridge::context_host) struct MediaVideoDecodeTask { media: DomHandle, document: DomHandle, epoch: u64, - target: WindowDocumentTaskTarget, + target: WindowTaskTarget, id: RendererPageMediaElementEventTaskId, position: f64, completion: Completion, @@ -277,11 +277,11 @@ impl PageScriptHost { .media_element_task_target(scope, media) .ok_or(moli_media::VideoError::Empty)?; let task_document = self - .resolve_authorized_window_document_task_context(scope, target) + .resolve_media_element_task_context(scope, target) .ok_or(moli_media::VideoError::Empty)? .document_handle; let loader = self - .document_resource_loader_for_window_owner(target.owner()) + .document_resource_loader_for_dispatch_scope(target.dispatch_scope()) .ok_or(moli_media::VideoError::Empty)?; let permit = self .media_playback @@ -350,9 +350,7 @@ impl PageScriptHost { self.media_element_events.remove(previous.id); } let Some(target) = state.target else { return }; - if self.current_window_document_task_target_for_dispatch_scope(target.dispatch_scope()) - != Some(target) - { + if self.current_media_window_task_target(target.dispatch_scope()) != Some(target) { self.cancel_media_video_resource(media); return; } @@ -377,7 +375,7 @@ impl PageScriptHost { completion: completion.clone(), }; self.media_element_events - .push(PendingExactWindowDocumentTask::new( + .push(PendingMediaElementEvent::new( id, target, RendererPageMediaElementEventTaskKind::Playback, @@ -507,9 +505,8 @@ impl MediaVideoDecodeTask { .and_then(|state| state.video.as_ref()) .and_then(|video| video.pending.as_ref()) .is_some_and(|pending| pending.id == self.id) - && host.current_window_document_task_target_for_dispatch_scope( - self.target.dispatch_scope(), - ) == Some(self.target) + && host.current_media_window_task_target(self.target.dispatch_scope()) + == Some(self.target) } pub(in crate::native_bridge::context_host) fn is_current(&self, host: &PageScriptHost) -> bool { 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 9bdefed45f7..fb881ed14a2 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 @@ -1,13 +1,10 @@ -use crate::runtime::PageOwnerTurnOutcome; - -use super::{ - PageWindowDocumentTaskTargetEffect, PageWindowDocumentTaskTurnAction, - RendererPageWindowDocumentTask, RendererPageWindowDocumentTaskOwner, - window_document_task_source::{ - RendererPageWindowDocumentTaskRoute, RendererPageWindowDocumentTaskSender, - RendererPageWindowDocumentTaskSource, - }, +use super::{RendererOwnerWakeSender, RendererOwnerWakeSource, RendererPageTaskReadySignal}; +use crate::{ + native_bridge::WindowTaskTarget, + resource_ready::{ReadyPageTask, RendererPageTaskReadyMetadata}, + runtime::{PageOwnerTurnOutcome, RendererDocumentToken}, }; +use moli_owner_queue::{OwnerReadyTaskRoute, OwnerReadyTaskSource}; /// Host-local key for one payload in the HTML media-element event task source. #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] @@ -35,29 +32,213 @@ pub(crate) enum RendererPageMediaElementEventTaskKind { RemotePlaybackAvailability, } -pub(crate) type RendererPageMediaElementEventOwner = RendererPageWindowDocumentTaskOwner; -pub(crate) type RendererPageMediaElementEventTask = RendererPageWindowDocumentTask< - RendererPageMediaElementEventTaskId, - RendererPageMediaElementEventTaskKind, ->; -pub(super) type RendererPageMediaElementEventRoute = RendererPageWindowDocumentTaskRoute< - RendererPageMediaElementEventTaskId, - RendererPageMediaElementEventTaskKind, ->; -pub(crate) type RendererPageMediaElementEventSender = RendererPageWindowDocumentTaskSender< - RendererPageMediaElementEventTaskId, - RendererPageMediaElementEventTaskKind, ->; -pub(super) type RendererPageMediaElementEventSource = RendererPageWindowDocumentTaskSource< - RendererPageMediaElementEventTaskId, - RendererPageMediaElementEventTaskKind, ->; +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct RendererPageMediaElementEventOwner { + root_document: RendererDocumentToken, + target: WindowTaskTarget, +} -pub(crate) type PageMediaElementEventTargetEffect = PageWindowDocumentTaskTargetEffect; -pub(crate) type PageMediaElementEventTurnAction = PageWindowDocumentTaskTurnAction< - RendererPageMediaElementEventTaskId, - RendererPageMediaElementEventTaskKind, ->; +impl RendererPageMediaElementEventOwner { + pub(crate) const fn new( + root_document: RendererDocumentToken, + target: WindowTaskTarget, + ) -> Self { + Self { + root_document, + target, + } + } + + pub(crate) const fn root_document(self) -> RendererDocumentToken { + self.root_document + } + + pub(crate) const fn target(self) -> WindowTaskTarget { + self.target + } +} + +/// Scheduler envelope for a concrete captured LocalWindow task whose mutable +/// V8/DOM payload remains in the creating `PageScriptHost` ledger. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct RendererPageMediaElementEventTask { + owner: RendererPageMediaElementEventOwner, + task_id: RendererPageMediaElementEventTaskId, + kind: RendererPageMediaElementEventTaskKind, +} + +impl RendererPageMediaElementEventTask { + pub(crate) const fn new( + owner: RendererPageMediaElementEventOwner, + task_id: RendererPageMediaElementEventTaskId, + kind: RendererPageMediaElementEventTaskKind, + ) -> Self { + Self { + owner, + task_id, + kind, + } + } + + pub(crate) const fn owner(&self) -> RendererPageMediaElementEventOwner { + self.owner + } + + pub(crate) const fn task_id(&self) -> RendererPageMediaElementEventTaskId { + self.task_id + } + + pub(crate) const fn kind(&self) -> RendererPageMediaElementEventTaskKind { + self.kind + } +} + +/// Common settlement of one captured LocalWindow event task. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) enum PageMediaElementEventTargetEffect { + DispatchedToCurrentOwner, + CurrentOwnerHadNoEventTarget, + DiscardedStaleOwner { + current_owner: Option, + }, +} + +/// Common owner-turn fact emitted after a captured LocalWindow task settles. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct PageMediaElementEventTurnAction { + pub(crate) owner: RendererPageMediaElementEventOwner, + pub(crate) task_id: RendererPageMediaElementEventTaskId, + pub(crate) kind: RendererPageMediaElementEventTaskKind, + pub(crate) target_effect: PageMediaElementEventTargetEffect, +} + +/// Media task route carrying a captured LocalWindow owner, a Host-local payload id, and a family-local +/// operation kind. +/// +/// Mutable DOM/V8 payloads remain in the creating `PageScriptHost`; this route +/// carries the immutable scheduler envelope and publishes one empty-to-nonempty +/// readiness edge. +#[derive(Clone, Debug)] +pub(crate) struct RendererPageMediaElementEventRoute { + task_route: OwnerReadyTaskRoute< + ReadyPageTask, + RendererPageTaskReadySignal, + >, +} + +impl RendererPageMediaElementEventRoute { + pub(crate) fn sender( + &self, + root_document: RendererDocumentToken, + ) -> RendererPageMediaElementEventSender { + RendererPageMediaElementEventSender::new(self.clone(), root_document) + } + + fn send( + &self, + task: RendererPageMediaElementEventTask, + ) -> Result<(), RendererPageMediaElementEventRouteClosed> { + self.task_route + .send_and_signal_if_newly_ready(ReadyPageTask::new(task)) + .map_err(|_| RendererPageMediaElementEventRouteClosed) + } + + fn same_source_as(&self, source: &RendererPageMediaElementEventSource) -> bool { + self.task_route.same_source_as(&source.source) + } +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct RendererPageMediaElementEventRouteClosed; + +/// PageVm-stamped producer capability for a LocalWindow task-source +/// family. A producer cannot choose another root Page namespace. +#[derive(Clone, Debug)] +pub(crate) struct RendererPageMediaElementEventSender { + route: RendererPageMediaElementEventRoute, + root_document: RendererDocumentToken, +} + +impl RendererPageMediaElementEventSender { + pub(crate) fn new( + route: RendererPageMediaElementEventRoute, + root_document: RendererDocumentToken, + ) -> Self { + Self { + route, + root_document, + } + } + + pub(crate) fn send( + &self, + target: WindowTaskTarget, + task_id: RendererPageMediaElementEventTaskId, + kind: RendererPageMediaElementEventTaskKind, + ) -> Result<(), RendererPageMediaElementEventRouteClosed> { + self.route.send(RendererPageMediaElementEventTask::new( + RendererPageMediaElementEventOwner::new(self.root_document, target), + task_id, + kind, + )) + } +} + +/// Unique Page-lifetime consumer for one captured LocalWindow task-source +/// family. +#[derive(Debug)] +pub(crate) struct RendererPageMediaElementEventSource { + source: OwnerReadyTaskSource< + ReadyPageTask, + RendererPageTaskReadySignal, + >, +} + +impl RendererPageMediaElementEventSource { + pub(crate) fn new( + owner_wake: RendererOwnerWakeSender, + source: RendererOwnerWakeSource, + ) -> Self { + Self { + source: OwnerReadyTaskSource::new(RendererPageTaskReadySignal::new(owner_wake, source)), + } + } + + pub(crate) fn route(&self) -> RendererPageMediaElementEventRoute { + RendererPageMediaElementEventRoute { + task_route: self.source.route(), + } + } + + pub(crate) fn next_ready_metadata(&mut self) -> Option { + self.source.front().map(ReadyPageTask::metadata) + } + + pub(crate) fn next_ready_owner(&mut self) -> Option { + self.source.front().map(|ready| ready.value().owner()) + } + + pub(crate) fn pop_front( + &mut self, + ) -> Option<( + RendererPageTaskReadyMetadata, + RendererPageMediaElementEventTask, + )> { + self.source.pop_front().map(ReadyPageTask::into_parts) + } + + pub(crate) fn has_ready_task(&mut self) -> bool { + !self.source.is_empty() + } + + pub(crate) fn clear(&mut self) { + self.source.clear_local(); + } + + pub(crate) fn route_matches(&self, route: &RendererPageMediaElementEventRoute) -> bool { + route.same_source_as(self) + } +} pub(crate) type PageMediaElementEventTurnOutcome = PageOwnerTurnOutcome; @@ -66,10 +247,8 @@ mod tests { use super::*; use crate::{ PageId, - frame_owner_model::{ - DocumentId, FrameDocumentTaskOwner, FrameSchedulerLaneId, LocalWindowId, - }, - native_bridge::{OwnerDispatchScope, WindowDocumentOwner, WindowDocumentTaskTarget}, + frame_owner_model::LocalWindowId, + native_bridge::{OwnerDispatchScope, WindowExecutionContextOwner, WindowTaskTarget}, page_task_queue::{RendererOwnerWake, RendererOwnerWakeSender, RendererOwnerWakeSource}, runtime::{RendererDocumentToken, RendererPageToken}, }; @@ -78,14 +257,10 @@ mod tests { RendererDocumentToken::new_for_testing(PageId::new_for_testing(81), 4) } - fn target(document_id: u64) -> WindowDocumentTaskTarget { - WindowDocumentTaskTarget::new( - WindowDocumentOwner::Frame(FrameDocumentTaskOwner::new( - FrameSchedulerLaneId(12), - LocalWindowId(13), - DocumentId(document_id), - )), + fn target(local_window_id: u64) -> WindowTaskTarget { + WindowTaskTarget::new( OwnerDispatchScope::Top, + WindowExecutionContextOwner::Frame(LocalWindowId(local_window_id)), ) } diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs index 672c584f086..b8dfd9f358a 100644 --- a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs +++ b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs @@ -1208,9 +1208,11 @@ impl MediaElementEventLane { fn enqueue_with(sender: &RendererPageMediaElementEventSender, sequence: u64) -> bool { sender .send( - WindowDocumentTaskTarget::new( - WindowDocumentOwner::Frame(task_owner(sequence + 1_650)), + crate::native_bridge::WindowTaskTarget::new( OwnerDispatchScope::Top, + crate::native_bridge::WindowExecutionContextOwner::Frame( + task_owner(sequence + 1_650).local_window_id, + ), ), RendererPageMediaElementEventTaskId::from_raw(sequence), match sequence % 4 { diff --git a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs index 571b0177464..64b8ea70be6 100644 --- a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs +++ b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs @@ -677,13 +677,11 @@ mod tests { ready: ready_metadata(ready_at, order), owner: RendererPageMediaElementEventOwner::new( RendererDocumentToken::new_for_testing(crate::PageId::new_for_testing(1), 1), - WindowDocumentTaskTarget::new( - WindowDocumentOwner::Frame(FrameDocumentTaskOwner::new( - FrameSchedulerLaneId(order), - LocalWindowId(order + 1), - DocumentId(order + 2), - )), + crate::native_bridge::WindowTaskTarget::new( OwnerDispatchScope::Top, + crate::native_bridge::WindowExecutionContextOwner::Frame(LocalWindowId( + order + 1, + )), ), ), } diff --git a/moli-renderer-v8/src/runtime/page_vm/page_media_element_event.rs b/moli-renderer-v8/src/runtime/page_vm/page_media_element_event.rs index b14c8b8d513..faef4f20bbe 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_media_element_event.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_media_element_event.rs @@ -5,9 +5,7 @@ use crate::page_task_queue::{ RendererPageMediaElementEventTaskKind, }; -use super::{ - AuthorizedCurrentWindowDocumentTask, IntoPageTaskCompletion, PageTaskCompletion, PageVm, -}; +use super::{IntoPageTaskCompletion, PageTaskCompletion, PageVm}; impl IntoPageTaskCompletion for PageMediaElementEventTurnAction { fn into_page_task_completion(self) -> PageTaskCompletion { @@ -25,10 +23,14 @@ impl IntoPageTaskCompletion for PageMediaElementEventTurnAction { } } -/// Proof that the Page arbiter matched the PageVm namespace, exact Document, +/// Proof that the Page arbiter matched the PageVm namespace, LocalWindow, /// Host-local payload id, and media-event operation before V8 application. -pub(crate) type AuthorizedCurrentPageMediaElementEvent = - AuthorizedCurrentWindowDocumentTask; +pub(crate) struct AuthorizedCurrentPageMediaElementEvent(RendererPageMediaElementEventTask); +impl AuthorizedCurrentPageMediaElementEvent { + pub(crate) fn into_task(self) -> RendererPageMediaElementEventTask { + self.0 + } +} impl PageVm { fn current_page_media_element_event_owner( @@ -52,34 +54,25 @@ impl PageVm { let task_id = task.task_id(); let kind = task.kind(); let current = self.current_page_media_element_event_owner(task_id); - let target_effect = - match self.authorize_current_window_document_task(task, owner, kind, current) { - Ok(authorization) => { - if self - .vm_mut() - .apply_current_media_element_event_body(authorization)? - { - PageMediaElementEventTargetEffect::DispatchedToCurrentOwner - } else { - PageMediaElementEventTargetEffect::CurrentOwnerHadNoEventTarget - } - } - Err(stale) => { - if stale.may_discard_local_payload() { - self.vm_mut() - .discard_stale_media_element_event_task(task_id); - } - let current_owner = stale.current_owner(); - tracing::debug!( - ?owner, - ?current_owner, - ?task_id, - ?kind, - "discarded stale exact-Document media-element event" - ); - PageMediaElementEventTargetEffect::DiscardedStaleOwner { current_owner } - } - }; + let target_effect = if current == Some((owner, kind)) { + let authorization = AuthorizedCurrentPageMediaElementEvent(task); + if self + .vm_mut() + .apply_current_media_element_event_body(authorization)? + { + PageMediaElementEventTargetEffect::DispatchedToCurrentOwner + } else { + PageMediaElementEventTargetEffect::CurrentOwnerHadNoEventTarget + } + } else { + if owner.root_document() == self.document_lifecycle.identity().document { + self.vm_mut() + .discard_stale_media_element_event_task(task_id); + } + PageMediaElementEventTargetEffect::DiscardedStaleOwner { + current_owner: current.map(|(owner, _)| owner), + } + }; let action = PageMediaElementEventTurnAction { owner, task_id, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/canvas_video_frames.rs b/moli-renderer-v8/src/runtime/page_vm/tests/canvas_video_frames.rs index 0f5de55ad37..3d246c66b8d 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/canvas_video_frames.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/canvas_video_frames.rs @@ -183,6 +183,9 @@ decodeMedia.load(); "load" => "decodeMedia.removeAttribute('src'); decodeMedia.load();", _ => "document.open(); document.write('replacement'); document.close();", })?; + // Rebind the same element before consuming the captured decoder task. + // Its retired resource epoch must never become current again. + page.vm_mut().eval("decodeMedia.volume = 0.25")?; page.vm_mut().eval_without_microtask_checkpoint_for_test(r#" globalThis.unrelatedVideoWork = []; Promise.resolve().then(() => unrelatedVideoWork.push('microtask')); diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/media_document_open.rs b/moli-renderer-v8/src/runtime/page_vm/tests/media_document_open.rs new file mode 100644 index 00000000000..62004457c6e --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/media_document_open.rs @@ -0,0 +1,70 @@ +use super::*; +use base64::Engine; + +#[tokio::test(flavor = "current_thread")] +async fn media_document_open_retains_resource_events_history_and_clock() { + run_page_vm_async_test(async move { + let video: &[u8] = include_bytes!("../../../../../moli-media/tests/fixtures/counting.webm"); + let audio: &[u8] = include_bytes!("../../../../tests/fixtures/media/sound_5.oga"); + let listener = TcpListener::bind("127.0.0.1:0").await?; + let base = format!("http://{}", listener.local_addr()?); + let server = tokio::spawn(async move { + loop { + let (mut stream, _) = listener.accept().await.expect("document.open fixture request"); + let request = read_http_request_head(&mut stream).await.expect("request head"); + let (body, mime) = if request.starts_with("GET /audio ") { + (audio, "audio/ogg") + } else { + assert!(request.starts_with("GET /video "), "{request}"); + (video, "video/webm") + }; + let header = format!( + "HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", + body.len() + ); + if stream.write_all(header.as_bytes()).await.is_ok() { + let _ = stream.write_all(body).await; + } + } + }); + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?; + for kind in [crate::types::SubresourceResourceType::Audio, crate::types::SubresourceResourceType::Video] { + loader.set_optional_resource_fetch_enabled(kind, true); + } + let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, Url::parse(&base)?, + ); + page.vm_mut().set_layout_policy(moli_page_types::LayoutPolicy::Mock); + let sources = serde_json::json!({ + "data": { + "video": format!("data:video/webm;base64,{}", base64::engine::general_purpose::STANDARD.encode(video)), + "audio": format!("data:audio/ogg;base64,{}", base64::engine::general_purpose::STANDARD.encode(audio)), + }, + "http": {"video": format!("{base}/video"), "audio": format!("{base}/audio")}, + }); + page.vm_mut().eval(&format!( + "document.body.innerHTML='';globalThis.__mediaTimelineSources={sources};" + ))?; + page.vm_mut().eval(include_str!("../../../../tests/fixtures/media-document-open.js"))?; + let deadline = Instant::now() + Duration::from_secs(180); + 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?; + } + let _ = page.run_one_due_timer_selected_task_for_test(&loader).await?; + anyhow::ensure!(Instant::now() < deadline, "document.open fixture did not finish: {}", + page.vm_mut().eval("__mediaDefaultStartProgress.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(|check| check["passed"] != true).collect(); + assert!(failures.is_empty(), "{failures:#?}"); + assert_eq!(result["total"], 144); + Ok::<_, anyhow::Error>(()) + }).await.expect("document.open preserves media resources and Window task ownership"); +} 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 3b1744115df..b91b735182e 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 @@ -470,7 +470,7 @@ media.volume = 0.5; } #[tokio::test(flavor = "current_thread")] -async fn media_captured_volumechange_tasks_retire_without_checkpointing_other_work() { +async fn media_captured_volumechange_tasks_follow_resource_and_window_lifetimes() { run_page_vm_async_test(async move { for retire_document in [false, true] { let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()) @@ -497,14 +497,14 @@ globalThis.unrelatedVolumeWork = []; Promise.resolve().then(() => unrelatedVolumeWork.push('microtask')); setTimeout(() => unrelatedVolumeWork.push('timer'), 0); "#)?; - page.vm_mut().enqueue_test_pending_runtime_source_load(); + if !retire_document { 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( "retiredVolumeEvents.join('|') + ':' + unrelatedVolumeWork.join('|')", - )?, ":", "a retired notification must not dispatch or checkpoint"); + )?, if retire_document { "stale event:microtask" } else { ":" }, "Window tasks survive document.open; load resets retire the resource task"); assert!(page.vm().has_ready_timeout()); assert_eq!(page.vm().document_runtime.runtime_script_work().dynamic_scripts - .pending_source_load_count_for_test(), 1); + .pending_source_load_count_for_test(), usize::from(!retire_document)); } Ok::<_, anyhow::Error>(()) }).await.expect("load and Document retirement isolate captured volume notifications"); @@ -677,14 +677,14 @@ globalThis.unrelatedPlaybackWork = []; Promise.resolve().then(() => unrelatedPlaybackWork.push('microtask')); setTimeout(() => unrelatedPlaybackWork.push('timer'), 0); "#)?; - page.vm_mut().enqueue_test_pending_runtime_source_load(); + if !retire_document { 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"); + )?, if retire_document { "play|fulfilled:".to_owned() + "microtask" } else { format!("{expected}:") }, "Window-owned playing promises survive document.open, while load resets retire their tasks"); 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"); + .pending_source_load_count_for_test(), usize::from(!retire_document), "stale media work must not advance script work"); } Ok::<_, anyhow::Error>(()) }).await.expect("captured playing requests obey load epochs and exact Document ownership"); @@ -964,7 +964,7 @@ media.currentTime = 2; } #[tokio::test(flavor = "current_thread")] -async fn media_event_is_document_exact_across_document_open() { +async fn media_events_retain_local_window_across_document_open() { run_page_vm_async_test(async move { let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader"); @@ -990,6 +990,9 @@ retiredMedia.currentTime = 1; document.open(); document.write("replacement"); document.close(); +for (const type of ["seeking", "seeked"]) { + retiredMedia.addEventListener(type, () => __documentExactMediaEvents.push(`current:${type}`)); +} "replaced" "#, )?; @@ -1017,7 +1020,6 @@ Promise.resolve().then(() => { "queued" "#, )?; - page_vm.vm_mut().enqueue_test_pending_runtime_source_load(); for expected_kind in [ RendererPageMediaElementEventTaskKind::Seeking, @@ -1027,7 +1029,7 @@ Promise.resolve().then(() => { .claim_exact_selected_page_task_for_test( PageSelectedTaskTestSelector::MediaElementEvent, ) - .expect("each retired media event should remain an exact source entry"); + .expect("each media event retains its original Window source entry"); assert_eq!( stale .media_element_event_kind() @@ -1044,7 +1046,7 @@ Promise.resolve().then(() => { .eval_without_microtask_checkpoint_for_test( "__documentExactMediaEvents.join('|')", )?, - "" + "current:seeking" ); assert_eq!( page_vm @@ -1052,31 +1054,27 @@ Promise.resolve().then(() => { .eval_without_microtask_checkpoint_for_test( "__staleMediaCompletionBoundary.join('|')", )?, - "", - "retired media work must not checkpoint the replacement realm" + "microtask", + "a current Window task must retain its normal task-end checkpoint" ); + let seeked = page_vm + .claim_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, + ) + .expect("completed seek queues a separate notification"); + page_vm + .run_claimed_selected_page_task_for_test(seeked, &loader) + .await?; assert_eq!( page_vm - .vm() - .document_runtime - .runtime_script_work() - .dynamic_scripts - .pending_source_load_count_for_test(), - 1, - "retired media work must not advance replacement runtime residence" - ); - assert!( - page_vm - .claim_exact_selected_page_task_for_test( - PageSelectedTaskTestSelector::MediaElementEvent, - ) - .is_none(), - "the two retired events must consume exactly two source turns" + .vm_mut() + .eval("__documentExactMediaEvents.join('|')")?, + "current:seeking|current:seeked" ); Ok::<_, anyhow::Error>(()) }) .await - .expect("Document-exact media event test should run"); + .expect("Window-owned media event test should run"); } #[tokio::test(flavor = "current_thread")] @@ -1427,3 +1425,48 @@ if (coldVolumeConversions !== 1 || coldMedia.volume !== 0.7) throw Error('reentr .await .expect("cold writes and reentrant conversion use current native volume"); } + +#[tokio::test(flavor = "current_thread")] +async fn media_partial_selection_reuse_does_not_revive_captured_playback_tasks() { + use base64::Engine as _; + run_page_vm_async_test(async move { + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?; + let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake( + &loader, Url::parse("https://media-resource-epoch.test/")?, + ); + let audio = base64::engine::general_purpose::STANDARD.encode(include_bytes!( + "../../../../tests/fixtures/media/sound_5.oga" + )); + page.vm_mut().eval(&format!(r#" +globalThis.mediaEpochEvents = []; +globalThis.epochMedia = document.createElement('audio'); +epochMedia.src = 'data:audio/ogg;base64,{audio}'; +epochMedia.onvolumechange = () => mediaEpochEvents.push(epochMedia.volume); +epochMedia.volume = 0.5; +"#))?; + let captured = page.claim_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, + ).expect("capture the original resource's queued volumechange"); + assert_eq!(captured.media_element_event_kind(), Some(RendererPageMediaElementEventTaskKind::VolumeChange)); + page.vm_mut().eval(r#" +document.open(); document.write('replacement'); document.close(); +epochMedia.load(); +epochMedia.volume = 0.75; +"#)?; + page.vm_mut().eval_without_microtask_checkpoint_for_test( + "globalThis.mediaEpochCheckpoint = [];Promise.resolve().then(() => mediaEpochCheckpoint.push('microtask'));", + )?; + page.run_claimed_selected_page_task_for_test(captured, &loader).await?; + assert_eq!(page.vm_mut().eval_without_microtask_checkpoint_for_test( + "mediaEpochEvents.join('|') + ':' + mediaEpochCheckpoint.join('|')", + )?, ":", "reusing the element cannot revive the canceled resource's notification"); + let deadline = Instant::now() + Duration::from_secs(5); + while page.vm_mut().eval("mediaEpochEvents.length")? == "0" { + let _ = page.run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::MediaElementEvent, &loader).await?; + anyhow::ensure!(Instant::now() < deadline, "the new resource's notification must remain runnable"); + tokio::time::sleep(Duration::from_millis(1)).await; + } + assert_eq!(page.vm_mut().eval("mediaEpochEvents.join('|')")?, "0.75"); + Ok::<_, anyhow::Error>(()) + }).await.expect("resource epochs remain monotonic across cancellation and element reuse"); +} diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs b/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs index 291a0445ec7..62bf01315bf 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs @@ -94,11 +94,16 @@ globalThis.unrelatedClockWork = []; Promise.resolve().then(() => unrelatedClockWork.push('microtask')); setTimeout(() => unrelatedClockWork.push('timer'), 0); "#)?; - page.vm_mut().enqueue_test_pending_runtime_source_load(); + let survives = windowless && retire == "document"; + if !survives { 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("unrelatedClockWork.join('|')")?, "", "{windowless}/{retire}"); + assert_eq!(page.vm_mut().eval_without_microtask_checkpoint_for_test("unrelatedClockWork.join('|')")?, if survives { "microtask" } else { "" }, "{windowless}/{retire}"); assert!(page.vm().has_ready_timeout()); - assert_eq!(page.vm().document_runtime.runtime_script_work().dynamic_scripts.pending_source_load_count_for_test(), 1); + assert_eq!(page.vm().document_runtime.runtime_script_work().dynamic_scripts.pending_source_load_count_for_test(), usize::from(!survives)); + if survives { + assert_eq!(page.vm_mut().eval("!clockMedia.paused && clockMedia.currentTime > 0 && Number.isFinite(clockMedia.duration)")?, "true"); + page.vm_mut().eval("clockMedia.pause();clockMedia.removeAttribute('src');clockMedia.load();")?; + } } } Ok::<_, anyhow::Error>(()) diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs index 44f2cdfb5de..a20a413f757 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs @@ -166,6 +166,7 @@ mod main_parser_owned_module_completion; mod main_runtime_module_completion; mod main_runtime_script_completion; mod markdown_dump; +mod media_document_open; mod media_element_event; mod media_playback_clock; mod media_played_ranges; diff --git a/moli-renderer-v8/tests/fixtures/media-document-open.js b/moli-renderer-v8/tests/fixtures/media-document-open.js new file mode 100644 index 00000000000..f620dabee62 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media-document-open.js @@ -0,0 +1,102 @@ +(async () => { + const checks = []; + const sources = globalThis.__mediaTimelineSources; + const progress = globalThis.__mediaDefaultStartProgress = {stage: 'starting'}; + const delay = ms => new Promise(resolve => setTimeout(resolve, ms)); + const check = (name, passed, facts) => checks.push({name, passed, facts}); + const once = (target, name) => new Promise((resolve, reject) => { + const timer = setTimeout(() => {target.removeEventListener(name, done); reject(new Error('waiting for ' + name));}, 1500); + const done = () => {clearTimeout(timer); resolve();}; + target.addEventListener(name, done, {once: true}); + }); + const replace = doc => { + doc.open(); + doc.write('replacementreplacement'); + doc.close(); + }; + const ranges = media => Array.from({length: media.played.length}, (_, i) => [media.played.start(i), media.played.end(i)]); + for (const child of [false, true]) for (const kind of ['audio', 'video']) { + for (const transport of ['data', 'http']) for (const connected of [false, true]) { + for (const reentrant of [false, true]) { + const label = [child ? 'child' : 'main', kind, transport, connected ? 'connected' : 'detached', reentrant ? 'timeupdate' : 'pending'].join('/'); + progress.stage = label; + let frame; + let media; + try { + if (child) { + frame = document.createElement('iframe'); + const loaded = once(frame, 'load'); + frame.srcdoc = 'child'; + document.body.append(frame); + await loaded; + } + const doc = child ? frame.contentDocument : document; + const win = doc.defaultView; + media = doc.createElement(kind); + media.muted = true; + if (connected) doc.body.append(media); + const ready = once(media, 'canplaythrough'); + media.src = sources[transport][kind]; + await ready; + const duration = media.duration; + const src = media.currentSrc; + let oldSeeked = 0, newSeeked = 0, opened = 0; + media.addEventListener('seeked', () => oldSeeked++); + let done; + const finished = new Promise(resolve => {done = resolve;}); + const open = () => { + opened++; + replace(doc); + media.addEventListener('seeked', () => {newSeeked++; done();}, {once: true}); + }; + if (reentrant) media.addEventListener('timeupdate', open, {once: true}); + media.currentTime = 1; + if (!reentrant) open(); + await Promise.race([finished, delay(1500)]); + check(label + '/queued notification', opened === 1 && newSeeked === 1, {opened, newSeeked}); + check(label + '/old listeners follow tree membership', oldSeeked === (connected ? 0 : 1), {oldSeeked}); + check(label + '/selected resource survives', media.ownerDocument === doc && doc.defaultView === win && media.duration === duration && media.currentSrc === src && media.currentTime === 1 && !media.seeking && media.readyState >= 1, + {duration: media.duration, currentTime: media.currentTime, readyState: media.readyState, seeking: media.seeking}); + const next = once(media, 'seeked'); + media.currentTime = 2; + await next; + check(label + '/subsequent seek uses retained resource', media.currentTime === 2 && media.duration === duration && !media.seeking); + } catch (error) { + check(label + '/completion', false, String(error)); + } finally { + if (media) {media.pause(); media.removeAttribute('src'); media.load(); media.remove();} + if (frame) frame.remove(); + } + } + } + } + for (const child of [false, true]) for (const kind of ['audio', 'video']) for (const transport of ['data', 'http']) { + const label = [child ? 'child' : 'main', kind, transport, 'history'].join('/'); + progress.stage = label; + let frame, media; + try { + if (child) { + frame = document.createElement('iframe'); + const loaded = once(frame, 'load'); + frame.srcdoc = 'child'; + document.body.append(frame); + await loaded; + } + const doc = child ? frame.contentDocument : document; + media = doc.createElement(kind); media.muted = true; + const ready = once(media, 'canplaythrough'); media.src = sources[transport][kind]; await ready; + await media.play(); + await once(media, 'timeupdate'); + const paused = once(media, 'pause'); media.pause(); await paused; + const before = JSON.stringify(ranges(media)); + const duration = media.duration; + const snapshot = media.played; + replace(doc); + check(label + '/resource history retained', media.duration === duration && media.played.length > 0 && JSON.stringify(ranges(media)) === before && snapshot.length === media.played.length, {before, after: ranges(media), duration: media.duration}); + const tick = once(media, 'timeupdate'); await media.play(); await tick; media.pause(); + check(label + '/clock continues in same Window', media.currentTime > snapshot.end(snapshot.length - 1) && media.played.end(0) > snapshot.end(0)); + } catch (error) {check(label + '/completion', false, String(error));} + finally {if (media) {media.pause(); media.removeAttribute('src'); media.load();} if (frame) frame.remove();} + } + globalThis.__uiEventResults = {total: checks.length, checks}; +})().catch(error => {globalThis.__uiEventResults = {total: 1, checks: [{name: 'fixture completion', passed: false, facts: String(error)}]};});