mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
feat(webrtc): expose native DTMF sender state
This commit is contained in:
@@ -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<'_, '_>) {
|
||||
|
||||
@@ -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<v8::Local<'s, v8::Object>> {
|
||||
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::<InsertArgs>(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));
|
||||
}
|
||||
@@ -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>,
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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,<body>",
|
||||
] {
|
||||
let mut vm = new_storage_page_task_executor_test_vm_with_loader(url, &loader);
|
||||
vm.eval("document.body.innerHTML='<iframe></iframe>'")
|
||||
.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",
|
||||
"<!doctype html><body><iframe></iframe>",
|
||||
);
|
||||
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::<v8::Object>::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");
|
||||
}
|
||||
+233
@@ -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);
|
||||
})()
|
||||
Reference in New Issue
Block a user