From 94e2e6fffc600ae078295cd70dc416cf74f3b36e Mon Sep 17 00:00:00 2001 From: ldm0 Date: Thu, 15 Oct 2026 17:30:49 +0800 Subject: [PATCH] fix(media): queue volume changes and validate volume range --- .../context_host/media_element_events.rs | 26 +-- .../context_host/media_playback.rs | 23 ++- moli-renderer-v8/src/native_bridge/element.rs | 2 +- .../src/native_bridge/element/media/state.rs | 24 +-- .../page_vm/tests/media_element_event.rs | 164 ++++++++++++++++++ .../tests/fixtures/media-volume-control.js | 156 +++++++++++++++++ 6 files changed, 348 insertions(+), 47 deletions(-) create mode 100644 moli-renderer-v8/tests/fixtures/media-volume-control.js diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs b/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs index 2419d44c50c..b808098cf94 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_element_events.rs @@ -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 { .. } diff --git a/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs b/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs index 161ec1ccb07..986b545407c 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/media_playback.rs @@ -110,6 +110,7 @@ struct StableWork { enum PlaybackOperation { Emptied, + VolumeChange, Play, Waiting, Playing, @@ -287,6 +288,11 @@ impl PageScriptHost { operation: PlaybackOperation, promises: Vec>, ) { + 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 diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs index d4c8bae0023..ce104b2bf31 100644 --- a/moli-renderer-v8/src/native_bridge/element.rs +++ b/moli-renderer-v8/src/native_bridge/element.rs @@ -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, diff --git a/moli-renderer-v8/src/native_bridge/element/media/state.rs b/moli-renderer-v8/src/native_bridge/element/media/state.rs index d294bd10683..1f679173ae7 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/state.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/state.rs @@ -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, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs b/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs index efc5da0d915..c4090ef84bf 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/media_element_event.rs @@ -4,6 +4,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 = ''")?; + 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('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 { diff --git a/moli-renderer-v8/tests/fixtures/media-volume-control.js b/moli-renderer-v8/tests/fixtures/media-volume-control.js new file mode 100644 index 00000000000..0de65af8eba --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media-volume-control.js @@ -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}; +})()