mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
fix(media): preserve selected resources across document.open
This commit is contained in:
@@ -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;
|
||||
|
||||
@@ -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)}]};});
|
||||
Reference in New Issue
Block a user