fix(media): preserve selected resources across document.open

This commit is contained in:
ldm0
2026-11-22 02:02:02 +08:00
parent b285a296e5
commit 85b60eb648
17 changed files with 632 additions and 171 deletions
@@ -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
@@ -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
@@ -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<bool> {
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);
};
@@ -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::<Vec<_>>();
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);
}
@@ -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<WindowDocumentTaskTarget>,
target: Option<WindowTaskTarget>,
task_document: Option<DomHandle>,
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<WindowTaskTarget> {
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<super::window_document_tasks::ResolvedWindowDocumentTaskContext<'s>> {
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<WindowDocumentTaskTarget> {
) -> Option<WindowTaskTarget> {
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<u64> {
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;
}
@@ -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,
@@ -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<AtomicBool>,
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 {
@@ -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<RendererPageMediaElementEventOwner>,
},
}
/// 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<RendererPageMediaElementEventTask>,
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<RendererPageMediaElementEventTask>,
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<RendererPageTaskReadyMetadata> {
self.source.front().map(ReadyPageTask::metadata)
}
pub(crate) fn next_ready_owner(&mut self) -> Option<RendererPageMediaElementEventOwner> {
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<PageMediaElementEventTurnAction>;
@@ -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)),
)
}
@@ -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 {
@@ -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,
)),
),
),
}
@@ -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<RendererPageMediaElementEventTask>;
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,
@@ -183,6 +183,9 @@ decodeMedia.load();
"load" => "decodeMedia.removeAttribute('src'); decodeMedia.load();",
_ => "document.open(); document.write('<!doctype html><body>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'));
@@ -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='<iframe></iframe>';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");
}
@@ -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("<!doctype html><body>replacement</body>");
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('<!doctype html><body>replacement</body>'); 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");
}
@@ -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>(())
@@ -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;
+102
View File
@@ -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('<!doctype html><title>replacement</title><body>replacement</body>');
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 = '<!doctype html><body>child</body>';
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 = '<!doctype html><body>child</body>';
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)}]};});