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 44643461152..58dc54f0d93 100644
--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs
+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs
@@ -156,6 +156,22 @@ pub(in crate::context_bootstrap) fn build_constructor_template_for_profile<'s>(
ConstructorKind::MediaStreamTrackEvent => {
build_value_event_template(scope, ValueEventKind::MediaStreamTrack)
}
+ ConstructorKind::RtcDtmfToneChangeEvent => {
+ v8::FunctionTemplate::builder(moli_webapi_declare::web_api_constructor!(
+ web_api_interfaces::RTCDTMFToneChangeEvent,
+ moli_webapi::rtc::rtc_dtmf_tone_event_constructor
+ ))
+ .length(1)
+ .build(scope)
+ }
+ ConstructorKind::RtcTrackEvent => {
+ v8::FunctionTemplate::builder(moli_webapi_declare::web_api_constructor!(
+ web_api_interfaces::RTCTrackEvent,
+ moli_webapi::rtc::rtc_track_event_constructor
+ ))
+ .length(2)
+ .build(scope)
+ }
ConstructorKind::WebGLContextEvent => {
build_value_event_template(scope, ValueEventKind::WebGlContext)
}
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 2f7e0a3d906..4fee0ab40a0 100644
--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/materialize.rs
+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/materialize.rs
@@ -323,6 +323,8 @@ fn finish_materialized_interface<'s>(
| ConstructorKind::RtcSessionDescription
| ConstructorKind::RtcError
| ConstructorKind::RtcErrorEvent
+ | ConstructorKind::RtcDtmfToneChangeEvent
+ | ConstructorKind::RtcTrackEvent
| ConstructorKind::RtcDataChannelEvent
| ConstructorKind::RtcPeerConnectionIceEvent
| ConstructorKind::RtcPeerConnectionIceErrorEvent
diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
index 1a0a49d41ca..d2ccbd37401 100644
--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
@@ -262,7 +262,7 @@ const CONSTRUCTOR_SPECS_BEFORE_STREAMS: &[ConstructorSpec] = &[
},
ConstructorSpec {
interface: web_api_interfaces::RTCDTMFToneChangeEvent::DESCRIPTOR,
- kind: ConstructorKind::Shell { length: 1 },
+ kind: ConstructorKind::RtcDtmfToneChangeEvent,
},
ConstructorSpec {
interface: web_api_interfaces::RTCDtlsTransport::DESCRIPTOR,
@@ -314,7 +314,7 @@ const CONSTRUCTOR_SPECS_BEFORE_STREAMS: &[ConstructorSpec] = &[
},
ConstructorSpec {
interface: web_api_interfaces::RTCTrackEvent::DESCRIPTOR,
- kind: ConstructorKind::Shell { length: 2 },
+ kind: ConstructorKind::RtcTrackEvent,
},
ConstructorSpec {
interface: web_api_interfaces::EncodedVideoChunk::DESCRIPTOR,
diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rs
index 5098eccf346..7d10b2e38d7 100644
--- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs
+++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs
@@ -63,6 +63,8 @@ pub(in crate::context_bootstrap) enum ConstructorKind {
RtcEncodedAudioFrame,
RtcEncodedVideoFrame,
RtcErrorEvent,
+ RtcDtmfToneChangeEvent,
+ RtcTrackEvent,
DomError,
QuotaExceededError,
CustomElementRegistry,
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index 7fb27ea6225..eab62831035 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -2524,6 +2524,7 @@ mod idb_object_store_native_receivers;
mod webidl_receivers;
mod webidl_trusted_types;
+mod webrtc_event_init;
mod websocket;
mod websocket_close_info_numbers;
diff --git a/moli-renderer-v8/src/script_vm/tests/webrtc_event_init.rs b/moli-renderer-v8/src/script_vm/tests/webrtc_event_init.rs
new file mode 100644
index 00000000000..0e5aa5d26fc
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/webrtc_event_init.rs
@@ -0,0 +1,99 @@
+use super::*;
+
+#[test]
+fn webrtc_event_constructors_use_shared_dictionary_brands_and_deferred_prototypes() {
+ for url in ["https://rtc-events.test/", "http://rtc-events.test/"] {
+ let mut vm = new_storage_page_task_executor_test_vm(url);
+ vm.eval(include_str!("../../../tests/fixtures/webrtc-event-init.js"))
+ .unwrap();
+ assert_eq!(
+ vm.eval("JSON.stringify(__uiEventResults.checks.filter(row => !row.passed))")
+ .unwrap(),
+ "[]"
+ );
+ assert_eq!(vm.eval("__uiEventResults.total >= 140").unwrap(), "true");
+ }
+}
+
+#[test]
+fn native_rtc_track_events_preserve_identity_frozen_snapshots_realms_and_proxies() {
+ let mut vm = new_storage_page_task_executor_test_vm("https://native-rtc-events.test/");
+ vm.eval("document.body.innerHTML = ''")
+ .unwrap();
+ media_streams::install_inert_media_tracks(&mut vm);
+ 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 (interface, name, proxy_name) in [
+ ("RTCRtpReceiver", "rtpReceiver", "nativeReceiver"),
+ ("RTCRtpTransceiver", "rtpTransceiver", "nativeTransceiver"),
+ ] {
+ let object = v8::Object::new(scope);
+ let prototype =
+ crate::context_bootstrap::ensure_intrinsic_interface_prototype(scope, interface)?;
+ assert_eq!(object.set_prototype(scope, prototype.into()), Some(true));
+ crate::web_api_interfaces::initialize(scope, object, interface)?;
+ 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)?;
+ for (key, value) in [(name, object.into()), (proxy_name, proxy.into())] {
+ assert_eq!(
+ global.create_data_property(
+ scope,
+ crate::util::v8str(scope, key).into(),
+ value
+ ),
+ Some(true)
+ );
+ }
+ }
+ Ok(())
+ })
+ .unwrap();
+ assert_eq!(
+ vm.eval(include_str!(
+ "../../../tests/fixtures/webrtc-event-native.js"
+ ))
+ .unwrap(),
+ "true"
+ );
+ 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 [
+ ("trackEvent", "nativeTrackEvent"),
+ ("toneEvent", "nativeToneEvent"),
+ ] {
+ 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)?;
+ 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 other=document.querySelector('iframe').contentWindow;
+ for(const w of [window,other]) {
+ const tone=Object.getOwnPropertyDescriptor(w.RTCDTMFToneChangeEvent.prototype,'tone').get;
+ if(tone.call(nativeToneEvent)!=='\ud800')throw Error('registered native event Proxy');
+ for(const property of ['receiver','track','streams','transceiver']) {
+ const get=Object.getOwnPropertyDescriptor(w.RTCTrackEvent.prototype,property).get;
+ if(get.call(nativeTrackEvent)!==trackEvent[property])throw Error('registered native track event Proxy');
+ let error;try{get.call(new Proxy(nativeTrackEvent,{}))}catch(caught){error=caught}
+ if(!(error instanceof w.TypeError))throw Error('author Proxy around native event');
+ }
+ }
+ return true;
+ })()"#).unwrap(), "true");
+}
diff --git a/moli-renderer-v8/tests/fixtures/webrtc-event-init.js b/moli-renderer-v8/tests/fixtures/webrtc-event-init.js
new file mode 100644
index 00000000000..433db059e7d
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/webrtc-event-init.js
@@ -0,0 +1,136 @@
+(() => {
+ const checks = [];
+ const assert = (value, name) => { if (!value) throw Error(name); };
+ 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) => {
+ let error;
+ try { action(); } catch (caught) { error = caught; }
+ assert(error instanceof C, 'callee exception');
+ };
+ const frame = document.createElement('iframe');
+ document.body.append(frame);
+ const other = frame.contentWindow;
+ for (const [realm, w] of [['main', window], ['iframe', other]]) {
+ const C = w.RTCDTMFToneChangeEvent;
+ for (const [name, properties, length] of [
+ ['RTCDTMFToneChangeEvent', ['tone'], 1],
+ ['RTCTrackEvent', ['receiver', 'track', 'streams', 'transceiver'], 2],
+ ]) {
+ const Constructor = w[name], P = Constructor.prototype;
+ check(`${realm} ${name} constructor`, () => {
+ assert(typeof Constructor === 'function' && Constructor.length === length && Constructor.name === name, 'constructor shape');
+ assert(Object.getPrototypeOf(P) === w.Event.prototype && P.constructor === Constructor, 'event inheritance');
+ });
+ for (const property of properties) {
+ const descriptor = Object.getOwnPropertyDescriptor(P, property);
+ check(`${realm} ${name}.${property} descriptor`, () => {
+ assert(descriptor && descriptor.enumerable && descriptor.configurable && typeof descriptor.get === 'function' && descriptor.set === undefined, 'readonly accessor');
+ });
+ for (const [index, receiver] of [null, undefined, 0, {}, Object.create(P), new w.Event('wrong')].entries()) {
+ check(`${realm} ${name}.${property} receiver ${index}`, () => {
+ assert(descriptor && typeof descriptor.get === 'function', 'getter must exist');
+ throws(w.TypeError, () => descriptor.get.call(receiver));
+ });
+ }
+ }
+ }
+ for (const [index, init] of [undefined, null, {}, [], () => {}].entries()) {
+ check(`${realm} tone default dictionary ${index}`, () => {
+ const event = new C('tone', init);
+ assert(event instanceof C && event instanceof w.Event && event.tone === '' && event.type === 'tone', 'default payload');
+ assert(!event.bubbles && !event.cancelable && !event.composed && !event.isTrusted && event.target === null, 'default header');
+ });
+ }
+ const values = [[undefined, ''], [null, 'null'], [false, 'false'], [0, '0'], [19n, '19'],
+ ['\ud800', '\ud800'], ['\udc00', '\udc00'], ['x\ud800\u0000y', 'x\ud800\u0000y'],
+ ['\ud83e\udd95', '\ud83e\udd95'], [{toString() { return '1,2'; }}, '1,2']];
+ for (const [index, [value, expected]] of values.entries()) {
+ check(`${realm} tone DOMString ${index}`, () => {
+ const event = new C('t\ud800', {tone: value, bubbles: true, cancelable: true, composed: true});
+ assert(event.type === 't\ud800' && event.tone === expected && event.bubbles && event.cancelable && event.composed, 'lossless constructor strings');
+ assert(!Object.hasOwn(event, 'tone') && Object.prototype.toString.call(event) === '[object RTCDTMFToneChangeEvent]', 'native prototype payload');
+ event.initEvent('reset', false, false);
+ assert(event.type === 'reset' && event.tone === expected && event.composed, 'legacy init preserves derived payload');
+ });
+ }
+ check(`${realm} tone conversion and prototype ordering`, () => {
+ const reads = [], prototype = Object.create(C.prototype);
+ const target = new Proxy(function Target() {}, {get(object, key, receiver) {
+ if (key === 'prototype') { reads.push('prototype'); return prototype; }
+ return Reflect.get(object, key, receiver);
+ }});
+ const type = {toString() { reads.push('type'); return 'tone'; }};
+ const init = new Proxy({bubbles: true, cancelable: true, composed: true, tone: {toString() { reads.push('string'); return '\ud800'; }}},
+ {get(object, key) { reads.push(key); return object[key]; }});
+ const event = Reflect.construct(C, [type, init], target);
+ assert(reads.join() === 'type,bubbles,cancelable,composed,tone,string,prototype' && Object.getPrototypeOf(event) === prototype && event.tone === '\ud800', 'conversion before allocation');
+ });
+ check(`${realm} tone constructor arity before conversions`, () => {
+ throws(w.TypeError, () => new C());
+ let reads = 0;
+ throws(w.TypeError, () => C({toString() { reads++; return 'x'; }}));
+ throws(w.TypeError, () => new w.RTCTrackEvent({toString() { reads++; return 'x'; }}));
+ assert(reads === 0, 'no argument conversion on invalid entry');
+ });
+ for (const [index, bad] of [1, 'x', true, Symbol(), 1n].entries()) {
+ check(`${realm} tone dictionary invalid ${index}`, () => throws(w.TypeError, () => new C('x', bad)));
+ }
+ check(`${realm} tone Symbol conversion`, () => throws(w.TypeError, () => new C('x', {tone: Symbol()})));
+ check(`${realm} tone getter exception identity`, () => {
+ const marker = {}, reads = [];
+ let error;
+ try { new C('x', {get bubbles() { reads.push('bubbles'); throw marker; }, get tone() { reads.push('tone'); return ''; }}); }
+ catch (caught) { error = caught; }
+ assert(error === marker && reads.join() === 'bubbles', 'abrupt inheritance member');
+ const target = new Proxy(function Target() {}, {get(object, key) { if (key === 'prototype') throw marker; return object[key]; }});
+ try { Reflect.construct(C, ['x', {tone: {toString() { reads.push('tone'); return ''; }}}], target); }
+ catch (caught) { error = caught; }
+ assert(error === marker && reads.join() === 'bubbles,tone', 'newTarget exception after conversion');
+ });
+ check(`${realm} tone author and revoked Proxy receiver`, () => {
+ const event = new C('x', {tone: '1'}), get = Object.getOwnPropertyDescriptor(C.prototype, 'tone').get;
+ let traps = 0;
+ const proxy = new Proxy(event, {get() { traps++; throw Error('trap'); }});
+ const revoked = Proxy.revocable(event, {}); revoked.revoke();
+ for (const bad of [proxy, revoked.proxy, Object.create(event)]) throws(w.TypeError, () => get.call(bad));
+ assert(traps === 0, 'native receiver guard does not enter author Proxy');
+ const cross = Object.getOwnPropertyDescriptor((w === window ? other : window).RTCDTMFToneChangeEvent.prototype, 'tone').get;
+ assert(cross.call(event) === '1', 'genuine cross realm receiver');
+ });
+ check(`${realm} tone subclass and readonly payload`, () => {
+ class Derived extends C {}
+ const event = new Derived('x', {tone: 'A'});
+ assert(event instanceof Derived && event instanceof C && event.tone === 'A', 'subclass allocation');
+ assert(!Reflect.set(event, 'tone', 'B') && event.tone === 'A', 'readonly payload');
+ });
+ check(`${realm} tone manual EventTarget dispatch`, () => {
+ const target = new w.EventTarget(), event = new C('x', {tone: '1', cancelable: true});
+ let seen = 0;
+ target.addEventListener('x', e => { assert(e === event && e.tone === '1', 'payload identity'); seen++; e.preventDefault(); });
+ assert(target.dispatchEvent(event) === false && seen === 1 && event.defaultPrevented, 'event dispatch semantics');
+ });
+ for (const [index, init] of [undefined, null, {}, {receiver: null}, {receiver: {}}].entries()) {
+ check(`${realm} track required native receiver ${index}`, () => throws(w.TypeError, () => new w.RTCTrackEvent('track', init)));
+ }
+ check(`${realm} track failed receiver stops other members`, () => {
+ const reads = [];
+ const init = new Proxy({bubbles: false, cancelable: false, composed: false, receiver: Object.create(w.RTCRtpReceiver.prototype)},
+ {get(object, key) { reads.push(key); return object[key]; }});
+ throws(w.TypeError, () => new w.RTCTrackEvent('track', init));
+ assert(reads.join() === 'bubbles,cancelable,composed,receiver', 'required native interface conversion');
+ });
+ check(`${realm} track receiver property exception identity`, () => {
+ const marker = {};
+ let error;
+ try { new w.RTCTrackEvent('track', {get receiver() { throw marker; }, get streams() { throw Error('late read'); }}); }
+ catch (caught) { error = caught; }
+ assert(error === marker, 'original property exception');
+ });
+ }
+ frame.remove();
+ globalThis.__uiEventResults = {complete: true, total: checks.length, passed: checks.filter(row => row.passed).length, checks};
+ return checks.every(row => row.passed);
+})()
diff --git a/moli-renderer-v8/tests/fixtures/webrtc-event-native.js b/moli-renderer-v8/tests/fixtures/webrtc-event-native.js
new file mode 100644
index 00000000000..d27f32aa0e7
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/webrtc-event-native.js
@@ -0,0 +1,68 @@
+(() => {
+ const assert = (value, message) => { if (!value) throw Error(message); };
+ const other = document.querySelector('iframe').contentWindow;
+ for (const w of [window, other]) {
+ const C = w.RTCTrackEvent;
+ const stream = new w.MediaStream(), second = new MediaStream();
+ const init = {receiver: rtpReceiver, track: audio, transceiver: rtpTransceiver, streams: [stream, second, stream]};
+ const event = new C('track\ud800', {...init, bubbles: true, cancelable: true, composed: true});
+ assert(event instanceof C && event.type === 'track\ud800' && event.bubbles && event.cancelable && event.composed && !event.isTrusted, 'native event header');
+ assert(event.receiver === rtpReceiver && event.track === audio && event.transceiver === rtpTransceiver, 'required object identities');
+ assert(event.streams instanceof w.Array && Object.isFrozen(event.streams) && event.streams === event.streams && event.streams.length === 3 && event.streams[0] === stream && event.streams[1] === second && event.streams[2] === stream, 'frozen snapshot with duplicates');
+ init.streams.length = 0;
+ assert(event.streams.length === 3 && !Reflect.set(event.streams, 0, second), 'snapshot is independent');
+ for (const property of ['receiver','track','streams','transceiver']) {
+ assert(!Object.hasOwn(event, property) && !Reflect.set(event, property, null), 'readonly prototype attribute');
+ const get = Object.getOwnPropertyDescriptor((w === window ? other : window).RTCTrackEvent.prototype, property).get;
+ assert(get.call(event) === event[property], 'borrowed cross realm getter');
+ }
+ for (const streams of [undefined, [], new Set([stream]), {*[Symbol.iterator]() { yield stream; yield stream; }}]) {
+ const result = new C('track', {...init, streams});
+ assert(Object.isFrozen(result.streams), 'every stream result frozen');
+ if (streams === undefined) assert(result.streams.length === 0, 'default sequence');
+ }
+ const reads = [];
+ const source = {get bubbles() { reads.push('bubbles'); return false; }, get cancelable() { reads.push('cancelable'); return false; }, get composed() { reads.push('composed'); return false; },
+ get receiver() { reads.push('receiver'); return rtpReceiver; },
+ get streams() { reads.push('streams'); return {get [Symbol.iterator]() { reads.push('iterator'); return function*() { reads.push('value'); yield stream; }; }}; },
+ get track() { reads.push('track'); return audio; }, get transceiver() { reads.push('transceiver'); return rtpTransceiver; }};
+ const prototype = Object.create(C.prototype), target = new Proxy(function Target() {}, {get(object, key) { if (key === 'prototype') { reads.push('prototype'); return prototype; } return object[key]; }});
+ const constructed = Reflect.construct(C, [{toString() { reads.push('type'); return 'track'; }}, source], target);
+ assert(reads.join() === 'type,bubbles,cancelable,composed,receiver,streams,iterator,value,track,transceiver,prototype' && Object.getPrototypeOf(constructed) === prototype, 'full conversion order before prototype');
+ let error, marker = {}, count = 0;
+ try { new C('track', {...init, streams: [new Proxy(stream, {})], get track() { count++; return audio; }}); } catch (caught) { error = caught; }
+ assert(error instanceof w.TypeError && count === 0, 'stream element native brand precedes track read');
+ try { new C('track', {...init, streams: {get [Symbol.iterator]() { throw marker; }}}); } catch (caught) { error = caught; }
+ assert(error === marker, 'iterator property exception identity');
+ for (const [key, real] of [['receiver',rtpReceiver],['track',audio],['transceiver',rtpTransceiver]]) {
+ let traps = 0;
+ const revoked = Proxy.revocable(real,{}); revoked.revoke();
+ for (const bad of [undefined,null,{},Object.create(real),new Proxy(real,{get() {traps++;throw Error('trap');}}),revoked.proxy]) {
+ error = undefined;
+ try { new C('track', {...init,[key]:bad}); } catch (caught) { error = caught; }
+ assert(error instanceof w.TypeError, 'required interface brand');
+ }
+ assert(traps === 0, 'no author interface Proxy traps');
+ }
+ const proxyEvent = new C('track', {receiver:nativeReceiver,track:nativeaudio,transceiver:nativeTransceiver,streams:[stream]});
+ assert(proxyEvent.receiver === nativeReceiver && proxyEvent.track === nativeaudio && proxyEvent.transceiver === nativeTransceiver, 'registered native proxy argument identities');
+ for (const key of ['receiver','track','transceiver']) Object.defineProperty(proxyEvent[key], 'constructor', {configurable:true,get() {throw Error('author constructor read');}});
+ assert(new C('track', {receiver:proxyEvent.receiver,track:proxyEvent.track,transceiver:proxyEvent.transceiver}).track === nativeaudio, 'brand uses private identity');
+ class Derived extends C {}
+ assert(new Derived('track', init) instanceof Derived, 'track subclass');
+ const targetEvent = new w.EventTarget(); let observed = 0;
+ targetEvent.addEventListener(event.type, e => { assert(e === event && e.streams[0] === stream, 'dispatch payload identity'); observed++; e.preventDefault(); });
+ assert(targetEvent.dispatchEvent(event) === false && observed === 1, 'native track EventTarget dispatch');
+ event.initEvent('reset', false, false);
+ assert(event.streams.length === 3 && event.receiver === rtpReceiver && event.track === audio && event.composed, 'legacy init preserves native payload');
+ const array = new C('track', {...init, streams: [stream]}).streams;
+ const savedArray = w.Array, savedFreeze = w.Object.freeze;
+ try {
+ w.Array = () => {throw Error('author Array');}; w.Object.freeze = () => {throw Error('author freeze');};
+ assert(new C('track', {...init,streams:[stream]}).streams[0] === stream && Object.getPrototypeOf(array) === savedArray.prototype, 'intrinsic frozen allocation');
+ } finally { w.Array = savedArray; w.Object.freeze = savedFreeze; }
+ }
+ globalThis.trackEvent = new RTCTrackEvent('track', {receiver:rtpReceiver,track:audio,transceiver:rtpTransceiver,streams:[new MediaStream()]});
+ globalThis.toneEvent = new RTCDTMFToneChangeEvent('tone', {tone:'\ud800'});
+ return true;
+})()
diff --git a/moli-webapi/src/events.rs b/moli-webapi/src/events.rs
index f3076b78f61..0cd07357c20 100644
--- a/moli-webapi/src/events.rs
+++ b/moli-webapi/src/events.rs
@@ -20,6 +20,7 @@ pub mod subclasses;
pub mod ui;
pub mod value;
pub mod webrtc;
+pub mod webrtc_payload;
use init::EventInit;
use state::{
diff --git a/moli-webapi/src/events/webrtc_payload.rs b/moli-webapi/src/events/webrtc_payload.rs
new file mode 100644
index 00000000000..a3162441c7c
--- /dev/null
+++ b/moli-webapi/src/events/webrtc_payload.rs
@@ -0,0 +1,224 @@
+//! Synthetic WebRTC event payloads, independent of an RTP or DTMF backend.
+
+use super::{
+ EventInit, event_private_value, initialize_event_object_with_type,
+ initialize_event_wrapper, new_event_state,
+};
+use crate::interfaces as web_api_interfaces;
+use moli_v8_util::{throw_type_error, v8str};
+use moli_webidl as webidl;
+use moli_webapi_declare::{
+ WebApiFunctionTemplate, WebApiObject, initialize_web_api_constructor_receiver,
+};
+
+const TONE: &str = "__moliRtcDtmfTone";
+const RECEIVER: &str = "__moliRtcTrackReceiver";
+const TRACK: &str = "__moliRtcTrackTrack";
+const STREAMS: &str = "__moliRtcTrackStreams";
+const TRANSCEIVER: &str = "__moliRtcTrackTransceiver";
+
+#[derive(webidl::WebIdlDictionary)]
+#[webidl(prefix = "RTCDTMFToneChangeEventInit")]
+struct ToneInit {
+ #[webidl(inherit)]
+ base: EventInit,
+ #[webidl(converter = "raw", default = webidl::DomString16(Vec::new()))]
+ tone: webidl::DomString16,
+}
+
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "RTCDTMFToneChangeEvent")]
+struct ToneArgs {
+ #[webidl(required, converter = "raw")]
+ event_type: webidl::DomString16,
+ #[webidl(dictionary)]
+ init: ToneInit,
+}
+
+#[derive(webidl::WebIdlDictionary)]
+#[webidl(prefix = "RTCTrackEventInit")]
+struct TrackInit<'s> {
+ #[webidl(inherit)]
+ base: EventInit,
+ #[webidl(required, interface = web_api_interfaces::RTCRtpReceiver)]
+ receiver: v8::Local<'s, v8::Object>,
+ #[webidl(sequence, interface = web_api_interfaces::MediaStream, default = Vec::new())]
+ streams: Vec>,
+ #[webidl(required, interface = web_api_interfaces::MediaStreamTrack)]
+ track: v8::Local<'s, v8::Object>,
+ #[webidl(required, interface = web_api_interfaces::RTCRtpTransceiver)]
+ transceiver: v8::Local<'s, v8::Object>,
+}
+
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "RTCTrackEvent")]
+struct TrackArgs<'s> {
+ #[webidl(required, converter = "raw")]
+ event_type: webidl::DomString16,
+ #[webidl(required, dictionary)]
+ init: TrackInit<'s>,
+}
+
+#[derive(WebApiObject)]
+#[webapi(interface = web_api_interfaces::RTCDTMFToneChangeEvent)]
+struct ToneSlots<'s> {
+ #[webapi(data_property, enumerable)]
+ composed: bool,
+ #[webapi(slot = TONE)]
+ tone: v8::Local<'s, v8::String>,
+}
+
+#[derive(WebApiObject)]
+#[webapi(interface = web_api_interfaces::RTCTrackEvent)]
+struct TrackSlots<'s> {
+ #[webapi(data_property, enumerable)]
+ composed: bool,
+ #[webapi(slot = RECEIVER)]
+ receiver: v8::Local<'s, v8::Object>,
+ #[webapi(slot = TRACK)]
+ track: v8::Local<'s, v8::Object>,
+ #[webapi(slot = STREAMS)]
+ streams: v8::Local<'s, v8::Array>,
+ #[webapi(slot = TRANSCEIVER)]
+ transceiver: v8::Local<'s, v8::Object>,
+}
+
+#[derive(WebApiFunctionTemplate)]
+#[webapi(interface = web_api_interfaces::RTCDTMFToneChangeEvent, enumerable)]
+struct TonePrototype {
+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, TONE))]
+ tone: (),
+}
+
+#[derive(WebApiFunctionTemplate)]
+#[webapi(interface = web_api_interfaces::RTCTrackEvent, enumerable)]
+struct TrackPrototype {
+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, RECEIVER))]
+ receiver: (),
+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, TRACK))]
+ track: (),
+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, STREAMS))]
+ streams: (),
+ #[webapi(accessor_property, getter = payload_getter, data = v8str(scope, TRANSCEIVER))]
+ transceiver: (),
+}
+
+pub fn install<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ prototype: v8::Local<'s, v8::ObjectTemplate>,
+ interface: &str,
+) {
+ match interface {
+ "RTCDTMFToneChangeEvent" => TonePrototype::initialize_prototype_template(scope, prototype),
+ "RTCTrackEvent" => TrackPrototype::initialize_prototype_template(scope, prototype),
+ _ => (),
+ }
+}
+
+pub fn rtc_dtmf_tone_event_constructor<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s>,
+) {
+ if !args.is_construct_call() {
+ throw_type_error(scope, "RTCDTMFToneChangeEvent requires 'new'.");
+ return;
+ }
+ let Some(parsed) = webidl::parse_args::(scope, &args) else {
+ return;
+ };
+ let Some(state) = event_state(
+ scope,
+ &args,
+ "RTCDTMFToneChangeEvent",
+ &parsed.event_type,
+ &parsed.init.base,
+ ) else {
+ return;
+ };
+ let Some(tone) =
+ v8::String::new_from_two_byte(scope, &parsed.init.tone.0, v8::NewStringType::Normal)
+ else {
+ return;
+ };
+ if ToneSlots::new(parsed.init.base.composed, tone)
+ .initialize(scope, state)
+ .is_ok()
+ && initialize_event_wrapper(scope, args.this(), state).is_some()
+ {
+ rv.set(args.this().into());
+ }
+}
+
+pub fn rtc_track_event_constructor<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s>,
+) {
+ if !args.is_construct_call() {
+ throw_type_error(scope, "RTCTrackEvent requires 'new'.");
+ return;
+ }
+ let Some(parsed) = webidl::parse_args::(scope, &args) else {
+ return;
+ };
+ let Some(state) = event_state(
+ scope,
+ &args,
+ "RTCTrackEvent",
+ &parsed.event_type,
+ &parsed.init.base,
+ ) else {
+ return;
+ };
+ // Snapshot the sequence in the event's realm, retaining supplied platform
+ // object identity and duplicates. Never consult author Array/Object helpers.
+ let elements: Vec<_> = parsed.init.streams.into_iter().map(Into::into).collect();
+ let streams = v8::Array::new_with_elements(scope, &elements);
+ if streams.set_integrity_level(scope, v8::IntegrityLevel::Frozen) != Some(true) {
+ return;
+ }
+ if TrackSlots::new(
+ parsed.init.base.composed,
+ parsed.init.receiver,
+ parsed.init.track,
+ streams,
+ parsed.init.transceiver,
+ )
+ .initialize(scope, state)
+ .is_ok()
+ && initialize_event_wrapper(scope, args.this(), state).is_some()
+ {
+ rv.set(args.this().into());
+ }
+}
+
+fn event_state<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: &v8::FunctionCallbackArguments<'s>,
+ interface: &str,
+ event_type: &webidl::DomString16,
+ init: &EventInit,
+) -> Option> {
+ // The public constructor uses the shared deferred-prototype entry. Complete
+ // all WebIDL conversion before observing newTarget.prototype.
+ if !initialize_web_api_constructor_receiver(scope, args.this(), interface) {
+ return None;
+ }
+ let event_type =
+ v8::String::new_from_two_byte(scope, &event_type.0, v8::NewStringType::Normal)?;
+ let state = new_event_state(scope);
+ initialize_event_object_with_type(scope, state, event_type, init.bubbles, init.cancelable);
+ Some(state)
+}
+
+fn payload_getter<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s>,
+) {
+ let slot = args.data().to_rust_string_lossy(scope);
+ if let Some(value) = event_private_value(scope, args.this(), &slot) {
+ rv.set(value);
+ }
+}
diff --git a/moli-webapi/src/rtc.rs b/moli-webapi/src/rtc.rs
index 01e5446e892..3f9c6417120 100644
--- a/moli-webapi/src/rtc.rs
+++ b/moli-webapi/src/rtc.rs
@@ -12,6 +12,9 @@ pub use crate::events::webrtc::{
rtc_data_channel_event_constructor_callback, rtc_error_event_constructor_callback,
rtc_peer_connection_ice_event_constructor_callback,
};
+pub use crate::events::webrtc_payload::{
+ rtc_dtmf_tone_event_constructor, rtc_track_event_constructor,
+};
pub use ice_candidate::rtc_ice_candidate_constructor_callback;
pub use peer_connection::rtc_peer_connection_constructor_callback;
pub use session_description::rtc_session_description_constructor_callback;
@@ -32,6 +35,9 @@ pub fn install_template_bindings<'s>(
"RTCPeerConnectionIceEvent" | "RTCDataChannelEvent" | "RTCErrorEvent" => {
crate::events::webrtc::install_event_template_bindings(scope, template, interface)
}
+ "RTCDTMFToneChangeEvent" | "RTCTrackEvent" => {
+ crate::events::webrtc_payload::install(scope, prototype, interface)
+ }
"RTCIceCandidate" => {
ice_candidate::install_ice_candidate_template_bindings(scope, template)
}