mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
feat(webtransport): connect native Window and worker streams
This commit is contained in:
Generated
+1
@@ -3744,6 +3744,7 @@ dependencies = [
|
||||
"moli-webidl-callback",
|
||||
"moli-webmcp",
|
||||
"moli-websocket",
|
||||
"moli-webtransport",
|
||||
"moli-window-features",
|
||||
"moli-xpath",
|
||||
"num-bigint",
|
||||
|
||||
@@ -111,6 +111,7 @@ moli-webidl = { path = "../moli-webidl" }
|
||||
moli-webidl-callback = { path = "../moli-webidl-callback" }
|
||||
moli-webmcp = { path = "../moli-webmcp" }
|
||||
moli-window-features = { path = "../moli-window-features" }
|
||||
moli-webtransport = { path = "../moli-webtransport" }
|
||||
moli-websocket = { path = "../moli-websocket" }
|
||||
moli-xpath = { path = "../moli-xpath" }
|
||||
curl = { version = "0.4.51", default-features = false, features = ["brotli", "http2", "poll_7_68_0", "ssl", "static-curl"] }
|
||||
|
||||
@@ -295,7 +295,7 @@ mod rtc_rtp;
|
||||
pub(crate) use rtc_rtp::rtp_transceivers::apply_task as apply_webrtc_task;
|
||||
pub(crate) use rtc_rtp::script_transform::run_worker_task as run_rtp_transform_worker_task;
|
||||
mod websocket;
|
||||
mod webtransport;
|
||||
pub(crate) mod webtransport;
|
||||
mod window_accessors;
|
||||
pub(crate) use window_accessors::{
|
||||
window_closed_value, window_frames_value, window_length_value, window_opener_value,
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
//! Native WebTransport frontend. The initial streams, WebIDL conversion and
|
||||
//! failure lifecycle are real; no HTTP/3 or HTTP/2 session backend is available.
|
||||
//! Native WebTransport frontend backed by browser-owned HTTP/3 sessions.
|
||||
//! WebIDL, streams and networking completions retain their exact Window/worker
|
||||
//! owner; resource retirement cancels transport independently from V8 handles.
|
||||
|
||||
use crate::{
|
||||
util::{
|
||||
@@ -10,8 +11,12 @@ use crate::{
|
||||
};
|
||||
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject, web_api_object_target};
|
||||
|
||||
pub(crate) mod backend;
|
||||
mod datagrams;
|
||||
mod incoming_datagrams;
|
||||
pub(crate) mod networking;
|
||||
mod schema;
|
||||
mod streams;
|
||||
mod tasks;
|
||||
|
||||
const STATE: &str = "__moliWebTransportState";
|
||||
@@ -86,11 +91,11 @@ struct Prototype {
|
||||
close: (),
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, DATAGRAMS))]
|
||||
datagrams: (),
|
||||
#[webapi(method, returns_promise, length = 0, callback = create_stream)]
|
||||
#[webapi(method, returns_promise, length = 0, callback = create_bidirectional_stream)]
|
||||
create_bidirectional_stream: (),
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, INCOMING_BIDI))]
|
||||
incoming_bidirectional_streams: (),
|
||||
#[webapi(method, returns_promise, length = 0, callback = create_stream)]
|
||||
#[webapi(method, returns_promise, length = 0, callback = create_unidirectional_stream)]
|
||||
create_unidirectional_stream: (),
|
||||
#[webapi(accessor_property, getter = slot_getter, data = v8str(scope, INCOMING_UNI))]
|
||||
incoming_unidirectional_streams: (),
|
||||
@@ -205,16 +210,22 @@ pub(super) fn constructor<'s>(
|
||||
return;
|
||||
}
|
||||
}
|
||||
if !options.headers.validate(scope) {
|
||||
let Some(headers) = options.headers.into_entries(scope) else {
|
||||
return;
|
||||
}
|
||||
};
|
||||
let csp_error = connection_csp_error(scope, &url);
|
||||
let ready = v8::PromiseResolver::new(scope).expect("WebTransport ready promise");
|
||||
let closed = v8::PromiseResolver::new(scope).expect("WebTransport closed promise");
|
||||
let draining = v8::PromiseResolver::new(scope).expect("WebTransport draining promise");
|
||||
let incoming_bidi = super::stream_adapter::new_readable_stream_object(scope, None, 0.0, None);
|
||||
let incoming_uni = super::stream_adapter::new_readable_stream_object(scope, None, 0.0, None);
|
||||
let datagrams = datagrams::build(scope, owner, options.datagrams_readable_type.is_some());
|
||||
let ready_promise = ready.get_promise(scope);
|
||||
let incoming_bidi = streams::incoming(scope, owner, ready_promise, true);
|
||||
let incoming_uni = streams::incoming(scope, owner, ready_promise, false);
|
||||
let datagrams = datagrams::build(
|
||||
scope,
|
||||
owner,
|
||||
ready_promise,
|
||||
options.datagrams_readable_type.is_some(),
|
||||
);
|
||||
let limit_bidi = nullable_limit(
|
||||
scope,
|
||||
options.anticipated_concurrent_incoming_bidirectional_streams,
|
||||
@@ -242,7 +253,23 @@ pub(super) fn constructor<'s>(
|
||||
// violation events still use the owning context's queued task source.
|
||||
tasks::fail(scope, owner, &message);
|
||||
} else {
|
||||
tasks::queue_connection_failure(scope, owner);
|
||||
let certificate_hashes = options
|
||||
.server_certificate_hashes
|
||||
.into_iter()
|
||||
.map(|hash| moli_webtransport::CertificateHash {
|
||||
algorithm: String::from_utf16_lossy(&hash.algorithm.0),
|
||||
value: hash.value.to_vec(scope),
|
||||
})
|
||||
.collect();
|
||||
backend::connect(
|
||||
scope,
|
||||
owner,
|
||||
url,
|
||||
headers,
|
||||
options.protocols,
|
||||
options.congestion_control,
|
||||
certificate_hashes,
|
||||
);
|
||||
}
|
||||
rv.set(owner.into());
|
||||
}
|
||||
@@ -339,24 +366,28 @@ fn set_limit<'s>(
|
||||
|
||||
fn reliability<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
_args: v8::FunctionCallbackArguments<'s>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
rv.set(v8str(scope, "pending").into());
|
||||
let owner = target(scope, args.this());
|
||||
let value = backend::reliability(scope, owner);
|
||||
rv.set(v8str(scope, value).into());
|
||||
}
|
||||
fn congestion_control<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
_args: v8::FunctionCallbackArguments<'s>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
rv.set(v8str(scope, "default").into());
|
||||
let owner = target(scope, args.this());
|
||||
rv.set(backend::congestion(scope, owner));
|
||||
}
|
||||
fn protocol<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
_args: v8::FunctionCallbackArguments<'s>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
rv.set(v8str(scope, "").into());
|
||||
let owner = target(scope, args.this());
|
||||
rv.set(backend::protocol(scope, owner));
|
||||
}
|
||||
fn response_headers<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
@@ -378,17 +409,11 @@ fn close<'s>(
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let Some(_converted) = webidl::parse_args::<schema::CloseArgs>(scope, &args) else {
|
||||
let Some(converted) = webidl::parse_args::<schema::CloseArgs>(scope, &args) else {
|
||||
return;
|
||||
};
|
||||
let receiver = target(scope, args.this());
|
||||
if connecting(scope, receiver) {
|
||||
tasks::fail(
|
||||
scope,
|
||||
receiver,
|
||||
"WebTransport was closed before connecting.",
|
||||
);
|
||||
}
|
||||
backend::close(scope, receiver, converted.close_info);
|
||||
}
|
||||
|
||||
fn get_stats<'s>(
|
||||
@@ -431,10 +456,26 @@ fn same_group<'s>(
|
||||
})
|
||||
}
|
||||
|
||||
fn create_bidirectional_stream<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
create_stream(scope, args, rv, true);
|
||||
}
|
||||
fn create_unidirectional_stream<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
create_stream(scope, args, rv, false);
|
||||
}
|
||||
|
||||
fn create_stream<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
bidi: bool,
|
||||
) {
|
||||
let Some(parsed) = webidl::parse_args::<schema::CreateStreamArgs>(scope, &args) else {
|
||||
return;
|
||||
@@ -444,7 +485,7 @@ fn create_stream<'s>(
|
||||
throw_type_error(scope, "The send group belongs to another WebTransport.");
|
||||
return;
|
||||
}
|
||||
tasks::wait_for_connection(scope, owner, rv);
|
||||
streams::open(scope, owner, bidi, rv);
|
||||
}
|
||||
|
||||
fn create_send_group<'s>(
|
||||
@@ -453,7 +494,7 @@ fn create_send_group<'s>(
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let owner = target(scope, args.this());
|
||||
if !connecting(scope, owner) {
|
||||
if !connecting(scope, owner) && backend::connection(scope, owner).is_none() {
|
||||
invalid_state(scope);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,450 @@
|
||||
//! Native session state stays with its branded wrapper. Resource authority
|
||||
//! cancels QUIC on Document/worker retirement, independently from V8 GC.
|
||||
|
||||
use std::{
|
||||
cell::{Cell, RefCell},
|
||||
rc::Rc,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use moli_webtransport::{CloseInfo, CloseReason, ConnectOptions, Session};
|
||||
|
||||
use super::{
|
||||
networking::{self, Completion},
|
||||
*,
|
||||
};
|
||||
use crate::{
|
||||
network::{RendererResourceTaskRunner, loads::ResourceLoadLease},
|
||||
util::{get_private_value, set_private_value, v8str},
|
||||
};
|
||||
|
||||
const NATIVE: &str = "__moliWebTransportNativeState";
|
||||
const PROTOCOL: &str = "__moliWebTransportProtocol";
|
||||
const CONGESTION: &str = "__moliWebTransportCongestion";
|
||||
|
||||
pub(crate) struct ConnectionContext {
|
||||
pub(crate) runner: RendererResourceTaskRunner,
|
||||
pub(crate) connector: moli_fetch::WebTransportConnector,
|
||||
pub(crate) lease: ResourceLoadLease,
|
||||
pub(crate) origin: String,
|
||||
pub(crate) blocked: bool,
|
||||
}
|
||||
|
||||
struct NativeState {
|
||||
runner: RendererResourceTaskRunner,
|
||||
lease: ResourceLoadLease,
|
||||
session: RefCell<Option<Session>>,
|
||||
streams: RefCell<Vec<v8::Weak<v8::Object>>>,
|
||||
incoming: RefCell<Option<Arc<incoming_datagrams::Incoming>>>,
|
||||
ingress: RefCell<Option<tokio::task::AbortHandle>>,
|
||||
graceful_close: Cell<bool>,
|
||||
}
|
||||
|
||||
impl NativeState {
|
||||
fn stop_ingress(&self) {
|
||||
if let Some(incoming) = self.incoming.borrow().as_ref() {
|
||||
incoming.finish("The WebTransport session is closed.".to_owned());
|
||||
}
|
||||
if let Some(ingress) = self.ingress.borrow_mut().take() {
|
||||
ingress.abort();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for NativeState {
|
||||
fn drop(&mut self) {
|
||||
self.stop_ingress();
|
||||
// A graceful close capsule retains the native session until it is
|
||||
// sent. Context retirement remains authoritative through the lease.
|
||||
if !self.graceful_close.get() {
|
||||
self.lease.cancel();
|
||||
}
|
||||
self.lease.finish();
|
||||
}
|
||||
}
|
||||
|
||||
fn state<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> Option<Rc<NativeState>> {
|
||||
let value = get_private_value(scope, owner, NATIVE)?;
|
||||
let external = v8::Local::<v8::External>::try_from(value).ok()?;
|
||||
// SAFETY: only initialize installs this private slot on a branded native
|
||||
// receiver. The context-owned finalizer retains its boxed Rc through GC.
|
||||
Some(unsafe { &*external.value().cast::<Rc<NativeState>>() }.clone())
|
||||
}
|
||||
|
||||
fn initialize<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
context: &ConnectionContext,
|
||||
) {
|
||||
let mut state = Box::new(Rc::new(NativeState {
|
||||
runner: context.runner.clone(),
|
||||
lease: context.lease.clone(),
|
||||
session: RefCell::new(None),
|
||||
streams: RefCell::new(Vec::new()),
|
||||
incoming: RefCell::new(None),
|
||||
ingress: RefCell::new(None),
|
||||
graceful_close: Cell::new(false),
|
||||
}));
|
||||
let pointer = (&mut *state as *mut Rc<NativeState>).cast();
|
||||
let external = v8::External::new(scope, pointer);
|
||||
set_private_value(scope, owner, NATIVE, external.into());
|
||||
crate::v8_finalizer::track_context_owned_v8_finalizer(scope, owner, move || drop(state));
|
||||
}
|
||||
|
||||
pub(super) fn connect<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
url: url::Url,
|
||||
headers: Vec<(String, String)>,
|
||||
protocols: Vec<webidl::DomString16>,
|
||||
congestion: schema::CongestionControl,
|
||||
certificate_hashes: Vec<moli_webtransport::CertificateHash>,
|
||||
) {
|
||||
if url.port() == Some(0) {
|
||||
tasks::queue_connection_failure(scope, owner, "WebTransport cannot connect to port 0.");
|
||||
return;
|
||||
}
|
||||
let context = if let Some(host) = context_host_ptr_from_global_bridge(scope) {
|
||||
// SAFETY: this realm's bridge owns the isolate-local host.
|
||||
unsafe { &*host }.webtransport_connection_context(scope, &url)
|
||||
} else {
|
||||
crate::worker::webtransport_tasks::connection_context(scope, &url)
|
||||
};
|
||||
let Some(context) = context else {
|
||||
tasks::queue_connection_failure(
|
||||
scope,
|
||||
owner,
|
||||
"No WebTransport session backend is available.",
|
||||
);
|
||||
return;
|
||||
};
|
||||
let Some(producer) = networking::register(scope, owner, owner) else {
|
||||
tasks::queue_connection_failure(
|
||||
scope,
|
||||
owner,
|
||||
"No WebTransport session task route is available.",
|
||||
);
|
||||
return;
|
||||
};
|
||||
initialize(scope, owner, &context);
|
||||
let congestion_name = match congestion {
|
||||
schema::CongestionControl::Default => "default",
|
||||
schema::CongestionControl::Throughput => "throughput",
|
||||
schema::CongestionControl::LowLatency => "low-latency",
|
||||
};
|
||||
let value = v8str(scope, congestion_name);
|
||||
set_private_value(scope, owner, CONGESTION, value.into());
|
||||
let mut options = ConnectOptions::new(url, context.origin);
|
||||
options.server_certificate_hashes = certificate_hashes;
|
||||
options.protocols = protocols
|
||||
.into_iter()
|
||||
.map(|p| String::from_utf16(&p.0).expect("validated ASCII protocol"))
|
||||
.collect();
|
||||
options.congestion_control = match congestion {
|
||||
schema::CongestionControl::Default => moli_webtransport::CongestionControl::Default,
|
||||
schema::CongestionControl::Throughput => moli_webtransport::CongestionControl::Throughput,
|
||||
schema::CongestionControl::LowLatency => moli_webtransport::CongestionControl::LowLatency,
|
||||
};
|
||||
for (name, value) in headers {
|
||||
let bytes: Vec<_> = value.chars().map(|value| value as u8).collect();
|
||||
let Ok(value) = http::HeaderValue::from_bytes(&bytes) else {
|
||||
producer.send(Completion::Connected(Err(
|
||||
"WebTransport header cannot be sent over HTTP/3.".to_owned(),
|
||||
)));
|
||||
return;
|
||||
};
|
||||
options.headers.append(
|
||||
http::HeaderName::from_bytes(name.as_bytes()).expect("validated header name"),
|
||||
value,
|
||||
);
|
||||
}
|
||||
let lease = context.lease;
|
||||
let task_lease = lease.clone();
|
||||
// Register cancellation before polling the handshake: immediate failure or
|
||||
// a fast local server must not race the handoff to session cancellation.
|
||||
let (start_tx, start_rx) = tokio::sync::oneshot::channel();
|
||||
let handle = context.runner.spawn_abortable(async move {
|
||||
if start_rx.await.is_err() {
|
||||
return;
|
||||
}
|
||||
let result = if context.blocked {
|
||||
Err("WebTransport request blocked by network policy.".to_owned())
|
||||
} else {
|
||||
context
|
||||
.connector
|
||||
.connect(options)
|
||||
.await
|
||||
.map_err(|error| format!("{error:#}"))
|
||||
};
|
||||
task_lease.release_consumer_cancel();
|
||||
if let Ok(session) = &result {
|
||||
let session = session.clone();
|
||||
task_lease.attach_consumer_cancel(move || session.cancel());
|
||||
}
|
||||
producer.send(Completion::Connected(result));
|
||||
});
|
||||
lease.attach_consumer_cancel(move || handle.abort());
|
||||
let _ = start_tx.send(());
|
||||
}
|
||||
|
||||
pub(crate) fn apply<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
result: Completion,
|
||||
) {
|
||||
let context = payload
|
||||
.get_creation_context(scope)
|
||||
.expect("WebTransport completion realm");
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
let owner = crate::util::get_private_object(scope, payload, OWNER).unwrap_or(payload);
|
||||
let Some(native) = state(scope, owner) else {
|
||||
return;
|
||||
};
|
||||
// Exact owner authorization already discarded retired Documents/workers.
|
||||
// A failed live session still has in-flight sink promises to settle.
|
||||
match result {
|
||||
Completion::Stream(result) => streams::apply(scope, owner, payload, result),
|
||||
Completion::Datagram(result) => datagrams::complete(scope, owner, payload, result),
|
||||
Completion::Connected(Err(message)) => {
|
||||
if connecting(scope, owner) {
|
||||
native.lease.finish();
|
||||
tasks::fail(scope, owner, &message);
|
||||
}
|
||||
}
|
||||
Completion::Connected(Ok(session)) => {
|
||||
if !connecting(scope, owner) {
|
||||
return;
|
||||
}
|
||||
let protocol = v8::String::new(scope, session.protocol().unwrap_or(""))
|
||||
.expect("negotiated protocol");
|
||||
set_private_value(scope, owner, PROTOCOL, protocol.into());
|
||||
*native.session.borrow_mut() = Some(session.clone());
|
||||
let (maximum, age) = datagrams::incoming_policy(scope, owner);
|
||||
let incoming = Arc::new(incoming_datagrams::Incoming::new(maximum, age));
|
||||
*native.incoming.borrow_mut() = Some(incoming.clone());
|
||||
let receiver = session.clone();
|
||||
let ingress = native.runner.spawn_abortable(async move {
|
||||
loop {
|
||||
match receiver.read_datagram().await {
|
||||
Ok(datagram) => incoming.push(datagram),
|
||||
Err(error) => {
|
||||
incoming.finish(error.to_string());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
*native.ingress.borrow_mut() = Some(ingress.abort_handle());
|
||||
let connected = v8str(scope, "connected");
|
||||
set_private_value(scope, owner, STATE, connected.into());
|
||||
if let Some(producer) = networking::register(scope, owner, owner) {
|
||||
native.runner.spawn(async move {
|
||||
producer.send(Completion::Closed(session.closed().await));
|
||||
});
|
||||
}
|
||||
let maximum_size = session_size(scope, owner);
|
||||
datagrams::connected(scope, owner, maximum_size);
|
||||
if connection(scope, owner).is_none() {
|
||||
return;
|
||||
}
|
||||
let pending = tasks::array(scope, owner, PENDING);
|
||||
let values: Vec<_> = (0..pending.length())
|
||||
.map(|index| pending.get_index(scope, index).expect("pending operation"))
|
||||
.collect();
|
||||
let empty = v8::Array::new(scope, 0);
|
||||
set_private_value(scope, owner, PENDING, empty.into());
|
||||
for value in values {
|
||||
let payload =
|
||||
v8::Local::<v8::Object>::try_from(value).expect("pending operation object");
|
||||
if get_private_value(scope, payload, streams::RESOLVER).is_some() {
|
||||
streams::open_pending(scope, owner, payload);
|
||||
} else {
|
||||
tasks::queue_unsupported(scope, owner, value);
|
||||
}
|
||||
}
|
||||
let ready = tasks::resolver(
|
||||
get_private_value(scope, owner, READY_RESOLVER).expect("ready resolver"),
|
||||
);
|
||||
let undefined = v8::undefined(scope);
|
||||
ready.resolve(scope, undefined.into());
|
||||
}
|
||||
Completion::Closed(CloseReason::Local(info) | CloseReason::Remote(info)) => {
|
||||
native.graceful_close.set(true);
|
||||
native.stop_ingress();
|
||||
native.lease.finish();
|
||||
let value = v8str(scope, "closed");
|
||||
set_private_value(scope, owner, STATE, value.into());
|
||||
let error = super::super::build_web_transport_error(
|
||||
scope,
|
||||
&super::super::WebTransportErrorClonePayload {
|
||||
message: "The WebTransport session is closed."
|
||||
.encode_utf16()
|
||||
.collect(),
|
||||
source: super::super::WebTransportErrorSource::Session,
|
||||
stream_error_code: None,
|
||||
},
|
||||
)
|
||||
.expect("closed session error");
|
||||
error_streams(scope, owner, error.into());
|
||||
let incoming_bidi = object(scope, owner, INCOMING_BIDI);
|
||||
let incoming_uni = object(scope, owner, INCOMING_UNI);
|
||||
super::super::stream_adapter::close_stream(scope, incoming_bidi);
|
||||
super::super::stream_adapter::close_stream(scope, incoming_uni);
|
||||
let duplex = object(scope, owner, DATAGRAMS);
|
||||
datagrams::finish_close(scope, duplex, error.into());
|
||||
let result = v8::Object::new(scope);
|
||||
let key = v8str(scope, "closeCode");
|
||||
let code = v8::Integer::new_from_unsigned(scope, info.code);
|
||||
result.create_data_property(scope, key.into(), code.into());
|
||||
let key = v8str(scope, "reason");
|
||||
let reason = v8::String::new(scope, &info.reason).expect("close reason");
|
||||
result.create_data_property(scope, key.into(), reason.into());
|
||||
let closed = tasks::resolver(
|
||||
get_private_value(scope, owner, CLOSED_RESOLVER).expect("closed resolver"),
|
||||
);
|
||||
closed.resolve(scope, result.into());
|
||||
}
|
||||
Completion::Closed(CloseReason::Failed(error)) => {
|
||||
native.lease.finish();
|
||||
tasks::fail(scope, owner, &error.to_string());
|
||||
}
|
||||
Completion::Closed(CloseReason::OwnerRetired) => {}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn close<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
info: schema::CloseInfo,
|
||||
) {
|
||||
let native = state(scope, owner);
|
||||
if connecting(scope, owner) {
|
||||
if let Some(native) = native {
|
||||
native.lease.cancel();
|
||||
}
|
||||
tasks::fail(scope, owner, "WebTransport was closed before connecting.");
|
||||
} else if let Some(native) = native {
|
||||
let session = native.session.borrow().clone();
|
||||
if let Some(session) = session {
|
||||
native.graceful_close.set(true);
|
||||
let closed = v8str(scope, "closed");
|
||||
set_private_value(scope, owner, STATE, closed.into());
|
||||
session.close(CloseInfo {
|
||||
code: info.close_code,
|
||||
reason: info.reason,
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn reliability<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> &'static str {
|
||||
if state(scope, owner).is_some_and(|state| state.session.borrow().is_some()) {
|
||||
"supports-unreliable"
|
||||
} else {
|
||||
"pending"
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn protocol<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> v8::Local<'s, v8::Value> {
|
||||
get_private_value(scope, owner, PROTOCOL).unwrap_or_else(|| v8str(scope, "").into())
|
||||
}
|
||||
|
||||
pub(super) fn congestion<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> v8::Local<'s, v8::Value> {
|
||||
get_private_value(scope, owner, CONGESTION).unwrap_or_else(|| v8str(scope, "default").into())
|
||||
}
|
||||
|
||||
pub(super) fn connection<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> Option<(Session, RendererResourceTaskRunner)> {
|
||||
if get_private_value(scope, owner, STATE)?.to_rust_string_lossy(scope) != "connected" {
|
||||
return None;
|
||||
}
|
||||
let native = state(scope, owner)?;
|
||||
if native.lease.is_cancelled() {
|
||||
return None;
|
||||
}
|
||||
let session = native.session.borrow().clone()?;
|
||||
Some((session, native.runner.clone()))
|
||||
}
|
||||
|
||||
pub(super) fn session_size<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> usize {
|
||||
connection(scope, owner).map_or(65535, |(session, _)| session.max_datagram_size())
|
||||
}
|
||||
|
||||
pub(super) fn incoming<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> Option<Arc<incoming_datagrams::Incoming>> {
|
||||
state(scope, owner)?.incoming.borrow().clone()
|
||||
}
|
||||
|
||||
pub(super) fn configure_incoming<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
if let Some(incoming) = incoming(scope, owner) {
|
||||
let (maximum, age) = datagrams::incoming_policy(scope, owner);
|
||||
incoming.configure(maximum, age);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn remember_stream<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
stream: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
if let Some(native) = state(scope, owner) {
|
||||
let weak = v8::Weak::new(scope, stream);
|
||||
let mut streams = native.streams.borrow_mut();
|
||||
if streams.len().is_multiple_of(64) {
|
||||
streams.retain(|stream| !stream.is_empty());
|
||||
}
|
||||
streams.push(weak);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn error_streams<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
error: v8::Local<'s, v8::Value>,
|
||||
) {
|
||||
let Some(native) = state(scope, owner) else {
|
||||
return;
|
||||
};
|
||||
let endpoints = std::mem::take(&mut *native.streams.borrow_mut());
|
||||
let endpoints: Vec<_> = endpoints
|
||||
.into_iter()
|
||||
.filter_map(|weak| weak.to_local(scope))
|
||||
.collect();
|
||||
for endpoint in endpoints {
|
||||
if web_api_interfaces::ReadableStream::is_instance(scope, endpoint) {
|
||||
super::super::stream_adapter::error_stream(scope, endpoint, error);
|
||||
} else {
|
||||
super::super::stream_adapter::error_writable_stream_with_value(scope, endpoint, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn cancel<'s>(scope: &mut v8::PinScope<'s, '_>, owner: v8::Local<'s, v8::Object>) {
|
||||
if let Some(native) = state(scope, owner) {
|
||||
native.stop_ingress();
|
||||
native.lease.cancel();
|
||||
native.lease.finish();
|
||||
}
|
||||
}
|
||||
@@ -17,6 +17,7 @@ const QUEUE: &str = "__moliWebTransportDatagramQueue";
|
||||
const WRITE_RESOLVER: &str = "__moliWebTransportDatagramWriteResolver";
|
||||
const WRITE_BYTES: &str = "__moliWebTransportDatagramWriteBytes";
|
||||
const WRITE_TIMESTAMP: &str = "__moliWebTransportDatagramWriteTimestamp";
|
||||
const WRITE_WRITABLE: &str = "__moliWebTransportDatagramWritable";
|
||||
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(interface = web_api_interfaces::WebTransportDatagramDuplexStream, require_prototype)]
|
||||
@@ -55,6 +56,10 @@ struct Writable<'s> {
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(plain)]
|
||||
struct Datagram<'s> {
|
||||
#[webapi(slot = OWNER)]
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = WRITE_WRITABLE)]
|
||||
writable: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = WRITE_RESOLVER)]
|
||||
resolver: v8::Local<'s, v8::Value>,
|
||||
#[webapi(slot = WRITE_BYTES)]
|
||||
@@ -110,6 +115,7 @@ pub(super) fn install<'s>(
|
||||
pub(super) fn build<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
ready: v8::Local<'s, v8::Promise>,
|
||||
bytes: bool,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
super::super::exposed_interfaces::ensure_intrinsic_interface_prototype(
|
||||
@@ -117,11 +123,7 @@ pub(super) fn build<'s>(
|
||||
"WebTransportDatagramDuplexStream",
|
||||
)
|
||||
.expect("datagram intrinsic");
|
||||
let readable = if bytes {
|
||||
super::super::stream_adapter::new_readable_byte_stream_object(scope)
|
||||
} else {
|
||||
super::super::stream_adapter::new_readable_stream_object(scope, None, 0.0, None)
|
||||
};
|
||||
let readable = streams::datagrams(scope, owner, ready, bytes);
|
||||
Duplex::new(owner, readable)
|
||||
.bind(scope)
|
||||
.expect("datagram duplex stream")
|
||||
@@ -141,7 +143,7 @@ fn create_writable<'s>(
|
||||
throw_type_error(scope, "The send group belongs to another WebTransport.");
|
||||
return;
|
||||
}
|
||||
if !connecting(scope, owner) {
|
||||
if !connecting(scope, owner) && backend::connection(scope, owner).is_none() {
|
||||
invalid_state(scope);
|
||||
return;
|
||||
}
|
||||
@@ -209,6 +211,10 @@ fn set_age<'s>(
|
||||
.map(|value| v8::Number::new(scope, value).into())
|
||||
.unwrap_or_else(|| v8::null(scope).into());
|
||||
set_private_value(scope, receiver, &key, value);
|
||||
if key == INCOMING_AGE {
|
||||
let owner = object(scope, receiver, OWNER);
|
||||
backend::configure_incoming(scope, owner);
|
||||
}
|
||||
}
|
||||
|
||||
fn set_buffered<'s>(
|
||||
@@ -223,6 +229,41 @@ fn set_buffered<'s>(
|
||||
let key = args.data().to_rust_string_lossy(scope);
|
||||
let value = v8::Integer::new_from_unsigned(scope, parsed.value.max(1));
|
||||
set_private_value(scope, receiver, &key, value.into());
|
||||
if key == INCOMING_LIMIT {
|
||||
let owner = object(scope, receiver, OWNER);
|
||||
backend::configure_incoming(scope, owner);
|
||||
}
|
||||
if key == OUTGOING_LIMIT {
|
||||
let writables = tasks::array(scope, receiver, WRITABLES);
|
||||
let writables: Vec<_> = (0..writables.length())
|
||||
.map(|index| {
|
||||
v8::Local::<v8::Object>::try_from(
|
||||
writables
|
||||
.get_index(scope, index)
|
||||
.expect("datagram writable"),
|
||||
)
|
||||
.expect("writable object")
|
||||
})
|
||||
.collect();
|
||||
for writable in writables {
|
||||
relieve_backpressure(scope, receiver, writable);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn incoming_policy<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
) -> (usize, Option<std::time::Duration>) {
|
||||
let duplex = object(scope, owner, DATAGRAMS);
|
||||
let maximum = get_private_value(scope, duplex, INCOMING_LIMIT)
|
||||
.expect("incoming buffer limit")
|
||||
.uint32_value(scope)
|
||||
.expect("numeric limit") as usize;
|
||||
let age = get_private_value(scope, duplex, INCOMING_AGE)
|
||||
.and_then(|value| v8::Local::<v8::Number>::try_from(value).ok())
|
||||
.and_then(|value| std::time::Duration::try_from_secs_f64(value.value() / 1000.0).ok());
|
||||
(maximum, age)
|
||||
}
|
||||
|
||||
fn set_group<'s>(
|
||||
@@ -296,18 +337,181 @@ fn write_datagram<'s>(
|
||||
}
|
||||
let bytes = bytes.to_vec(scope);
|
||||
let bytes = crate::blob::array_buffer_from_bytes(scope, bytes).expect("datagram byte copy");
|
||||
let datagram = Datagram::new(resolver.into(), bytes.into(), timestamp)
|
||||
let datagram = Datagram::new(owner, writable, resolver.into(), bytes.into(), timestamp)
|
||||
.bind(scope)
|
||||
.expect("buffered datagram");
|
||||
if !connecting(scope, owner) && backend::connection(scope, owner).is_none() {
|
||||
reject(scope, resolver, "The WebTransport session is closed.");
|
||||
return;
|
||||
}
|
||||
let queue = tasks::array(scope, writable, QUEUE);
|
||||
tasks::push(scope, queue, datagram.into());
|
||||
if backend::connection(scope, owner).is_some() {
|
||||
send(scope, owner, datagram);
|
||||
}
|
||||
relieve_backpressure(scope, duplex, writable);
|
||||
}
|
||||
|
||||
fn relieve_backpressure<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
duplex: v8::Local<'s, v8::Object>,
|
||||
writable: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
let queue = tasks::array(scope, writable, QUEUE);
|
||||
let limit = get_private_value(scope, duplex, OUTGOING_LIMIT)
|
||||
.expect("datagram buffering limit")
|
||||
.expect("outgoing buffer limit")
|
||||
.uint32_value(scope)
|
||||
.unwrap();
|
||||
if queue.length() < limit {
|
||||
.expect("numeric limit");
|
||||
if queue.length() >= limit {
|
||||
return;
|
||||
}
|
||||
let writes: Vec<_> = (0..queue.length())
|
||||
.map(|index| {
|
||||
let datagram = v8::Local::<v8::Object>::try_from(
|
||||
queue.get_index(scope, index).expect("buffered datagram"),
|
||||
)
|
||||
.expect("datagram object");
|
||||
tasks::resolver(
|
||||
get_private_value(scope, datagram, WRITE_RESOLVER).expect("write resolver"),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
for write in writes {
|
||||
let undefined = v8::undefined(scope);
|
||||
write.resolve(scope, undefined.into());
|
||||
}
|
||||
}
|
||||
|
||||
fn reject<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
resolver: v8::Local<'s, v8::PromiseResolver>,
|
||||
message: &str,
|
||||
) {
|
||||
let error = super::super::build_web_transport_error(
|
||||
scope,
|
||||
&super::super::WebTransportErrorClonePayload {
|
||||
message: message.encode_utf16().collect(),
|
||||
source: super::super::WebTransportErrorSource::Session,
|
||||
stream_error_code: None,
|
||||
},
|
||||
)
|
||||
.expect("datagram error");
|
||||
resolver.reject(scope, error.into());
|
||||
}
|
||||
|
||||
fn send<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
datagram: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
let resolver = tasks::resolver(
|
||||
get_private_value(scope, datagram, WRITE_RESOLVER).expect("write resolver"),
|
||||
);
|
||||
let Some((session, runner)) = backend::connection(scope, owner) else {
|
||||
reject(scope, resolver, "The WebTransport session is closed.");
|
||||
return;
|
||||
};
|
||||
let Some(producer) = networking::register(scope, owner, datagram) else {
|
||||
return;
|
||||
};
|
||||
let value = get_private_value(scope, datagram, WRITE_BYTES).expect("private datagram bytes");
|
||||
let bytes = webidl::convert::<webidl::NonSharedBufferSource>(
|
||||
scope,
|
||||
value,
|
||||
webidl::Context::member("WebTransport", "datagrams"),
|
||||
)
|
||||
.expect("private datagram buffer")
|
||||
.to_vec(scope);
|
||||
let duplex = object(scope, owner, DATAGRAMS);
|
||||
let timestamp = get_private_value(scope, datagram, WRITE_TIMESTAMP)
|
||||
.expect("datagram timestamp")
|
||||
.number_value(scope)
|
||||
.expect("numeric timestamp");
|
||||
let age = get_private_value(scope, duplex, OUTGOING_AGE)
|
||||
.and_then(|value| v8::Local::<v8::Number>::try_from(value).ok())
|
||||
.map(|value| value.value());
|
||||
let remaining_ms =
|
||||
age.map(|age| age - (moli_time::monotonic_timestamp_seconds() * 1000.0 - timestamp));
|
||||
let expired = remaining_ms.is_some_and(|age| age <= 0.0);
|
||||
let deadline = remaining_ms
|
||||
.filter(|age| age.is_finite() && *age > 0.0)
|
||||
.and_then(|age| std::time::Duration::try_from_secs_f64(age / 1000.0).ok());
|
||||
runner.spawn(async move {
|
||||
let result = if expired || bytes.len() > session.max_datagram_size() {
|
||||
Ok(())
|
||||
} else if let Some(deadline) = deadline {
|
||||
match tokio::time::timeout(deadline, session.send_datagram_wait(bytes.into())).await {
|
||||
Ok(result) => result.map_err(|error| error.to_string()),
|
||||
Err(_) => Ok(()), // Expired unreliable payload, not a session failure.
|
||||
}
|
||||
} else {
|
||||
session
|
||||
.send_datagram_wait(bytes.into())
|
||||
.await
|
||||
.map_err(|error| error.to_string())
|
||||
};
|
||||
producer.send(networking::Completion::Datagram(result));
|
||||
});
|
||||
}
|
||||
|
||||
pub(super) fn complete<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
datagram: v8::Local<'s, v8::Object>,
|
||||
result: Result<(), String>,
|
||||
) {
|
||||
let resolver = tasks::resolver(
|
||||
get_private_value(scope, datagram, WRITE_RESOLVER).expect("write resolver"),
|
||||
);
|
||||
let writable = object(scope, datagram, WRITE_WRITABLE);
|
||||
let previous = tasks::array(scope, writable, QUEUE);
|
||||
let remaining = v8::Array::new(scope, 0);
|
||||
for index in 0..previous.length() {
|
||||
let value = previous.get_index(scope, index).expect("queued datagram");
|
||||
if !value.strict_equals(datagram.into()) {
|
||||
tasks::push(scope, remaining, value);
|
||||
}
|
||||
}
|
||||
set_private_value(scope, writable, QUEUE, remaining.into());
|
||||
if let Err(message) = result {
|
||||
let error = tasks::fail(scope, owner, &message);
|
||||
resolver.reject(scope, error.into());
|
||||
} else {
|
||||
let undefined = v8::undefined(scope);
|
||||
resolver.resolve(scope, undefined.into());
|
||||
let duplex = object(scope, owner, DATAGRAMS);
|
||||
relieve_backpressure(scope, duplex, writable);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn connected<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
maximum_size: usize,
|
||||
) {
|
||||
let duplex = object(scope, owner, DATAGRAMS);
|
||||
let maximum_size = v8::Integer::new_from_unsigned(scope, maximum_size as u32);
|
||||
set_private_value(scope, duplex, MAX_SIZE, maximum_size.into());
|
||||
let writables = tasks::array(scope, duplex, WRITABLES);
|
||||
let mut queued = Vec::new();
|
||||
for index in 0..writables.length() {
|
||||
let writable = v8::Local::<v8::Object>::try_from(
|
||||
writables
|
||||
.get_index(scope, index)
|
||||
.expect("datagram writable"),
|
||||
)
|
||||
.expect("writable");
|
||||
let queue = tasks::array(scope, writable, QUEUE);
|
||||
for index in 0..queue.length() {
|
||||
let data = v8::Local::<v8::Object>::try_from(
|
||||
queue.get_index(scope, index).expect("datagram record"),
|
||||
)
|
||||
.expect("datagram record object");
|
||||
queued.push(data);
|
||||
}
|
||||
}
|
||||
for data in queued {
|
||||
send(scope, owner, data);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -361,3 +565,18 @@ pub(super) fn finish_failure<'s>(
|
||||
}
|
||||
super::super::stream_adapter::error_stream(scope, failure.readable, error);
|
||||
}
|
||||
|
||||
pub(super) fn finish_close<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
duplex: v8::Local<'s, v8::Object>,
|
||||
error: v8::Local<'s, v8::Value>,
|
||||
) {
|
||||
let failure = prepare_failure(scope, duplex);
|
||||
for write in failure.writes {
|
||||
write.reject(scope, error);
|
||||
}
|
||||
for writable in failure.writables {
|
||||
super::super::stream_adapter::error_writable_stream_with_value(scope, writable, error);
|
||||
}
|
||||
super::super::stream_adapter::close_stream(scope, failure.readable);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,167 @@
|
||||
//! Native ingress is bounded even while no JavaScript reader has demand.
|
||||
//! Only a registered pull publishes bytes through the networking task source.
|
||||
|
||||
use bytes::Bytes;
|
||||
use parking_lot::Mutex;
|
||||
use std::{
|
||||
collections::VecDeque,
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
use tokio::sync::Notify;
|
||||
|
||||
pub(super) struct Incoming {
|
||||
state: Mutex<State>,
|
||||
changed: Notify,
|
||||
}
|
||||
|
||||
struct State {
|
||||
datagrams: VecDeque<(Instant, Bytes)>,
|
||||
maximum: usize,
|
||||
age: Option<Duration>,
|
||||
discarded: bool,
|
||||
closed: Option<String>,
|
||||
}
|
||||
|
||||
impl State {
|
||||
fn expire(&mut self, now: Instant) {
|
||||
if let Some(age) = self.age {
|
||||
while self
|
||||
.datagrams
|
||||
.front()
|
||||
.is_some_and(|(received, _)| now.saturating_duration_since(*received) > age)
|
||||
{
|
||||
self.datagrams.pop_front();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn trim(&mut self) {
|
||||
while self.datagrams.len() > self.maximum {
|
||||
self.datagrams.pop_front();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Incoming {
|
||||
pub(super) fn new(maximum: usize, age: Option<Duration>) -> Self {
|
||||
Self {
|
||||
state: Mutex::new(State {
|
||||
datagrams: VecDeque::new(),
|
||||
maximum: maximum.max(1),
|
||||
age,
|
||||
discarded: false,
|
||||
closed: None,
|
||||
}),
|
||||
changed: Notify::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn push(&self, datagram: Bytes) {
|
||||
self.push_at(datagram, Instant::now());
|
||||
}
|
||||
|
||||
fn push_at(&self, datagram: Bytes, now: Instant) {
|
||||
let mut state = self.state.lock();
|
||||
if state.discarded || state.closed.is_some() {
|
||||
return;
|
||||
}
|
||||
state.expire(now);
|
||||
state.datagrams.push_back((now, datagram));
|
||||
state.trim();
|
||||
drop(state);
|
||||
self.changed.notify_one();
|
||||
}
|
||||
|
||||
pub(super) fn configure(&self, maximum: usize, age: Option<Duration>) {
|
||||
let mut state = self.state.lock();
|
||||
state.maximum = maximum.max(1);
|
||||
state.age = age;
|
||||
state.expire(Instant::now());
|
||||
state.trim();
|
||||
}
|
||||
|
||||
pub(super) fn discard(&self) {
|
||||
let mut state = self.state.lock();
|
||||
state.discarded = true;
|
||||
state.datagrams.clear();
|
||||
}
|
||||
|
||||
pub(super) fn finish(&self, error: String) {
|
||||
let mut state = self.state.lock();
|
||||
if state.closed.is_some() {
|
||||
return;
|
||||
}
|
||||
state.closed = Some(error);
|
||||
state.datagrams.clear();
|
||||
drop(state);
|
||||
self.changed.notify_one();
|
||||
}
|
||||
|
||||
pub(super) async fn read(&self) -> Result<Bytes, String> {
|
||||
loop {
|
||||
let changed = self.changed.notified();
|
||||
{
|
||||
let mut state = self.state.lock();
|
||||
state.expire(Instant::now());
|
||||
if let Some((_, datagram)) = state.datagrams.pop_front() {
|
||||
return Ok(datagram);
|
||||
}
|
||||
if let Some(error) = &state.closed {
|
||||
return Err(error.clone());
|
||||
}
|
||||
}
|
||||
changed.await;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn unread_ingress_discards_oldest_payloads_at_the_configured_count() {
|
||||
let incoming = Incoming::new(5, None);
|
||||
for value in 0..50 {
|
||||
incoming.push(Bytes::from(vec![value]));
|
||||
}
|
||||
for value in 45..50 {
|
||||
assert_eq!(incoming.read().await.unwrap(), Bytes::from(vec![value]));
|
||||
}
|
||||
incoming.finish("closed".into());
|
||||
assert_eq!(incoming.read().await.unwrap_err(), "closed");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn incoming_age_and_later_limit_changes_apply_to_retained_payloads() {
|
||||
let incoming = Incoming::new(5, Some(Duration::from_secs(60)));
|
||||
incoming.push_at(
|
||||
Bytes::from_static(b"expired"),
|
||||
Instant::now() - Duration::from_secs(120),
|
||||
);
|
||||
incoming.push(Bytes::from_static(b"current"));
|
||||
assert_eq!(
|
||||
incoming.read().await.unwrap(),
|
||||
Bytes::from_static(b"current")
|
||||
);
|
||||
incoming.configure(5, None);
|
||||
for value in 0..5 {
|
||||
incoming.push(Bytes::from(vec![value]));
|
||||
}
|
||||
incoming.configure(2, None);
|
||||
assert_eq!(incoming.read().await.unwrap(), Bytes::from(vec![3]));
|
||||
assert_eq!(incoming.read().await.unwrap(), Bytes::from(vec![4]));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn finishing_ingress_wakes_a_pending_read_and_rejects_late_bytes() {
|
||||
let incoming = std::sync::Arc::new(Incoming::new(1, None));
|
||||
let reader = incoming.clone();
|
||||
let waiting = tokio::spawn(async move { reader.read().await });
|
||||
tokio::task::yield_now().await;
|
||||
incoming.finish("owner retired".into());
|
||||
incoming.push(Bytes::from_static(b"late"));
|
||||
assert_eq!(waiting.await.unwrap().unwrap_err(), "owner retired");
|
||||
assert_eq!(incoming.read().await.unwrap_err(), "owner retired");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
//! Native results cross threads through a single-use mailbox. V8 handles stay
|
||||
//! with the exact Window realm or worker that registered the operation.
|
||||
|
||||
use tokio::sync::oneshot;
|
||||
|
||||
use crate::{
|
||||
native_bridge::WindowExecutionContextIdentity,
|
||||
page_task_queue::{
|
||||
RendererPageWebTransportSender, RendererPageWebTransportTaskId,
|
||||
RendererPageWebTransportTaskKind,
|
||||
},
|
||||
};
|
||||
|
||||
pub(crate) enum Completion {
|
||||
Connected(Result<moli_webtransport::Session, String>),
|
||||
Closed(moli_webtransport::CloseReason),
|
||||
Stream(super::streams::StreamCompletion),
|
||||
Datagram(Result<(), String>),
|
||||
}
|
||||
|
||||
pub(crate) struct Pending {
|
||||
payload: v8::Global<v8::Object>,
|
||||
result: oneshot::Receiver<Completion>,
|
||||
}
|
||||
|
||||
impl Pending {
|
||||
pub(crate) fn new<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
) -> (Self, oneshot::Sender<Completion>) {
|
||||
let (sender, result) = oneshot::channel();
|
||||
(
|
||||
Self {
|
||||
payload: v8::Global::new(scope, payload),
|
||||
result,
|
||||
},
|
||||
sender,
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn apply(mut self, scope: &mut v8::PinScope<'_, '_>) -> bool {
|
||||
let Ok(result) = self.result.try_recv() else {
|
||||
return false;
|
||||
};
|
||||
let payload = v8::Local::new(scope, self.payload);
|
||||
super::backend::apply(scope, payload, result);
|
||||
true
|
||||
}
|
||||
|
||||
pub(crate) fn context<'s>(
|
||||
&self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
) -> Option<v8::Local<'s, v8::Context>> {
|
||||
v8::Local::new(scope, &self.payload).get_creation_context(scope)
|
||||
}
|
||||
}
|
||||
|
||||
enum Route {
|
||||
Window {
|
||||
sender: RendererPageWebTransportSender,
|
||||
target: WindowExecutionContextIdentity,
|
||||
id: RendererPageWebTransportTaskId,
|
||||
},
|
||||
Worker {
|
||||
sender: tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerMessage>,
|
||||
id: u64,
|
||||
},
|
||||
}
|
||||
|
||||
pub(crate) struct Producer {
|
||||
result: oneshot::Sender<Completion>,
|
||||
route: Route,
|
||||
}
|
||||
|
||||
impl Producer {
|
||||
pub(crate) fn window(
|
||||
result: oneshot::Sender<Completion>,
|
||||
sender: RendererPageWebTransportSender,
|
||||
target: WindowExecutionContextIdentity,
|
||||
id: RendererPageWebTransportTaskId,
|
||||
) -> Self {
|
||||
Self {
|
||||
result,
|
||||
route: Route::Window { sender, target, id },
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn worker(
|
||||
result: oneshot::Sender<Completion>,
|
||||
sender: tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerMessage>,
|
||||
id: u64,
|
||||
) -> Self {
|
||||
Self {
|
||||
result,
|
||||
route: Route::Worker { sender, id },
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn send(self, result: Completion) {
|
||||
// Teardown drops the receiver before retiring the V8 payload. A late
|
||||
// result then releases its native resources without waking the owner.
|
||||
if self.result.send(result).is_err() {
|
||||
return;
|
||||
}
|
||||
match self.route {
|
||||
Route::Window { sender, target, id } => {
|
||||
sender.send(target, id, RendererPageWebTransportTaskKind::Complete);
|
||||
}
|
||||
Route::Worker { sender, id } => {
|
||||
let _ = sender.send(crate::worker::WorkerMessage::RunWebTransportTask(id));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn register<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
) -> Option<Producer> {
|
||||
if let Some(host) = crate::util::context_host_ptr_from_global_bridge(scope) {
|
||||
// SAFETY: the current realm's bridge owns this isolate-local host.
|
||||
unsafe { &mut *host }.register_webtransport_task(scope, owner, payload)
|
||||
} else {
|
||||
crate::worker::webtransport_tasks::register(scope, payload)
|
||||
}
|
||||
}
|
||||
@@ -49,7 +49,10 @@ impl<'s> webidl::WebIdlConverter<'s> for Headers {
|
||||
}
|
||||
|
||||
impl Headers {
|
||||
pub(super) fn validate(self, scope: &mut v8::PinScope<'_, '_>) -> bool {
|
||||
pub(super) fn into_entries(
|
||||
self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
) -> Option<Vec<(String, String)>> {
|
||||
let pairs = match self {
|
||||
Self::Empty => Vec::new(),
|
||||
Self::Record(record) => record,
|
||||
@@ -58,7 +61,7 @@ impl Headers {
|
||||
for pair in sequence {
|
||||
let Ok([key, value]) = <[_; 2]>::try_from(pair.0) else {
|
||||
crate::util::throw_type_error(scope, "Header pairs must have length 2.");
|
||||
return false;
|
||||
return None;
|
||||
};
|
||||
pairs.push((key, value));
|
||||
}
|
||||
@@ -68,24 +71,24 @@ impl Headers {
|
||||
// Fill the complete Headers object before applying request-specific
|
||||
// restrictions; later invalid entries take precedence over these.
|
||||
let mut available_protocols = false;
|
||||
let mut entries = Vec::with_capacity(pairs.len());
|
||||
for (name, value) in pairs {
|
||||
let Some((name, _)) = crate::network_host::validated_header_entry_or_throw(
|
||||
let (name, value) = crate::network_host::validated_header_entry_or_throw(
|
||||
scope,
|
||||
name.into(),
|
||||
value.into(),
|
||||
) else {
|
||||
return false;
|
||||
};
|
||||
)?;
|
||||
available_protocols |= name.eq_ignore_ascii_case("wt-available-protocols");
|
||||
entries.push((name.to_ascii_lowercase(), value));
|
||||
}
|
||||
if available_protocols {
|
||||
crate::util::throw_type_error(
|
||||
scope,
|
||||
"WT-Available-Protocols is controlled by WebTransport.",
|
||||
);
|
||||
return false;
|
||||
return None;
|
||||
}
|
||||
true
|
||||
Some(entries)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -93,9 +96,9 @@ impl Headers {
|
||||
#[webidl(prefix = "WebTransportHash")]
|
||||
pub(super) struct CertificateHash<'s> {
|
||||
#[webidl(required, converter = "raw", name = "algorithm")]
|
||||
_algorithm: webidl::DomString16,
|
||||
pub(super) algorithm: webidl::DomString16,
|
||||
#[webidl(required, converter = "raw", name = "value")]
|
||||
_value: webidl::NonSharedBufferSource<'s>,
|
||||
pub(super) value: webidl::NonSharedBufferSource<'s>,
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlDictionary)]
|
||||
@@ -108,7 +111,7 @@ pub(super) struct Options<'s> {
|
||||
#[webidl(nullable, converter = "enforce_range_unsigned_short")]
|
||||
pub(super) anticipated_concurrent_incoming_unidirectional_streams: Option<u16>,
|
||||
#[webidl(name = "congestionControl", converter = "enum", default = CongestionControl::Default)]
|
||||
_congestion_control: CongestionControl,
|
||||
pub(super) congestion_control: CongestionControl,
|
||||
#[webidl(converter = "enum")]
|
||||
pub(super) datagrams_readable_type: Option<ReadableType>,
|
||||
#[webidl(converter = "raw", default = Headers::default())]
|
||||
@@ -132,18 +135,18 @@ pub(super) struct ConstructorArgs<'s> {
|
||||
|
||||
#[derive(webidl::WebIdlDictionary)]
|
||||
#[webidl(prefix = "WebTransportCloseInfo")]
|
||||
struct CloseInfo {
|
||||
pub(super) struct CloseInfo {
|
||||
#[webidl(name = "closeCode", converter = "unsigned_long", default = 0)]
|
||||
_close_code: u32,
|
||||
pub(super) close_code: u32,
|
||||
#[webidl(name = "reason", converter = "usv_string", default = "")]
|
||||
_reason: String,
|
||||
pub(super) reason: String,
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlArgs)]
|
||||
#[webidl(prefix = "WebTransport.close")]
|
||||
pub(super) struct CloseArgs {
|
||||
#[webidl(name = "closeInfo", dictionary)]
|
||||
_close_info: CloseInfo,
|
||||
pub(super) close_info: CloseInfo,
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlDictionary)]
|
||||
|
||||
@@ -0,0 +1,672 @@
|
||||
//! Pull-driven QUIC byte streams. Each source admits one native read at a
|
||||
//! time; WritableStream's sink promise applies transport backpressure.
|
||||
|
||||
use std::sync::Arc;
|
||||
use tokio::sync::{Mutex, watch};
|
||||
|
||||
use super::super::stream_adapter as streams;
|
||||
use super::{
|
||||
networking::{self, Completion},
|
||||
*,
|
||||
};
|
||||
|
||||
pub(super) const RESOLVER: &str = "__moliWebTransportOperationResolver";
|
||||
const STREAM: &str = "__moliWebTransportOperationStream";
|
||||
const OPEN_BIDI: &str = "__moliWebTransportOpenBidirectional";
|
||||
const ENDPOINT: &str = "__moliWebTransportNativeEndpoint";
|
||||
|
||||
#[derive(Clone)]
|
||||
enum ReadKind {
|
||||
IncomingBi,
|
||||
IncomingUni,
|
||||
Datagram { bytes: bool },
|
||||
Bytes(Arc<Mutex<moli_webtransport::RecvStream>>),
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
enum Endpoint {
|
||||
Read {
|
||||
kind: ReadKind,
|
||||
stop: watch::Sender<Option<u32>>,
|
||||
},
|
||||
Send {
|
||||
stream: Arc<Mutex<moli_webtransport::SendStream>>,
|
||||
stop: watch::Sender<Option<u32>>,
|
||||
},
|
||||
}
|
||||
|
||||
pub(crate) struct TransferError {
|
||||
message: String,
|
||||
code: Option<u32>,
|
||||
session: bool,
|
||||
}
|
||||
|
||||
impl TransferError {
|
||||
fn session(error: impl std::fmt::Display) -> Self {
|
||||
Self {
|
||||
message: error.to_string(),
|
||||
code: None,
|
||||
session: true,
|
||||
}
|
||||
}
|
||||
fn read(error: moli_webtransport::ReadError) -> Self {
|
||||
let code = match error {
|
||||
moli_webtransport::ReadError::Reset(code) => Some(code),
|
||||
_ => None,
|
||||
};
|
||||
let session = matches!(error, moli_webtransport::ReadError::SessionError(_));
|
||||
Self {
|
||||
message: error.to_string(),
|
||||
code,
|
||||
session,
|
||||
}
|
||||
}
|
||||
fn write(error: moli_webtransport::WriteError) -> Self {
|
||||
let code = match error {
|
||||
moli_webtransport::WriteError::Stopped(code) => Some(code),
|
||||
_ => None,
|
||||
};
|
||||
let session = matches!(error, moli_webtransport::WriteError::SessionError(_));
|
||||
Self {
|
||||
message: error.to_string(),
|
||||
code,
|
||||
session,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) enum StreamValue {
|
||||
Bidirectional(moli_webtransport::SendStream, moli_webtransport::RecvStream),
|
||||
Send(moli_webtransport::SendStream),
|
||||
Receive(moli_webtransport::RecvStream),
|
||||
Bytes(Option<Vec<u8>>),
|
||||
Datagram(Vec<u8>),
|
||||
Complete,
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
pub(crate) type StreamCompletion = Result<StreamValue, TransferError>;
|
||||
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(plain)]
|
||||
struct Operation<'s> {
|
||||
#[webapi(slot = OWNER)]
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = RESOLVER)]
|
||||
resolver: v8::Local<'s, v8::PromiseResolver>,
|
||||
#[webapi(slot = STREAM)]
|
||||
stream: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = OPEN_BIDI)]
|
||||
bidi: bool,
|
||||
}
|
||||
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(interface = web_api_interfaces::WebTransportBidirectionalStream, require_prototype)]
|
||||
struct Bidirectional<'s> {
|
||||
#[webapi(slot = "__moliWebTransportBidiReadable")]
|
||||
readable: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = "__moliWebTransportBidiWritable")]
|
||||
writable: v8::Local<'s, v8::Object>,
|
||||
}
|
||||
|
||||
fn set_endpoint<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
endpoint: Endpoint,
|
||||
) {
|
||||
let mut endpoint = Box::new(endpoint);
|
||||
let pointer = (&mut *endpoint as *mut Endpoint).cast();
|
||||
let external = v8::External::new(scope, pointer);
|
||||
set_private_value(scope, object, ENDPOINT, external.into());
|
||||
crate::v8_finalizer::track_context_owned_v8_finalizer(scope, object, move || drop(endpoint));
|
||||
}
|
||||
|
||||
fn endpoint<'s>(scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>) -> Endpoint {
|
||||
let value = get_private_value(scope, object, ENDPOINT).expect("native stream endpoint");
|
||||
let external = v8::Local::<v8::External>::try_from(value).expect("endpoint private slot");
|
||||
// SAFETY: set_endpoint owns this typed allocation through the context's
|
||||
// guaranteed finalizer. Only native algorithm payloads call this helper.
|
||||
unsafe { &*external.value().cast::<Endpoint>() }.clone()
|
||||
}
|
||||
|
||||
fn algorithm<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
source: v8::Local<'s, v8::Object>,
|
||||
name: &'static str,
|
||||
callback: impl v8::MapFnTo<v8::FunctionCallback>,
|
||||
data: v8::Local<'s, v8::Value>,
|
||||
) {
|
||||
let function = v8::Function::builder(callback)
|
||||
.data(data)
|
||||
.build(scope)
|
||||
.expect("native stream algorithm");
|
||||
let name = v8str(scope, name);
|
||||
assert_eq!(
|
||||
source.create_data_property(scope, name.into(), function.into()),
|
||||
Some(true)
|
||||
);
|
||||
}
|
||||
|
||||
pub(super) fn incoming<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
ready: v8::Local<'s, v8::Promise>,
|
||||
bidi: bool,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
readable(
|
||||
scope,
|
||||
owner,
|
||||
ready,
|
||||
if bidi {
|
||||
ReadKind::IncomingBi
|
||||
} else {
|
||||
ReadKind::IncomingUni
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn datagrams<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
ready: v8::Local<'s, v8::Promise>,
|
||||
bytes: bool,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
readable(scope, owner, ready, ReadKind::Datagram { bytes })
|
||||
}
|
||||
|
||||
fn readable<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
ready: v8::Local<'s, v8::Promise>,
|
||||
kind: ReadKind,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
let received_bytes = matches!(kind, ReadKind::Bytes(_));
|
||||
let byte_stream = matches!(
|
||||
kind,
|
||||
ReadKind::Bytes(_) | ReadKind::Datagram { bytes: true }
|
||||
);
|
||||
let stream = streams::new_readable_stream_shell_object(scope);
|
||||
set_private_value(scope, stream, OWNER, owner.into());
|
||||
let (stop, _) = watch::channel(None);
|
||||
set_endpoint(scope, stream, Endpoint::Read { kind, stop });
|
||||
let source = crate::util::new_null_prototype_object(scope);
|
||||
algorithm(scope, source, "start", start, ready.into());
|
||||
algorithm(scope, source, "pull", pull, stream.into());
|
||||
algorithm(scope, source, "cancel", cancel_read, stream.into());
|
||||
let source = streams::parse_readable_stream_source_object(scope, source)
|
||||
.expect("native source callbacks");
|
||||
streams::initialize_webidl_readable_stream_object(
|
||||
scope,
|
||||
stream,
|
||||
Some(source),
|
||||
byte_stream,
|
||||
0.0,
|
||||
None,
|
||||
);
|
||||
if received_bytes {
|
||||
backend::remember_stream(scope, owner, stream);
|
||||
}
|
||||
stream
|
||||
}
|
||||
|
||||
fn start<'s>(
|
||||
_scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
rv.set(args.data());
|
||||
}
|
||||
|
||||
fn operation<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
stream: v8::Local<'s, v8::Object>,
|
||||
bidi: bool,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
let resolver = v8::PromiseResolver::new(scope).expect("WebTransport stream promise");
|
||||
rv.set(resolver.get_promise(scope).into());
|
||||
Operation::new(owner, resolver, stream, bidi)
|
||||
.bind(scope)
|
||||
.expect("native stream operation")
|
||||
}
|
||||
|
||||
pub(super) fn open<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
bidi: bool,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
if !connecting(scope, owner) && backend::connection(scope, owner).is_none() {
|
||||
invalid_state(scope);
|
||||
return;
|
||||
}
|
||||
let payload = operation(scope, owner, owner, bidi, rv);
|
||||
if connecting(scope, owner) {
|
||||
let pending = tasks::array(scope, owner, PENDING);
|
||||
tasks::push(scope, pending, payload.into());
|
||||
} else {
|
||||
open_pending(scope, owner, payload);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn open_pending<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
) {
|
||||
let bidi = get_private_value(scope, payload, OPEN_BIDI)
|
||||
.expect("stream kind")
|
||||
.is_true();
|
||||
let Some((session, runner)) = backend::connection(scope, owner) else {
|
||||
reject_open(scope, payload);
|
||||
return;
|
||||
};
|
||||
let Some(producer) = networking::register(scope, owner, payload) else {
|
||||
return;
|
||||
};
|
||||
runner.spawn(async move {
|
||||
let result = if bidi {
|
||||
session
|
||||
.open_bi()
|
||||
.await
|
||||
.map(|(send, recv)| StreamValue::Bidirectional(send, recv))
|
||||
} else {
|
||||
session.open_uni().await.map(StreamValue::Send)
|
||||
};
|
||||
producer.send(Completion::Stream(result.map_err(TransferError::session)));
|
||||
});
|
||||
}
|
||||
|
||||
fn pull<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let stream = v8::Local::<v8::Object>::try_from(args.data()).expect("native readable payload");
|
||||
let owner = object(scope, stream, OWNER);
|
||||
let payload = operation(scope, owner, stream, false, rv);
|
||||
let Endpoint::Read { kind, stop } = endpoint(scope, stream) else {
|
||||
unreachable!("read endpoint")
|
||||
};
|
||||
let Some((session, runner)) = backend::connection(scope, owner) else {
|
||||
reject(
|
||||
scope,
|
||||
payload,
|
||||
TransferError::session("The WebTransport session is closed."),
|
||||
);
|
||||
return;
|
||||
};
|
||||
let Some(producer) = networking::register(scope, owner, payload) else {
|
||||
return;
|
||||
};
|
||||
let mut cancelled = stop.subscribe();
|
||||
let incoming = backend::incoming(scope, owner);
|
||||
runner.spawn(async move {
|
||||
if cancelled.borrow().is_some() { producer.send(Completion::Stream(Ok(StreamValue::Cancelled))); return; }
|
||||
let result = match kind {
|
||||
ReadKind::Bytes(stream) => {
|
||||
let mut stream = stream.lock().await;
|
||||
let mut bytes = vec![0; 64 * 1024];
|
||||
tokio::select! { biased;
|
||||
_ = cancelled.changed() => {
|
||||
let _ = stream.stop(cancelled.borrow().unwrap_or(0));
|
||||
Ok(StreamValue::Cancelled)
|
||||
}
|
||||
result = stream.read(&mut bytes) => result.map(|length| {
|
||||
StreamValue::Bytes(length.map(|length| { bytes.truncate(length); bytes }))
|
||||
}).map_err(TransferError::read),
|
||||
}
|
||||
}
|
||||
kind => tokio::select! { biased;
|
||||
_ = cancelled.changed() => Ok(StreamValue::Cancelled),
|
||||
result = async {
|
||||
match kind {
|
||||
ReadKind::IncomingBi => session.accept_bi().await.map(|(send, recv)| StreamValue::Bidirectional(send, recv)).map_err(TransferError::session),
|
||||
ReadKind::IncomingUni => session.accept_uni().await.map(StreamValue::Receive).map_err(TransferError::session),
|
||||
ReadKind::Datagram { bytes } => loop {
|
||||
let incoming = incoming.as_ref().expect("connected datagram ingress");
|
||||
match incoming.read().await {
|
||||
Ok(value) if bytes && value.is_empty() => continue,
|
||||
result => break result.map(|value| StreamValue::Datagram(value.to_vec())).map_err(TransferError::session),
|
||||
}
|
||||
},
|
||||
ReadKind::Bytes(_) => unreachable!("byte stream handled above"),
|
||||
}
|
||||
} => result,
|
||||
},
|
||||
};
|
||||
producer.send(Completion::Stream(result));
|
||||
});
|
||||
}
|
||||
|
||||
fn error_code<'s>(scope: &mut v8::PinScope<'s, '_>, value: v8::Local<'s, v8::Value>) -> u32 {
|
||||
v8::Local::<v8::Object>::try_from(value)
|
||||
.ok()
|
||||
.and_then(|value| super::super::web_transport_error_clone_payload_from_object(scope, value))
|
||||
.and_then(|payload| payload.stream_error_code)
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
fn cancel_read<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let stream = v8::Local::<v8::Object>::try_from(args.data()).expect("native readable payload");
|
||||
let code = error_code(scope, args.get(0));
|
||||
let owner = object(scope, stream, OWNER);
|
||||
let Endpoint::Read { kind, stop } = endpoint(scope, stream) else {
|
||||
unreachable!("read endpoint")
|
||||
};
|
||||
stop.send_replace(Some(code));
|
||||
if matches!(kind, ReadKind::Datagram { .. })
|
||||
&& let Some(incoming) = backend::incoming(scope, owner)
|
||||
{
|
||||
incoming.discard();
|
||||
}
|
||||
if let ReadKind::Bytes(stream) = kind
|
||||
&& let Some((_, runner)) = backend::connection(scope, owner)
|
||||
{
|
||||
runner.spawn(async move {
|
||||
let _ = stream.lock().await.stop(code);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn stream_owner<'s>(
|
||||
_scope: &mut v8::PinScope<'s, '_>,
|
||||
data: v8::Local<'s, v8::Value>,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
v8::Local::<v8::Object>::try_from(data).expect("stream payload")
|
||||
}
|
||||
|
||||
fn writable<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
native: moli_webtransport::SendStream,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
let stream = streams::new_writable_stream_shell_object(scope);
|
||||
set_private_value(scope, stream, OWNER, owner.into());
|
||||
let (stop, _) = watch::channel(None);
|
||||
set_endpoint(
|
||||
scope,
|
||||
stream,
|
||||
Endpoint::Send {
|
||||
stream: Arc::new(Mutex::new(native)),
|
||||
stop,
|
||||
},
|
||||
);
|
||||
let sink = crate::util::new_null_prototype_object(scope);
|
||||
algorithm(scope, sink, "write", write, stream.into());
|
||||
algorithm(scope, sink, "close", finish, stream.into());
|
||||
algorithm(scope, sink, "abort", abort, stream.into());
|
||||
let sink =
|
||||
streams::parse_writable_stream_sink_object(scope, sink).expect("native sink callbacks");
|
||||
streams::initialize_webidl_writable_stream_object(scope, stream, Some(sink), 1.0, None);
|
||||
backend::remember_stream(scope, owner, stream);
|
||||
stream
|
||||
}
|
||||
|
||||
fn write<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let bytes = match webidl::convert::<webidl::NonSharedBufferSource>(
|
||||
scope,
|
||||
args.get(0),
|
||||
webidl::Context::argument("WebTransportSendStream.write", 1),
|
||||
) {
|
||||
Ok(bytes) => bytes.to_vec(scope),
|
||||
Err(error) => {
|
||||
webidl::throw_error(scope, &error);
|
||||
return;
|
||||
}
|
||||
};
|
||||
send(scope, args.data(), Some(bytes), rv);
|
||||
}
|
||||
|
||||
fn finish<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
send(scope, args.data(), None, rv);
|
||||
}
|
||||
|
||||
fn send<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
data: v8::Local<'s, v8::Value>,
|
||||
bytes: Option<Vec<u8>>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let stream = stream_owner(scope, data);
|
||||
let owner = object(scope, stream, OWNER);
|
||||
let payload = operation(scope, owner, stream, false, rv);
|
||||
let Endpoint::Send { stream, stop } = endpoint(scope, stream) else {
|
||||
unreachable!("send endpoint")
|
||||
};
|
||||
let Some((_, runner)) = backend::connection(scope, owner) else {
|
||||
reject(
|
||||
scope,
|
||||
payload,
|
||||
TransferError::session("The WebTransport session is closed."),
|
||||
);
|
||||
return;
|
||||
};
|
||||
let Some(producer) = networking::register(scope, owner, payload) else {
|
||||
return;
|
||||
};
|
||||
let mut cancelled = stop.subscribe();
|
||||
runner.spawn(async move {
|
||||
let mut stream = stream.lock().await;
|
||||
let cancelled_code = *cancelled.borrow();
|
||||
let result = if let Some(code) = cancelled_code {
|
||||
let _ = stream.reset(code);
|
||||
Ok(StreamValue::Complete)
|
||||
} else {
|
||||
tokio::select! { biased;
|
||||
_ = cancelled.changed() => { let _ = stream.reset(cancelled.borrow().unwrap_or(0)); Ok(StreamValue::Complete) }
|
||||
result = async {
|
||||
if let Some(bytes) = bytes {
|
||||
stream.write_all(&bytes).await.map_err(TransferError::write)?;
|
||||
} else {
|
||||
stream.finish().map_err(TransferError::session)?;
|
||||
if let Some(code) = stream.stopped().await.map_err(TransferError::session)? {
|
||||
return Err(TransferError { message: "The peer stopped the stream.".into(), code: Some(code), session: false });
|
||||
}
|
||||
}
|
||||
Ok(StreamValue::Complete)
|
||||
} => result,
|
||||
}
|
||||
};
|
||||
producer.send(Completion::Stream(result));
|
||||
});
|
||||
}
|
||||
|
||||
fn abort<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let code = error_code(scope, args.get(0));
|
||||
let target = stream_owner(scope, args.data());
|
||||
let Endpoint::Send { stream, stop } = endpoint(scope, target) else {
|
||||
unreachable!("send endpoint")
|
||||
};
|
||||
stop.send_replace(Some(code));
|
||||
let owner = object(scope, target, OWNER);
|
||||
let payload = operation(scope, owner, target, false, rv);
|
||||
let Some((_, runner)) = backend::connection(scope, owner) else {
|
||||
reject(
|
||||
scope,
|
||||
payload,
|
||||
TransferError::session("The WebTransport session is closed."),
|
||||
);
|
||||
return;
|
||||
};
|
||||
let Some(producer) = networking::register(scope, owner, payload) else {
|
||||
return;
|
||||
};
|
||||
runner.spawn(async move {
|
||||
let result = stream
|
||||
.lock()
|
||||
.await
|
||||
.reset(code)
|
||||
.map(|_| StreamValue::Complete)
|
||||
.map_err(TransferError::session);
|
||||
producer.send(Completion::Stream(result));
|
||||
});
|
||||
}
|
||||
|
||||
fn bidi<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
send: moli_webtransport::SendStream,
|
||||
recv: moli_webtransport::RecvStream,
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
let ready = object_promise(scope, owner, READY);
|
||||
let readable = readable(
|
||||
scope,
|
||||
owner,
|
||||
ready,
|
||||
ReadKind::Bytes(Arc::new(Mutex::new(recv))),
|
||||
);
|
||||
let writable = writable(scope, owner, send);
|
||||
super::super::exposed_interfaces::ensure_intrinsic_interface_prototype(
|
||||
scope,
|
||||
"WebTransportBidirectionalStream",
|
||||
)
|
||||
.expect("bidirectional intrinsic");
|
||||
Bidirectional::new(readable, writable)
|
||||
.bind(scope)
|
||||
.expect("bidirectional stream")
|
||||
}
|
||||
|
||||
fn object_promise<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
slot: &str,
|
||||
) -> v8::Local<'s, v8::Promise> {
|
||||
v8::Local::<v8::Promise>::try_from(
|
||||
get_private_value(scope, owner, slot).expect("session promise"),
|
||||
)
|
||||
.expect("promise slot")
|
||||
}
|
||||
|
||||
fn reject_open<'s>(scope: &mut v8::PinScope<'s, '_>, payload: v8::Local<'s, v8::Object>) {
|
||||
let error = super::super::new_dom_exception_value(
|
||||
scope,
|
||||
"The WebTransport session closed before opening the stream.",
|
||||
"InvalidStateError",
|
||||
);
|
||||
let resolver =
|
||||
tasks::resolver(get_private_value(scope, payload, RESOLVER).expect("operation resolver"));
|
||||
resolver.reject(scope, error);
|
||||
}
|
||||
|
||||
fn reject<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
error: TransferError,
|
||||
) {
|
||||
let error = super::super::build_web_transport_error(
|
||||
scope,
|
||||
&super::super::WebTransportErrorClonePayload {
|
||||
message: error.message.encode_utf16().collect(),
|
||||
source: if error.session {
|
||||
super::super::WebTransportErrorSource::Session
|
||||
} else {
|
||||
super::super::WebTransportErrorSource::Stream
|
||||
},
|
||||
stream_error_code: error.code,
|
||||
},
|
||||
)
|
||||
.expect("WebTransport stream error");
|
||||
let resolver =
|
||||
tasks::resolver(get_private_value(scope, payload, RESOLVER).expect("operation resolver"));
|
||||
resolver.reject(scope, error.into());
|
||||
}
|
||||
|
||||
pub(super) fn apply<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
result: StreamCompletion,
|
||||
) {
|
||||
let resolver =
|
||||
tasks::resolver(get_private_value(scope, payload, RESOLVER).expect("operation resolver"));
|
||||
let stream = object(scope, payload, STREAM);
|
||||
let result = match result {
|
||||
Ok(result) => result,
|
||||
Err(error) => {
|
||||
// Opening has no stream to error. A session that closed while
|
||||
// allocating its id rejects the pending creation operation with
|
||||
// InvalidStateError; established endpoints preserve transport errors.
|
||||
if stream == owner && error.session {
|
||||
reject_open(scope, payload);
|
||||
} else {
|
||||
reject(scope, payload, error);
|
||||
}
|
||||
return;
|
||||
}
|
||||
};
|
||||
let pulling = stream != owner;
|
||||
if !pulling && backend::connection(scope, owner).is_none() {
|
||||
reject_open(scope, payload);
|
||||
return;
|
||||
}
|
||||
if pulling
|
||||
&& let Endpoint::Read { stop, .. } = endpoint(scope, stream)
|
||||
&& stop.borrow().is_some()
|
||||
{
|
||||
let undefined = v8::undefined(scope);
|
||||
resolver.resolve(scope, undefined.into());
|
||||
return;
|
||||
}
|
||||
let value: v8::Local<v8::Value> = match result {
|
||||
StreamValue::Bidirectional(send, recv) => bidi(scope, owner, send, recv).into(),
|
||||
StreamValue::Send(send) => writable(scope, owner, send).into(),
|
||||
StreamValue::Receive(recv) => {
|
||||
let ready = object_promise(scope, owner, READY);
|
||||
readable(
|
||||
scope,
|
||||
owner,
|
||||
ready,
|
||||
ReadKind::Bytes(Arc::new(Mutex::new(recv))),
|
||||
)
|
||||
.into()
|
||||
}
|
||||
StreamValue::Bytes(Some(bytes)) | StreamValue::Datagram(bytes) => {
|
||||
let length = bytes.len();
|
||||
let buffer =
|
||||
crate::blob::array_buffer_from_bytes(scope, bytes).expect("transport read buffer");
|
||||
v8::Uint8Array::new(scope, buffer, 0, length)
|
||||
.expect("transport read view")
|
||||
.into()
|
||||
}
|
||||
StreamValue::Bytes(None) => {
|
||||
streams::close_stream(scope, stream);
|
||||
v8::undefined(scope).into()
|
||||
}
|
||||
StreamValue::Complete | StreamValue::Cancelled => v8::undefined(scope).into(),
|
||||
};
|
||||
if pulling {
|
||||
if !value.is_undefined() {
|
||||
let result = if streams::readable_stream_is_byte_stream(scope, stream) {
|
||||
streams::enqueue_byte_chunk(scope, stream, value)
|
||||
} else {
|
||||
streams::enqueue_chunk(scope, stream, value)
|
||||
};
|
||||
if let Err(streams::EnqueueChunkError::Strategy(error)) = result {
|
||||
resolver.reject(scope, error);
|
||||
return;
|
||||
}
|
||||
}
|
||||
let undefined = v8::undefined(scope);
|
||||
resolver.resolve(scope, undefined.into());
|
||||
} else {
|
||||
resolver.resolve(scope, value);
|
||||
}
|
||||
}
|
||||
@@ -4,6 +4,17 @@
|
||||
|
||||
use super::*;
|
||||
|
||||
const FAILURE_MESSAGE: &str = "__moliWebTransportConnectionFailureMessage";
|
||||
|
||||
#[derive(WebApiObject)]
|
||||
#[webapi(plain)]
|
||||
struct ConnectionFailure<'s> {
|
||||
#[webapi(slot = OWNER)]
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
#[webapi(slot = FAILURE_MESSAGE)]
|
||||
message: v8::Local<'s, v8::String>,
|
||||
}
|
||||
|
||||
pub(super) fn queue<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
@@ -29,8 +40,13 @@ pub(super) fn queue<'s>(
|
||||
pub(super) fn queue_connection_failure<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
message: &str,
|
||||
) {
|
||||
queue(scope, owner, connection_failure, owner.into());
|
||||
let message = v8::String::new(scope, message).expect("connection failure message");
|
||||
let payload = ConnectionFailure::new(owner, message)
|
||||
.bind(scope)
|
||||
.expect("failure payload");
|
||||
queue(scope, owner, connection_failure, payload.into());
|
||||
}
|
||||
|
||||
fn connection_failure<'s>(
|
||||
@@ -38,13 +54,14 @@ fn connection_failure<'s>(
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let owner = v8::Local::<v8::Object>::try_from(args.data()).expect("WebTransport task payload");
|
||||
let payload =
|
||||
v8::Local::<v8::Object>::try_from(args.data()).expect("WebTransport task payload");
|
||||
let owner = object(scope, payload, OWNER);
|
||||
if connecting(scope, owner) {
|
||||
fail(
|
||||
scope,
|
||||
owner,
|
||||
"No WebTransport session backend is available.",
|
||||
);
|
||||
let message = get_private_value(scope, payload, FAILURE_MESSAGE)
|
||||
.expect("failure message")
|
||||
.to_rust_string_lossy(scope);
|
||||
fail(scope, owner, &message);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -81,12 +98,16 @@ pub(super) fn wait_for_connection<'s>(
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
if !connecting(scope, owner) {
|
||||
if !connecting(scope, owner) && backend::connection(scope, owner).is_none() {
|
||||
invalid_state(scope);
|
||||
return;
|
||||
}
|
||||
let resolver = v8::PromiseResolver::new(scope).expect("WebTransport operation promise");
|
||||
rv.set(resolver.get_promise(scope).into());
|
||||
if !connecting(scope, owner) {
|
||||
queue_unsupported(scope, owner, resolver.into());
|
||||
return;
|
||||
}
|
||||
let pending = array(scope, owner, PENDING);
|
||||
push(scope, pending, resolver.into());
|
||||
}
|
||||
@@ -95,11 +116,20 @@ pub(super) fn fail<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
message: &str,
|
||||
) {
|
||||
) -> v8::Local<'s, v8::Object> {
|
||||
let context = owner
|
||||
.get_creation_context(scope)
|
||||
.expect("WebTransport cleanup realm");
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
if get_private_value(scope, owner, STATE)
|
||||
.is_some_and(|value| value.to_rust_string_lossy(scope) == "failed")
|
||||
{
|
||||
let value = get_private_value(scope, owner, CLOSED_RESOLVER).expect("closed resolver");
|
||||
let closed = resolver(value).get_promise(scope);
|
||||
if closed.state() == v8::PromiseState::Rejected {
|
||||
return v8::Local::<v8::Object>::try_from(closed.result(scope)).expect("session error");
|
||||
}
|
||||
}
|
||||
let error = super::super::build_web_transport_error(
|
||||
scope,
|
||||
&super::super::WebTransportErrorClonePayload {
|
||||
@@ -127,8 +157,12 @@ pub(super) fn fail<'s>(
|
||||
// Commit all session state and retain cleanup snapshots before settling
|
||||
// promises or erroring streams, which can expose user Promise hooks.
|
||||
let datagrams = datagrams::prepare_failure(scope, datagrams);
|
||||
backend::cancel(scope, owner);
|
||||
backend::error_streams(scope, owner, error.into());
|
||||
for pending in pending_values {
|
||||
queue(scope, owner, reject_operation, pending);
|
||||
let object = v8::Local::<v8::Object>::try_from(pending).expect("pending operation");
|
||||
let resolver = get_private_value(scope, object, streams::RESOLVER).unwrap_or(pending);
|
||||
queue(scope, owner, reject_operation, resolver);
|
||||
}
|
||||
closed.reject(scope, error.into());
|
||||
closed.get_promise(scope).mark_as_handled();
|
||||
@@ -137,6 +171,7 @@ pub(super) fn fail<'s>(
|
||||
super::super::stream_adapter::error_stream(scope, incoming_bidi, error.into());
|
||||
super::super::stream_adapter::error_stream(scope, incoming_uni, error.into());
|
||||
datagrams::finish_failure(scope, datagrams, error.into());
|
||||
error
|
||||
}
|
||||
|
||||
fn reject_operation<'s>(
|
||||
@@ -190,3 +225,28 @@ fn empty_group_stats<'s>(
|
||||
}
|
||||
resolver.resolve(scope, stats.into());
|
||||
}
|
||||
|
||||
pub(super) fn queue_unsupported<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
resolver: v8::Local<'s, v8::Value>,
|
||||
) {
|
||||
queue(scope, owner, unsupported_operation, resolver);
|
||||
}
|
||||
fn unsupported_operation<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
_rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let resolver = resolver(args.data());
|
||||
let context = resolver
|
||||
.get_creation_context(scope)
|
||||
.expect("operation realm");
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
let error = super::super::new_dom_exception_value(
|
||||
scope,
|
||||
"This native WebTransport operation is not available.",
|
||||
"NotSupportedError",
|
||||
);
|
||||
resolver.reject(scope, error);
|
||||
}
|
||||
|
||||
@@ -557,6 +557,7 @@ impl PageScriptHost {
|
||||
media_element_events: super::media_element_events::MediaElementEventState::default(),
|
||||
media_playback: super::media_playback::MediaPlaybackState::default(),
|
||||
webrtc_tasks: super::webrtc_tasks::WebRtcTaskState::default(),
|
||||
webtransport_tasks: super::webtransport_tasks::WebTransportTaskState::default(),
|
||||
element_toggle_events: super::element_toggle_events::ElementToggleEventState::default(),
|
||||
form_navigations: super::form_navigations::FormNavigationState::default(),
|
||||
text_track_default_modes:
|
||||
|
||||
@@ -757,6 +757,7 @@ impl PageScriptHost {
|
||||
}
|
||||
|
||||
pub(crate) fn retire_all_document_resource_loaders(&mut self) {
|
||||
self.webtransport_tasks.retain(|_| false);
|
||||
let retired = self.document_resource_loaders.retire_all();
|
||||
for loader in retired {
|
||||
let registry_id = loader.load_diagnostics().registry_id;
|
||||
|
||||
@@ -136,6 +136,7 @@ mod media_loads;
|
||||
mod media_playback;
|
||||
mod misc_platform_api_tasks;
|
||||
mod webrtc_tasks;
|
||||
mod webtransport_tasks;
|
||||
pub(crate) use media_loads::PendingMediaLoadTerminalFollowup;
|
||||
mod text_track_loads;
|
||||
pub(crate) use text_track_loads::{
|
||||
@@ -1086,6 +1087,7 @@ pub(crate) struct PageScriptHost {
|
||||
media_element_events: media_element_events::MediaElementEventState,
|
||||
media_playback: media_playback::MediaPlaybackState,
|
||||
webrtc_tasks: webrtc_tasks::WebRtcTaskState,
|
||||
webtransport_tasks: webtransport_tasks::WebTransportTaskState,
|
||||
element_toggle_events: element_toggle_events::ElementToggleEventState,
|
||||
form_navigations: form_navigations::FormNavigationState,
|
||||
text_track_default_modes: text_track_default_modes::TextTrackDefaultModeState,
|
||||
|
||||
@@ -2645,6 +2645,7 @@ impl PageScriptHost {
|
||||
self.retire_canvas_blob_execution_context_owner(execution_context_owner);
|
||||
let retired_webcrypto_count =
|
||||
self.retire_webcrypto_execution_context_owner(execution_context_owner);
|
||||
self.retire_webtransport_execution_context_owner(execution_context_owner);
|
||||
self.retire_opfs_execution_context_owner(execution_context_owner);
|
||||
let retired_worker_count =
|
||||
self.retire_workers_for_execution_context_owner(execution_context_owner);
|
||||
|
||||
@@ -115,6 +115,7 @@ impl PageScriptHost {
|
||||
self.retire_web_locks_context_token(realm_token);
|
||||
let canvas_blobs = self.retire_canvas_blob_context_token(realm_token);
|
||||
let crypto = self.retire_webcrypto_context_token(realm_token);
|
||||
self.retire_webtransport_context_token(realm_token);
|
||||
let fonts = self.retire_font_face_loads_for_context_token(realm_token);
|
||||
self.retire_opfs_context_token(realm_token);
|
||||
let workers = self.retire_workers_for_context_token(realm_token);
|
||||
@@ -184,6 +185,7 @@ impl PageScriptHost {
|
||||
self.retire_web_locks_execution_context_owner(owner);
|
||||
self.retire_canvas_blob_execution_context_owner(owner);
|
||||
self.retire_webcrypto_execution_context_owner(owner);
|
||||
self.retire_webtransport_execution_context_owner(owner);
|
||||
self.retire_opfs_execution_context_owner(owner);
|
||||
self.retire_workers_for_execution_context_owner(owner);
|
||||
self.disconnect_shared_worker_clients_for_execution_context_owner(owner);
|
||||
|
||||
@@ -0,0 +1,123 @@
|
||||
use super::window_document_tasks::{PendingWindowTask, WindowTaskLedger};
|
||||
use super::{
|
||||
PageScriptHost, RuntimeObservableContextToken, WindowExecutionContextIdentity,
|
||||
WindowExecutionContextOwner,
|
||||
};
|
||||
use crate::context_bootstrap::webtransport::{
|
||||
backend::ConnectionContext,
|
||||
networking::{Pending, Producer},
|
||||
};
|
||||
use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind};
|
||||
use crate::page_task_queue::{RendererPageWebTransportTaskId, RendererPageWebTransportTaskKind};
|
||||
|
||||
pub(super) type WebTransportTaskState = WindowTaskLedger<
|
||||
RendererPageWebTransportTaskId,
|
||||
RendererPageWebTransportTaskKind,
|
||||
Pending,
|
||||
WindowExecutionContextIdentity,
|
||||
>;
|
||||
|
||||
impl PageScriptHost {
|
||||
pub(crate) fn webtransport_connection_context(
|
||||
&self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
url: &url::Url,
|
||||
) -> Option<ConnectionContext> {
|
||||
let target = self.current_window_document_task_target(scope)?;
|
||||
let loader = self.document_resource_loader_for_dispatch_scope(target.dispatch_scope())?;
|
||||
let lease = loader.register_load(
|
||||
ResourceLoadKind::WebTransport,
|
||||
ResourceLoadDisposition::Ordinary,
|
||||
None,
|
||||
)?;
|
||||
Some(ConnectionContext {
|
||||
runner: loader.task_runner(),
|
||||
connector: loader.request_client().webtransport_connector(),
|
||||
lease,
|
||||
origin: self.window_document_origin(target.dispatch_scope())?,
|
||||
blocked: self.network_offline() || self.is_url_blocked(url),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn register_webtransport_task<'s>(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
owner: v8::Local<'s, v8::Object>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
) -> Option<Producer> {
|
||||
let context = owner.get_creation_context(scope)?;
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
let target = self.current_runtime_window_execution_context_identity(scope)?;
|
||||
let sender = self.page_task_capabilities.get()?.webtransport().clone();
|
||||
let id = self
|
||||
.webtransport_tasks
|
||||
.allocate_task_id(RendererPageWebTransportTaskId::from_raw);
|
||||
let (pending, result) = Pending::new(scope, payload);
|
||||
self.webtransport_tasks.push(PendingWindowTask::new(
|
||||
id,
|
||||
target,
|
||||
RendererPageWebTransportTaskKind::Complete,
|
||||
pending,
|
||||
));
|
||||
Some(Producer::window(result, sender, target, id))
|
||||
}
|
||||
|
||||
pub(crate) fn current_pending_webtransport_task(
|
||||
&self,
|
||||
id: RendererPageWebTransportTaskId,
|
||||
) -> Option<(
|
||||
WindowExecutionContextIdentity,
|
||||
RendererPageWebTransportTaskKind,
|
||||
)> {
|
||||
let pending = self.webtransport_tasks.pending(id)?;
|
||||
self.window_execution_context_identity_is_current(pending.target())
|
||||
.then_some((pending.target(), pending.kind()))
|
||||
}
|
||||
|
||||
pub(crate) fn apply_authorized_webtransport(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
_host_ptr: *mut PageScriptHost,
|
||||
id: RendererPageWebTransportTaskId,
|
||||
target: WindowExecutionContextIdentity,
|
||||
kind: RendererPageWebTransportTaskKind,
|
||||
) -> Option<bool> {
|
||||
let pending = self
|
||||
.webtransport_tasks
|
||||
.remove_exact(id, target, kind)?
|
||||
.into_payload();
|
||||
if !self.window_execution_context_identity_is_current(target) {
|
||||
return Some(false);
|
||||
}
|
||||
let context = pending.context(scope)?;
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
let dispatch = target.dispatch_scope();
|
||||
let previous = dispatch.enter(scope);
|
||||
let applied = pending.apply(scope);
|
||||
dispatch.restore(scope, previous);
|
||||
Some(applied)
|
||||
}
|
||||
|
||||
pub(crate) fn discard_pending_webtransport_task(
|
||||
&mut self,
|
||||
id: RendererPageWebTransportTaskId,
|
||||
) -> bool {
|
||||
self.webtransport_tasks.remove(id).is_some()
|
||||
}
|
||||
|
||||
pub(crate) fn retire_webtransport_execution_context_owner(
|
||||
&mut self,
|
||||
owner: WindowExecutionContextOwner,
|
||||
) {
|
||||
self.webtransport_tasks
|
||||
.retain(|pending| pending.target().owner() != owner);
|
||||
}
|
||||
|
||||
pub(crate) fn retire_webtransport_context_token(
|
||||
&mut self,
|
||||
token: RuntimeObservableContextToken,
|
||||
) {
|
||||
self.webtransport_tasks
|
||||
.retain(|pending| pending.target().realm_token() != token);
|
||||
}
|
||||
}
|
||||
@@ -105,6 +105,10 @@ impl<I: Copy + Eq, K: Copy + Eq, P, T: Copy + Eq> WindowTaskLedger<I, K, P, T> {
|
||||
&self.pending[index]
|
||||
}
|
||||
|
||||
pub(super) fn retain(&mut self, keep: impl FnMut(&PendingWindowTask<I, K, P, T>) -> bool) {
|
||||
self.pending.retain(keep);
|
||||
}
|
||||
|
||||
pub(super) fn remove_at(&mut self, index: usize) -> PendingWindowTask<I, K, P, T> {
|
||||
self.pending.remove(index)
|
||||
}
|
||||
|
||||
@@ -61,6 +61,7 @@ pub(crate) enum ResourceLoadKind {
|
||||
Beacon,
|
||||
CspReport,
|
||||
WebSocket,
|
||||
WebTransport,
|
||||
Dictionary,
|
||||
Manifest,
|
||||
}
|
||||
|
||||
@@ -26,6 +26,12 @@ mod main_document_task_owner;
|
||||
mod main_native_module_task;
|
||||
mod main_parser_continuation;
|
||||
mod media_element_event;
|
||||
mod webtransport;
|
||||
pub(crate) use webtransport::{
|
||||
PageWebTransportTargetEffect, PageWebTransportTurnAction, PageWebTransportTurnOutcome,
|
||||
RendererPageWebTransportOwner, RendererPageWebTransportSender, RendererPageWebTransportTask,
|
||||
RendererPageWebTransportTaskId, RendererPageWebTransportTaskKind,
|
||||
};
|
||||
mod webrtc;
|
||||
pub(crate) use webrtc::{
|
||||
PageWebRtcTargetEffect, PageWebRtcTurnAction, PageWebRtcTurnOutcome, RendererPageWebRtcOwner,
|
||||
@@ -148,24 +154,24 @@ impl<I: Copy, K: Copy, T: Copy> RendererPageWindowDocumentTask<I, K, T> {
|
||||
|
||||
/// Common settlement of one exact Window/Document event task.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub(crate) enum PageWindowDocumentTaskTargetEffect {
|
||||
pub(crate) enum PageWindowDocumentTaskTargetEffect<T = WindowDocumentTaskTarget> {
|
||||
DispatchedToCurrentOwner,
|
||||
CurrentOwnerHadNoEventTarget,
|
||||
DiscardedStaleOwner {
|
||||
current_owner: Option<RendererPageWindowDocumentTaskOwner>,
|
||||
current_owner: Option<RendererPageWindowDocumentTaskOwner<T>>,
|
||||
},
|
||||
}
|
||||
|
||||
/// Common owner-turn fact emitted after an exact Window/Document task settles.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub(crate) struct PageWindowDocumentTaskTurnAction<I, K> {
|
||||
pub(crate) owner: RendererPageWindowDocumentTaskOwner,
|
||||
pub(crate) struct PageWindowDocumentTaskTurnAction<I, K, T = WindowDocumentTaskTarget> {
|
||||
pub(crate) owner: RendererPageWindowDocumentTaskOwner<T>,
|
||||
pub(crate) task_id: I,
|
||||
pub(crate) kind: K,
|
||||
pub(crate) target_effect: PageWindowDocumentTaskTargetEffect,
|
||||
pub(crate) target_effect: PageWindowDocumentTaskTargetEffect<T>,
|
||||
}
|
||||
|
||||
impl<I, K> PageWindowDocumentTaskTurnAction<I, K> {}
|
||||
impl<I, K, T> PageWindowDocumentTaskTurnAction<I, K, T> {}
|
||||
|
||||
pub(crate) use self::bitmap_task::{
|
||||
PageBitmapTaskTargetEffect, PageBitmapTaskTurnAction, PageBitmapTaskTurnOutcome,
|
||||
|
||||
@@ -29,6 +29,7 @@ pub(crate) enum RendererPageNetworkingOwner {
|
||||
StylesheetCompletion(RendererPageStylesheetTaskOwner),
|
||||
WorkerHostBridge(RendererPageWorkerHostBridgeOwner),
|
||||
WebRtc(super::RendererPageWebRtcOwner),
|
||||
WebTransport(super::RendererPageWebTransportOwner),
|
||||
}
|
||||
|
||||
/// One concrete task in the Page-owned HTML networking source.
|
||||
@@ -41,11 +42,13 @@ pub(crate) enum RendererPageNetworkingTask {
|
||||
StylesheetCompletion(RendererPageStylesheetNetworkingTask),
|
||||
WorkerHostBridge(RendererPageWorkerHostBridgeTask),
|
||||
WebRtc(super::RendererPageWebRtcTask),
|
||||
WebTransport(super::RendererPageWebTransportTask),
|
||||
}
|
||||
|
||||
impl RendererPageNetworkingTask {
|
||||
pub(crate) fn owner(&self) -> RendererPageNetworkingOwner {
|
||||
match self {
|
||||
Self::WebTransport(task) => RendererPageNetworkingOwner::WebTransport(task.owner()),
|
||||
Self::WebRtc(task) => RendererPageNetworkingOwner::WebRtc(task.owner()),
|
||||
Self::ResourceCompletion(completion) => {
|
||||
RendererPageNetworkingOwner::ResourceCompletion(completion.owner())
|
||||
@@ -218,7 +221,8 @@ impl RendererPageNetworkingSource {
|
||||
| RendererPageNetworkingTask::TextTrackLoad(_)
|
||||
| RendererPageNetworkingTask::StylesheetCompletion(_)
|
||||
| RendererPageNetworkingTask::WorkerHostBridge(_)
|
||||
| RendererPageNetworkingTask::WebRtc(_) => None,
|
||||
| RendererPageNetworkingTask::WebRtc(_)
|
||||
| RendererPageNetworkingTask::WebTransport(_) => None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -236,7 +240,8 @@ impl RendererPageNetworkingSource {
|
||||
| RendererPageNetworkingTask::TextTrackLoad(_)
|
||||
| RendererPageNetworkingTask::StylesheetCompletion(_)
|
||||
| RendererPageNetworkingTask::WorkerHostBridge(_)
|
||||
| RendererPageNetworkingTask::WebRtc(_) => return None,
|
||||
| RendererPageNetworkingTask::WebRtc(_)
|
||||
| RendererPageNetworkingTask::WebTransport(_) => return None,
|
||||
}
|
||||
let (ready, task) = self.pop_front_task()?;
|
||||
let RendererPageNetworkingTask::ResourceCompletion(completion) = task else {
|
||||
@@ -263,6 +268,7 @@ pub(crate) enum PageNetworkingTurnAction {
|
||||
StylesheetCompletion(PageStylesheetNetworkingTurnAction),
|
||||
WorkerHostBridge(PageWorkerHostBridgeTurnAction),
|
||||
WebRtc(super::PageWebRtcTurnAction),
|
||||
WebTransport(super::PageWebTransportTurnAction),
|
||||
}
|
||||
|
||||
pub(crate) type PageNetworkingTurnOutcome = PageOwnerTurnOutcome<PageNetworkingTurnAction>;
|
||||
|
||||
@@ -1788,6 +1788,13 @@ impl RendererPageOwnedTaskSources {
|
||||
}
|
||||
|
||||
impl RendererPageTaskProducerRoutes {
|
||||
pub(crate) fn webtransport_sender(
|
||||
&self,
|
||||
root_document: crate::runtime::RendererDocumentToken,
|
||||
) -> super::RendererPageWebTransportSender {
|
||||
super::RendererPageWebTransportSender::new(self.networking.clone(), root_document)
|
||||
}
|
||||
|
||||
pub(crate) fn webrtc_sender(
|
||||
&self,
|
||||
root_document: crate::runtime::RendererDocumentToken,
|
||||
|
||||
@@ -84,6 +84,7 @@ pub(crate) struct RendererPageJsContextTaskSenders {
|
||||
media_element_event: RendererPageMediaElementEventSender,
|
||||
text_track_load: RendererPageTextTrackLoadSender,
|
||||
webrtc: super::RendererPageWebRtcSender,
|
||||
webtransport: super::RendererPageWebTransportSender,
|
||||
dedicated_worker_client_event: RendererPageDedicatedWorkerClientEventSender,
|
||||
shared_worker_client_event: RendererPageSharedWorkerClientEventSender,
|
||||
worker_host_bridge: RendererWorkerHostBridgeEventSender,
|
||||
@@ -170,6 +171,10 @@ impl RendererPageJsContextTaskSenders {
|
||||
&self.media_element_event
|
||||
}
|
||||
|
||||
pub(crate) fn webtransport(&self) -> &super::RendererPageWebTransportSender {
|
||||
&self.webtransport
|
||||
}
|
||||
|
||||
pub(crate) fn webrtc(&self) -> &super::RendererPageWebRtcSender {
|
||||
&self.webrtc
|
||||
}
|
||||
@@ -376,6 +381,7 @@ impl PageRuntimeTaskSource {
|
||||
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),
|
||||
webtransport: routes.webtransport_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,67 @@
|
||||
//! WebTransport tasks share HTML's networking FIFO; V8 payloads stay in their Host.
|
||||
use super::{
|
||||
PageWindowDocumentTaskTargetEffect, PageWindowDocumentTaskTurnAction,
|
||||
RendererPageNetworkingRoute, RendererPageNetworkingTask, RendererPageWindowDocumentTask,
|
||||
RendererPageWindowDocumentTaskOwner,
|
||||
};
|
||||
use crate::{native_bridge::WindowExecutionContextIdentity, runtime::RendererDocumentToken};
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub(crate) struct RendererPageWebTransportTaskId(u64);
|
||||
impl RendererPageWebTransportTaskId {
|
||||
pub(crate) const fn from_raw(raw: u64) -> Self {
|
||||
Self(raw)
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub(crate) enum RendererPageWebTransportTaskKind {
|
||||
Complete,
|
||||
}
|
||||
pub(crate) type RendererPageWebTransportOwner =
|
||||
RendererPageWindowDocumentTaskOwner<WindowExecutionContextIdentity>;
|
||||
pub(crate) type RendererPageWebTransportTask = RendererPageWindowDocumentTask<
|
||||
RendererPageWebTransportTaskId,
|
||||
RendererPageWebTransportTaskKind,
|
||||
WindowExecutionContextIdentity,
|
||||
>;
|
||||
pub(crate) type PageWebTransportTurnAction = PageWindowDocumentTaskTurnAction<
|
||||
RendererPageWebTransportTaskId,
|
||||
RendererPageWebTransportTaskKind,
|
||||
WindowExecutionContextIdentity,
|
||||
>;
|
||||
pub(crate) type PageWebTransportTargetEffect =
|
||||
PageWindowDocumentTaskTargetEffect<WindowExecutionContextIdentity>;
|
||||
pub(crate) type PageWebTransportTurnOutcome =
|
||||
crate::runtime::PageOwnerTurnOutcome<PageWebTransportTurnAction>;
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct RendererPageWebTransportSender {
|
||||
networking: RendererPageNetworkingRoute,
|
||||
root_document: RendererDocumentToken,
|
||||
}
|
||||
impl RendererPageWebTransportSender {
|
||||
pub(super) fn new(
|
||||
networking: RendererPageNetworkingRoute,
|
||||
root_document: RendererDocumentToken,
|
||||
) -> Self {
|
||||
Self {
|
||||
networking,
|
||||
root_document,
|
||||
}
|
||||
}
|
||||
pub(crate) fn send(
|
||||
&self,
|
||||
target: WindowExecutionContextIdentity,
|
||||
id: RendererPageWebTransportTaskId,
|
||||
kind: RendererPageWebTransportTaskKind,
|
||||
) -> bool {
|
||||
self.networking
|
||||
.send(RendererPageNetworkingTask::WebTransport(
|
||||
RendererPageWebTransportTask::new(
|
||||
RendererPageWebTransportOwner::new(self.root_document, target),
|
||||
id,
|
||||
kind,
|
||||
),
|
||||
))
|
||||
.is_ok()
|
||||
}
|
||||
}
|
||||
@@ -172,6 +172,7 @@ 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::AuthorizedCurrentPageWebTransport;
|
||||
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_webtransport;
|
||||
pub(crate) use page_webtransport::AuthorizedCurrentPageWebTransport;
|
||||
mod page_webrtc;
|
||||
pub(crate) use page_webrtc::AuthorizedCurrentPageWebRtc;
|
||||
mod page_device_sensor;
|
||||
|
||||
@@ -10,6 +10,9 @@ impl PageVm {
|
||||
task: RendererPageNetworkingTask,
|
||||
) -> anyhow::Result<PageNetworkingTurnOutcome> {
|
||||
match task {
|
||||
RendererPageNetworkingTask::WebTransport(task) => self
|
||||
.apply_selected_page_webtransport_turn(task)
|
||||
.map(|outcome| outcome.map_action(PageNetworkingTurnAction::WebTransport)),
|
||||
RendererPageNetworkingTask::WebRtc(task) => self
|
||||
.apply_selected_page_webrtc_turn(task)
|
||||
.map(|outcome| outcome.map_action(PageNetworkingTurnAction::WebRtc)),
|
||||
|
||||
@@ -18,6 +18,13 @@ impl PageVm {
|
||||
loader: &crate::network::ResourceRequestClient,
|
||||
) -> Result<()> {
|
||||
match action {
|
||||
PageNetworkingTurnAction::WebTransport(action) => {
|
||||
self.finish_selected_page_task_completion(
|
||||
action.into_page_task_completion(),
|
||||
loader,
|
||||
)
|
||||
.await?;
|
||||
}
|
||||
PageNetworkingTurnAction::WebRtc(action) => {
|
||||
self.finish_selected_page_task_completion(
|
||||
action.into_page_task_completion(),
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
use crate::page_task_queue::{
|
||||
PageWebTransportTargetEffect, PageWebTransportTurnAction, PageWebTransportTurnOutcome,
|
||||
RendererPageWebTransportOwner, RendererPageWebTransportTask, RendererPageWebTransportTaskId,
|
||||
RendererPageWebTransportTaskKind,
|
||||
};
|
||||
|
||||
use super::{
|
||||
AuthorizedCurrentWindowDocumentTask, IntoPageTaskCompletion, PageTaskCompletion, PageVm,
|
||||
};
|
||||
|
||||
impl IntoPageTaskCompletion for PageWebTransportTurnAction {
|
||||
fn into_page_task_completion(self) -> PageTaskCompletion {
|
||||
match self.target_effect {
|
||||
PageWebTransportTargetEffect::DispatchedToCurrentOwner => {
|
||||
PageTaskCompletion::CallbackCompletion
|
||||
}
|
||||
PageWebTransportTargetEffect::CurrentOwnerHadNoEventTarget => {
|
||||
PageTaskCompletion::CheckpointOnly
|
||||
}
|
||||
PageWebTransportTargetEffect::DiscardedStaleOwner { .. } => {
|
||||
PageTaskCompletion::NoCompletion
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Proof that the Page arbiter matched the PageVm namespace, exact Window realm,
|
||||
/// Host-local payload id, and WebTransport operation before V8 application.
|
||||
pub(crate) type AuthorizedCurrentPageWebTransport =
|
||||
AuthorizedCurrentWindowDocumentTask<RendererPageWebTransportTask>;
|
||||
|
||||
impl PageVm {
|
||||
fn current_page_webtransport_owner(
|
||||
&self,
|
||||
task_id: RendererPageWebTransportTaskId,
|
||||
) -> Option<(
|
||||
RendererPageWebTransportOwner,
|
||||
RendererPageWebTransportTaskKind,
|
||||
)> {
|
||||
self.vm().current_pending_webtransport_owner(
|
||||
task_id,
|
||||
self.document_lifecycle.identity().document,
|
||||
)
|
||||
}
|
||||
|
||||
pub(in crate::runtime) fn apply_selected_page_webtransport_turn(
|
||||
&mut self,
|
||||
task: RendererPageWebTransportTask,
|
||||
) -> anyhow::Result<PageWebTransportTurnOutcome> {
|
||||
let owner = task.owner();
|
||||
let task_id = task.task_id();
|
||||
let kind = task.kind();
|
||||
let current = self.current_page_webtransport_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_webtransport_body(authorization)?
|
||||
{
|
||||
PageWebTransportTargetEffect::DispatchedToCurrentOwner
|
||||
} else {
|
||||
PageWebTransportTargetEffect::CurrentOwnerHadNoEventTarget
|
||||
}
|
||||
}
|
||||
Err(stale) => {
|
||||
if stale.may_discard_local_payload() {
|
||||
self.vm_mut().discard_stale_webtransport_task(task_id);
|
||||
}
|
||||
let current_owner = stale.current_owner();
|
||||
tracing::debug!(
|
||||
?owner,
|
||||
?current_owner,
|
||||
?task_id,
|
||||
?kind,
|
||||
"discarded stale exact-Window WebTransport task"
|
||||
);
|
||||
PageWebTransportTargetEffect::DiscardedStaleOwner { current_owner }
|
||||
}
|
||||
};
|
||||
let action = PageWebTransportTurnAction {
|
||||
owner,
|
||||
task_id,
|
||||
kind,
|
||||
target_effect,
|
||||
};
|
||||
Ok(PageWebTransportTurnOutcome::new(action))
|
||||
}
|
||||
}
|
||||
@@ -753,6 +753,7 @@ mod page_task_capabilities;
|
||||
mod page_task_enqueue;
|
||||
mod parser_owned_classic;
|
||||
mod webrtc;
|
||||
mod webtransport;
|
||||
pub(crate) use parser_owned_classic::*;
|
||||
mod parser_module_terminal;
|
||||
mod popup_close;
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
use anyhow::{Result, anyhow};
|
||||
|
||||
use super::ScriptVm;
|
||||
use crate::page_task_queue::{
|
||||
RendererPageWebTransportOwner, RendererPageWebTransportTaskId, RendererPageWebTransportTaskKind,
|
||||
};
|
||||
use crate::runtime::AuthorizedCurrentPageWebTransport;
|
||||
|
||||
impl ScriptVm {
|
||||
pub(crate) fn current_pending_webtransport_owner(
|
||||
&self,
|
||||
task_id: RendererPageWebTransportTaskId,
|
||||
root_document: crate::runtime::RendererDocumentToken,
|
||||
) -> Option<(
|
||||
RendererPageWebTransportOwner,
|
||||
RendererPageWebTransportTaskKind,
|
||||
)> {
|
||||
let (target, kind) = self
|
||||
._context_host
|
||||
.borrow()
|
||||
.current_pending_webtransport_task(task_id)?;
|
||||
Some((
|
||||
RendererPageWebTransportOwner::new(root_document, target),
|
||||
kind,
|
||||
))
|
||||
}
|
||||
|
||||
/// Apply only the callback-visible body of one authorized WebTransport 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_webtransport_body(
|
||||
&mut self,
|
||||
authorization: AuthorizedCurrentPageWebTransport,
|
||||
) -> 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_webtransport(
|
||||
scope,
|
||||
host_ptr,
|
||||
task.task_id(),
|
||||
owner.target(),
|
||||
task.kind(),
|
||||
)
|
||||
.ok_or_else(|| anyhow!("authorized WebTransport task lost its exact payload"))
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn discard_stale_webtransport_task(
|
||||
&mut self,
|
||||
task_id: RendererPageWebTransportTaskId,
|
||||
) -> bool {
|
||||
self._context_host
|
||||
.borrow_mut()
|
||||
.discard_pending_webtransport_task(task_id)
|
||||
}
|
||||
}
|
||||
@@ -75,6 +75,8 @@ pub(crate) struct WorkerGlobalState {
|
||||
/// Codec completions cannot be canceled by author timer IDs.
|
||||
pub(in crate::worker) codec_tasks: super::super::codec_tasks::WorkerCodecTaskQueue,
|
||||
pub(in crate::worker) bitmap_tasks: super::super::bitmap_tasks::WorkerBitmapTasks,
|
||||
pub(in crate::worker) webtransport_tasks:
|
||||
super::super::webtransport_tasks::WorkerWebTransportTasks,
|
||||
pub(in crate::worker) web_locks_tasks: super::super::web_locks_tasks::WorkerWebLocksTasks,
|
||||
pub(in crate::worker) canvas_blob_tasks: super::super::canvas_blob_tasks::WorkerCanvasBlobTasks,
|
||||
/// Inside-settings resource authority for every request owned by this
|
||||
|
||||
@@ -181,6 +181,8 @@ pub(crate) enum WorkerMessage {
|
||||
RunCodecTask,
|
||||
/// Settle one ImageBitmap result on its owning worker event loop.
|
||||
RunBitmapTask(u64),
|
||||
/// Complete one native WebTransport operation on the networking task source.
|
||||
RunWebTransportTask(u64),
|
||||
RunWebLocksTask(u64, moli_storage_service::WebLockEvent),
|
||||
/// Settle an encoded OffscreenCanvas file on its owning worker event loop.
|
||||
RunCanvasBlobTask(u64),
|
||||
|
||||
@@ -35,6 +35,7 @@ pub(crate) use file_reading_tasks::{
|
||||
pub(crate) use networking_tasks::queue_worker_networking_task;
|
||||
pub(crate) mod web_locks_tasks;
|
||||
mod websocket_events;
|
||||
pub(crate) mod webtransport_tasks;
|
||||
|
||||
pub(crate) type WorkerScriptUpdateResources =
|
||||
std::collections::HashMap<url::Url, Result<WorkerScriptResource, String>>;
|
||||
|
||||
@@ -657,6 +657,7 @@ fn worker_has_pending_async(state: &Rc<RefCell<WorkerGlobalState>>) -> bool {
|
||||
|| !state.codec_tasks.is_empty()
|
||||
|| state.web_locks_tasks.has_pending()
|
||||
|| !state.bitmap_tasks.is_empty()
|
||||
|| !state.webtransport_tasks.is_empty()
|
||||
|| !state.canvas_blob_tasks.is_empty()
|
||||
|| !state.pending_fetches.is_empty()
|
||||
|| !state.pending_xhrs.is_empty()
|
||||
@@ -1803,6 +1804,12 @@ async fn worker_main(
|
||||
worker_isolate
|
||||
.worker_isolate_mut()
|
||||
.set_slot(worker_web_locks_tasks.clone());
|
||||
let worker_webtransport_tasks =
|
||||
super::webtransport_tasks::WorkerWebTransportTasks::new(worker_wake_tx.clone());
|
||||
worker_isolate
|
||||
.worker_isolate_mut()
|
||||
.set_slot(worker_webtransport_tasks.clone());
|
||||
|
||||
let worker_bitmap_tasks = WorkerBitmapTasks::new(worker_wake_tx.clone());
|
||||
worker_isolate
|
||||
.worker_isolate_mut()
|
||||
@@ -1894,6 +1901,7 @@ async fn worker_main(
|
||||
font_tasks: std::collections::VecDeque::new(),
|
||||
codec_tasks: worker_codec_tasks.clone(),
|
||||
bitmap_tasks: worker_bitmap_tasks.clone(),
|
||||
webtransport_tasks: worker_webtransport_tasks.clone(),
|
||||
web_locks_tasks: worker_web_locks_tasks.clone(),
|
||||
canvas_blob_tasks: worker_canvas_blob_tasks.clone(),
|
||||
loader,
|
||||
@@ -3024,6 +3032,15 @@ async fn worker_main(
|
||||
let scope = &mut v8::ContextScope::new(scope, ctx);
|
||||
drain_worker_dynamic_module_imports(scope, &state, &module_graph_fetch_tx);
|
||||
}
|
||||
WorkerLoopWake::Message(Some(WorkerMessage::RunWebTransportTask(task_id))) => {
|
||||
let scope = pin!(v8::HandleScope::new(worker_isolate.worker_isolate_mut()));
|
||||
let scope = &mut scope.init();
|
||||
let ctx = v8::Local::new(scope, &context);
|
||||
let scope = &mut v8::ContextScope::new(scope, ctx);
|
||||
worker_webtransport_tasks.settle(scope, task_id);
|
||||
perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope);
|
||||
drain_worker_dynamic_module_imports(scope, &state, &module_graph_fetch_tx);
|
||||
}
|
||||
WorkerLoopWake::Message(Some(WorkerMessage::RunBitmapTask(task_id))) => {
|
||||
// Bitmap decoding can also fulfill module top-level await.
|
||||
let scope = pin!(v8::HandleScope::new(worker_isolate.worker_isolate_mut()));
|
||||
@@ -3672,6 +3689,10 @@ async fn worker_main(
|
||||
worker_isolate
|
||||
.worker_isolate_mut()
|
||||
.remove_slot::<WorkerWebLocksTasks>();
|
||||
worker_webtransport_tasks.clear();
|
||||
worker_isolate
|
||||
.worker_isolate_mut()
|
||||
.remove_slot::<super::webtransport_tasks::WorkerWebTransportTasks>();
|
||||
worker_bitmap_tasks.clear();
|
||||
worker_isolate
|
||||
.worker_isolate_mut()
|
||||
|
||||
@@ -0,0 +1,159 @@
|
||||
//! Worker-local V8 payloads and one-shot networking completions.
|
||||
|
||||
use super::WorkerMessage;
|
||||
use crate::context_bootstrap::webtransport::{
|
||||
backend::ConnectionContext,
|
||||
networking::{Pending, Producer},
|
||||
};
|
||||
use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind};
|
||||
use std::{cell::RefCell, collections::HashMap, rc::Rc};
|
||||
use tokio::sync::mpsc;
|
||||
|
||||
#[derive(Default)]
|
||||
struct Tasks {
|
||||
next_id: u64,
|
||||
pending: HashMap<u64, Pending>,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(super) struct WorkerWebTransportTasks {
|
||||
tasks: Rc<RefCell<Tasks>>,
|
||||
wake: mpsc::UnboundedSender<WorkerMessage>,
|
||||
}
|
||||
|
||||
impl WorkerWebTransportTasks {
|
||||
pub(super) fn new(wake: mpsc::UnboundedSender<WorkerMessage>) -> Self {
|
||||
Self {
|
||||
tasks: Default::default(),
|
||||
wake,
|
||||
}
|
||||
}
|
||||
pub(super) fn is_empty(&self) -> bool {
|
||||
self.tasks.borrow().pending.is_empty()
|
||||
}
|
||||
pub(super) fn clear(&self) {
|
||||
self.tasks.borrow_mut().pending.clear();
|
||||
}
|
||||
pub(super) fn settle(&self, scope: &mut v8::PinScope<'_, '_>, id: u64) {
|
||||
let pending = self.tasks.borrow_mut().pending.remove(&id);
|
||||
if let Some(pending) = pending {
|
||||
pending.apply(scope);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn register<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
payload: v8::Local<'s, v8::Object>,
|
||||
) -> Option<Producer> {
|
||||
let queue = scope.get_slot::<WorkerWebTransportTasks>()?.clone();
|
||||
let (pending, result) = Pending::new(scope, payload);
|
||||
let id = {
|
||||
let mut tasks = queue.tasks.borrow_mut();
|
||||
tasks.next_id = tasks
|
||||
.next_id
|
||||
.checked_add(1)
|
||||
.expect("worker WebTransport task id exhausted");
|
||||
let id = tasks.next_id;
|
||||
assert!(tasks.pending.insert(id, pending).is_none());
|
||||
id
|
||||
};
|
||||
Some(Producer::worker(result, queue.wake, id))
|
||||
}
|
||||
|
||||
pub(crate) fn connection_context(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
url: &url::Url,
|
||||
) -> Option<ConnectionContext> {
|
||||
let state = super::get_worker_state(scope)?;
|
||||
let state = state.borrow();
|
||||
if !state.callback_task_delivery_allowed() {
|
||||
return None;
|
||||
}
|
||||
let lease = state.loader.register_load(
|
||||
ResourceLoadKind::WebTransport,
|
||||
ResourceLoadDisposition::Ordinary,
|
||||
None,
|
||||
)?;
|
||||
let blocked = state.network_offline
|
||||
|| state
|
||||
.blocked_url_patterns
|
||||
.iter()
|
||||
.any(|pattern| moli_fetch::url_pattern_matches(pattern, url.as_str()));
|
||||
Some(ConnectionContext {
|
||||
runner: state.loader.task_runner(),
|
||||
connector: state.loader.request_client().webtransport_connector(),
|
||||
lease,
|
||||
origin: super::global_scope::worker_global_origin(scope)?
|
||||
.ascii_serialization()
|
||||
.to_owned(),
|
||||
blocked,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::context_bootstrap::webtransport::networking::Completion;
|
||||
|
||||
#[test]
|
||||
fn webtransport_retired_worker_drops_late_completion_without_a_wake() {
|
||||
crate::ensure_v8_for_test();
|
||||
let mut isolate = v8::Isolate::new(Default::default());
|
||||
let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));
|
||||
let scope = &mut scope.init();
|
||||
let context = v8::Context::new(scope, Default::default());
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
let (wake, mut messages) = mpsc::unbounded_channel();
|
||||
let tasks = WorkerWebTransportTasks::new(wake);
|
||||
scope.set_slot(tasks.clone());
|
||||
let payload = v8::Object::new(scope);
|
||||
let producer = register(scope, payload).unwrap();
|
||||
assert!(!tasks.is_empty());
|
||||
tasks.clear();
|
||||
scope.remove_slot::<WorkerWebTransportTasks>();
|
||||
producer.send(Completion::Connected(Err("late TLS failure".into())));
|
||||
assert!(tasks.is_empty());
|
||||
assert!(matches!(
|
||||
messages.try_recv(),
|
||||
Err(mpsc::error::TryRecvError::Empty)
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn webtransport_stale_worker_wake_cannot_take_a_new_operation() {
|
||||
crate::ensure_v8_for_test();
|
||||
let mut isolate = v8::Isolate::new(Default::default());
|
||||
let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate));
|
||||
let scope = &mut scope.init();
|
||||
let context = v8::Context::new(scope, Default::default());
|
||||
let scope = &mut v8::ContextScope::new(scope, context);
|
||||
let (wake, mut messages) = mpsc::unbounded_channel();
|
||||
let tasks = WorkerWebTransportTasks::new(wake);
|
||||
scope.set_slot(tasks.clone());
|
||||
let payload = v8::Object::new(scope);
|
||||
register(scope, payload)
|
||||
.unwrap()
|
||||
.send(Completion::Connected(Err("first failure".into())));
|
||||
let WorkerMessage::RunWebTransportTask(first) = messages.try_recv().unwrap() else {
|
||||
panic!("wrong task");
|
||||
};
|
||||
tasks.clear();
|
||||
let payload = v8::Object::new(scope);
|
||||
let producer = register(scope, payload).unwrap();
|
||||
tasks.settle(scope, first);
|
||||
assert!(!tasks.is_empty());
|
||||
producer.send(Completion::Connected(Err("second failure".into())));
|
||||
let WorkerMessage::RunWebTransportTask(second) = messages.try_recv().unwrap() else {
|
||||
panic!("wrong task");
|
||||
};
|
||||
assert_ne!(first, second);
|
||||
tasks.settle(scope, second);
|
||||
assert!(tasks.is_empty());
|
||||
assert!(matches!(
|
||||
messages.try_recv(),
|
||||
Err(mpsc::error::TryRecvError::Empty)
|
||||
));
|
||||
scope.remove_slot::<WorkerWebTransportTasks>();
|
||||
}
|
||||
}
|
||||
@@ -87,7 +87,7 @@ pub(in crate::streams) struct QueuingStrategyMembers {
|
||||
size: Option<webidl::WebIdlCallbackFunction>,
|
||||
}
|
||||
|
||||
pub(in crate::streams) struct WebIdlReadableStreamSource<'s> {
|
||||
pub struct WebIdlReadableStreamSource<'s> {
|
||||
pub(in crate::streams) object: v8::Local<'s, v8::Object>,
|
||||
pub(in crate::streams) start: Option<webidl::WebIdlCallbackFunction>,
|
||||
pub(in crate::streams) pull: Option<webidl::WebIdlCallbackFunction>,
|
||||
@@ -96,7 +96,7 @@ pub(in crate::streams) struct WebIdlReadableStreamSource<'s> {
|
||||
pub(in crate::streams) byte_stream: bool,
|
||||
}
|
||||
|
||||
pub(in crate::streams) struct WebIdlWritableStreamSink<'s> {
|
||||
pub struct WebIdlWritableStreamSink<'s> {
|
||||
pub(in crate::streams) object: v8::Local<'s, v8::Object>,
|
||||
pub(in crate::streams) start: Option<webidl::WebIdlCallbackFunction>,
|
||||
pub(in crate::streams) write: Option<webidl::WebIdlCallbackFunction>,
|
||||
@@ -153,7 +153,7 @@ pub(in crate::streams) fn callback_carrier_value<'s>(
|
||||
.unwrap_or_else(|| v8::undefined(scope).into())
|
||||
}
|
||||
|
||||
pub(in crate::streams) fn parse_readable_stream_source_object<'s>(
|
||||
pub fn parse_readable_stream_source_object<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Result<WebIdlReadableStreamSource<'s>, webidl::WebIdlError> {
|
||||
@@ -168,7 +168,7 @@ pub(in crate::streams) fn parse_readable_stream_source_object<'s>(
|
||||
})
|
||||
}
|
||||
|
||||
pub(in crate::streams) fn parse_writable_stream_sink_object<'s>(
|
||||
pub fn parse_writable_stream_sink_object<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Result<WebIdlWritableStreamSink<'s>, webidl::WebIdlError> {
|
||||
|
||||
@@ -548,7 +548,7 @@ pub fn initialize_readable_stream_object<'s>(
|
||||
finish_browser_readable_stream_start(scope, stream, source, true);
|
||||
}
|
||||
|
||||
pub(in crate::streams) fn initialize_webidl_readable_stream_object<'s>(
|
||||
pub fn initialize_webidl_readable_stream_object<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
stream: v8::Local<'s, v8::Object>,
|
||||
source: Option<WebIdlReadableStreamSource<'s>>,
|
||||
@@ -831,7 +831,7 @@ pub fn initialize_writable_stream_object<'s>(
|
||||
let _ = call_named_method(scope, sink, "start", &[controller.into()]);
|
||||
}
|
||||
|
||||
pub(in crate::streams) fn initialize_webidl_writable_stream_object<'s>(
|
||||
pub fn initialize_webidl_writable_stream_object<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
stream: v8::Local<'s, v8::Object>,
|
||||
sink: Option<WebIdlWritableStreamSink<'s>>,
|
||||
|
||||
@@ -56,7 +56,7 @@ pub fn enqueue_chunk<'s>(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(in crate::streams) fn readable_stream_is_byte_stream<'s>(
|
||||
pub fn readable_stream_is_byte_stream<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
stream: v8::Local<'s, v8::Object>,
|
||||
) -> bool {
|
||||
|
||||
@@ -113,6 +113,11 @@ impl Session {
|
||||
self.0.native.send_datagram(bytes)
|
||||
}
|
||||
|
||||
/// Queue a datagram with QUIC backpressure, without blocking its owner thread.
|
||||
pub async fn send_datagram_wait(&self, bytes: Bytes) -> Result<(), SessionError> {
|
||||
self.0.native.send_datagram_wait(bytes).await
|
||||
}
|
||||
|
||||
pub async fn read_datagram(&self) -> Result<Bytes, SessionError> {
|
||||
self.0.native.read_datagram().await
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user