From a447004edcdd67892dab8b4ef0a36e35a70b2aca Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 16 Oct 2026 05:15:56 +0800 Subject: [PATCH] fix(media): preserve default start positions and seek notifications --- moli-dom/src/native/element/control_state.rs | 14 ++ moli-dom/src/native/element/mod.rs | 14 ++ moli-dom/src/native/host/clone.rs | 3 + moli-dom/src/native/host/mutation/state.rs | 6 + .../src/document_runtime/mutation_commands.rs | 9 ++ .../context_host/media_playback.rs | 14 ++ .../context_host/media_playback/video.rs | 21 ++- .../native_bridge/element/media/attributes.rs | 78 +++++++++--- .../src/native_bridge/element/media/state.rs | 93 ++++++++++++-- .../element/media/time_ranges.rs | 16 ++- .../page_vm/tests/media_element_event.rs | 105 +++++++++++++-- .../tests/extracted/owner_lifecycle.rs | 22 ++++ .../src/script_vm/tests/browser_api/media.rs | 56 ++++++-- .../tests/fixtures/media-default-start.js | 120 ++++++++++++++++++ 14 files changed, 511 insertions(+), 60 deletions(-) create mode 100644 moli-renderer-v8/tests/fixtures/media-default-start.js diff --git a/moli-dom/src/native/element/control_state.rs b/moli-dom/src/native/element/control_state.rs index 3c656b5de42..7302a094535 100644 --- a/moli-dom/src/native/element/control_state.rs +++ b/moli-dom/src/native/element/control_state.rs @@ -166,6 +166,7 @@ pub struct ElementControlState { media_seek_token: u64, media_playback_rate: Option, media_current_time: Option, + media_default_start_position: Option, media_ready_state: Option, media_network_state: Option, media_error_code: Option, @@ -331,6 +332,7 @@ impl ElementControlState { state.media_seeking = Some(false); state.media_playback_rate = Some(1.0); state.media_current_time = Some(0.0); + state.media_default_start_position = Some(0.0); state.media_ready_state = Some(0); state.media_network_state = Some(0); state.media_error_code = None; @@ -478,6 +480,10 @@ impl ElementControlState { self.media_current_time } + pub fn media_default_start_position(&self) -> Option { + self.media_default_start_position + } + pub fn media_ready_state(&self) -> Option { self.media_ready_state } @@ -865,6 +871,14 @@ impl ElementControlState { true } + pub fn set_media_default_start_position(&mut self, position: f64) -> bool { + if self.media_default_start_position == Some(position) { + return false; + } + self.media_default_start_position = Some(position); + true + } + pub fn set_media_ready_state(&mut self, ready_state: u32) -> bool { if self.media_ready_state == Some(ready_state) { return false; diff --git a/moli-dom/src/native/element/mod.rs b/moli-dom/src/native/element/mod.rs index 9e7d9ef469f..9f7a5aa4686 100644 --- a/moli-dom/src/native/element/mod.rs +++ b/moli-dom/src/native/element/mod.rs @@ -1153,6 +1153,20 @@ impl Element { self.control_state().media_current_time().unwrap_or(0.0) } + pub fn media_default_start_position(&self) -> f64 { + self.control_state() + .media_default_start_position() + .unwrap_or(0.0) + } + + pub fn set_media_default_start_position(&mut self, position: f64) -> bool { + if !self.is_html_media() { + return false; + } + self.control_state_mut() + .set_media_default_start_position(position) + } + pub fn set_media_current_time(&mut self, current_time: f64) -> bool { if !self.is_html_media() { return false; diff --git a/moli-dom/src/native/host/clone.rs b/moli-dom/src/native/host/clone.rs index ebd8ec76852..53bad06a1c9 100644 --- a/moli-dom/src/native/host/clone.rs +++ b/moli-dom/src/native/host/clone.rs @@ -1178,6 +1178,7 @@ mod tests { source.set_media_volume(media, 0.25); source.set_media_paused(media, false); source.set_media_current_time(media, 7.0); + source.set_media_default_start_position(media, 3.0); source.set_media_playback_rate(media, 2.0); source.set_media_ready_state(media, 4); source.set_media_network_state(media, 1); @@ -1200,6 +1201,7 @@ mod tests { assert_eq!(element.media_volume(), 1.0); assert!(element.media_paused()); assert_eq!(element.media_current_time(), 0.0); + assert_eq!(element.media_default_start_position(), 0.0); assert_eq!(element.media_playback_rate(), 1.0); assert_eq!(element.media_ready_state(), 0); assert_eq!(element.media_network_state(), 0); @@ -1210,6 +1212,7 @@ mod tests { assert_eq!(original.media_muted(), !default_muted); assert_eq!(original.media_volume(), 0.25); assert_eq!(original.media_current_time(), 7.0); + assert_eq!(original.media_default_start_position(), 3.0); } } } diff --git a/moli-dom/src/native/host/mutation/state.rs b/moli-dom/src/native/host/mutation/state.rs index adc3cc28196..b3d1e2b9dec 100644 --- a/moli-dom/src/native/host/mutation/state.rs +++ b/moli-dom/src/native/host/mutation/state.rs @@ -643,6 +643,12 @@ impl DomHost { did_change } + pub fn set_media_default_start_position(&mut self, handle: DomHandle, position: f64) -> bool { + self.node_mut(handle) + .and_then(|node| node.data_mut().as_element_mut()) + .is_some_and(|element| element.set_media_default_start_position(position)) + } + pub fn set_media_ready_state(&mut self, handle: DomHandle, ready_state: u32) -> bool { let did_change = { let Some(element) = self diff --git a/moli-renderer-v8/src/document_runtime/mutation_commands.rs b/moli-renderer-v8/src/document_runtime/mutation_commands.rs index fcb6e745c1a..11849b15462 100644 --- a/moli-renderer-v8/src/document_runtime/mutation_commands.rs +++ b/moli-renderer-v8/src/document_runtime/mutation_commands.rs @@ -1716,6 +1716,15 @@ impl DocumentRuntime { self.dom_host.set_media_current_time(handle, current_time) } + pub(crate) fn set_media_default_start_position( + &mut self, + handle: DomHandle, + position: f64, + ) -> bool { + self.dom_host + .set_media_default_start_position(handle, position) + } + pub(crate) fn set_media_ready_state(&mut self, handle: DomHandle, ready_state: u32) -> bool { self.dom_host.set_media_ready_state(handle, ready_state) } 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 88ac431c16f..3c896938991 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 @@ -130,6 +130,7 @@ enum PlaybackOperation { Playing, Resolve, Pause, + Seeked, Reject(MediaPlayError), } @@ -249,6 +250,7 @@ impl PageScriptHost { ) { self.stop_media_clock(media); self.cancel_media_video_resource(media); + let _ = self.dom_host_mut().advance_media_seek_token(media); let promises = self .media_playback .elements @@ -503,6 +505,14 @@ impl PageScriptHost { self.queue_playback(scope, media, PlaybackOperation::Emptied, Vec::new()); } + pub(crate) fn queue_media_seeked( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + media: DomHandle, + ) { + self.queue_playback(scope, media, PlaybackOperation::Seeked, Vec::new()); + } + pub(crate) fn queue_media_volume_change<'s>( &mut self, scope: &mut v8::PinScope<'s, '_>, @@ -714,6 +724,10 @@ impl MediaPlaybackTask { None } PlaybackOperation::Resolve => None, + PlaybackOperation::Seeked => { + fire(scope, host, self.media, "seeked"); + None + } PlaybackOperation::Pause => { fire(scope, host, self.media, "timeupdate"); if !unsafe { &*host }.playback_is_current(self.media, self.document, self.epoch) { 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 4e9f8499439..8422f266bbb 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 @@ -435,27 +435,34 @@ impl PageScriptHost { &mut self, scope: &mut v8::PinScope<'_, '_>, media: DomHandle, - ) { + ) -> bool { if self .dom_host() .node(media) .and_then(crate::dom::native::Node::as_element) .is_none_or(|element| element.media_ready_state() < 2) { - return; + return false; } - let token = self + let Some(video) = self .media_playback .elements .get_mut(&media) .and_then(|state| state.video.as_mut()) - .filter(|video| { - video.pending.is_none() && video.decoded_position == Some(video.desired_position) - }) - .and_then(|video| video.seek_token.take()); + .filter(|video| video.seek_token.is_some()) + else { + return false; + }; + let token = + if video.pending.is_none() && video.decoded_position == Some(video.desired_position) { + video.seek_token.take() + } else { + None + }; if let Some(token) = token { self.queue_media_seek_completion(scope, media, token); } + true } pub(crate) fn media_video_metadata( 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 61085ef6faf..ae6f95124fb 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs @@ -655,15 +655,16 @@ impl MediaLoadEventPhase { } } - fn next(self, is_video: bool) -> Option { + fn next(self) -> Option { match self { - 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), - Self::CanPlayThrough | Self::Error => None, + Self::LoadStart + | Self::DurationChange + | Self::Resize + | Self::CanPlayThrough + | Self::Error => None, } } } @@ -706,6 +707,7 @@ pub(crate) fn dispatch_media_load_event_phase( | MediaLoadEventPhase::CanPlayThrough => {} MediaLoadEventPhase::LoadedData => { let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 2); + super::state::finish_media_seek_after_loaded_data(scope, runtime_ptr, handle); } MediaLoadEventPhase::CanPlay => { let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 4); @@ -754,8 +756,11 @@ pub(crate) fn dispatch_media_load_event_phase( queue_media_load_terminal_followup_if_ready(scope, runtime_ptr, handle, sequence, followup); return dispatched; } - if phase == MediaLoadEventPhase::LoadedData { - unsafe { &mut *runtime_ptr }.finish_video_seek_if_ready(scope, handle); + if matches!( + phase, + MediaLoadEventPhase::DurationChange | MediaLoadEventPhase::Resize + ) { + return dispatched; } if phase == MediaLoadEventPhase::LoadedData && unsafe { &mut *runtime_ptr } @@ -763,12 +768,7 @@ pub(crate) fn dispatch_media_load_event_phase( { return dispatched; } - 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 Some(next) = phase.next() else { let _ = unsafe { &mut *runtime_ptr } .finish_pending_media_load_sequence_if_matches(handle, sequence); return dispatched; @@ -825,16 +825,54 @@ fn queue_media_load_terminal_followup_if_ready( let Some(followup) = followup else { return; }; - let phase = match followup { - PendingMediaLoadTerminalFollowup::Ready => { - let _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 1); - MediaLoadEventPhase::DurationChange + if !unsafe { &*runtime_ptr }.pending_media_load_sequence_is_current(handle, sequence) { + return; + } + if matches!(followup, PendingMediaLoadTerminalFollowup::Failed) { + if !queue_media_load_event_phase( + scope, + runtime_ptr, + handle, + sequence, + MediaLoadEventPhase::Error, + ) { + let _ = unsafe { &mut *runtime_ptr } + .cancel_pending_media_load_sequence_if_matches(handle, sequence); + } + return; + } + 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 _ = unsafe { &mut *runtime_ptr }.set_media_ready_state(handle, 1); + for phase in [ + MediaLoadEventPhase::DurationChange, + MediaLoadEventPhase::Resize, + MediaLoadEventPhase::LoadedMetadata, + ] { + if phase == MediaLoadEventPhase::Resize && !is_video { + continue; + } + if queue_media_load_event_phase(scope, runtime_ptr, handle, sequence, phase) { + continue; } - PendingMediaLoadTerminalFollowup::Failed => MediaLoadEventPhase::Error, - }; - if !queue_media_load_event_phase(scope, runtime_ptr, handle, sequence, phase) { let _ = unsafe { &mut *runtime_ptr } .cancel_pending_media_load_sequence_if_matches(handle, sequence); + return; + } + let start = unsafe { &*runtime_ptr } + .dom_host() + .node(handle) + .and_then(crate::dom::native::Node::as_element) + .map_or( + 0.0, + crate::dom::native::Element::media_default_start_position, + ); + let _ = unsafe { &mut *runtime_ptr }.set_media_default_start_position(handle, 0.0); + if start > 0.0 { + super::state::seek_media_to(scope, runtime_ptr, handle, start); } } 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 f3e6478d191..9b486c9286e 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/state.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/state.rs @@ -238,7 +238,14 @@ pub(in crate::native_bridge) fn media_current_time_getter_function<'s>( .dom_host() .node(handle) .and_then(Node::as_element) - .map(Element::media_current_time) + .map(|element| { + let start = element.media_default_start_position(); + if start != 0.0 { + start + } else { + element.media_current_time() + } + }) .unwrap_or(0.0); rv.set(v8::Number::new(scope, value).into()); } @@ -257,19 +264,35 @@ pub(in crate::native_bridge) fn media_current_time_setter_function<'s>( let Some(number) = media_double_value(scope, args.get(0), "currentTime") else { return; }; - let changed = { - let runtime = unsafe { &mut *runtime_ptr }; - let time_changed = runtime.set_media_current_time(handle, number.max(0.0)); - let seeking_changed = runtime.set_media_seeking(handle, true); - time_changed || seeking_changed - }; - refresh_media_active_text_track_cues(scope, runtime_ptr, handle); - if changed { - schedule_media_seek_completion(scope, runtime_ptr, handle); + if unsafe { &*runtime_ptr } + .dom_host() + .node(handle) + .and_then(Node::as_element) + .is_some_and(|element| element.media_ready_state() == 0) + { + unsafe { &mut *runtime_ptr }.set_media_default_start_position(handle, number); + } else { + seek_media_to(scope, runtime_ptr, handle, number); } rv.set_undefined(); } +pub(in crate::native_bridge) fn seek_media_to( + scope: &mut v8::PinScope<'_, '_>, + runtime_ptr: *mut crate::native_bridge::PageScriptHost, + handle: DomHandle, + position: f64, +) { + { + let runtime = unsafe { &mut *runtime_ptr }; + let duration = runtime.media_duration(handle).unwrap_or(f64::INFINITY); + runtime.set_media_seeking(handle, true); + runtime.set_media_current_time(handle, position.max(0.0).min(duration)); + } + schedule_media_seek_completion(scope, runtime_ptr, handle); + refresh_media_active_text_track_cues(scope, runtime_ptr, handle); +} + fn schedule_media_seek_completion( scope: &mut v8::PinScope<'_, '_>, runtime_ptr: *mut crate::native_bridge::PageScriptHost, @@ -288,11 +311,43 @@ fn schedule_media_seek_completion( if unsafe { &mut *runtime_ptr }.defer_video_seek_completion(handle, token) { return; } + if unsafe { &*runtime_ptr } + .dom_host() + .node(handle) + .and_then(Node::as_element) + .is_some_and(|element| element.media_ready_state() < 2) + { + return; + } if !unsafe { &mut *runtime_ptr }.queue_media_seek_completion(scope, handle, token) { let _ = unsafe { &mut *runtime_ptr }.set_media_seeking(handle, false); } } +pub(in crate::native_bridge) fn finish_media_seek_after_loaded_data( + scope: &mut v8::PinScope<'_, '_>, + runtime_ptr: *mut crate::native_bridge::PageScriptHost, + handle: DomHandle, +) { + let seeking = unsafe { &*runtime_ptr } + .dom_host() + .node(handle) + .and_then(Node::as_element) + .is_some_and(Element::media_seeking); + if !seeking { + return; + } + if unsafe { &mut *runtime_ptr }.finish_video_seek_if_ready(scope, handle) { + return; + } + let Some(token) = unsafe { &*runtime_ptr }.dom_host().media_seek_token(handle) else { + return; + }; + if !unsafe { &mut *runtime_ptr }.defer_video_seek_completion(handle, token) { + let _ = unsafe { &mut *runtime_ptr }.queue_media_seek_completion(scope, handle, token); + } +} + pub(crate) fn dispatch_media_seeking_event( scope: &mut v8::PinScope<'_, '_>, runtime_ptr: *mut crate::native_bridge::PageScriptHost, @@ -301,7 +356,7 @@ pub(crate) fn dispatch_media_seeking_event( if !media_element_is_current_event_target(unsafe { &*runtime_ptr }, handle) { return false; } - dispatch_text_control_event(scope, runtime_ptr, handle, "seeking"); + fire_media_seek_event(scope, runtime_ptr, handle, "seeking"); true } @@ -317,10 +372,24 @@ pub(crate) fn dispatch_media_seek_completion( { return false; } - dispatch_text_control_event(scope, runtime_ptr, handle, "seeked"); + // The completed seek owns its notification even if timeupdate starts a + // new seek. Resource replacement still retires it through the load epoch. + unsafe { &mut *runtime_ptr }.queue_media_seeked(scope, handle); + fire_media_seek_event(scope, runtime_ptr, handle, "timeupdate"); true } +fn fire_media_seek_event( + scope: &mut v8::PinScope<'_, '_>, + runtime_ptr: *mut crate::native_bridge::PageScriptHost, + handle: DomHandle, + event_type: &str, +) { + if let Some(event) = construct_simple_event(scope, event_type, false, false, false) { + let _ = dispatch_public_event(scope, runtime_ptr, handle, event); + } +} + fn media_element_is_current_event_target( runtime: &crate::native_bridge::PageScriptHost, handle: DomHandle, diff --git a/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs b/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs index a375cb86809..5fd8ebcc6d9 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs @@ -30,11 +30,19 @@ fn media_ranges_getter<'s>( member: &'static str, mut rv: v8::ReturnValue<'_, v8::Value>, ) { - if html_media_element_getter_receiver(scope, receiver, member).is_none() { + let Some((runtime_ptr, handle)) = html_media_element_getter_receiver(scope, receiver, member) + else { + return; + }; + if member == "seekable" + && let Some(duration) = unsafe { &*runtime_ptr }.media_duration(handle) + && duration.is_finite() + && duration > 0.0 + { + rv.set(crate::context_bootstrap::new_time_ranges_value(scope, &[(0.0, duration)]).into()); return; } - // The current media backend does not decode/buffer media or advance a - // playback timeline. Do not invent loaded or played ranges from currentTime. - // Each read still returns an independent native snapshot. + // Played intervals and buffering require their own resource state; + // currentTime alone does not establish either range. rv.set(crate::context_bootstrap::new_time_ranges_value(scope, &[]).into()); } 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 6d34ac688c9..3b1744115df 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 @@ -4,6 +4,45 @@ use crate::page_task_queue::{ PageMediaElementEventTargetEffect, RendererPageMediaElementEventTaskKind, }; +async fn load_video_metadata_for_seek_test( + page: &mut PageVm, + loader: &crate::network::ResourceRequestClient, +) -> anyhow::Result<()> { + use base64::Engine; + let audio = base64::engine::general_purpose::STANDARD.encode(include_bytes!( + "../../../../tests/fixtures/media/sound_5.oga" + )); + page.vm_mut().eval(&format!("globalThis.__seekReadyMedia=document.createElement('video');__seekReadyMedia.src='data:audio/ogg;base64,{audio}';"))?; + for phase in [ + "loadstart", + "durationchange", + "resize", + "loadedmetadata", + "loadeddata", + "canplay", + "canplaythrough", + ] { + let task = page + .claim_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, + ) + .unwrap_or_else(|| panic!("loaded media preparation requires {phase}")); + assert_eq!( + task.media_element_event_kind(), + Some(RendererPageMediaElementEventTaskKind::LoadEventPhase) + ); + page.run_claimed_selected_page_task_for_test(task, loader) + .await?; + } + anyhow::ensure!( + page.vm_mut().eval( + "__seekReadyMedia.readyState === 4 && Number.isFinite(__seekReadyMedia.duration)" + )? == "true", + "seek test requires real metadata" + ); + Ok(()) +} + #[tokio::test(flavor = "current_thread")] async fn empty_local_media_fails_before_readiness_without_resetting_controls() { run_page_vm_async_test(async move { @@ -227,7 +266,6 @@ async fn media_metadata_preserves_values_event_tasks_realms_and_selection_cancel 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)")?, )?; @@ -235,6 +273,27 @@ async fn media_metadata_preserves_values_event_tasks_realms_and_selection_cancel .filter(|check| check["passed"] != true).collect(); assert!(failures.is_empty(), "{failures:#?}"); assert_eq!(result["total"], 120); + page.vm_mut().eval("globalThis.__uiEventResults=undefined;globalThis.__mediaTimelineSources=__mediaMetadataSources;")?; + page.vm_mut().eval(include_str!("../../../../tests/fixtures/media-default-start.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, "default start fixture did not finish: {}", + page.vm_mut().eval("__mediaDefaultStartProgress.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"], 128); Ok::<_, anyhow::Error>(()) }).await.expect("media metadata values and owned event sequencing"); } @@ -840,11 +899,12 @@ async fn media_element_event_body_cleans_up_callbacks_before_selected_completion let document_url = Url::parse("https://example.com/media-event-body-boundary").unwrap(); let (mut page_vm, _resource_source, _owner_wake_rx) = page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url); + load_video_metadata_for_seek_test(&mut page_vm, &loader).await?; page_vm.vm_mut().eval( r#" globalThis.__mediaEventTaskBoundary = []; -const media = document.createElement("video"); +const media = globalThis.__seekReadyMedia; media.addEventListener("seeking", () => { __mediaEventTaskBoundary.push("callback"); Promise.resolve().then(() => { @@ -911,6 +971,7 @@ async fn media_event_is_document_exact_across_document_open() { let document_url = Url::parse("https://example.com/media-event-document-open").unwrap(); let (mut page_vm, _resource_source, _owner_wake_rx) = page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url); + load_video_metadata_for_seek_test(&mut page_vm, &loader).await?; let retired_document = page_vm .vm() .current_main_document_task_owner() @@ -919,7 +980,7 @@ async fn media_event_is_document_exact_across_document_open() { page_vm.vm_mut().eval( r#" globalThis.__documentExactMediaEvents = []; -const retiredMedia = document.createElement("video"); +const retiredMedia = globalThis.__seekReadyMedia; for (const type of ["seeking", "seeked"]) { retiredMedia.addEventListener(type, () => __documentExactMediaEvents.push(`retired:${type}`)); } @@ -1026,14 +1087,18 @@ async fn media_seek_events_preserve_fifo_and_exact_seek_token() { let document_url = Url::parse("https://example.com/media-seek-events").unwrap(); let (mut page_vm, _resource_source, _owner_wake_rx) = page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url); + load_video_metadata_for_seek_test(&mut page_vm, &loader).await?; page_vm.vm_mut().eval( r#" globalThis.__documentExactMediaEvents = []; -const currentMedia = document.createElement("video"); -for (const type of ["seeking", "seeked"]) { +const currentMedia = globalThis.__seekReadyMedia; +for (const type of ["seeking", "timeupdate", "seeked"]) { currentMedia.addEventListener(type, () => __documentExactMediaEvents.push(`current:${type}`)); } +currentMedia.addEventListener("timeupdate", () => { + Promise.resolve().then(() => __documentExactMediaEvents.push("current:microtask")); +}); document.body.append(currentMedia); currentMedia.currentTime = 2; "queued-current" @@ -1076,7 +1141,30 @@ currentMedia.currentTime = 2; page_vm .vm_mut() .eval("__documentExactMediaEvents.join('|')")?, - "current:seeking|current:seeked" + "current:seeking|current:timeupdate|current:microtask", + "the timeupdate turn must finish before the seeked notification" + ); + assert_eq!( + page_vm.vm_mut().eval("String(currentMedia.seeking)")?, + "false" + ); + let notification = page_vm + .claim_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::MediaElementEvent, + ) + .expect("a completed seek retains its own notification task"); + assert_eq!( + notification.media_element_event_kind(), + Some(RendererPageMediaElementEventTaskKind::Playback) + ); + page_vm + .run_claimed_selected_page_task_for_test(notification, &loader) + .await?; + assert_eq!( + page_vm + .vm_mut() + .eval("__documentExactMediaEvents.join('|')")?, + "current:seeking|current:timeupdate|current:microtask|current:seeked" ); assert!( page_vm @@ -1084,7 +1172,7 @@ currentMedia.currentTime = 2; PageSelectedTaskTestSelector::MediaElementEvent, ) .is_none(), - "seeking and seeked must consume exactly two source turns" + "seeking, timeupdate and seeked must consume exactly three source turns" ); Ok::<_, anyhow::Error>(()) }) @@ -1100,11 +1188,12 @@ async fn media_event_completion_syncs_a_microtask_created_child_after_the_checkp Url::parse("https://example.com/media-event-microtask-child").unwrap(); let (mut page_vm, _resource_source, _owner_wake_rx) = page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url); + load_video_metadata_for_seek_test(&mut page_vm, &loader).await?; page_vm.vm_mut().eval( r#" globalThis.__mediaEventChildOrder = []; -const media = document.createElement("video"); +const media = globalThis.__seekReadyMedia; media.addEventListener("seeking", () => { __mediaEventChildOrder.push("callback"); Promise.resolve().then(() => { diff --git a/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs b/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs index 482675bc55f..1d7232199b6 100644 --- a/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs +++ b/moli-renderer-v8/src/runtime/tests/extracted/owner_lifecycle.rs @@ -2266,9 +2266,12 @@ document.getElementById("owner-selection").addEventListener("select", event => { } #[tokio::test(flavor = "multi_thread")] async fn owner_scheduler_dispatches_media_events_without_timer_or_observation_command() { + use base64::Engine; + let runtime = JsRuntime::initialize(); let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("default loader"); + loader.set_optional_resource_fetch_enabled(crate::types::SubresourceResourceType::Video, true); let (base_url, effect_request_seen, release_effect_response, effect_server) = spawn_owner_wake_gated_server_with_content_type( "/owner-media-event-applied", @@ -2294,6 +2297,25 @@ for (const type of ["seeking", "seeked"]) { "#, ) .await; + let source = base64::engine::general_purpose::STANDARD.encode(include_bytes!( + "../../../../tests/fixtures/media/sound_5.oga" + )); + let (ready, _) = page + .run_async_command(RendererPageCommand::EvaluateExpression { + expression: format!( + r#"new Promise((resolve, reject) => {{ + const media = document.getElementById("owner-media"); + media.addEventListener("canplaythrough", () => resolve(media.readyState), {{once:true}}); + media.addEventListener("error", () => reject(new Error("seek fixture failed to load")), {{once:true}}); + media.src = "data:audio/ogg;base64,{source}"; + media.load(); +}})"# + ), + await_promise: true, + }) + .await + .expect("seek fixture must have real media metadata before the owner-wake assertion"); + assert_eq!(renderer_json_value(ready), Some(serde_json::json!(4))); let (scheduled, _) = page .run_async_command(RendererPageCommand::EvaluateExpression { expression: r#"document.getElementById("owner-media").currentTime = 1; "scheduled""# 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 bfc7d96ef2f..06ac257dda0 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 @@ -53,6 +53,34 @@ fn media_cue_state_and_list_updates_ignore_author_getters() { ); } +async fn load_video_metadata_for_seek_test( + vm: &mut crate::runtime::PageVmTaskExecutorTestHarness, + loader: &ResourceRequestClient, +) { + use base64::Engine; + let audio = base64::engine::general_purpose::STANDARD.encode(include_bytes!( + "../../../../tests/fixtures/media/sound_5.oga" + )); + vm.eval(&format!("globalThis.__seekReadyMedia=document.createElement('video');__seekReadyMedia.src='data:audio/ogg;base64,{audio}';")) + .expect("load a real media resource before testing seek state"); + for phase in [ + "loadstart", + "durationchange", + "resize", + "loadedmetadata", + "loadeddata", + "canplay", + "canplaythrough", + ] { + run_next_page_media_element_event_for_test(vm, loader, phase).await; + } + assert_eq!( + vm.eval("__seekReadyMedia.readyState === 4 && Number.isFinite(__seekReadyMedia.duration)") + .unwrap(), + "true" + ); +} + #[tokio::test] async fn media_load_honors_media_src_csp() { let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); @@ -600,7 +628,7 @@ fn media_numeric_setters_parse_webidl_values() { }; const currentTimeObject = `${video.currentTime}:${currentTimeCalls}`; video.currentTime = -4; - const currentTimeLowerClamp = video.currentTime; + const currentTimeNegativeDefault = video.currentTime; const currentTimeSymbol = probe(() => { video.currentTime = Symbol('time'); }); const currentTimeInfinity = probe(() => { video.currentTime = Infinity; }); @@ -615,7 +643,7 @@ fn media_numeric_setters_parse_webidl_values() { playbackRateThrowing, playbackRateNaN, currentTimeObject, - currentTimeLowerClamp, + currentTimeNegativeDefault, currentTimeSymbol, currentTimeInfinity ].join('|'); @@ -626,7 +654,7 @@ fn media_numeric_setters_parse_webidl_values() { assert_eq!( result, - "0.25:1|throw:IndexSizeError|throw:IndexSizeError|0.25|throw:TypeError|throw:TypeError|1.5:1|throw:RangeError|throw:TypeError|3.5:1|0|throw:TypeError|throw:TypeError" + "0.25:1|throw:IndexSizeError|throw:IndexSizeError|0.25|throw:TypeError|throw:TypeError|1.5:1|throw:RangeError|throw:TypeError|3.5:1|-4|throw:TypeError|throw:TypeError" ); } @@ -637,6 +665,7 @@ async fn media_pseudo_classes_update_has_ancestor_styles() { "https://media-pseudo-classes.test/", &loader, ); + load_video_metadata_for_seek_test(&mut vm, &loader).await; let result = vm .eval( @@ -668,7 +697,7 @@ async fn media_pseudo_classes_update_has_ancestor_styles() { const subject = document.createElement("section"); subject.id = "subject"; - const video = document.createElement("video"); + const video = globalThis.__seekReadyMedia; subject.appendChild(video); document.body.appendChild(subject); @@ -712,7 +741,7 @@ async fn media_pseudo_classes_update_has_ancestor_styles() { const afterMuted = snapshot(); video.play(); const afterPlay = snapshot(); - video.currentTime = 10; + video.currentTime = 1; const afterSeeking = snapshot(); return [supports, before, afterMuted, afterPlay, afterSeeking].join("|"); })() @@ -736,7 +765,7 @@ async fn media_pseudo_classes_update_has_ancestor_styles() { vm.eval("[__lmMediaPseudo.counts.volumeEvents, __lmMediaPseudo.counts.seekingEvents, __lmMediaPseudo.counts.seekedEvents].join(',')").unwrap(), "1,0,0", ); - for event in ["play", "waiting"] { + for event in ["play", "playing"] { run_next_page_media_element_event_for_test(&mut vm, &loader, event).await; assert_eq!(vm.eval("[__lmMediaPseudo.counts.seekingEvents, __lmMediaPseudo.counts.seekedEvents].join(',')").unwrap(), "0,0"); } @@ -751,6 +780,13 @@ async fn media_pseudo_classes_update_has_ancestor_styles() { "true,1,0" ); + run_next_page_media_element_event_for_test(&mut vm, &loader, "media timeupdate event turn") + .await; + assert_eq!( + vm.eval("[__lmMediaPseudo.video.seeking, __lmMediaPseudo.counts.seekedEvents].join(',')") + .unwrap(), + "false,0" + ); run_next_page_media_element_event_for_test(&mut vm, &loader, "media seeked event turn").await; let after_task = vm @@ -781,6 +817,7 @@ async fn media_seek_completion_ignores_stale_seek_tokens() { "https://media-stale-seek-token.test/", &loader, ); + load_video_metadata_for_seek_test(&mut vm, &loader).await; let result = vm .eval( @@ -790,7 +827,7 @@ async fn media_seek_completion_ignores_stale_seek_tokens() { if (!document.body) { html.appendChild(document.createElement('body')); } - const video = document.createElement('video'); + const video = globalThis.__seekReadyMedia; document.body.appendChild(video); let seekingEvents = 0; let seekedEvents = 0; @@ -807,7 +844,7 @@ async fn media_seek_completion_ignores_stale_seek_tokens() { assert_eq!(result, "true,2,0,0"); - for _ in 0..4 { + for _ in 0..5 { if !vm .run_one_media_element_event_executor_turn(&loader) .await @@ -838,6 +875,7 @@ async fn slotted_media_state_invalidates_shadow_stylesheet_source() { "https://slotted-media-state-shadow.test/", &loader, ); + load_video_metadata_for_seek_test(&mut vm, &loader).await; let result = vm .eval( @@ -858,7 +896,7 @@ async fn slotted_media_state_invalidates_shadow_stylesheet_source() { `; shadow.appendChild(style); shadow.appendChild(document.createElement('slot')); - const video = document.createElement('video'); + const video = globalThis.__seekReadyMedia; host.appendChild(video); document.body.appendChild(host); const before = [video.matches(':seeking'), getComputedStyle(video).color].join(','); diff --git a/moli-renderer-v8/tests/fixtures/media-default-start.js b/moli-renderer-v8/tests/fixtures/media-default-start.js new file mode 100644 index 00000000000..0ec13ce7058 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media-default-start.js @@ -0,0 +1,120 @@ +(async () => { + const checks=[]; + const progress=globalThis.__mediaDefaultStartProgress={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 set=(callee,media,value)=>Object.getOwnPropertyDescriptor(callee.HTMLMediaElement.prototype,'currentTime').set.call(media,value); + const get=(callee,media)=>Object.getOwnPropertyDescriptor(callee.HTMLMediaElement.prototype,'currentTime').get.call(media); + const load=(callee,media)=>callee.HTMLMediaElement.prototype.load.call(media); + async function until(condition,message) { + const deadline=Date.now()+5000; + while(!condition()) {assert(Date.now()seekComplete=true,{once:true}); + let done=false;media.addEventListener('canplaythrough',()=>done=true,{once:true}); + media.src=source;load(callee,media); + await until(()=>done && !media.seeking && seekComplete,'resource did not become ready and finish seeking'); + assert(media.error===null && media.readyState>=3,'valid resource readiness'); + } + const cases=[ + ['cold assignments preserve raw finite values without seeking',async(media,callee)=>{ + let events=0; + for(const type of ['seeking','timeupdate','seeked'])media.addEventListener(type,()=>events++); + for(const value of [1,-1,Number.MAX_VALUE,0,-0,2]) { + set(callee,media,value); + assert(Object.is(get(callee,media),value===0?0:value),'HAVE_NOTHING exposes the default start position'); + assert(media.readyState===0 && !media.seeking,'a cold assignment does not seek'); + } + await wait(20);assert(events===0,'a default start position must not dispatch seek events'); + }], + ['load preserves and applies the last positive default',async(media,callee,source)=>{ + const order=[]; + for(const type of ['durationchange','resize','loadedmetadata','seeking','timeupdate','seeked'])media.addEventListener(type,()=>order.push(type)); + media.addEventListener('timeupdate',()=>queueMicrotask(()=>order.push('timeupdate microtask'))); + set(callee,media,2);set(callee,media,3);set(callee,media,1); + load(callee,media); + assert(get(callee,media)===1 && !media.seeking,'load preserves the pending start preference'); + await ready(media,callee,source,true); + assert(Math.abs(get(callee,media)-1)<1e-6 && media.paused,'metadata applies the default without starting playback'); + assert(order.indexOf('loadedmetadata')=0 && seeking{ + await ready(media,callee,source); + let restarted=false,notifications=0; + media.addEventListener('timeupdate',()=>{ + if(!restarted && !media.seeking && get(callee,media)===1) { + restarted=true;set(callee,media,2); + } + }); + media.addEventListener('seeked',()=>notifications++); + set(callee,media,1); + await until(()=>restarted && notifications===2 && !media.seeking,'both completed seeks must keep their notification'); + assert(get(callee,media)===2,'the reentrant seek reaches its requested position'); + }], + ['negative defaults are cleared when metadata becomes available',async(media,callee,source)=>{ + let seeks=0;media.addEventListener('seeking',()=>seeks++); + set(callee,media,-2);assert(get(callee,media)===-2,'negative default is observable before metadata'); + await ready(media,callee,source); + assert(get(callee,media)===0 && seeks===0,'only a positive default causes an initial seek'); + }], + ['finite resource bounds clamp default and explicit seeks',async(media,callee,source)=>{ + set(callee,media,Number.MAX_VALUE);await ready(media,callee,source,true); + assert(get(callee,media)===media.duration,'initial seek is clamped to the resource end'); + let done=false;media.addEventListener('seeked',()=>done=true,{once:true}); + set(callee,media,-1);await until(()=>done,'lower-bound seek did not finish'); + assert(get(callee,media)===0,'explicit seek is clamped to the earliest position'); + done=false;media.addEventListener('seeked',()=>done=true,{once:true}); + set(callee,media,Number.MAX_VALUE);await until(()=>done,'upper-bound seek did not finish'); + assert(get(callee,media)===media.duration,'explicit seek is clamped to the finite duration'); + const snapshot=media.seekable;assert(snapshot.length===1 && snapshot.start(0)===0 && snapshot.end(0)===media.duration,'the complete resource has a finite seekable range'); + media.removeAttribute('src');load(callee,media); + assert(media.seekable.length===0 && snapshot.length===1,'TimeRanges reads are independent resource snapshots'); + }], + ['conversion observes a reentrant load before choosing seek semantics',async(media,callee,source)=>{ + await ready(media,callee,source); + let conversions=0; + set(callee,media,{valueOf(){conversions++;media.removeAttribute('src');load(callee,media);return 2;}}); + assert(conversions===1 && media.readyState===0 && !media.seeking && get(callee,media)===2,'conversion can return the receiver to HAVE_NOTHING'); + await ready(media,callee,source,true);assert(Math.abs(get(callee,media)-2)<1e-6,'the converted default survives reselection'); + }], + ['clones and imports discard the default start preference',async(media,callee)=>{ + set(callee,media,2); + for(const clone of [media.cloneNode(true),callee.document.importNode(media,true)]) { + assert(get(callee,clone)===0 && !clone.seeking && clone.readyState===0,'clones start with fresh media state'); + } + assert(get(callee,media)===2,'cloning does not mutate the source preference'); + }], + ['receiver checks precede conversion for author and revoked Proxies',async(media,callee)=>{ + let conversions=0,traps=0; + const value={valueOf(){conversions++;return 2;}}; + 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]) { + let caught;try {set(callee,receiver,value);}catch(error){caught=error;} + assert(caught instanceof callee.TypeError,'illegal receiver error belongs to the setter realm'); + } + assert(conversions===0 && traps===0,'invalid receivers must not execute author code'); + }], + ]; + 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']) { + for(const [name,body] of cases) { + 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,__mediaTimelineSources[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:'default start fixture setup',passed:false,detail:String(error)});} + globalThis.__uiEventResults={checks,total:checks.length}; +})()