fix(media): publish duration and resize before metadata events

This commit is contained in:
ldm0
2026-11-21 20:03:33 +08:00
parent 9aa30142b8
commit 02c70389ea
13 changed files with 396 additions and 30 deletions
@@ -75,6 +75,7 @@ struct PlaybackElementState {
pending: Vec<Rc<PlayPromise>>,
outstanding: Vec<Weak<PlayPromise>>,
selection: Option<u64>,
duration: Option<f64>,
clock: Option<MediaPlaybackClock>,
video: Option<video::VideoElementResource>,
}
@@ -90,6 +91,7 @@ impl PlaybackElementState {
pending: Vec::new(),
outstanding: Vec::new(),
selection: None,
duration: None,
clock: None,
video: None,
}
@@ -140,6 +142,40 @@ pub(crate) struct MediaPlaybackTask {
}
impl PageScriptHost {
pub(crate) fn begin_media_resource(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
media: DomHandle,
sequence: super::MediaLoadSequenceId,
bytes: &[u8],
origin_clean: bool,
network_id: Option<u64>,
) -> Result<bool, String> {
if self
.begin_media_video_resource(scope, media, sequence, bytes, origin_clean, network_id)
.map_err(|error| error.to_string())?
{
return Ok(true);
}
let duration = moli_media::ogg_vorbis_duration(bytes).map_err(|error| error.to_string())?;
self.media_playback_state_for(media)
.ok_or_else(|| "media resource owner is unavailable".to_owned())?
.duration = duration;
Ok(false)
}
pub(crate) fn media_duration(&self, media: DomHandle) -> Option<f64> {
let node = self.dom_host().node(media)?;
if node.as_element()?.media_ready_state() < 1 {
return None;
}
let state = self.media_playback.elements.get(&media)?;
if Some(state.document) != node.owner_document() {
return None;
}
Some(state.duration.unwrap_or(f64::INFINITY))
}
fn media_playback_state_for(&mut self, media: DomHandle) -> Option<&mut PlaybackElementState> {
let document = self.dom_host().node(media)?.owner_document()?;
if self
@@ -230,6 +266,7 @@ impl PageScriptHost {
};
state.pending.clear();
state.selection = None;
state.duration = None;
state.video = None;
state.can_autoplay = true;
state.epoch = state.epoch.checked_add(1).expect("media epoch overflow");
@@ -249,7 +249,7 @@ impl PageScriptHost {
}
}
pub(crate) fn begin_media_video_resource(
pub(super) fn begin_media_video_resource(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
media: DomHandle,
@@ -522,15 +522,16 @@ impl MediaVideoDecodeTask {
};
let (load, successful) = {
let runtime = unsafe { &mut *host };
let video = runtime
let state = runtime
.media_playback
.elements
.get_mut(&self.media)
.and_then(|state| state.video.as_mut())
.expect("current decode");
let video = state.video.as_mut().expect("current video");
video.pending = None;
match result {
Ok(snapshot) => {
state.duration = snapshot.metadata.duration;
video.cached = Some(snapshot);
video.decoded_position = Some(self.position);
}
@@ -632,6 +632,8 @@ fn start_media_load(
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum MediaLoadEventPhase {
LoadStart,
DurationChange,
Resize,
LoadedMetadata,
LoadedData,
CanPlay,
@@ -643,6 +645,8 @@ impl MediaLoadEventPhase {
fn event_type(self) -> &'static str {
match self {
Self::LoadStart => "loadstart",
Self::DurationChange => "durationchange",
Self::Resize => "resize",
Self::LoadedMetadata => "loadedmetadata",
Self::LoadedData => "loadeddata",
Self::CanPlay => "canplay",
@@ -651,9 +655,11 @@ impl MediaLoadEventPhase {
}
}
fn next(self) -> Option<Self> {
fn next(self, is_video: bool) -> Option<Self> {
match self {
Self::LoadStart => Some(Self::LoadedMetadata),
Self::LoadStart => Some(Self::DurationChange),
Self::DurationChange if is_video => Some(Self::Resize),
Self::DurationChange | Self::Resize => Some(Self::LoadedMetadata),
Self::LoadedMetadata => Some(Self::LoadedData),
Self::LoadedData => Some(Self::CanPlay),
Self::CanPlay => Some(Self::CanPlayThrough),
@@ -693,10 +699,11 @@ pub(crate) fn dispatch_media_load_event_phase(
None
};
match phase {
MediaLoadEventPhase::LoadStart | MediaLoadEventPhase::CanPlayThrough => {}
MediaLoadEventPhase::LoadedMetadata => {
let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 1);
}
MediaLoadEventPhase::LoadStart
| MediaLoadEventPhase::DurationChange
| MediaLoadEventPhase::Resize
| MediaLoadEventPhase::LoadedMetadata
| MediaLoadEventPhase::CanPlayThrough => {}
MediaLoadEventPhase::LoadedData => {
let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 2);
}
@@ -756,7 +763,12 @@ pub(crate) fn dispatch_media_load_event_phase(
{
return dispatched;
}
let Some(next) = phase.next() else {
let is_video = unsafe { &*runtime_ptr }
.dom_host()
.node(handle)
.and_then(crate::dom::native::Node::as_element)
.is_some_and(|element| element.is_html_element("video"));
let Some(next) = phase.next(is_video) else {
let _ = unsafe { &mut *runtime_ptr }
.finish_pending_media_load_sequence_if_matches(handle, sequence);
return dispatched;
@@ -814,7 +826,10 @@ fn queue_media_load_terminal_followup_if_ready(
return;
};
let phase = match followup {
PendingMediaLoadTerminalFollowup::Ready => MediaLoadEventPhase::LoadedMetadata,
PendingMediaLoadTerminalFollowup::Ready => {
let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 1);
MediaLoadEventPhase::DurationChange
}
PendingMediaLoadTerminalFollowup::Failed => MediaLoadEventPhase::Error,
};
if !queue_media_load_event_phase(scope, runtime_ptr, handle, sequence, phase) {
@@ -355,11 +355,16 @@ pub(in crate::native_bridge) fn media_duration_getter_function<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'s, v8::Value>,
) {
if html_media_element_getter_receiver(scope, args.this(), "duration").is_none() {
let Some((runtime_ptr, handle)) =
html_media_element_getter_receiver(scope, args.this(), "duration")
else {
rv.set(v8::Number::new(scope, f64::NAN).into());
return;
}
rv.set(v8::Number::new(scope, f64::NAN).into());
};
let duration = unsafe { &*runtime_ptr }
.media_duration(handle)
.unwrap_or(f64::NAN);
rv.set(v8::Number::new(scope, duration).into());
}
pub(in crate::native_bridge) fn media_ended_getter_function<'s>(
+1 -1
View File
@@ -83,7 +83,7 @@ pub(crate) fn start_media_element_resource_fetch(
credentials_mode,
None,
);
match host.begin_media_video_resource(
match host.begin_media_resource(
scope,
media_handle,
sequence,
@@ -169,6 +169,124 @@ async fn media_adoption_reloads_without_losing_playback_intent_or_decoder_capaci
}).await.expect("media playback intent across Document adoption");
}
#[tokio::test(flavor = "current_thread")]
async fn media_metadata_preserves_values_event_tasks_realms_and_selection_cancellation() {
use base64::Engine;
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("media metadata request");
let request = read_http_request_head(&mut stream).await.expect("request head");
let (bytes, 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",
bytes.len()
);
if stream.write_all(header.as_bytes()).await.is_ok() {
let _ = stream.write_all(bytes).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.__mediaMetadataSources={sources};"
))?;
page.vm_mut().eval(include_str!("../../../../tests/fixtures/media-metadata-events.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?;
}
let _ = page.run_one_due_timer_selected_task_for_test(&loader).await?;
anyhow::ensure!(Instant::now() < deadline, "metadata fixture did not finish: {}",
page.vm_mut().eval("__mediaMetadataProgress.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"], 120);
Ok::<_, anyhow::Error>(())
}).await.expect("media metadata values and owned event sequencing");
}
#[tokio::test(flavor = "current_thread")]
async fn retired_metadata_tasks_do_not_dispatch_or_checkpoint_the_replacement() {
use base64::Engine;
run_page_vm_async_test(async move {
let audio = base64::engine::general_purpose::STANDARD.encode(include_bytes!(
"../../../../tests/fixtures/media/sound_5.oga"
));
for (kind, event, preceding) in [("audio", "durationchange", 1), ("video", "resize", 2)] {
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://retired-media-metadata.test/")?,
);
page.vm_mut().eval(&format!(r#"
globalThis.retiredMetadataEvents = [];
const media = document.createElement({kind:?});
media.addEventListener({event:?}, () => retiredMetadataEvents.push({event:?}));
document.body.append(media);
media.src = 'data:audio/ogg;base64,{audio}';
"#))?;
for _ in 0..preceding {
let task = page.claim_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::MediaElementEvent,
).expect("phase before the captured metadata task");
page.run_claimed_selected_page_task_for_test(task, &loader).await?;
}
let captured = page.claim_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::MediaElementEvent,
).expect("capture an initialized metadata event before retirement");
page.vm_mut().eval(
"document.open();document.write('<!doctype html><body>replacement</body>');document.close();",
)?;
page.vm_mut().eval_without_microtask_checkpoint_for_test(
"globalThis.replacementMetadataEvents = [];Promise.resolve().then(() => replacementMetadataEvents.push('microtask'));",
)?;
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(
"retiredMetadataEvents.join('|') + ':' + replacementMetadataEvents.join('|')",
)?, ":", "{event} must respect its exact Document owner");
assert_eq!(page.vm().document_runtime.runtime_script_work().dynamic_scripts
.pending_source_load_count_for_test(), 1,
"retired metadata work must not advance replacement scripts");
}
Ok::<_, anyhow::Error>(())
}).await.expect("stale metadata tasks have no effects in the replacement Document");
}
#[tokio::test(flavor = "current_thread")]
async fn media_volume_controls_preserve_tasks_realms_defaults_and_brands() {
run_page_vm_async_test(async move {
@@ -525,7 +643,7 @@ async fn media_canplaythrough_runs_in_a_separate_owned_task_after_canplay_microt
page.vm_mut().eval(r#"
globalThis.mediaEvents = [];
globalThis.media = document.createElement('video');
for (const type of ['loadstart', 'loadedmetadata', 'loadeddata', 'canplay', 'canplaythrough']) {
for (const type of ['loadstart', 'durationchange', 'resize', 'loadedmetadata', 'loadeddata', 'canplay', 'canplaythrough']) {
media.addEventListener(type, event => {
mediaEvents.push(type + ':' + media.readyState);
if (type === 'canplay' || type === 'canplaythrough') {
@@ -537,21 +655,21 @@ media.oncanplay = () => setTimeout(() => mediaEvents.push('timer'), 0);
document.body.append(media);
media.src = 'data:video/mp4;base64,AAAAGGZ0eXBtcDQyAAAAAG1wNDJtcDQx';
"#)?;
for _ in 0..4 {
for _ in 0..6 {
let turn = page.claim_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::MediaElementEvent,
).expect("each load phase must have its own media-element task");
page.run_claimed_selected_page_task_for_test(turn, &loader).await?;
}
assert_eq!(page.vm_mut().eval("mediaEvents.join('|')")?,
"loadstart:0|loadedmetadata:1|loadeddata:2|canplay:4|canplay-microtask");
"loadstart:0|durationchange:1|resize:1|loadedmetadata:1|loadeddata:2|canplay:4|canplay-microtask");
assert!(page.vm().has_ready_timeout(), "the unrelated timer must remain queued");
let through = page.claim_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::MediaElementEvent,
).expect("HAVE_ENOUGH_DATA must queue canplaythrough after canplay");
page.run_claimed_selected_page_task_for_test(through, &loader).await?;
assert_eq!(page.vm_mut().eval("mediaEvents.join('|')")?,
"loadstart:0|loadedmetadata:1|loadeddata:2|canplay:4|canplay-microtask|canplaythrough:4|canplaythrough-microtask");
"loadstart:0|durationchange:1|resize:1|loadedmetadata:1|loadeddata:2|canplay:4|canplay-microtask|canplaythrough:4|canplaythrough-microtask");
assert_eq!(page.vm_mut().eval("media.paused && media.networkState === 1")?, "true");
assert!(page.vm().has_ready_timeout(), "canplaythrough must not consume timers");
assert!(page.claim_exact_selected_page_task_for_test(
@@ -581,7 +699,7 @@ document.body.append(media);
media.src = 'data:video/mp4;base64,AAAAGGZ0eXBtcDQyAAAAAG1wNDJtcDQx';
"#,
)?;
for _ in 0..4 {
for _ in 0..6 {
let turn = page
.claim_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::MediaElementEvent,
@@ -664,7 +782,7 @@ document.body.append(media);
media.src = 'data:video/mp4;base64,AAAAGGZ0eXBtcDQyAAAAAG1wNDJtcDQx';
"#,
)?;
for _ in 0..4 {
for _ in 0..6 {
let turn = page
.claim_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::MediaElementEvent,
@@ -684,12 +802,12 @@ media.src = 'data:video/mp4;base64,AAAAGGZ0eXBtcDQyAAAAAG1wNDJtcDQx';
.expect("the next task must belong to the replacement loadstart");
page.run_claimed_selected_page_task_for_test(restarted, &loader)
.await?;
assert_eq!(page.vm_mut().eval("media.readyState")?, "0");
assert_eq!(page.vm_mut().eval("media.readyState")?, "1");
assert_eq!(
page.vm_mut().eval("replacedMediaEvents.join('|')")?,
"canplay"
);
for _ in 0..4 {
for _ in 0..6 {
let turn = page
.claim_exact_selected_page_task_for_test(
PageSelectedTaskTestSelector::MediaElementEvent,
@@ -273,7 +273,7 @@ fn apply_media_subresource_terminal(
{
false
} else {
match host.begin_media_video_resource(
match host.begin_media_resource(
scope,
media_handle,
sequence,
@@ -135,7 +135,14 @@ async fn media_report_only_csp_reports_without_blocking_load() {
1
);
for phase in ["loadstart", "loadedmetadata", "loadeddata", "canplay"] {
for phase in [
"loadstart",
"durationchange",
"resize",
"loadedmetadata",
"loadeddata",
"canplay",
] {
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
@@ -390,7 +397,9 @@ async fn media_blocks_http_dangling_markup_without_blocking_safe_url_inputs() {
)
.expect("media dangling markup setup should evaluate");
for turn in 0..10 {
// Three rejected selections have two tasks each; the successful audio
// selection has five phases through canplay, including durationchange.
for turn in 0..11 {
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
@@ -1734,7 +1743,14 @@ async fn media_active_cues_update_after_media_load_and_play() {
assert_eq!(before, "0:false");
for phase in ["loadstart", "loadedmetadata", "loadeddata", "canplay"] {
for phase in [
"loadstart",
"durationchange",
"resize",
"loadedmetadata",
"loadeddata",
"canplay",
] {
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
@@ -778,6 +778,9 @@ async fn child_static_media_delays_complete_and_iframe_load_until_loadeddata() {
run_next_page_media_element_event_for_test(&mut vm, &loader, "child media loadstart turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "child media durationchange turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "child media resize turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "child media loadedmetadata turn")
.await;
assert!(
@@ -1195,6 +1198,13 @@ async fn child_dynamic_media_accepted_during_dcl_delays_later_load_turns() {
run_next_page_media_element_event_for_test(&mut vm, &loader, "dynamic media loadstart turn")
.await;
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
"dynamic media durationchange turn",
)
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "dynamic media resize turn").await;
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
@@ -1604,7 +1614,14 @@ async fn moving_pending_child_media_restarts_under_the_new_document_owner() {
"stale child media loadstart turn",
)
.await;
for phase in ["loadstart", "loadedmetadata", "loadeddata", "canplay"] {
for phase in [
"loadstart",
"durationchange",
"resize",
"loadedmetadata",
"loadeddata",
"canplay",
] {
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
@@ -1395,6 +1395,8 @@ async fn main_static_media_load_delays_complete_until_loadeddata_owner_turn() {
);
run_next_page_media_element_event_for_test(&mut vm, &loader, "loadstart owner turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "durationchange owner turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "resize owner turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "loadedmetadata owner turn").await;
assert_eq!(
vm._context_host
@@ -1541,6 +1543,9 @@ async fn main_media_source_mutation_replaces_sequence_without_stale_settlement()
);
run_next_page_media_element_event_for_test(&mut vm, &loader, "new loadstart owner turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "new durationchange owner turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "new resize owner turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "new loadedmetadata owner turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "new loadeddata owner turn").await;
@@ -1640,6 +1645,13 @@ async fn main_media_network_terminal_drives_readiness_on_later_event_turns() {
"resource completion may only enqueue the media event follow-up"
);
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
"network media durationchange turn",
)
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "network media resize turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "network media metadata turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "network media data turn").await;
@@ -1814,7 +1826,14 @@ async fn main_media_source_restart_cancels_exact_network_request_and_stale_termi
.expect("stale media callback trace should evaluate"),
""
);
for phase in ["loadstart", "loadedmetadata", "loadeddata", "canplay"] {
for phase in [
"loadstart",
"durationchange",
"resize",
"loadedmetadata",
"loadeddata",
"canplay",
] {
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
@@ -1886,7 +1905,14 @@ async fn main_media_source_children_reselect_through_parent_sequence() {
assert_ne!(first.id(), second.id());
run_next_page_media_element_event_for_test(&mut vm, &loader, "stale source child media task")
.await;
for phase in ["loadstart", "loadedmetadata", "loadeddata", "canplay"] {
for phase in [
"loadstart",
"durationchange",
"resize",
"loadedmetadata",
"loadeddata",
"canplay",
] {
run_next_page_media_element_event_for_test(
&mut vm,
&loader,
@@ -2101,6 +2127,9 @@ async fn main_text_track_network_terminal_gates_canplay_without_delaying_complet
.expect("already-applied default track mode turn"),
"interactive selection should leave one coalesced default-mode task"
);
run_next_page_media_element_event_for_test(&mut vm, &loader, "media durationchange owner turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "media resize owner turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "media loadedmetadata owner turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "media loadeddata owner turn")
@@ -1144,6 +1144,9 @@ async fn stale_text_track_start_releases_media_canplay_gate() {
.await
.expect("default-mode DOM turn")
);
run_next_page_media_element_event_for_test(&mut vm, &loader, "media durationchange owner turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "media resize owner turn").await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "media loadedmetadata owner turn")
.await;
run_next_page_media_element_event_for_test(&mut vm, &loader, "media loadeddata owner turn")
@@ -514,6 +514,8 @@ async fn default_video_fetch_policy_synthesizes_lifecycle_without_a_network_requ
.expect("register the terminal default-policy event");
for phase in [
"loadstart",
"durationchange",
"resize",
"loadedmetadata",
"loadeddata",
"canplay",
+123
View File
@@ -0,0 +1,123 @@
(async () => {
const checks=[];
const progress=globalThis.__mediaMetadataProgress={stage:'setup',checks};
const assert=(value,message)=>{if(!value)throw Error(message);};
const wait=ms=>new Promise(resolve=>setTimeout(resolve,ms));
const realms=[['main',globalThis],['iframe',document.querySelector('iframe').contentWindow]];
const expected={audio:110255/22050,video:9.8};
const types=['loadstart','durationchange','resize','loadedmetadata','loadeddata','canplay','canplaythrough'];
const load=(callee,media)=>callee.HTMLMediaElement.prototype.load.call(media);
const duration=(callee,media)=>Object.getOwnPropertyDescriptor(callee.HTMLMediaElement.prototype,'duration').get.call(media);
async function until(condition,message) {
const deadline=Date.now()+5000;
while(!condition()) {assert(Date.now()<deadline,message);await wait(5);}
}
function values(media,callee) {
assert(Math.abs(duration(callee,media)-expected[media.localName])<1e-6,'duration must come from the resource timeline');
assert(duration(callee,media)===media.duration,'cross-realm getters must share metadata');
if(media.localName==='video')assert(media.videoWidth===352 && media.videoHeight===288,'natural dimensions must come from the decoded resource');
}
function empty(media,callee) {
assert(Number.isNaN(duration(callee,media)) && media.readyState===0,'no resource metadata means NaN and HAVE_NOTHING');
if(media.localName==='video')assert(media.videoWidth===0 && media.videoHeight===0,'natural dimensions reset with metadata');
}
function record(media,callee) {
const trace=[],records=[];
let complete=false;
for(const type of types)media.addEventListener(type,event=>{
trace.push(type);
records.push({type,duration:duration(callee,media),readyState:media.readyState,
width:media.videoWidth,height:media.videoHeight,bubbles:event.bubbles,cancelable:event.cancelable,
exactTarget:event.target===media});
if(['durationchange','resize','loadedmetadata'].includes(type)) {
Promise.resolve().then(()=>trace.push(type+' microtask'));
}
if(type==='canplaythrough')complete=true;
});
return {trace,records,complete:()=>complete};
}
function begin(media,callee,source) {media.src=source;load(callee,media);}
async function ready(media,state) {
await until(state.complete,'resource events did not complete');
assert(media.error===null && media.readyState>=3,'valid media must become ready');
}
async function replaceDuring(media,callee,source,type,microtask) {
const state=record(media,callee);
let replaced=false;
media.addEventListener(type,()=>{
if(replaced)return;
replaced=true;
const replace=()=>{values(media,callee);load(callee,media);empty(media,callee);};
if(microtask)Promise.resolve().then(replace);else replace();
});
begin(media,callee,source);await ready(media,state);values(media,callee);
const events=state.records.map(record=>record.type);
assert(events.filter(value=>value==='durationchange').length===2,'each usable selection gets one durationchange');
assert(events.filter(value=>value==='loadedmetadata').length===1,'the old loadedmetadata task must be cancelled');
assert(events.filter(value=>value==='resize').length===(media.localName==='audio'?0:type==='resize'?2:1),'resize must belong to the current selection');
return {trace:state.trace.slice()};
}
const cases=[
['initial state and receiver brands',async(media,callee)=>{
empty(media,callee);
let traps=0;
const proxy=new Proxy(media,{get(){traps++;throw Error('get trap');},getPrototypeOf(){traps++;throw Error('prototype trap');}});
const revoked=Proxy.revocable(media,{});revoked.revoke();
for(const receiver of [{},Object.create(media),proxy,revoked.proxy,callee.document.createElement('div')]) {
let caught;try {duration(callee,receiver);}catch(error){caught=error;}
assert(caught instanceof callee.TypeError,'illegal receivers must throw in the getter realm');
}
assert(traps===0,'author Proxy traps must not participate in receiver validation');
}],
['metadata event order and values',async(media,callee,source)=>{
const state=record(media,callee);begin(media,callee,source);await ready(media,state);values(media,callee);
const metadata=media.localName==='video'?['durationchange','resize','loadedmetadata']:['durationchange','loadedmetadata'];
const events=state.records.map(record=>record.type);
assert(JSON.stringify(events)===JSON.stringify(['loadstart',...metadata,'loadeddata','canplay','canplaythrough']),'metadata events precede readiness events exactly once');
for(const type of metadata) {
const event=state.records.find(record=>record.type===type);
assert(event.readyState>=1 && Math.abs(event.duration-expected[media.localName])<1e-6,'metadata callbacks must see initialized duration and readyState');
if(media.localName==='video')assert(event.width===352 && event.height===288,'durationchange and resize must see natural dimensions');
const next=events[events.indexOf(type)+1];
assert(state.trace.indexOf(type+' microtask')<state.trace.indexOf(next),'each metadata event uses a separate task');
}
return {duration:media.duration,width:media.videoWidth,height:media.videoHeight,trace:state.trace.slice()};
}],
['metadata event target and flags',async(media,callee,source)=>{
const state=record(media,callee);begin(media,callee,source);await ready(media,state);values(media,callee);
const events=state.records.filter(record=>['durationchange','resize','loadedmetadata'].includes(record.type));
for(const event of events)assert(!event.bubbles && !event.cancelable && event.exactTarget,'metadata event target and flags: '+JSON.stringify(event));
return {events};
}],
['load resets metadata without durationchange',async(media,callee,source)=>{
const state=record(media,callee);begin(media,callee,source);await ready(media,state);values(media,callee);
const before=state.records.filter(record=>record.type==='durationchange').length;
media.removeAttribute('src');load(callee,media);empty(media,callee);
await wait(40);empty(media,callee);
assert(state.records.filter(record=>record.type==='durationchange').length===before,'resetting duration to NaN must not fire durationchange');
}],
['durationchange replaces selection',(media,callee,source)=>replaceDuring(media,callee,source,'durationchange',false)],
['durationchange microtask replaces selection',(media,callee,source)=>replaceDuring(media,callee,source,'durationchange',true)],
['clones start without resource metadata',async(media,callee,source)=>{
const state=record(media,callee);begin(media,callee,source);await ready(media,state);values(media,callee);
const clone=media.cloneNode(true);empty(clone,callee);
assert(clone.getAttribute('src')===media.getAttribute('src'),'cloning preserves the source attribute');
clone.removeAttribute('src');load(callee,clone);
}],
];
try {
for(const [ownerName,owner] of realms)for(const [calleeName,callee] of realms)
for(const kind of ['audio','video'])for(const transport of ['data','http']) {
const group=kind==='video'?[...cases,['resize replaces selection',(media,callee,source)=>replaceDuring(media,callee,source,'resize',false)]]:cases;
for(const [name,body] of group) {
const label=`${ownerName}/${calleeName}/${kind}/${transport}/${name}`;
progress.stage=label;
const media=owner.document.createElement(kind);owner.document.body.appendChild(media);
try {const facts=await body(media,callee,__mediaMetadataSources[transport][kind]);checks.push({name:label,passed:true,...facts});}
catch(error){checks.push({name:label,passed:false,detail:String(error)});}
finally {media.pause();media.removeAttribute('src');load(callee,media);media.remove();}
}
}
} catch(error) {checks.push({name:'metadata fixture setup',passed:false,detail:String(error)});}
globalThis.__uiEventResults={checks,total:checks.length};
})()