From 5e5eeca80d2248dfd1eaa66c758121683f9d3d0d Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 9 Oct 2026 13:08:20 +0800 Subject: [PATCH] feat(media): add MediaRecorder frontend state and validation --- moli-renderer-v8/src/context_bootstrap.rs | 1 + .../assets/constructor_templates.rs | 8 + .../assets/prototype_bindings.rs | 1 + .../exposed_interfaces/materialize.rs | 1 + .../src/context_bootstrap/media_recorder.rs | 324 ++++++++++++++++++ .../src/context_bootstrap/media_streams.rs | 21 +- .../src/context_bootstrap/specs/registry.rs | 2 +- .../src/context_bootstrap/specs/types.rs | 1 + .../src/script_vm/tests/media_recorder.rs | 113 ++++++ .../script_vm/tests/media_recorder_shell.js | 14 +- .../src/script_vm/tests/media_streams.rs | 2 +- moli-renderer-v8/src/script_vm/tests/mod.rs | 1 + .../tests/fixtures/media-recorder-frontend.js | 170 +++++++++ 13 files changed, 649 insertions(+), 10 deletions(-) create mode 100644 moli-renderer-v8/src/context_bootstrap/media_recorder.rs create mode 100644 moli-renderer-v8/src/script_vm/tests/media_recorder.rs create mode 100644 moli-renderer-v8/tests/fixtures/media-recorder-frontend.js diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index d1d92db2b16..a59e02c0a70 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -50,6 +50,7 @@ mod picture_in_picture_tests; #[cfg(test)] pub(crate) use picture_in_picture_tests::closed_window_for_test as closed_picture_in_picture_window_for_test; mod media_metadata; +mod media_recorder; mod media_streams; #[cfg(test)] pub(crate) use media_streams::inert_track_for_test; diff --git a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs index bb1c37bee9b..f0943622717 100644 --- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs +++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs @@ -520,6 +520,14 @@ pub(in crate::context_bootstrap) fn build_constructor_template_for_profile<'s>( .length(0) .build(scope) } + ConstructorKind::MediaRecorder => { + v8::FunctionTemplate::builder(moli_webapi_declare::web_api_constructor!( + web_api_interfaces::MediaRecorder, + super::super::media_recorder::constructor + )) + .length(1) + .build(scope) + } ConstructorKind::ImageData => { let template = v8::FunctionTemplate::builder(moli_webapi_declare::web_api_constructor!( diff --git a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs index 80d8fe45c69..d53303a1128 100644 --- a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs +++ b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs @@ -423,6 +423,7 @@ pub(super) fn install_constructor_template_bindings<'s>( install_media_source_template_bindings(scope, template, spec.interface.name()); super::super::picture_in_picture::install(scope, template, spec.interface.name()); super::super::media_streams::install(scope, template, spec.interface.name()); + super::super::media_recorder::install(scope, template, spec.interface.name()); install_message_port_template_bindings(scope, template, spec.interface.name()); if spec.interface.name() == "BroadcastChannel" { install_broadcast_channel_template_bindings(scope, template); diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/materialize.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/materialize.rs index bfd2e04b850..2f7e0a3d906 100644 --- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/materialize.rs +++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/materialize.rs @@ -318,6 +318,7 @@ fn finish_materialized_interface<'s>( | ConstructorKind::VideoColorSpace | ConstructorKind::MediaMetadata | ConstructorKind::MediaStream + | ConstructorKind::MediaRecorder | ConstructorKind::RtcIceCandidate | ConstructorKind::RtcSessionDescription | ConstructorKind::RtcError diff --git a/moli-renderer-v8/src/context_bootstrap/media_recorder.rs b/moli-renderer-v8/src/context_bootstrap/media_recorder.rs new file mode 100644 index 00000000000..d01a71c3fb2 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/media_recorder.rs @@ -0,0 +1,324 @@ +//! MediaRecorder construction and inactive state, without an encoding backend. +//! A valid configuration is separate from support: no nonempty MIME type or +//! recording session is supported, and no encoded data or recording events are +//! fabricated. Receiver checks and input conversion use shared WebIDL bindings. + +use moli_webapi_declare::{ + WebApiFunctionTemplate, WebApiObject, WebApiValue, initialize_web_api_constructor_receiver, +}; + +use super::{media_streams, throw_dom_exception_value}; +use crate::{ + util::{get_private_value, throw_type_error, v8str}, + web_api_interfaces, webidl, +}; + +const STREAM: &str = "__moliRecorderStream"; +const MIME_TYPE: &str = "__moliRecorderMimeType"; +const STATE: &str = "__moliRecorderState"; +const VIDEO_RATE: &str = "__moliRecorderVideoBitsPerSecond"; +const AUDIO_RATE: &str = "__moliRecorderAudioBitsPerSecond"; +const AUDIO_MODE: &str = "__moliRecorderAudioBitrateMode"; +const KEY_FRAME_COUNT: &str = "__moliRecorderVideoKeyFrameIntervalCount"; +const KEY_FRAME_DURATION: &str = "__moliRecorderVideoKeyFrameIntervalDuration"; + +#[derive(Clone, Copy, Default, webidl::WebIdlEnum)] +#[webidl(name = "BitrateMode")] +enum AudioBitrateMode { + #[default] + #[webidl(token = "variable")] + Variable, + #[webidl(token = "constant")] + Constant, +} + +impl<'s> WebApiValue<'s> for AudioBitrateMode { + fn to_v8_value(&self, scope: &mut v8::PinScope<'s, '_>) -> Option> { + match self { + Self::Variable => "variable", + Self::Constant => "constant", + } + .to_v8_value(scope) + } +} + +#[derive(webidl::WebIdlDictionary)] +#[webidl(prefix = "MediaRecorderOptions")] +struct RecorderOptions { + #[webidl(converter = "enum", default = AudioBitrateMode::Variable)] + audio_bitrate_mode: AudioBitrateMode, + audio_bits_per_second: Option, + bits_per_second: Option, + #[webidl(converter = "raw", default = webidl::DomString16(Vec::new()))] + mime_type: webidl::DomString16, + video_bits_per_second: Option, + video_key_frame_interval_count: Option, + #[webidl(converter = "double")] + video_key_frame_interval_duration: Option, +} + +impl Default for RecorderOptions { + fn default() -> Self { + Self { + audio_bitrate_mode: AudioBitrateMode::Variable, + audio_bits_per_second: None, + bits_per_second: None, + mime_type: webidl::DomString16(Vec::new()), + video_bits_per_second: None, + video_key_frame_interval_count: None, + video_key_frame_interval_duration: None, + } + } +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "MediaRecorder")] +struct ConstructorArgs<'s> { + #[webidl(required, interface = web_api_interfaces::MediaStream)] + stream: v8::Local<'s, v8::Object>, + #[webidl(dictionary, default = RecorderOptions::default())] + options: RecorderOptions, +} + +#[derive(WebApiObject)] +#[webapi(interface = web_api_interfaces::MediaRecorder)] +struct RecorderSlots<'s> { + #[webapi(slot = STREAM)] + stream: v8::Local<'s, v8::Object>, + #[webapi(slot = MIME_TYPE, value = "")] + mime_type: (), + #[webapi(slot = STATE, value = "inactive")] + state: (), + #[webapi(slot = VIDEO_RATE)] + video_bits_per_second: u32, + #[webapi(slot = AUDIO_RATE)] + audio_bits_per_second: u32, + // The frontend falls back to variable mode when constant mode is unavailable. + #[webapi(slot = AUDIO_MODE, value = "variable")] + audio_bitrate_mode: (), + #[webapi(slot = "__moliRecorderRequestedAudioBitrateMode")] + requested_audio_bitrate_mode: AudioBitrateMode, + #[webapi(slot = KEY_FRAME_COUNT)] + video_key_frame_interval_count: Option, + #[webapi(slot = KEY_FRAME_DURATION)] + video_key_frame_interval_duration: Option, + #[webapi(slot = "__moliMediaHandlerOnstart", init = "null")] + onstart: (), + #[webapi(slot = "__moliMediaHandlerOnstop", init = "null")] + onstop: (), + #[webapi(slot = "__moliMediaHandlerOndataavailable", init = "null")] + ondataavailable: (), + #[webapi(slot = "__moliMediaHandlerOnpause", init = "null")] + onpause: (), + #[webapi(slot = "__moliMediaHandlerOnresume", init = "null")] + onresume: (), + #[webapi(slot = "__moliMediaHandlerOnerror", init = "null")] + onerror: (), +} + +#[derive(WebApiFunctionTemplate)] +#[webapi(interface = web_api_interfaces::MediaRecorder, enumerable)] +struct RecorderPrototype { + #[webapi(accessor_property, getter = media_streams::slot_getter, data = v8str(scope, STREAM))] + stream: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, data = v8str(scope, MIME_TYPE))] + mime_type: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, data = v8str(scope, STATE))] + state: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, data = v8str(scope, VIDEO_RATE))] + video_bits_per_second: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, data = v8str(scope, AUDIO_RATE))] + audio_bits_per_second: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, data = v8str(scope, AUDIO_MODE))] + audio_bitrate_mode: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, setter = media_streams::handler_setter, data = v8str(scope, "__moliMediaHandlerOnstart"))] + onstart: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, setter = media_streams::handler_setter, data = v8str(scope, "__moliMediaHandlerOnstop"))] + onstop: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, setter = media_streams::handler_setter, data = v8str(scope, "__moliMediaHandlerOndataavailable"))] + ondataavailable: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, setter = media_streams::handler_setter, data = v8str(scope, "__moliMediaHandlerOnpause"))] + onpause: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, setter = media_streams::handler_setter, data = v8str(scope, "__moliMediaHandlerOnresume"))] + onresume: (), + #[webapi(accessor_property, getter = media_streams::slot_getter, setter = media_streams::handler_setter, data = v8str(scope, "__moliMediaHandlerOnerror"))] + onerror: (), + #[webapi(method, length = 0, callback = start)] + start: (), + #[webapi(method, length = 0, callback = stop)] + stop: (), + #[webapi(method, length = 0, callback = require_recording)] + pause: (), + #[webapi(method, length = 0, callback = require_recording)] + resume: (), + #[webapi(method, length = 0, callback = require_recording)] + request_data: (), + #[webapi(static_method, length = 1, callback = is_type_supported)] + is_type_supported: (), +} + +pub(super) fn install<'s>( + scope: &mut v8::PinScope<'s, '_, ()>, + template: v8::Local<'s, v8::FunctionTemplate>, + name: &str, +) { + if name == "MediaRecorder" { + RecorderPrototype::initialize_template(scope, template); + RecorderPrototype::initialize_prototype_template(scope, template.prototype_template(scope)); + } +} + +pub(super) fn constructor<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + if !args.is_construct_call() { + throw_type_error(scope, "MediaRecorder requires 'new'."); + return; + } + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + if !initialize_web_api_constructor_receiver(scope, args.this(), "MediaRecorder") { + return; + } + if !parsed.options.mime_type.0.is_empty() { + throw_dom_exception_value( + scope, + "No recording MIME type is supported.", + "NotSupportedError", + ); + return; + } + let (audio, video) = if let Some(total) = parsed.options.bits_per_second { + // Bitrate allocation is UA-defined. A total target overrides per-kind + // targets; use a deterministic 5/95 split without unsigned overflow. + let audio = total / 20; + (audio, total - audio) + } else { + ( + parsed.options.audio_bits_per_second.unwrap_or(128_000), + parsed.options.video_bits_per_second.unwrap_or(2_500_000), + ) + }; + RecorderSlots::new( + parsed.stream, + video, + audio, + parsed.options.audio_bitrate_mode, + parsed.options.video_key_frame_interval_count, + parsed.options.video_key_frame_interval_duration, + ) + .initialize(scope, args.this()) + .expect("MediaRecorder slots"); + media_streams::initialize_event_target(scope, args.this()); + rv.set(args.this().into()); +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "MediaRecorder.isTypeSupported")] +struct SupportArgs { + #[webidl(required, converter = "raw")] + mime_type: webidl::DomString16, +} + +fn is_type_supported<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + // An empty type lets the UA choose later; it does not promise an encoder. + rv.set(v8::Boolean::new(scope, parsed.mime_type.0.is_empty()).into()); +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "MediaRecorder.start")] +struct StartArgs { + #[webidl(name = "timeslice")] + _timeslice: Option, +} + +fn is_inactive<'s>(scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>) -> bool { + get_private_value(scope, object, STATE) + .expect("MediaRecorder state") + .strict_equals(v8str(scope, "inactive").into()) +} + +fn start<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(_parsed) = webidl::parse_args::(scope, &args) else { + return; + }; + let object = media_streams::target(scope, args.this()); + if !is_inactive(scope, object) { + throw_dom_exception_value( + scope, + "MediaRecorder is already recording.", + "InvalidStateError", + ); + return; + } + let stream = v8::Local::::try_from( + get_private_value(scope, object, STREAM).expect("MediaRecorder stream"), + ) + .expect("native MediaStream"); + if !media_streams::is_active(scope, stream) { + throw_dom_exception_value(scope, "The stream is inactive.", "NotSupportedError"); + return; + } + if get_private_value(scope, object, KEY_FRAME_COUNT).is_some_and(|value| !value.is_undefined()) + && get_private_value(scope, object, KEY_FRAME_DURATION) + .is_some_and(|value| !value.is_undefined()) + { + throw_dom_exception_value( + scope, + "Only one video keyframe interval may be specified.", + "NotSupportedError", + ); + return; + } + throw_dom_exception_value( + scope, + "No recording encoder is available.", + "NotSupportedError", + ); +} + +fn stop<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let object = media_streams::target(scope, args.this()); + if !is_inactive(scope, object) { + throw_dom_exception_value( + scope, + "No recording encoder is available.", + "NotSupportedError", + ); + } +} + +fn require_recording<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let object = media_streams::target(scope, args.this()); + if is_inactive(scope, object) { + throw_dom_exception_value(scope, "MediaRecorder is inactive.", "InvalidStateError"); + } else { + throw_dom_exception_value( + scope, + "No recording encoder is available.", + "NotSupportedError", + ); + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/media_streams.rs b/moli-renderer-v8/src/context_bootstrap/media_streams.rs index 317f51a37f0..cddf4523e71 100644 --- a/moli-renderer-v8/src/context_bootstrap/media_streams.rs +++ b/moli-renderer-v8/src/context_bootstrap/media_streams.rs @@ -26,6 +26,12 @@ const HANDLER_SLOTS: &[&str] = &[ "__moliMediaHandlerOnmute", "__moliMediaHandlerOnunmute", "__moliMediaHandlerOnended", + "__moliMediaHandlerOnstart", + "__moliMediaHandlerOnstop", + "__moliMediaHandlerOndataavailable", + "__moliMediaHandlerOnpause", + "__moliMediaHandlerOnresume", + "__moliMediaHandlerOnerror", ]; #[derive(WebApiObject)] @@ -345,14 +351,21 @@ fn active_getter<'s>( args: v8::FunctionCallbackArguments<'s>, mut rv: v8::ReturnValue<'_, v8::Value>, ) { - let stream = target(scope, args.this()); - let active = track_set(scope, stream).iter().any(|track| { + let active = is_active(scope, args.this()); + rv.set(v8::Boolean::new(scope, active).into()); +} + +pub(super) fn is_active<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, +) -> bool { + let stream = target(scope, stream); + track_set(scope, stream).iter().any(|track| { let track = target(scope, *track); get_private_value(scope, track, READY_STATE) .expect("native track state") .strict_equals(v8str(scope, "live").into()) - }); - rv.set(v8::Boolean::new(scope, active).into()); + }) } fn tracks_getter<'s>( diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs index ba171f2c034..83a01041a3c 100644 --- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs +++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs @@ -182,7 +182,7 @@ const CONSTRUCTOR_SPECS_BEFORE_STREAMS: &[ConstructorSpec] = &[ }, ConstructorSpec { interface: web_api_interfaces::MediaRecorder::DESCRIPTOR, - kind: ConstructorKind::Shell { length: 1 }, + kind: ConstructorKind::MediaRecorder, }, ConstructorSpec { interface: web_api_interfaces::MediaSourceHandle::DESCRIPTOR, diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rs index 69974ac3276..bdbaf97c4bf 100644 --- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs +++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs @@ -87,6 +87,7 @@ pub(in crate::context_bootstrap) enum ConstructorKind { VideoEncoder, MediaMetadata, MediaStream, + MediaRecorder, MediaStreamTrackEvent, OffscreenCanvas, Path2D, diff --git a/moli-renderer-v8/src/script_vm/tests/media_recorder.rs b/moli-renderer-v8/src/script_vm/tests/media_recorder.rs new file mode 100644 index 00000000000..8a3688e9c76 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/media_recorder.rs @@ -0,0 +1,113 @@ +use super::*; + +#[test] +fn media_recorder_frontend_preserves_inactive_state_conversion_handlers_and_realms() { + let mut vm = new_storage_page_task_executor_test_vm("https://media-recorder.test/"); + vm.eval("document.body.innerHTML = ''") + .unwrap(); + let result = vm + .eval(include_str!( + "../../../tests/fixtures/media-recorder-frontend.js" + )) + .unwrap(); + assert_eq!( + result, + "true", + "{}", + vm.eval("JSON.stringify(__uiEventResults.checks.filter(row=>!row.passed))") + .unwrap() + ); +} + +#[test] +fn media_recorder_registered_native_proxies_share_private_state_and_stream_identity() { + let mut vm = new_storage_page_task_executor_test_vm("https://native-recorder.test/"); + vm.eval("document.body.innerHTML = ''; globalThis.stream = new MediaStream(); globalThis.recorder = new MediaRecorder(stream)").unwrap(); + let context_ptr = &vm.page_default_context as *const _; + vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| { + let global = scope.get_current_context().global(scope); + for (name, proxy_name) in [("stream", "nativeStream"), ("recorder", "nativeRecorder")] { + let value = global + .get(scope, crate::util::v8str(scope, name).into()) + .unwrap(); + let object = v8::Local::::try_from(value).unwrap(); + let handler = crate::util::new_null_prototype_object(scope); + let proxy = v8::Proxy::new(scope, object, handler).unwrap(); + moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap(); + assert_eq!( + global.create_data_property( + scope, + crate::util::v8str(scope, proxy_name).into(), + proxy.into() + ), + Some(true) + ); + } + Ok(()) + }) + .unwrap(); + assert_eq!(vm.eval(r#"(() => { + const assert = (condition,name) => {if (!condition) throw Error(name)}; + const other = document.querySelector('iframe').contentWindow; + const state = Object.getOwnPropertyDescriptor(other.MediaRecorder.prototype,'state').get; + const streamGetter = Object.getOwnPropertyDescriptor(other.MediaRecorder.prototype,'stream').get; + assert(state.call(nativeRecorder) === 'inactive' && streamGetter.call(nativeRecorder) === stream, 'native recorder proxy shares private slots'); + assert(new other.MediaRecorder(nativeStream).stream === nativeStream, 'stream argument retains registered proxy identity'); + assert(other.MediaRecorder.prototype.stop.call(nativeRecorder) === undefined, 'native proxy method'); + let conversions = 0, error; + try {other.MediaRecorder.prototype.start.call(nativeRecorder,{valueOf() {conversions++; return 1}})} catch(caught) {error=caught} + assert(conversions === 1 && error instanceof other.DOMException && error.name === 'NotSupportedError' && !(error instanceof DOMException), 'valid proxy converts input then uses callee error realm'); + let traps = 0; + const proxy = new Proxy(nativeRecorder, {get() {traps++; throw Error('get')}, getPrototypeOf() {traps++; throw Error('prototype')}}); + const revoked = Proxy.revocable(nativeRecorder,{}); revoked.revoke(); + for (const receiver of [proxy,revoked.proxy,Object.create(nativeRecorder),Object.create(other.MediaRecorder.prototype)]) { + try {other.MediaRecorder.prototype.start.call(receiver,{valueOf() {conversions++; return 1}})} catch(caught) {error=caught} + assert(error instanceof other.TypeError && !(error instanceof TypeError), 'author wrapper fails brand check'); + } + assert(conversions === 1 && traps === 0 && state.call(recorder) === 'inactive', 'no trap or argument conversion on author wrappers'); + const log = []; + Object.getOwnPropertyDescriptor(other.MediaRecorder.prototype,'onstop').set.call(nativeRecorder, function(event) {assert(this===recorder && event.target===recorder,'EventTarget identity'); log.push('stop')}); + recorder.dispatchEvent(new Event('stop')); assert(log.join() === 'stop', 'native proxy handler uses original EventTarget'); + for (const [object,names] of [[stream,['active','getTracks']],[recorder,['state','stream']]]) { + for (const name of names) Object.defineProperty(object,name,{get() {throw Error('author getter '+name)}}); + } + try {other.MediaRecorder.prototype.start.call(nativeRecorder)} catch(caught) {error=caught} + assert(error instanceof other.DOMException && error.name==='NotSupportedError', 'private state checks ignore author properties'); + return true; + })()"#).unwrap(), "true"); +} + +#[test] +fn media_recorder_inert_live_tracks_remain_unrecorded_and_options_convert_before_allocation() { + let mut vm = new_storage_page_task_executor_test_vm("https://recorder-options.test/"); + vm.eval("document.body.innerHTML = ''") + .unwrap(); + super::media_streams::install_inert_media_tracks(&mut vm); + assert_eq!(vm.eval(r#"(() => { + const assert = (condition,name) => {if (!condition) throw Error(name)}; + const other = document.querySelector('iframe').contentWindow, stream = new MediaStream([audio,video]); + assert(stream.active, 'native live inert track stream'); + for (const options of [{},{videoKeyFrameIntervalCount:0},{videoKeyFrameIntervalDuration:0},{videoKeyFrameIntervalCount:0,videoKeyFrameIntervalDuration:0}]) { + const recorder = new other.MediaRecorder(stream,options), events = []; + for (const name of ['start','stop','dataavailable','pause','resume','error']) recorder.addEventListener(name,()=>events.push(name)); + let error; try {recorder.start()} catch(caught) {error=caught} + assert(error instanceof other.DOMException && error.name==='NotSupportedError' && recorder.state==='inactive' && recorder.mimeType==='', 'frontend cannot encode inert tracks'); + recorder.stop(); assert(events.length===0, 'no fabricated backend events'); + } + for (const type of ['video/webm','audio/ogg','video/mp4','audio/wav','Audio/WebM',' video/webm','\ud800']) assert(!other.MediaRecorder.isTypeSupported(type), 'no recording encoder support'); + const log = [], target = new Proxy(function() {}, {get(object,key) {if(key==='prototype') log.push('prototype'); return Reflect.get(object,key)}}); + const options = {get mimeType() {log.push('type'); return 'audio/banana'}, get videoBitsPerSecond() {log.push('rate'); return 1}}; + let error; try {Reflect.construct(other.MediaRecorder,[stream,options],target)} catch(caught) {error=caught} + assert(error instanceof other.DOMException && error.name==='NotSupportedError' && log.join()==='type,rate,prototype','conversion, allocation, backend validation order'); + const marker = {}; log.length=0; + try {Reflect.construct(other.MediaRecorder,[stream,{get mimeType() {log.push('type'); throw marker}}],target)} catch(caught) {error=caught} + assert(error===marker && log.join()==='type','conversion exception prevents prototype lookup'); + const savedRecorder = other.MediaRecorder, savedStream = MediaStream; + other.MediaRecorder = function() {throw Error('poisoned MediaRecorder')}; + globalThis.MediaStream = function() {throw Error('poisoned MediaStream')}; + const recorder = new savedRecorder(stream); + assert(recorder.stream===stream && recorder.state==='inactive','intrinsic brands do not depend on public constructors'); + other.MediaRecorder = savedRecorder; globalThis.MediaStream = savedStream; + return true; + })()"#).unwrap(), "true"); +} diff --git a/moli-renderer-v8/src/script_vm/tests/media_recorder_shell.js b/moli-renderer-v8/src/script_vm/tests/media_recorder_shell.js index ae4904467db..1370ef43c9c 100644 --- a/moli-renderer-v8/src/script_vm/tests/media_recorder_shell.js +++ b/moli-renderer-v8/src/script_vm/tests/media_recorder_shell.js @@ -17,12 +17,18 @@ try { constructor(); } catch (error) { callError = error; } assert(callError instanceof realm.TypeError, name + ' call requires new in the callee realm'); if (realm !== window) assert(!(callError instanceof TypeError), name + ' foreign TypeError'); - // These are interface shells. Argument conversion and backend operations remain unavailable. let constructionError; try { Reflect.construct(constructor, []); } catch (error) { constructionError = error; } - assert(constructionError instanceof realm.DOMException && constructionError.name === 'NotSupportedError' && constructionError.code === 9, - name + ' unavailable construction is explicit in the callee realm'); - if (realm !== window) assert(!(constructionError instanceof DOMException), name + ' foreign DOMException'); + assert(constructionError instanceof realm.TypeError, + name + ' requires a native MediaStream argument in the callee realm'); + if (realm !== window) assert(!(constructionError instanceof TypeError), name + ' foreign argument TypeError'); + const stream = new realm.MediaStream(), recorder = new constructor(stream); + assert(recorder.stream === stream && recorder.state === 'inactive' && recorder.mimeType === '', name + ' valid frontend construction'); + let startError; + try { recorder.start(); } catch (error) { startError = error; } + assert(startError instanceof realm.DOMException && startError.name === 'NotSupportedError' && startError.code === 9, + name + ' inactive stream error belongs to the callee realm'); + if (realm !== window) assert(!(startError instanceof DOMException), name + ' foreign DOMException'); assert(realm[name] === constructor, name + ' materialization remains stable'); } } diff --git a/moli-renderer-v8/src/script_vm/tests/media_streams.rs b/moli-renderer-v8/src/script_vm/tests/media_streams.rs index b8c29ee8a74..1b9d661f64d 100644 --- a/moli-renderer-v8/src/script_vm/tests/media_streams.rs +++ b/moli-renderer-v8/src/script_vm/tests/media_streams.rs @@ -14,7 +14,7 @@ fn media_stream_frontend_preserves_empty_streams_overloads_receivers_and_realms( ); } -fn install_inert_media_tracks(vm: &mut ScriptVm) { +pub(super) fn install_inert_media_tracks(vm: &mut ScriptVm) { let context_ptr = &vm.page_default_context as *const _; vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| { let global = scope.get_current_context().global(scope); diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 7d139582df9..797a9357390 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -2412,6 +2412,7 @@ mod legacy_performance; mod location_put_forwards; mod media_device_interfaces; mod media_metadata; +mod media_recorder; mod media_streams; mod midi_owner_interfaces; #[cfg(feature = "devtools")] diff --git a/moli-renderer-v8/tests/fixtures/media-recorder-frontend.js b/moli-renderer-v8/tests/fixtures/media-recorder-frontend.js new file mode 100644 index 00000000000..75066fccd20 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/media-recorder-frontend.js @@ -0,0 +1,170 @@ +(() => { + const checks = []; + const assert = (condition, message) => { if (!condition) throw Error(message); }; + const check = (name, action) => { + try { action(); checks.push({name, passed: true}); } + catch (error) { checks.push({name, passed: false, error: String(error)}); } + }; + const throws = (C, action, expectedName) => { + let error; try { action(); } catch (caught) { error = caught; } + assert(error instanceof C && (!expectedName || error.name === expectedName), 'Expected '+(expectedName || C.name)+', got '+error); + return error; + }; + for (const [index, realm] of [globalThis, document.querySelector('iframe').contentWindow].entries()) { + const prefix = index ? 'iframe ' : 'main '; + const C = realm.MediaRecorder, P = C.prototype; + check(prefix+'MediaRecorder interface', () => { + assert(C.name === 'MediaRecorder' && C.length === 1 && P.constructor === C, 'interface object'); + assert(Object.getPrototypeOf(C) === realm.EventTarget && Object.getPrototypeOf(P) === realm.EventTarget.prototype, 'interface inheritance'); + assert(Object.prototype.toString.call(P) === '[object MediaRecorder]', 'prototype tag'); + throws(realm.TypeError, () => C(new realm.MediaStream())); + }); + for (const name of ['stream','mimeType','state','videoBitsPerSecond','audioBitsPerSecond','audioBitrateMode','onstart','onstop','ondataavailable','onpause','onresume','onerror']) { + check(prefix+'MediaRecorder '+name+' descriptor', () => { + const d = Object.getOwnPropertyDescriptor(P, name); + assert(d && d.enumerable && d.configurable && d.get && !!d.set === name.startsWith('on'), 'attribute descriptor'); + throws(realm.TypeError, () => d.get.call({})); + if (d.set) throws(realm.TypeError, () => d.set.call({}, () => {})); + }); + } + for (const name of ['start','stop','pause','resume','requestData']) { + check(prefix+'MediaRecorder '+name+' descriptor', () => { + const d = Object.getOwnPropertyDescriptor(P, name); + assert(d && d.enumerable && d.configurable && d.writable && d.value.name === name && d.value.length === 0, 'method descriptor'); + throws(realm.TypeError, () => d.value.call({})); + }); + } + check(prefix+'MediaRecorder static descriptor and conversion', () => { + const d = Object.getOwnPropertyDescriptor(C, 'isTypeSupported'); + assert(d && d.enumerable && d.configurable && d.writable && d.value.name === 'isTypeSupported' && d.value.length === 1, 'static method descriptor'); + assert(d.value.call({}, '') === true && !d.value.call(null, 'audio/banana'), 'static call needs no branded receiver'); + throws(realm.TypeError, () => d.value()); + throws(realm.TypeError, () => d.value(Symbol())); + let calls = 0; assert(d.value({toString() {calls++; return ''}}) === true && calls === 1, 'single DOMString conversion'); + const marker = {}; let caught; try {d.value({toString() {throw marker}})} catch(error) {caught = error} + assert(caught === marker, 'conversion exception identity'); + assert(!d.value('\ud800') && !d.value(undefined) && !d.value(null), 'nonempty strings unsupported'); + }); + for (const [name, arguments_] of [['missing',[]], ['undefined',[undefined]], ['null',[null]], ['ordinary',[{}]], ['forged',[Object.create(realm.MediaStream.prototype)]]]) { + check(prefix+'MediaRecorder rejects '+name+' stream', () => throws(realm.TypeError, () => Reflect.construct(C, arguments_))); + } + for (const [name, options] of [['default',undefined], ['null',null], ['empty',{}], ['array',[]], ['callable',function() {}]]) { + check(prefix+'MediaRecorder '+name+' options', () => { + const stream = new MediaStream(), recorder = new C(stream, options); + assert(recorder instanceof C && recorder.stream === stream && recorder.stream === recorder.stream && recorder.state === 'inactive' && recorder.mimeType === '', 'frontend state and SameObject stream'); + assert(Number.isInteger(recorder.audioBitsPerSecond) && recorder.audioBitsPerSecond >= 0 && Number.isInteger(recorder.videoBitsPerSecond) && recorder.videoBitsPerSecond >= 0, 'UA-selected unsigned targets'); + assert(['variable','constant'].includes(recorder.audioBitrateMode), 'resolved mode'); + for (const key of ['stream','mimeType','state','audioBitsPerSecond','videoBitsPerSecond']) assert(!Object.hasOwn(recorder,key), 'prototype attribute '+key); + }); + } + check(prefix+'MediaRecorder explicit bitrates convert unsigned values', () => { + const recorder = new C(new realm.MediaStream(), {audioBitsPerSecond: 123.75, videoBitsPerSecond: 4294967299}); + assert(recorder.audioBitsPerSecond === 123 && recorder.videoBitsPerSecond === 3, 'unsigned-long conversion'); + const zero = new C(new realm.MediaStream(), {audioBitsPerSecond: NaN, videoBitsPerSecond: Infinity}); + assert(zero.audioBitsPerSecond === 0 && zero.videoBitsPerSecond === 0, 'nonfinite unsigned values convert to zero'); + const wrapped = new C(new realm.MediaStream(), {audioBitsPerSecond: -1}); + assert(wrapped.audioBitsPerSecond === 4294967295, 'normal unsigned conversion wraps'); + throws(realm.TypeError, () => new C(new realm.MediaStream(), {audioBitsPerSecond: 1n})); + }); + check(prefix+'MediaRecorder total bitrate target and modes', () => { + const recorder = new C(new realm.MediaStream(), {bitsPerSecond: 1000000, audioBitsPerSecond: 7, videoBitsPerSecond: 9, audioBitrateMode: 'constant'}); + assert(recorder.audioBitsPerSecond !== 7 && recorder.videoBitsPerSecond !== 9 && ['constant','variable'].includes(recorder.audioBitrateMode), 'total overrides individual targets and mode is selected by support'); + throws(realm.TypeError, () => new C(new realm.MediaStream(), {audioBitrateMode: 'quantizer'})); + throws(realm.TypeError, () => new C(new realm.MediaStream(), {audioBitrateMode: null})); + }); + check(prefix+'MediaRecorder option getters are lexicographic and precede support', () => { + const log = [], options = {}; + const values = {audioBitrateMode:'variable', audioBitsPerSecond:1, bitsPerSecond:2, mimeType:'audio/banana', videoBitsPerSecond:3, videoKeyFrameIntervalCount:4, videoKeyFrameIntervalDuration:5}; + for (const key of Object.keys(values).reverse()) Object.defineProperty(options,key,{get() {log.push(key); return values[key]}}); + throws(realm.DOMException, () => new C(new realm.MediaStream(), options), 'NotSupportedError'); + assert(log.join() === Object.keys(values).join(), 'all declared dictionary members converted before format support check: '+log); + const marker = {}, markerOptions = {mimeType:'audio/banana', get videoBitsPerSecond() {throw marker}}; + let caught; try {new C(new realm.MediaStream(), markerOptions)} catch(error) {caught=error} + assert(caught === marker, 'later conversion error wins over unsupported MIME type'); + }); + check(prefix+'MediaRecorder inherited options and numeric conversion', () => { + const log = [], options = Object.create({audioBitsPerSecond: 42}); + Object.defineProperty(options, 'videoBitsPerSecond', {get() {log.push('get'); return {valueOf() {log.push('number'); return 73}}}}); + const recorder = new C(new realm.MediaStream(), options); + assert(recorder.audioBitsPerSecond === 42 && recorder.videoBitsPerSecond === 73 && log.join() === 'get,number', 'dictionary Get and ToNumber'); + for (const value of [NaN, Infinity, -Infinity]) throws(realm.TypeError, () => new C(new realm.MediaStream(), {videoKeyFrameIntervalDuration:value})); + }); + check(prefix+'MediaRecorder format support agrees with construction', () => { + for (const type of ['audio/banana', 'video/pineapple', '\ud800', 'video/webm', 'audio/ogg; codecs=opus']) { + const supported = C.isTypeSupported(type); + assert(typeof supported === 'boolean', 'support result'); + if (supported) assert(new C(new realm.MediaStream(), {mimeType:type}).mimeType === type, 'supported MIME snapshot'); + else throws(realm.DOMException, () => new C(new realm.MediaStream(), {mimeType:type}), 'NotSupportedError'); + } + const log = [], recorder = new C(new realm.MediaStream(), {mimeType:{toString() {log.push('type'); return ''}}}); + assert(recorder.mimeType === '' && log.join() === 'type', 'MIME conversion'); + throws(realm.TypeError, () => new C(new realm.MediaStream(), {mimeType:Symbol()})); + }); + check(prefix+'MediaRecorder inactive operations and start conversion', () => { + const recorder = new C(new realm.MediaStream()); + assert(recorder.stop() === undefined && recorder.stop() === undefined && recorder.state === 'inactive', 'stop is idempotent'); + for (const name of ['pause','resume','requestData']) throws(realm.DOMException, () => recorder[name](), 'InvalidStateError'); + for (const timeslice of [undefined, null, 0, -1, NaN, Infinity]) throws(realm.DOMException, () => recorder.start(timeslice), 'NotSupportedError'); + throws(realm.TypeError, () => recorder.start(1n)); + let conversions = 0; throws(realm.DOMException, () => recorder.start({valueOf() {conversions++; return 1}}), 'NotSupportedError'); + assert(conversions === 1 && recorder.state === 'inactive' && recorder.mimeType === '', 'failed start leaves state and MIME untouched'); + const marker = {}; let caught; try {recorder.start({valueOf() {throw marker}})} catch(error) {caught=error} + assert(caught === marker, 'start conversion error identity'); + }); + check(prefix+'MediaRecorder receiver checks precede conversion without Proxy traps', () => { + const recorder = new C(new realm.MediaStream()), revoked = Proxy.revocable(recorder, {}); revoked.revoke(); + let conversions = 0, traps = 0; + const proxy = new Proxy(recorder,{get() {traps++; throw Error('get')}, getPrototypeOf() {traps++; throw Error('prototype')}}); + for (const receiver of [{}, Object.create(P), Object.create(recorder), proxy, revoked.proxy]) { + throws(realm.TypeError, () => P.start.call(receiver, {valueOf() {conversions++; throw Error('number')}})); + for (const name of ['stop','pause','resume','requestData']) throws(realm.TypeError, () => P[name].call(receiver)); + for (const name of ['stream','state','mimeType','onstart']) throws(realm.TypeError, () => Object.getOwnPropertyDescriptor(P,name).get.call(receiver)); + } + assert(conversions === 0 && traps === 0, 'brand validation runs first'); + }); + check(prefix+'MediaRecorder stream brand precedes option getters', () => { + const stream = new realm.MediaStream(), revoked = Proxy.revocable(stream, {}); revoked.revoke(); + let reads = 0, traps = 0; + const proxy = new Proxy(stream, {get() {traps++; throw Error('get')}, getPrototypeOf() {traps++; throw Error('prototype')}}); + for (const value of [{}, Object.create(stream), proxy, revoked.proxy]) throws(realm.TypeError, () => new C(value, {get mimeType() {reads++; return ''}})); + assert(reads === 0 && traps === 0, 'stream conversion validates native identity'); + }); + for (const eventType of ['start','stop','dataavailable','pause','resume','error']) { + check(prefix+'MediaRecorder on'+eventType+' listener ordering', () => { + const recorder = new C(new realm.MediaStream()), log = [], slot = 'on'+eventType; + assert(recorder[slot] === null, 'initial handler null'); + recorder.addEventListener(eventType, () => log.push(1)); + recorder[slot] = () => log.push(2); + recorder.addEventListener(eventType, () => log.push(3)); + recorder[slot] = function(event) {assert(this === recorder && event.target === recorder && !event.isTrusted, 'synthetic event receiver'); log.push(4)}; + recorder.dispatchEvent(new realm.Event(eventType)); + assert(log.join() === '1,4,3', 'replacement preserves listener order'); + recorder[slot] = 7; assert(recorder[slot] === null, 'nonobject becomes null'); + recorder[slot] = {}; assert(recorder[slot] !== null, 'noncallable object retained'); + recorder[slot] = null; log.length = 0; recorder.dispatchEvent(new realm.Event(eventType)); + assert(log.join() === '1,3', 'handler deactivation'); + }); + } + check(prefix+'MediaRecorder failed start and inactive stop emit no recording events', () => { + const recorder = new C(new realm.MediaStream()), log = []; + for (const type of ['start','stop','dataavailable','pause','resume','error']) recorder.addEventListener(type, () => log.push(type)); + throws(realm.DOMException, () => recorder.start(), 'NotSupportedError'); + recorder.stop(); assert(log.length === 0, 'no synthetic recording events'); + }); + check(prefix+'MediaRecorder conversion precedes newTarget prototype lookup', () => { + const log = [], target = new Proxy(function() {}, {get(object,key) {if (key === 'prototype') log.push('prototype'); return Reflect.get(object,key)}}); + const options = {get mimeType() {log.push('mimeType'); return ''}}; + const recorder = Reflect.construct(C,[new realm.MediaStream(),options],target); + assert(log.join() === 'mimeType,prototype', 'WebIDL constructor allocation order '+log); + assert(Object.getOwnPropertyDescriptor(P,'state').get.call(recorder) === 'inactive', 'subclass native brand'); + }); + check(prefix+'MediaRecorder callee error realm with foreign genuine receivers', () => { + const recorder = new MediaRecorder(new MediaStream()); + const error = throws(realm.DOMException, () => P.start.call(recorder), 'NotSupportedError'); + assert(Object.getPrototypeOf(error) === realm.DOMException.prototype, 'callee DOMException prototype'); + assert(Object.getOwnPropertyDescriptor(P,'state').get.call(recorder) === 'inactive', 'cross-realm native receiver'); + }); + } + globalThis.__uiEventResults = {complete:true, total:checks.length, passed:checks.filter(row => row.passed).length, checks}; + return checks.every(row => row.passed); +})()