mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(media): publish duration and resize before metadata events
This commit is contained in:
@@ -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>(
|
||||
|
||||
@@ -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,
|
||||
|
||||
+18
-1
@@ -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",
|
||||
|
||||
@@ -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};
|
||||
})()
|
||||
Reference in New Issue
Block a user