mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(media): advance playback through owned monotonic clock tasks
This commit is contained in:
@@ -2235,6 +2235,7 @@ impl PageScriptHost {
|
||||
}
|
||||
|
||||
pub(crate) fn set_media_paused(&mut self, handle: DomHandle, paused: bool) -> bool {
|
||||
self.synchronize_media_clock(handle);
|
||||
let old_state = self.retained_current_element_state(handle);
|
||||
let changed = unsafe {
|
||||
DocumentRuntime::set_media_paused(&mut *self.document_runtime, handle, paused)
|
||||
@@ -2246,6 +2247,7 @@ impl PageScriptHost {
|
||||
old_state,
|
||||
);
|
||||
}
|
||||
self.rebase_media_clock_from_element(handle);
|
||||
changed
|
||||
}
|
||||
|
||||
@@ -2274,6 +2276,7 @@ impl PageScriptHost {
|
||||
}
|
||||
|
||||
pub(crate) fn set_media_seeking(&mut self, handle: DomHandle, seeking: bool) -> bool {
|
||||
self.synchronize_media_clock(handle);
|
||||
let old_state = self.retained_current_element_state(handle);
|
||||
let changed = unsafe {
|
||||
DocumentRuntime::set_media_seeking(&mut *self.document_runtime, handle, seeking)
|
||||
@@ -2285,6 +2288,7 @@ impl PageScriptHost {
|
||||
old_state,
|
||||
);
|
||||
}
|
||||
self.rebase_media_clock_from_element(handle);
|
||||
changed
|
||||
}
|
||||
|
||||
|
||||
@@ -10,10 +10,14 @@ use std::{
|
||||
|
||||
use super::{PageScriptHost, WindowDocumentTaskTarget};
|
||||
use crate::{
|
||||
document_runtime::DomHandle, native_bridge::element,
|
||||
page_task_queue::RendererPageMediaElementEventTaskKind,
|
||||
document_runtime::DomHandle,
|
||||
native_bridge::element,
|
||||
page_task_queue::{RendererPageMediaElementEventTaskId, RendererPageMediaElementEventTaskKind},
|
||||
};
|
||||
|
||||
mod clock;
|
||||
use clock::MediaPlaybackClock;
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub(crate) enum MediaPlayError {
|
||||
Abort,
|
||||
@@ -69,6 +73,7 @@ struct PlaybackElementState {
|
||||
pending: Vec<Rc<PlayPromise>>,
|
||||
outstanding: Vec<Weak<PlayPromise>>,
|
||||
selection: Option<u64>,
|
||||
clock: Option<MediaPlaybackClock>,
|
||||
}
|
||||
|
||||
impl PlaybackElementState {
|
||||
@@ -82,6 +87,7 @@ impl PlaybackElementState {
|
||||
pending: Vec::new(),
|
||||
outstanding: Vec::new(),
|
||||
selection: None,
|
||||
clock: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -109,6 +115,7 @@ struct StableWork {
|
||||
}
|
||||
|
||||
enum PlaybackOperation {
|
||||
ClockTick(RendererPageMediaElementEventTaskId),
|
||||
Emptied,
|
||||
VolumeChange,
|
||||
Play,
|
||||
@@ -130,6 +137,14 @@ pub(crate) struct MediaPlaybackTask {
|
||||
impl PageScriptHost {
|
||||
fn media_playback_state_for(&mut self, media: DomHandle) -> Option<&mut PlaybackElementState> {
|
||||
let document = self.dom_host().node(media)?.owner_document()?;
|
||||
if self
|
||||
.media_playback
|
||||
.elements
|
||||
.get(&media)
|
||||
.is_some_and(|state| state.document != document)
|
||||
{
|
||||
self.stop_media_clock(media);
|
||||
}
|
||||
let entry = self
|
||||
.media_playback
|
||||
.elements
|
||||
@@ -190,6 +205,7 @@ impl PageScriptHost {
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
media: DomHandle,
|
||||
) {
|
||||
self.stop_media_clock(media);
|
||||
let promises = self
|
||||
.media_playback
|
||||
.elements
|
||||
@@ -221,6 +237,18 @@ impl PageScriptHost {
|
||||
}
|
||||
|
||||
pub(crate) fn retire_media_playback_for_document(&mut self, document: DomHandle) {
|
||||
let clocks = self
|
||||
.media_playback
|
||||
.elements
|
||||
.iter()
|
||||
.filter_map(|(media, state)| {
|
||||
(state.document == document || state.task_document == Some(document))
|
||||
.then_some(*media)
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
for media in clocks {
|
||||
self.stop_media_clock(media);
|
||||
}
|
||||
self.media_playback
|
||||
.elements
|
||||
.retain(|_, state| state.document != document && state.task_document != Some(document));
|
||||
@@ -445,6 +473,7 @@ impl PageScriptHost {
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
media: DomHandle,
|
||||
) {
|
||||
self.start_media_clock(media);
|
||||
let promises = self.take_media_play_promises(media);
|
||||
self.queue_playback(scope, media, PlaybackOperation::Playing, promises);
|
||||
}
|
||||
@@ -595,6 +624,15 @@ impl PageScriptHost {
|
||||
impl MediaPlaybackTask {
|
||||
pub(super) fn is_current(&self, host: &PageScriptHost) -> bool {
|
||||
host.playback_is_current(self.media, self.document, self.epoch)
|
||||
&& match self.operation {
|
||||
PlaybackOperation::ClockTick(task_id) => host
|
||||
.media_playback
|
||||
.elements
|
||||
.get(&self.media)
|
||||
.and_then(|state| state.clock.as_ref())
|
||||
.is_some_and(|clock| clock.is_current_tick(task_id)),
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn dispatch(
|
||||
@@ -606,6 +644,9 @@ impl MediaPlaybackTask {
|
||||
return false;
|
||||
}
|
||||
let error = match self.operation {
|
||||
PlaybackOperation::ClockTick(task_id) => {
|
||||
return clock::dispatch_media_clock_tick(scope, host, self.media, task_id);
|
||||
}
|
||||
PlaybackOperation::Emptied => {
|
||||
fire(scope, host, self.media, "emptied");
|
||||
None
|
||||
|
||||
@@ -0,0 +1,284 @@
|
||||
use super::*;
|
||||
use crate::{
|
||||
document_runtime::DocumentRuntime,
|
||||
native_bridge::context_host::{
|
||||
media_element_events::PendingMediaElementEventPayload,
|
||||
window_document_tasks::PendingExactWindowDocumentTask,
|
||||
},
|
||||
};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
const UPDATE_INTERVAL: Duration = Duration::from_millis(250);
|
||||
|
||||
pub(super) struct MediaPlaybackClock {
|
||||
anchor: Instant,
|
||||
position: f64,
|
||||
rate: f64,
|
||||
running: bool,
|
||||
pending_task: Option<RendererPageMediaElementEventTaskId>,
|
||||
wakeup: Option<tokio::task::JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl MediaPlaybackClock {
|
||||
fn new(position: f64, rate: f64, running: bool) -> Self {
|
||||
Self {
|
||||
anchor: Instant::now(),
|
||||
position,
|
||||
rate,
|
||||
running,
|
||||
pending_task: None,
|
||||
wakeup: None,
|
||||
}
|
||||
}
|
||||
|
||||
fn position_at(&self, now: Instant) -> f64 {
|
||||
if self.running {
|
||||
(self.position + now.saturating_duration_since(self.anchor).as_secs_f64() * self.rate)
|
||||
.clamp(0.0, f64::MAX)
|
||||
} else {
|
||||
self.position
|
||||
}
|
||||
}
|
||||
|
||||
fn rebase(&mut self, position: f64, rate: f64, running: bool, now: Instant) {
|
||||
self.anchor = now;
|
||||
self.position = position;
|
||||
self.rate = rate;
|
||||
self.running = running;
|
||||
}
|
||||
|
||||
pub(super) fn is_current_tick(&self, task: RendererPageMediaElementEventTaskId) -> bool {
|
||||
self.running && self.rate != 0.0 && self.pending_task == Some(task)
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for MediaPlaybackClock {
|
||||
fn drop(&mut self) {
|
||||
if let Some(wakeup) = self.wakeup.take() {
|
||||
wakeup.abort();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PageScriptHost {
|
||||
fn media_clock_controls(&self, media: DomHandle) -> Option<(f64, f64, bool)> {
|
||||
let element = self.dom_host().node(media)?.as_element()?;
|
||||
Some((
|
||||
element.media_current_time(),
|
||||
element.media_playback_rate(),
|
||||
!element.media_paused() && !element.media_seeking() && element.media_ready_state() >= 3,
|
||||
))
|
||||
}
|
||||
|
||||
pub(super) fn start_media_clock(&mut self, media: DomHandle) {
|
||||
self.synchronize_media_clock(media);
|
||||
let Some((position, rate, running)) = self.media_clock_controls(media) else {
|
||||
return;
|
||||
};
|
||||
let Some(state) = self.media_playback.elements.get_mut(&media) else {
|
||||
return;
|
||||
};
|
||||
if state.clock.is_none() {
|
||||
state.clock = Some(MediaPlaybackClock::new(position, rate, running));
|
||||
}
|
||||
self.arm_media_clock_tick(media);
|
||||
}
|
||||
|
||||
pub(crate) fn synchronize_media_clock(&mut self, media: DomHandle) {
|
||||
let Some((_, rate, running)) = self.media_clock_controls(media) else {
|
||||
return;
|
||||
};
|
||||
let Some(clock) = self
|
||||
.media_playback
|
||||
.elements
|
||||
.get_mut(&media)
|
||||
.and_then(|state| state.clock.as_mut())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
let now = Instant::now();
|
||||
let position = clock.position_at(now);
|
||||
clock.rebase(position, rate, running, now);
|
||||
let _ = unsafe {
|
||||
DocumentRuntime::set_media_current_time(&mut *self.document_runtime, media, position)
|
||||
};
|
||||
if !running || rate == 0.0 {
|
||||
self.cancel_media_clock_tick(media);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn rebase_media_clock_from_element(&mut self, media: DomHandle) {
|
||||
let Some((position, rate, running)) = self.media_clock_controls(media) else {
|
||||
return;
|
||||
};
|
||||
let Some(clock) = self
|
||||
.media_playback
|
||||
.elements
|
||||
.get_mut(&media)
|
||||
.and_then(|state| state.clock.as_mut())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
clock.rebase(position, rate, running, Instant::now());
|
||||
if !running || rate == 0.0 {
|
||||
self.cancel_media_clock_tick(media);
|
||||
} else {
|
||||
self.arm_media_clock_tick(media);
|
||||
}
|
||||
}
|
||||
|
||||
fn cancel_media_clock_tick(&mut self, media: DomHandle) {
|
||||
let Some(clock) = self
|
||||
.media_playback
|
||||
.elements
|
||||
.get_mut(&media)
|
||||
.and_then(|state| state.clock.as_mut())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
if let Some(wakeup) = clock.wakeup.take() {
|
||||
wakeup.abort();
|
||||
}
|
||||
if let Some(task) = clock.pending_task.take() {
|
||||
let _ = self.media_element_events.remove(task);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn stop_media_clock(&mut self, media: DomHandle) {
|
||||
self.synchronize_media_clock(media);
|
||||
self.cancel_media_clock_tick(media);
|
||||
if let Some(state) = self.media_playback.elements.get_mut(&media) {
|
||||
state.clock = None;
|
||||
}
|
||||
}
|
||||
|
||||
fn arm_media_clock_tick(&mut self, media: DomHandle) {
|
||||
let Some(state) = self.media_playback.elements.get(&media) else {
|
||||
return;
|
||||
};
|
||||
let Some(clock) = state.clock.as_ref() else {
|
||||
return;
|
||||
};
|
||||
if !clock.running || clock.rate == 0.0 || clock.pending_task.is_some() {
|
||||
return;
|
||||
}
|
||||
let Some(target) = state.target else {
|
||||
return;
|
||||
};
|
||||
if self.current_window_document_task_target_for_dispatch_scope(target.dispatch_scope())
|
||||
!= Some(target)
|
||||
{
|
||||
return;
|
||||
}
|
||||
let Some(loader) = self.document_resource_loader_for_window_owner(target.owner()) else {
|
||||
return;
|
||||
};
|
||||
let task_id = self
|
||||
.media_element_events
|
||||
.allocate_task_id(RendererPageMediaElementEventTaskId::from_raw);
|
||||
let Some(task) = self.capture_media_playback_task(
|
||||
media,
|
||||
PlaybackOperation::ClockTick(task_id),
|
||||
Vec::new(),
|
||||
) else {
|
||||
return;
|
||||
};
|
||||
let kind = RendererPageMediaElementEventTaskKind::Playback;
|
||||
self.media_element_events
|
||||
.push(PendingExactWindowDocumentTask::new(
|
||||
task_id,
|
||||
target,
|
||||
kind,
|
||||
PendingMediaElementEventPayload::Playback(task),
|
||||
));
|
||||
let sender = self.page_media_element_event_sender().clone();
|
||||
let wakeup = loader.task_runner().spawn_abortable(async move {
|
||||
tokio::time::sleep(UPDATE_INTERVAL).await;
|
||||
let _ = sender.send(target, task_id, kind);
|
||||
});
|
||||
let clock = self
|
||||
.media_playback
|
||||
.elements
|
||||
.get_mut(&media)
|
||||
.and_then(|state| state.clock.as_mut())
|
||||
.expect("clock was captured on the owner thread");
|
||||
clock.pending_task = Some(task_id);
|
||||
clock.wakeup = Some(wakeup);
|
||||
}
|
||||
|
||||
pub(crate) fn set_media_current_time(&mut self, media: DomHandle, time: f64) -> bool {
|
||||
self.synchronize_media_clock(media);
|
||||
let changed = unsafe {
|
||||
DocumentRuntime::set_media_current_time(&mut *self.document_runtime, media, time)
|
||||
};
|
||||
self.rebase_media_clock_from_element(media);
|
||||
changed
|
||||
}
|
||||
|
||||
pub(crate) fn set_media_playback_rate(&mut self, media: DomHandle, rate: f64) -> bool {
|
||||
self.synchronize_media_clock(media);
|
||||
let changed = unsafe {
|
||||
DocumentRuntime::set_media_playback_rate(&mut *self.document_runtime, media, rate)
|
||||
};
|
||||
self.rebase_media_clock_from_element(media);
|
||||
changed
|
||||
}
|
||||
|
||||
pub(crate) fn set_media_ready_state(&mut self, media: DomHandle, ready: u32) -> bool {
|
||||
self.synchronize_media_clock(media);
|
||||
let changed = unsafe {
|
||||
DocumentRuntime::set_media_ready_state(&mut *self.document_runtime, media, ready)
|
||||
};
|
||||
self.rebase_media_clock_from_element(media);
|
||||
changed
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn dispatch_media_clock_tick(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host: *mut PageScriptHost,
|
||||
media: DomHandle,
|
||||
task_id: RendererPageMediaElementEventTaskId,
|
||||
) -> bool {
|
||||
let (changed, document, epoch) = {
|
||||
let runtime = unsafe { &mut *host };
|
||||
let Some(clock) = runtime
|
||||
.media_playback
|
||||
.elements
|
||||
.get_mut(&media)
|
||||
.and_then(|state| state.clock.as_mut())
|
||||
else {
|
||||
return false;
|
||||
};
|
||||
if !clock.is_current_tick(task_id) {
|
||||
return false;
|
||||
}
|
||||
let previous_position = clock.position;
|
||||
clock.pending_task = None;
|
||||
clock.wakeup = None;
|
||||
runtime.synchronize_media_clock(media);
|
||||
let changed = runtime
|
||||
.dom_host()
|
||||
.node(media)
|
||||
.and_then(crate::dom::native::Node::as_element)
|
||||
.is_some_and(|element| element.media_current_time() != previous_position);
|
||||
let state = runtime
|
||||
.media_playback
|
||||
.elements
|
||||
.get(&media)
|
||||
.expect("current clock");
|
||||
(changed, state.document, state.epoch)
|
||||
};
|
||||
// Author callbacks can reenter the host, so no mutable host reference may
|
||||
// span cue or timeupdate dispatch.
|
||||
if changed {
|
||||
element::refresh_media_active_text_track_cues(scope, host, media);
|
||||
if unsafe { &*host }.playback_is_current(media, document, epoch) {
|
||||
fire(scope, host, media, "timeupdate");
|
||||
}
|
||||
}
|
||||
if unsafe { &*host }.playback_is_current(media, document, epoch) {
|
||||
unsafe { &mut *host }.arm_media_clock_tick(media);
|
||||
}
|
||||
changed
|
||||
}
|
||||
@@ -1,4 +1,102 @@
|
||||
use super::*;
|
||||
use base64::Engine;
|
||||
|
||||
fn media_sources() -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"video": format!("data:video/webm;base64,{}", base64::engine::general_purpose::STANDARD.encode(include_bytes!("../../../../tests/fixtures/media/movie_5.webm"))),
|
||||
"audio": format!("data:audio/ogg;base64,{}", base64::engine::general_purpose::STANDARD.encode(include_bytes!("../../../../tests/fixtures/media/sound_5.oga"))),
|
||||
})
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn media_clock_and_windowless_loads_share_owned_tasks_and_realms() {
|
||||
run_page_vm_async_test(async move {
|
||||
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("media request");
|
||||
let request = read_http_request_head(&mut stream).await.expect("request head");
|
||||
let (mime, bytes): (&str, &[u8]) = if request.starts_with("GET /audio ") {
|
||||
("audio/ogg", include_bytes!("../../../../tests/fixtures/media/sound_5.oga"))
|
||||
} else {
|
||||
assert!(request.starts_with("GET /video "), "{request}");
|
||||
("video/webm", include_bytes!("../../../../tests/fixtures/media/movie_5.webm"))
|
||||
};
|
||||
let head = format!("HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", bytes.len());
|
||||
stream.write_all(head.as_bytes()).await.expect("media headers");
|
||||
stream.write_all(bytes).await.expect("media body");
|
||||
}
|
||||
});
|
||||
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 = media_sources();
|
||||
let http = serde_json::json!({"audio":format!("{base}/audio"),"video":format!("{base}/video")});
|
||||
page.vm_mut().eval(&format!("document.body.innerHTML='<iframe></iframe>';globalThis.__mediaPlaybackSources={sources};globalThis.__mediaClockHttpSources={http};"))?;
|
||||
page.vm_mut().eval(include_str!("../../../../tests/fixtures/media-playback-clock.js"))?;
|
||||
let deadline = Instant::now() + Duration::from_secs(120);
|
||||
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?;
|
||||
}
|
||||
// These timers belong to the fixture's quiet periods/watchdogs.
|
||||
// The clock itself publishes only native media-source envelopes.
|
||||
let _ = page.run_one_due_timer_selected_task_for_test(&loader).await?;
|
||||
anyhow::ensure!(Instant::now() < deadline, "clock fixture did not finish: {}", page.vm_mut().eval("__mediaClockProgress.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"], 80);
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.expect("native clock and load-neutral relevant-global routing");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn captured_clock_ticks_retire_without_checkpointing_other_work() {
|
||||
run_page_vm_async_test(async move {
|
||||
for windowless in [false, true] {
|
||||
for retire in ["pause", "load", "document"] {
|
||||
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-clock-retire.test/")?);
|
||||
let sources = media_sources();
|
||||
page.vm_mut().eval(&format!(r#"
|
||||
const clockDocument = {windowless} ? document.implementation.createHTMLDocument('') : document;
|
||||
globalThis.clockMedia = clockDocument.createElement('video');
|
||||
clockDocument.body.appendChild(clockMedia);
|
||||
clockMedia.src = ({sources}).video;
|
||||
clockMedia.play().catch(() => {{}});
|
||||
"#))?;
|
||||
while page.run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::MediaElementEvent, &loader).await? {}
|
||||
tokio::time::sleep(Duration::from_millis(300)).await;
|
||||
let captured = page.claim_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::MediaElementEvent).expect("capture the delayed clock tick");
|
||||
page.vm_mut().eval(match retire {
|
||||
"pause" => "clockMedia.pause()",
|
||||
"load" => "clockMedia.removeAttribute('src'); clockMedia.load()",
|
||||
_ => "document.open(); document.write('<!doctype html><body>replacement'); document.close();",
|
||||
})?;
|
||||
page.vm_mut().eval_without_microtask_checkpoint_for_test(r#"
|
||||
globalThis.unrelatedClockWork = [];
|
||||
Promise.resolve().then(() => unrelatedClockWork.push('microtask'));
|
||||
setTimeout(() => unrelatedClockWork.push('timer'), 0);
|
||||
"#)?;
|
||||
page.vm_mut().enqueue_test_pending_runtime_source_load();
|
||||
page.run_claimed_selected_page_task_for_test(captured, &loader).await?;
|
||||
assert_eq!(page.vm_mut().eval_without_microtask_checkpoint_for_test("unrelatedClockWork.join('|')")?, "", "{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);
|
||||
}
|
||||
}
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.expect("stale clock envelopes do not receive a completion checkpoint");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn windowless_network_load_is_cancelled_when_its_relevant_document_retires() {
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
(async () => {
|
||||
const checks=[];
|
||||
const progress=globalThis.__mediaClockProgress={stage:'setup',checks};
|
||||
const assert=(condition,message)=>{if(!condition)throw Error(message);};
|
||||
const set=(callee,media,name,value)=>Object.getOwnPropertyDescriptor(callee.HTMLMediaElement.prototype,name).set.call(media,value);
|
||||
const play=(callee,media)=>callee.HTMLMediaElement.prototype.play.call(media);
|
||||
const pause=(callee,media)=>callee.HTMLMediaElement.prototype.pause.call(media);
|
||||
const wait=milliseconds=>new Promise(resolve=>setTimeout(resolve,milliseconds));
|
||||
function once(media,type,action,owner,predicate=()=>true) {
|
||||
return new Promise((resolve,reject)=>{
|
||||
const listener=event=>{
|
||||
try{
|
||||
assert(event.target===media && event.currentTarget===media && event.isTrusted,'native event target and trust');
|
||||
assert(event instanceof owner.Event,'native event realm');
|
||||
if(!predicate(event))return;
|
||||
media.removeEventListener(type,listener);resolve(event);
|
||||
}catch(error){media.removeEventListener(type,listener);reject(error);}
|
||||
};
|
||||
media.addEventListener(type,listener);
|
||||
if(action)action();
|
||||
});
|
||||
}
|
||||
async function readyPlay(owner,callee,media,kind) {
|
||||
set(callee,media,'src',__mediaPlaybackSources[kind]);
|
||||
const promise=play(callee,media);
|
||||
assert(promise instanceof owner.Promise,'play promise uses the media object realm');
|
||||
await promise;
|
||||
assert(!media.paused && media.readyState>=3,'loaded media must become playable');
|
||||
}
|
||||
const cases=[
|
||||
['playback advances through native media tasks',async(owner,callee,media,kind)=>{
|
||||
await readyPlay(owner,callee,media,kind);
|
||||
const start=media.currentTime;
|
||||
await once(media,'timeupdate',null,owner,()=>media.currentTime>start);
|
||||
assert(!media.paused && media.currentTime>start,'playing media must advance');
|
||||
const official=media.currentTime;
|
||||
for(let i=0;i<1000;i++)assert(media.currentTime===official,'the official position stays stable within a JavaScript turn');
|
||||
}],
|
||||
['pause seek and playbackRate preserve the clock',async(owner,callee,media,kind)=>{
|
||||
await readyPlay(owner,callee,media,kind);
|
||||
await once(media,'timeupdate',null,owner,()=>media.currentTime>0);
|
||||
await once(media,'pause',()=>pause(callee,media),owner);
|
||||
const stopped=media.currentTime;
|
||||
await wait(40);assert(media.currentTime===stopped && media.paused,'pause freezes playback position');
|
||||
set(callee,media,'playbackRate',0);
|
||||
await play(callee,media);
|
||||
const zeroRatePosition=media.currentTime;
|
||||
await wait(40);assert(!media.paused && media.currentTime===zeroRatePosition,'zero rate keeps an unpaused clock stationary');
|
||||
await once(media,'seeked',()=>set(callee,media,'currentTime',1),owner);
|
||||
assert(media.currentTime===1 && !media.seeking,'seek establishes the new anchor');
|
||||
const began=performance.now();
|
||||
await once(media,'timeupdate',()=>set(callee,media,'playbackRate',2),owner,()=>media.currentTime>1);
|
||||
const elapsed=(performance.now()-began)/1000;
|
||||
assert(Math.abs((media.currentTime-1)-2*elapsed)<0.2,'playbackRate must scale elapsed monotonic time');
|
||||
}],
|
||||
['reentrant pause stops periodic notifications',async(owner,callee,media,kind)=>{
|
||||
await readyPlay(owner,callee,media,kind);
|
||||
const paused=once(media,'pause',null,owner);
|
||||
const first=event=>{
|
||||
if(media.currentTime===0)return;
|
||||
media.removeEventListener('timeupdate',first);
|
||||
pause(callee,media);
|
||||
};
|
||||
media.addEventListener('timeupdate',first);
|
||||
await paused;
|
||||
let later=0;media.ontimeupdate=()=>later++;
|
||||
const stopped=media.currentTime;
|
||||
await wait(300);
|
||||
assert(later===0 && media.currentTime===stopped && media.paused,'a paused clock must cancel its scheduled wakeup');
|
||||
}],
|
||||
['empty resource settles in the relevant global',async(owner,callee,media)=>{
|
||||
media.defaultMuted=true;set(callee,media,'muted',false);set(callee,media,'volume',0.25);
|
||||
const order=[];
|
||||
media.addEventListener('error',()=>order.push('error'));
|
||||
const failed=once(media,'error',()=>set(callee,media,'src','data:,'),owner);
|
||||
const promise=play(callee,media);
|
||||
assert(promise instanceof owner.Promise,'failed request retains its promise realm');
|
||||
let rejected;
|
||||
await promise.then(()=>{throw Error('empty resource fulfilled');},error=>{rejected=error;order.push('rejected');});
|
||||
await failed;
|
||||
assert(rejected instanceof owner.DOMException && rejected.name==='NotSupportedError','failure uses the media object realm');
|
||||
assert(order.join('|')==='error|rejected','error precedes the play rejection');
|
||||
assert(media.error.code===4 && media.readyState===0 && media.volume===0.25 && !media.muted && media.defaultMuted,'failure preserves controls');
|
||||
}],
|
||||
['HTTP resource loads under its relevant global',async(owner,callee,media,kind)=>{
|
||||
const ready=once(media,'canplaythrough',()=>set(callee,media,'src',__mediaClockHttpSources[kind]),owner);
|
||||
const promise=play(callee,media);
|
||||
await promise;await ready;
|
||||
assert(media.readyState===4 && media.error===null && !media.paused,'a real network response must complete for the media object');
|
||||
}],
|
||||
];
|
||||
try{
|
||||
const realms=[['main',globalThis],['iframe',document.querySelector('iframe').contentWindow]];
|
||||
for(const [ownerName,owner] of realms)for(const [calleeName,callee] of realms)
|
||||
for(const kind of ['audio','video'])for(const windowless of [false,true]){
|
||||
const doc=windowless?owner.document.implementation.createHTMLDocument(''):owner.document;
|
||||
for(const [name,body] of cases){
|
||||
const media=doc.createElement(kind);doc.body.appendChild(media);
|
||||
const label=`${ownerName}/${calleeName}/${kind}/${windowless?'windowless':'live'}/${name}`;
|
||||
progress.stage=label;let timeout;
|
||||
try{
|
||||
await Promise.race([body(owner,callee,media,kind),new Promise((_,reject)=>{timeout=setTimeout(()=>reject(Error('clock case timeout')),2000);})]);
|
||||
if(windowless)assert(doc.defaultView===null && doc.hidden,'media tasks must keep inert Documents windowless and hidden');
|
||||
checks.push({name:label,category:windowless?'windowless':'live',passed:true});
|
||||
}catch(error){checks.push({name:label,category:windowless?'windowless':'live',passed:false,detail:String(error)});}
|
||||
finally{clearTimeout(timeout);media.remove();media.removeAttribute('src');media.load();}
|
||||
}
|
||||
}
|
||||
}catch(error){checks.push({name:'clock fixture setup',passed:false,detail:String(error)});}
|
||||
globalThis.__uiEventResults={checks,total:checks.length};
|
||||
})()
|
||||
Reference in New Issue
Block a user