diff --git a/moli-renderer-v8/src/context_bootstrap/rtc_rtp.rs b/moli-renderer-v8/src/context_bootstrap/rtc_rtp.rs index 92fcde2acdb..b7dc8f32af1 100644 --- a/moli-renderer-v8/src/context_bootstrap/rtc_rtp.rs +++ b/moli-renderer-v8/src/context_bootstrap/rtc_rtp.rs @@ -1,11 +1,13 @@ //! Host-owned RTP objects and WebRTC tasks. +use moli_webapi::event_target::SIMPLE_EVENT_TARGET_LISTENERS_SLOT; use moli_webapi::rtc::peer_connection::{ RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT, rtp_capabilities, complete_create_offer, complete_set_local_description, }; mod operations; +mod dtmf; mod signaling; mod rtp_sender; mod rtp_offer; @@ -23,6 +25,9 @@ pub(super) fn install<'s>( if interface == "RTCPeerConnection" { signaling::install(scope, prototype); } + if interface == "RTCDTMFSender" { + dtmf::install(scope, prototype); + } } pub(super) fn install_runtime(scope: &mut v8::PinScope<'_, '_>) { diff --git a/moli-renderer-v8/src/context_bootstrap/rtc_rtp/dtmf.rs b/moli-renderer-v8/src/context_bootstrap/rtc_rtp/dtmf.rs new file mode 100644 index 00000000000..a897d0bc3aa --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/rtc_rtp/dtmf.rs @@ -0,0 +1,132 @@ +//! DTMF identity and events for local, unnegotiated RTP senders. There is no +//! negotiated telephone-event codec or connected RTP transport yet, so sending +//! tones is unavailable. WebIDL conversion still precedes InvalidStateError. + +use crate::{ + context_bootstrap::{exposed_interfaces, media_queries}, + native_bridge::throw_dom_exception, + util::{get_private_value, set_private_value}, + web_api_interfaces, webidl, +}; +use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject}; + +const TONE_BUFFER: &str = "__moliRtcDtmfToneBuffer"; +const HANDLER: &str = "__moliRtcOnToneChange"; + +#[derive(WebApiObject)] +#[webapi(interface = web_api_interfaces::RTCDTMFSender)] +struct Slots { + #[webapi(slot = TONE_BUFFER, init = "")] + tone_buffer: (), + #[webapi(slot = HANDLER, init = "null")] + ontonechange: (), + #[webapi(slot = super::SIMPLE_EVENT_TARGET_LISTENERS_SLOT, init = "null_object")] + event_target_slot: (), +} + +#[derive(WebApiFunctionTemplate)] +#[webapi(interface = web_api_interfaces::RTCDTMFSender, enumerable)] +struct Prototype { + #[webapi(accessor_property, getter = tone_buffer)] + tone_buffer: (), + #[webapi(accessor_property = "canInsertDTMF", getter = can_insert_dtmf)] + can_insert_dtmf: (), + #[webapi(accessor_property, getter = handler, setter = set_handler)] + ontonechange: (), + #[webapi(method = "insertDTMF", length = 1, callback = insert_dtmf)] + insert_dtmf: (), +} + +#[derive(webidl::WebIdlArgs)] +#[webidl(prefix = "RTCDTMFSender.insertDTMF")] +struct InsertArgs { + #[webidl(required, name = "tones", converter = "raw")] + _tones: webidl::DomString16, + #[webidl(name = "duration", default = 100)] + _duration: u32, + #[webidl(name = "interToneGap", default = 70)] + _inter_tone_gap: u32, +} + +pub(super) fn install<'s>( + scope: &mut v8::PinScope<'s, '_, ()>, + prototype: v8::Local<'s, v8::ObjectTemplate>, +) { + Prototype::initialize_prototype_template(scope, prototype); +} + +pub(super) fn build<'s>( + scope: &mut v8::PinScope<'s, '_>, + sender: v8::Local<'s, v8::Object>, +) -> Option> { + let context = sender + .get_creation_context(scope) + .expect("RTP sender realm"); + let scope = &mut v8::ContextScope::new(scope, context); + let object = + exposed_interfaces::build_intrinsic_interface_instance(scope, "RTCDTMFSender").ok()?; + let prototype = + exposed_interfaces::ensure_intrinsic_interface_prototype(scope, "RTCDTMFSender").ok()?; + if object.set_prototype(scope, prototype.into()) != Some(true) { + return None; + } + Slots::new() + .initialize(scope, object) + .expect("DTMF sender slots"); + Some(object) +} + +fn tone_buffer<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let dtmf = super::rtp_transceivers::target(scope, args.this()); + rv.set(get_private_value(scope, dtmf, TONE_BUFFER).expect("DTMF tone buffer")); +} + +fn can_insert_dtmf<'s>( + _scope: &mut v8::PinScope<'s, '_>, + _args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + // Sender.transport is null and getParameters().codecs is empty until + // negotiation is implemented. Neither permits sending telephone events. + rv.set_bool(false); +} + +fn insert_dtmf<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(_) = webidl::parse_args::(scope, &args) else { + return; + }; + // The capability check precedes tone validation and any buffer mutation, + // including when tones is empty. No playout task or synthetic event starts. + throw_dom_exception( + scope, + "InvalidStateError", + 11, + "DTMF sending is unavailable.", + ); +} + +fn handler<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let dtmf = super::rtp_transceivers::target(scope, args.this()); + rv.set(get_private_value(scope, dtmf, HANDLER).expect("DTMF event handler")); +} + +fn set_handler<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let dtmf = super::rtp_transceivers::target(scope, args.this()); + media_queries::simple_object_event_set_handler(scope, dtmf, "tonechange", HANDLER, args.get(0)); +} diff --git a/moli-renderer-v8/src/context_bootstrap/rtc_rtp/rtp_sender.rs b/moli-renderer-v8/src/context_bootstrap/rtc_rtp/rtp_sender.rs index 40e6fa33e10..8d2f1c583be 100644 --- a/moli-renderer-v8/src/context_bootstrap/rtc_rtp/rtp_sender.rs +++ b/moli-renderer-v8/src/context_bootstrap/rtc_rtp/rtp_sender.rs @@ -26,6 +26,7 @@ const TRACK_ID: &str = "__moliRtpSdpTrackId"; const ENCODINGS: &str = "__moliRtpEncodings"; const STREAMS: &str = "__moliRtpAssociatedStreamIds"; const LAST_PARAMETERS: &str = "__moliRtpLastReturnedParameters"; +const DTMF: &str = "__moliRtpDtmf"; const CNAME: &str = "__moliRtcRtcpCname"; const TASK_SENDER: &str = "__moliRtpTaskSender"; const TASK_PARAMETERS: &str = "__moliRtpTaskParameters"; @@ -51,6 +52,8 @@ struct SenderSlots<'s> { streams: v8::Local<'s, v8::Array>, #[webapi(slot = LAST_PARAMETERS, init = "null")] last_parameters: (), + #[webapi(slot = DTMF)] + dtmf: v8::Local<'s, v8::Value>, } #[derive(WebApiObject)] #[webapi(plain)] @@ -102,6 +105,8 @@ struct SenderPrototype { track: (), #[webapi(accessor_property, getter = transport)] transport: (), + #[webapi(accessor_property, getter = dtmf)] + dtmf: (), #[webapi(method, length = 0, callback = get_parameters)] get_parameters: (), #[webapi(method, returns_promise, length = 1, callback = set_parameters)] @@ -151,6 +156,11 @@ pub(super) fn initialize<'s>( } else { media_streams::identifier(scope)? }; + let dtmf = if kind == "audio" { + super::dtmf::build(scope, sender)?.into() + } else { + v8::null(scope).into() + }; SenderSlots::new( pc, transceiver, @@ -161,6 +171,7 @@ pub(super) fn initialize<'s>( track_id, v8_string(scope, &encodings.to_string())?, v8::Array::new_with_elements(scope, streams), + dtmf, ) .initialize(scope, sender) .expect("RTP sender slots"); @@ -212,6 +223,15 @@ fn transport<'s>( rv.set_null(); } +fn dtmf<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + mut rv: v8::ReturnValue<'_, v8::Value>, +) { + let sender = rtp_transceivers::target(scope, args.this()); + rv.set(get_private_value(scope, sender, DTMF).expect("sender DTMF identity")); +} + fn get_parameters<'s>( scope: &mut v8::PinScope<'s, '_>, args: v8::FunctionCallbackArguments<'s>, diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 61d60225129..d5984bbd72a 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -2480,6 +2480,7 @@ mod document_attribute_factory_realms; mod response_blob_mime; mod retained_child_window; mod rtc_certificate; +mod rtc_dtmf_sender; mod rtc_encoded_frames; mod rtp_sender; mod rtp_transceivers; diff --git a/moli-renderer-v8/src/script_vm/tests/rtc_dtmf_sender.rs b/moli-renderer-v8/src/script_vm/tests/rtc_dtmf_sender.rs new file mode 100644 index 00000000000..6ba3cf5b847 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/rtc_dtmf_sender.rs @@ -0,0 +1,76 @@ +use super::*; + +#[tokio::test(flavor = "current_thread")] +async fn rtc_dtmf_sender_identity_conversion_events_and_lifecycle() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + for url in [ + "https://dtmf.test/", + "http://dtmf.test/", + "data:text/html,", + ] { + let mut vm = new_storage_page_task_executor_test_vm_with_loader(url, &loader); + vm.eval("document.body.innerHTML=''") + .unwrap(); + vm.eval(include_str!("../../../tests/fixtures/rtc-dtmf-sender.js")) + .unwrap(); + advance_page_task_executor_until_eval_equals( + &mut vm, + &loader, + "String(globalThis.__uiEventResults?.complete)", + "true", + "DTMF sender fixture must finish through the production selected Page dispatcher", + ) + .await; + assert_eq!( + vm.eval("JSON.stringify(__uiEventResults.checks.filter(row=>!row.passed))") + .unwrap(), + "[]", + "{url}" + ); + assert_eq!(vm.eval("__uiEventResults.total===64 && new Set(__uiEventResults.checks.map(row=>row.name)).size===64").unwrap(), "true"); + } +} + +#[test] +fn rtc_dtmf_sender_registered_native_proxies_keep_identity_and_event_state() { + let mut vm = new_parsed_test_vm( + "https://dtmf.test/proxy", + "", + ); + vm.eval("globalThis.pc=new RTCPeerConnection();globalThis.sender=pc.addTransceiver('audio').sender;globalThis.dtmf=sender.dtmf").unwrap(); + let context_ptr = &vm.current_main_world().unwrap().context as *const _; + vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| { + let global = scope.get_current_context().global(scope); + for (name, alias) in [("sender", "nativeSender"), ("dtmf", "nativeDTMF")] { + let key = crate::util::v8_string(scope, name).unwrap(); + let object = + v8::Local::::try_from(global.get(scope, key.into()).unwrap()).unwrap(); + let handler = crate::util::new_null_prototype_object(scope); + let proxy = v8::Proxy::new(scope, object, handler).unwrap(); + moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap(); + let key = crate::util::v8_string(scope, alias).unwrap(); + assert_eq!( + global.create_data_property(scope, key.into(), proxy.into()), + Some(true) + ); + } + Ok(()) + }) + .unwrap(); + assert_eq!(vm.eval(r#"(() => { + const other=document.querySelector('iframe').contentWindow; + const assert=ok=>{if(!ok)throw Error('native DTMF proxy')}; + assert(nativeSender.dtmf===dtmf && nativeDTMF.toneBuffer==='' && nativeDTMF.canInsertDTMF===false); + let count=0; const callback=()=>count++; + Object.getOwnPropertyDescriptor(other.RTCDTMFSender.prototype,'ontonechange').set.call(nativeDTMF,callback); + assert(dtmf.ontonechange===callback); + EventTarget.prototype.dispatchEvent.call(nativeDTMF,new RTCDTMFToneChangeEvent('tonechange',{tone:'1'})); + assert(count===1); + let conversions=0,error; + try{other.RTCDTMFSender.prototype.insertDTMF.call(nativeDTMF,{toString(){conversions++;return '1'}})}catch(e){error=e} + assert(error instanceof other.DOMException && error.name==='InvalidStateError' && conversions===1); + conversions=0;try{other.RTCDTMFSender.prototype.insertDTMF.call(new Proxy(nativeDTMF,{}),{toString(){conversions++;return '1'}})}catch(e){error=e} + assert(error instanceof other.TypeError && conversions===0); + pc.close(); assert(nativeSender.dtmf===dtmf && nativeDTMF.toneBuffer==='');return true; + })()"#).unwrap(), "true"); +} diff --git a/moli-renderer-v8/tests/fixtures/rtc-dtmf-sender.js b/moli-renderer-v8/tests/fixtures/rtc-dtmf-sender.js new file mode 100644 index 00000000000..ebdc5f70f49 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/rtc-dtmf-sender.js @@ -0,0 +1,233 @@ +(async () => { + const checks = []; + const assert = (ok, message = 'assertion failed') => { if (!ok) throw Error(message); }; + const check = async (name, body) => { + try { await body(); checks.push({name, passed: true}); } + catch (error) { checks.push({name, passed: false, error: String(error), stack: error.stack}); } + }; + const caught = body => { try { body(); } catch (error) { return error; } }; + const child = document.querySelector('iframe').contentWindow; + for (const [realm, w] of [['main', window], ['iframe', child]]) { + const run = (name, body) => check(`${realm}: ${name}`, async () => { + const pc = new w.RTCPeerConnection(); + try { await body(pc); } finally { pc.close(); } + }); + const audio = pc => pc.addTransceiver('audio').sender; + const dtmf = pc => audio(pc).dtmf; + const event = () => new w.RTCDTMFToneChangeEvent('tonechange', {tone: '1'}); + const unavailable = (value, tones = '') => { + const error = caught(() => value.insertDTMF(tones)); + assert(error instanceof w.DOMException && error.name === 'InvalidStateError'); + assert(value.toneBuffer === '' && value.canInsertDTMF === false); + }; + await run('DTMF interface is an illegal EventTarget constructor', () => { + assert(w.RTCDTMFSender.name === 'RTCDTMFSender' && w.RTCDTMFSender.length === 0); + assert(w.Object.getPrototypeOf(w.RTCDTMFSender.prototype) === w.EventTarget.prototype); + assert(caught(() => new w.RTCDTMFSender()) instanceof w.TypeError); + assert(caught(() => w.RTCDTMFSender()) instanceof w.TypeError); + }); + await run('audio sender without a track has a stable native DTMF identity', pc => { + const sender = audio(pc), value = sender.dtmf; + assert(sender.track === null && value instanceof w.RTCDTMFSender && value instanceof w.EventTarget); + assert(sender.dtmf === value && w.Object.getPrototypeOf(value) === w.RTCDTMFSender.prototype); + assert(w.Object.prototype.toString.call(value) === '[object RTCDTMFSender]'); + }); + await run('video sender has null DTMF', pc => { + assert(pc.addTransceiver('video').sender.dtmf === null); + }); + await run('different audio senders have different DTMF objects', pc => { + const first = dtmf(pc), second = dtmf(pc); + assert(first instanceof w.RTCDTMFSender && second instanceof w.RTCDTMFSender && first !== second); + }); + await run('sender DTMF descriptor is a readonly native accessor', pc => { + const sender = audio(pc), d = w.Object.getOwnPropertyDescriptor(w.RTCRtpSender.prototype, 'dtmf'); + assert(typeof d.get === 'function' && d.get.length === 0 && d.set === undefined && d.enumerable && d.configurable); + assert(!w.Object.hasOwn(sender, 'dtmf') && !w.Reflect.set(sender, 'dtmf', null)); + assert(d.get.call(sender) === sender.dtmf); + }); + await run('DTMF members have native WebIDL descriptors', pc => { + const value = dtmf(pc), p = w.RTCDTMFSender.prototype; + for (const name of ['toneBuffer', 'canInsertDTMF']) { + const d = w.Object.getOwnPropertyDescriptor(p, name); + assert(typeof d.get === 'function' && d.get.length === 0 && d.set === undefined && d.enumerable && d.configurable); + assert(!w.Object.hasOwn(value, name) && !w.Reflect.set(value, name, 123)); + } + const h = w.Object.getOwnPropertyDescriptor(p, 'ontonechange'); + assert(typeof h.get === 'function' && typeof h.set === 'function' && h.get.length === 0 && h.set.length === 1 && h.enumerable && h.configurable); + const m = w.Object.getOwnPropertyDescriptor(p, 'insertDTMF'); + assert(typeof m.value === 'function' && m.value.name === 'insertDTMF' && m.value.length === 1 && m.writable && m.enumerable && m.configurable); + }); + await run('new sender is unavailable with an empty tone buffer and null handler', pc => { + const value = dtmf(pc); + assert(value.canInsertDTMF === false && value.toneBuffer === '' && value.ontonechange === null); + }); + await run('nonobject handler assignments clear the handler', pc => { + const value = dtmf(pc); + for (const next of [null, undefined, false, true, 0, 'handler', Symbol('handler'), 1n]) { + value.ontonechange = () => {}; value.ontonechange = next; assert(value.ontonechange === null); + } + }); + await run('handler callback object is retained without property access', pc => { + const value = dtmf(pc); let reads = 0; + const callback = new Proxy({}, {get() { reads++; throw Error('handler trap'); }}); + value.ontonechange = callback; assert(value.ontonechange === callback && reads === 0); + value.ontonechange = null; + }); + await run('handler participates in listener registration order', pc => { + const value = dtmf(pc), trace = []; + value.addEventListener('tonechange', () => trace.push('before')); + value.ontonechange = function(e) { assert(this === value && e.currentTarget === value); trace.push('handler'); }; + value.addEventListener('tonechange', () => trace.push('after')); + value.dispatchEvent(event()); assert(trace.join(',') === 'before,handler,after'); + }); + await run('handler replacement retains its position', pc => { + const value = dtmf(pc), trace = []; + value.ontonechange = () => trace.push('old'); value.addEventListener('tonechange', () => trace.push('listener')); + value.ontonechange = () => trace.push('new'); value.dispatchEvent(event()); + assert(trace.join(',') === 'new,listener'); + }); + await run('cleared and reactivated handler is appended', pc => { + const value = dtmf(pc), trace = []; + value.ontonechange = () => trace.push('old'); value.addEventListener('tonechange', () => trace.push('listener')); + value.ontonechange = null; value.ontonechange = () => trace.push('new'); value.dispatchEvent(event()); + assert(trace.join(',') === 'listener,new'); + }); + await run('once and removed listeners use EventTarget lifecycle', pc => { + const value = dtmf(pc); let count = 0; const removed = () => count += 100; + value.addEventListener('tonechange', () => count++, {once: true}); + value.addEventListener('tonechange', removed); value.removeEventListener('tonechange', removed); + value.dispatchEvent(event()); value.dispatchEvent(event()); assert(count === 1); + }); + await run('aborted listener is not invoked', pc => { + const value = dtmf(pc), controller = new w.AbortController(); let count = 0; + value.addEventListener('tonechange', () => count++, {signal: controller.signal}); controller.abort(); + value.dispatchEvent(event()); assert(count === 0); + }); + await run('listener exception does not prevent subsequent dispatch', pc => { + const value = dtmf(pc); let count = 0; + value.ontonechange = () => { throw Error('expected DTMF callback failure'); }; + value.addEventListener('tonechange', () => count++); assert(value.dispatchEvent(event()) === true && count === 1); + }); + await run('stopImmediatePropagation suppresses later handlers', pc => { + const value = dtmf(pc); let count = 0; + value.addEventListener('tonechange', e => e.stopImmediatePropagation()); value.ontonechange = () => count++; + value.dispatchEvent(event()); assert(count === 0); + }); + await run('manual tone event retains UTF16 payload and does not mutate the buffer', pc => { + const value = dtmf(pc), e = new w.RTCDTMFToneChangeEvent('tonechange', {tone: 'a\ud800'}); + let observed; value.ontonechange = next => { observed = next; assert(next.eventPhase === 2); }; + assert(value.dispatchEvent(e) && observed === e && e.tone === 'a\ud800' && !e.isTrusted); + assert(e.target === value && e.currentTarget === null && e.eventPhase === 0 && value.toneBuffer === ''); + }); + await run('insertDTMF requires its tones argument', pc => { + const value = dtmf(pc); assert(caught(() => value.insertDTMF()) instanceof w.TypeError); + assert(value.toneBuffer === ''); + }); + await run('unavailable state precedes validation of tone characters', pc => { + const value = dtmf(pc); + for (const tones of ['', '123Abcd#*,', 'invalid', '🎵', '\ud800', null, undefined]) unavailable(value, tones); + }); + await run('all argument conversions precede unavailable state', pc => { + const value = dtmf(pc), trace = []; + const error = caught(() => value.insertDTMF({toString() { trace.push('tones'); return '1'; }}, + {valueOf() { trace.push('duration'); return 100; }}, {valueOf() { trace.push('gap'); return 70; }})); + assert(error instanceof w.DOMException && error.name === 'InvalidStateError' && trace.join(',') === 'tones,duration,gap'); + }); + await run('each conversion exception is preserved without later conversions', pc => { + const value = dtmf(pc), marker = {}; + for (let failing = 0; failing < 3; failing++) { + const trace = [], convert = index => { trace.push(index); if (index === failing) throw marker; return index === 0 ? '1' : 100; }; + const error = caught(() => value.insertDTMF({toString() { return convert(0); }}, + {valueOf() { return convert(1); }}, {valueOf() { return convert(2); }})); + assert(error === marker && trace.join(',') === [0, 1, 2].slice(0, failing + 1).join(',')); + } + }); + await run('symbol tones and bigint numeric arguments fail conversion', pc => { + const value = dtmf(pc); + for (const args of [[Symbol('tone')], ['1', 1n], ['1', 100, 1n], ['1', Symbol('duration')], ['1', 100, Symbol('gap')]]) { + assert(caught(() => value.insertDTMF(...args)) instanceof w.TypeError); + } + }); + await run('ordinary unsigned-long conversion accepts nonfinite and wrapping values', pc => { + const value = dtmf(pc); + for (const number of [NaN, Infinity, -Infinity, -1, 0, 0.5, 2 ** 32 + 100]) { + const error = caught(() => value.insertDTMF('1', number, number)); + assert(error instanceof w.DOMException && error.name === 'InvalidStateError'); + } + }); + await run('native brands reject forged author and revoked proxies before conversion or traps', pc => { + const value = dtmf(pc); assert(value instanceof w.RTCDTMFSender); let conversions = 0, traps = 0; + const proxy = new Proxy(value, {get() { traps++; throw Error('get trap'); }, getPrototypeOf() { traps++; throw Error('prototype trap'); }}); + const revoked = Proxy.revocable(value, {}); revoked.revoke(); + const p = w.RTCDTMFSender.prototype; + for (const invalid of [{}, Object.create(value), Object.create(p), proxy, revoked.proxy]) { + for (const name of ['toneBuffer', 'canInsertDTMF', 'ontonechange']) { + assert(caught(() => w.Object.getOwnPropertyDescriptor(p, name).get.call(invalid)) instanceof w.TypeError); + } + assert(caught(() => p.insertDTMF.call(invalid, {toString() { conversions++; return '1'; }})) instanceof w.TypeError); + assert(caught(() => w.Object.getOwnPropertyDescriptor(p, 'ontonechange').set.call(invalid, () => {})) instanceof w.TypeError); + } + assert(conversions === 0 && traps === 0); + }); + await run('sender DTMF getter rejects forged and author proxies', pc => { + const sender = audio(pc), getter = w.Object.getOwnPropertyDescriptor(w.RTCRtpSender.prototype, 'dtmf').get; + let traps = 0; const proxy = new Proxy(sender, {getPrototypeOf() { traps++; throw Error('trap'); }}); + const revoked = Proxy.revocable(sender, {}); revoked.revoke(); + for (const invalid of [{}, Object.create(sender), Object.create(w.RTCRtpSender.prototype), proxy, revoked.proxy]) { + assert(caught(() => getter.call(invalid)) instanceof w.TypeError); + } + assert(traps === 0); + }); + await run('replaced global constructor does not change native DTMF allocation', pc => { + const original = w.RTCDTMFSender; + try { w.RTCDTMFSender = function() { throw Error('author constructor'); }; + const value = audio(pc).dtmf; assert(value instanceof original && w.Object.getPrototypeOf(value) === original.prototype); + } finally { w.RTCDTMFSender = original; } + }); + await run('replaceTrack preserves DTMF identity while track changes', async pc => { + const sender = audio(pc), value = sender.dtmf; assert(value instanceof w.RTCDTMFSender); + const track = pc.addTransceiver('audio').receiver.track; + await sender.replaceTrack(track); assert(sender.track === track && sender.dtmf === value); unavailable(value); + await sender.replaceTrack(null); assert(sender.track === null && sender.dtmf === value); unavailable(value); + }); + await run('local offer and rollback do not enable tone transmission', async pc => { + const sender = audio(pc), value = sender.dtmf; assert(value instanceof w.RTCDTMFSender); + await pc.setLocalDescription(); unavailable(value, '12'); + await pc.setLocalDescription({type: 'rollback'}); unavailable(value, '12'); assert(sender.dtmf === value); + }); + await run('stopping transceiver retains identity and remains unavailable', pc => { + const transceiver = pc.addTransceiver('audio'), value = transceiver.sender.dtmf; + transceiver.stop(); assert(transceiver.sender.dtmf === value); unavailable(value, '1'); + }); + await run('closing connection retains DTMF and EventTarget behavior', pc => { + const sender = audio(pc), value = sender.dtmf; let count = 0; + value.ontonechange = () => count++; pc.close(); assert(sender.dtmf === value); unavailable(value, '1'); + value.dispatchEvent(event()); assert(count === 1); + }); + await run('shadowed public capability cannot authorize native sending', pc => { + const value = dtmf(pc), getter = w.Object.getOwnPropertyDescriptor(w.RTCDTMFSender.prototype, 'canInsertDTMF').get; + w.Object.defineProperty(value, 'canInsertDTMF', {value: true}); + assert(value.canInsertDTMF && getter.call(value) === false); + const error = caught(() => value.insertDTMF('1')); assert(error instanceof w.DOMException && error.name === 'InvalidStateError'); + assert(value.toneBuffer === ''); + }); + } + for (const [name, owner, callee] of [['main owner', window, child], ['iframe owner', child, window]]) { + await check(`cross realm: ${name} keeps DTMF identity and callee errors`, () => { + const pc = new owner.RTCPeerConnection(); + try { + const sender = pc.addTransceiver('audio').sender; + const getter = callee.Object.getOwnPropertyDescriptor(callee.RTCRtpSender.prototype, 'dtmf').get; + const value = getter.call(sender); + assert(value === sender.dtmf && value instanceof owner.RTCDTMFSender && !(value instanceof callee.RTCDTMFSender)); + const buffer = callee.Object.getOwnPropertyDescriptor(callee.RTCDTMFSender.prototype, 'toneBuffer').get; + assert(buffer.call(value) === ''); + const error = caught(() => callee.RTCDTMFSender.prototype.insertDTMF.call(value, '1')); + assert(error instanceof callee.DOMException && !(error instanceof owner.DOMException) && error.name === 'InvalidStateError'); + const invalid = caught(() => getter.call({})); assert(invalid instanceof callee.TypeError && !(invalid instanceof owner.TypeError)); + } finally { pc.close(); } + }); + } + globalThis.__uiEventResults = {complete: true, total: checks.length, passed: checks.filter(row => row.passed).length, checks}; + return checks.every(row => row.passed); +})()