From 02c70389ea6cb67f49510ae387ea41fcb571fd6c Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 16 Oct 2026 03:25:50 +0800 Subject: [PATCH] fix(media): publish duration and resize before metadata events --- .../context_host/media_playback.rs | 37 +++++ .../context_host/media_playback/video.rs | 7 +- .../native_bridge/element/media/attributes.rs | 31 ++-- .../src/native_bridge/element/media/state.rs | 11 +- moli-renderer-v8/src/network_host/media.rs | 2 +- .../page_vm/tests/media_element_event.rs | 134 ++++++++++++++++-- .../src/script_vm/subresource_fetch.rs | 2 +- .../src/script_vm/tests/browser_api/media.rs | 22 ++- .../extracted/child_document_lifecycle.rs | 19 ++- .../extracted/main_document_lifecycle.rs | 33 ++++- .../tests/extracted/resources_and_media.rs | 3 + .../script_vm/tests/extracted/window_apis.rs | 2 + .../tests/fixtures/media-metadata-events.js | 123 ++++++++++++++++ 13 files changed, 396 insertions(+), 30 deletions(-) create mode 100644 moli-renderer-v8/tests/fixtures/media-metadata-events.js 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 c9d07fc757e..88ac431c16f 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 @@ -75,6 +75,7 @@ struct PlaybackElementState { pending: Vec>, outstanding: Vec>, selection: Option, + duration: Option, clock: Option, video: Option, } @@ -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, + ) -> Result { + 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 { + 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"); diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs b/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs index 658f1947248..4e9f8499439 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback/video.rs @@ -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); } diff --git a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs index 0c8445e8ee2..61085ef6faf 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs @@ -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 { + fn next(self, is_video: bool) -> Option { 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) { diff --git a/moli-renderer-v8/src/native_bridge/element/media/state.rs b/moli-renderer-v8/src/native_bridge/element/media/state.rs index 5ff6ca22f60..f3e6478d191 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/state.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/state.rs @@ -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>( diff --git a/moli-renderer-v8/src/network_host/media.rs b/moli-renderer-v8/src/network_host/media.rs index 74366fa0b6c..48544cff885 100644 --- a/moli-renderer-v8/src/network_host/media.rs +++ b/moli-renderer-v8/src/network_host/media.rs @@ -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, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs b/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs index c06fc0848f9..6d34ac688c9 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs @@ -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='';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('replacement');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, diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch.rs index 75f63ff5b88..b8f2c395334 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch.rs @@ -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, diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs index d40162cc7a2..bfc7d96ef2f 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/media.rs @@ -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, diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs index 377eb434026..f68b0bdf5c8 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs @@ -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, diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs b/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs index e04aa4faa94..e33ddea14c5 100644 --- a/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs +++ b/moli-renderer-v8/src/script_vm/tests/extracted/main_document_lifecycle.rs @@ -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") diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs b/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs index 504820a8a98..bf55145cad8 100644 --- a/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs +++ b/moli-renderer-v8/src/script_vm/tests/extracted/resources_and_media.rs @@ -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") diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs b/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs index 9fedade15d2..a2fd72dcc16 100644 --- a/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs +++ b/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs @@ -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", diff --git a/moli-renderer-v8/tests/fixtures/media-metadata-events.js b/moli-renderer-v8/tests/fixtures/media-metadata-events.js new file mode 100644 index 00000000000..1c8b48b2729 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media-metadata-events.js @@ -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(){ + 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'){ + 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}; +})()