From 03f2ec96caecd8502b98dcddbaff87f5de589eac Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 9 Oct 2026 14:41:33 +0800 Subject: [PATCH] fix(webrtc): initialize tone and track event payloads Use shared WebIDL dictionary and native receiver bindings for synthetic RTC events. Retain platform object identities, freeze the stream snapshot in the event realm, and defer newTarget prototype selection until argument conversion completes. --- .../assets/constructor_templates.rs | 16 ++ .../exposed_interfaces/materialize.rs | 2 + .../src/context_bootstrap/specs/registry.rs | 4 +- .../src/context_bootstrap/specs/types.rs | 2 + moli-renderer-v8/src/script_vm/tests/mod.rs | 1 + .../src/script_vm/tests/webrtc_event_init.rs | 99 ++++++++ .../tests/fixtures/webrtc-event-init.js | 136 +++++++++++ .../tests/fixtures/webrtc-event-native.js | 68 ++++++ moli-webapi/src/events.rs | 1 + moli-webapi/src/events/webrtc_payload.rs | 224 ++++++++++++++++++ moli-webapi/src/rtc.rs | 6 + 11 files changed, 557 insertions(+), 2 deletions(-) create mode 100644 moli-renderer-v8/src/script_vm/tests/webrtc_event_init.rs create mode 100644 moli-renderer-v8/tests/fixtures/webrtc-event-init.js create mode 100644 moli-renderer-v8/tests/fixtures/webrtc-event-native.js create mode 100644 moli-webapi/src/events/webrtc_payload.rs 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) }