Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

feat(webrtc): implement RTCIceCandidate construction and serialization

ldm023ef197b600f
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 79fbaee75..a36ade629 100644
--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs
+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs
@@ -55,7 +55,7 @@ use super::super::{
build_audio_context_constructor_template, build_audio_worklet_node_constructor_template,
offline_audio_context_constructor_callback,
},
- webrtc::rtc_peer_connection_constructor_callback,
+ webrtc::{rtc_ice_candidate_constructor_callback, rtc_peer_connection_constructor_callback},
websocket::{
websocket_constructor_callback, websocket_error_constructor_callback,
websocket_stream_constructor_callback,
@@ -434,6 +434,11 @@ pub(in crate::context_bootstrap) fn build_constructor_template<'s>(
.length(0)
.build(scope)
}
+ ConstructorKind::RtcIceCandidate => {
+ v8::FunctionTemplate::builder(rtc_ice_candidate_constructor_callback)
+ .length(0)
+ .build(scope)
+ }
ConstructorKind::Navigator
| ConstructorKind::WorkerNavigator
| ConstructorKind::Permissions
diff --git a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs b/moli-renderer-v8/src/context_bootstrap/runtime_state.rs
index 202c30a2f..94f7fd9ea 100644
--- a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs
+++ b/moli-renderer-v8/src/context_bootstrap/runtime_state.rs
@@ -1826,6 +1826,7 @@ pub(crate) fn finish_context_bootstrap(
("WebSocketError", "WebSocketError"),
("WebSocketStream", "WebSocketStream"),
("RTCPeerConnection", "RTCPeerConnection"),
+ ("RTCIceCandidate", "RTCIceCandidate"),
("RTCRtpReceiver", "RTCRtpReceiver"),
("RTCDataChannel", "RTCDataChannel"),
("Blob", "Blob"),
diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
index f250f9b37..0051955b1 100644
--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs
@@ -1026,6 +1026,11 @@ const CONSTRUCTOR_SPECS_AFTER_STREAMS: &[ConstructorSpec] = &[
parent: Some("EventTarget"),
kind: ConstructorKind::RtcPeerConnection,
},
+ ConstructorSpec {
+ name: "RTCIceCandidate",
+ parent: None,
+ kind: ConstructorKind::RtcIceCandidate,
+ },
ConstructorSpec {
name: "RTCRtpReceiver",
parent: None,
diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rs
index c64dc4ee0..ef48b7be3 100644
--- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs
+++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs
@@ -86,6 +86,7 @@ pub(in crate::context_bootstrap) enum ConstructorKind {
SharedWorker,
WebSocket,
RtcPeerConnection,
+ RtcIceCandidate,
Navigator,
WorkerNavigator,
Permissions,
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc.rs b/moli-renderer-v8/src/context_bootstrap/webrtc.rs
index a36b470ba..7ef0a632c 100644
--- a/moli-renderer-v8/src/context_bootstrap/webrtc.rs
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc.rs
@@ -4,6 +4,10 @@ use crate::util::{
};
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
+mod ice_candidate;
+mod ice_candidate_parser;
+pub(in crate::context_bootstrap) use ice_candidate::rtc_ice_candidate_constructor_callback;
+
const RTC_PEER_CONNECTION_BRAND_SLOT: &str = "__moliRtcPeerConnectionBrand";
const RTC_PEER_CONNECTION_CONFIGURATION_SLOT: &str = "__moliRtcPeerConnectionConfiguration";
const RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT: &str = "__moliRtcPeerConnectionSignalingState";
@@ -202,6 +206,9 @@ pub(in crate::context_bootstrap) fn install_webrtc_template_bindings<'s>(
) {
let prototype = template.prototype_template(scope);
match interface_name {
+ "RTCIceCandidate" => {
+ ice_candidate::install_ice_candidate_template_bindings(scope, template)
+ }
"RTCPeerConnection" => {
RtcPeerConnectionPrototypeDeclaration::initialize_prototype_template(scope, prototype);
}
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs
new file mode 100644
index 000000000..d4d545e9a
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate.rs
@@ -0,0 +1,256 @@
+use super::ice_candidate_parser::parse_ice_candidate;
+use crate::{
+ util::{
+ apply_webidl_constructor_prototype_fallback, callback_data_index_value, get_private_value,
+ throw_type_error, v8str,
+ },
+ webidl::{self, WebIdlConverter},
+};
+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
+
+const CANDIDATE_VALUES_SLOT: &str = "__moliRtcIceCandidateValues";
+
+#[derive(WebApiObject)]
+#[webapi(interface = "RTCIceCandidate")]
+struct IceCandidateObjectDeclaration<'scope> {
+ #[webapi(slot = CANDIDATE_VALUES_SLOT)]
+ values: v8::Local<'scope, v8::Array>,
+}
+
+#[derive(WebApiFunctionTemplate)]
+#[webapi(name = "RTCIceCandidate", enumerable)]
+struct IceCandidatePrototypeDeclaration {
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 0))]
+ candidate: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 1))]
+ sdp_mid: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 2))]
+ sdp_m_line_index: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 3))]
+ foundation: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 4))]
+ component: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 5))]
+ priority: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 6))]
+ address: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 7))]
+ protocol: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 8))]
+ port: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 9))]
+ r#type: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 10))]
+ tcp_type: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 11))]
+ related_address: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 12))]
+ related_port: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 13))]
+ username_fragment: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 14))]
+ relay_protocol: (),
+ #[webapi(accessor_property, getter = candidate_attribute_getter, data = callback_data_index_value(scope, 15))]
+ url: (),
+ #[webapi(method = "toJSON", length = 0, callback = candidate_to_json_callback)]
+ to_json: (),
+}
+
+#[derive(WebApiObject)]
+#[webapi(interface = "Object", data_properties, enumerable)]
+struct IceCandidateJsonDeclaration<'scope> {
+ candidate: v8::Local<'scope, v8::Value>,
+ sdp_mid: v8::Local<'scope, v8::Value>,
+ sdp_m_line_index: v8::Local<'scope, v8::Value>,
+ username_fragment: v8::Local<'scope, v8::Value>,
+}
+
+pub(super) fn install_ice_candidate_template_bindings<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ template: v8::Local<'s, v8::FunctionTemplate>,
+) {
+ IceCandidatePrototypeDeclaration::initialize_prototype_template(
+ scope,
+ template.prototype_template(scope),
+ );
+}
+
+pub(in crate::context_bootstrap) fn rtc_ice_candidate_constructor_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s, v8::Value>,
+) {
+ if !args.is_construct_call() {
+ throw_type_error(scope, "RTCIceCandidate constructor requires 'new'.");
+ return;
+ }
+ let dictionary = match webidl::dictionary_value(
+ args.get(0),
+ webidl::Context::argument("RTCIceCandidate", 1),
+ ) {
+ Ok(dictionary) => dictionary,
+ Err(error) => {
+ webidl::throw_error(scope, &error);
+ return;
+ }
+ };
+ let Some(mut values) = parse_candidate_init(scope, dictionary) else {
+ return;
+ };
+ if values[1].is_null() && values[2].is_null() {
+ throw_type_error(scope, "RTCIceCandidate requires sdpMid or sdpMLineIndex.");
+ return;
+ }
+ let candidate =
+ v8::Local::<v8::String>::try_from(values[0]).expect("converted candidate string");
+ let candidate = candidate.to_rust_string_lossy(scope);
+ if let Some(parsed) = parse_ice_candidate(&candidate) {
+ values[3] = v8::String::new(scope, parsed.foundation).unwrap().into();
+ values[4] = v8str(scope, parsed.component).into();
+ values[5] = v8::Integer::new_from_unsigned(scope, parsed.priority).into();
+ values[6] = v8::String::new(scope, parsed.address).unwrap().into();
+ values[7] = v8str(scope, parsed.protocol).into();
+ values[8] = v8::Integer::new_from_unsigned(scope, parsed.port.into()).into();
+ values[9] = v8str(scope, parsed.kind).into();
+ if let Some(tcp_type) = parsed.tcp_type {
+ values[10] = v8str(scope, tcp_type).into();
+ }
+ if let Some(address) = parsed.related_address {
+ values[11] = v8::String::new(scope, address).unwrap().into();
+ }
+ if let Some(port) = parsed.related_port {
+ values[12] = v8::Integer::new_from_unsigned(scope, port.into()).into();
+ }
+ }
+ let values = v8::Array::new_with_elements(scope, &values);
+ if IceCandidateObjectDeclaration::new(values)
+ .initialize(scope, args.this())
+ .is_err()
+ {
+ return;
+ }
+ apply_webidl_constructor_prototype_fallback(
+ scope,
+ args.this(),
+ args.new_target(),
+ "RTCIceCandidate",
+ );
+ rv.set(args.this().into());
+}
+
+fn parse_candidate_init<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ dictionary: Option<v8::Local<'s, v8::Object>>,
+) -> Option<[v8::Local<'s, v8::Value>; 16]> {
+ let mut values = [v8::null(scope).into(); 16];
+ values[0] = v8str(scope, "").into();
+ let Some(dictionary) = dictionary else {
+ return Some(values);
+ };
+ // Convert base dictionary members in lexical order before derived members.
+ // Keep DOMStrings in V8, preserving lone UTF-16 surrogates; only `url` is a USVString.
+ for (name, index) in [
+ ("candidate", 0),
+ ("sdpMLineIndex", 2),
+ ("sdpMid", 1),
+ ("usernameFragment", 13),
+ ("relayProtocol", 14),
+ ("url", 15),
+ ] {
+ let raw = dictionary.get(scope, v8str(scope, name).into())?;
+ if raw.is_undefined() || (index != 0 && raw.is_null()) {
+ continue;
+ }
+ let context = webidl::Context::member("RTCLocalIceCandidateInit", name);
+ if index == 2 {
+ let value = match webidl::UnsignedShort::convert(scope, raw, context, &()) {
+ Ok(value) => value.0,
+ Err(error) => {
+ webidl::throw_error(scope, &error);
+ return None;
+ }
+ };
+ values[index] = v8::Integer::new_from_unsigned(scope, value.into()).into();
+ } else if index == 15 {
+ let value = match webidl::UsvString::convert(scope, raw, context, &Default::default()) {
+ Ok(value) => value.0,
+ Err(error) => {
+ webidl::throw_error(scope, &error);
+ return None;
+ }
+ };
+ values[index] = v8::String::new(scope, &value)?.into();
+ } else {
+ if raw.is_symbol() {
+ throw_type_error(scope, "Cannot convert a Symbol to a DOMString.");
+ return None;
+ }
+ let value = raw.to_string(scope)?;
+ if index == 14
+ && !matches!(
+ value.to_rust_string_lossy(scope).as_str(),
+ "udp" | "tcp" | "tls"
+ )
+ {
+ throw_type_error(scope, "Invalid RTCIceServerTransportProtocol.");
+ return None;
+ }
+ values[index] = value.into();
+ }
+ }
+ Some(values)
+}
+
+fn candidate_values<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+) -> Option<v8::Local<'s, v8::Array>> {
+ let values = get_private_value(scope, receiver, CANDIDATE_VALUES_SLOT)
+ .and_then(|value| v8::Local::<v8::Array>::try_from(value).ok());
+ if values.is_none() {
+ throw_type_error(scope, "Illegal invocation");
+ }
+ values
+}
+
+fn candidate_attribute_getter<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s, v8::Value>,
+) {
+ let Some(values) = candidate_values(scope, args.this()) else {
+ return;
+ };
+ let Some(index) = args.data().uint32_value(scope) else {
+ return;
+ };
+ if let Some(value) = values.get_index(scope, index) {
+ rv.set(value);
+ }
+}
+
+fn candidate_to_json_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s, v8::Value>,
+) {
+ let Some(values) = candidate_values(scope, args.this()) else {
+ return;
+ };
+ let Some(candidate) = values.get_index(scope, 0) else {
+ return;
+ };
+ let Some(mid) = values.get_index(scope, 1) else {
+ return;
+ };
+ let Some(line) = values.get_index(scope, 2) else {
+ return;
+ };
+ let Some(fragment) = values.get_index(scope, 13) else {
+ return;
+ };
+ if let Ok(result) = IceCandidateJsonDeclaration::new(candidate, mid, line, fragment).bind(scope)
+ {
+ rv.set(result.into());
+ }
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate_parser.rs b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate_parser.rs
new file mode 100644
index 000000000..fe68ce9f3
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/webrtc/ice_candidate_parser.rs
@@ -0,0 +1,181 @@
+use std::net::IpAddr;
+
+#[derive(Debug, PartialEq)]
+pub(super) struct ParsedIceCandidate<'a> {
+ pub(super) foundation: &'a str,
+ pub(super) component: &'static str,
+ pub(super) priority: u32,
+ pub(super) address: &'a str,
+ pub(super) protocol: &'static str,
+ pub(super) port: u16,
+ pub(super) kind: &'static str,
+ pub(super) tcp_type: Option<&'static str>,
+ pub(super) related_address: Option<&'a str>,
+ pub(super) related_port: Option<u16>,
+}
+
+// RFC 5245 section 15.1 and the TCP extension in RFC 6544 section 4.5.
+// Return no derived fields if parsing or an attribute's value is invalid;
+// RTCIceCandidate itself still retains the original candidate string.
+pub(super) fn parse_ice_candidate(input: &str) -> Option<ParsedIceCandidate<'_>> {
+ let fields: Vec<_> = input.strip_prefix("candidate:")?.split(' ').collect();
+ if fields.len() < 8 || fields.iter().any(|field| field.is_empty()) {
+ return None;
+ }
+ let foundation = fields[0];
+ if foundation.len() > 32
+ || !foundation
+ .bytes()
+ .all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, b'+' | b'/'))
+ {
+ return None;
+ }
+ let component = match decimal(fields[1], 5)? {
+ 1 => "rtp",
+ 2 => "rtcp",
+ _ => return None,
+ };
+ let protocol = if fields[2].eq_ignore_ascii_case("udp") {
+ "udp"
+ } else if fields[2].eq_ignore_ascii_case("tcp") {
+ "tcp"
+ } else {
+ return None;
+ };
+ let priority = decimal(fields[3], 10)?;
+ if !(1..=i32::MAX as u32).contains(&priority) || !address_is_valid(fields[4]) {
+ return None;
+ }
+ let port = u16::try_from(decimal(fields[5], usize::MAX)?).ok()?;
+ if !fields[6].eq_ignore_ascii_case("typ") {
+ return None;
+ }
+ let kind = ["host", "srflx", "prflx", "relay"]
+ .into_iter()
+ .find(|kind| fields[7].eq_ignore_ascii_case(kind))?;
+ let mut candidate = ParsedIceCandidate {
+ foundation,
+ component,
+ priority,
+ address: fields[4],
+ protocol,
+ port,
+ kind,
+ tcp_type: None,
+ related_address: None,
+ related_port: None,
+ };
+ let extensions = fields[8..].chunks_exact(2);
+ if !extensions.remainder().is_empty() {
+ return None;
+ }
+ for pair in extensions {
+ if pair
+ .iter()
+ .any(|field| field.bytes().any(|ch| ch.is_ascii_control()))
+ {
+ return None;
+ }
+ if pair[0].eq_ignore_ascii_case("raddr") {
+ if !address_is_valid(pair[1]) || candidate.related_address.replace(pair[1]).is_some() {
+ return None;
+ }
+ } else if pair[0].eq_ignore_ascii_case("rport") {
+ let port = u16::try_from(decimal(pair[1], usize::MAX)?).ok()?;
+ if candidate.related_port.replace(port).is_some() {
+ return None;
+ }
+ } else if pair[0].eq_ignore_ascii_case("tcptype") && protocol == "tcp" {
+ let tcp_type = ["active", "passive", "so"]
+ .into_iter()
+ .find(|kind| pair[1].eq_ignore_ascii_case(kind))?;
+ if candidate.tcp_type.replace(tcp_type).is_some() {
+ return None;
+ }
+ }
+ }
+ if protocol == "tcp" && candidate.tcp_type.is_none() {
+ return None;
+ }
+ Some(candidate)
+}
+
+fn decimal(input: &str, max_digits: usize) -> Option<u32> {
+ if input.is_empty() || input.len() > max_digits || !input.bytes().all(|ch| ch.is_ascii_digit())
+ {
+ return None;
+ }
+ input.parse().ok()
+}
+
+fn address_is_valid(input: &str) -> bool {
+ if input.parse::<IpAddr>().is_ok() {
+ return true;
+ }
+ let hostname = input.strip_suffix('.').unwrap_or(input);
+ !hostname.is_empty()
+ && hostname.len() <= 253
+ && hostname.split('.').all(|label| {
+ !label.is_empty()
+ && label.len() <= 63
+ && label.as_bytes()[0].is_ascii_alphanumeric()
+ && label.as_bytes()[label.len() - 1].is_ascii_alphanumeric()
+ && label
+ .bytes()
+ .all(|ch| ch.is_ascii_alphanumeric() || ch == b'-')
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn ice_candidate_parser_handles_udp_tcp_ipv6_and_mdns() {
+ let udp = parse_ice_candidate(
+ "candidate:ab+/12 1 UDP 2113937151 2001:db8::1 65535 typ host generation 0 ufrag test",
+ )
+ .unwrap();
+ assert_eq!(udp.foundation, "ab+/12");
+ assert_eq!(udp.component, "rtp");
+ assert_eq!(udp.protocol, "udp");
+ assert_eq!(udp.priority, 2113937151);
+ assert_eq!(udp.address, "2001:db8::1");
+ assert_eq!(udp.port, 65535);
+ assert_eq!(udp.tcp_type, None);
+ let tcp = parse_ice_candidate("candidate:123 2 tcp 123456 foo.local 9 typ srflx raddr www.example.com rport 22222 tcptype active").unwrap();
+ assert_eq!(tcp.component, "rtcp");
+ assert_eq!(tcp.tcp_type, Some("active"));
+ assert_eq!(tcp.related_address, Some("www.example.com"));
+ assert_eq!(tcp.related_port, Some(22222));
+ }
+
+ #[test]
+ fn ice_candidate_parser_rejects_invalid_fields_without_partial_results() {
+ for invalid in [
+ "",
+ "arbitrary candidate",
+ "candidate:",
+ "candidate:a 1 udp 0 127.0.0.1 9 typ host",
+ "candidate:a 1 udp 2147483648 127.0.0.1 9 typ host",
+ "candidate:a 1 udp 1 127.0.0.1 65536 typ host",
+ "candidate:a 1 udp 1 127.0.0.1 -1 typ host",
+ "candidate:a 3 udp 1 127.0.0.1 9 typ host",
+ "candidate:a 1 sctp 1 127.0.0.1 9 typ host",
+ "candidate:a 1 udp 1 127.0.0.1 9 typ unknown",
+ "candidate:a 1 udp 1 [::1] 9 typ host",
+ "candidate:a 1 udp 1 -invalid.local 9 typ host",
+ "candidate:a 1 tcp 1 127.0.0.1 9 typ host",
+ "candidate:a 1 tcp 1 127.0.0.1 9 typ host tcptype unknown",
+ "candidate:a 1 udp 1 127.0.0.1 9 typ host rport 65536",
+ "candidate:a 1 udp 1 127.0.0.1 9 typ host generation",
+ "candidate:a 1 udp 1 127.0.0.1 9 typ host\r\n",
+ "candidate:a 1 udp 1 127.0.0.1 9 typ host x y\n",
+ ] {
+ assert!(
+ parse_ice_candidate(invalid).is_none(),
+ "accepted {invalid:?}"
+ );
+ }
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/ice_candidate.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/ice_candidate.rs
new file mode 100644
index 000000000..558816423
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/ice_candidate.rs
@@ -0,0 +1,131 @@
+use super::*;
+
+#[test]
+fn rtc_ice_candidate_has_branded_readonly_attributes_and_four_json_members() {
+ let mut vm = new_storage_test_vm("https://ice-candidate.test/");
+ let result = vm.eval(r#"
+ (() => {
+ const candidate = new RTCIceCandidate({sdpMid: 'audio', relayProtocol: 'tls', url: 'turn:example.com'});
+ const names = ['candidate', 'sdpMid', 'sdpMLineIndex', 'foundation', 'component',
+ 'priority', 'address', 'protocol', 'port', 'type', 'tcpType', 'relatedAddress',
+ 'relatedPort', 'usernameFragment', 'relayProtocol', 'url'];
+ const rejects = callback => {
+ try { callback(); return false; } catch (error) { return error instanceof TypeError; }
+ };
+ const checks = [
+ RTCIceCandidate.length === 0, candidate instanceof RTCIceCandidate,
+ Object.prototype.toString.call(candidate) === '[object RTCIceCandidate]',
+ Object.getOwnPropertyNames(candidate).length === 0,
+ candidate.toJSON.length === 0,
+ rejects(() => RTCIceCandidate({sdpMid: 'audio'})),
+ rejects(() => new RTCIceCandidate()), rejects(() => new RTCIceCandidate(null)),
+ rejects(() => new RTCIceCandidate({})), rejects(() => new RTCIceCandidate(true)),
+ rejects(() => candidate.toJSON.call(Object.create(candidate)))
+ ];
+ for (const name of names) {
+ const descriptor = Object.getOwnPropertyDescriptor(RTCIceCandidate.prototype, name);
+ if (!descriptor) return 'missing:' + name;
+ checks.push(descriptor.get.name === 'get ' + name, descriptor.get.length === 0,
+ descriptor.set === undefined, descriptor.enumerable, descriptor.configurable);
+ const value = candidate[name];
+ candidate[name] = 'changed';
+ checks.push(candidate[name] === value, rejects(() => { 'use strict'; candidate[name] = 'changed'; }));
+ for (const fake of [{}, RTCIceCandidate.prototype, Object.create(candidate)]) {
+ checks.push(rejects(() => descriptor.get.call(fake)));
+ }
+ }
+ const first = candidate.toJSON();
+ const second = candidate.toJSON();
+ checks.push(first !== second, JSON.stringify(first) ===
+ '{"candidate":"","sdpMid":"audio","sdpMLineIndex":null,"usernameFragment":null}');
+ const cloned = new RTCIceCandidate(candidate);
+ const signaled = new RTCIceCandidate(first);
+ checks.push(cloned.relayProtocol === 'tls', cloned.url === 'turn:example.com',
+ signaled.relayProtocol === null, signaled.url === null);
+ return checks.every(Boolean);
+ })()
+ "#).expect("RTCIceCandidate should expose the WebIDL surface without mutable own attributes");
+ assert_eq!(result, "true");
+}
+
+#[test]
+fn rtc_ice_candidate_converts_dictionary_members_in_order_and_preserves_dom_strings() {
+ let mut vm = new_storage_test_vm("https://ice-candidate-conversion.test/");
+ let result = vm.eval(r#"
+ (() => {
+ const reads = [];
+ const raw = {
+ candidate: '\ud800', sdpMid: '\udc00', sdpMLineIndex: -1.9,
+ usernameFragment: '\ud800', relayProtocol: 'udp', url: 'turn:\ud800'
+ };
+ const candidate = new RTCIceCandidate(new Proxy(raw, {
+ get(target, name) { reads.push(name); return target[name]; }
+ }));
+ const checks = [
+ reads.join(',') === 'candidate,sdpMLineIndex,sdpMid,usernameFragment,relayProtocol,url',
+ candidate.candidate === raw.candidate, candidate.sdpMid === raw.sdpMid,
+ candidate.usernameFragment === raw.usernameFragment,
+ candidate.sdpMLineIndex === 65535, candidate.url === 'turn:\ufffd',
+ new RTCIceCandidate({sdpMLineIndex: 65536}).sdpMLineIndex === 0,
+ new RTCIceCandidate({sdpMLineIndex: Infinity}).sdpMLineIndex === 0,
+ new RTCIceCandidate({candidate: null, sdpMid: false}).candidate === 'null',
+ new RTCIceCandidate({sdpMid: false}).sdpMid === 'false'
+ ];
+ for (const bad of [{candidate: Symbol()}, {sdpMid: Symbol()}, {sdpMLineIndex: 1n},
+ {sdpMLineIndex: Symbol()}, {usernameFragment: Symbol()}, {relayProtocol: 'UDP'}, {url: Symbol()}]) {
+ try { new RTCIceCandidate({sdpMid: 'audio', ...bad}); checks.push(false); }
+ catch (error) { checks.push(error instanceof TypeError); }
+ }
+ const error = new RangeError('conversion');
+ try { new RTCIceCandidate({candidate: {toString() { throw error; }}, sdpMid: 'audio'}); checks.push(false); }
+ catch (caught) { checks.push(caught === error); }
+ return checks.every(Boolean);
+ })()
+ "#).expect("ICE dictionary conversions should preserve WebIDL ordering and original exceptions");
+ assert_eq!(result, "true");
+}
+
+#[test]
+fn rtc_ice_candidate_invalid_strings_preserve_raw_input_without_partial_parsing() {
+ let mut vm = new_storage_test_vm("https://ice-candidate-parsing.test/");
+ let result = vm.eval(r#"
+ (() => {
+ const derived = ['foundation', 'component', 'priority', 'address', 'protocol',
+ 'port', 'type', 'tcpType', 'relatedAddress', 'relatedPort'];
+ return ['', 'arbitrary string', 'candidate:x 1 udp 1 127.0.0.1 65536 typ host',
+ 'candidate:x 1 udp 1 127.0.0.1 9 typ host rport 65536'].every(raw => {
+ const candidate = new RTCIceCandidate({candidate: raw, sdpMid: 'video', usernameFragment: 'keep'});
+ return candidate.candidate === raw && candidate.usernameFragment === 'keep' &&
+ derived.every(name => candidate[name] === null);
+ });
+ })()
+ "#).expect("invalid candidate text should not throw or expose partial derived attributes");
+ assert_eq!(result, "true");
+}
+
+#[test]
+fn rtc_ice_candidate_respects_new_target_and_accepts_genuine_foreign_receivers() {
+ let mut vm = new_parsed_test_vm(
+ "https://ice-candidate-realms.test/",
+ "<!doctype html><iframe></iframe>",
+ );
+ let result = vm.eval(r#"
+ (() => {
+ const child = document.querySelector('iframe').contentWindow;
+ class Derived extends RTCIceCandidate {}
+ const derived = new Derived({sdpMid: 'audio'});
+ const foreign = new child.RTCIceCandidate({sdpMid: 'foreign'});
+ const newTarget = child.Function('');
+ newTarget.prototype = 1;
+ const fallback = Reflect.construct(RTCIceCandidate, [{sdpMid: 'fallback'}], newTarget);
+ return [
+ derived instanceof Derived, derived instanceof RTCIceCandidate,
+ Object.getPrototypeOf(foreign) === child.RTCIceCandidate.prototype,
+ Object.getPrototypeOf(fallback) === child.RTCIceCandidate.prototype,
+ Object.getOwnPropertyDescriptor(RTCIceCandidate.prototype, 'sdpMid').get.call(foreign) === 'foreign',
+ RTCIceCandidate.prototype.toJSON.call(foreign).sdpMid === 'foreign'
+ ].every(Boolean);
+ })()
+ "#).expect("ICE constructors should retain subclass and relevant NewTarget prototypes");
+ assert_eq!(result, "true");
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
index 406769769..7497604d6 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs
@@ -13,6 +13,7 @@ mod crypto_subtle_x25519;
mod details;
mod event_handlers;
mod events_selection_storage;
+mod ice_candidate;
mod idle_callbacks;
mod idle_detection;
mod images;
diff --git a/moli-renderer-v8/src/util.rs b/moli-renderer-v8/src/util.rs
index 63b7cf7de..64428f391 100644
--- a/moli-renderer-v8/src/util.rs
+++ b/moli-renderer-v8/src/util.rs
@@ -116,6 +116,58 @@ pub(crate) fn callable_relevant_context<'s>(
.get_creation_context(scope)
}
+pub(crate) fn new_target_realm_constructor_prototype<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ new_target: v8::Local<'s, v8::Value>,
+ constructor_name: &str,
+) -> Option<v8::Local<'s, v8::Object>> {
+ let context = callable_relevant_context(scope, new_target)?;
+ let prototype = {
+ let context_scope = &mut v8::ContextScope::new(scope, context);
+ let prototype = global_constructor_prototype(context_scope, constructor_name)?;
+ v8::Global::new(context_scope, prototype)
+ };
+ Some(v8::Local::new(scope, &prototype))
+}
+
+pub(crate) fn receiver_uses_new_target_realm_object_fallback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+ new_target: v8::Local<'s, v8::Value>,
+) -> bool {
+ let Some(receiver_prototype) = receiver.get_prototype(scope) else {
+ return false;
+ };
+ let Some(object_prototype) =
+ new_target_realm_constructor_prototype(scope, new_target, "Object")
+ else {
+ return false;
+ };
+ receiver_prototype.strict_equals(object_prototype.into())
+}
+
+pub(crate) fn apply_webidl_constructor_prototype_fallback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+ new_target: v8::Local<'s, v8::Value>,
+ default_constructor_name: &str,
+) {
+ // V8 has already read `NewTarget.prototype` while preparing the native
+ // constructor receiver. Do not read it again: a Proxy getter must run only
+ // once. V8 represents a non-object result with NewTarget's realm-local
+ // Object prototype, which lets us replace precisely that fallback with
+ // the WebIDL interface's default prototype from the same realm.
+ if !receiver_uses_new_target_realm_object_fallback(scope, receiver, new_target) {
+ return;
+ }
+ let Some(prototype) =
+ new_target_realm_constructor_prototype(scope, new_target, default_constructor_name)
+ else {
+ return;
+ };
+ let _ = receiver.set_prototype(scope, prototype.into());
+}
+
pub(crate) fn define_v8_array_data_properties<'s, I, T>(
scope: &mut v8::PinScope<'s, '_>,
array: v8::Local<'s, v8::Array>,