mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(media): queue volume changes and validate volume range
This commit is contained in:
@@ -7,9 +7,6 @@ use crate::{
|
||||
};
|
||||
|
||||
pub(super) enum PendingMediaElementEventPayload {
|
||||
VolumeChange {
|
||||
media_handle: DomHandle,
|
||||
},
|
||||
Playback(super::media_playback::MediaPlaybackTask),
|
||||
Seeking {
|
||||
media_handle: DomHandle,
|
||||
@@ -40,19 +37,6 @@ pub(super) type MediaElementEventState = ExactWindowDocumentTaskLedger<
|
||||
>;
|
||||
|
||||
impl PageScriptHost {
|
||||
pub(crate) fn queue_media_volume_change(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
media_handle: DomHandle,
|
||||
) -> bool {
|
||||
self.queue_media_element_event_for_node(
|
||||
scope,
|
||||
media_handle,
|
||||
RendererPageMediaElementEventTaskKind::VolumeChange,
|
||||
PendingMediaElementEventPayload::VolumeChange { media_handle },
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn queue_remote_playback_availability(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
@@ -228,13 +212,6 @@ impl PageScriptHost {
|
||||
let dispatch_scope = target.dispatch_scope();
|
||||
let previous_scope = dispatch_scope.enter(scope);
|
||||
let dispatched = match payload {
|
||||
PendingMediaElementEventPayload::VolumeChange { media_handle } => {
|
||||
crate::native_bridge::element::dispatch_media_volume_change(
|
||||
scope,
|
||||
host_ptr,
|
||||
media_handle,
|
||||
)
|
||||
}
|
||||
PendingMediaElementEventPayload::Playback(task) => task.dispatch(scope, host_ptr),
|
||||
PendingMediaElementEventPayload::RemotePlaybackAvailability(callback) => {
|
||||
callback.invoke(scope, host_ptr)
|
||||
@@ -311,8 +288,7 @@ impl PageScriptHost {
|
||||
} => {
|
||||
let _ = self.cancel_pending_media_load_sequence_if_matches(media_handle, sequence);
|
||||
}
|
||||
PendingMediaElementEventPayload::VolumeChange { .. }
|
||||
| PendingMediaElementEventPayload::Seeking { .. }
|
||||
PendingMediaElementEventPayload::Seeking { .. }
|
||||
| PendingMediaElementEventPayload::Playback(_)
|
||||
| PendingMediaElementEventPayload::RemotePlaybackAvailability(_)
|
||||
| PendingMediaElementEventPayload::SeekCompletion { .. }
|
||||
|
||||
@@ -110,6 +110,7 @@ struct StableWork {
|
||||
|
||||
enum PlaybackOperation {
|
||||
Emptied,
|
||||
VolumeChange,
|
||||
Play,
|
||||
Waiting,
|
||||
Playing,
|
||||
@@ -287,6 +288,11 @@ impl PageScriptHost {
|
||||
operation: PlaybackOperation,
|
||||
promises: Vec<Rc<PlayPromise>>,
|
||||
) {
|
||||
let kind = if matches!(operation, PlaybackOperation::VolumeChange) {
|
||||
RendererPageMediaElementEventTaskKind::VolumeChange
|
||||
} else {
|
||||
RendererPageMediaElementEventTaskKind::Playback
|
||||
};
|
||||
let Some(task) = self.capture_media_playback_task(media, operation, promises) else {
|
||||
return;
|
||||
};
|
||||
@@ -294,7 +300,7 @@ impl PageScriptHost {
|
||||
if let Some(target) = target {
|
||||
let _ = self.queue_media_element_event_for_target(
|
||||
target,
|
||||
RendererPageMediaElementEventTaskKind::Playback,
|
||||
kind,
|
||||
super::media_element_events::PendingMediaElementEventPayload::Playback(task),
|
||||
);
|
||||
}
|
||||
@@ -415,6 +421,17 @@ impl PageScriptHost {
|
||||
self.queue_playback(scope, media, PlaybackOperation::Emptied, Vec::new());
|
||||
}
|
||||
|
||||
pub(crate) fn queue_media_volume_change<'s>(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
media: DomHandle,
|
||||
receiver: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
if self.bind_media_playback_global(scope, media, receiver) {
|
||||
self.queue_playback(scope, media, PlaybackOperation::VolumeChange, Vec::new());
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn notify_media_playing(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
@@ -583,6 +600,10 @@ impl MediaPlaybackTask {
|
||||
fire(scope, host, self.media, "emptied");
|
||||
None
|
||||
}
|
||||
PlaybackOperation::VolumeChange => {
|
||||
fire(scope, host, self.media, "volumechange");
|
||||
None
|
||||
}
|
||||
PlaybackOperation::Play => {
|
||||
fire(scope, host, self.media, "play");
|
||||
None
|
||||
|
||||
@@ -608,7 +608,7 @@ pub(in crate::native_bridge) use media::queue_text_track_load_if_source;
|
||||
pub(crate) use media::{
|
||||
MediaLoadEventPhase, apply_default_text_track_mode_for_track, apply_media_resource_selection,
|
||||
apply_text_track_load_task, dispatch_media_load_event_phase, dispatch_media_seek_completion,
|
||||
dispatch_media_seeking_event, dispatch_media_volume_change, dispatch_text_track_list_event,
|
||||
dispatch_media_seeking_event, dispatch_text_track_list_event,
|
||||
queue_default_text_track_mode_if_needed, queue_media_canplay_after_text_tracks,
|
||||
queue_media_load_for_explicit_request, queue_media_load_if_needed,
|
||||
queue_media_load_if_source_or_loading_change, queue_media_load_network_terminal_followup,
|
||||
|
||||
@@ -7,9 +7,8 @@ const MEDIA_ERROR_OBJECT_SLOT: &str = "__moliMediaElementErrorObject";
|
||||
const MEDIA_ERROR_OBJECT_CODE_SLOT: &str = "__moliMediaElementErrorObjectCode";
|
||||
|
||||
use super::super::{
|
||||
construct_simple_event, dispatch_public_event, dispatch_text_control_event,
|
||||
html_media_element_getter_receiver, html_media_element_setter_receiver,
|
||||
refresh_media_active_text_track_cues,
|
||||
construct_simple_event, dispatch_public_event, html_media_element_getter_receiver,
|
||||
html_media_element_setter_receiver, refresh_media_active_text_track_cues,
|
||||
};
|
||||
|
||||
pub(in crate::native_bridge) fn media_paused_getter_function<'s>(
|
||||
@@ -143,7 +142,7 @@ pub(in crate::native_bridge) fn media_volume_setter_function<'s>(
|
||||
.and_then(Node::as_element)
|
||||
.map(Element::media_volume);
|
||||
if runtime.set_media_volume(handle, number) && previous != Some(number) {
|
||||
runtime.queue_media_volume_change(scope, handle);
|
||||
runtime.queue_media_volume_change(scope, handle, args.this());
|
||||
}
|
||||
rv.set_undefined();
|
||||
}
|
||||
@@ -181,7 +180,7 @@ pub(in crate::native_bridge) fn media_muted_setter_function<'s>(
|
||||
let runtime = unsafe { &mut *runtime_ptr };
|
||||
let muted = args.get(0).boolean_value(scope);
|
||||
if runtime.set_media_muted(handle, muted) {
|
||||
runtime.queue_media_volume_change(scope, handle);
|
||||
runtime.queue_media_volume_change(scope, handle, args.this());
|
||||
}
|
||||
rv.set_undefined();
|
||||
}
|
||||
@@ -291,21 +290,6 @@ fn schedule_media_seek_completion(
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn dispatch_media_volume_change(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
runtime_ptr: *mut crate::native_bridge::PageScriptHost,
|
||||
handle: DomHandle,
|
||||
) -> bool {
|
||||
if !media_element_is_current_event_target(unsafe { &*runtime_ptr }, handle) {
|
||||
return false;
|
||||
}
|
||||
let Some(event) = construct_simple_event(scope, "volumechange", false, false, false) else {
|
||||
return false;
|
||||
};
|
||||
let _ = dispatch_public_event(scope, runtime_ptr, handle, event);
|
||||
true
|
||||
}
|
||||
|
||||
pub(crate) fn dispatch_media_seeking_event(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
runtime_ptr: *mut crate::native_bridge::PageScriptHost,
|
||||
|
||||
@@ -4,6 +4,170 @@ use crate::page_task_queue::{
|
||||
PageMediaElementEventTargetEffect, RendererPageMediaElementEventTaskKind,
|
||||
};
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn media_volume_controls_preserve_tasks_realms_defaults_and_brands() {
|
||||
run_page_vm_async_test(async move {
|
||||
let loader =
|
||||
crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
|
||||
let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake(
|
||||
&loader,
|
||||
Url::parse("https://media-volume-control.test/")?,
|
||||
);
|
||||
page.vm_mut()
|
||||
.set_layout_policy(moli_page_types::LayoutPolicy::Mock);
|
||||
page.vm_mut()
|
||||
.eval("document.body.innerHTML = '<iframe></iframe>'")?;
|
||||
page.vm_mut().eval(include_str!(
|
||||
"../../../../tests/fixtures/media-volume-control.js"
|
||||
))?;
|
||||
let deadline = Instant::now() + Duration::from_secs(45);
|
||||
while page.vm_mut().eval("typeof __uiEventResults")? == "undefined" {
|
||||
let _ = page
|
||||
.run_next_child_frame_task_source_for_semantic_test()
|
||||
.await;
|
||||
let _ = page
|
||||
.run_exact_selected_page_task_for_test(
|
||||
PageSelectedTaskTestSelector::MediaElementEvent,
|
||||
&loader,
|
||||
)
|
||||
.await?;
|
||||
// Timers belong only to explicit quiet-period checks and watchdogs
|
||||
// in the shared fixture; notifications use the media task source.
|
||||
let _ = page
|
||||
.run_one_due_timer_selected_task_for_test(&loader)
|
||||
.await?;
|
||||
anyhow::ensure!(
|
||||
Instant::now() < deadline,
|
||||
"volume fixture did not finish: {}",
|
||||
page.vm_mut().eval("__mediaVolumeProgress.stage")?
|
||||
);
|
||||
tokio::time::sleep(Duration::from_millis(1)).await;
|
||||
}
|
||||
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"], 176,
|
||||
"all media/realm/windowless combinations must run"
|
||||
);
|
||||
Ok::<_, anyhow::Error>(())
|
||||
})
|
||||
.await
|
||||
.expect("native media volume state and task semantics");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn media_volumechange_reentrancy_uses_separate_tasks_without_draining_timers() {
|
||||
run_page_vm_async_test(async move {
|
||||
let loader =
|
||||
crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
|
||||
let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake(
|
||||
&loader,
|
||||
Url::parse("https://media-volume-order.test/")?,
|
||||
);
|
||||
page.vm_mut().eval(
|
||||
r#"
|
||||
globalThis.volumeEvents = [];
|
||||
globalThis.media = new Audio();
|
||||
media.onvolumechange = event => {
|
||||
volumeEvents.push('event:' + media.volume + ':' + event.isTrusted);
|
||||
if (media.volume === 0.5) {
|
||||
media.volume = 0.25;
|
||||
Promise.resolve().then(() => volumeEvents.push('microtask'));
|
||||
}
|
||||
};
|
||||
setTimeout(() => volumeEvents.push('timer'), 0);
|
||||
media.volume = 0.5;
|
||||
"#,
|
||||
)?;
|
||||
assert_eq!(page.vm_mut().eval("volumeEvents.join('|')")?, "");
|
||||
assert!(
|
||||
page.run_exact_selected_page_task_for_test(
|
||||
PageSelectedTaskTestSelector::MediaElementEvent,
|
||||
&loader,
|
||||
)
|
||||
.await?
|
||||
);
|
||||
assert_eq!(
|
||||
page.vm_mut().eval("volumeEvents.join('|')")?,
|
||||
"event:0.5:true|microtask"
|
||||
);
|
||||
assert!(
|
||||
page.vm().has_ready_timeout(),
|
||||
"volumechange must leave the unrelated timer queued"
|
||||
);
|
||||
assert!(
|
||||
page.run_exact_selected_page_task_for_test(
|
||||
PageSelectedTaskTestSelector::MediaElementEvent,
|
||||
&loader,
|
||||
)
|
||||
.await?
|
||||
);
|
||||
assert_eq!(
|
||||
page.vm_mut().eval("volumeEvents.join('|')")?,
|
||||
"event:0.5:true|microtask|event:0.25:true"
|
||||
);
|
||||
assert!(page.vm().has_ready_timeout());
|
||||
assert!(
|
||||
page.claim_exact_selected_page_task_for_test(
|
||||
PageSelectedTaskTestSelector::MediaElementEvent,
|
||||
)
|
||||
.is_none(),
|
||||
"equal values and completed notifications must not queue extra work"
|
||||
);
|
||||
Ok::<_, anyhow::Error>(())
|
||||
})
|
||||
.await
|
||||
.expect("volumechange owns a separate media task per change");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn media_captured_volumechange_tasks_retire_without_checkpointing_other_work() {
|
||||
run_page_vm_async_test(async move {
|
||||
for retire_document in [false, true] {
|
||||
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())
|
||||
.expect("loader");
|
||||
let (mut page, _source, _wake) = page_vm_with_bound_task_sources_and_owner_wake(
|
||||
&loader, Url::parse("https://media-volume-retire.test/")?,
|
||||
);
|
||||
page.vm_mut().eval(r#"
|
||||
globalThis.retiredVolumeEvents = [];
|
||||
globalThis.media = new Audio();
|
||||
media.onvolumechange = () => retiredVolumeEvents.push('stale event');
|
||||
media.volume = 0.5;
|
||||
"#)?;
|
||||
let captured = page.claim_exact_selected_page_task_for_test(
|
||||
PageSelectedTaskTestSelector::MediaElementEvent,
|
||||
).expect("capture volumechange before cancellation");
|
||||
page.vm_mut().eval(if retire_document {
|
||||
"document.open(); document.write('<!doctype html><body>replacement'); document.close();"
|
||||
} else {
|
||||
"media.load()"
|
||||
})?;
|
||||
page.vm_mut().eval_without_microtask_checkpoint_for_test(r#"
|
||||
globalThis.unrelatedVolumeWork = [];
|
||||
Promise.resolve().then(() => unrelatedVolumeWork.push('microtask'));
|
||||
setTimeout(() => unrelatedVolumeWork.push('timer'), 0);
|
||||
"#)?;
|
||||
page.vm_mut().enqueue_test_pending_runtime_source_load();
|
||||
page.run_claimed_selected_page_task_for_test(captured, &loader).await?;
|
||||
assert_eq!(page.vm_mut().eval_without_microtask_checkpoint_for_test(
|
||||
"retiredVolumeEvents.join('|') + ':' + unrelatedVolumeWork.join('|')",
|
||||
)?, ":", "a retired notification must not dispatch or checkpoint");
|
||||
assert!(page.vm().has_ready_timeout());
|
||||
assert_eq!(page.vm().document_runtime.runtime_script_work().dynamic_scripts
|
||||
.pending_source_load_count_for_test(), 1);
|
||||
}
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.expect("load and Document retirement isolate captured volume notifications");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn media_playback_requests_preserve_realms_tasks_readiness_and_cancellation() {
|
||||
run_page_vm_async_test(async move {
|
||||
|
||||
@@ -0,0 +1,156 @@
|
||||
(async () => {
|
||||
const checks=[];
|
||||
const progress=globalThis.__mediaVolumeProgress={stage:'setup',checks};
|
||||
const assert=(condition,message)=>{if(!condition)throw Error(message);};
|
||||
const setter=(realm,name)=>Object.getOwnPropertyDescriptor(realm.HTMLMediaElement.prototype,name).set;
|
||||
const set=(realm,media,name,value)=>setter(realm,name).call(media,value);
|
||||
const wait=milliseconds=>new Promise(resolve=>setTimeout(resolve,milliseconds));
|
||||
function nextEvents(media,count,action,owner) {
|
||||
const events=[];
|
||||
return new Promise((resolve,reject)=>{
|
||||
const listener=event=>{
|
||||
try{
|
||||
assert(event.target===media && event.currentTarget===media,'native event target');
|
||||
assert(!event.bubbles && !event.composed && event.isTrusted,'native event flags');
|
||||
assert(event instanceof owner.Event,'native event realm');
|
||||
events.push([media.volume,media.muted]);
|
||||
if(events.length===count){media.removeEventListener('volumechange',listener);resolve(events);}
|
||||
}catch(error){media.removeEventListener('volumechange',listener);reject(error);}
|
||||
};
|
||||
media.addEventListener('volumechange',listener);
|
||||
action();
|
||||
assert(events.length===0,'volumechange must be asynchronous');
|
||||
});
|
||||
}
|
||||
const cases=[
|
||||
['volume notifies asynchronously',async(owner,callee,media)=>{
|
||||
set(callee,media,'volume',0.25);
|
||||
assert(media.volume===0.25,'volume changes synchronously');
|
||||
const events=await nextEvents(media,1,()=>{},owner);
|
||||
assert(events.length===1 && events[0][0]===0.25,'listener installed after the setter must observe the event');
|
||||
}],
|
||||
['mute notifies asynchronously',async(owner,callee,media)=>{
|
||||
set(callee,media,'muted',true);
|
||||
assert(media.muted,'mute changes synchronously');
|
||||
const events=await nextEvents(media,1,()=>{},owner);
|
||||
assert(events.length===1 && events[0][1],'muted must queue volumechange');
|
||||
}],
|
||||
['equal values stay silent',async(owner,callee,media)=>{
|
||||
await nextEvents(media,1,()=>set(callee,media,'muted',true),owner);
|
||||
await nextEvents(media,1,()=>set(callee,media,'muted',false),owner);
|
||||
let count=0;media.onvolumechange=()=>count++;
|
||||
set(callee,media,'volume',1);set(callee,media,'volume',1);
|
||||
set(callee,media,'muted',false);set(callee,media,'muted',false);
|
||||
await wait(20);assert(count===0,'equal explicit values must not notify');
|
||||
media.defaultMuted=true;
|
||||
assert(!media.muted,'an equal-value muted setter still records an explicit preference');
|
||||
}],
|
||||
['batched changes do not coalesce',async(owner,callee,media)=>{
|
||||
const events=await nextEvents(media,4,()=>{
|
||||
set(callee,media,'volume',0.25);set(callee,media,'muted',true);
|
||||
set(callee,media,'volume',0.75);set(callee,media,'muted',false);
|
||||
},owner);
|
||||
assert(events.length===4 && events.every(([volume,muted])=>volume===0.75 && !muted),'each real change gets its own task observing current state');
|
||||
}],
|
||||
['reentrant change gets a later task',async(owner,callee,media)=>{
|
||||
const order=[];
|
||||
await new Promise(resolve=>{
|
||||
media.onvolumechange=()=>{
|
||||
if(order.length===0){
|
||||
order.push('first');set(callee,media,'volume',0.25);
|
||||
Promise.resolve().then(()=>order.push('microtask'));
|
||||
}else{order.push('second');resolve();}
|
||||
};
|
||||
set(callee,media,'volume',0.5);
|
||||
assert(order.length===0,'the first event must be asynchronous');
|
||||
});
|
||||
assert(order.join('|')==='first|microtask|second','reentrant notification must wait for another task: '+order);
|
||||
}],
|
||||
['invalid volume preserves state and error realm',async(owner,callee,media)=>{
|
||||
const valid=nextEvents(media,1,()=>set(callee,media,'volume',0.25),owner);
|
||||
for(const value of [-1,-Number.MIN_VALUE,1+Number.EPSILON,2]){
|
||||
let error;try{set(callee,media,'volume',value);}catch(value){error=value;}
|
||||
assert(error instanceof callee.DOMException && error.name==='IndexSizeError' && error.code===1,'range errors must use the setter realm');
|
||||
assert(media.volume===0.25,'an invalid value must not change volume');
|
||||
}
|
||||
for(const value of [NaN,Infinity,-Infinity,Symbol('volume')]){
|
||||
let error;try{set(callee,media,'volume',value);}catch(value){error=value;}
|
||||
assert(error instanceof callee.TypeError,'non-finite or symbol conversion must fail in the setter realm');
|
||||
}
|
||||
let conversions=0,error;
|
||||
try{set(callee,media,'volume',{valueOf(){conversions++;return 2;}});}catch(value){error=value;}
|
||||
assert(conversions===1 && error instanceof callee.DOMException && media.volume===0.25,'convert once before range validation');
|
||||
const sentinel=Error('conversion sentinel');error=undefined;
|
||||
try{set(callee,media,'volume',{valueOf(){throw sentinel;}});}catch(value){error=value;}
|
||||
assert(error===sentinel,'conversion must propagate the original exception');
|
||||
await valid;
|
||||
}],
|
||||
['receiver brands precede conversion',async(owner,callee,media)=>{
|
||||
let conversions=0,traps=0;
|
||||
const converted={valueOf(){conversions++;return 0.25;}};
|
||||
const revoked=Proxy.revocable(media,{});revoked.revoke();
|
||||
const receivers=[{},Object.create(media),Object.create(callee.HTMLMediaElement.prototype),
|
||||
new Proxy(media,{get(){traps++;throw Error('author proxy trap');}}),revoked.proxy];
|
||||
for(const receiver of receivers){
|
||||
let error;try{set(callee,receiver,'volume',converted);}catch(value){error=value;}
|
||||
assert(error instanceof callee.TypeError,'forged and author proxy receivers must reject');
|
||||
}
|
||||
assert(conversions===0 && traps===0 && media.volume===1,'branding must happen before conversion or proxy traps');
|
||||
}],
|
||||
['default muted preference and explicit override',async(owner,callee,media)=>{
|
||||
media.defaultMuted=true;assert(media.muted,'the default muted state must consult the content attribute');
|
||||
set(callee,media,'muted',true);media.removeAttribute('muted');
|
||||
assert(media.muted,'the explicit preference must survive attribute removal');
|
||||
set(callee,media,'muted',false);media.defaultMuted=true;
|
||||
assert(!media.muted,'the explicit false preference must override the content attribute');
|
||||
},'default-muted'],
|
||||
['default to explicit mute state notifies once',async(owner,callee,media)=>{
|
||||
let count=0;media.addEventListener('volumechange',()=>count++);
|
||||
await nextEvents(media,1,()=>set(callee,media,'muted',false),owner);
|
||||
assert(!media.muted && count===1,'default to explicit false must notify even when effective mute is unchanged');
|
||||
set(callee,media,'muted',false);
|
||||
await wait(20);
|
||||
assert(count===1,'a repeated explicit false must not notify');
|
||||
media.defaultMuted=true;
|
||||
assert(!media.muted,'the explicit false preference must override later content attributes');
|
||||
},'mute-state-transition'],
|
||||
['clones reset mutable controls',async(owner,callee,media)=>{
|
||||
set(callee,media,'volume',0.25);set(callee,media,'muted',true);
|
||||
media.currentTime=7;media.playbackRate=2;
|
||||
const copy=media.cloneNode(false);
|
||||
assert(copy.volume===1 && !copy.muted && copy.paused && !copy.seeking && copy.currentTime===0 && copy.playbackRate===1,'a clone must start from fresh media control state');
|
||||
assert(copy.readyState===0 && copy.networkState===0 && copy.error===null,'a clone must not share loaded state or errors');
|
||||
media.defaultMuted=true;set(callee,media,'muted',false);
|
||||
const withDefault=media.cloneNode(true);
|
||||
assert(withDefault.muted && withDefault.defaultMuted,'a clone must apply copied default attributes');
|
||||
assert(media.volume===0.25 && !media.muted && media.currentTime===7,'cloning must preserve the source');
|
||||
}],
|
||||
['native volumechange is not cancelable',async(owner,callee,media)=>{
|
||||
const event=await new Promise(resolve=>{
|
||||
media.onvolumechange=resolve;
|
||||
set(callee,media,'volume',0.25);
|
||||
});
|
||||
event.preventDefault();
|
||||
assert(!event.cancelable && !event.defaultPrevented,'volumechange must use the default noncancelable EventInit');
|
||||
},'event-cancelability'],
|
||||
];
|
||||
try{
|
||||
const realms=[['main',globalThis],['iframe',document.querySelector('iframe').contentWindow]];
|
||||
for(const [ownerName,owner] of realms)for(const [calleeName,callee] of realms)
|
||||
for(const kind of ['audio','video'])for(const windowless of [false,true]){
|
||||
const doc=windowless?owner.document.implementation.createHTMLDocument(''):owner.document;
|
||||
for(const [name,body,category] of cases){
|
||||
const media=doc.createElement(kind);doc.body.appendChild(media);
|
||||
const label=`${ownerName}/${calleeName}/${kind}/${windowless?'windowless':'live'}/${name}`;
|
||||
progress.stage=label;let timeout;
|
||||
try{
|
||||
await Promise.race([body(owner,callee,media),new Promise((_,reject)=>{timeout=setTimeout(()=>reject(Error('control case timeout')),900);})]);
|
||||
if(windowless)assert(doc.defaultView===null && doc.hidden,'media control must not associate a Window with an inert Document');
|
||||
checks.push({name:label,category:category||'common',passed:true});
|
||||
}catch(error){checks.push({name:label,category:category||'common',passed:false,detail:String(error)});}
|
||||
finally{clearTimeout(timeout);media.remove();media.load();}
|
||||
}
|
||||
}
|
||||
}catch(error){checks.push({name:'volume control setup',passed:false,detail:String(error)});}
|
||||
globalThis.__uiEventResults={checks,total:checks.length};
|
||||
})()
|
||||
Reference in New Issue
Block a user