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) }