fix(media): preserve default start positions and seek notifications

This commit is contained in:
ldm0
2026-11-21 20:03:33 +08:00
parent 02c70389ea
commit a447004edc
14 changed files with 511 additions and 60 deletions
@@ -166,6 +166,7 @@ pub struct ElementControlState {
media_seek_token: u64,
media_playback_rate: Option<f64>,
media_current_time: Option<f64>,
media_default_start_position: Option<f64>,
media_ready_state: Option<u32>,
media_network_state: Option<u32>,
media_error_code: Option<u32>,
@@ -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<f64> {
self.media_default_start_position
}
pub fn media_ready_state(&self) -> Option<u32> {
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;
+14
View File
@@ -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;
+3
View File
@@ -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);
}
}
}
@@ -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
@@ -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)
}
@@ -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) {
@@ -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(
@@ -655,15 +655,16 @@ impl MediaLoadEventPhase {
}
}
fn next(self, is_video: bool) -> Option<Self> {
fn next(self) -> Option<Self> {
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);
}
}
@@ -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,
@@ -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());
}
@@ -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(() => {
@@ -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"]) {
</script></body>"#,
)
.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""#
@@ -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(',');
+120
View File
@@ -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()<deadline,message);await wait(5);}
}
async function ready(media,callee,source,waitForInitialSeek=false) {
let seekComplete=!waitForInitialSeek;
if(waitForInitialSeek)media.addEventListener('seeked',()=>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')<order.indexOf('seeking'),'metadata notifications precede the initial seeking event');
const seeking=order.indexOf('seeking'),updated=order.indexOf('timeupdate',seeking);
assert(seeking>=0 && seeking<updated && updated<order.indexOf('seeked'),'initial seek completion event order');
const checkpoint=order.indexOf('timeupdate microtask',updated);
assert(updated<checkpoint && checkpoint<order.indexOf('seeked'),'a microtask checkpoint separates the completion notifications');
return {position:media.currentTime,order:order.slice()};
}],
['a reentrant seek retains the completed seek notification',async(media,callee,source)=>{
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};
})()