feat(media): add MediaRecorder frontend state and validation

This commit is contained in:
ldm0
2026-11-21 20:03:31 +08:00
parent bf72c55e8a
commit 5e5eeca80d
13 changed files with 649 additions and 10 deletions
@@ -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;
@@ -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!(
@@ -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);
@@ -318,6 +318,7 @@ fn finish_materialized_interface<'s>(
| ConstructorKind::VideoColorSpace
| ConstructorKind::MediaMetadata
| ConstructorKind::MediaStream
| ConstructorKind::MediaRecorder
| ConstructorKind::RtcIceCandidate
| ConstructorKind::RtcSessionDescription
| ConstructorKind::RtcError
@@ -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<v8::Local<'s, v8::Value>> {
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<u32>,
bits_per_second: Option<u32>,
#[webidl(converter = "raw", default = webidl::DomString16(Vec::new()))]
mime_type: webidl::DomString16,
video_bits_per_second: Option<u32>,
video_key_frame_interval_count: Option<u32>,
#[webidl(converter = "double")]
video_key_frame_interval_duration: Option<f64>,
}
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<u32>,
#[webapi(slot = KEY_FRAME_DURATION)]
video_key_frame_interval_duration: Option<f64>,
#[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::<ConstructorArgs>(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::<SupportArgs>(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<u32>,
}
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::<StartArgs>(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::<v8::Object>::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",
);
}
}
@@ -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>(
@@ -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,
@@ -87,6 +87,7 @@ pub(in crate::context_bootstrap) enum ConstructorKind {
VideoEncoder,
MediaMetadata,
MediaStream,
MediaRecorder,
MediaStreamTrackEvent,
OffscreenCanvas,
Path2D,
@@ -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 = '<iframe></iframe>'")
.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 = '<iframe></iframe>'; 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::<v8::Object>::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 = '<iframe></iframe>'")
.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");
}
@@ -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');
}
}
@@ -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);
@@ -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")]
@@ -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);
})()