mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(media): preserve default start positions and seek notifications
This commit is contained in:
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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(',');
|
||||
|
||||
@@ -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};
|
||||
})()
|
||||
Reference in New Issue
Block a user