fix(media): queue volume changes and validate volume range

This commit is contained in:
ldm0
2026-11-21 20:03:33 +08:00
parent 99e0315893
commit 94e2e6fffc
6 changed files with 348 additions and 47 deletions
@@ -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 {
+156
View File
@@ -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};
})()