diff --git a/Cargo.lock b/Cargo.lock index f2f867d1088..411b8ab322a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3744,6 +3744,7 @@ dependencies = [ "moli-webidl-callback", "moli-webmcp", "moli-websocket", + "moli-webtransport", "moli-window-features", "moli-xpath", "num-bigint", diff --git a/moli-renderer-v8/Cargo.toml b/moli-renderer-v8/Cargo.toml index 0fcb03427bf..bfe71d58762 100644 --- a/moli-renderer-v8/Cargo.toml +++ b/moli-renderer-v8/Cargo.toml @@ -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"] } diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index d25ee98701d..53f1876fe1f 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -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, diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport.rs b/moli-renderer-v8/src/context_bootstrap/webtransport.rs index 8cba6948eb8..db226d19fef 100644 --- a/moli-renderer-v8/src/context_bootstrap/webtransport.rs +++ b/moli-renderer-v8/src/context_bootstrap/webtransport.rs @@ -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::(scope, &args) else { + let Some(converted) = webidl::parse_args::(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::(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; } diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport/backend.rs b/moli-renderer-v8/src/context_bootstrap/webtransport/backend.rs new file mode 100644 index 00000000000..b1cfd868060 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/webtransport/backend.rs @@ -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>, + streams: RefCell>>, + incoming: RefCell>>, + ingress: RefCell>, + graceful_close: Cell, +} + +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> { + let value = get_private_value(scope, owner, NATIVE)?; + let external = v8::Local::::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::>() }.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).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, + congestion: schema::CongestionControl, + certificate_hashes: Vec, +) { + 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::::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> { + 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(); + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport/datagrams.rs b/moli-renderer-v8/src/context_bootstrap/webtransport/datagrams.rs index c2107a449a7..53538c8ff7c 100644 --- a/moli-renderer-v8/src/context_bootstrap/webtransport/datagrams.rs +++ b/moli-renderer-v8/src/context_bootstrap/webtransport/datagrams.rs @@ -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::::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) { + 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::::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::::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::( + 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::::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::::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::::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); +} diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport/incoming_datagrams.rs b/moli-renderer-v8/src/context_bootstrap/webtransport/incoming_datagrams.rs new file mode 100644 index 00000000000..9ede6d69493 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/webtransport/incoming_datagrams.rs @@ -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, + changed: Notify, +} + +struct State { + datagrams: VecDeque<(Instant, Bytes)>, + maximum: usize, + age: Option, + discarded: bool, + closed: Option, +} + +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) -> 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) { + 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 { + 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"); + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport/networking.rs b/moli-renderer-v8/src/context_bootstrap/webtransport/networking.rs new file mode 100644 index 00000000000..764129a99e5 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/webtransport/networking.rs @@ -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), + Closed(moli_webtransport::CloseReason), + Stream(super::streams::StreamCompletion), + Datagram(Result<(), String>), +} + +pub(crate) struct Pending { + payload: v8::Global, + result: oneshot::Receiver, +} + +impl Pending { + pub(crate) fn new<'s>( + scope: &mut v8::PinScope<'s, '_>, + payload: v8::Local<'s, v8::Object>, + ) -> (Self, oneshot::Sender) { + 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::new(scope, &self.payload).get_creation_context(scope) + } +} + +enum Route { + Window { + sender: RendererPageWebTransportSender, + target: WindowExecutionContextIdentity, + id: RendererPageWebTransportTaskId, + }, + Worker { + sender: tokio::sync::mpsc::UnboundedSender, + id: u64, + }, +} + +pub(crate) struct Producer { + result: oneshot::Sender, + route: Route, +} + +impl Producer { + pub(crate) fn window( + result: oneshot::Sender, + sender: RendererPageWebTransportSender, + target: WindowExecutionContextIdentity, + id: RendererPageWebTransportTaskId, + ) -> Self { + Self { + result, + route: Route::Window { sender, target, id }, + } + } + + pub(crate) fn worker( + result: oneshot::Sender, + sender: tokio::sync::mpsc::UnboundedSender, + 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 { + 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) + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport/schema.rs b/moli-renderer-v8/src/context_bootstrap/webtransport/schema.rs index b297596b377..9577353c10f 100644 --- a/moli-renderer-v8/src/context_bootstrap/webtransport/schema.rs +++ b/moli-renderer-v8/src/context_bootstrap/webtransport/schema.rs @@ -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> { 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, #[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, #[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)] diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport/streams.rs b/moli-renderer-v8/src/context_bootstrap/webtransport/streams.rs new file mode 100644 index 00000000000..36550c8c5f5 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/webtransport/streams.rs @@ -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>), +} + +#[derive(Clone)] +enum Endpoint { + Read { + kind: ReadKind, + stop: watch::Sender>, + }, + Send { + stream: Arc>, + stop: watch::Sender>, + }, +} + +pub(crate) struct TransferError { + message: String, + code: Option, + 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>), + Datagram(Vec), + Complete, + Cancelled, +} + +pub(crate) type StreamCompletion = Result; + +#[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::::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::() }.clone() +} + +fn algorithm<'s>( + scope: &mut v8::PinScope<'s, '_>, + source: v8::Local<'s, v8::Object>, + name: &'static str, + callback: impl v8::MapFnTo, + 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::::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::::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::::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::::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::( + 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>, + 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::::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 = 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); + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/webtransport/tasks.rs b/moli-renderer-v8/src/context_bootstrap/webtransport/tasks.rs index 2e578dbf2ba..7d8c9b788ca 100644 --- a/moli-renderer-v8/src/context_bootstrap/webtransport/tasks.rs +++ b/moli-renderer-v8/src/context_bootstrap/webtransport/tasks.rs @@ -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::::try_from(args.data()).expect("WebTransport task payload"); + let payload = + v8::Local::::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::::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::::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); +} diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs index d46f5fc5492..c67aece20d8 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/core.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs @@ -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: diff --git a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs index 462b2268998..deca5b5908c 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs @@ -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; diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs index f239a969047..f4629a2ea13 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs @@ -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, diff --git a/moli-renderer-v8/src/native_bridge/context_host/popups.rs b/moli-renderer-v8/src/native_bridge/context_host/popups.rs index 1db2491fe38..fcb7118e0ec 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/popups.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/popups.rs @@ -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); diff --git a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs index c1c6842c764..af50066e982 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs @@ -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); diff --git a/moli-renderer-v8/src/native_bridge/context_host/webtransport_tasks.rs b/moli-renderer-v8/src/native_bridge/context_host/webtransport_tasks.rs new file mode 100644 index 00000000000..adb33a997ed --- /dev/null +++ b/moli-renderer-v8/src/native_bridge/context_host/webtransport_tasks.rs @@ -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 { + 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 { + 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 { + 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); + } +} diff --git a/moli-renderer-v8/src/native_bridge/context_host/window_document_tasks.rs b/moli-renderer-v8/src/native_bridge/context_host/window_document_tasks.rs index 2ca4d0424be..3476e3faad7 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/window_document_tasks.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/window_document_tasks.rs @@ -105,6 +105,10 @@ impl WindowTaskLedger { &self.pending[index] } + pub(super) fn retain(&mut self, keep: impl FnMut(&PendingWindowTask) -> bool) { + self.pending.retain(keep); + } + pub(super) fn remove_at(&mut self, index: usize) -> PendingWindowTask { self.pending.remove(index) } diff --git a/moli-renderer-v8/src/network/loads/registry.rs b/moli-renderer-v8/src/network/loads/registry.rs index 5de80caec54..4cf3c95ab8f 100644 --- a/moli-renderer-v8/src/network/loads/registry.rs +++ b/moli-renderer-v8/src/network/loads/registry.rs @@ -61,6 +61,7 @@ pub(crate) enum ResourceLoadKind { Beacon, CspReport, WebSocket, + WebTransport, Dictionary, Manifest, } diff --git a/moli-renderer-v8/src/page_task_queue.rs b/moli-renderer-v8/src/page_task_queue.rs index 8589a2f31b7..65d310642b6 100644 --- a/moli-renderer-v8/src/page_task_queue.rs +++ b/moli-renderer-v8/src/page_task_queue.rs @@ -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 RendererPageWindowDocumentTask { /// Common settlement of one exact Window/Document event task. #[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub(crate) enum PageWindowDocumentTaskTargetEffect { +pub(crate) enum PageWindowDocumentTaskTargetEffect { DispatchedToCurrentOwner, CurrentOwnerHadNoEventTarget, DiscardedStaleOwner { - current_owner: Option, + current_owner: Option>, }, } /// Common owner-turn fact emitted after an exact Window/Document task settles. #[derive(Clone, Copy, Debug, Eq, PartialEq)] -pub(crate) struct PageWindowDocumentTaskTurnAction { - pub(crate) owner: RendererPageWindowDocumentTaskOwner, +pub(crate) struct PageWindowDocumentTaskTurnAction { + pub(crate) owner: RendererPageWindowDocumentTaskOwner, pub(crate) task_id: I, pub(crate) kind: K, - pub(crate) target_effect: PageWindowDocumentTaskTargetEffect, + pub(crate) target_effect: PageWindowDocumentTaskTargetEffect, } -impl PageWindowDocumentTaskTurnAction {} +impl PageWindowDocumentTaskTurnAction {} pub(crate) use self::bitmap_task::{ PageBitmapTaskTargetEffect, PageBitmapTaskTurnAction, PageBitmapTaskTurnOutcome, diff --git a/moli-renderer-v8/src/page_task_queue/networking.rs b/moli-renderer-v8/src/page_task_queue/networking.rs index 83ff6858570..2876a8c19ff 100644 --- a/moli-renderer-v8/src/page_task_queue/networking.rs +++ b/moli-renderer-v8/src/page_task_queue/networking.rs @@ -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; diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources.rs b/moli-renderer-v8/src/page_task_queue/owner_sources.rs index c291fcaf034..a2963503907 100644 --- a/moli-renderer-v8/src/page_task_queue/owner_sources.rs +++ b/moli-renderer-v8/src/page_task_queue/owner_sources.rs @@ -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, diff --git a/moli-renderer-v8/src/page_task_queue/senders.rs b/moli-renderer-v8/src/page_task_queue/senders.rs index 62388c13d39..c2b68d4c374 100644 --- a/moli-renderer-v8/src/page_task_queue/senders.rs +++ b/moli-renderer-v8/src/page_task_queue/senders.rs @@ -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), diff --git a/moli-renderer-v8/src/page_task_queue/webtransport.rs b/moli-renderer-v8/src/page_task_queue/webtransport.rs new file mode 100644 index 00000000000..5c3380ee0af --- /dev/null +++ b/moli-renderer-v8/src/page_task_queue/webtransport.rs @@ -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; +pub(crate) type RendererPageWebTransportTask = RendererPageWindowDocumentTask< + RendererPageWebTransportTaskId, + RendererPageWebTransportTaskKind, + WindowExecutionContextIdentity, +>; +pub(crate) type PageWebTransportTurnAction = PageWindowDocumentTaskTurnAction< + RendererPageWebTransportTaskId, + RendererPageWebTransportTaskKind, + WindowExecutionContextIdentity, +>; +pub(crate) type PageWebTransportTargetEffect = + PageWindowDocumentTaskTargetEffect; +pub(crate) type PageWebTransportTurnOutcome = + crate::runtime::PageOwnerTurnOutcome; +#[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() + } +} diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs index 7e5af8ea6e3..af88082b051 100644 --- a/moli-renderer-v8/src/runtime/mod.rs +++ b/moli-renderer-v8/src/runtime/mod.rs @@ -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; diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rs index 1fc009f9ea8..4ec295d6c2e 100644 --- a/moli-renderer-v8/src/runtime/page_vm/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs @@ -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; diff --git a/moli-renderer-v8/src/runtime/page_vm/page_networking.rs b/moli-renderer-v8/src/runtime/page_vm/page_networking.rs index 1d1c2c7acde..ff2b617780f 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_networking.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_networking.rs @@ -10,6 +10,9 @@ impl PageVm { task: RendererPageNetworkingTask, ) -> anyhow::Result { 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)), diff --git a/moli-renderer-v8/src/runtime/page_vm/page_networking_task_completion.rs b/moli-renderer-v8/src/runtime/page_vm/page_networking_task_completion.rs index f5e1d0f1610..0955e50bcef 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_networking_task_completion.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_networking_task_completion.rs @@ -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(), diff --git a/moli-renderer-v8/src/runtime/page_vm/page_webtransport.rs b/moli-renderer-v8/src/runtime/page_vm/page_webtransport.rs new file mode 100644 index 00000000000..57668658048 --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/page_webtransport.rs @@ -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; + +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 { + 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)) + } +} diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs index 882c9180801..7ef1f7060f8 100644 --- a/moli-renderer-v8/src/script_vm.rs +++ b/moli-renderer-v8/src/script_vm.rs @@ -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; diff --git a/moli-renderer-v8/src/script_vm/webtransport.rs b/moli-renderer-v8/src/script_vm/webtransport.rs new file mode 100644 index 00000000000..ce7e7381db3 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/webtransport.rs @@ -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 { + 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) + } +} diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rs index 98bf8aed26d..9889df65395 100644 --- a/moli-renderer-v8/src/worker/global_scope/state.rs +++ b/moli-renderer-v8/src/worker/global_scope/state.rs @@ -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 diff --git a/moli-renderer-v8/src/worker/handle.rs b/moli-renderer-v8/src/worker/handle.rs index e5f39b280f8..3feddeb9d65 100644 --- a/moli-renderer-v8/src/worker/handle.rs +++ b/moli-renderer-v8/src/worker/handle.rs @@ -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), diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index d74417d1fed..446f4b760e4 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -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>; diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index 29999c2b467..613e1ac7e71 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -657,6 +657,7 @@ fn worker_has_pending_async(state: &Rc>) -> 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::(); + worker_webtransport_tasks.clear(); + worker_isolate + .worker_isolate_mut() + .remove_slot::(); worker_bitmap_tasks.clear(); worker_isolate .worker_isolate_mut() diff --git a/moli-renderer-v8/src/worker/webtransport_tasks.rs b/moli-renderer-v8/src/worker/webtransport_tasks.rs new file mode 100644 index 00000000000..4843311b69d --- /dev/null +++ b/moli-renderer-v8/src/worker/webtransport_tasks.rs @@ -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, +} + +#[derive(Clone)] +pub(super) struct WorkerWebTransportTasks { + tasks: Rc>, + wake: mpsc::UnboundedSender, +} + +impl WorkerWebTransportTasks { + pub(super) fn new(wake: mpsc::UnboundedSender) -> 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 { + let queue = scope.get_slot::()?.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 { + 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::(); + 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::(); + } +} diff --git a/moli-webapi/src/streams/adapter/callbacks.rs b/moli-webapi/src/streams/adapter/callbacks.rs index 53e2ac603bd..c3018f34765 100644 --- a/moli-webapi/src/streams/adapter/callbacks.rs +++ b/moli-webapi/src/streams/adapter/callbacks.rs @@ -87,7 +87,7 @@ pub(in crate::streams) struct QueuingStrategyMembers { size: Option, } -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, pub(in crate::streams) pull: Option, @@ -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, pub(in crate::streams) write: Option, @@ -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, 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, webidl::WebIdlError> { diff --git a/moli-webapi/src/streams/adapter/construction.rs b/moli-webapi/src/streams/adapter/construction.rs index 260dfbe910f..fc3e1659006 100644 --- a/moli-webapi/src/streams/adapter/construction.rs +++ b/moli-webapi/src/streams/adapter/construction.rs @@ -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>, @@ -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>, diff --git a/moli-webapi/src/streams/adapter/readable_state.rs b/moli-webapi/src/streams/adapter/readable_state.rs index 0a7417958be..e2df4db83a5 100644 --- a/moli-webapi/src/streams/adapter/readable_state.rs +++ b/moli-webapi/src/streams/adapter/readable_state.rs @@ -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 { diff --git a/moli-webtransport/src/session.rs b/moli-webtransport/src/session.rs index 21244b444e4..eeef51ff27c 100644 --- a/moli-webtransport/src/session.rs +++ b/moli-webtransport/src/session.rs @@ -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 { self.0.native.read_datagram().await }