mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
feat(webrtc): add native RTP transceiver frontend
This commit is contained in:
@@ -286,6 +286,8 @@ mod web_audio_runtime;
|
||||
mod web_storage;
|
||||
mod webassembly_runtime;
|
||||
pub(crate) mod rtc_certificate;
|
||||
mod rtc_rtp;
|
||||
pub(crate) use rtc_rtp::rtp_transceivers::apply_task as apply_webrtc_task;
|
||||
mod websocket;
|
||||
mod window_accessors;
|
||||
pub(crate) use window_accessors::{
|
||||
|
||||
@@ -584,6 +584,7 @@ pub(super) fn install_constructor_template_bindings<'s>(
|
||||
install_view_transition_template_bindings(scope, template, spec.interface.name());
|
||||
install_web_audio_template_bindings(scope, template, spec.interface.name());
|
||||
install_webrtc_template_bindings(scope, template, spec.interface.name());
|
||||
super::super::rtc_rtp::install(scope, template, spec.interface.name());
|
||||
match spec.interface.name() {
|
||||
"RTCPeerConnection" => super::super::rtc_certificate::install_static(scope, template),
|
||||
"RTCCertificate" => {
|
||||
|
||||
@@ -220,6 +220,7 @@ fn install_event_runtime(scope: &mut v8::PinScope<'_, '_>) {
|
||||
);
|
||||
crate::context_bootstrap::web_audio_runtime::install_audio_runtime(scope);
|
||||
crate::context_bootstrap::rtc_certificate::install_runtime(scope);
|
||||
crate::context_bootstrap::rtc_rtp::install_runtime(scope);
|
||||
moli_webapi::events::install_runtime(
|
||||
scope,
|
||||
moli_webapi::events::EventRuntime {
|
||||
|
||||
@@ -513,6 +513,65 @@ fn new_track<'s>(
|
||||
Some(object)
|
||||
}
|
||||
|
||||
/// The receiver's remote source exists before negotiation but supplies no
|
||||
/// samples yet. This is a real muted track, independent of capture devices.
|
||||
pub(super) fn new_remote_track<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
kind: &str,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let source = v8::Object::new(scope);
|
||||
set_private_value(
|
||||
scope,
|
||||
source,
|
||||
KIND,
|
||||
crate::util::v8_string(scope, kind)
|
||||
.expect("media kind")
|
||||
.into(),
|
||||
);
|
||||
set_private_value(
|
||||
scope,
|
||||
source,
|
||||
LABEL,
|
||||
crate::util::v8_string(scope, &format!("remote {kind}"))?.into(),
|
||||
);
|
||||
set_private_value(scope, source, MUTED, v8::Boolean::new(scope, true).into());
|
||||
new_track(scope, source, true, v8str(scope, "live").into())
|
||||
}
|
||||
|
||||
pub(super) fn track_kind<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
track: v8::Local<'s, v8::Object>,
|
||||
) -> String {
|
||||
source_value(scope, track, KIND).to_rust_string_lossy(scope)
|
||||
}
|
||||
|
||||
pub(super) fn stream_id<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
stream: v8::Local<'s, v8::Object>,
|
||||
) -> v8::Local<'s, v8::String> {
|
||||
let stream = target(scope, stream);
|
||||
v8::Local::<v8::String>::try_from(
|
||||
get_private_value(scope, stream, ID).expect("native stream id"),
|
||||
)
|
||||
.expect("stream id string")
|
||||
}
|
||||
|
||||
/// The UA's queued ended steps differ from the author's synchronous stop().
|
||||
pub(super) fn end_track<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
track: v8::Local<'s, v8::Object>,
|
||||
) -> bool {
|
||||
let track = target(scope, track);
|
||||
if get_private_value(scope, track, READY_STATE)
|
||||
.expect("track state")
|
||||
.strict_equals(v8str(scope, "ended").into())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
set_private_value(scope, track, READY_STATE, v8str(scope, "ended").into());
|
||||
true
|
||||
}
|
||||
|
||||
fn clone_track<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
track: v8::Local<'s, v8::Object>,
|
||||
|
||||
@@ -0,0 +1,40 @@
|
||||
//! Host-owned RTP objects and WebRTC tasks.
|
||||
|
||||
use moli_webapi::rtc::peer_connection::{
|
||||
RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT, rtp_capabilities,
|
||||
};
|
||||
|
||||
mod rtp_offer;
|
||||
mod rtp_parameters;
|
||||
pub(crate) mod rtp_transceivers;
|
||||
|
||||
pub(super) fn install<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_, ()>,
|
||||
template: v8::Local<'s, v8::FunctionTemplate>,
|
||||
interface: &str,
|
||||
) {
|
||||
let prototype = template.prototype_template(scope);
|
||||
rtp_transceivers::install(scope, prototype, interface);
|
||||
}
|
||||
|
||||
pub(super) fn install_runtime(scope: &mut v8::PinScope<'_, '_>) {
|
||||
moli_webapi::rtc::peer_connection::rtp_transceivers::install_runtime(
|
||||
scope,
|
||||
moli_webapi::rtc::peer_connection::rtp_transceivers::RtpRuntime {
|
||||
initialize_pc: rtp_transceivers::initialize_pc,
|
||||
close: rtp_transceivers::close,
|
||||
create_offer,
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
fn create_offer<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
pc: v8::Local<'s, v8::Object>,
|
||||
data: bool,
|
||||
) -> Option<String> {
|
||||
rtp_transceivers::has_transceivers(scope, pc).then(|| {
|
||||
let sections = rtp_transceivers::offer_sections(scope, pc);
|
||||
rtp_offer::build(§ions, data)
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
//! Adapt the existing signaling-only SDP to local transceiver preferences.
|
||||
//! Payload identities and RTX dependencies come from the compatibility offer;
|
||||
//! this does not allocate ICE/DTLS transports or negotiate a remote description.
|
||||
|
||||
use super::rtp_parameters::Codec;
|
||||
use moli_webapi::rtc::peer_connection::{
|
||||
RTC_AUDIO_OFFER_SECTION, RTC_DATA_OFFER_SECTION, RTC_VIDEO_OFFER_SECTION,
|
||||
};
|
||||
|
||||
struct Format<'a> {
|
||||
payload: &'a str,
|
||||
codec: Codec,
|
||||
lines: Vec<&'a str>,
|
||||
apt: Option<&'a str>,
|
||||
}
|
||||
|
||||
fn formats<'a>(section: &'a str, kind: &str) -> Vec<Format<'a>> {
|
||||
section
|
||||
.lines()
|
||||
.filter_map(|line| {
|
||||
let (payload, encoding) = line.strip_prefix("a=rtpmap:")?.split_once(' ')?;
|
||||
let mut fields = encoding.split('/');
|
||||
let name = fields.next()?;
|
||||
let clock_rate = fields.next()?.parse().ok()?;
|
||||
let channels = if kind == "audio" {
|
||||
Some(fields.next().unwrap_or("1").parse().ok()?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let fmtp_prefix = format!("a=fmtp:{payload} ");
|
||||
let fmtp = section
|
||||
.lines()
|
||||
.find_map(|line| line.strip_prefix(&fmtp_prefix));
|
||||
let apt = fmtp.and_then(|value| value.strip_prefix("apt="));
|
||||
let lines = section
|
||||
.lines()
|
||||
.filter(|line| {
|
||||
line.strip_prefix("a=rtpmap:")
|
||||
.or_else(|| line.strip_prefix("a=fmtp:"))
|
||||
.or_else(|| line.strip_prefix("a=rtcp-fb:"))
|
||||
.is_some_and(|value| {
|
||||
value.split_once(' ').is_some_and(|(pt, _)| pt == payload)
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Some(Format {
|
||||
payload,
|
||||
codec: Codec {
|
||||
mime_type: format!("{kind}/{name}"),
|
||||
clock_rate,
|
||||
channels,
|
||||
sdp_fmtp_line: if apt.is_some() || name.eq_ignore_ascii_case("red") {
|
||||
None
|
||||
} else {
|
||||
fmtp.map(str::to_owned)
|
||||
},
|
||||
},
|
||||
lines,
|
||||
apt,
|
||||
})
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn media_section(kind: &str, direction: &str, codecs: &[Codec], mid: usize) -> String {
|
||||
let template = if kind == "audio" {
|
||||
RTC_AUDIO_OFFER_SECTION
|
||||
} else {
|
||||
RTC_VIDEO_OFFER_SECTION
|
||||
};
|
||||
let formats = formats(template, kind);
|
||||
let mut selected: Vec<&Format<'_>> = Vec::new();
|
||||
for codec in codecs {
|
||||
for format in &formats {
|
||||
if codec.matches(&format.codec)
|
||||
&& !selected
|
||||
.iter()
|
||||
.any(|selected| selected.payload == format.payload)
|
||||
{
|
||||
selected.push(format);
|
||||
}
|
||||
}
|
||||
}
|
||||
// RTX is only meaningful when its referenced primary payload is offered.
|
||||
let primary: Vec<_> = selected
|
||||
.iter()
|
||||
.filter(|format| format.apt.is_none())
|
||||
.map(|format| format.payload)
|
||||
.collect();
|
||||
selected.retain(|format| format.apt.is_none_or(|apt| primary.contains(&apt)));
|
||||
let payloads: Vec<_> = selected.iter().map(|format| format.payload).collect();
|
||||
let mut result = format!(
|
||||
"m={kind} 9 UDP/TLS/RTP/SAVPF {}\r\nc=IN IP4 0.0.0.0\r\na=mid:{mid}\r\na={direction}\r\na=rtcp-mux\r\na=rtcp-rsize\r\n",
|
||||
payloads.join(" ")
|
||||
);
|
||||
for format in selected {
|
||||
for line in &format.lines {
|
||||
result.push_str(line);
|
||||
result.push_str("\r\n");
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
pub(super) fn build(sections: &[(String, String, Vec<Codec>)], data: bool) -> String {
|
||||
let count = sections.len() + usize::from(data);
|
||||
let mids: Vec<_> = (0..count).map(|mid| mid.to_string()).collect();
|
||||
let mut sdp = format!(
|
||||
"v=0\r\no=- 0 2 IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\na=group:BUNDLE {}\r\na=extmap-allow-mixed\r\na=msid-semantic: WMS\r\n",
|
||||
mids.join(" ")
|
||||
);
|
||||
for (mid, (kind, direction, codecs)) in sections.iter().enumerate() {
|
||||
sdp.push_str(&media_section(kind, direction, codecs, mid));
|
||||
}
|
||||
if data {
|
||||
sdp.push_str(
|
||||
&RTC_DATA_OFFER_SECTION.replace("a=mid:2", &format!("a=mid:{}", sections.len())),
|
||||
);
|
||||
}
|
||||
sdp
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn codec_order_filters_payloads_and_rtx_and_uses_unique_mids() {
|
||||
let all = super::super::rtp_parameters::capabilities("video");
|
||||
let h264 = all
|
||||
.iter()
|
||||
.find(|codec| codec.mime_type == "video/H264")
|
||||
.unwrap()
|
||||
.clone();
|
||||
let rtx = all
|
||||
.iter()
|
||||
.find(|codec| codec.mime_type == "video/rtx")
|
||||
.unwrap()
|
||||
.clone();
|
||||
let sdp = build(
|
||||
&[
|
||||
("video".into(), "sendonly".into(), vec![h264.clone(), rtx]),
|
||||
("video".into(), "inactive".into(), vec![h264]),
|
||||
],
|
||||
true,
|
||||
);
|
||||
assert!(sdp.contains("a=group:BUNDLE 0 1 2\r\n"));
|
||||
assert!(sdp.contains("m=video 9 UDP/TLS/RTP/SAVPF 103 104\r\n"));
|
||||
assert!(!sdp.contains("VP8"));
|
||||
assert!(sdp.contains("a=fmtp:104 apt=103\r\n"));
|
||||
assert_eq!(sdp.matches("a=mid:").count(), 3);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
//! Conversion and validation for the local RTP frontend. The capability tables
|
||||
//! describe compatibility; they do not advertise a running media codec backend.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use crate::webidl;
|
||||
|
||||
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, webidl::WebIdlDictionary)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
#[webidl(prefix = "RTCRtpCodec")]
|
||||
pub(super) struct Codec {
|
||||
#[webidl(required)]
|
||||
pub mime_type: String,
|
||||
#[webidl(required)]
|
||||
pub clock_rate: u32,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub channels: Option<u16>,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub sdp_fmtp_line: Option<String>,
|
||||
}
|
||||
|
||||
impl Codec {
|
||||
pub(super) fn matches(&self, other: &Self) -> bool {
|
||||
self.mime_type.eq_ignore_ascii_case(&other.mime_type)
|
||||
&& self.clock_rate == other.clock_rate
|
||||
&& self.channels == other.channels
|
||||
&& match (&self.sdp_fmtp_line, &other.sdp_fmtp_line) {
|
||||
(None, None) => true,
|
||||
(Some(left), Some(right)) => {
|
||||
match (fmtp_parameters(left), fmtp_parameters(right)) {
|
||||
(Some(left), Some(right)) => left == right,
|
||||
_ => left == right,
|
||||
}
|
||||
}
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn is_media(&self) -> bool {
|
||||
!self.mime_type.split('/').nth(1).is_some_and(|name| {
|
||||
["rtx", "red", "ulpfec", "flexfec-03", "cn"]
|
||||
.iter()
|
||||
.any(|auxiliary| name.eq_ignore_ascii_case(auxiliary))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Compare key/value FMTP independent of parameter order and surrounding ASCII
|
||||
// whitespace. Opaque codec-specific lists (e.g. telephone-event) stay exact.
|
||||
// Missing parameters are not invented and asymmetric values are not discarded.
|
||||
fn fmtp_parameters(value: &str) -> Option<BTreeMap<&str, &str>> {
|
||||
let mut parameters = BTreeMap::new();
|
||||
for part in value.split(';') {
|
||||
let (name, value) = part.trim().split_once('=')?;
|
||||
let name = name.trim();
|
||||
if name.is_empty() || parameters.insert(name, value.trim()).is_some() {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
Some(parameters)
|
||||
}
|
||||
|
||||
pub(super) fn capabilities(kind: &str) -> Vec<Codec> {
|
||||
#[derive(serde::Deserialize)]
|
||||
struct Capabilities {
|
||||
codecs: Vec<Codec>,
|
||||
}
|
||||
serde_json::from_str::<Capabilities>(super::rtp_capabilities::capabilities_json(kind))
|
||||
.expect("static RTP capability table")
|
||||
.codecs
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlDictionary)]
|
||||
#[webidl(prefix = "RTCRtpCodingParameters")]
|
||||
pub(super) struct Coding {
|
||||
pub rid: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlDictionary)]
|
||||
#[webidl(prefix = "RTCRtpEncodingParameters")]
|
||||
pub(super) struct Encoding {
|
||||
#[webidl(inherit)]
|
||||
pub coding: Coding,
|
||||
#[webidl(default = true)]
|
||||
pub active: bool,
|
||||
#[webidl(dictionary)]
|
||||
pub codec: Option<Codec>,
|
||||
pub max_bitrate: Option<u32>,
|
||||
#[webidl(converter = "raw")]
|
||||
pub max_framerate: Option<webidl::Double>,
|
||||
#[webidl(converter = "raw")]
|
||||
pub scale_resolution_down_by: Option<webidl::Double>,
|
||||
}
|
||||
|
||||
impl Encoding {
|
||||
pub(super) fn snapshot(&self) -> serde_json::Value {
|
||||
let mut value = serde_json::json!({"active": self.active});
|
||||
for (name, member) in [
|
||||
(
|
||||
"rid",
|
||||
self.coding.rid.as_ref().map(|v| serde_json::json!(v)),
|
||||
),
|
||||
("codec", self.codec.as_ref().map(|v| serde_json::json!(v))),
|
||||
("maxBitrate", self.max_bitrate.map(|v| serde_json::json!(v))),
|
||||
(
|
||||
"maxFramerate",
|
||||
self.max_framerate.as_ref().map(|v| serde_json::json!(v.0)),
|
||||
),
|
||||
(
|
||||
"scaleResolutionDownBy",
|
||||
self.scale_resolution_down_by
|
||||
.as_ref()
|
||||
.map(|v| serde_json::json!(v.0)),
|
||||
),
|
||||
] {
|
||||
if let Some(member) = member {
|
||||
value[name] = member;
|
||||
}
|
||||
}
|
||||
value
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn codec_matching_preserves_parameters_but_ignores_fmtp_order() {
|
||||
let mut left = capabilities("audio")[0].clone();
|
||||
let mut right = left.clone();
|
||||
right.mime_type = "AUDIO/OPUS".into();
|
||||
right.sdp_fmtp_line = Some("useinbandfec=1 ; minptime = 10".into());
|
||||
assert!(left.matches(&right));
|
||||
right.sdp_fmtp_line = Some("useinbandfec=1;minptime=20".into());
|
||||
assert!(!left.matches(&right));
|
||||
left.sdp_fmtp_line = None;
|
||||
assert!(!left.matches(&right));
|
||||
assert_eq!(fmtp_parameters("a=1;a=2"), None);
|
||||
assert_eq!(fmtp_parameters("0-15"), None);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,749 @@
|
||||
//! Local RTP object relationships and offer preferences. Transport creation,
|
||||
//! SDP negotiation, encoding and reception still require a WebRTC backend.
|
||||
|
||||
use super::rtp_parameters::{Codec, Encoding, capabilities};
|
||||
use crate::{
|
||||
context_bootstrap::{events, exposed_interfaces, media_queries, media_streams},
|
||||
native_bridge::throw_dom_exception,
|
||||
page_task_queue::RendererPageWebRtcTaskKind,
|
||||
util::{
|
||||
context_host_ptr_from_global_bridge, get_private_object, get_private_value,
|
||||
set_private_value, throw_range_error, throw_type_error, v8_string, v8str,
|
||||
},
|
||||
web_api_interfaces, webidl,
|
||||
};
|
||||
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
|
||||
|
||||
const TRANSCEIVERS: &str = "__moliRtcTransceivers";
|
||||
const OWNER: &str = "__moliRtpOwner";
|
||||
const SENDER: &str = "__moliRtpSender";
|
||||
const RECEIVER: &str = "__moliRtpReceiver";
|
||||
const TRACK: &str = "__moliRtpTrack";
|
||||
const DIRECTION: &str = "__moliRtpDirection";
|
||||
const CURRENT_DIRECTION: &str = "__moliRtpCurrentDirection";
|
||||
const MID: &str = "__moliRtpMid";
|
||||
const STOPPING: &str = "__moliRtpStopping";
|
||||
const STOPPED: &str = "__moliRtpStopped";
|
||||
const CODECS: &str = "__moliRtpPreferredCodecs";
|
||||
const ENCODINGS: &str = "__moliRtpEncodings";
|
||||
const STREAMS: &str = "__moliRtpAssociatedStreamIds";
|
||||
const NEGOTIATION_TASK: &str = "__moliRtcNegotiationTask";
|
||||
const NEGOTIATION_NEEDED: &str = "__moliRtcNegotiationNeeded";
|
||||
pub(super) use moli_webapi::rtc::peer_connection::rtp_transceivers::NEGOTIATION_HANDLER;
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, webidl::WebIdlEnum)]
|
||||
#[webidl(name = "RTCRtpTransceiverDirection")]
|
||||
enum Direction {
|
||||
#[webidl(token = "sendrecv")]
|
||||
SendRecv,
|
||||
#[webidl(token = "sendonly")]
|
||||
SendOnly,
|
||||
#[webidl(token = "recvonly")]
|
||||
RecvOnly,
|
||||
#[webidl(token = "inactive")]
|
||||
Inactive,
|
||||
#[webidl(token = "stopped")]
|
||||
Stopped,
|
||||
}
|
||||
impl Direction {
|
||||
fn token(self) -> &'static str {
|
||||
match self {
|
||||
Self::SendRecv => "sendrecv",
|
||||
Self::SendOnly => "sendonly",
|
||||
Self::RecvOnly => "recvonly",
|
||||
Self::Inactive => "inactive",
|
||||
Self::Stopped => "stopped",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlDictionary)]
|
||||
#[webidl(prefix = "RTCRtpTransceiverInit")]
|
||||
struct Init<'s> {
|
||||
#[webidl(converter = "enum", default = Direction::SendRecv)]
|
||||
direction: Direction,
|
||||
#[webidl(sequence, converter = "dictionary", default = Vec::new())]
|
||||
send_encodings: Vec<Encoding>,
|
||||
#[webidl(sequence, interface = web_api_interfaces::MediaStream, default = Vec::new())]
|
||||
streams: Vec<v8::Local<'s, v8::Object>>,
|
||||
}
|
||||
enum TrackOrKind<'s> {
|
||||
Track(v8::Local<'s, v8::Object>),
|
||||
Kind(String),
|
||||
}
|
||||
fn track_or_kind<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: &v8::FunctionCallbackArguments<'s>,
|
||||
index: i32,
|
||||
) -> Result<TrackOrKind<'s>, webidl::WebIdlError> {
|
||||
let value = args.get(index);
|
||||
if let Ok(track) = v8::Local::<v8::Object>::try_from(value)
|
||||
&& web_api_interfaces::MediaStreamTrack::is_instance(scope, track)
|
||||
{
|
||||
return Ok(TrackOrKind::Track(track));
|
||||
}
|
||||
webidl::convert::<webidl::DomString>(
|
||||
scope,
|
||||
value,
|
||||
webidl::Context::argument("RTCPeerConnection.addTransceiver", (index + 1) as usize),
|
||||
)
|
||||
.map(|kind| TrackOrKind::Kind(kind.0))
|
||||
}
|
||||
#[derive(webidl::WebIdlArgs)]
|
||||
#[webidl(prefix = "RTCPeerConnection.addTransceiver")]
|
||||
struct AddArgs<'s> {
|
||||
#[webidl(required, with = track_or_kind)]
|
||||
track_or_kind: TrackOrKind<'s>,
|
||||
#[webidl(dictionary)]
|
||||
init: Init<'s>,
|
||||
}
|
||||
#[derive(webidl::WebIdlArgs)]
|
||||
#[webidl(prefix = "RTCRtpTransceiver.direction")]
|
||||
struct DirectionArgs {
|
||||
#[webidl(required)]
|
||||
value: String,
|
||||
}
|
||||
#[derive(webidl::WebIdlArgs)]
|
||||
#[webidl(prefix = "RTCRtpTransceiver.setCodecPreferences")]
|
||||
struct CodecArgs {
|
||||
#[webidl(required, sequence, converter = "dictionary")]
|
||||
codecs: Vec<Codec>,
|
||||
}
|
||||
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(interface = web_api_interfaces::RTCRtpTransceiver)]
|
||||
struct TransceiverSlots<'s> {
|
||||
#[webapi(slot = OWNER)]
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = SENDER)]
|
||||
sender: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = RECEIVER)]
|
||||
receiver: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = DIRECTION)]
|
||||
direction: v8::Local<'s, v8::String>,
|
||||
#[webapi(slot = CURRENT_DIRECTION, init = "null")]
|
||||
current_direction: (),
|
||||
#[webapi(slot = MID, init = "null")]
|
||||
mid: (),
|
||||
#[webapi(slot = STOPPING, init = false)]
|
||||
stopping: (),
|
||||
#[webapi(slot = STOPPED, init = false)]
|
||||
stopped: (),
|
||||
#[webapi(slot = CODECS, init = string("[]"))]
|
||||
codecs: (),
|
||||
}
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(interface = web_api_interfaces::RTCRtpSender)]
|
||||
struct SenderSlots<'s> {
|
||||
#[webapi(slot = TRACK)]
|
||||
track: v8::Local<'s, v8::Value>,
|
||||
#[webapi(slot = ENCODINGS)]
|
||||
encodings: v8::Local<'s, v8::String>,
|
||||
#[webapi(slot = STREAMS)]
|
||||
streams: v8::Local<'s, v8::Array>,
|
||||
}
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(interface = web_api_interfaces::RTCRtpReceiver)]
|
||||
struct ReceiverSlots<'s> {
|
||||
#[webapi(slot = TRACK)]
|
||||
track: v8::Local<'s, v8::Object>,
|
||||
}
|
||||
|
||||
#[derive(WebApiFunctionTemplate)]
|
||||
#[webapi(interface = web_api_interfaces::RTCPeerConnection, enumerable)]
|
||||
struct PeerPrototype {
|
||||
#[webapi(accessor_property, getter = slot_getter, setter = negotiation_handler_setter, data = v8str(scope, NEGOTIATION_HANDLER))]
|
||||
onnegotiationneeded: (),
|
||||
#[webapi(method, length = 1, callback = add_transceiver)]
|
||||
add_transceiver: (),
|
||||
#[webapi(method, length = 0, callback = collect, data = v8str(scope, TRANSCEIVERS))]
|
||||
get_transceivers: (),
|
||||
#[webapi(method, length = 0, callback = collect, data = v8str(scope, SENDER))]
|
||||
get_senders: (),
|
||||
#[webapi(method, length = 0, callback = collect, data = v8str(scope, RECEIVER))]
|
||||
get_receivers: (),
|
||||
}
|
||||
#[derive(WebApiFunctionTemplate)]
|
||||
#[webapi(interface = web_api_interfaces::RTCRtpTransceiver, enumerable)]
|
||||
struct TransceiverPrototype {
|
||||
// Chromium retains this non-standard compatibility attribute. It reflects
|
||||
// stopping, while [[Stopped]] waits for the completed negotiation/close.
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, STOPPING))]
|
||||
stopped: (),
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, MID))]
|
||||
mid: (),
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, SENDER))]
|
||||
sender: (),
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, RECEIVER))]
|
||||
receiver: (),
|
||||
#[webapi(accessor_property, getter = direction_getter, setter = direction_setter)]
|
||||
direction: (),
|
||||
#[webapi(accessor_property, getter = current_direction_getter)]
|
||||
current_direction: (),
|
||||
#[webapi(method, length = 0, callback = stop)]
|
||||
stop: (),
|
||||
#[webapi(method, length = 1, callback = set_codec_preferences)]
|
||||
set_codec_preferences: (),
|
||||
}
|
||||
#[derive(WebApiFunctionTemplate)]
|
||||
#[webapi(interface = web_api_interfaces::RTCRtpSender, enumerable)]
|
||||
struct SenderPrototype {
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, TRACK))]
|
||||
track: (),
|
||||
#[webapi(accessor_property, getter = transport_getter)]
|
||||
transport: (),
|
||||
}
|
||||
#[derive(WebApiFunctionTemplate)]
|
||||
#[webapi(interface = web_api_interfaces::RTCRtpReceiver, enumerable)]
|
||||
struct ReceiverPrototype {
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, TRACK))]
|
||||
track: (),
|
||||
#[webapi(accessor_property, getter = transport_getter)]
|
||||
transport: (),
|
||||
}
|
||||
|
||||
pub(super) fn install<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_, ()>,
|
||||
prototype: v8::Local<'s, v8::ObjectTemplate>,
|
||||
name: &str,
|
||||
) {
|
||||
match name {
|
||||
"RTCPeerConnection" => PeerPrototype::initialize_prototype_template(scope, prototype),
|
||||
"RTCRtpTransceiver" => {
|
||||
TransceiverPrototype::initialize_prototype_template(scope, prototype)
|
||||
}
|
||||
"RTCRtpSender" => SenderPrototype::initialize_prototype_template(scope, prototype),
|
||||
"RTCRtpReceiver" => ReceiverPrototype::initialize_prototype_template(scope, prototype),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
pub(super) fn initialize_pc<'s>(scope: &mut v8::PinScope<'s, '_>, pc: v8::Local<'s, v8::Object>) {
|
||||
let list = v8::Array::new(scope, 0);
|
||||
set_private_value(scope, pc, TRANSCEIVERS, list.into());
|
||||
set_bool(scope, pc, NEGOTIATION_TASK, false);
|
||||
set_bool(scope, pc, NEGOTIATION_NEEDED, false);
|
||||
}
|
||||
pub(super) fn has_transceivers<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
pc: v8::Local<'s, v8::Object>,
|
||||
) -> bool {
|
||||
list(scope, pc).length() != 0
|
||||
}
|
||||
fn target<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
moli_webapi_declare::web_api_object_target(scope, object).expect("validated RTP receiver")
|
||||
}
|
||||
fn flag<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
slot: &str,
|
||||
) -> bool {
|
||||
get_private_value(scope, object, slot)
|
||||
.expect("RTP state slot")
|
||||
.boolean_value(scope)
|
||||
}
|
||||
fn set_bool<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
slot: &str,
|
||||
value: bool,
|
||||
) {
|
||||
set_private_value(scope, object, slot, v8::Boolean::new(scope, value).into());
|
||||
}
|
||||
fn closed<'s>(scope: &mut v8::PinScope<'s, '_>, pc: v8::Local<'s, v8::Object>) -> bool {
|
||||
get_private_value(scope, pc, super::RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT)
|
||||
.expect("PC state")
|
||||
.strict_equals(v8str(scope, "closed").into())
|
||||
}
|
||||
fn invalid_state(scope: &mut v8::PinScope<'_, '_>) {
|
||||
throw_dom_exception(
|
||||
scope,
|
||||
"InvalidStateError",
|
||||
11,
|
||||
"The RTP transceiver or connection is stopped.",
|
||||
);
|
||||
}
|
||||
fn list<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
pc: v8::Local<'s, v8::Object>,
|
||||
) -> v8::Local<'s, v8::Array> {
|
||||
v8::Local::<v8::Array>::try_from(
|
||||
get_private_value(scope, pc, TRANSCEIVERS).expect("transceiver list"),
|
||||
)
|
||||
.expect("native RTP array")
|
||||
}
|
||||
fn entries<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
pc: v8::Local<'s, v8::Object>,
|
||||
) -> Vec<v8::Local<'s, v8::Object>> {
|
||||
let list = list(scope, pc);
|
||||
(0..list.length())
|
||||
.map(|i| {
|
||||
v8::Local::<v8::Object>::try_from(list.get_index(scope, i).expect("RTP list entry"))
|
||||
.expect("native transceiver")
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
fn instance<'s>(scope: &mut v8::PinScope<'s, '_>, name: &str) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let object = exposed_interfaces::build_intrinsic_interface_instance(scope, name).ok()?;
|
||||
let prototype = exposed_interfaces::ensure_intrinsic_interface_prototype(scope, name).ok()?;
|
||||
(object.set_prototype(scope, prototype.into()) == Some(true)).then_some(object)
|
||||
}
|
||||
|
||||
fn validate_encodings(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
kind: &str,
|
||||
encodings: &mut Vec<Encoding>,
|
||||
) -> bool {
|
||||
let rids: Vec<_> = encodings
|
||||
.iter()
|
||||
.filter_map(|e| e.coding.rid.as_ref())
|
||||
.collect();
|
||||
if (!rids.is_empty() && rids.len() != encodings.len())
|
||||
|| rids.iter().any(|rid| {
|
||||
rid.is_empty() || rid.len() > 16 || !rid.bytes().all(|b| b.is_ascii_alphanumeric())
|
||||
})
|
||||
|| rids
|
||||
.iter()
|
||||
.enumerate()
|
||||
.any(|(i, rid)| rids[..i].contains(rid))
|
||||
{
|
||||
throw_type_error(
|
||||
scope,
|
||||
"Encodings require unique, consistently present alphanumeric RIDs of at most 16 characters.",
|
||||
);
|
||||
return false;
|
||||
}
|
||||
let supported = capabilities(kind);
|
||||
for encoding in encodings.iter_mut() {
|
||||
if encoding
|
||||
.codec
|
||||
.as_ref()
|
||||
.is_some_and(|codec| !supported.iter().any(|candidate| codec.matches(candidate)))
|
||||
{
|
||||
throw_dom_exception(
|
||||
scope,
|
||||
"OperationError",
|
||||
0,
|
||||
"The requested encoding codec is unsupported.",
|
||||
);
|
||||
return false;
|
||||
}
|
||||
if encoding.codec.is_some() {
|
||||
throw_dom_exception(
|
||||
scope,
|
||||
"OperationError",
|
||||
0,
|
||||
"Per-encoding codec selection requires a media backend.",
|
||||
);
|
||||
return false;
|
||||
}
|
||||
if kind == "audio" {
|
||||
encoding.max_framerate = None;
|
||||
encoding.scale_resolution_down_by = None;
|
||||
}
|
||||
if encoding.max_framerate.as_ref().is_some_and(|v| v.0 <= 0.0)
|
||||
|| encoding
|
||||
.scale_resolution_down_by
|
||||
.as_ref()
|
||||
.is_some_and(|v| v.0 < 1.0)
|
||||
{
|
||||
throw_range_error(scope, "Invalid video encoding rate or scale.");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// The local frontend retains at most three simulcast encodings. No RTP
|
||||
// encoder is started. Validate every input before applying this limit.
|
||||
let any_scale = encodings
|
||||
.iter()
|
||||
.any(|e| e.scale_resolution_down_by.is_some());
|
||||
encodings.truncate(if kind == "audio" { 1 } else { 3 });
|
||||
let count = encodings.len();
|
||||
for (index, encoding) in encodings.iter_mut().enumerate() {
|
||||
if count == 1 {
|
||||
encoding.coding.rid = None;
|
||||
}
|
||||
if kind == "video" && encoding.scale_resolution_down_by.is_none() {
|
||||
encoding.scale_resolution_down_by = Some(webidl::Double(if any_scale {
|
||||
1.0
|
||||
} else {
|
||||
2_f64.powi((count - index - 1) as i32)
|
||||
}));
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
fn add_transceiver<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let Some(mut parsed) = webidl::parse_args::<AddArgs>(scope, &args) else {
|
||||
return;
|
||||
};
|
||||
let (kind, track) = match parsed.track_or_kind {
|
||||
TrackOrKind::Track(track) => (media_streams::track_kind(scope, track), Some(track)),
|
||||
TrackOrKind::Kind(kind) => (kind, None),
|
||||
};
|
||||
if !matches!(kind.as_str(), "audio" | "video") || parsed.init.direction == Direction::Stopped {
|
||||
throw_type_error(scope, "Invalid transceiver kind or direction.");
|
||||
return;
|
||||
}
|
||||
let pc = target(scope, args.this());
|
||||
if closed(scope, pc) {
|
||||
invalid_state(scope);
|
||||
return;
|
||||
}
|
||||
if !validate_encodings(scope, &kind, &mut parsed.init.send_encodings) {
|
||||
return;
|
||||
}
|
||||
let Some(receiver_track) = media_streams::new_remote_track(scope, &kind) else {
|
||||
return;
|
||||
};
|
||||
let Some(sender) = instance(scope, "RTCRtpSender") else {
|
||||
return;
|
||||
};
|
||||
let Some(receiver) = instance(scope, "RTCRtpReceiver") else {
|
||||
return;
|
||||
};
|
||||
let Some(transceiver) = instance(scope, "RTCRtpTransceiver") else {
|
||||
return;
|
||||
};
|
||||
let encodings = if parsed.init.send_encodings.is_empty() {
|
||||
serde_json::json!([{"active":true}])
|
||||
} else {
|
||||
serde_json::Value::Array(
|
||||
parsed
|
||||
.init
|
||||
.send_encodings
|
||||
.iter()
|
||||
.map(Encoding::snapshot)
|
||||
.collect(),
|
||||
)
|
||||
};
|
||||
// Senders retain associated IDs, rather than keeping author stream objects
|
||||
// alive. Native identity is consulted without invoking public id getters.
|
||||
let mut streams: Vec<v8::Local<v8::Value>> = Vec::new();
|
||||
for stream in parsed.init.streams {
|
||||
let id = media_streams::stream_id(scope, stream);
|
||||
if !streams
|
||||
.iter()
|
||||
.any(|existing| existing.strict_equals(id.into()))
|
||||
{
|
||||
streams.push(id.into());
|
||||
}
|
||||
}
|
||||
SenderSlots::new(
|
||||
track
|
||||
.map(Into::into)
|
||||
.unwrap_or_else(|| v8::null(scope).into()),
|
||||
v8_string(scope, &encodings.to_string()).expect("encoding snapshot"),
|
||||
v8::Array::new_with_elements(scope, &streams),
|
||||
)
|
||||
.initialize(scope, sender)
|
||||
.expect("RTP sender slots");
|
||||
ReceiverSlots::new(receiver_track)
|
||||
.initialize(scope, receiver)
|
||||
.expect("RTP receiver slots");
|
||||
TransceiverSlots::new(
|
||||
pc,
|
||||
sender,
|
||||
receiver,
|
||||
v8str(scope, parsed.init.direction.token()),
|
||||
)
|
||||
.initialize(scope, transceiver)
|
||||
.expect("RTP transceiver slots");
|
||||
let array = list(scope, pc);
|
||||
if array.set_index(scope, array.length(), transceiver.into()) != Some(true) {
|
||||
return;
|
||||
}
|
||||
update_negotiation_needed(scope, pc);
|
||||
rv.set(transceiver.into());
|
||||
}
|
||||
fn collect<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let pc = target(scope, args.this());
|
||||
let slot = args.data().to_rust_string_lossy(scope);
|
||||
let result: Vec<_> = entries(scope, pc)
|
||||
.into_iter()
|
||||
.filter_map(|transceiver| {
|
||||
if slot == TRANSCEIVERS {
|
||||
Some(transceiver.into())
|
||||
} else if flag(scope, transceiver, STOPPED) {
|
||||
None
|
||||
} else {
|
||||
get_private_value(scope, transceiver, &slot)
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
rv.set(v8::Array::new_with_elements(scope, &result).into());
|
||||
}
|
||||
fn slot_getter<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let object = target(scope, args.this());
|
||||
let slot = args.data().to_rust_string_lossy(scope);
|
||||
rv.set(get_private_value(scope, object, &slot).expect("RTP slot"));
|
||||
}
|
||||
fn transport_getter<'s>(
|
||||
_scope: &mut v8::PinScope<'s, '_>,
|
||||
_args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
rv.set_null();
|
||||
}
|
||||
fn direction_getter<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let object = target(scope, args.this());
|
||||
rv.set(if flag(scope, object, STOPPING) {
|
||||
v8str(scope, "stopped").into()
|
||||
} else {
|
||||
get_private_value(scope, object, DIRECTION).expect("RTP direction")
|
||||
});
|
||||
}
|
||||
fn current_direction_getter<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let object = target(scope, args.this());
|
||||
rv.set(if flag(scope, object, STOPPED) {
|
||||
v8str(scope, "stopped").into()
|
||||
} else {
|
||||
get_private_value(scope, object, CURRENT_DIRECTION).expect("current RTP direction")
|
||||
});
|
||||
}
|
||||
fn direction_setter<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let Some(parsed) = webidl::parse_args::<DirectionArgs>(scope, &args) else {
|
||||
return;
|
||||
};
|
||||
// WebIDL enum attributes ignore unknown strings after DOMString
|
||||
// conversion. Operations and dictionaries use the strict enum converter.
|
||||
let Some(direction) = <Direction as webidl::WebIdlEnum>::parse_token(&parsed.value) else {
|
||||
return;
|
||||
};
|
||||
let object = target(scope, args.this());
|
||||
if flag(scope, object, STOPPING) {
|
||||
invalid_state(scope);
|
||||
return;
|
||||
}
|
||||
if direction == Direction::Stopped {
|
||||
throw_type_error(scope, "Use stop() to stop a transceiver.");
|
||||
return;
|
||||
}
|
||||
let next = v8str(scope, direction.token());
|
||||
if get_private_value(scope, object, DIRECTION)
|
||||
.expect("RTP direction")
|
||||
.strict_equals(next.into())
|
||||
{
|
||||
return;
|
||||
}
|
||||
set_private_value(scope, object, DIRECTION, next.into());
|
||||
let pc = get_private_object(scope, object, OWNER).expect("RTP owner");
|
||||
update_negotiation_needed(scope, pc);
|
||||
}
|
||||
fn stop_receiving<'s>(scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>) {
|
||||
if flag(scope, object, STOPPING) {
|
||||
return;
|
||||
}
|
||||
set_bool(scope, object, STOPPING, true);
|
||||
set_private_value(scope, object, DIRECTION, v8str(scope, "inactive").into());
|
||||
let receiver = get_private_object(scope, object, RECEIVER).expect("RTP receiver");
|
||||
let track = get_private_object(scope, receiver, TRACK).expect("receiver track");
|
||||
queue_task(scope, track, RendererPageWebRtcTaskKind::TrackEnded);
|
||||
}
|
||||
fn stop<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let object = target(scope, args.this());
|
||||
let pc = get_private_object(scope, object, OWNER).expect("RTP owner");
|
||||
if closed(scope, pc) {
|
||||
invalid_state(scope);
|
||||
return;
|
||||
}
|
||||
stop_receiving(scope, object);
|
||||
update_negotiation_needed(scope, pc);
|
||||
}
|
||||
pub(super) fn close<'s>(scope: &mut v8::PinScope<'s, '_>, pc: v8::Local<'s, v8::Object>) {
|
||||
for object in entries(scope, pc) {
|
||||
stop_receiving(scope, object);
|
||||
set_bool(scope, object, STOPPED, true);
|
||||
}
|
||||
}
|
||||
fn set_codec_preferences<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let Some(parsed) = webidl::parse_args::<CodecArgs>(scope, &args) else {
|
||||
return;
|
||||
};
|
||||
let object = target(scope, args.this());
|
||||
let receiver = get_private_object(scope, object, RECEIVER).expect("RTP receiver");
|
||||
let track = get_private_object(scope, receiver, TRACK).expect("receiver track");
|
||||
let supported = capabilities(&media_streams::track_kind(scope, track));
|
||||
let mut codecs: Vec<Codec> = Vec::new();
|
||||
for codec in parsed.codecs {
|
||||
if !supported.iter().any(|candidate| codec.matches(candidate)) {
|
||||
throw_dom_exception(
|
||||
scope,
|
||||
"InvalidModificationError",
|
||||
13,
|
||||
"The requested codec is unsupported.",
|
||||
);
|
||||
return;
|
||||
}
|
||||
if !codecs.iter().any(|candidate| codec.matches(candidate)) {
|
||||
codecs.push(codec);
|
||||
}
|
||||
}
|
||||
if !codecs.is_empty() && !codecs.iter().any(Codec::is_media) {
|
||||
throw_dom_exception(
|
||||
scope,
|
||||
"InvalidModificationError",
|
||||
13,
|
||||
"At least one media codec is required.",
|
||||
);
|
||||
return;
|
||||
}
|
||||
set_private_value(
|
||||
scope,
|
||||
object,
|
||||
CODECS,
|
||||
v8_string(
|
||||
scope,
|
||||
&serde_json::to_string(&codecs).expect("codec snapshot"),
|
||||
)
|
||||
.expect("codec snapshot string")
|
||||
.into(),
|
||||
);
|
||||
}
|
||||
fn queue_task<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
kind: RendererPageWebRtcTaskKind,
|
||||
) -> bool {
|
||||
context_host_ptr_from_global_bridge(scope)
|
||||
.is_some_and(|host| unsafe { &mut *host }.queue_webrtc_task(scope, object, kind))
|
||||
}
|
||||
fn update_negotiation_needed<'s>(scope: &mut v8::PinScope<'s, '_>, pc: v8::Local<'s, v8::Object>) {
|
||||
if !closed(scope, pc) && !flag(scope, pc, NEGOTIATION_TASK) {
|
||||
let queued = queue_task(scope, pc, RendererPageWebRtcTaskKind::NegotiationNeeded);
|
||||
set_bool(scope, pc, NEGOTIATION_TASK, queued);
|
||||
}
|
||||
}
|
||||
fn negotiation_handler_setter<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let pc = target(scope, args.this());
|
||||
media_queries::simple_object_event_set_handler(
|
||||
scope,
|
||||
pc,
|
||||
"negotiationneeded",
|
||||
NEGOTIATION_HANDLER,
|
||||
args.get(0),
|
||||
);
|
||||
}
|
||||
pub(crate) fn apply_task<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
kind: RendererPageWebRtcTaskKind,
|
||||
) -> bool {
|
||||
let event_type = match kind {
|
||||
RendererPageWebRtcTaskKind::TrackEnded => {
|
||||
if !media_streams::end_track(scope, object) {
|
||||
return false;
|
||||
}
|
||||
"ended"
|
||||
}
|
||||
RendererPageWebRtcTaskKind::NegotiationNeeded => {
|
||||
set_bool(scope, object, NEGOTIATION_TASK, false);
|
||||
if closed(scope, object)
|
||||
|| flag(scope, object, NEGOTIATION_NEEDED)
|
||||
|| !get_private_value(
|
||||
scope,
|
||||
object,
|
||||
super::RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT,
|
||||
)
|
||||
.expect("PC state")
|
||||
.strict_equals(v8str(scope, "stable").into())
|
||||
|| !entries(scope, object)
|
||||
.iter()
|
||||
.any(|entry| !flag(scope, *entry, STOPPING))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
set_bool(scope, object, NEGOTIATION_NEEDED, true);
|
||||
"negotiationneeded"
|
||||
}
|
||||
};
|
||||
let event = events::new_event_state(scope);
|
||||
events::initialize_event_object(scope, event, event_type, false, false);
|
||||
web_api_interfaces::initialize(scope, event, "Event").expect("native RTP event");
|
||||
events::mark_event_trusted(scope, event);
|
||||
let wrapper = exposed_interfaces::build_intrinsic_interface_instance(scope, "Event")
|
||||
.expect("Event instance");
|
||||
let prototype = exposed_interfaces::ensure_intrinsic_interface_prototype(scope, "Event")
|
||||
.expect("Event prototype");
|
||||
if wrapper.set_prototype(scope, prototype.into()) != Some(true)
|
||||
|| events::initialize_event_wrapper(scope, wrapper, event).is_none()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
media_queries::dispatch_simple_event_target_event(scope, object, event_type, wrapper);
|
||||
true
|
||||
}
|
||||
|
||||
/// Read only private snapshots when building the signaling-only offer.
|
||||
pub(super) fn offer_sections<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
pc: v8::Local<'s, v8::Object>,
|
||||
) -> Vec<(String, String, Vec<Codec>)> {
|
||||
entries(scope, pc)
|
||||
.into_iter()
|
||||
.filter_map(|object| {
|
||||
if flag(scope, object, STOPPING) {
|
||||
return None;
|
||||
}
|
||||
let receiver = get_private_object(scope, object, RECEIVER).expect("RTP receiver");
|
||||
let track = get_private_object(scope, receiver, TRACK).expect("receiver track");
|
||||
let kind = media_streams::track_kind(scope, track);
|
||||
let direction = get_private_value(scope, object, DIRECTION)
|
||||
.expect("direction")
|
||||
.to_rust_string_lossy(scope);
|
||||
let snapshot = get_private_value(scope, object, CODECS)
|
||||
.expect("codec snapshot")
|
||||
.to_rust_string_lossy(scope);
|
||||
let codecs: Vec<Codec> =
|
||||
serde_json::from_str(&snapshot).expect("native codec snapshot");
|
||||
Some((
|
||||
kind.clone(),
|
||||
direction,
|
||||
if codecs.is_empty() {
|
||||
capabilities(&kind)
|
||||
} else {
|
||||
codecs
|
||||
},
|
||||
))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
@@ -530,6 +530,7 @@ impl PageScriptHost {
|
||||
view_transition_updates:
|
||||
super::view_transition_updates::ViewTransitionUpdateState::default(),
|
||||
media_element_events: super::media_element_events::MediaElementEventState::default(),
|
||||
webrtc_tasks: super::webrtc_tasks::WebRtcTaskState::default(),
|
||||
element_toggle_events: super::element_toggle_events::ElementToggleEventState::default(),
|
||||
form_navigations: super::form_navigations::FormNavigationState::default(),
|
||||
text_track_default_modes:
|
||||
|
||||
@@ -128,6 +128,7 @@ mod main_document_lifecycle;
|
||||
mod media_element_events;
|
||||
mod media_loads;
|
||||
mod misc_platform_api_tasks;
|
||||
mod webrtc_tasks;
|
||||
pub(crate) use media_loads::PendingMediaLoadTerminalFollowup;
|
||||
mod text_track_loads;
|
||||
pub(crate) use text_track_loads::{
|
||||
@@ -1059,6 +1060,7 @@ pub(crate) struct PageScriptHost {
|
||||
scroll_observable_effect_batch: interaction_batch::ScrollObservableEffectBatchState,
|
||||
view_transition_updates: view_transition_updates::ViewTransitionUpdateState,
|
||||
media_element_events: media_element_events::MediaElementEventState,
|
||||
webrtc_tasks: webrtc_tasks::WebRtcTaskState,
|
||||
element_toggle_events: element_toggle_events::ElementToggleEventState,
|
||||
form_navigations: form_navigations::FormNavigationState,
|
||||
text_track_default_modes: text_track_default_modes::TextTrackDefaultModeState,
|
||||
|
||||
@@ -0,0 +1,86 @@
|
||||
use super::window_document_tasks::{ExactWindowDocumentTaskLedger, PendingExactWindowDocumentTask};
|
||||
use super::{PageScriptHost, WindowDocumentTaskTarget};
|
||||
use crate::page_task_queue::{RendererPageWebRtcTaskId, RendererPageWebRtcTaskKind};
|
||||
|
||||
pub(super) type WebRtcTaskState = ExactWindowDocumentTaskLedger<
|
||||
RendererPageWebRtcTaskId,
|
||||
RendererPageWebRtcTaskKind,
|
||||
v8::Global<v8::Object>,
|
||||
>;
|
||||
|
||||
impl PageScriptHost {
|
||||
pub(crate) fn queue_webrtc_task<'s>(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
kind: RendererPageWebRtcTaskKind,
|
||||
) -> bool {
|
||||
let Some(context) = object.get_creation_context(scope) else {
|
||||
return false;
|
||||
};
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
let Some(target) = self.current_window_document_task_target(scope) else {
|
||||
return false;
|
||||
};
|
||||
let id = self
|
||||
.webrtc_tasks
|
||||
.allocate_task_id(RendererPageWebRtcTaskId::from_raw);
|
||||
self.webrtc_tasks.push(PendingExactWindowDocumentTask::new(
|
||||
id,
|
||||
target,
|
||||
kind,
|
||||
v8::Global::new(scope, object),
|
||||
));
|
||||
if self
|
||||
.page_task_capabilities
|
||||
.get()
|
||||
.expect("Page WebRTC task capabilities")
|
||||
.webrtc()
|
||||
.send(target, id, kind)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
self.webrtc_tasks.remove_exact(id, target, kind);
|
||||
false
|
||||
}
|
||||
|
||||
pub(crate) fn current_pending_webrtc_task(
|
||||
&self,
|
||||
id: RendererPageWebRtcTaskId,
|
||||
) -> Option<(WindowDocumentTaskTarget, RendererPageWebRtcTaskKind)> {
|
||||
let pending = self.webrtc_tasks.pending(id)?;
|
||||
let target = self.current_window_document_task_target_for_dispatch_scope(
|
||||
pending.target().dispatch_scope(),
|
||||
)?;
|
||||
Some((target, pending.kind()))
|
||||
}
|
||||
|
||||
pub(crate) fn apply_authorized_webrtc(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
_host_ptr: *mut PageScriptHost,
|
||||
id: RendererPageWebRtcTaskId,
|
||||
target: WindowDocumentTaskTarget,
|
||||
kind: RendererPageWebRtcTaskKind,
|
||||
) -> Option<bool> {
|
||||
let object = self
|
||||
.webrtc_tasks
|
||||
.remove_exact(id, target, kind)?
|
||||
.into_payload();
|
||||
let Some(resolved) = self.resolve_authorized_window_document_task_context(scope, target)
|
||||
else {
|
||||
return Some(false);
|
||||
};
|
||||
let scope = &mut v8::ContextScope::new(scope, resolved.context);
|
||||
let dispatch = target.dispatch_scope();
|
||||
let previous = dispatch.enter(scope);
|
||||
let object = v8::Local::new(scope, &object);
|
||||
let applied = crate::context_bootstrap::apply_webrtc_task(scope, object, kind);
|
||||
dispatch.restore(scope, previous);
|
||||
Some(applied)
|
||||
}
|
||||
|
||||
pub(crate) fn discard_pending_webrtc_task(&mut self, id: RendererPageWebRtcTaskId) -> bool {
|
||||
self.webrtc_tasks.remove(id).is_some()
|
||||
}
|
||||
}
|
||||
@@ -26,6 +26,12 @@ mod main_document_task_owner;
|
||||
mod main_native_module_task;
|
||||
mod main_parser_continuation;
|
||||
mod media_element_event;
|
||||
mod webrtc;
|
||||
pub(crate) use webrtc::{
|
||||
PageWebRtcTargetEffect, PageWebRtcTurnAction, PageWebRtcTurnOutcome, RendererPageWebRtcOwner,
|
||||
RendererPageWebRtcSender, RendererPageWebRtcTask, RendererPageWebRtcTaskId,
|
||||
RendererPageWebRtcTaskKind,
|
||||
};
|
||||
mod message_port_delivery;
|
||||
mod misc_platform_api;
|
||||
mod module_reaction;
|
||||
|
||||
@@ -28,6 +28,7 @@ pub(crate) enum RendererPageNetworkingOwner {
|
||||
TextTrackLoad(RendererPageTextTrackLoadOwner),
|
||||
StylesheetCompletion(RendererPageStylesheetTaskOwner),
|
||||
WorkerHostBridge(RendererPageWorkerHostBridgeOwner),
|
||||
WebRtc(super::RendererPageWebRtcOwner),
|
||||
}
|
||||
|
||||
/// One concrete task in the Page-owned HTML networking source.
|
||||
@@ -39,11 +40,13 @@ pub(crate) enum RendererPageNetworkingTask {
|
||||
TextTrackLoad(RendererPageTextTrackLoadTask),
|
||||
StylesheetCompletion(RendererPageStylesheetNetworkingTask),
|
||||
WorkerHostBridge(RendererPageWorkerHostBridgeTask),
|
||||
WebRtc(super::RendererPageWebRtcTask),
|
||||
}
|
||||
|
||||
impl RendererPageNetworkingTask {
|
||||
pub(crate) fn owner(&self) -> RendererPageNetworkingOwner {
|
||||
match self {
|
||||
Self::WebRtc(task) => RendererPageNetworkingOwner::WebRtc(task.owner()),
|
||||
Self::ResourceCompletion(completion) => {
|
||||
RendererPageNetworkingOwner::ResourceCompletion(completion.owner())
|
||||
}
|
||||
@@ -214,7 +217,8 @@ impl RendererPageNetworkingSource {
|
||||
| RendererPageNetworkingTask::StyleElementEvent(_)
|
||||
| RendererPageNetworkingTask::TextTrackLoad(_)
|
||||
| RendererPageNetworkingTask::StylesheetCompletion(_)
|
||||
| RendererPageNetworkingTask::WorkerHostBridge(_) => None,
|
||||
| RendererPageNetworkingTask::WorkerHostBridge(_)
|
||||
| RendererPageNetworkingTask::WebRtc(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -231,7 +235,8 @@ impl RendererPageNetworkingSource {
|
||||
| RendererPageNetworkingTask::StyleElementEvent(_)
|
||||
| RendererPageNetworkingTask::TextTrackLoad(_)
|
||||
| RendererPageNetworkingTask::StylesheetCompletion(_)
|
||||
| RendererPageNetworkingTask::WorkerHostBridge(_) => return None,
|
||||
| RendererPageNetworkingTask::WorkerHostBridge(_)
|
||||
| RendererPageNetworkingTask::WebRtc(_) => return None,
|
||||
}
|
||||
let (ready, task) = self.pop_front_task()?;
|
||||
let RendererPageNetworkingTask::ResourceCompletion(completion) = task else {
|
||||
@@ -257,6 +262,7 @@ pub(crate) enum PageNetworkingTurnAction {
|
||||
TextTrackLoad(PageTextTrackLoadTurnAction),
|
||||
StylesheetCompletion(PageStylesheetNetworkingTurnAction),
|
||||
WorkerHostBridge(PageWorkerHostBridgeTurnAction),
|
||||
WebRtc(super::PageWebRtcTurnAction),
|
||||
}
|
||||
|
||||
pub(crate) type PageNetworkingTurnOutcome = PageOwnerTurnOutcome<PageNetworkingTurnAction>;
|
||||
|
||||
@@ -1734,6 +1734,13 @@ impl RendererPageOwnedTaskSources {
|
||||
}
|
||||
|
||||
impl RendererPageTaskProducerRoutes {
|
||||
pub(crate) fn webrtc_sender(
|
||||
&self,
|
||||
root_document: crate::runtime::RendererDocumentToken,
|
||||
) -> super::RendererPageWebRtcSender {
|
||||
super::RendererPageWebRtcSender::new(self.networking.clone(), root_document)
|
||||
}
|
||||
|
||||
pub(crate) fn v8_foreground_task_sender(&self) -> RendererPageV8ForegroundTaskSender {
|
||||
self.v8_foreground_task.clone()
|
||||
}
|
||||
|
||||
@@ -81,6 +81,7 @@ pub(crate) struct RendererPageJsContextTaskSenders {
|
||||
rendering_update: RendererPageRenderingUpdateSender,
|
||||
media_element_event: RendererPageMediaElementEventSender,
|
||||
text_track_load: RendererPageTextTrackLoadSender,
|
||||
webrtc: super::RendererPageWebRtcSender,
|
||||
dedicated_worker_client_event: RendererPageDedicatedWorkerClientEventSender,
|
||||
shared_worker_client_event: RendererPageSharedWorkerClientEventSender,
|
||||
worker_host_bridge: RendererWorkerHostBridgeEventSender,
|
||||
@@ -164,6 +165,10 @@ impl RendererPageJsContextTaskSenders {
|
||||
&self.media_element_event
|
||||
}
|
||||
|
||||
pub(crate) fn webrtc(&self) -> &super::RendererPageWebRtcSender {
|
||||
&self.webrtc
|
||||
}
|
||||
|
||||
pub(crate) fn text_track_load(&self) -> &RendererPageTextTrackLoadSender {
|
||||
&self.text_track_load
|
||||
}
|
||||
@@ -364,6 +369,7 @@ impl PageRuntimeTaskSource {
|
||||
rendering_update: routes.rendering_update_sender(root_document),
|
||||
media_element_event: routes.media_element_event_sender(root_document),
|
||||
text_track_load: routes.text_track_load_sender(root_document),
|
||||
webrtc: routes.webrtc_sender(root_document),
|
||||
dedicated_worker_client_event: routes
|
||||
.dedicated_worker_client_event_sender(root_document),
|
||||
shared_worker_client_event: routes.shared_worker_client_event_sender(root_document),
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
//! WebRTC tasks share HTML's networking FIFO; V8 payloads stay in their Host.
|
||||
use super::{
|
||||
PageWindowDocumentTaskTargetEffect, PageWindowDocumentTaskTurnAction,
|
||||
RendererPageNetworkingRoute, RendererPageNetworkingTask, RendererPageWindowDocumentTask,
|
||||
RendererPageWindowDocumentTaskOwner,
|
||||
};
|
||||
use crate::{native_bridge::WindowDocumentTaskTarget, runtime::RendererDocumentToken};
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub(crate) struct RendererPageWebRtcTaskId(u64);
|
||||
impl RendererPageWebRtcTaskId {
|
||||
pub(crate) const fn from_raw(raw: u64) -> Self {
|
||||
Self(raw)
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub(crate) enum RendererPageWebRtcTaskKind {
|
||||
TrackEnded,
|
||||
NegotiationNeeded,
|
||||
}
|
||||
pub(crate) type RendererPageWebRtcOwner = RendererPageWindowDocumentTaskOwner;
|
||||
pub(crate) type RendererPageWebRtcTask =
|
||||
RendererPageWindowDocumentTask<RendererPageWebRtcTaskId, RendererPageWebRtcTaskKind>;
|
||||
pub(crate) type PageWebRtcTurnAction =
|
||||
PageWindowDocumentTaskTurnAction<RendererPageWebRtcTaskId, RendererPageWebRtcTaskKind>;
|
||||
pub(crate) type PageWebRtcTargetEffect = PageWindowDocumentTaskTargetEffect;
|
||||
pub(crate) type PageWebRtcTurnOutcome = crate::runtime::PageOwnerTurnOutcome<PageWebRtcTurnAction>;
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct RendererPageWebRtcSender {
|
||||
networking: RendererPageNetworkingRoute,
|
||||
root_document: RendererDocumentToken,
|
||||
}
|
||||
impl RendererPageWebRtcSender {
|
||||
pub(super) fn new(
|
||||
networking: RendererPageNetworkingRoute,
|
||||
root_document: RendererDocumentToken,
|
||||
) -> Self {
|
||||
Self {
|
||||
networking,
|
||||
root_document,
|
||||
}
|
||||
}
|
||||
pub(crate) fn send(
|
||||
&self,
|
||||
target: WindowDocumentTaskTarget,
|
||||
id: RendererPageWebRtcTaskId,
|
||||
kind: RendererPageWebRtcTaskKind,
|
||||
) -> bool {
|
||||
self.networking
|
||||
.send(RendererPageNetworkingTask::WebRtc(
|
||||
RendererPageWebRtcTask::new(
|
||||
RendererPageWebRtcOwner::new(self.root_document, target),
|
||||
id,
|
||||
kind,
|
||||
),
|
||||
))
|
||||
.is_ok()
|
||||
}
|
||||
}
|
||||
@@ -165,6 +165,7 @@ pub(crate) use self::page_vm::AuthorizedCurrentPageUserInteractionTask;
|
||||
pub(crate) use self::page_vm::AuthorizedCurrentPageViewTransitionUpdate;
|
||||
pub(crate) use self::page_vm::AuthorizedCurrentPageWebCryptoTask;
|
||||
pub(crate) use self::page_vm::AuthorizedCurrentPageWebLocksTask;
|
||||
pub(crate) use self::page_vm::AuthorizedCurrentPageWebRtc;
|
||||
pub(crate) use self::page_vm::AuthorizedCurrentPageWindowMessage;
|
||||
#[cfg(test)]
|
||||
pub(crate) use self::page_vm::PageDomManipulationTestFamily;
|
||||
|
||||
@@ -121,6 +121,8 @@ mod page_main_document_runtime;
|
||||
mod page_main_native_module_task;
|
||||
mod page_main_parser_continuation;
|
||||
mod page_media_element_event;
|
||||
mod page_webrtc;
|
||||
pub(crate) use page_webrtc::AuthorizedCurrentPageWebRtc;
|
||||
#[cfg(test)]
|
||||
mod page_media_element_event_body_test_support;
|
||||
mod page_message_port_delivery;
|
||||
|
||||
@@ -10,6 +10,9 @@ impl PageVm {
|
||||
task: RendererPageNetworkingTask,
|
||||
) -> anyhow::Result<PageNetworkingTurnOutcome> {
|
||||
match task {
|
||||
RendererPageNetworkingTask::WebRtc(task) => self
|
||||
.apply_selected_page_webrtc_turn(task)
|
||||
.map(|outcome| outcome.map_action(PageNetworkingTurnAction::WebRtc)),
|
||||
RendererPageNetworkingTask::ResourceCompletion(completion) => self
|
||||
.apply_selected_page_resource_completion_turn(*completion)
|
||||
.map(|outcome| outcome.map_action(PageNetworkingTurnAction::ResourceCompletion)),
|
||||
|
||||
@@ -18,6 +18,13 @@ impl PageVm {
|
||||
loader: &crate::network::ResourceRequestClient,
|
||||
) -> Result<()> {
|
||||
match action {
|
||||
PageNetworkingTurnAction::WebRtc(action) => {
|
||||
self.finish_selected_page_task_completion(
|
||||
action.into_page_task_completion(),
|
||||
loader,
|
||||
)
|
||||
.await?;
|
||||
}
|
||||
PageNetworkingTurnAction::ResourceCompletion(action) => {
|
||||
self.finish_selected_page_resource_completion_task(action)?;
|
||||
}
|
||||
|
||||
@@ -63,6 +63,7 @@ pub(crate) enum PageSelectedTaskTestSelector {
|
||||
InternalLoading,
|
||||
MainParserContinuation,
|
||||
MediaElementEvent,
|
||||
WebRtc,
|
||||
MessagePortDelivery,
|
||||
ModuleReaction,
|
||||
ModulepreloadStart,
|
||||
@@ -201,6 +202,13 @@ impl PageSelectedTaskTestSelector {
|
||||
..
|
||||
}
|
||||
),
|
||||
Self::WebRtc => matches!(
|
||||
descriptor,
|
||||
RendererPageReadyDescriptor::Networking {
|
||||
owner: RendererPageNetworkingOwner::WebRtc(_),
|
||||
..
|
||||
}
|
||||
),
|
||||
Self::MediaElementEvent => matches!(
|
||||
descriptor,
|
||||
RendererPageReadyDescriptor::MediaElementEvent { .. }
|
||||
@@ -423,6 +431,10 @@ impl PageSelectedTaskTestSelector {
|
||||
RendererPageNetworkingTask::MainParserContinuation(_),
|
||||
),
|
||||
)
|
||||
| (
|
||||
Self::WebRtc,
|
||||
RendererPageSchedulerTask::Networking(RendererPageNetworkingTask::WebRtc(_)),
|
||||
)
|
||||
| (Self::MediaElementEvent, RendererPageSchedulerTask::MediaElementEvent(_))
|
||||
| (Self::MessagePortDelivery, RendererPageSchedulerTask::MessagePortDelivery { .. })
|
||||
| (Self::ModuleReaction, RendererPageSchedulerTask::ModuleReaction(_))
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
use crate::page_task_queue::{
|
||||
PageWebRtcTargetEffect, PageWebRtcTurnAction, PageWebRtcTurnOutcome, RendererPageWebRtcOwner,
|
||||
RendererPageWebRtcTask, RendererPageWebRtcTaskId, RendererPageWebRtcTaskKind,
|
||||
};
|
||||
|
||||
use super::{
|
||||
AuthorizedCurrentWindowDocumentTask, IntoPageTaskCompletion, PageTaskCompletion, PageVm,
|
||||
};
|
||||
|
||||
impl IntoPageTaskCompletion for PageWebRtcTurnAction {
|
||||
fn into_page_task_completion(self) -> PageTaskCompletion {
|
||||
match self.target_effect {
|
||||
PageWebRtcTargetEffect::DispatchedToCurrentOwner => {
|
||||
PageTaskCompletion::CallbackCompletion
|
||||
}
|
||||
PageWebRtcTargetEffect::CurrentOwnerHadNoEventTarget => {
|
||||
PageTaskCompletion::CheckpointOnly
|
||||
}
|
||||
PageWebRtcTargetEffect::DiscardedStaleOwner { .. } => PageTaskCompletion::NoCompletion,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Proof that the Page arbiter matched the PageVm namespace, exact Document,
|
||||
/// Host-local payload id, and WebRTC operation before V8 application.
|
||||
pub(crate) type AuthorizedCurrentPageWebRtc =
|
||||
AuthorizedCurrentWindowDocumentTask<RendererPageWebRtcTask>;
|
||||
|
||||
impl PageVm {
|
||||
fn current_page_webrtc_owner(
|
||||
&self,
|
||||
task_id: RendererPageWebRtcTaskId,
|
||||
) -> Option<(RendererPageWebRtcOwner, RendererPageWebRtcTaskKind)> {
|
||||
self.vm()
|
||||
.current_pending_webrtc_owner(task_id, self.document_lifecycle.identity().document)
|
||||
}
|
||||
|
||||
pub(in crate::runtime) fn apply_selected_page_webrtc_turn(
|
||||
&mut self,
|
||||
task: RendererPageWebRtcTask,
|
||||
) -> anyhow::Result<PageWebRtcTurnOutcome> {
|
||||
let owner = task.owner();
|
||||
let task_id = task.task_id();
|
||||
let kind = task.kind();
|
||||
let current = self.current_page_webrtc_owner(task_id);
|
||||
let target_effect =
|
||||
match self.authorize_current_window_document_task(task, owner, kind, current) {
|
||||
Ok(authorization) => {
|
||||
if self.vm_mut().apply_current_webrtc_body(authorization)? {
|
||||
PageWebRtcTargetEffect::DispatchedToCurrentOwner
|
||||
} else {
|
||||
PageWebRtcTargetEffect::CurrentOwnerHadNoEventTarget
|
||||
}
|
||||
}
|
||||
Err(stale) => {
|
||||
if stale.may_discard_local_payload() {
|
||||
self.vm_mut().discard_stale_webrtc_task(task_id);
|
||||
}
|
||||
let current_owner = stale.current_owner();
|
||||
tracing::debug!(
|
||||
?owner,
|
||||
?current_owner,
|
||||
?task_id,
|
||||
?kind,
|
||||
"discarded stale exact-Document WebRTC task"
|
||||
);
|
||||
PageWebRtcTargetEffect::DiscardedStaleOwner { current_owner }
|
||||
}
|
||||
};
|
||||
let action = PageWebRtcTurnAction {
|
||||
owner,
|
||||
task_id,
|
||||
kind,
|
||||
target_effect,
|
||||
};
|
||||
Ok(PageWebRtcTurnOutcome::new(action))
|
||||
}
|
||||
}
|
||||
@@ -2411,3 +2411,5 @@ mod request_body_transfer;
|
||||
|
||||
mod canvas_blob_serialization;
|
||||
mod response_body_clone;
|
||||
|
||||
mod rtp_transceivers;
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn rtp_transceiver_tasks_use_networking_fifo_and_one_selected_boundary() {
|
||||
run_page_vm_async_test(async move {
|
||||
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
|
||||
let (mut page, _, _) = page_vm_with_bound_task_sources_and_owner_wake(&loader, Url::parse("https://rtp.test/fifo")?);
|
||||
page.vm_mut().eval(r#"
|
||||
globalThis.trace=[];globalThis.pc=new RTCPeerConnection();
|
||||
pc.addEventListener('negotiationneeded',()=>trace.push('before'));
|
||||
pc.onnegotiationneeded=()=>trace.push('original');
|
||||
pc.addEventListener('negotiationneeded',()=>trace.push('after'));
|
||||
pc.onnegotiationneeded=e=>{if(!e.isTrusted)throw Error('untrusted negotiation');trace.push('negotiation');};
|
||||
globalThis.audio=pc.addTransceiver('audio');globalThis.video=pc.addTransceiver('video');
|
||||
pc.addTransceiver('audio');
|
||||
audio.receiver.track.onended=()=>{trace.push('audio');Promise.resolve().then(()=>trace.push('audio microtask'));};
|
||||
video.receiver.track.onended=()=>trace.push('video');
|
||||
audio.stop();video.stop();'queued'
|
||||
"#)?;
|
||||
assert!(!page.vm().has_ready_timeout(), "RTP tasks cannot borrow the timer source");
|
||||
for expected in ["before|negotiation|after", "before|negotiation|after|audio|audio microtask", "before|negotiation|after|audio|audio microtask|video"] {
|
||||
assert!(page.run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::WebRtc, &loader).await?);
|
||||
assert_eq!(page.vm_mut().eval("trace.join('|')")?, expected);
|
||||
}
|
||||
assert!(!page.run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::WebRtc, &loader).await?);
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn rtp_transceiver_tasks_cannot_dispatch_or_checkpoint_after_document_open() {
|
||||
run_page_vm_async_test(async move {
|
||||
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
|
||||
let (mut page, _, _) = page_vm_with_bound_task_sources_and_owner_wake(&loader, Url::parse("https://rtp.test/retirement")?);
|
||||
page.vm_mut().eval(r#"
|
||||
globalThis.trace=[];const pc=new RTCPeerConnection();const t=pc.addTransceiver('audio');
|
||||
t.receiver.track.onended=()=>trace.push('retired ended');t.stop();
|
||||
document.open();document.write('<!doctype html><body>replacement');document.close();'replaced'
|
||||
"#)?;
|
||||
page.vm_mut().eval_without_microtask_checkpoint_for_test("Promise.resolve().then(()=>trace.push('replacement microtask'));'queued'")?;
|
||||
for _ in 0..2 {
|
||||
let task = page.claim_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::WebRtc).expect("retired task retains its FIFO residence");
|
||||
page.run_claimed_selected_page_task_for_test(task, &loader).await?;
|
||||
}
|
||||
assert_eq!(page.vm_mut().eval_without_microtask_checkpoint_for_test("trace.join('|')")?, "", "stale tasks must not checkpoint the replacement realm");
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.unwrap();
|
||||
}
|
||||
@@ -856,6 +856,7 @@ mod page_resource_completion_owner;
|
||||
mod page_task_capabilities;
|
||||
mod page_task_enqueue;
|
||||
mod parser_owned_classic;
|
||||
mod webrtc;
|
||||
pub(crate) use parser_owned_classic::*;
|
||||
mod parser_module_terminal;
|
||||
mod popup_close;
|
||||
|
||||
@@ -2481,6 +2481,7 @@ mod response_blob_mime;
|
||||
mod retained_child_window;
|
||||
mod rtc_certificate;
|
||||
mod rtc_encoded_frames;
|
||||
mod rtp_transceivers;
|
||||
mod script_terminal_completion;
|
||||
mod service_worker_interfaces;
|
||||
mod speech_events;
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn rtp_transceivers_native_graph_conversion_preferences_and_lifecycle() {
|
||||
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
|
||||
for url in [
|
||||
"https://rtp.test/",
|
||||
"http://rtp.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/rtp-transceivers.js"))
|
||||
.unwrap();
|
||||
advance_page_task_executor_until_eval_equals(
|
||||
&mut vm,
|
||||
&loader,
|
||||
"String(globalThis.__uiEventResults?.complete)",
|
||||
"true",
|
||||
"RTP fixture must settle through the production selected Page task dispatcher",
|
||||
)
|
||||
.await;
|
||||
assert_eq!(vm.eval("__uiEventResults.complete").unwrap(), "true");
|
||||
assert_eq!(
|
||||
vm.eval("JSON.stringify(__uiEventResults.checks.filter(row=>!row.passed))")
|
||||
.unwrap(),
|
||||
"[]",
|
||||
"{url}"
|
||||
);
|
||||
assert_eq!(vm.eval("__uiEventResults.total===100 && new Set(__uiEventResults.checks.map(row=>row.name)).size===100").unwrap(), "true");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rtp_transceivers_accept_registered_native_proxies_and_reject_author_wrappers() {
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://rtp-native-proxy.test/");
|
||||
vm.eval("globalThis.pc=new RTCPeerConnection();globalThis.transceiver=pc.addTransceiver('audio');globalThis.sender=transceiver.sender;globalThis.receiver=transceiver.receiver;globalThis.track=receiver.track").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 (original, native) in [
|
||||
("pc", "nativePC"),
|
||||
("transceiver", "nativeTransceiver"),
|
||||
("sender", "nativeSender"),
|
||||
("receiver", "nativeReceiver"),
|
||||
("track", "nativeTrack"),
|
||||
] {
|
||||
let key = crate::util::v8_string(scope, original).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 name = crate::util::v8_string(scope, native).unwrap();
|
||||
assert_eq!(
|
||||
global.create_data_property(scope, name.into(), proxy.into()),
|
||||
Some(true)
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(vm.eval(r#"(() => {
|
||||
if(nativePC.getTransceivers()[0]!==transceiver||nativeSender.track!==null||nativeReceiver.track!==track)return false;
|
||||
if(nativePC.onnegotiationneeded!==null)return false;
|
||||
const handler=()=>{};nativePC.onnegotiationneeded=handler;if(pc.onnegotiationneeded!==handler)return false;
|
||||
nativePC.onnegotiationneeded=42;if(pc.onnegotiationneeded!==null)return false;
|
||||
const descriptor=Object.getOwnPropertyDescriptor(RTCPeerConnection.prototype,'onnegotiationneeded');
|
||||
try{descriptor.set.call(new Proxy(nativePC,{}),handler);return false;}catch(error){if(!(error instanceof TypeError))return false;}
|
||||
nativeTransceiver.direction='sendonly';nativeTransceiver.setCodecPreferences(RTCRtpSender.getCapabilities('audio').codecs);
|
||||
if(transceiver.direction!=='sendonly'||nativePC.addTransceiver(nativeTrack).sender.track!==nativeTrack)return false;
|
||||
let reads=0;try{RTCRtpTransceiver.prototype.setCodecPreferences.call(new Proxy(nativeTransceiver,{}),{[Symbol.iterator](){reads++;return [][Symbol.iterator]();}});return false;}catch(error){if(!(error instanceof TypeError)||reads!==0)return false;}
|
||||
nativeTransceiver.stop();if(transceiver.direction!=='stopped')return false;pc.close();return true;
|
||||
})()"#).unwrap(), "true");
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
use anyhow::{Result, anyhow};
|
||||
|
||||
use super::ScriptVm;
|
||||
use crate::page_task_queue::{
|
||||
RendererPageWebRtcOwner, RendererPageWebRtcTaskId, RendererPageWebRtcTaskKind,
|
||||
};
|
||||
use crate::runtime::AuthorizedCurrentPageWebRtc;
|
||||
|
||||
impl ScriptVm {
|
||||
pub(crate) fn current_pending_webrtc_owner(
|
||||
&self,
|
||||
task_id: RendererPageWebRtcTaskId,
|
||||
root_document: crate::runtime::RendererDocumentToken,
|
||||
) -> Option<(RendererPageWebRtcOwner, RendererPageWebRtcTaskKind)> {
|
||||
let (target, kind) = self
|
||||
._context_host
|
||||
.borrow()
|
||||
.current_pending_webrtc_task(task_id)?;
|
||||
Some((RendererPageWebRtcOwner::new(root_document, target), kind))
|
||||
}
|
||||
|
||||
/// Apply only the callback-visible body of one authorized WebRTC task.
|
||||
///
|
||||
/// The selected Page-task dispatcher owns the task-end checkpoint, child
|
||||
/// synchronization, and runtime follow-up. Keeping those operations out of
|
||||
/// this helper prevents low-level semantic fixtures or nested callers from
|
||||
/// manufacturing an extra HTML task boundary.
|
||||
pub(crate) fn apply_current_webrtc_body(
|
||||
&mut self,
|
||||
authorization: AuthorizedCurrentPageWebRtc,
|
||||
) -> Result<bool> {
|
||||
let task = authorization.into_task();
|
||||
let owner = task.owner();
|
||||
self.with_default_context_scope(|scope, host_ptr| {
|
||||
unsafe { &mut *host_ptr }
|
||||
.apply_authorized_webrtc(
|
||||
scope,
|
||||
host_ptr,
|
||||
task.task_id(),
|
||||
owner.target(),
|
||||
task.kind(),
|
||||
)
|
||||
.ok_or_else(|| anyhow!("authorized WebRTC task lost its exact payload"))
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn discard_stale_webrtc_task(&mut self, task_id: RendererPageWebRtcTaskId) -> bool {
|
||||
self._context_host
|
||||
.borrow_mut()
|
||||
.discard_pending_webrtc_task(task_id)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
(async () => {
|
||||
const checks=[];
|
||||
const assert=(ok,message='assertion failed')=>{if(!ok)throw Error(message);};
|
||||
const equal=(actual,expected)=>assert(JSON.stringify(actual)===JSON.stringify(expected),JSON.stringify({actual,expected}));
|
||||
const raises=(action,C,name)=>{let error;try{action();}catch(value){error=value;}assert(error instanceof C&&(!name||error.name===name),'expected '+(name||C.name)+', got '+error);};
|
||||
for(const [index,w] of [window,document.querySelector('iframe').contentWindow].entries()) {
|
||||
const P=w.RTCPeerConnection,T=w.RTCRtpTransceiver,S=w.RTCRtpSender,R=w.RTCRtpReceiver;
|
||||
const check=async(name,action)=>{const key=index+':'+name;globalThis.__codecCurrentCheck=key;try{await action();checks.push({name:key,passed:true});}catch(error){checks.push({name:key,passed:false,error:{name:error.name,message:error.message}});}};
|
||||
const withPC=async(action)=>{const pc=new P();try{await action(pc);}finally{pc.close();}};
|
||||
await check('illegal RTP constructors',()=>{for(const C of [T,S,R]){raises(()=>new C(),w.TypeError);raises(()=>C(),w.TypeError);}});
|
||||
await check('initial fresh callee realm collections',()=>withPC(pc=>{for(const key of ['getSenders','getReceivers','getTransceivers']){const a=pc[key](),b=pc[key]();assert(a instanceof w.Array&&a!==b);equal(a,[]);}}));
|
||||
for(const kind of ['audio','video'])await check(kind+' native graph and initial state',()=>withPC(pc=>{
|
||||
const t=pc.addTransceiver(kind);assert(t instanceof T&&t.sender instanceof S&&t.receiver instanceof R);assert(t.sender.track===null&&t.sender.transport===null&&t.receiver.transport===null);assert(t.mid===null&&t.currentDirection===null&&t.direction==='sendrecv'&&t.stopped===false);
|
||||
const track=t.receiver.track;assert(track instanceof w.MediaStreamTrack&&track.kind===kind&&track.enabled&&track.muted&&track.readyState==='live'&&typeof track.id==='string'&&track.id.length>0);
|
||||
assert(pc.getTransceivers()[0]===t&&pc.getSenders()[0]===t.sender&&pc.getReceivers()[0]===t.receiver);assert(t.sender===t.sender&&track===t.receiver.track);
|
||||
}));
|
||||
await check('insertion order and collection isolation',()=>withPC(pc=>{const a=pc.addTransceiver('audio'),b=pc.addTransceiver('audio'),c=pc.addTransceiver('video');const list=pc.getTransceivers();list.splice(0,3);equal(pc.getTransceivers().map(t=>t.receiver.track.kind),['audio','audio','video']);assert(a!==b&&a.receiver.track!==b.receiver.track&&a.receiver.track.id!==b.receiver.track.id&&pc.getTransceivers()[2]===c);}));
|
||||
await check('track union uses native identity before string coercion',()=>withPC(pc=>{const track=pc.addTransceiver('video').receiver.track;Object.defineProperty(track,'kind',{get(){throw Error('author kind getter');}});track.toString=()=>{throw Error('track coercion');};const a=pc.addTransceiver(track);assert(a.sender.track===track&&a.receiver.track!==track&&a.receiver.track.kind==='video');}));
|
||||
await check('author proxy is not a native track union',()=>withPC(pc=>{const real=pc.addTransceiver('audio').receiver.track;const proxy=new Proxy(real,{get(target,key){if(key===Symbol.toPrimitive)return()=> 'not-a-media-kind';throw Error('unexpected trap');}});raises(()=>pc.addTransceiver(proxy),w.TypeError);}));
|
||||
await check('full dictionary conversion precedes invalid kind',()=>withPC(pc=>{const reads=[];raises(()=>pc.addTransceiver('invalid',{get direction(){reads.push('direction');return 'sendrecv';},get sendEncodings(){reads.push('sendEncodings');return [];},get streams(){reads.push('streams');return [];}}),w.TypeError);equal(reads,['direction','sendEncodings','streams']);assert(pc.getTransceivers().length===0);}));
|
||||
await check('conversion getter exceptions retain identity',()=>withPC(pc=>{const sentinel={};try{pc.addTransceiver('audio',{get streams(){throw sentinel;}});assert(false);}catch(error){assert(error===sentinel);}assert(pc.getTransceivers().length===0);}));
|
||||
await check('required arguments and kinds',()=>withPC(pc=>{raises(()=>pc.addTransceiver(),w.TypeError);for(const kind of [undefined,null,'Audio','VIDEO','',42,Symbol()])raises(()=>pc.addTransceiver(kind),w.TypeError);}));
|
||||
await check('streams are converted by native brand',()=>withPC(pc=>{const stream=new w.MediaStream();pc.addTransceiver('audio',{streams:[stream,stream]});for(const value of [{},Object.create(stream),new Proxy(stream,{})])raises(()=>pc.addTransceiver('audio',{streams:[value]}),w.TypeError);}));
|
||||
await check('closed state after conversion and kind validation',()=>{const pc=new P();pc.close();const reads=[];raises(()=>pc.addTransceiver('audio',{get streams(){reads.push('streams');return [];}}),w.DOMException,'InvalidStateError');equal(reads,['streams']);raises(()=>pc.addTransceiver('invalid'),w.TypeError);raises(()=>pc.addTransceiver('audio',{sendEncodings:[{rid:'!'}]}),w.DOMException,'InvalidStateError');});
|
||||
for(const direction of ['sendrecv','sendonly','recvonly','inactive'])await check('direction '+direction,()=>withPC(pc=>{const t=pc.addTransceiver('audio',{direction});assert(t.direction===direction&&t.currentDirection===null);t.direction=direction;assert(t.direction===direction);t.direction='inactive';assert(t.direction==='inactive'&&t.currentDirection===null);}));
|
||||
await check('invalid direction setter leaves state intact',()=>withPC(pc=>{const t=pc.addTransceiver('audio');for(const value of ['invalid',null,undefined]){t.direction=value;assert(t.direction==='sendrecv');}for(const value of ['stopped',Symbol()]){raises(()=>{t.direction=value;},w.TypeError);assert(t.direction==='sendrecv');}}));
|
||||
await check('encoding dictionary ancestor and member order',()=>withPC(pc=>{const reads=[],encoding={};for(const [name,value] of [['rid','a'],['active',true],['codec',undefined],['maxBitrate',64000],['maxFramerate',30],['scaleResolutionDownBy',2]])Object.defineProperty(encoding,name,{get(){reads.push(name);return value;}});pc.addTransceiver('video',{sendEncodings:[encoding]});equal(reads,['rid','active','codec','maxBitrate','maxFramerate','scaleResolutionDownBy']);}));
|
||||
for(const kind of ['audio','video']) {
|
||||
for(const [name,encodings] of [['punctuation',[{rid:'a-b'}]],['empty',[{rid:''}]],['length',[{rid:'abcdefghijklmnopq'}]],['partial',[{rid:'a'},{}]],['duplicates',[{rid:'a'},{rid:'a'}]]])await check(kind+' RID validation '+name,()=>withPC(pc=>{raises(()=>pc.addTransceiver(kind,{sendEncodings:encodings}),w.TypeError);assert(pc.getTransceivers().length===0);}));
|
||||
await check(kind+' valid encodings',()=>withPC(pc=>{pc.addTransceiver(kind,{sendEncodings:[{rid:'A1',active:false,maxBitrate:1234},{rid:'b2',scaleResolutionDownBy:2}]});assert(pc.getTransceivers().length===1);}));
|
||||
}
|
||||
await check('audio discards video-only range constraints',()=>withPC(pc=>{pc.addTransceiver('audio',{sendEncodings:[{scaleResolutionDownBy:0,maxFramerate:-2}]});}));
|
||||
await check('finite WebIDL double conversion precedes audio discard',()=>withPC(pc=>{for(const key of ['scaleResolutionDownBy','maxFramerate'])for(const value of [Infinity,-Infinity,NaN])raises(()=>pc.addTransceiver('audio',{sendEncodings:[{[key]:value}]}),w.TypeError);}));
|
||||
await check('all video encodings validated before truncation',()=>withPC(pc=>{raises(()=>pc.addTransceiver('video',{sendEncodings:[{rid:'a'},{rid:'b'},{rid:'c'},{rid:'d',scaleResolutionDownBy:.5}]}),w.RangeError);assert(pc.getTransceivers().length===0);}));
|
||||
await check('video range errors',()=>withPC(pc=>{for(const encoding of [{scaleResolutionDownBy:0},{scaleResolutionDownBy:.5},{maxFramerate:-1}])raises(()=>pc.addTransceiver('video',{sendEncodings:[encoding]}),w.RangeError);}));
|
||||
for(const kind of ['audio','video'])await check(kind+' codec preferences and reset',()=>withPC(async pc=>{
|
||||
const t=pc.addTransceiver(kind);const caps=R.getCapabilities(kind).codecs;t.setCodecPreferences(caps);t.setCodecPreferences([]);
|
||||
const codec=caps.find(c=>kind==='audio'?c.mimeType==='audio/opus':c.mimeType==='video/VP8');t.setCodecPreferences([codec,codec]);const offer=await pc.createOffer();const lines=offer.sdp.split('\r\n').filter(l=>l.startsWith('a=rtpmap:'));assert(lines.length===1&&lines[0].includes(kind==='audio'?'opus':'VP8'));assert(t.mid===null&&t.currentDirection===null);
|
||||
}));
|
||||
await check('codec dictionary inherited property conversion order',()=>withPC(pc=>{const t=pc.addTransceiver('audio'),reads=[],codec=R.getCapabilities('audio').codecs[0],arg={};for(const name of ['channels','clockRate','mimeType','sdpFmtpLine'])Object.defineProperty(arg,name,{get(){reads.push(name);return codec[name];}});t.setCodecPreferences([arg]);equal(reads,['channels','clockRate','mimeType','sdpFmtpLine']);}));
|
||||
await check('codec iterable errors retain identity and previous snapshot',()=>withPC(async pc=>{const t=pc.addTransceiver('video'),vp8=R.getCapabilities('video').codecs.find(c=>c.mimeType==='video/VP8');t.setCodecPreferences([vp8]);const sentinel={};try{t.setCodecPreferences({[Symbol.iterator](){throw sentinel;}});assert(false);}catch(error){assert(error===sentinel);}assert((await pc.createOffer()).sdp.includes('VP8'));}));
|
||||
await check('unsupported codec errors',()=>withPC(pc=>{const t=pc.addTransceiver('audio'),codec=R.getCapabilities('audio').codecs[0];for(const changed of [{mimeType:'video/VP8'},{clockRate:1},{channels:3},{sdpFmtpLine:'unknown=1'}])raises(()=>t.setCodecPreferences([{...codec,...changed}]),w.DOMException,'InvalidModificationError');for(const value of [undefined,null,{},[{mimeType:'audio/opus'}]])raises(()=>t.setCodecPreferences(value),w.TypeError);}));
|
||||
await check('auxiliary-only codec list rejected',()=>withPC(pc=>{const t=pc.addTransceiver('video');for(const name of ['video/rtx','video/red','video/ulpfec'])raises(()=>t.setCodecPreferences(R.getCapabilities('video').codecs.filter(c=>c.mimeType===name)),w.DOMException,'InvalidModificationError');}));
|
||||
await check('codec inputs snapshotted without author getters during offer',()=>withPC(async pc=>{const t=pc.addTransceiver('video'),codec=R.getCapabilities('video').codecs.find(c=>c.mimeType==='video/VP8'),array=[codec];t.setCodecPreferences(array);array.length=0;Object.defineProperty(codec,'mimeType',{get(){throw Error('late getter');}});assert((await pc.createOffer()).sdp.includes('VP8'));}));
|
||||
await check('RTP getters and methods reject forged and author proxies',()=>withPC(pc=>{
|
||||
const t=pc.addTransceiver('audio');for(const [C,real,names] of [[P,pc,['getTransceivers','getSenders','getReceivers','addTransceiver']],[T,t,['mid','sender','receiver','direction','currentDirection','stop','setCodecPreferences']],[S,t.sender,['track','transport']],[R,t.receiver,['track','transport']]]) {
|
||||
for(const name of names){const descriptor=Object.getOwnPropertyDescriptor(C.prototype,name),f=descriptor.get??descriptor.value;for(const fake of [{},Object.create(C.prototype),Object.create(real),new Proxy(real,{})])raises(()=>f.call(fake),w.TypeError);}
|
||||
}
|
||||
}));
|
||||
await check('brand rejection before conversion',()=>withPC(pc=>{const t=pc.addTransceiver('audio');let reads=0;raises(()=>T.prototype.setCodecPreferences.call(new Proxy(t,{}),{[Symbol.iterator](){reads++;return [][Symbol.iterator]();}}),w.TypeError);raises(()=>P.prototype.addTransceiver.call({},'audio',{get direction(){reads++;return 'sendrecv';}}),w.TypeError);assert(reads===0);}));
|
||||
await check('stop leaves stopping transceiver in collections',()=>withPC(async pc=>{const a=pc.addTransceiver('audio'),v=pc.addTransceiver('video');a.stop();a.stop();assert(a.direction==='stopped'&&a.currentDirection===null&&a.stopped===true);assert(pc.getTransceivers()[0]===a&&pc.getSenders()[0]===a.sender&&pc.getReceivers()[0]===a.receiver);raises(()=>{a.direction='sendonly';},w.DOMException,'InvalidStateError');a.direction='invalid';assert(a.direction==='stopped');const sdp=(await pc.createOffer()).sdp;assert(!sdp.includes('m=audio')&&sdp.includes('m=video')&&v.direction==='sendrecv');}));
|
||||
await check('receiver ended is one trusted asynchronous event',()=>withPC(async pc=>{const t=pc.addTransceiver('audio'),track=t.receiver.track;let count=0,synchronous=true;const ended=new Promise(resolve=>{track.onended=e=>{count++;assert(!synchronous&&e.isTrusted&&e.target===track&&e instanceof w.Event&&track.readyState==='ended');resolve();};});t.stop();t.stop();assert(count===0);synchronous=false;await Promise.race([ended,new Promise((_,reject)=>setTimeout(()=>reject(Error('ended task timeout')),1000))]);assert(count===1&&track.readyState==='ended');}));
|
||||
await check('author track stop suppresses queued ended event',()=>withPC(async pc=>{const t=pc.addTransceiver('audio'),track=t.receiver.track;let events=0;track.onended=()=>events++;t.stop();track.stop();const barrier=pc.addTransceiver('video');const done=new Promise(resolve=>{barrier.receiver.track.onended=resolve;});barrier.stop();await done;assert(events===0&&track.readyState==='ended');}));
|
||||
await check('close stops transceivers and rejects stop after close',()=>{const pc=new P(),t=pc.addTransceiver('audio');pc.close();pc.close();assert(t.direction==='stopped'&&t.currentDirection==='stopped');assert(pc.getTransceivers()[0]===t&&pc.getSenders().length===0&&pc.getReceivers().length===0);raises(()=>t.stop(),w.DOMException,'InvalidStateError');t.setCodecPreferences([]);});
|
||||
await check('multiple media sections use direction and unique mids',()=>withPC(async pc=>{pc.addTransceiver('video',{direction:'sendonly'});pc.addTransceiver('audio',{direction:'inactive'});pc.addTransceiver('video',{direction:'recvonly'});pc.createDataChannel('data');const sdp=(await pc.createOffer()).sdp,sections=sdp.split('m=').slice(1),mids=sections.map(s=>s.match(/a=mid:(\S+)/)[1]);assert(sections.length===4&&new Set(mids).size===4&&sdp.includes('a=group:BUNDLE '+mids.join(' ')));assert(sections[0].includes('a=sendonly')&§ions[1].includes('a=inactive')&§ions[2].includes('a=recvonly'));}));
|
||||
await check('negotiationneeded task coalesces same-turn changes',()=>withPC(async pc=>{let count=0;const event=new Promise(resolve=>{pc.onnegotiationneeded=e=>{count++;assert(e.isTrusted&&e instanceof w.Event);resolve();};});pc.addTransceiver('audio').direction='sendonly';pc.addTransceiver('video');await Promise.race([event,new Promise((_,reject)=>setTimeout(()=>reject(Error('negotiation task timeout')),1000))]);assert(count===1);}));
|
||||
await check('closed peer suppresses queued negotiation notification',async()=>{const pc=new P();let count=0;pc.onnegotiationneeded=()=>count++;pc.addTransceiver('audio');pc.close();const barrier=new P();const t=barrier.addTransceiver('audio');const done=new Promise(resolve=>{t.receiver.track.onended=resolve;});t.stop();await done;barrier.close();assert(count===0);});
|
||||
}
|
||||
globalThis.__uiEventResults={complete:true,total:checks.length,passed:checks.filter(row=>row.passed).length,checks};
|
||||
return checks.every(row=>row.passed);
|
||||
})()
|
||||
@@ -13,10 +13,11 @@ use moli_webidl::{self as webidl, WebIdlDictionarySerialize};
|
||||
pub mod certificate;
|
||||
mod configuration;
|
||||
mod peer_options;
|
||||
mod rtp_capabilities;
|
||||
pub mod rtp_capabilities;
|
||||
pub mod rtp_transceivers;
|
||||
|
||||
const RTC_PEER_CONNECTION_CONFIGURATION_SLOT: &str = "__moliRtcPeerConnectionConfiguration";
|
||||
const RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT: &str = "__moliRtcPeerConnectionSignalingState";
|
||||
pub const RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT: &str = "__moliRtcPeerConnectionSignalingState";
|
||||
const RTC_PEER_CONNECTION_ICE_GATHERING_STATE_SLOT: &str =
|
||||
"__moliRtcPeerConnectionIceGatheringState";
|
||||
const RTC_PEER_CONNECTION_ICE_CONNECTION_STATE_SLOT: &str =
|
||||
@@ -87,6 +88,8 @@ struct RtcPeerConnectionObjectDeclaration<'scope> {
|
||||
pending_local_description: (),
|
||||
#[webapi(slot = RTC_PEER_CONNECTION_HAS_DATA_CHANNEL_SLOT, init = false)]
|
||||
has_data_channel: (),
|
||||
#[webapi(slot = rtp_transceivers::NEGOTIATION_HANDLER, init = "null")]
|
||||
onnegotiationneeded: (),
|
||||
#[webapi(slot = SIMPLE_EVENT_TARGET_LISTENERS_SLOT, init = "null_object")]
|
||||
event_listeners: (),
|
||||
}
|
||||
@@ -213,12 +216,14 @@ pub fn rtc_peer_connection_constructor_callback<'s>(
|
||||
current_local_description: (),
|
||||
pending_local_description: (),
|
||||
has_data_channel: (),
|
||||
onnegotiationneeded: (),
|
||||
event_listeners: (),
|
||||
};
|
||||
if declaration.initialize(scope, args.this()).is_err() {
|
||||
rv.set_undefined();
|
||||
return;
|
||||
}
|
||||
rtp_transceivers::initialize_pc(scope, args.this());
|
||||
rv.set(args.this().into());
|
||||
}
|
||||
|
||||
@@ -334,9 +339,10 @@ fn rtc_peer_connection_create_offer_callback<'s>(
|
||||
RTC_PEER_CONNECTION_HAS_DATA_CHANNEL_SLOT,
|
||||
)
|
||||
.is_some_and(|value| value.boolean_value(scope));
|
||||
let mut sdp = build_signaling_only_offer(audio == 1, video == 1, data);
|
||||
let target = moli_webapi_declare::web_api_object_target(scope, args.this())
|
||||
.expect("RTCPeerConnection receiver");
|
||||
let mut sdp = rtp_transceivers::create_offer(scope, target, data)
|
||||
.unwrap_or_else(|| build_signaling_only_offer(audio == 1, video == 1, data));
|
||||
let config = configuration::configuration(scope, target);
|
||||
// Fingerprints are session-level attributes and therefore cover every
|
||||
// bundled media section. Author-visible certificate getters are not read.
|
||||
@@ -414,6 +420,9 @@ fn rtc_peer_connection_close_callback<'s>(
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let target = moli_webapi_declare::web_api_object_target(scope, args.this())
|
||||
.expect("RTCPeerConnection receiver");
|
||||
rtp_transceivers::close(scope, target);
|
||||
for (slot, state) in [
|
||||
(RTC_PEER_CONNECTION_SIGNALING_STATE_SLOT, "closed"),
|
||||
(RTC_PEER_CONNECTION_ICE_CONNECTION_STATE_SLOT, "closed"),
|
||||
@@ -514,7 +523,7 @@ fn build_signaling_only_offer(audio: bool, video: bool, data: bool) -> String {
|
||||
sdp
|
||||
}
|
||||
|
||||
const RTC_AUDIO_OFFER_SECTION: &str = concat!(
|
||||
pub const RTC_AUDIO_OFFER_SECTION: &str = concat!(
|
||||
"m=audio 9 UDP/TLS/RTP/SAVPF 111 63 9 0 8 13 110 126\r\n",
|
||||
"c=IN IP4 0.0.0.0\r\na=mid:0\r\na=recvonly\r\na=rtcp-mux\r\na=rtcp-rsize\r\n",
|
||||
"a=rtpmap:111 opus/48000/2\r\na=fmtp:111 minptime=10;useinbandfec=1\r\n",
|
||||
@@ -524,7 +533,7 @@ const RTC_AUDIO_OFFER_SECTION: &str = concat!(
|
||||
"a=rtpmap:126 telephone-event/8000\r\n"
|
||||
);
|
||||
|
||||
const RTC_VIDEO_OFFER_SECTION: &str = concat!(
|
||||
pub const RTC_VIDEO_OFFER_SECTION: &str = concat!(
|
||||
"m=video 9 UDP/TLS/RTP/SAVPF 96 97 98 99 100 101 35 36 37 38 103 104 107 108 109 114 115 116 117 118 39 40 41 42 43 44 45 46 47 48 119 120 121 49\r\n",
|
||||
"c=IN IP4 0.0.0.0\r\na=mid:1\r\na=recvonly\r\na=rtcp-mux\r\na=rtcp-rsize\r\n",
|
||||
"a=rtpmap:96 VP8/90000\r\na=rtpmap:97 rtx/90000\r\na=fmtp:97 apt=96\r\n",
|
||||
@@ -561,7 +570,7 @@ const RTC_VIDEO_OFFER_SECTION: &str = concat!(
|
||||
"a=fmtp:49 repair-window=10000000\r\n"
|
||||
);
|
||||
|
||||
const RTC_DATA_OFFER_SECTION: &str = concat!(
|
||||
pub const RTC_DATA_OFFER_SECTION: &str = concat!(
|
||||
"m=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\n",
|
||||
"c=IN IP4 0.0.0.0\r\na=mid:2\r\na=sctp-port:5000\r\na=max-message-size:262144\r\n"
|
||||
);
|
||||
|
||||
@@ -61,6 +61,14 @@ fn get_capabilities<'s>(
|
||||
}
|
||||
}
|
||||
|
||||
pub fn capabilities_json(kind: &str) -> &'static str {
|
||||
match kind {
|
||||
"audio" => RTC_AUDIO_CAPABILITIES_JSON,
|
||||
"video" => RTC_VIDEO_CAPABILITIES_JSON,
|
||||
_ => unreachable!("validated RTP kind"),
|
||||
}
|
||||
}
|
||||
|
||||
// Compatibility tables shared with the existing receiver surface. These do not
|
||||
// represent a native codec negotiation or media encoding backend.
|
||||
const RTC_AUDIO_CAPABILITIES_JSON: &str = r#"{
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
//! Hooks for host-owned RTP objects associated with a peer connection.
|
||||
|
||||
pub const NEGOTIATION_HANDLER: &str = "__moliRtcOnNegotiationNeeded";
|
||||
|
||||
pub type ConnectionOperation = for<'s, 'p> fn(
|
||||
&mut v8::PinScope<'s, 'p>,
|
||||
v8::Local<'s, v8::Object>,
|
||||
);
|
||||
pub type CreateOffer = for<'s, 'p> fn(
|
||||
&mut v8::PinScope<'s, 'p>,
|
||||
v8::Local<'s, v8::Object>,
|
||||
bool,
|
||||
) -> Option<String>;
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
pub struct RtpRuntime {
|
||||
pub initialize_pc: ConnectionOperation,
|
||||
pub close: ConnectionOperation,
|
||||
pub create_offer: CreateOffer,
|
||||
}
|
||||
|
||||
pub fn install_runtime(scope: &mut v8::PinScope<'_, '_>, runtime: RtpRuntime) {
|
||||
scope.get_current_context().set_slot(runtime.into());
|
||||
}
|
||||
|
||||
fn runtime(scope: &mut v8::PinScope<'_, '_>) -> RtpRuntime {
|
||||
*scope.get_current_context().get_slot::<RtpRuntime>()
|
||||
.expect("install the RTP runtime before invoking RTC bindings")
|
||||
}
|
||||
|
||||
pub(super) fn initialize_pc<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
pc: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
(runtime(scope).initialize_pc)(scope, pc);
|
||||
}
|
||||
|
||||
pub(super) fn close<'s>(scope: &mut v8::PinScope<'s, '_>, pc: v8::Local<'s, v8::Object>) {
|
||||
(runtime(scope).close)(scope, pc);
|
||||
}
|
||||
|
||||
pub(super) fn create_offer<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
pc: v8::Local<'s, v8::Object>,
|
||||
data: bool,
|
||||
) -> Option<String> {
|
||||
(runtime(scope).create_offer)(scope, pc, data)
|
||||
}
|
||||
Reference in New Issue
Block a user