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.
This commit is contained in:
ldm0
2026-11-19 00:58:09 +08:00
parent 97d207de5e
commit 03f2ec96ca
11 changed files with 557 additions and 2 deletions
@@ -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)
}
@@ -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
@@ -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,
@@ -63,6 +63,8 @@ pub(in crate::context_bootstrap) enum ConstructorKind {
RtcEncodedAudioFrame,
RtcEncodedVideoFrame,
RtcErrorEvent,
RtcDtmfToneChangeEvent,
RtcTrackEvent,
DomError,
QuotaExceededError,
CustomElementRegistry,
@@ -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;
@@ -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 = '<iframe></iframe>'")
.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::<v8::Object>::try_from(value).unwrap();
let handler = crate::util::new_null_prototype_object(scope);
let proxy = v8::Proxy::new(scope, object, handler).unwrap();
moli_webapi_declare::register_web_api_proxy(scope, proxy)?;
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");
}
+136
View File
@@ -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);
})()
+68
View File
@@ -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;
})()
+1
View File
@@ -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::{
+224
View File
@@ -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<v8::Local<'s, v8::Object>>,
#[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::<ToneArgs>(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::<TrackArgs>(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<v8::Local<'s, v8::Object>> {
// 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);
}
}
+6
View File
@@ -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)
}