From d75f2c21560952f4cfd58378f797f4f5ce5d97cd Mon Sep 17 00:00:00 2001 From: ldm0 Date: Thu, 15 Oct 2026 18:46:05 +0800 Subject: [PATCH] fix(media): advance playback through owned monotonic clock tasks --- .../context_host/host_environment.rs | 4 + .../context_host/media_playback.rs | 45 ++- .../context_host/media_playback/clock.rs | 284 ++++++++++++++++++ .../page_vm/tests/media_playback_clock.rs | 98 ++++++ .../tests/fixtures/media-playback-clock.js | 111 +++++++ 5 files changed, 540 insertions(+), 2 deletions(-) create mode 100644 moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs create mode 100644 moli-renderer-v8/tests/fixtures/media-playback-clock.js diff --git a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs index 17eeedd560e..3bf7619b6c6 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs @@ -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 } diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs b/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs index 921c44965db..422a3f263fa 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs @@ -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>, outstanding: Vec>, selection: Option, + clock: Option, } 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::>(); + 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 diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs b/moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs new file mode 100644 index 00000000000..bdecaeb7718 --- /dev/null +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback/clock.rs @@ -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, + wakeup: Option>, +} + +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 +} diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs b/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs index 199a26c5644..2959e569375 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/media_playback_clock.rs @@ -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='';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('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() { diff --git a/moli-renderer-v8/tests/fixtures/media-playback-clock.js b/moli-renderer-v8/tests/fixtures/media-playback-clock.js new file mode 100644 index 00000000000..c67b0a9e6df --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media-playback-clock.js @@ -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}; +})()