mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
feat(media): add MediaRecorder frontend state and validation
This commit is contained in:
@@ -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);
|
||||
})()
|
||||
Reference in New Issue
Block a user