From e85cfcd484ce9aa5254baef8160a42a76ee13453 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Tue, 3 Nov 2026 15:09:14 +0800 Subject: [PATCH] feat(fetch): carry streams through controlled service workers Preserve byte streams across FetchEvent dispatch, clone and network fallback. Keep upload and abort lifetimes independent of synthetic responses, and stream Service Worker replies to controlled Worker clients. Validation: fmt, full workspace clippy and nextest pass (25094 tests, 19 skipped). Ordinary debug and release each improve the selected original WPT cohort from 107/117 to 112/117, with every prior passing case retained. --- moli-renderer-v8/src/context_bootstrap.rs | 14 +- .../src/context_bootstrap/streams.rs | 12 +- .../context_bootstrap/streams/transferable.rs | 6 + .../streams/transferable/receiver.rs | 53 ++- .../streams/transferable/request_body.rs | 329 ++++++++++++++++++ .../streams/transferable/sender.rs | 7 +- .../streams/transferable/state.rs | 1 + .../context_host/resource_loading.rs | 33 +- .../context_host/service_workers.rs | 1 + .../src/network_host/csp_reports.rs | 1 + .../src/network_host/dictionary.rs | 1 + .../src/network_host/event_source/request.rs | 1 + .../src/network_host/fetch/bindings.rs | 4 + .../fetch/bindings/service_worker.rs | 32 +- moli-renderer-v8/src/network_host/image.rs | 1 + moli-renderer-v8/src/network_host/media.rs | 1 + moli-renderer-v8/src/network_host/preload.rs | 1 + .../src/network_host/request_upload.rs | 27 +- .../src/network_host/subresource.rs | 1 + .../src/network_host/text_track.rs | 1 + .../src/network_host/xhr/send/paths.rs | 1 + .../service_workers.rs | 16 + .../page_vm/tests/fetch_xhr/request_upload.rs | 10 + .../fetch_xhr/request_upload/controlled.rs | 248 +++++++++++++ .../src/script_vm/subresource_fetch.rs | 6 + .../subresource_fetch/pending_fetch.rs | 1 + .../script_vm/subresource_fetch/streaming.rs | 62 ++++ .../src/service_worker_runtime.rs | 33 +- .../src/service_worker_runtime/events.rs | 19 + .../src/service_worker_runtime/service.rs | 4 + .../service/event_completion.rs | 63 +++- .../service/event_dispatch.rs | 3 + .../service/fetch_settlement.rs | 128 +++++-- .../service/tests/extracted/clients.rs | 2 + .../service/tests/extracted/fetch_events.rs | 30 ++ .../tests/extracted/registration_jobs.rs | 3 + .../src/service_worker_runtime/state.rs | 7 + moli-renderer-v8/src/types.rs | 9 + .../global_scope/content_security_policy.rs | 25 ++ .../worker/global_scope/extendable_events.rs | 2 + .../src/worker/global_scope/fetch.rs | 245 +++++++++++-- .../src/worker/global_scope/network_state.rs | 14 + .../src/worker/global_scope/state.rs | 2 + .../src/worker/thread/dispatch.rs | 120 ++++++- moli-renderer-v8/src/worker/thread/mod.rs | 5 + .../lifecycle/fetch_events_and_messages.rs | 4 + .../src/worker/thread/tests/mod.rs | 1 + .../controlled-request-upload-worker.js | 31 ++ 48 files changed, 1529 insertions(+), 92 deletions(-) create mode 100644 moli-renderer-v8/src/context_bootstrap/streams/transferable/request_body.rs create mode 100644 moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload/controlled.rs create mode 100644 moli-renderer-v8/tests/fixtures/controlled-request-upload-worker.js diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 3b3dfe1c43b..0d2c99903a4 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -586,13 +586,15 @@ pub(crate) use self::stream_adapter::{ require_internal_stream_value, }; pub(crate) use self::streams::{ - ReadableStreamClonePayload, TransformStreamClonePayload, WritableStreamClonePayload, - build_readable_stream_clone_shell, build_transform_stream_clone_shell, - build_writable_stream_clone_shell, initialize_readable_stream_clone_shell, + ReadableStreamClonePayload, RequestBodyOwner, RequestBodyProducer, TransformStreamClonePayload, + WritableStreamClonePayload, build_readable_stream_clone_shell, + build_transform_stream_clone_shell, build_writable_stream_clone_shell, + initialize_readable_stream_clone_shell, initialize_request_body_stream, initialize_transform_stream_clone_shell, initialize_writable_stream_clone_shell, - new_readable_stream_from_array_buffer, new_readable_stream_from_source, - prepare_readable_stream_transfer, prepare_transform_stream_transfer, - prepare_writable_stream_transfer, proxy_fetch_body_stream, tee_fetch_body_stream, + install_request_body_abort, new_readable_stream_from_array_buffer, + new_readable_stream_from_source, prepare_readable_stream_transfer, + prepare_transform_stream_transfer, prepare_writable_stream_transfer, proxy_fetch_body_stream, + request_body_owner, tee_fetch_body_stream, transfer_request_body, }; pub(crate) use self::time_ranges::new_time_ranges_value; #[cfg(test)] diff --git a/moli-renderer-v8/src/context_bootstrap/streams.rs b/moli-renderer-v8/src/context_bootstrap/streams.rs index 6699eb70dca..2498af343ce 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams.rs @@ -351,12 +351,14 @@ pub(super) use readable::{ readable_stream_tee_callback, }; pub(crate) use transferable::{ - ReadableStreamClonePayload, TransformStreamClonePayload, WritableStreamClonePayload, - build_readable_stream_clone_shell, build_transform_stream_clone_shell, - build_writable_stream_clone_shell, initialize_readable_stream_clone_shell, + ReadableStreamClonePayload, RequestBodyOwner, RequestBodyProducer, TransformStreamClonePayload, + WritableStreamClonePayload, build_readable_stream_clone_shell, + build_transform_stream_clone_shell, build_writable_stream_clone_shell, + initialize_readable_stream_clone_shell, initialize_request_body_stream, initialize_transform_stream_clone_shell, initialize_writable_stream_clone_shell, - prepare_readable_stream_transfer, prepare_transform_stream_transfer, - prepare_writable_stream_transfer, + install_request_body_abort, prepare_readable_stream_transfer, + prepare_transform_stream_transfer, prepare_writable_stream_transfer, request_body_owner, + transfer_request_body, }; pub(super) use writable::{ writable_stream_abort_callback, writable_stream_close_callback, diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs index 32201c69378..8f83dca1680 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable.rs @@ -40,11 +40,17 @@ use moli_streams::{ mod protocol; mod receiver; +mod request_body; mod sender; mod state; mod writable; mod writable_state; +pub(crate) use request_body::{ + RequestBodyOwner, RequestBodyProducer, initialize_request_body_stream, + install_request_body_abort, request_body_owner, transfer_request_body, +}; + #[derive(Clone, Debug)] pub(crate) struct ReadableStreamClonePayload { pub(crate) port_id: MessagePortId, diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs index 8e69e8bc4d3..688f7e5073e 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/receiver.rs @@ -1,4 +1,7 @@ use super::*; +use crate::context_bootstrap::stream_adapter::{ + enqueue_byte_chunk, finish_readable_byte_stream_source_close, +}; use moli_streams::transfer::{ ReceiverCancelPlan, ReceiverEnqueueOutcome, ReceiverEnqueuePlan, ReceiverMessageErrorPlan, ReceiverMessagePlan, ReceiverPullPlan, @@ -9,12 +12,21 @@ pub(super) fn initialize<'s>( scope: &mut v8::PinScope<'s, '_>, stream: v8::Local<'s, v8::Object>, payload: &ReadableStreamClonePayload, +) -> Option<()> { + initialize_mode(scope, stream, payload, false) +} + +pub(super) fn initialize_mode<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + payload: &ReadableStreamClonePayload, + byte_stream: bool, ) -> Option<()> { let Some(port) = ensure_message_port_wrapper_for_id(scope, payload.port_id) else { payload.discard_port(scope); return None; }; - let initialized = initialize_with_port(scope, stream, port); + let initialized = initialize_with_port(scope, stream, port, byte_stream); if initialized.is_none() { payload.discard_port(scope); } @@ -26,7 +38,7 @@ pub(super) fn new_from_port<'s>( port: v8::Local<'s, v8::Object>, ) -> Option> { let stream = new_readable_stream_shell_object(scope); - initialize_with_port(scope, stream, port)?; + initialize_with_port(scope, stream, port, false)?; Some(stream) } @@ -34,11 +46,16 @@ fn initialize_with_port<'s>( scope: &mut v8::PinScope<'s, '_>, stream: v8::Local<'s, v8::Object>, port: v8::Local<'s, v8::Object>, + byte_stream: bool, ) -> Option<()> { // Keep construction free of local close side effects. The payload owner or // prepared-transfer owner must discard the complete private channel if any // required V8 machinery below cannot be published. - initialize_readable_stream_object(scope, stream, None, 0.0, None); + if byte_stream { + initialize_webidl_readable_stream_object(scope, stream, None, true, 0.0, None); + } else { + initialize_readable_stream_object(scope, stream, None, 0.0, None); + } let state = state::create(scope, stream, port); let (onmessage, onmessageerror) = build_transfer_port_handlers(scope, state, message_callback, messageerror_callback)?; @@ -101,10 +118,33 @@ fn message_callback<'s>( match state::snapshot(scope, state).plan_receiver_message(Some(kind)) { ReceiverMessagePlan::IgnoreLateMessage => {} ReceiverMessagePlan::EnqueueChunk => { - let outcome = match enqueue_chunk(scope, stream, value) { + if readable_stream_is_byte_stream(scope, stream) + && v8::Local::::try_from(value) + .is_ok_and(|chunk| chunk.byte_length() == 0) + { + // Empty upload chunks are not EOF and cannot be enqueued by + // byte controllers. Retain the read and request another chunk. + let undefined = v8::undefined(scope).into(); + if let Err(error) = post_handling_error(scope, state, MessageKind::Pull, undefined) + { + error_stream(scope, stream, error); + state::finish(scope, state); + } + rv.set_undefined(); + return; + } + let result = if readable_stream_is_byte_stream(scope, stream) { + enqueue_byte_chunk(scope, stream, value) + } else { + enqueue_chunk(scope, stream, value) + }; + let outcome = match result { Ok(()) => ReceiverEnqueueOutcome::Enqueued, Err(EnqueueChunkError::ClosedOrErrored) => ReceiverEnqueueOutcome::StreamTerminal, - Err(EnqueueChunkError::Strategy(_)) => ReceiverEnqueueOutcome::StrategyError, + Err(EnqueueChunkError::Strategy(error)) => { + error_stream(scope, stream, error); + ReceiverEnqueueOutcome::StrategyError + } }; if matches!(outcome.plan(), ReceiverEnqueuePlan::Finish) { state::finish(scope, state); @@ -112,6 +152,9 @@ fn message_callback<'s>( } ReceiverMessagePlan::CloseStreamAndFinish => { let _ = close_stream(scope, stream); + if let Err(error) = finish_readable_byte_stream_source_close(scope, stream) { + error_stream(scope, stream, error); + } state::finish(scope, state); } ReceiverMessagePlan::ErrorStreamAndFinish => { diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/request_body.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/request_body.rs new file mode 100644 index 00000000000..e263e9eeb55 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/request_body.rs @@ -0,0 +1,329 @@ +//! Fetch body pipes carry snapshotted bytes and network errors. Their source +//! remains independent of the response promise, including synthetic responses +//! which never consume their FetchEvent request body. + +use super::*; +use crate::context_bootstrap::stream_adapter::{ + begin_readable_stream_body_consumption, cancel_readable_stream_for_fetch, maybe_pull_stream, + prepare_readable_stream_read_with_steps, stream_slot_value, +}; +use moli_streams::transfer::{SenderReadResultSnapshot, SenderStartReadPlan}; + +const BYTE_BODY: &str = "__moliFetchBodyByteSender"; +const SOURCE_STATE: &str = "__moliFetchBodyTransferState"; +const ABORT_CALLBACK: &str = "__moliFetchBodyAbortCallback"; +const ABORT_SIGNAL: &str = "__moliFetchBodyAbortSignal"; +const READ_STEPS: &str = "__moliFetchBodyReadSteps"; + +pub(crate) type RequestBodyOwner = std::sync::Arc< + dyn Fn(ReadableStreamClonePayload, moli_fetch::UploadBodySender, moli_fetch::FetchCancelHandle) + + Send + + Sync, +>; + +pub(crate) struct RequestBodyProducer { + stream: Option, + sender: Option, + pub(crate) cancel: moli_fetch::FetchCancelHandle, + registry: SharedMessagePortRegistry, +} + +impl std::fmt::Debug for RequestBodyProducer { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("RequestBodyProducer") + .field("stream", &self.stream) + .finish_non_exhaustive() + } +} + +impl RequestBodyProducer { + pub(crate) fn take_stream(&mut self) -> ReadableStreamClonePayload { + self.stream.take().expect("single body producer delivery") + } + pub(crate) fn take_sender(&mut self) -> moli_fetch::UploadBodySender { + self.sender.take().expect("single body producer sender") + } +} + +impl Drop for RequestBodyProducer { + fn drop(&mut self) { + if let Some(stream) = self.stream.take() { + self.registry.discard_message_port_channel(stream.port_id()); + } + } +} + +pub(crate) fn request_body_owner( + scope: &mut v8::PinScope<'_, '_>, + send: impl Fn(RequestBodyProducer) + Send + Sync + 'static, +) -> RequestBodyOwner { + let realm = MessagePortRealmBinding::current(scope).expect("request body owner realm"); + let registry = realm.registry().clone(); + std::sync::Arc::new(move |stream, sender, cancel| { + send(RequestBodyProducer { + stream: Some(stream), + sender: Some(sender), + cancel, + registry: registry.clone(), + }); + }) +} + +pub(crate) fn initialize_request_body_stream<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + payload: &ReadableStreamClonePayload, +) -> Option<()> { + receiver::initialize_mode(scope, stream, payload, true) +} + +pub(crate) fn transfer_request_body<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + already_locked: bool, +) -> Option { + if !is_readable_stream_object(scope, stream) + || (!already_locked && readable_stream_access_snapshot(scope, stream).locked()) + { + let error = state::type_error(scope, "Body stream is locked"); + scope.throw_exception(error); + return None; + } + let realm = MessagePortRealmBinding::current(scope)?; + let registry = realm.registry().clone(); + let (sender_id, receiver_id) = registry.create_entangled_message_port_pair(realm.owner()); + let Some(port) = ensure_message_port_wrapper_for_id_in_realm(scope, sender_id, &realm) else { + discard_prepared_port_pair(scope, ®istry, None, sender_id); + return None; + }; + let state = state::create(scope, stream, port); + set_stream_slot_bool(scope, state, BYTE_BODY, true); + let Some((onmessage, onmessageerror)) = build_transfer_port_handlers( + scope, + state, + sender::message_callback, + sender::messageerror_callback, + ) else { + discard_prepared_port_pair(scope, ®istry, Some(port), sender_id); + return None; + }; + let callbacks = (|| { + let steps = [ + v8::Function::builder(chunk) + .data(state.into()) + .build(scope)?, + v8::Function::builder(close) + .data(state.into()) + .build(scope)?, + v8::Function::builder(error) + .data(state.into()) + .build(scope)?, + ] + .map(v8::Local::::from); + let steps = v8::Array::new_with_elements(scope, &steps); + set_stream_slot_value(scope, state, READ_STEPS, steps.into()); + v8::Function::builder(start_callback) + .data(state.into()) + .build(scope) + })(); + let Some(start) = callbacks else { + discard_prepared_port_pair(scope, ®istry, Some(port), sender_id); + return None; + }; + if !already_locked && !begin_readable_stream_body_consumption(scope, stream) { + discard_prepared_port_pair(scope, ®istry, Some(port), sender_id); + return None; + } + registry.detach_message_port_owner_for_transfer(receiver_id); + install_transfer_port_handlers(scope, port, onmessage, onmessageerror); + set_stream_slot_value(scope, stream, SOURCE_STATE, state.into()); + // Author pull algorithms run only after the fetch callback releases its + // host borrow and installs cancellation, as on the direct network path. + scope.enqueue_microtask(start); + Some(ReadableStreamClonePayload { + port_id: receiver_id, + }) +} + +pub(super) fn is_request_body<'s>( + scope: &mut v8::PinScope<'s, '_>, + state: v8::Local<'s, v8::Object>, +) -> bool { + stream_slot_bool(scope, state, BYTE_BODY).unwrap_or(false) +} + +pub(super) fn start_read<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>) { + if matches!( + state::snapshot(scope, state).plan_sender_start_read(), + SenderStartReadPlan::Ignore + ) { + return; + } + let Some(stream) = state::stream(scope, state) else { + return; + }; + let Some(steps) = stream_slot_array(scope, state, READ_STEPS) else { + return; + }; + let callbacks = [0, 1, 2].map(|index| { + v8::Local::::try_from( + steps.get_index(scope, index).expect("body pipe read step"), + ) + .expect("body pipe read function") + }); + state::set_read_in_flight(scope, state, true); + let pull = prepare_readable_stream_read_with_steps( + scope, + stream, + callbacks[0], + callbacks[1], + callbacks[2], + ); + if pull && state::snapshot(scope, state).active() { + maybe_pull_stream(scope, stream); + } +} + +fn active<'s>( + scope: &mut v8::PinScope<'s, '_>, + value: v8::Local<'s, v8::Value>, +) -> Option> { + let (binding, _) = crate::common_runtime::CommonRuntimeBinding::from_scope(scope)?; + binding.callback_execution_context(scope)?; + let state = v8::Local::::try_from(value).ok()?; + state::snapshot(scope, state).active().then_some(state) +} + +fn start_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + if let Some(state) = active(scope, args.data()) { + start_read(scope, state); + } +} + +fn chunk<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + let Some(state) = active(scope, args.data()) else { + return; + }; + state::set_read_in_flight(scope, state, false); + let Ok(chunk) = v8::Local::::try_from(args.get(0)) else { + fail(scope, state, None); + return; + }; + // The next source pull can mutate or detach the original backing store. + let mut bytes = vec![0; chunk.byte_length()]; + let count = chunk.copy_contents(&mut bytes); + bytes.truncate(count); + let length = bytes.len(); + let backing = v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared(); + let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing); + let copy = v8::Uint8Array::new(scope, buffer, 0, length).expect("body pipe byte snapshot"); + let plan = state::snapshot(scope, state) + .plan_sender_read_fulfilled(SenderReadResultSnapshot::new(true, false)); + sender::apply_read_fulfillment(scope, state, plan, Some(copy.into())); +} + +fn close<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + let Some(state) = active(scope, args.data()) else { + return; + }; + state::set_read_in_flight(scope, state, false); + let plan = state::snapshot(scope, state) + .plan_sender_read_fulfilled(SenderReadResultSnapshot::new(true, true)); + sender::apply_read_fulfillment(scope, state, plan, None); +} + +fn error<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + if let Some(state) = active(scope, args.data()) { + fail(scope, state, None); + } +} + +fn fail<'s>( + scope: &mut v8::PinScope<'s, '_>, + state: v8::Local<'s, v8::Object>, + cancel_reason: Option>, +) { + state::set_active(scope, state, false); + let error = state::type_error(scope, "Failed to fetch"); + let _ = protocol::post(scope, state, protocol::MessageKind::Error, error); + state::close_port(scope, state); + remove_abort(scope, state); + if let Some(stream) = state::stream(scope, state) { + cancel_readable_stream_for_fetch(scope, stream, cancel_reason.unwrap_or(error)); + } +} + +pub(crate) fn install_request_body_abort<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + signal: v8::Local<'s, v8::Object>, +) { + let Some(signal) = crate::abort_signal_route::ResolvedAbortSignal::resolve(scope, signal) + else { + return; + }; + let callback = v8::Function::builder(abort) + .data(stream.into()) + .build(scope) + .expect("request body abort algorithm"); + set_stream_slot_value(scope, stream, ABORT_CALLBACK, callback.into()); + if signal.is_aborted(scope) { + let reason = signal.reason(scope); + cancel_readable_stream_for_fetch(scope, stream, reason); + return; + } + assert!(signal.register_weak_algorithm(scope, callback)); + if let Some(state) = stream_slot_object(scope, stream, SOURCE_STATE) { + set_stream_slot_value(scope, state, ABORT_SIGNAL, signal.value().into()); + } +} + +fn abort<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _: v8::ReturnValue<'_, v8::Value>, +) { + let Ok(stream) = v8::Local::::try_from(args.data()) else { + return; + }; + if let Some(state) = stream_slot_object(scope, stream, SOURCE_STATE) { + fail(scope, state, Some(args.get(0))); + } else { + cancel_readable_stream_for_fetch(scope, stream, args.get(0)); + } +} + +pub(super) fn remove_abort<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>) { + if !is_request_body(scope, state) { + return; + } + if let Some(stream) = state::stream(scope, state) { + if let Some(signal) = stream_slot_object(scope, state, ABORT_SIGNAL) + && let Some(callback) = stream_slot_value(scope, stream, ABORT_CALLBACK) + .and_then(|value| v8::Local::::try_from(value).ok()) + && let Some(signal) = + crate::abort_signal_route::ResolvedAbortSignal::resolve(scope, signal) + { + signal.unregister_algorithm(scope, callback); + } + set_stream_slot_value(scope, state, ABORT_SIGNAL, v8::undefined(scope).into()); + set_stream_slot_value(scope, stream, ABORT_CALLBACK, v8::undefined(scope).into()); + set_stream_slot_value(scope, stream, SOURCE_STATE, v8::undefined(scope).into()); + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs index 56ba5780c72..c577bc7d98e 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/sender.rs @@ -6,6 +6,10 @@ use moli_streams::transfer::{ use protocol::{MessageKind, parts, post}; pub(super) fn start_read<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>) { + if request_body::is_request_body(scope, state) { + request_body::start_read(scope, state); + return; + } if matches!( state::snapshot(scope, state).plan_sender_start_read(), SenderStartReadPlan::Ignore @@ -81,7 +85,7 @@ fn read_fulfilled_callback<'s>( rv.set_undefined(); } -fn apply_read_fulfillment<'s>( +pub(super) fn apply_read_fulfillment<'s>( scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, v8::Object>, plan: SenderReadFulfillmentPlan, @@ -248,6 +252,7 @@ fn close_port_and_cancel_source<'s>( // Both terminal paths deactivate before reaching this helper. Release the // channel before cancellation can reenter or terminate the owning realm. state::close_port(scope, state); + request_body::remove_abort(scope, state); if let Some(stream) = state::stream(scope, state) && let Some(promise) = cancel_readable_stream(scope, stream, reason) { diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs index 737e18a118a..7aacb3e1714 100644 --- a/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs +++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/state.rs @@ -125,6 +125,7 @@ pub(super) fn finish<'s>(scope: &mut v8::PinScope<'s, '_>, state: v8::Local<'s, ) { set_active(scope, state, false); close_port(scope, state); + request_body::remove_abort(scope, state); } } diff --git a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs index 99d65a41b6e..6871bb6e163 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs @@ -1899,7 +1899,14 @@ impl JsContextHost { internal_id: u64, upload: crate::network_host::RequestUpload, ) { - let Some(pending) = self.pending_subresource_fetches.get_mut(&internal_id) else { + let pending = if self.pending_subresource_fetches.contains_key(&internal_id) { + self.pending_subresource_fetches.get_mut(&internal_id) + } else { + self.running_subresource_fetches + .get_mut(&internal_id) + .map(|state| &mut state.pending) + }; + let Some(pending) = pending else { return; }; if let PendingSubresourceContinuation::Fetch(fetch) = &mut pending.continuation { @@ -1907,6 +1914,30 @@ impl JsContextHost { } } + pub(crate) fn window_request_body_producer_delivery( + &self, + internal_id: u64, + ) -> Option<( + v8::Global, + super::WindowExecutionContextBinding, + super::OwnerDispatchScope, + crate::network::RendererResourceTaskRunner, + )> { + let pending = self + .subresource_fetch_states() + .find(|pending| pending.info.internal_id == internal_id)?; + let binding = pending.execution_context.window_realm_binding()?; + if pending.load.is_cancelled() || !binding.is_current(self) { + return None; + } + Some(( + pending.continuation.window_fetch()?.resolver()?.clone(), + binding.clone(), + pending.execution_context.dispatch_scope(), + pending.load.task_runner(), + )) + } + pub(crate) fn window_request_upload( &self, internal_id: u64, diff --git a/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs b/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs index b2e7e2a94fd..e17f1675e19 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs @@ -1877,6 +1877,7 @@ impl JsContextHost { metadata: ServiceWorkerFetchRequestMetadata, ) -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url, diff --git a/moli-renderer-v8/src/network_host/csp_reports.rs b/moli-renderer-v8/src/network_host/csp_reports.rs index 3c3fa12b8f0..8bcf505552c 100644 --- a/moli-renderer-v8/src/network_host/csp_reports.rs +++ b/moli-renderer-v8/src/network_host/csp_reports.rs @@ -370,6 +370,7 @@ fn dispatch_service_worker_content_security_policy_report( ); let request_body_text = report_request_body_text(&request); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/dictionary.rs b/moli-renderer-v8/src/network_host/dictionary.rs index 5f6aedfa034..92d9e46b4d8 100644 --- a/moli-renderer-v8/src/network_host/dictionary.rs +++ b/moli-renderer-v8/src/network_host/dictionary.rs @@ -153,6 +153,7 @@ fn start_dictionary_fetch( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/event_source/request.rs b/moli-renderer-v8/src/network_host/event_source/request.rs index 947e5ea1808..1b8f730a028 100644 --- a/moli-renderer-v8/src/network_host/event_source/request.rs +++ b/moli-renderer-v8/src/network_host/event_source/request.rs @@ -422,6 +422,7 @@ fn dispatch_service_worker_event_source<'s>( }, ); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: host.window_fetch_redirect_check(registered.internal_id), internal_id: registered.internal_id, request, diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rs index 156699c86f8..2d02c9c3122 100644 --- a/moli-renderer-v8/src/network_host/fetch/bindings.rs +++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs @@ -370,6 +370,10 @@ fn window_fetch_callback_in_relevant_realm<'s>( Ok(Some(internal_id)) => { if let Some(signal) = signal { install_window_fetch_abort_listener(scope, signal, internal_id); + if let Some(stream) = prepared.body_stream.as_ref() { + let stream = v8::Local::new(scope, stream); + crate::context_bootstrap::install_request_body_abort(scope, stream, signal); + } } rv.set(promise.into()); return; diff --git a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs index 45be9c56d8d..e784505f30c 100644 --- a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs +++ b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs @@ -5,10 +5,10 @@ use crate::service_worker_runtime::{ }; use moli_fetch::FetchCancelHandle; -pub(super) fn dispatch_service_worker_fetch( - scope: &mut v8::PinScope<'_, '_>, +pub(super) fn dispatch_service_worker_fetch<'s>( + scope: &mut v8::PinScope<'s, '_>, host: &mut JsContextHost, - resolver: v8::Local<'_, v8::PromiseResolver>, + resolver: v8::Local<'s, v8::PromiseResolver>, prepared: &PreparedWindowFetchRequest, ) -> anyhow::Result> { if !matches!(prepared.resolved_url.scheme(), "http" | "https") { @@ -87,7 +87,7 @@ pub(super) fn dispatch_service_worker_fetch( requires_preflight, ) .ok_or_else(|| anyhow::anyhow!("Failed to fetch"))?; - let request = host.service_worker_fetch_request( + let mut request = host.service_worker_fetch_request( client_id, prepared.resolved_url.clone(), prepared.method.clone(), @@ -111,7 +111,31 @@ pub(super) fn dispatch_service_worker_fetch( link_preload: false, }, ); + if prepared.body_source_is_null + && let Some(stream) = prepared.body_stream.as_ref() + { + let stream = v8::Local::new(scope, stream); + let Some(body) = crate::context_bootstrap::transfer_request_body( + scope, + stream, + prepared.body_stream_locked, + ) else { + host.take_pending_subresource_fetch(internal_id); + return Err(anyhow::anyhow!("Failed to transfer request body")); + }; + request.body_stream = Some(body); + } + let completion = host.resource_completion_sender(); + let body_owner = crate::context_bootstrap::request_body_owner(scope, move |producer| { + let _ = completion.send_async_subresource_event( + AsyncSubresourceFetchEvent::RequestBodyProducer { + internal_id, + producer, + }, + ); + }); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: Some(body_owner), redirect_check: host.window_fetch_redirect_check(internal_id), internal_id, request, diff --git a/moli-renderer-v8/src/network_host/image.rs b/moli-renderer-v8/src/network_host/image.rs index 236c5fadce2..74b9c9ddc9a 100644 --- a/moli-renderer-v8/src/network_host/image.rs +++ b/moli-renderer-v8/src/network_host/image.rs @@ -367,6 +367,7 @@ pub(crate) fn start_image_element_resource_fetch( if service_worker_controller.is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/media.rs b/moli-renderer-v8/src/network_host/media.rs index 90fa3f9e6ab..9add769da2c 100644 --- a/moli-renderer-v8/src/network_host/media.rs +++ b/moli-renderer-v8/src/network_host/media.rs @@ -179,6 +179,7 @@ pub(crate) fn start_media_element_resource_fetch( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/preload.rs b/moli-renderer-v8/src/network_host/preload.rs index 89903c254e2..ae16d1d87c3 100644 --- a/moli-renderer-v8/src/network_host/preload.rs +++ b/moli-renderer-v8/src/network_host/preload.rs @@ -275,6 +275,7 @@ fn start_resource_preload( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/request_upload.rs b/moli-renderer-v8/src/network_host/request_upload.rs index 773451cd750..3c567aba205 100644 --- a/moli-renderer-v8/src/network_host/request_upload.rs +++ b/moli-renderer-v8/src/network_host/request_upload.rs @@ -46,6 +46,30 @@ impl RequestUpload { cancel: FetchCancelHandle, ready: impl Fn(Result<(), UploadBodyError>) + Send + Sync + 'static, ) -> Result<(Self, UploadBody), v8::Local<'s, v8::Value>> { + let (sender, body) = UploadBody::channel(); + Self::with_sender( + scope, + stream, + resolver, + already_locked, + runner, + cancel, + ready, + sender, + ) + .map(|upload| (upload, body)) + } + + pub(crate) fn with_sender<'s>( + scope: &mut v8::PinScope<'s, '_>, + stream: v8::Local<'s, v8::Object>, + resolver: v8::Local<'s, v8::PromiseResolver>, + already_locked: bool, + runner: RendererResourceTaskRunner, + cancel: FetchCancelHandle, + ready: impl Fn(Result<(), UploadBodyError>) + Send + Sync + 'static, + sender: UploadBodySender, + ) -> Result> { if !already_locked && !begin_readable_stream_body_consumption(scope, stream) { return Err(v8::Exception::type_error( scope, @@ -71,7 +95,6 @@ impl RequestUpload { let steps = v8::Array::new_with_elements(scope, &steps); set_null_prototype(scope, steps.into()); set_private_value(scope, consumer, STEPS, steps.into()); - let (sender, body) = UploadBody::channel(); let upload = Self(Rc::new(Upload { consumer: v8::Global::new(scope, consumer), sender: RefCell::new(Some(sender)), @@ -87,7 +110,7 @@ impl RequestUpload { let external = v8::External::new(scope, (&mut *weak as *mut Weak).cast()); set_private_value(scope, consumer, NATIVE, external.into()); crate::v8_finalizer::track_context_owned_v8_finalizer(scope, consumer, move || drop(weak)); - Ok((upload, body)) + Ok(upload) } /// Lock synchronously, but start reads after fetch has installed its abort diff --git a/moli-renderer-v8/src/network_host/subresource.rs b/moli-renderer-v8/src/network_host/subresource.rs index e53e3a7efba..4f7d5a8978d 100644 --- a/moli-renderer-v8/src/network_host/subresource.rs +++ b/moli-renderer-v8/src/network_host/subresource.rs @@ -152,6 +152,7 @@ impl PreparedSubresourceFetch { .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/text_track.rs b/moli-renderer-v8/src/network_host/text_track.rs index 7747d912bb6..bfa41628492 100644 --- a/moli-renderer-v8/src/network_host/text_track.rs +++ b/moli-renderer-v8/src/network_host/text_track.rs @@ -153,6 +153,7 @@ pub(crate) fn start_text_track_resource_fetch( .is_some() { let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: host.service_worker_fetch_request( diff --git a/moli-renderer-v8/src/network_host/xhr/send/paths.rs b/moli-renderer-v8/src/network_host/xhr/send/paths.rs index 0e704f4491d..d4ff68cc830 100644 --- a/moli-renderer-v8/src/network_host/xhr/send/paths.rs +++ b/moli-renderer-v8/src/network_host/xhr/send/paths.rs @@ -129,6 +129,7 @@ pub(super) fn dispatch_service_worker_xhr( }, ); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: host.window_fetch_redirect_check(internal_id), internal_id, request, diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs index 251f4f0e1e4..794b6030451 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs @@ -198,9 +198,11 @@ impl RendererBrowserContextRuntime { let redirect_mode = main_resource_fetch_event_redirect_mode(destination, request.redirect_mode()); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 0, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: Some(client_id), url: request.url.clone(), @@ -237,6 +239,12 @@ impl RendererBrowserContextRuntime { } match main_resource_completion_rx.await { + Ok( + ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::Stream(_), + ) => Err(anyhow!( + "navigation requests cannot contain an author stream" + )), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), Ok(ServiceWorkerDirectFetchResult::Response(response)) => Ok(Some(*response.response)), Ok(ServiceWorkerDirectFetchResult::Failure(message)) => Err(anyhow!(message)), @@ -311,11 +319,13 @@ impl RendererBrowserContextRuntime { let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); let redirect_request = request.clone(); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: Some(moli_fetch::RequestRedirectCheck::new(move |next_url| { redirect_request.check_redirect_target(next_url) })), internal_id: 0, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request.url.clone(), @@ -351,6 +361,12 @@ impl RendererBrowserContextRuntime { } match direct_completion_rx.await { + Ok( + ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::Stream(_), + ) => Err(anyhow!( + "native subresource requests cannot contain an author stream" + )), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), Ok(ServiceWorkerDirectFetchResult::Response(response)) => Ok(Some(response)), Ok(ServiceWorkerDirectFetchResult::Failure(message)) => Err(anyhow!(message)), diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs index 05f683ab48f..5e8e2ed163b 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload.rs @@ -7,6 +7,8 @@ use tokio_rustls::rustls::{ pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer}, }; +mod controlled; + #[derive(Default)] struct Wire { bytes: Vec, @@ -111,6 +113,14 @@ impl UploadServer { .header("access-control-allow-headers", "authorization"); if request.method() == http::Method::OPTIONS { response.send_response(head.status(204).body(())?, true)?; + } else if path == "/sw.js" { + let head = head.status(200) + .header("content-type", "text/javascript") + .header("service-worker-allowed", "/").body(())?; + let mut send = response.send_response(head, false)?; + send.send_data(bytes::Bytes::from_static(include_bytes!( + "../../../../../tests/fixtures/controlled-request-upload-worker.js" + )), true)?; } else if path == "/upload" { wire.lock().headers = request.headers().clone(); events.headers.send_replace(true); diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload/controlled.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload/controlled.rs new file mode 100644 index 00000000000..3f9e761fede --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr/request_upload/controlled.rs @@ -0,0 +1,248 @@ +use super::*; + +async fn controlled_probe( + server: &UploadServer, + script: &str, + dedicated: bool, +) -> serde_json::Value { + // Blob Worker URLs cannot resolve relative request URLs. + let script = script.replace("'/", &format!("'{}", server.url)); + let mut config = FetchConfig::default(); + config.set_tls_verify_host(false); + config.set_http_no_proxy(Some("*".to_owned())); + let owner = ResourceRequestClient::new(&config).unwrap(); + let mut page = test_page_vm_with_loader_and_document_url( + &owner, + Vec::new(), + server.url.join("page").unwrap(), + ); + page.retain_standalone_request_client_owner_for_test(owner); + let executor = page.local_executor.clone(); + let source = format!( + r#" + (async () => {{ + globalThis.__wsEvents = ['register']; + const registration = await navigator.serviceWorker.register('/sw.js', {{scope:'/'}}); + await navigator.serviceWorker.ready; + if (!navigator.serviceWorker.controller) await new Promise(resolve => + navigator.serviceWorker.addEventListener('controllerchange', resolve, {{once:true}})); + __wsEvents.push('controlled'); + async function run() {{ {script} }} + let result; + if ({dedicated}) {{ + const url = URL.createObjectURL(new Blob(['onmessage=async()=>{{try{{postMessage(await ('+run.toString()+')());}}catch(e){{postMessage({{failure:String(e.stack||e)}});}}}};'])); + const worker = new Worker(url); + try {{ + result = await new Promise((resolve,reject) => {{ + worker.onmessage = event => resolve(event.data); + worker.onerror = event => reject(new Error(event.message)); + worker.postMessage(1); + }}); + }} finally {{worker.terminate();URL.revokeObjectURL(url);}} + }} else result = await run(); + await registration.unregister(); + return result; + }})().then(value => globalThis.__controlledUploadResult = value, + error => globalThis.__controlledUploadResult = {{failure:String(error.stack||error)}}) + .finally(() => globalThis.__controlledUploadDone = true); + "# + ); + let result = executor + .run(async move { + page.vm_mut().eval(&source)?; + drive_page_work_until_done_with_explicit_producer_admission( + &mut page, + "String(globalThis.__controlledUploadDone===true)", + "controlled author upload should complete", + |page| { + page.runtime_hooks + .browser_context_runtime + .drain_service_worker_service_lane(); + }, + ) + .await?; + page.vm_mut() + .eval("JSON.stringify(globalThis.__controlledUploadResult)") + }) + .await + .unwrap(); + serde_json::from_str(&result).unwrap() +} + +#[tokio::test] +async fn controlled_upload_snapshots_views_and_exposes_byob_across_window_and_worker() { + run_page_vm_async_test(async { + for dedicated in [false, true] { + let server = UploadServer::new(false, 200).await.unwrap(); + let result = controlled_probe(&server, r#" + const backing = new Uint8Array([88,0,255,65,66,99]); + const body = new ReadableStream({ + start(c){c.enqueue(backing.subarray(1,5));c.enqueue(new Uint8Array());}, + pull(c){backing.fill(123);c.enqueue(new Uint8Array([3,4]));c.close();} + },{highWaterMark:0}); + ReadableStream.prototype.getReader = () => {throw Error('public input getReader');}; + ReadableStreamDefaultReader.prototype.read = () => {throw Error('public input read');}; + const request = new Request('/upload?mode=byob',{method:'POST',body,duplex:'half'}); + const response = await fetch(request); + return {bytes:await response.json(),locked:body.locked,used:request.bodyUsed}; + "#, dedicated).await; + assert_eq!(result, serde_json::json!({"bytes":[0,255,65,66,3,4],"locked":true,"used":true}), "dedicated={dedicated}"); + assert!(server.wire.lock().bytes.is_empty()); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_fallback_clone_and_forward_send_bytes_before_eof() { + run_page_vm_async_test(async { + for dedicated in [false, true] { + for mode in ["fallback", "clone", "forward"] { + let server = UploadServer::new(false, 200).await.unwrap(); + let script = r#" + let controller,settled=false; + const body = new ReadableStream({start(c){controller=c;c.enqueue(new Uint8Array([0,255,65,66]));}}); + const promise=fetch('/upload?mode=MODE',{method:'POST',body,duplex:'half'}) + .then(async response=>{settled=true;return response.text();}); + await (await fetch('/first')).text(); + if(settled)throw Error('fetch settled before request EOF'); + controller.enqueue(new Uint8Array()); + controller.enqueue(new Uint8Array(196613).fill(7));controller.close(); + const text=await promise;await (await fetch('/finished')).text(); + return {text,locked:body.locked}; + "#.replace("MODE", mode); + let result=controlled_probe(&server,&script,dedicated).await; + assert_eq!(result,serde_json::json!({"text":"uploaded","locked":true}),"mode={mode}, dedicated={dedicated}"); + { + let wire=server.wire.lock();assert!(wire.ended); + assert_eq!(&wire.bytes[..4],&[0,255,65,66]);assert_eq!(wire.bytes.len(),196617); + assert!(wire.bytes[4..].iter().all(|byte|*byte==7)); + assert!(wire.headers.get("content-length").is_none()); + } + server.shutdown().await; + } + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_retains_backpressure_through_fallback_and_forward() { + run_page_vm_async_test(async { + for mode in ["fallback","forward"] { + let server=UploadServer::new(true,200).await.unwrap(); + // Keep 4 MiB on the wire while limiting external owner turns in + // this standalone PageVm's explicitly admitted Service Worker lane. + let script=r#" + let pulls=0,settled=false; + const body=new ReadableStream({pull(c){c.enqueue(new Uint8Array(262144).fill(1));if(++pulls===16)c.close();}},{highWaterMark:0}); + const promise=fetch('/upload?mode=MODE',{method:'POST',body,duplex:'half'}) + .then(async response=>{settled=true;return response.text();}); + __wsEvents.push('await headers'); + await (await fetch('/headers')).text();const bounded=pulls<16&&!settled; + __wsEvents.push('headers, pulls='+pulls); + await (await fetch('/release')).text(); + __wsEvents.push('released, pulls='+pulls); + const text=await promise; + await (await fetch('/finished')).text();return {bounded,pulls,text}; + "#.replace("MODE",mode); + let result=controlled_probe(&server,&script,false).await; + assert_eq!(result,serde_json::json!({"bounded":true,"pulls":16,"text":"uploaded"}),"mode={mode}"); + assert_eq!(server.wire.lock().bytes.len(),4*1024*1024); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_echo_exposes_headers_and_bytes_before_source_eof() { + run_page_vm_async_test(async { + for dedicated in [false, true] { + let server = UploadServer::new(false, 200).await.unwrap(); + let result = controlled_probe(&server, r#" + let controller; + const body = new ReadableStream({start(c){controller=c;c.enqueue(new Uint8Array([0,255]));}}); + const response = await fetch('/upload?mode=echo',{method:'POST',body,duplex:'half'}); + const reader = response.body.getReader(),first = await reader.read(); + controller.enqueue(new Uint8Array([65,66]));controller.close(); + const bytes = Array.from(first.value); + while (true) {const {value,done}=await reader.read();if(done)break;bytes.push(...value);} + return {status:response.status,bytes}; + "#, dedicated).await; + assert_eq!(result, serde_json::json!({"status":200,"bytes":[0,255,65,66]}), "dedicated={dedicated}"); + assert!(server.wire.lock().bytes.is_empty()); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_synthetic_responses_keep_body_errors_and_abort_lifetimes() { + run_page_vm_async_test(async { + for dedicated in [false,true] { + let server=UploadServer::new(false,200).await.unwrap(); + let result=controlled_probe(&server,r#" + const rows=[]; + for(const kind of ['open','error','invalid']){ + const controller=new AbortController(),reason={marker:'after response'}; + let cancelled=0,same=false; + const body=new ReadableStream({start(c){if(kind==='error')c.error(Error('source'));else {c.enqueue(kind==='invalid'?'wrong':new Uint8Array([65,66]));if(kind==='invalid')c.close();}},cancel(value){cancelled++;same=value===reason;}}); + const response=await fetch('/upload?mode=constant',{method:'POST',body,duplex:'half',signal:controller.signal}); + const text=await response.text(),before=cancelled;controller.abort(reason); + rows.push({kind,text,before,cancelled,same}); + } + for(const kind of ['error','invalid']){ + const body=new ReadableStream({start(c){if(kind==='error')c.error(Error('source'));else {c.enqueue('wrong');c.close();}}}); + const response=await fetch('/upload?mode=echo',{method:'POST',body,duplex:'half'}); + let name;try{await response.text();}catch(error){name=error.name;} + rows.push({kind,status:response.status,name}); + }return rows; + "#,dedicated).await; + assert_eq!(result,serde_json::json!([ + {"kind":"open","text":"constant","before":0,"cancelled":1,"same":true}, + {"kind":"error","text":"constant","before":0,"cancelled":0,"same":false}, + {"kind":"invalid","text":"constant","before":0,"cancelled":0,"same":false}, + {"kind":"error","status":200,"name":"TypeError"}, + {"kind":"invalid","status":200,"name":"TypeError"} + ]),"dedicated={dedicated}"); + server.shutdown().await; + } + }).await; +} + +#[tokio::test] +async fn controlled_upload_rejects_used_fallback_but_keeps_source_abort_algorithm() { + run_page_vm_async_test(async { + let server=UploadServer::new(false,200).await.unwrap(); + let result=controlled_probe(&server,r#" + const controller=new AbortController(),reason={marker:'used fallback'}; + let cancelled=0,same=false; + const body=new ReadableStream({start(c){c.enqueue(new Uint8Array([65]));},cancel(value){cancelled++;same=value===reason;}}); + let name;try{await fetch('/upload?mode=used',{method:'POST',body,duplex:'half',signal:controller.signal});}catch(error){name=error.name;} + const before=cancelled;controller.abort(reason);return {name,before,cancelled,same}; + "#,false).await; + assert_eq!(result,serde_json::json!({"name":"TypeError","before":0,"cancelled":1,"same":true})); + assert!(server.wire.lock().bytes.is_empty()); + server.shutdown().await; + }).await; +} + +#[tokio::test] +async fn controlled_upload_checks_source_before_synthetic_redirect_method_rewriting() { + run_page_vm_async_test(async { + let server=UploadServer::new(false,200).await.unwrap(); + let result=controlled_probe(&server,r#" + const rows=[]; + for(const status of [301,302,303,307,308]){ + const body=new ReadableStream({start(c){c.enqueue(new Uint8Array([65]));c.close();}}); + try{const response=await fetch('/upload?mode=redirect&status='+status,{method:'POST',body,duplex:'half'});rows.push({status,text:await response.text()});} + catch(error){rows.push({status,name:error.name});} + }return rows; + "#,false).await; + assert_eq!(result,serde_json::json!([ + {"status":301,"name":"TypeError"},{"status":302,"name":"TypeError"}, + {"status":303,"text":"uploaded"},{"status":307,"name":"TypeError"}, + {"status":308,"name":"TypeError"} + ])); + server.shutdown().await; + }).await; +} diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch.rs index 25a3c9d537a..078c1c59b34 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch.rs @@ -774,6 +774,12 @@ fn async_subresource_trace_fields_for_event( event: &AsyncSubresourceFetchEvent, ) -> AsyncSubresourceTraceFields { match event { + AsyncSubresourceFetchEvent::RequestBodyProducer { internal_id, .. } => { + AsyncSubresourceTraceFields { + internal_id: Some(*internal_id), + ..Default::default() + } + } AsyncSubresourceFetchEvent::RequestUploadReady { internal_id, .. } => { AsyncSubresourceTraceFields { internal_id: Some(*internal_id), diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs index 8a08670f7cc..7f0d80c14d1 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs @@ -490,6 +490,7 @@ impl ScriptVm { let request_client = pending.load.request_client(); let resource_task_runner = pending.load.task_runner(); let dispatch = crate::service_worker_runtime::ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: self._context_host.borrow().service_worker_fetch_request( diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs index e45e443dd16..737206679b6 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs @@ -424,6 +424,10 @@ impl ScriptVm { let trace_fields = async_subresource_trace_fields_for_event(&event); trace_async_subresource_stage("async_subresource_event_start", trace_fields, trace_started); let result = match event { + AsyncSubresourceFetchEvent::RequestBodyProducer { + internal_id, + producer, + } => self.apply_request_body_producer(internal_id, producer), AsyncSubresourceFetchEvent::RequestUploadReady { internal_id, result, @@ -486,6 +490,64 @@ impl ScriptVm { trace_async_subresource_stage("async_subresource_event_done", trace_fields, trace_started); result } + fn apply_request_body_producer( + &mut self, + internal_id: u64, + mut producer: crate::context_bootstrap::RequestBodyProducer, + ) -> Result { + let host = self._context_host.clone(); + self.renderer_document_isolate + .with_entered_renderer_document_isolate(|isolate| { + let scope = pin!(v8::HandleScope::new(isolate)); + let scope = &mut scope.init(); + let Some((resolver, binding, dispatch, runner)) = host + .borrow() + .window_request_body_producer_delivery(internal_id) + else { + return Ok(AsyncSubresourceFetchBodyActivity::NoWindowRealmEntered); + }; + let context = v8::Local::new(scope, binding.context_global()); + let scope = &mut v8::ContextScope::new(scope, context); + let previous = enter_subresource_owner_async_scope(&host, scope, dispatch); + let stream = crate::context_bootstrap::build_readable_stream_clone_shell(scope); + let payload = producer.take_stream(); + if crate::context_bootstrap::initialize_request_body_stream(scope, stream, &payload) + .is_some() + { + let resolver = v8::Local::new(scope, resolver); + let completion = host.borrow().resource_completion_sender(); + match crate::network_host::RequestUpload::with_sender( + scope, + stream, + resolver, + false, + runner, + producer.cancel.clone(), + move |result| { + let _ = completion.send_async_subresource_event( + AsyncSubresourceFetchEvent::RequestUploadReady { + internal_id, + result, + }, + ); + }, + producer.take_sender(), + ) { + Ok(upload) => { + host.borrow_mut() + .set_window_request_upload(internal_id, upload.clone()); + upload.start(scope); + } + Err(reason) => { + resolver.reject(scope, reason); + } + } + } + defer_subresource_owner_async_scope(&host, scope, dispatch, previous); + Ok(AsyncSubresourceFetchBodyActivity::WindowRealmEntered) + }) + } + fn apply_request_upload_ready( &mut self, internal_id: u64, diff --git a/moli-renderer-v8/src/service_worker_runtime.rs b/moli-renderer-v8/src/service_worker_runtime.rs index 5a01f094781..62962f63200 100644 --- a/moli-renderer-v8/src/service_worker_runtime.rs +++ b/moli-renderer-v8/src/service_worker_runtime.rs @@ -38,22 +38,23 @@ pub(crate) use events::{ ServiceWorkerClientNavigateResult, ServiceWorkerClientsOpenWindow, ServiceWorkerClientsOpenWindowError, ServiceWorkerClientsOpenWindowResult, ServiceWorkerCloseNotification, ServiceWorkerDirectFetchResponse, - ServiceWorkerDirectFetchResult, ServiceWorkerFetchCompletion, ServiceWorkerFetchDispatch, - ServiceWorkerFetchEvent, ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, - ServiceWorkerFetchResponse, ServiceWorkerFetchResult, ServiceWorkerFetchStreamChunk, - ServiceWorkerFetchStreamStarted, ServiceWorkerGetNotifications, - ServiceWorkerGetNotificationsResult, ServiceWorkerLifecycleCompletion, - ServiceWorkerLifecycleEvent, ServiceWorkerLifecycleEventKind, ServiceWorkerMessageCompletion, - ServiceWorkerMessageEvent, ServiceWorkerNavigationPreloadFailure, - ServiceWorkerNavigationPreloadResponseStarted, ServiceWorkerNavigationPreloadStreamChunk, - ServiceWorkerNavigationPreloadStreamFinished, ServiceWorkerNotificationAction, - ServiceWorkerNotificationCompletion, ServiceWorkerNotificationEvent, - ServiceWorkerNotificationMetadata, ServiceWorkerNotificationSnapshot, - ServiceWorkerPeriodicSyncCompletion, ServiceWorkerPeriodicSyncEvent, - ServiceWorkerPeriodicSyncGetTags, ServiceWorkerPeriodicSyncGetTagsResult, - ServiceWorkerPeriodicSyncRegistration, ServiceWorkerPeriodicSyncRegistrationResult, - ServiceWorkerPeriodicSyncUnregistration, ServiceWorkerPeriodicSyncUnregistrationResult, - ServiceWorkerPushCompletion, ServiceWorkerPushEvent, ServiceWorkerPushGetSubscription, + ServiceWorkerDirectFetchResult, ServiceWorkerDirectFetchStreamEvent, + ServiceWorkerFetchCompletion, ServiceWorkerFetchDispatch, ServiceWorkerFetchEvent, + ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerFetchResponse, + ServiceWorkerFetchResult, ServiceWorkerFetchStreamChunk, ServiceWorkerFetchStreamStarted, + ServiceWorkerGetNotifications, ServiceWorkerGetNotificationsResult, + ServiceWorkerLifecycleCompletion, ServiceWorkerLifecycleEvent, ServiceWorkerLifecycleEventKind, + ServiceWorkerMessageCompletion, ServiceWorkerMessageEvent, + ServiceWorkerNavigationPreloadFailure, ServiceWorkerNavigationPreloadResponseStarted, + ServiceWorkerNavigationPreloadStreamChunk, ServiceWorkerNavigationPreloadStreamFinished, + ServiceWorkerNotificationAction, ServiceWorkerNotificationCompletion, + ServiceWorkerNotificationEvent, ServiceWorkerNotificationMetadata, + ServiceWorkerNotificationSnapshot, ServiceWorkerPeriodicSyncCompletion, + ServiceWorkerPeriodicSyncEvent, ServiceWorkerPeriodicSyncGetTags, + ServiceWorkerPeriodicSyncGetTagsResult, ServiceWorkerPeriodicSyncRegistration, + ServiceWorkerPeriodicSyncRegistrationResult, ServiceWorkerPeriodicSyncUnregistration, + ServiceWorkerPeriodicSyncUnregistrationResult, ServiceWorkerPushCompletion, + ServiceWorkerPushEvent, ServiceWorkerPushGetSubscription, ServiceWorkerPushGetSubscriptionResult, ServiceWorkerPushSubscribe, ServiceWorkerPushSubscribeResult, ServiceWorkerPushSubscriptionSnapshot, ServiceWorkerPushUnsubscribe, ServiceWorkerPushUnsubscribeResult, diff --git a/moli-renderer-v8/src/service_worker_runtime/events.rs b/moli-renderer-v8/src/service_worker_runtime/events.rs index ac230c2e24d..d204207e9a9 100644 --- a/moli-renderer-v8/src/service_worker_runtime/events.rs +++ b/moli-renderer-v8/src/service_worker_runtime/events.rs @@ -473,6 +473,7 @@ pub(crate) struct ServiceWorkerFetchRequest { /// Isomorphically decoded wire bytes, ready for the worker's Fetch Headers. pub(crate) headers: Vec<(String, String)>, pub(crate) body: Option, + pub(crate) body_stream: Option, pub(crate) destination: ServiceWorkerRequestDestination, pub(crate) request_mode: moli_fetch::RequestMode, pub(crate) credentials_mode: moli_fetch::RequestCredentialsMode, @@ -672,6 +673,7 @@ pub(crate) struct ServiceWorkerFetchResponse { #[derive(Clone, Debug)] pub(crate) enum ServiceWorkerFetchResult { Fallback, + FallbackStream(moli_fetch::UploadBody), Response(ServiceWorkerFetchResponse), Failure(String), } @@ -739,10 +741,26 @@ pub(crate) struct MaterializedServiceWorkerFetchResponseHead { #[derive(Debug)] pub(crate) enum ServiceWorkerDirectFetchResult { Fallback, + FallbackStream(moli_fetch::UploadBody), Response(ServiceWorkerDirectFetchResponse), + Stream(Box), Failure(String), } +#[derive(Debug)] +pub(crate) struct ServiceWorkerDirectFetchStream { + pub(crate) body_source_id: crate::types::NetworkBodySourceId, + pub(crate) head: moli_fetch::ResponseHead, + pub(crate) response_filter: Option, + pub(crate) events: tokio::sync::mpsc::UnboundedReceiver, +} + +#[derive(Debug)] +pub(crate) enum ServiceWorkerDirectFetchStreamEvent { + Chunk(Vec), + Finished(Result<(), String>), +} + #[derive(Debug)] pub(crate) struct ServiceWorkerDirectFetchResponse { /// The worker response's URL before applying the request-URL fallback. @@ -760,6 +778,7 @@ pub(crate) struct ServiceWorkerFetchCompletion { } pub(crate) struct ServiceWorkerFetchDispatch { + pub(crate) request_body_owner: Option, pub(crate) internal_id: u64, pub(crate) request: ServiceWorkerFetchRequest, pub(crate) redirect_check: Option, diff --git a/moli-renderer-v8/src/service_worker_runtime/service.rs b/moli-renderer-v8/src/service_worker_runtime/service.rs index fa33e10ecb5..420de9a424d 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service.rs @@ -872,6 +872,7 @@ mod tests { request_url: Url, ) -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -900,6 +901,9 @@ mod tests { cancel_handle: moli_fetch::FetchCancelHandle, ) -> ServiceWorkerFetchJob { ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs b/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs index 8bae2c0ef3c..e73c68e4924 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/event_completion.rs @@ -159,7 +159,14 @@ impl ServiceWorkerRuntimeService { return; }; job.cancel_pending_navigation_preload(); - if let Some(version) = state.versions.get_mut(&version_id) { + if matches!( + completion.result, + ServiceWorkerFetchResult::FallbackStream(_) + ) { + state + .pending_fetch_body_uploads + .insert(completion.event_id, job.owner().clone()); + } else if let Some(version) = state.versions.get_mut(&version_id) { version.in_flight_event_count = version.in_flight_event_count.saturating_sub(1); } let unregistration_progress = @@ -186,6 +193,19 @@ impl ServiceWorkerRuntimeService { ServiceWorkerFetchResult::Fallback => { self.dispatch_fetch_fallback(job); } + ServiceWorkerFetchResult::FallbackStream(body) => { + let runtime = self.clone(); + let owner = job.owner().clone(); + let transmitted = body.transmission(); + job.resource_task_runner.spawn(async move { + let _ = transmitted.await; + runtime.finish_fetch_body_upload(completion.event_id, owner); + }); + let mut job = job; + job.request = job.request.with_upload_body(body); + job.body_stream = None; + self.dispatch_fetch_fallback(job); + } ServiceWorkerFetchResult::Response(response) => { self.complete_fetch_with_service_worker_response(job, response); } @@ -195,6 +215,45 @@ impl ServiceWorkerRuntimeService { } } + fn finish_fetch_body_upload( + &self, + event_id: ServiceWorkerEventId, + owner: ServiceWorkerRunOwner, + ) { + let (idle_timeout, lifecycle_progress) = { + let mut state = self.inner.state.lock(); + if state.pending_fetch_body_uploads.get(&event_id) != Some(&owner) { + return; + } + state.pending_fetch_body_uploads.remove(&event_id); + let Some(version) = state.versions.get_mut(&owner.version_id()) else { + return; + }; + if &version.run != owner.run_identity() { + return; + } + version.in_flight_event_count = version.in_flight_event_count.saturating_sub(1); + let mut progress = self.unregistration_progress_for_version_if_ready_locked( + &mut state, + owner.version_id(), + ); + if progress.is_empty() { + progress.extend(self.activation_progress_for_active_version_if_ready_locked( + &mut state, + owner.version_id(), + )); + } + let idle = self.maybe_schedule_idle_timeout_locked(&mut state, owner.version_id()); + (idle, progress) + }; + for progress in lifecycle_progress { + self.run_lifecycle_progress(progress); + } + if let Some(idle) = idle_timeout { + self.schedule_idle_timeout(idle); + } + } + pub(super) fn finish_message_event_completed( &self, completion: ServiceWorkerMessageCompletion, @@ -501,7 +560,7 @@ pub(super) fn service_worker_fetch_diagnostic_from_job_result( result: &ServiceWorkerFetchResult, ) -> crate::runtime::RendererServiceWorkerFetchDiagnostic { let result = match result { - ServiceWorkerFetchResult::Fallback => { + ServiceWorkerFetchResult::Fallback | ServiceWorkerFetchResult::FallbackStream(_) => { crate::runtime::RendererServiceWorkerFetchDiagnosticResult::Fallback } ServiceWorkerFetchResult::Response(response) => { diff --git a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs index 27d4fadba73..ed550c6c47b 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs @@ -241,6 +241,9 @@ impl ServiceWorkerRuntimeService { pub(crate) fn dispatch_controlled_fetch(&self, dispatch: ServiceWorkerFetchDispatch) -> bool { let request = dispatch.request.clone(); let fetch_job = ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: dispatch.request_body_owner, + body_stream: request.body_stream.clone(), request: { let origin = dispatch.network_context.request_origin.clone(); let mut network_request = moli_fetch::Request::new_browser( diff --git a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs index c80f7a6442a..312bc421f7a 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs @@ -51,6 +51,7 @@ fn service_worker_redirect_target( fn fetch_request_for_job(job: &ServiceWorkerFetchJob) -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: job.body_stream.clone(), client_id: job.client_id, resulting_client_id: job.resulting_client_id, url: job.request.url.clone(), @@ -78,7 +79,9 @@ pub(super) fn service_worker_network_fallback_request_for_job( .policy_context .network_credentials_mode(job.request.request_mode, job.request.credentials_mode), ) - .with_use_cors_preflight(job.metadata.use_cors_preflight) + .with_use_cors_preflight( + job.metadata.use_cors_preflight || job.request.body_source_is_null(), + ) .with_browser_request_metadata(service_worker_fetch_browser_metadata( job.network_context.resource_type, )) @@ -143,22 +146,24 @@ fn service_worker_fetch_can_forward_stream( response_head.final_url.as_ref(), &response_head.headers, )?; - Ok(job.direct_completion_tx.is_none() - && job.metadata.integrity.is_empty() - && !matches!( - job.network_context.resource_type, - crate::types::SubresourceResourceType::Audio - | crate::types::SubresourceResourceType::Font - | crate::types::SubresourceResourceType::Image - | crate::types::SubresourceResourceType::Media - | crate::types::SubresourceResourceType::TextTrack - | crate::types::SubresourceResourceType::Video - ) - && !is_redirect_status(response_head.status) - && matches!( - response_head.response_type.as_str(), - "default" | "basic" | "cors" - )) + Ok( + (job.direct_completion_tx.is_none() || job.request_body_owner.is_some()) + && job.metadata.integrity.is_empty() + && !matches!( + job.network_context.resource_type, + crate::types::SubresourceResourceType::Audio + | crate::types::SubresourceResourceType::Font + | crate::types::SubresourceResourceType::Image + | crate::types::SubresourceResourceType::Media + | crate::types::SubresourceResourceType::TextTrack + | crate::types::SubresourceResourceType::Video + ) + && !is_redirect_status(response_head.status) + && matches!( + response_head.response_type.as_str(), + "default" | "basic" | "cors" + ), + ) } fn apply_service_worker_synthetic_redirect( @@ -166,6 +171,9 @@ fn apply_service_worker_synthetic_redirect( response: ServiceWorkerFetchResponse, next_url: Url, ) -> Result<(), String> { + if response.status != 303 && job.request.body_source_is_null() { + return Err("Cannot replay a streaming request body after a redirect".to_owned()); + } let from_url = response .final_url .unwrap_or_else(|| job.request.url.clone()); @@ -186,6 +194,10 @@ fn apply_service_worker_synthetic_redirect( negotiated_http_version: None, }) .map_err(|error| error.to_string())?; + if response.status == 303 { + job.body_stream = None; + job.metadata.body_source_is_null = job.request.body_source_is_null(); + } job.cors_preflight_request_headers = job.request.request_headers.to_byte_strings(); Ok(()) } @@ -214,9 +226,11 @@ impl ServiceWorkerRuntimeService { crate::page_task_queue::RendererResourceCompletionSender::direct_completion_only(); let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 0, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: Some(client_id), url: request.url.clone(), @@ -255,6 +269,10 @@ impl ServiceWorkerRuntimeService { } match direct_completion_rx.await { + Ok( + ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::Stream(_), + ) => Err("worker script requests cannot contain an author stream".to_owned()), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), Ok(ServiceWorkerDirectFetchResult::Response(response)) => Ok(Some(*response.response)), Ok(ServiceWorkerDirectFetchResult::Failure(message)) => Err(message), @@ -266,12 +284,31 @@ impl ServiceWorkerRuntimeService { pub(super) fn dispatch_fetch_fallback(&self, mut job: ServiceWorkerFetchJob) { job.cancel_pending_navigation_preload(); + if let Some(stream) = job.body_stream.take() { + // Startup failure can select network fallback before a FetchEvent + // ever acquires its receiver. Return that pipe to the exact client + // script owner; IO retains only the bounded native upload. + let Some(owner) = job.request_body_owner.as_ref() else { + self.complete_fetch_with_failure( + job, + "Missing request body owner for fallback".to_owned(), + ); + return; + }; + let (sender, body) = moli_fetch::UploadBody::channel(); + owner(stream, sender, job.cancel_handle.clone()); + job.request = job.request.with_upload_body(body); + } if let Some(completion_tx) = job.direct_completion_tx.take() { if job.request.redirect_count() != 0 { self.dispatch_direct_fetch_network_fallback(job, completion_tx); return; } - let _ = completion_tx.send(ServiceWorkerDirectFetchResult::Fallback); + let result = job.request.upload_body().cloned().map_or( + ServiceWorkerDirectFetchResult::Fallback, + ServiceWorkerDirectFetchResult::FallbackStream, + ); + let _ = completion_tx.send(result); return; } let request_client = job.request_client.clone(); @@ -381,7 +418,7 @@ impl ServiceWorkerRuntimeService { return; } - let Some((completion_tx, request_client, request, streaming_started)) = ({ + let Some((completion_tx, request_client, request, streaming_started, direct)) = ({ let mut state = self.inner.state.lock(); let Some(job) = state.pending_fetch_jobs.get_mut(&started.event_id) else { return; @@ -399,6 +436,27 @@ impl ServiceWorkerRuntimeService { } } job.streaming_body_source_id = Some(started.body_source_id); + let direct = job.direct_completion_tx.take().map(|completion| { + let (sender, events) = tokio::sync::mpsc::unbounded_channel(); + job.direct_streaming_tx = Some(sender); + ( + completion, + super::super::events::ServiceWorkerDirectFetchStream { + body_source_id: started.body_source_id, + head: service_worker_fetch_stream_response_head( + job, + &started.response_head, + ), + response_filter: service_worker_fetch_response_head_filter( + &started.response_head.response_type, + started.response_head.cors_exposed_header_names.as_deref(), + started.response_head.status, + job.request.redirect_mode(), + ), + events, + }, + ) + }); Some(( job.completion_tx.clone(), job.request_client.clone(), @@ -420,11 +478,16 @@ impl ServiceWorkerRuntimeService { network_request_headers: None, head: service_worker_fetch_stream_response_head(job, &started.response_head), }, + direct, )) }) else { return; }; request_client.observe_service_worker_response_links(&request, &streaming_started.head); + if let Some((completion, stream)) = direct { + let _ = completion.send(ServiceWorkerDirectFetchResult::Stream(Box::new(stream))); + return; + } let _ = completion_tx.send_async_subresource_event( AsyncSubresourceFetchEvent::StreamingStarted(Box::new(streaming_started)), ); @@ -511,18 +574,24 @@ impl ServiceWorkerRuntimeService { } pub(super) fn finish_fetch_stream_chunk(&self, chunk: ServiceWorkerFetchStreamChunk) { - let Some(completion_tx) = ({ + let Some((completion_tx, direct)) = ({ let state = self.inner.state.lock(); state .pending_fetch_jobs .get(&chunk.event_id) .and_then(|job| { (job.streaming_body_source_id == Some(chunk.body_source_id)) - .then(|| job.completion_tx.clone()) + .then(|| (job.completion_tx.clone(), job.direct_streaming_tx.clone())) }) }) else { return; }; + if let Some(direct) = direct { + let _ = direct.send( + super::super::events::ServiceWorkerDirectFetchStreamEvent::Chunk(chunk.bytes), + ); + return; + } let _ = completion_tx.send_async_subresource_event( AsyncSubresourceFetchEvent::StreamingChunk(AsyncSubresourceStreamingChunk { body_source_id: chunk.body_source_id, @@ -660,6 +729,11 @@ impl ServiceWorkerRuntimeService { job.request_client .observe_service_worker_response_links(&job.request, &navigation_response.head()); } + if let Some(direct) = job.direct_streaming_tx.take() { + let _ = direct + .send(super::super::events::ServiceWorkerDirectFetchStreamEvent::Finished(Ok(()))); + return; + } if let Some(completion_tx) = job.direct_completion_tx.take() { let _ = completion_tx.send(ServiceWorkerDirectFetchResult::Response( ServiceWorkerDirectFetchResponse { @@ -720,6 +794,12 @@ impl ServiceWorkerRuntimeService { if network_error_text.is_none() { network_error_text = service_worker_fetch_failure_network_error_text(&message); } + if let Some(direct) = job.direct_streaming_tx.take() { + let _ = direct.send( + super::super::events::ServiceWorkerDirectFetchStreamEvent::Finished(Err(message)), + ); + return; + } if let Some(completion_tx) = job.direct_completion_tx.take() { let _ = completion_tx.send(ServiceWorkerDirectFetchResult::Failure(message)); return; @@ -1167,6 +1247,9 @@ mod tests { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2303,6 +2386,9 @@ mod tests { let completion_queue = crate::page_task_queue::RendererResourceCompletionTestHarness::new(); let request_url = url("https://example.test/app/post"); let mut job = ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&request_url); let initiator = request_url.clone(); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs index 1ffcd08944c..8686fa87fb8 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/clients.rs @@ -2329,9 +2329,11 @@ async fn controlled_fetch_from_worker_client_dispatches_to_active_worker() { let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 90, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs index ef648151d38..6eaec51be2a 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs @@ -370,6 +370,9 @@ fn pending_unregistration_waits_for_active_fetch_to_complete_before_delete() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -678,9 +681,11 @@ fn resource_store_restores_no_fetch_handler_metadata_for_controlled_fetch() { let (direct_completion_tx, mut direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( second_service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 89, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -838,6 +843,9 @@ fn restart_start_failure_rejects_pending_fetch_job() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = document_url.clone(); @@ -901,6 +909,7 @@ fn restart_start_failure_rejects_pending_fetch_job() { event_id, owner: test_run_owner(version_id, &run), request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -1624,9 +1633,11 @@ fn no_fetch_handler_controlled_fetch_falls_back_without_dispatching_event() { let (direct_completion_tx, mut direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 88, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), @@ -1716,9 +1727,11 @@ fn controlled_fetch_waits_for_activating_active_version() { assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 91, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -1826,9 +1839,11 @@ fn empty_fetch_handler_controlled_fetch_falls_back_without_dispatching_event() { let (direct_completion_tx, mut direct_completion_rx) = tokio::sync::oneshot::channel(); assert!( service.dispatch_controlled_fetch(ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id: 89, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, @@ -1906,6 +1921,7 @@ fn empty_fetch_handler_pending_start_fetch_falls_back_after_worker_start() { let client_id = client_id_for_document(&service, &document_url); let host = new_loading_test_host(version_id, &run); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), @@ -1926,6 +1942,9 @@ fn empty_fetch_handler_pending_start_fetch_falls_back_after_worker_start() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2054,6 +2073,9 @@ fn fetch_completion_schedules_idle_timeout_for_running_active_worker() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2284,6 +2306,9 @@ fn active_fetch_completion_queues_waiting_activation_after_controllees_are_gone( state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = (document_url).clone(); @@ -2477,6 +2502,9 @@ fn activating_new_worker_fails_replaced_active_fetch_and_pending_start_events() state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&document_url); let initiator = document_url.clone(); @@ -2541,6 +2569,7 @@ fn activating_new_worker_fails_replaced_active_fetch_and_pending_start_events() event_id: pending_event_id, owner: test_run_owner(active_version_id, &active_run), request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url.clone(), @@ -2562,6 +2591,7 @@ fn activating_new_worker_fails_replaced_active_fetch_and_pending_start_events() event_id: activation_wait_event_id, owner: test_run_owner(active_version_id, &active_run), request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request_url, diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs index 7145f491cea..50d22ea33bf 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs @@ -227,6 +227,9 @@ fn pending_unregistration_deletion_clears_owner_state() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + direct_streaming_tx: None, + request_body_owner: None, + body_stream: None, request: { let origin = moli_url::WebOrigin::from_url(&request_url); let initiator = request_url.clone(); diff --git a/moli-renderer-v8/src/service_worker_runtime/state.rs b/moli-renderer-v8/src/service_worker_runtime/state.rs index 8aff4607e66..694fe819362 100644 --- a/moli-renderer-v8/src/service_worker_runtime/state.rs +++ b/moli-renderer-v8/src/service_worker_runtime/state.rs @@ -181,6 +181,7 @@ pub(super) struct ServiceWorkerRuntimeState { pub(super) versions: HashMap, pub(super) pending_ready_jobs: Vec, pub(super) pending_fetch_jobs: HashMap, + pub(super) pending_fetch_body_uploads: HashMap, pub(super) lifecycle_watchers: Vec, pub(super) live_clients: HashMap, pub(super) notification_records: Vec, @@ -286,6 +287,7 @@ impl ServiceWorkerRuntimeState { versions: HashMap::new(), pending_ready_jobs: Vec::new(), pending_fetch_jobs: HashMap::new(), + pending_fetch_body_uploads: HashMap::new(), lifecycle_watchers: Vec::new(), live_clients: HashMap::new(), notification_records: Vec::new(), @@ -768,6 +770,11 @@ pub(super) enum ServiceWorkerPeriodicSyncStart { } pub(super) struct ServiceWorkerFetchJob { + pub(super) direct_streaming_tx: Option< + tokio::sync::mpsc::UnboundedSender, + >, + pub(super) request_body_owner: Option, + pub(super) body_stream: Option, pub(super) request: moli_fetch::Request, pub(super) internal_id: u64, pub(super) owner: Option, diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs index 5b4650b2ce4..363290bac88 100644 --- a/moli-renderer-v8/src/types.rs +++ b/moli-renderer-v8/src/types.rs @@ -1038,6 +1038,10 @@ pub(crate) enum AsyncSubresourceFetchEventTarget { #[derive(Debug)] pub(super) enum AsyncSubresourceFetchEvent { + RequestBodyProducer { + internal_id: u64, + producer: crate::context_bootstrap::RequestBodyProducer, + }, RequestUploadReady { internal_id: u64, result: Result<(), moli_fetch::UploadBodyError>, @@ -1068,6 +1072,11 @@ pub(super) enum AsyncSubresourceFetchEvent { impl AsyncSubresourceFetchEvent { pub(crate) fn target(&self) -> AsyncSubresourceFetchEventTarget { match self { + Self::RequestBodyProducer { internal_id, .. } => { + AsyncSubresourceFetchEventTarget::RequestUpload { + internal_id: *internal_id, + } + } Self::RequestUploadReady { internal_id, .. } => { AsyncSubresourceFetchEventTarget::RequestUpload { internal_id: *internal_id, diff --git a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs index 7506766780a..12e34ed7a22 100644 --- a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs +++ b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs @@ -590,9 +590,11 @@ fn dispatch_worker_content_security_policy_report_to_service_worker( load.attach_cancel_handle(cancel_handle.clone()); let request_metadata = service_worker_fetch_request_metadata(&request); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, redirect_check: None, internal_id, request: ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: None, url: request.url.clone(), @@ -641,6 +643,29 @@ fn dispatch_worker_content_security_policy_report_to_service_worker( let task_runner = load.task_runner(); task_runner.spawn(async move { match direct_completion_rx.await { + Ok(ServiceWorkerDirectFetchResult::Stream(_)) => { + load.finish(); + send_worker_content_security_policy_report_failure( + parent_tx, + request_handle, + continue_internal_id, + document_url, + request, + request_body, + "CSP report requests do not use a response stream route".to_owned(), + ); + } + Ok(ServiceWorkerDirectFetchResult::FallbackStream(body)) => { + spawn_worker_content_security_policy_report_network( + parent_tx, + load, + request_handle, + continue_internal_id, + document_url, + request.with_upload_body(body), + request_body, + ); + } Ok(ServiceWorkerDirectFetchResult::Fallback) => { spawn_worker_content_security_policy_report_network( parent_tx, diff --git a/moli-renderer-v8/src/worker/global_scope/extendable_events.rs b/moli-renderer-v8/src/worker/global_scope/extendable_events.rs index c375596b688..b321f51ba26 100644 --- a/moli-renderer-v8/src/worker/global_scope/extendable_events.rs +++ b/moli-renderer-v8/src/worker/global_scope/extendable_events.rs @@ -103,6 +103,7 @@ pub(in crate::worker) struct PendingServiceWorkerPeriodicSyncEvent { } pub(in crate::worker) struct PendingServiceWorkerFetchEvent { + pub(in crate::worker) request_for_body: Option>, pub(in crate::worker) completion: ServiceWorkerFetchCompletion, pub(in crate::worker) handled_resolver: Option>, pub(in crate::worker) request_signal_id: Option, @@ -125,6 +126,7 @@ impl PendingServiceWorkerFetchEvent { request_destination: ServiceWorkerRequestDestination, ) -> Self { Self { + request_for_body: None, completion: ServiceWorkerFetchCompletion { result: ServiceWorkerFetchResult::Fallback, ..completion diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index 4ba212fbc67..65c1637c8cd 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -5,9 +5,9 @@ use crate::network_host::{ fetch_browser_subresource_raw_stream_for_owner, local_url_response_with_blob_entry, }; use crate::service_worker_runtime::{ - ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerFetchDispatch, - ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination, - ServiceWorkerRuntimeService, + ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerDirectFetchStreamEvent, + ServiceWorkerFetchDispatch, ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, + ServiceWorkerRequestDestination, ServiceWorkerRuntimeService, }; use crate::types::{AsyncSubresourceNetworkContext, SubresourcePolicyContext}; @@ -424,6 +424,8 @@ pub(in crate::worker) fn spawn_worker_fetch_network( timing.observe_head(&head); let _ = completion_tx.send(WorkerFetchEvent::StreamingStarted( WorkerFetchStreamingStarted { + response_filter: None, + skip_fetch_security_validation: false, fetch_id, body_source_id, head: head.clone(), @@ -536,6 +538,8 @@ fn spawn_worker_fetch_service_worker( resolved_url: Url, method: String, body: Option, + body_stream: Option, + request_body_owner: crate::context_bootstrap::RequestBodyOwner, headers: moli_fetch::RequestHeaders, request_mode: RequestMode, credentials_mode: RequestCredentialsMode, @@ -546,9 +550,11 @@ fn spawn_worker_fetch_service_worker( ) { let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: Some(request_body_owner), redirect_check: redirect_check.clone(), internal_id: u64::from(fetch_id), request: ServiceWorkerFetchRequest { + body_stream, client_id, resulting_client_id: None, url: resolved_url.clone(), @@ -600,7 +606,14 @@ fn spawn_worker_fetch_service_worker( // A controlled request can fall back after the client Worker has closed. load.task_runner().spawn(async move { match direct_completion_rx.await { - Ok(ServiceWorkerDirectFetchResult::Fallback) => { + Ok( + result @ (ServiceWorkerDirectFetchResult::Fallback + | ServiceWorkerDirectFetchResult::FallbackStream(_)), + ) => { + let upload = match result { + ServiceWorkerDirectFetchResult::FallbackStream(body) => Some(body), + _ => None, + }; spawn_worker_fetch_network( kind, load, @@ -626,10 +639,63 @@ fn spawn_worker_fetch_service_worker( None, Vec::new(), redirect_check, - None, + upload, ); return; } + Ok(ServiceWorkerDirectFetchResult::Stream(mut stream)) => { + timing.begin_synthetic_response(); + timing.observe_head(&stream.head); + let head = stream.head; + let body_source_id = stream.body_source_id; + let _ = completion_tx.send(WorkerFetchEvent::StreamingStarted( + WorkerFetchStreamingStarted { + fetch_id, + body_source_id, + head: head.clone(), + network_request_headers: None, + response_filter: stream.response_filter, + skip_fetch_security_validation: true, + }, + )); + let mut body = SubresourceResponseBodyWriter::with_disk_pool( + load.request_client().disk_pool(), + ); + let result = loop { + let event = tokio::select! { + _ = cancel_handle.cancelled() => break Err(ABORTED_ERROR_TEXT.to_owned()), + event = stream.events.recv() => event, + }; + match event { + Some(ServiceWorkerDirectFetchStreamEvent::Chunk(bytes)) => { + timing.observe_chunk(bytes.len()); + body.append(&bytes); + let _ = completion_tx.send(WorkerFetchEvent::StreamingChunk( + WorkerFetchStreamingChunk { + fetch_id, + body_source_id, + bytes, + }, + )); + } + Some(ServiceWorkerDirectFetchStreamEvent::Finished(result)) => { + break result; + } + None => break Err("service worker response stream closed".to_owned()), + } + }; + timing.complete(); + let _ = completion_tx.send(WorkerFetchEvent::StreamingFinished( + WorkerFetchStreamingFinished { + fetch_id, + body_source_id, + head, + result: result.map(|()| body.finish()), + }, + )); + let _ = completion_tx.send(WorkerFetchEvent::ResourceTiming { fetch_id, timing }); + return; + } Ok(ServiceWorkerDirectFetchResult::Response(response)) => { if !response.from_network_fallback { timing.begin_synthetic_response(); @@ -2856,6 +2922,44 @@ pub(super) fn start_worker_resource_fetch<'s>( }; if let Some((service_worker_runtime, service_worker_client_id)) = service_worker_controller { + let transferred = if request_metadata.body_source_is_null { + body_stream.as_ref().and_then(|stream| { + let stream = v8::Local::new(scope, stream); + crate::context_bootstrap::transfer_request_body( + scope, + stream, + body_stream_locked, + ) + }) + } else { + None + }; + if request_metadata.body_source_is_null + && body_stream.is_some() + && transferred.is_none() + { + state.borrow_mut().pending_fetches.remove(&fetch_id); + resolver.reject( + scope, + v8::Exception::type_error( + scope, + v8str(scope, "Failed to transfer request body"), + ), + ); + return Some(promise); + } + if let Some(signal) = signal + && let Some(stream) = body_stream.as_ref() + { + let stream = v8::Local::new(scope, stream); + crate::context_bootstrap::install_request_body_abort(scope, stream, signal); + } + let events = completion_tx.clone(); + let request_body_owner = + crate::context_bootstrap::request_body_owner(scope, move |producer| { + let _ = + events.send(WorkerFetchEvent::RequestBodyProducer { fetch_id, producer }); + }); spawn_worker_fetch_service_worker( kind, service_worker_runtime, @@ -2872,6 +2976,8 @@ pub(super) fn start_worker_resource_fetch<'s>( resolved_url, method, body, + transferred, + request_body_owner, headers, request_mode, credentials_mode, @@ -3036,6 +3142,84 @@ pub(in crate::worker) fn drain_worker_fetch_completion( event: WorkerFetchEvent, ) { match event { + WorkerFetchEvent::RequestBodyProducer { + fetch_id, + mut producer, + } => { + let delivery = { + let state = state.borrow(); + state + .pending_fetches + .get(&fetch_id) + .filter(|pending| !pending.load.is_cancelled()) + .map(|pending| { + ( + pending.resolver.clone(), + pending.load.task_runner(), + state.fetch_completion_tx.clone(), + ) + }) + }; + if let Some((resolver, runner, completion)) = delivery { + let stream = crate::context_bootstrap::build_readable_stream_clone_shell(scope); + let payload = producer.take_stream(); + if crate::context_bootstrap::initialize_request_body_stream(scope, stream, &payload) + .is_some() + { + let resolver = v8::Local::new(scope, resolver); + match crate::network_host::RequestUpload::with_sender( + scope, + stream, + resolver, + false, + runner, + producer.cancel.clone(), + move |result| { + let _ = completion + .send(WorkerFetchEvent::RequestUploadReady { fetch_id, result }); + }, + producer.take_sender(), + ) { + Ok(upload) => { + state + .borrow_mut() + .pending_fetches + .get_mut(&fetch_id) + .expect("body producer fetch") + .upload = Some(upload.clone()); + upload.start(scope); + } + Err(reason) => { + resolver.reject(scope, reason); + } + } + } + } + } + WorkerFetchEvent::ServiceWorkerUploadReady { event_id, result } => { + let upload = state + .borrow() + .pending_service_worker_request_uploads + .get(&event_id) + .cloned(); + if let Some(upload) = upload { + upload.ready(scope, result); + } + } + WorkerFetchEvent::ServiceWorkerUploadFinished { event_id, result } => { + let upload = state + .borrow_mut() + .pending_service_worker_request_uploads + .remove(&event_id); + if let Some(upload) = upload { + if result.is_ok() { + upload.finish(scope); + } else { + let reason = v8::Exception::type_error(scope, v8str(scope, "Failed to fetch")); + upload.stop(scope, reason); + } + } + } WorkerFetchEvent::RequestUploadReady { fetch_id, result } => { let upload = state .borrow() @@ -3161,7 +3345,11 @@ pub(in crate::worker) fn start_worker_streaming_fetch( let Some(pending) = state_ref.pending_fetches.get(&started.fetch_id) else { return; }; - worker_fetch_response_csp_violations(&state_ref, pending, &started.head) + if started.skip_fetch_security_validation { + (None, None) + } else { + worker_fetch_response_csp_violations(&state_ref, pending, &started.head) + } }; if let Some(violation) = report_only_violation { dispatch_worker_content_security_policy_violation_event_for_state(scope, state, &violation); @@ -3185,35 +3373,42 @@ pub(in crate::worker) fn start_worker_streaming_fetch( return; }; let request_origin = pending.timing.origin().clone(); - if let Err(message) = validate_fetch_response_headers( - &request_origin, - &started.head, - pending.request_mode, - pending.credentials_mode, - pending.policy_context, - ) { + let validation = if started.skip_fetch_security_validation { + Ok(()) + } else { + validate_fetch_response_headers( + &request_origin, + &started.head, + pending.request_mode, + pending.credentials_mode, + pending.policy_context, + ) + }; + if let Err(message) = validation { pending.load.cancel(); reject = Some((pending.resolver.clone(), message)); None } else { - pending.streaming_needs_orb_body_validation = - crate::network_host::fetch_response_needs_orb_body_validation( + pending.streaming_needs_orb_body_validation = !started.skip_fetch_security_validation + && crate::network_host::fetch_response_needs_orb_body_validation( &request_origin, &started.head.final_url, &started.head.headers, pending.request_mode, ); let observable_head = started.head.clone(); - let response_filter = crate::network_host::FetchResponseRequest { - method: &pending.request_method, - mode: pending.request_mode, - redirect_mode: pending.redirect_mode, - } - .network_response_filter( - &request_origin, - &observable_head, - pending.credentials_mode, - ); + let response_filter = started.response_filter.clone().unwrap_or_else(|| { + crate::network_host::FetchResponseRequest { + method: &pending.request_method, + mode: pending.request_mode, + redirect_mode: pending.redirect_mode, + } + .network_response_filter( + &request_origin, + &observable_head, + pending.credentials_mode, + ) + }); pending.streaming_body_source_id = Some(started.body_source_id); Some(( pending.resolver.clone(), diff --git a/moli-renderer-v8/src/worker/global_scope/network_state.rs b/moli-renderer-v8/src/worker/global_scope/network_state.rs index af5da57af01..5bd4033ff8a 100644 --- a/moli-renderer-v8/src/worker/global_scope/network_state.rs +++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs @@ -35,6 +35,18 @@ pub(in crate::worker) struct PendingWorkerFetch { } pub(in crate::worker) enum WorkerFetchEvent { + RequestBodyProducer { + fetch_id: u32, + producer: crate::context_bootstrap::RequestBodyProducer, + }, + ServiceWorkerUploadReady { + event_id: crate::runtime::ServiceWorkerEventId, + result: Result<(), moli_fetch::UploadBodyError>, + }, + ServiceWorkerUploadFinished { + event_id: crate::runtime::ServiceWorkerEventId, + result: Result<(), moli_fetch::UploadBodyError>, + }, RequestUploadReady { fetch_id: u32, result: Result<(), moli_fetch::UploadBodyError>, @@ -65,6 +77,8 @@ pub(in crate::worker) struct WorkerFetchCompletion { } pub(in crate::worker) struct WorkerFetchStreamingStarted { + pub(super) response_filter: Option, + pub(super) skip_fetch_security_validation: bool, pub(super) fetch_id: u32, pub(super) body_source_id: NetworkBodySourceId, pub(super) head: ResponseHead, diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rs index f74c86e50fb..df937f6a18c 100644 --- a/moli-renderer-v8/src/worker/global_scope/state.rs +++ b/moli-renderer-v8/src/worker/global_scope/state.rs @@ -263,6 +263,8 @@ pub(crate) struct WorkerGlobalState { /// and minimal `waitUntil()` promises to finish. pub(in crate::worker) pending_service_worker_fetch_events: HashMap, + pub(in crate::worker) pending_service_worker_request_uploads: + HashMap, /// Navigation preload promises and response bodies stay alive until preload complete/error. pub(in crate::worker) pending_service_worker_navigation_preloads: HashMap, diff --git a/moli-renderer-v8/src/worker/thread/dispatch.rs b/moli-renderer-v8/src/worker/thread/dispatch.rs index e9905c8ce63..179ae133dec 100644 --- a/moli-renderer-v8/src/worker/thread/dispatch.rs +++ b/moli-renderer-v8/src/worker/thread/dispatch.rs @@ -1096,6 +1096,9 @@ fn dispatch_service_worker_fetch_event_in_context<'s>( event.request.destination, ); pending.handled_resolver = Some(v8::Global::new(scope, handled_resolver)); + if event.request.body_stream.is_some() { + pending.request_for_body = Some(v8::Global::new(scope, request)); + } if event.navigation_preload_sent { state.pending_service_worker_navigation_preloads.insert( event.event_id, @@ -1119,6 +1122,7 @@ fn dispatch_service_worker_fetch_event_in_context<'s>( if default_prevented_without_response { mark_service_worker_fetch_default_prevented(state, event.event_id); } + reject_consumed_streaming_fallback(scope, state, event.event_id); mark_service_worker_fetch_dispatch_finished(state, event.event_id); settle_service_worker_fetch_handled_after_dispatch(scope, state, event.event_id); maybe_send_service_worker_fetch_completion(state, event.event_id, scope); @@ -1763,7 +1767,12 @@ fn new_service_worker_fetch_request<'s>( set_object_string(scope, headers, name, value); } let _ = init.set(scope, v8str(scope, "headers").into(), headers.into()); - if !matches!(event.request.method.as_str(), "GET" | "HEAD") + if let Some(payload) = event.request.body_stream.as_ref() { + let stream = crate::context_bootstrap::build_readable_stream_clone_shell(scope); + crate::context_bootstrap::initialize_request_body_stream(scope, stream, payload)?; + let _ = init.set(scope, v8str(scope, "body").into(), stream.into()); + set_object_string(scope, init, "duplex", "half"); + } else if !matches!(event.request.method.as_str(), "GET" | "HEAD") && let Some(body) = event.request.body.clone() { // The mutable JS buffer must not alias shared immutable upload bytes. @@ -3409,7 +3418,9 @@ fn settle_service_worker_fetch_handled_for_pending( }; let resolver = v8::Local::new(scope, resolver); match &pending.completion.result { - ServiceWorkerFetchResult::Response(_) | ServiceWorkerFetchResult::Fallback => { + ServiceWorkerFetchResult::Response(_) + | ServiceWorkerFetchResult::Fallback + | ServiceWorkerFetchResult::FallbackStream(_) => { let value = v8::undefined(scope); let _ = resolver.resolve(scope, value.into()); } @@ -3601,12 +3612,49 @@ fn maybe_send_service_worker_lifecycle_completion( )); } +fn reject_consumed_streaming_fallback( + scope: &mut v8::PinScope<'_, '_>, + state: &Rc>, + event_id: ServiceWorkerEventId, +) { + let request = { + let state = state.borrow(); + let Some(pending) = state.pending_service_worker_fetch_events.get(&event_id) else { + return; + }; + if !matches!( + pending.completion.result, + ServiceWorkerFetchResult::Fallback + ) { + return; + } + pending.request_for_body.clone() + }; + if let Some(request) = request { + let request = v8::Local::new(scope, request); + if let Some(body) = crate::network_host::body_stream_object(scope, request) + && (crate::context_bootstrap::readable_stream_locked(scope, body) + || crate::context_bootstrap::readable_stream_disturbed(scope, body)) + { + state + .borrow_mut() + .pending_service_worker_fetch_events + .get_mut(&event_id) + .expect("current FetchEvent") + .completion + .result = ServiceWorkerFetchResult::Failure( + "Cannot use a consumed streaming body for network fallback".to_owned(), + ); + } + } +} + fn maybe_send_service_worker_fetch_completion( state: &Rc>, event_id: ServiceWorkerEventId, scope: &mut v8::PinScope<'_, '_>, ) { - let (parent_tx, completion, handled_settled) = { + let (parent_tx, mut completion, handled_settled, request_body) = { let mut state = state.borrow_mut(); let Some(pending) = state.pending_service_worker_fetch_events.get_mut(&event_id) else { return; @@ -3619,9 +3667,73 @@ fn maybe_send_service_worker_fetch_completion( } let handled_settled = settle_service_worker_fetch_handled_for_pending(scope, pending); let completion = pending.completion.clone(); + let request_body = pending.request_for_body.clone(); state.pending_service_worker_fetch_events.remove(&event_id); - (state.parent_tx.clone(), completion, handled_settled) + ( + state.parent_tx.clone(), + completion, + handled_settled, + request_body, + ) }; + if matches!(completion.result, ServiceWorkerFetchResult::Fallback) + && let Some(body) = request_body + { + let request = v8::Local::new(scope, body); + let body = crate::network_host::body_stream_object(scope, request) + .expect("streaming FetchEvent body"); + completion.result = if crate::context_bootstrap::readable_stream_locked(scope, body) + || crate::context_bootstrap::readable_stream_disturbed(scope, body) + { + ServiceWorkerFetchResult::Failure( + "Cannot use a consumed streaming body for network fallback".to_owned(), + ) + } else { + let (runner, events) = { + let state = state.borrow(); + ( + state.loader.task_runner(), + state.fetch_completion_tx.clone(), + ) + }; + let resolver = v8::PromiseResolver::new(scope).expect("fallback upload resolver"); + resolver.get_promise(scope).mark_as_handled(); + let ready = events.clone(); + match crate::network_host::RequestUpload::new( + scope, + body, + resolver, + false, + runner.clone(), + moli_fetch::FetchCancelHandle::new(), + move |result| { + let _ = ready.send( + super::super::global_scope::WorkerFetchEvent::ServiceWorkerUploadReady { + event_id, + result, + }, + ); + }, + ) { + Ok((upload, body)) => { + state + .borrow_mut() + .pending_service_worker_request_uploads + .insert(event_id, upload.clone()); + upload.start(scope); + let transmission = body.transmission(); + runner.spawn(async move { + let result = transmission.await; + let _ = events.send(super::super::global_scope::WorkerFetchEvent::ServiceWorkerUploadFinished { event_id, result }); + }); + ServiceWorkerFetchResult::FallbackStream(body) + } + Err(_) => ServiceWorkerFetchResult::Failure( + "Failed to acquire fallback request body".to_owned(), + ), + } + }; + } if handled_settled { perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope); } diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index abbcdef4971..8678a9ef2ae 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -1924,6 +1924,7 @@ async fn worker_main( service_worker_window_interaction_allowed_count: 0, pending_service_worker_lifecycle_events: std::collections::HashMap::new(), pending_service_worker_fetch_events: std::collections::HashMap::new(), + pending_service_worker_request_uploads: std::collections::HashMap::new(), pending_service_worker_navigation_preloads: std::collections::HashMap::new(), pending_service_worker_message_events: std::collections::HashMap::new(), pending_service_worker_notification_events: std::collections::HashMap::new(), @@ -3818,6 +3819,10 @@ async fn worker_main( crate::context_bootstrap::retire_indexed_db_context(ctx); runtime_inspector.context_destroyed(ctx); } + state + .borrow_mut() + .pending_service_worker_request_uploads + .clear(); let common = Rc::clone(&state.borrow().common); common.clear_for_context_teardown(); state.borrow_mut().rtp_transformers.clear(); diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs index 1c6545d7bea..646f0b888a3 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs @@ -615,6 +615,7 @@ async fn service_worker_navigation_requests_preserve_native_flags_until_init_ove let native = moli_fetch::Request::get_with_url(url.clone()).with_browser_navigation_kind(kind); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url, @@ -679,6 +680,7 @@ async fn service_worker_fetch_event_request_exposes_destination_metadata() { ); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url: url::Url::parse("https://example.test/app/script.js").unwrap(), @@ -737,6 +739,7 @@ async fn service_worker_fetch_event_exposes_resulting_client_metadata() { let resulting_client_id = crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(8); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id, resulting_client_id: Some(resulting_client_id), url: url::Url::parse("https://example.test/app/").unwrap(), @@ -935,6 +938,7 @@ async fn service_worker_fetch_event_request_body_used_guards_inherited_body() { ); let request = ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url: url::Url::parse("https://example.test/app/post").unwrap(), diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs index f879eacdea7..ffde3fd16a0 100644 --- a/moli-renderer-v8/src/worker/thread/tests/mod.rs +++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs @@ -417,6 +417,7 @@ async fn dispatch_service_worker_fetch_event_for_test( fn service_worker_fetch_request_for_test() -> ServiceWorkerFetchRequest { ServiceWorkerFetchRequest { + body_stream: None, client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), resulting_client_id: None, url: url::Url::parse("https://example.test/app/data.txt").unwrap(), diff --git a/moli-renderer-v8/tests/fixtures/controlled-request-upload-worker.js b/moli-renderer-v8/tests/fixtures/controlled-request-upload-worker.js new file mode 100644 index 00000000000..eccac231741 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/controlled-request-upload-worker.js @@ -0,0 +1,31 @@ +self.oninstall = event => event.waitUntil(skipWaiting()); +self.onactivate = event => event.waitUntil(clients.claim()); +self.onfetch = event => { + const url = new URL(event.request.url); + if (url.pathname !== '/upload') return; + const mode = url.searchParams.get('mode'); + if (mode === 'byob') { + event.respondWith((async () => { + const reader = event.request.body.getReader({mode: 'byob'}); + const bytes = []; + while (true) { + const {done, value} = await reader.read(new Uint8Array(3)); + bytes.push(...value); + if (done) break; + } + return new Response(JSON.stringify(bytes)); + })()); + } else if (mode === 'constant') { + event.respondWith(new Response('constant')); + } else if (mode === 'echo') { + event.respondWith(new Response(event.request.body)); + } else if (mode === 'used') { + event.request.text().catch(() => {}); + } else if (mode === 'clone') { + event.request.clone().text().catch(() => {}); + } else if (mode === 'forward') { + event.respondWith(fetch(event.request)); + } else if (mode === 'redirect') { + event.respondWith(Response.redirect(new URL('/done', url), +url.searchParams.get('status'))); + } +};