diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs index ed95906588e..a4ad11213e6 100644 --- a/moli-renderer-v8/src/network_host.rs +++ b/moli-renderer-v8/src/network_host.rs @@ -233,8 +233,9 @@ pub(crate) use self::xhr::{ install_xml_http_request_bindings, install_xml_http_request_event_target_bindings, progress_event_constructor_callback, reset_xhr_response, retire_window_xhrs_in_current_context, set_xhr_state_number, throw_synchronous_xhr_failure, xhr_author_request_headers, - xhr_constructor_callback, xhr_ensure_send_allowed, xhr_response_text_decoder, - xhr_state_bool_property, xhr_state_number_property, xhr_state_string_property, + xhr_constructor_callback, xhr_ensure_send_allowed, xhr_response_headers_for_filter, + xhr_response_text_decoder, xhr_state_bool_property, xhr_state_number_property, + xhr_state_string_property, }; pub(in crate::network_host) const NETWORK_BODY_SLOT: &str = "__lmBody"; pub(in crate::network_host) const NETWORK_BODY_BYTES_SLOT: &str = "__lmBodyBytes"; diff --git a/moli-renderer-v8/src/network_host/controlled_resource.rs b/moli-renderer-v8/src/network_host/controlled_resource.rs index e29cad742d1..57495a4d67a 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource.rs @@ -188,6 +188,7 @@ impl ControlledResourceLoad { Err(error) => (Err(error), None), }; let mut completed = XhrLoadResult::new(self.info.clone(), result, network_headers); + completed.response_filter = self.response_filter.clone(); completed.csp_violations = std::mem::take(&mut self.csp_violations); completed.network_record = completed .network_record @@ -586,6 +587,7 @@ impl ControlledResourceLoad { super::response_hop::network_response_extra_info(&response.head, &observations); let mut response = response; if handle_auth_requests + && self.response_filter.as_ref().is_none_or(|filter| filter.service_worker_metadata().is_none()) && matches!(response.head.status, 401 | 407) && let Some(challenge) = crate::protocol_types::extract_subresource_auth_challenge( &response.head.headers, diff --git a/moli-renderer-v8/src/network_host/controlled_resource/result.rs b/moli-renderer-v8/src/network_host/controlled_resource/result.rs index 972aff54e1c..cdbc4ed22ef 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/result.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/result.rs @@ -25,6 +25,7 @@ impl BufferedXhrResponse { #[derive(Debug)] pub(crate) struct XhrLoadResult { + pub(crate) response_filter: Option, pub(crate) result: Result, pub(crate) info: PendingSubresourceFetchInfo, pub(crate) network_record: SubresourceNetworkRecord, @@ -98,6 +99,7 @@ impl XhrLoadResult { result: result.map(|delivered| delivered.response), network_record, csp_violations: Vec::new(), + response_filter: None, } } } diff --git a/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs b/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs index 77c345e432b..b6931459c92 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/service_worker.rs @@ -10,6 +10,7 @@ pub(crate) struct WorkerServiceWorkerFetch { pub(crate) runtime: ServiceWorkerRuntimeService, pub(crate) client_id: ServiceWorkerClientId, pub(crate) metadata: ServiceWorkerFetchRequestMetadata, + policy_context: crate::types::SubresourcePolicyContext, body_stream: Option, request_body_owner: Option, } @@ -25,12 +26,17 @@ impl ControlledResourceLoad { runtime, client_id, metadata, + policy_context: match self.response_policy { ResourceResponsePolicy::Fetch(policy) => policy, ResourceResponsePolicy::Xhr => Default::default() }, body_stream: None, request_body_owner: None, }); } self } + pub(crate) fn with_service_worker_policy(mut self, policy: crate::types::SubresourcePolicyContext) -> Self { + if let Some(source) = &mut self.service_worker { source.policy_context = policy; } + self + } pub(crate) fn with_service_worker_request_body(mut self, body_stream: Option, request_body_owner: Option) -> Self { if let Some(source) = &mut self.service_worker { source.body_stream = body_stream; @@ -51,9 +57,7 @@ impl ControlledResourceLoad { return Ok(None); } let (tx, rx) = tokio::sync::oneshot::channel(); - let ResourceResponsePolicy::Fetch(policy_context) = self.response_policy else { - return Ok(None); - }; + let policy_context = source.policy_context; let dispatch = ServiceWorkerFetchDispatch { redirect_check: None, request_body_owner: source.request_body_owner, @@ -95,7 +99,7 @@ impl ControlledResourceLoad { request_client: self.load.request_client(), resource_task_runner: self.load.task_runner(), cancel_handle: self.cancel.clone(), - direct_completion_tx: Some(tx), + direct_completion_tx: Some(crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::streaming(tx)), }; if !source .runtime @@ -110,6 +114,11 @@ impl ControlledResourceLoad { }; match result { ServiceWorkerDirectFetchResult::Fallback => Ok(None), + ServiceWorkerDirectFetchResult::NetworkFallback { request, preflight_headers } => { + self.request = *request; + self.preflight_headers = preflight_headers; + Ok(None) + } ServiceWorkerDirectFetchResult::FallbackStream(body) => { self.request = self.request.clone().with_upload_body(body); Ok(None) diff --git a/moli-renderer-v8/src/network_host/xhr.rs b/moli-renderer-v8/src/network_host/xhr.rs index 15b8fb76eea..8696bf30e0e 100644 --- a/moli-renderer-v8/src/network_host/xhr.rs +++ b/moli-renderer-v8/src/network_host/xhr.rs @@ -3,6 +3,7 @@ mod delivery; mod encoding; mod events; mod header_surface; +pub(crate) use self::header_surface::xhr_response_headers_for_filter; mod instance_state; mod lifecycle; mod request_state; diff --git a/moli-renderer-v8/src/network_host/xhr/header_surface.rs b/moli-renderer-v8/src/network_host/xhr/header_surface.rs index 49a18991287..69b33554659 100644 --- a/moli-renderer-v8/src/network_host/xhr/header_surface.rs +++ b/moli-renderer-v8/src/network_host/xhr/header_surface.rs @@ -193,3 +193,27 @@ pub(super) fn xhr_override_mime_type_callback<'s>( fn response_header_name_is(candidate: &str, expected: &HeaderName) -> bool { HeaderName::from_bytes(candidate.as_bytes()).is_ok_and(|candidate| candidate == *expected) } + +pub(crate) fn xhr_response_headers_for_filter( + origin: &moli_url::WebOrigin, + head: &moli_fetch::ResponseHead, + filter: &crate::types::AsyncSubresourceFetchResponseFilter, + credentials: moli_fetch::RequestCredentialsMode, + web_security_disabled: bool, +) -> Vec<(String, Vec)> { + if !filter.is_readable() { + return Vec::new(); + } + if let Some(metadata) = filter.service_worker_metadata() { + return head + .headers + .iter() + .filter(|(name, _)| { + !moli_fetch::is_forbidden_response_header_name(name) + && metadata.exposes_header(&head.headers, name) + }) + .cloned() + .collect(); + } + crate::network_host::filter_cors_exposed_response_headers(origin, head, credentials, web_security_disabled) +} 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 1601ca2dccf..9c27ec804d7 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 @@ -228,7 +228,11 @@ impl RendererBrowserContextRuntime { request_client: navigation_loader.request_client().clone(), resource_task_runner: navigation_loader.task_runner(), cancel_handle: navigation_loader.cancel_handle(), - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ), }; // Retain the upload's protocol text view and native request context, @@ -241,6 +245,7 @@ impl RendererBrowserContextRuntime { match main_resource_completion_rx.await { Ok( ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::NetworkFallback { .. } | ServiceWorkerDirectFetchResult::Stream(_), ) => Err(anyhow!( "navigation requests cannot contain an author stream" diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker/service_and_shared_worker_lifecycle.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker/service_and_shared_worker_lifecycle.rs index 37508cceda8..548faf266cc 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/worker/service_and_shared_worker_lifecycle.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker/service_and_shared_worker_lifecycle.rs @@ -552,6 +552,210 @@ async fn service_worker_intercepts_synchronous_xhr_with_native_document_and_work }).await; } +#[tokio::test] +async fn service_worker_intercepts_asynchronous_worker_xhr_with_native_clients_and_response_filters() + { + run_page_vm_async_test(async move { + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + listener.set_nonblocking(true).unwrap(); + let address = listener.local_addr().unwrap(); + let origin = format!("http://{address}"); + let cross_origin = format!("http://localhost:{}", address.port()); + let server_origin = origin.clone(); + let (requests, mut received) = tokio::sync::mpsc::unbounded_channel(); + let worker_source = format!(r#" + function take(url) {{ + return new Promise(resolve => {{ + const xhr = new XMLHttpRequest(); + xhr.open("POST", url, true); + xhr.withCredentials = true; + xhr.setRequestHeader("X-Fixture", "body-marker"); + let returned = false; + xhr.onloadend = () => resolve({{ + returned, status: xhr.status, text: xhr.responseText, + visible: xhr.getResponseHeader("X-Visible"), + hidden: xhr.getResponseHeader("X-Hidden"), + cookie: xhr.getResponseHeader("Set-Cookie") + }}); + xhr.send("payload"); + returned = true; + }}); + }} + async function run() {{ + const violations = []; + self.addEventListener("securitypolicyviolation", event => violations.push({{ + directive: event.effectiveDirective, disposition: event.disposition, + blocked: event.blockedURI + }})); + const echo = await take("{cross_origin}/sw-echo"); + const data = JSON.parse(echo.text); + data.paddingLength = data.padding.length; + delete data.padding; + delete echo.text; + const cors = await take("/app/cors-proxy"); + await new Promise(resolve => setTimeout(resolve, 50)); + return {{echo, data, cors, violations, + resourceNames: performance.getEntriesByType("resource").map(entry => entry.name)}}; + }} + self.onmessage = () => run().then(value => self.postMessage(value)).catch(error => self.postMessage({{error: String(error)}})); + self.onconnect = event => {{ + const port = event.ports[0]; + port.onmessage = () => run().then(value => port.postMessage(value)) + .catch(error => port.postMessage({{error: String(error)}})); + }}; + "#); + let server = std::thread::spawn(move || { + tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async move { + let listener = TcpListener::from_std(listener).unwrap(); + for index in 0..6 { + let wait = if index < 5 { Duration::from_secs(5) } else { Duration::from_millis(500) }; + let Ok(accepted) = tokio::time::timeout(wait, listener.accept()).await else { break }; + let (mut stream, _) = accepted.unwrap(); + let request = read_http_request_head(&mut stream).await.unwrap(); + let path = request.lines().next().unwrap().split_whitespace().nth(1).unwrap(); + requests.send(path.to_owned()).unwrap(); + let body = match path { + "/app/sw.js" => r#" + self.oninstall = event => event.waitUntil(self.skipWaiting()); + self.onfetch = event => { + const path = new URL(event.request.url).pathname; + if (path === "/app/cors-proxy") { + const target = new URL("/cors-source", event.request.url); + target.hostname = "localhost"; + event.respondWith(fetch(target, {credentials: "include"})); + } else if (path === "/sw-echo") { + event.respondWith((async () => { + const client = await self.clients.get(event.clientId); + const text = JSON.stringify({ + method: event.request.method, mode: event.request.mode, + credentials: event.request.credentials, + destination: event.request.destination, + clientId: event.clientId, resultingClientId: event.resultingClientId, + clientType: client.type, clientUrl: client.url, + referrer: event.request.referrer, + header: event.request.headers.get("X-Fixture"), + body: await event.request.text(), padding: "x".repeat(1024 * 1024) + }); + const bytes = new TextEncoder().encode(text); + return new Response(new ReadableStream({start(controller) { + let offset = 0; + function push() { + if (offset === bytes.length) { controller.close(); return; } + const next = Math.min(offset + 65536, bytes.length); + controller.enqueue(bytes.slice(offset, next)); + offset = next; + setTimeout(push, 0); + } + push(); + }}), {headers: { + "Content-Type": "application/json", "X-Visible": "visible", + "X-Hidden": "basic-visible", "Set-Cookie": "secret=value" + }}); + })()); + } + }; + "#, + "/app/actor.js" => &worker_source, + "/cors-source" => "cors response", + _ => "unexpected network request", + }; + let policy = if path == "/app/actor.js" { "Content-Security-Policy-Report-Only: connect-src 'self'\r\n" } else { "" }; + let response = format!( + "HTTP/1.1 200 OK\r\nContent-Type: text/javascript\r\nCache-Control: no-store\r\n{policy}Access-Control-Allow-Origin: {server_origin}\r\nAccess-Control-Allow-Credentials: true\r\nAccess-Control-Expose-Headers: X-Visible\r\nX-Visible: visible\r\nX-Hidden: network-hidden\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", + body.len(), body + ); + stream.write_all(response.as_bytes()).await.unwrap(); + } + }); + }); + let loader_owner = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let mut hooks = PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(); + hooks.resource_task_runner = Some(loader_owner.resource_task_runner()); + let mut page_vm = test_page_vm_with_loader_document_url_and_hooks( + &loader_owner, Vec::new(), Url::parse(&format!("{origin}/page.html")).unwrap(), hooks, + ); + page_vm.retain_standalone_request_client_owner_for_test(loader_owner); + let local_executor = page_vm.local_executor.clone(); + local_executor.run(async move { + page_vm.vm_mut().eval(r#" + globalThis.asyncXhrResults = null; + globalThis.asyncXhrError = null; + (async () => { + const registration = await navigator.serviceWorker.register("/app/sw.js", {scope: "/app/actor.js"}); + const active = registration.installing || registration.active; + if (active.state !== "activated") await new Promise(resolve => active.addEventListener("statechange", () => { + if (active.state === "activated") resolve(); + })); + globalThis.asyncXhrDedicated = new Worker("/app/actor.js"); + const dedicated = new Promise((resolve, reject) => { + asyncXhrDedicated.onmessage = event => resolve(event.data); + asyncXhrDedicated.onerror = event => reject(event.message); + }); + asyncXhrDedicated.postMessage("run"); + globalThis.asyncXhrShared = new SharedWorker("/app/actor.js"); + const shared = new Promise((resolve, reject) => { + asyncXhrShared.port.onmessage = event => resolve(event.data); + asyncXhrShared.onerror = event => reject(event.message); + }); + asyncXhrShared.port.postMessage("run"); + asyncXhrResults = {dedicated: await dedicated, shared: await shared}; + })().catch(error => asyncXhrError = String(error)); + "#)?; + drive_service_worker_and_shared_worker_page_vm_until_done( + &mut page_vm, "String(asyncXhrResults !== null || asyncXhrError !== null)", + "native Worker clients should intercept asynchronous XHR without a controlled creator", + ).await?; + assert_eq!(page_vm.vm_mut().eval("String(asyncXhrError)")?, "null"); + assert_eq!(page_vm.vm_mut().eval("String(navigator.serviceWorker.controller)")?, "null"); + let results: serde_json::Value = serde_json::from_str(&page_vm.vm_mut().eval("JSON.stringify(asyncXhrResults)")?)?; + assert_ne!(results["dedicated"]["data"]["clientId"], results["shared"]["data"]["clientId"]); + for (kind, expected_type) in [("dedicated", "worker"), ("shared", "sharedworker")] { + let result = &results[kind]; + assert!(result.get("error").is_none(), "{result}"); + assert_eq!(result["echo"]["returned"], true); + assert_eq!(result["echo"]["status"], 200); + assert_eq!(result["echo"]["visible"], "visible"); + assert_eq!(result["echo"]["hidden"], "basic-visible"); + assert!(result["echo"]["cookie"].is_null()); + let data = &result["data"]; + assert!(!data["clientId"].as_str().unwrap().is_empty()); + assert_eq!(data["clientType"], expected_type); + assert_eq!(data["clientUrl"], format!("{origin}/app/actor.js")); + assert_eq!(data["resultingClientId"], ""); + assert_eq!(data["destination"], ""); + assert_eq!(data["method"], "POST"); + assert_eq!(data["mode"], "cors"); + assert_eq!(data["credentials"], "include"); + assert_eq!(data["referrer"], format!("{origin}/")); + assert_eq!(data["body"], "payload"); + assert_eq!(data["header"], "body-marker"); + assert_eq!(data["paddingLength"], 1024 * 1024); + assert_eq!(result["cors"]["returned"], true); + assert_eq!(result["cors"]["status"], 200); + assert_eq!(result["cors"]["text"], "cors response"); + assert_eq!(result["cors"]["visible"], "visible"); + assert!(result["cors"]["hidden"].is_null()); + assert!(result["cors"]["cookie"].is_null()); + let violations = result["violations"].as_array().unwrap(); + assert_eq!(violations.len(), 3, "{kind}: {violations:?}"); + assert_eq!(violations.iter().filter(|v| v["blocked"] == format!("{cross_origin}/sw-echo")).count(), 2); + assert_eq!(violations.iter().filter(|v| v["blocked"] == format!("{origin}/app/cors-proxy")).count(), 1); + assert!(violations.iter().all(|v| v["directive"] == "connect-src" && v["disposition"] == "report")); + let names = result["resourceNames"].as_array().unwrap(); + assert!(names.contains(&serde_json::json!(format!("{cross_origin}/sw-echo")))); + assert!(names.contains(&serde_json::json!(format!("{origin}/app/cors-proxy")))); + assert!(!names.contains(&serde_json::json!(format!("{cross_origin}/cors-source")))); + } + anyhow::Ok(()) + }).await.unwrap(); + server.join().unwrap(); + let mut paths = Vec::new(); + while let Some(path) = received.recv().await { paths.push(path); } + paths.sort(); + assert_eq!(paths, ["/app/actor.js", "/app/actor.js", "/app/sw.js", "/cors-source", "/cors-source"]); + }).await; +} + #[tokio::test] async fn service_worker_blob_shared_worker_inherits_parent_controller_for_fetch() { run_page_vm_async_test(async move { diff --git a/moli-renderer-v8/src/script_vm/tests/native_request_url_provenance.rs b/moli-renderer-v8/src/script_vm/tests/native_request_url_provenance.rs index 9b51bd0dba4..77bd383cafc 100644 --- a/moli-renderer-v8/src/script_vm/tests/native_request_url_provenance.rs +++ b/moli-renderer-v8/src/script_vm/tests/native_request_url_provenance.rs @@ -20,7 +20,7 @@ async fn cache_keys_preserves_native_credential_urls_without_author_constructors let source = ServiceWorkerFetchRequest { body_stream: None, - client_id: ServiceWorkerClientId::from_u64_for_test(7), + client_id: Some(ServiceWorkerClientId::from_u64_for_test(7)), resulting_client_id: None, url: Url::parse(url).unwrap(), method: "GET".to_owned(), @@ -116,7 +116,7 @@ async fn window_fetch_retains_native_request_urls_and_rejects_converted_credenti let request = ServiceWorkerFetchRequest { body_stream: None, - client_id: ServiceWorkerClientId::from_u64_for_test(7), + client_id: Some(ServiceWorkerClientId::from_u64_for_test(7)), resulting_client_id: None, url: native_url.clone(), method: "GET".to_owned(), diff --git a/moli-renderer-v8/src/service_worker_runtime.rs b/moli-renderer-v8/src/service_worker_runtime.rs index 25e9166b79c..e56aed19d34 100644 --- a/moli-renderer-v8/src/service_worker_runtime.rs +++ b/moli-renderer-v8/src/service_worker_runtime.rs @@ -43,24 +43,24 @@ pub(crate) use events::{ ServiceWorkerClientNavigate, ServiceWorkerClientNavigateError, ServiceWorkerClientNavigateResult, ServiceWorkerClientsOpenWindow, ServiceWorkerClientsOpenWindowError, ServiceWorkerClientsOpenWindowResult, - ServiceWorkerCloseNotification, ServiceWorkerDirectFetchResponse, - 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, + ServiceWorkerCloseNotification, ServiceWorkerDirectFetchCompletion, + ServiceWorkerDirectFetchResponse, 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 1e52590681a..2384223c2b4 100644 --- a/moli-renderer-v8/src/service_worker_runtime/events.rs +++ b/moli-renderer-v8/src/service_worker_runtime/events.rs @@ -704,10 +704,55 @@ pub(crate) struct ServiceWorkerNavigationPreloadFailure { pub(crate) use moli_fetch_types::FetchResponseHead as MaterializedServiceWorkerFetchResponseHead; +#[derive(Debug)] +pub(crate) struct ServiceWorkerDirectFetchCompletion { + sender: tokio::sync::oneshot::Sender, + pub(super) stream_response: bool, + pub(super) defer_network_fallback: bool, +} + +impl ServiceWorkerDirectFetchCompletion { + pub(crate) fn buffered( + sender: tokio::sync::oneshot::Sender, + ) -> Self { + Self { + sender, + stream_response: false, + defer_network_fallback: false, + } + } + + pub(crate) fn streaming( + sender: tokio::sync::oneshot::Sender, + ) -> Self { + Self { + stream_response: true, + ..Self::buffered(sender) + } + } + + pub(crate) fn streaming_with_network_fallback( + sender: tokio::sync::oneshot::Sender, + ) -> Self { + Self { + defer_network_fallback: true, + ..Self::streaming(sender) + } + } + + pub(super) fn send(self, result: ServiceWorkerDirectFetchResult) -> bool { + self.sender.send(result).is_ok() + } +} + #[derive(Debug)] pub(crate) enum ServiceWorkerDirectFetchResult { Fallback, FallbackStream(moli_fetch::UploadBody), + NetworkFallback { + request: Box, + preflight_headers: Vec<(String, String)>, + }, Response(ServiceWorkerDirectFetchResponse), Stream(Box), Failure(String), @@ -755,8 +800,7 @@ pub(crate) struct ServiceWorkerFetchDispatch { pub(crate) request_client: ResourceRequestClient, pub(crate) resource_task_runner: crate::network::RendererResourceTaskRunner, pub(crate) cancel_handle: moli_fetch::FetchCancelHandle, - pub(crate) direct_completion_tx: - Option>, + pub(crate) direct_completion_tx: Option, } #[cfg(test)] 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 93a34310803..427e86b3bd4 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 @@ -153,25 +153,26 @@ fn service_worker_fetch_can_forward_stream( final_url, &response_head.headers, )?; - 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.metadata.response_type.as_str(), - "default" | "basic" - ) - && !service_worker_fetch_response_requires_body_security_policy(job), - ) + Ok(job + .direct_completion_tx + .as_ref() + .is_none_or(|completion| completion.stream_response) + && 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.metadata.response_type.as_str(), + "default" | "basic" | "cors" + ) + && !service_worker_fetch_response_requires_body_security_policy(job)) } fn apply_service_worker_synthetic_redirect( @@ -279,7 +280,11 @@ impl ServiceWorkerRuntimeService { request_client: request_client.clone(), resource_task_runner, cancel_handle, - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ), }; if !self.dispatch_controlled_fetch(dispatch) { return Ok(None); @@ -287,6 +292,7 @@ impl ServiceWorkerRuntimeService { match direct_completion_rx.await { Ok( ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::NetworkFallback { .. } | ServiceWorkerDirectFetchResult::Stream(_), ) => Err("native subresource requests cannot contain an author stream".to_owned()), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), @@ -354,7 +360,11 @@ impl ServiceWorkerRuntimeService { request_client: request_client.clone(), resource_task_runner, cancel_handle, - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ), }; if !self.dispatch_controlled_fetch(dispatch) { @@ -364,6 +374,7 @@ impl ServiceWorkerRuntimeService { match direct_completion_rx.await { Ok( ServiceWorkerDirectFetchResult::FallbackStream(_) + | ServiceWorkerDirectFetchResult::NetworkFallback { .. } | ServiceWorkerDirectFetchResult::Stream(_), ) => Err("worker script requests cannot contain an author stream".to_owned()), Ok(ServiceWorkerDirectFetchResult::Fallback) => Ok(None), @@ -394,6 +405,14 @@ impl ServiceWorkerRuntimeService { } if let Some(completion_tx) = job.direct_completion_tx.take() { if job.request.redirect_count() > job.initial_redirect_count { + if completion_tx.defer_network_fallback { + let request = service_worker_network_fallback_request_for_job(&job); + let _ = completion_tx.send(ServiceWorkerDirectFetchResult::NetworkFallback { + request: Box::new(request), + preflight_headers: job.cors_preflight_request_headers, + }); + return; + } self.dispatch_direct_fetch_network_fallback(job, completion_tx); return; } @@ -426,7 +445,7 @@ impl ServiceWorkerRuntimeService { fn dispatch_direct_fetch_network_fallback( &self, job: ServiceWorkerFetchJob, - completion_tx: tokio::sync::oneshot::Sender, + completion_tx: crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion, ) { let request_client = job.request_client.clone(); let request = service_worker_network_fallback_request_for_job(&job); @@ -4294,7 +4313,11 @@ mod tests { .pending_fetch_jobs .get_mut(&event_id) .expect("active fetch job") - .direct_completion_tx = Some(direct_completion_tx); + .direct_completion_tx = Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ); service.finish_fetch_event_completed(ServiceWorkerFetchCompletion { event_id, @@ -4369,7 +4392,11 @@ mod tests { from_cache: false, negotiated_http_version: None, }); - job.direct_completion_tx = Some(direct_completion_tx); + job.direct_completion_tx = Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ); // This test intentionally calls from a plain test thread. The // fallback must use the runner captured by the original resource 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 b67d739eb69..e91017fe84b 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 @@ -3539,7 +3539,11 @@ async fn controlled_fetch_from_worker_client_dispatches_to_active_worker() { request_client: test_request_client(&service), resource_task_runner: test_resource_task_runner(), cancel_handle: moli_fetch::FetchCancelHandle::new(), - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx + ) + ), }), "controlled worker client fetch should dispatch to the active worker" ); 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 7a2998ec3d4..764a9c91d13 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 @@ -1098,7 +1098,11 @@ fn resource_store_restores_no_fetch_handler_metadata_for_controlled_fetch() { request_client: test_request_client(&second_service), resource_task_runner: test_resource_task_runner(), cancel_handle: moli_fetch::FetchCancelHandle::new(), - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx + ) + ), }) ); @@ -1473,7 +1477,11 @@ fn navigation_preload_fallback_completion_cancels_unstarted_preload_only() { .pending_fetch_jobs .get_mut(&event_id) .expect("pending navigation preload fetch job") - .direct_completion_tx = Some(direct_completion_tx); + .direct_completion_tx = Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ); service.finish_fetch_event_completed(ServiceWorkerFetchCompletion { event_id, @@ -1836,7 +1844,11 @@ fn abort_controlled_fetch_drops_direct_worker_completion_and_ignores_late_comple completion_queue.sender(), cancel_handle.clone(), ); - job.direct_completion_tx = Some(direct_completion_tx); + job.direct_completion_tx = Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ); state.pending_fetch_jobs.insert(event_id, job); } @@ -2065,7 +2077,11 @@ fn no_fetch_handler_controlled_fetch_falls_back_without_dispatching_event() { request_client: test_request_client(&service), resource_task_runner: test_resource_task_runner(), cancel_handle: moli_fetch::FetchCancelHandle::new(), - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx + ) + ), }) ); @@ -2159,7 +2175,11 @@ fn controlled_fetch_waits_for_activating_active_version() { request_client: test_request_client(&service), resource_task_runner: test_resource_task_runner(), cancel_handle: moli_fetch::FetchCancelHandle::new(), - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx + ) + ), }) ); @@ -2271,7 +2291,11 @@ fn empty_fetch_handler_controlled_fetch_falls_back_without_dispatching_event() { request_client: test_request_client(&service), resource_task_runner: test_resource_task_runner(), cancel_handle: moli_fetch::FetchCancelHandle::new(), - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx + ) + ), }) ); @@ -2379,7 +2403,11 @@ fn empty_fetch_handler_pending_start_fetch_falls_back_after_worker_start() { cancel_handle: moli_fetch::FetchCancelHandle::new(), navigation_preload_cancel_handle: None, streaming_body_source_id: None, - direct_completion_tx: Some(direct_completion_tx), + direct_completion_tx: Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered( + direct_completion_tx, + ), + ), }, ); let version = state.versions.get_mut(&version_id).unwrap(); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/network_fallback_policy.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/network_fallback_policy.rs index de8030ccae2..ce53bd0457f 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/network_fallback_policy.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/network_fallback_policy.rs @@ -446,7 +446,9 @@ async fn direct_network_fallback_after_synthetic_redirect_enforces_page_policy() .pending_fetch_jobs .get_mut(&event.event_id) .unwrap() - .direct_completion_tx = Some(direct_tx); + .direct_completion_tx = Some( + crate::service_worker_runtime::ServiceWorkerDirectFetchCompletion::buffered(direct_tx), + ); service.finish_fetch_event_completed(ServiceWorkerFetchCompletion { event_id: event.event_id, owner: event.owner, diff --git a/moli-renderer-v8/src/service_worker_runtime/state.rs b/moli-renderer-v8/src/service_worker_runtime/state.rs index 2fb1d1ddeac..5447ffd28a9 100644 --- a/moli-renderer-v8/src/service_worker_runtime/state.rs +++ b/moli-renderer-v8/src/service_worker_runtime/state.rs @@ -35,9 +35,9 @@ use super::{ diagnostics::ServiceWorkerMainScriptUpdateCheckDiagnostics, errors::ServiceWorkerRegistrationError, events::{ - ServiceWorkerDirectFetchResult, ServiceWorkerFetchCompletion, - ServiceWorkerFetchRequestMetadata, ServiceWorkerLifecycleEvent, ServiceWorkerMessageEvent, - ServiceWorkerNotificationEvent, ServiceWorkerPeriodicSyncEvent, ServiceWorkerPushEvent, + ServiceWorkerFetchCompletion, ServiceWorkerFetchRequestMetadata, + ServiceWorkerLifecycleEvent, ServiceWorkerMessageEvent, ServiceWorkerNotificationEvent, + ServiceWorkerPeriodicSyncEvent, ServiceWorkerPushEvent, ServiceWorkerPushSubscriptionSnapshot, ServiceWorkerRequestDestination, ServiceWorkerSyncEvent, }, @@ -835,8 +835,7 @@ pub(super) struct ServiceWorkerFetchJob { pub(super) cancel_handle: moli_fetch::FetchCancelHandle, pub(super) navigation_preload_cancel_handle: Option, pub(super) streaming_body_source_id: Option, - pub(super) direct_completion_tx: - Option>, + pub(super) direct_completion_tx: Option, } impl ServiceWorkerFetchJob { 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 a5a6cf9fa07..698940d49ad 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 @@ -412,6 +412,7 @@ fn send_worker_content_security_policy_report_for_state( .run() .await; + }); } 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 6d2897cd123..ee460858d3b 100644 --- a/moli-renderer-v8/src/worker/global_scope/network_state.rs +++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs @@ -149,12 +149,15 @@ pub(in crate::worker) struct PendingWorkerXhr { pub(in crate::worker) xhr: v8::Global, pub(in crate::worker) credentials_mode: RequestCredentialsMode, + pub(in crate::worker) load: ResourceLoadLease, } pub(in crate::worker) struct WorkerXhrCompletion { + pub(in crate::worker) response_filter: Option, pub(in crate::worker) csp_violations: Vec, + pub(in crate::worker) xhr_id: u32, // Rejections admitted before a native load use the Worker networking task. // Aborting or reopening before that task runs suppresses their delivery. diff --git a/moli-renderer-v8/src/worker/global_scope/xhr.rs b/moli-renderer-v8/src/worker/global_scope/xhr.rs index b0867b2681d..4813fbc0bad 100644 --- a/moli-renderer-v8/src/worker/global_scope/xhr.rs +++ b/moli-renderer-v8/src/worker/global_scope/xhr.rs @@ -361,7 +361,11 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( )) } else if worker_url_blocked(&blocked_url_patterns, &prepared.resolved_url) { Some(BLOCKED_BY_CLIENT_ERROR_TEXT.to_owned()) - } else if network_offline { + } else if async_request + && network_offline + && super::fetch::worker_service_worker_controller(&state.borrow(), &prepared.resolved_url) + .is_none() + { Some("Network emulation offline".to_owned()) } else { None @@ -434,6 +438,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( credentials_mode: prepared.credentials_mode, load: load.clone(), + }, ); xhr_id @@ -453,7 +458,9 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( result: Ok(response), local_request: Some(local_request), csp_violations: Vec::new(), + response_filter: None, }))); + } Err(error_text) => { let _ = state.worker_wake_tx.send(WorkerMessage::DispatchXhrFailure { xhr_id, error_text, local_request }); @@ -467,6 +474,11 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( let info = worker_xhr_info(&prepared); let request = worker_xhr_request(&state.borrow(), &prepared); let redirect_owner = crate::network_host::RedirectOwner::Worker(WorkerRedirectOwner::xhr(completion_tx.clone(), xhr_id, load.clone())); + let (runtime, client_id, policy_context) = { + let state = state.borrow(); + (state.service_worker_runtime.clone(), state.service_worker_client_id, state.policy_context) + }; + let metadata = crate::service_worker_runtime::service_worker_fetch_request_metadata(&request); let timing = prepared.timing.clone(); timing.begin_transport(cancel_handle.clone()); load.task_runner().spawn(async move { @@ -487,11 +499,16 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( prepared.request_headers.to_byte_strings(), ) .with_redirect_owner(Some(redirect_owner)) + .with_service_worker(runtime, client_id, metadata) + .with_service_worker_policy(policy_context) .run() .await; if let Ok(response) = &completed.result { timing.observe_head(&response.head()); timing.observe_chunk(response.body_bytes().len()); + if let Some(filter) = completed.response_filter.clone() { + timing.select_response(&response.head(), filter, response.body_bytes().len(), true); + } } else { timing.discard_response(); } @@ -500,12 +517,14 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( xhr_id, local_request: None, csp_violations: completed.csp_violations, + response_filter: completed.response_filter, result: completed.result, }))); let _ = completion_tx.send(WorkerXhrEvent::ResourceTiming { xhr_id: Some(xhr_id), timing }); }); + true } @@ -801,6 +820,7 @@ pub(in crate::worker) fn drain_worker_xhr_completion( + let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) else { return; }; @@ -828,14 +848,14 @@ pub(in crate::worker) fn drain_worker_xhr_completion( pending.timing.observe_head(&response.head()); pending.timing.observe_chunk(response.body_bytes().len()); pending.timing.complete(); + } let (mut head, body) = response.into_body(); - head.headers = filter_cors_exposed_response_headers( - pending.timing.origin(), - &head, - pending.credentials_mode, - pending.load.request_client().web_security_disabled(), - ); + let web_security_disabled = pending.load.request_client().web_security_disabled(); + let filter = completion.response_filter.unwrap_or_else(|| { + head.fetch_response_type_with_web_security(pending.timing.origin(), RequestMode::Cors, web_security_disabled).into() + }); + head.headers = crate::network_host::xhr_response_headers_for_filter(pending.timing.origin(), &head, &filter, pending.credentials_mode, web_security_disabled); pending.timing.publish(scope); apply_xhr_response_body_source(scope, xhr, head, body); diff --git a/moli-renderer-v8/src/worker/global_scope/xhr_service_worker.rs b/moli-renderer-v8/src/worker/global_scope/xhr_service_worker.rs new file mode 100644 index 00000000000..271e60a5220 --- /dev/null +++ b/moli-renderer-v8/src/worker/global_scope/xhr_service_worker.rs @@ -0,0 +1,215 @@ +use super::*; +use crate::network_host::RedirectOwner; +use crate::service_worker_runtime::{ + ServiceWorkerClientId, ServiceWorkerDirectFetchCompletion, ServiceWorkerDirectFetchResult, + ServiceWorkerDirectFetchStreamEvent, ServiceWorkerFetchDispatch, ServiceWorkerFetchRequest, + ServiceWorkerRequestDestination, ServiceWorkerRuntimeService, + service_worker_fetch_request_metadata, +}; +use crate::types::SubresourcePolicyContext; + +pub(in crate::worker) struct WorkerXhrServiceWorkerController { + runtime: ServiceWorkerRuntimeService, + client_id: ServiceWorkerClientId, + policy_context: SubresourcePolicyContext, +} + +pub(super) fn take_controller( + state: &Rc>, + xhr_id: u32, + url: &Url, +) -> Option { + let mut state = state.borrow_mut(); + let pending = state.pending_xhrs.get_mut(&xhr_id)?; + if std::mem::replace(&mut pending.service_worker_checked, true) { + return None; + } + let (runtime, client_id) = super::fetch::worker_service_worker_controller(&state, url)?; + Some(WorkerXhrServiceWorkerController { + runtime, + client_id, + policy_context: state.policy_context, + }) +} + +pub(super) async fn load_response( + load: &ResourceLoadLease, + mut request: Request, + cancel: FetchCancelHandle, + mut preflight_headers: Vec<(String, String)>, + document_url: &Url, + timing: &WorkerResourceTiming, + redirect_owner: &RedirectOwner, + controller: Option, + xhr_id: u32, +) -> WorkerXhrCompletion { + let failure = |message| WorkerXhrCompletion { + native_record: None, + + xhr_id, + network_request_headers: None, + response_filter: None, + skip_fetch_security_validation: false, + result: Err(message), + }; + if let Some(controller) = controller { + let (reply, result) = tokio::sync::oneshot::channel(); + let redirect_request = request.clone(); + let dispatch = ServiceWorkerFetchDispatch { + request_body_owner: None, + redirect_check: Some(moli_fetch::RequestRedirectCheck::new(move |url| { + redirect_request.check_redirect_target(url) + })), + // Direct consumers use their owning completion channel. Worker + // XHR ids are local to the Worker, not browser resource ids. + internal_id: 0, + request: ServiceWorkerFetchRequest { + body_stream: None, + client_id: controller.client_id, + resulting_client_id: None, + url: request.url.clone(), + method: request.method.clone(), + headers: request.request_headers.to_byte_strings(), + body: request.body.clone(), + destination: ServiceWorkerRequestDestination::Empty, + request_mode: RequestMode::Cors, + credentials_mode: request.credentials_mode, + redirect_mode: request.redirect_mode(), + priority: request.priority_hints.fetch_priority, + is_reload: false, + metadata: service_worker_fetch_request_metadata(&request), + }, + cors_preflight_request_headers: preflight_headers.clone(), + request_cookie_report: None, + network_context: crate::types::AsyncSubresourceNetworkContext { + frame_id: None, + request_origin: timing.origin().clone(), + document_url: document_url.clone(), + resource_type: SubresourceResourceType::Xhr, + policy_context: controller.policy_context, + }, + completion_tx: + crate::page_task_queue::RendererResourceCompletionSender::direct_completion_only(), + request_client: load.request_client(), + resource_task_runner: load.task_runner(), + cancel_handle: cancel.clone(), + direct_completion_tx: Some( + ServiceWorkerDirectFetchCompletion::streaming_with_network_fallback(reply), + ), + }; + if controller.runtime.dispatch_controlled_fetch(dispatch) { + let outcome = tokio::select! { + biased; + _ = cancel.cancelled() => return failure(ABORTED_ERROR_TEXT.to_owned()), + result = result => result, + }; + match outcome { + Ok(ServiceWorkerDirectFetchResult::Fallback) => {} + Ok(ServiceWorkerDirectFetchResult::NetworkFallback { + request: next, + preflight_headers: next_headers, + }) => { + let observer = request.upload_observer().cloned(); + request = *next; + if request.body.is_some() + && let Some(observer) = observer + { + request = request.with_upload_observer(observer); + } + preflight_headers = next_headers; + if let Err(message) = redirect_owner.admit(&cancel).await { + return failure(message); + } + } + Ok(ServiceWorkerDirectFetchResult::Stream(mut stream)) => { + timing.begin_synthetic_response(); + timing.observe_head(&stream.head); + let mut body = SubresourceResponseBodyWriter::with_disk_pool( + load.request_client().disk_pool(), + ); + let result = loop { + let event = tokio::select! { + biased; + _ = cancel.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); + } + Some(ServiceWorkerDirectFetchStreamEvent::Finished(result)) => { + break result; + } + None => { + break Err("service worker XHR response stream closed".to_owned()); + } + } + }; + let head = Box::new(stream.head); + let response_filter = stream.response_filter; + return WorkerXhrCompletion { + native_record: None, + + xhr_id, + network_request_headers: None, + response_filter, + skip_fetch_security_validation: true, + result: result.map(|()| WorkerXhrResponse::Streamed { + head, + body: body.finish(), + }), + }; + } + Ok(ServiceWorkerDirectFetchResult::Response(response)) => { + let synthetic = !response.from_network_fallback; + if synthetic { + timing.begin_synthetic_response(); + } + let response_filter = response.response_filter; + let response: Response = (*response.response).into(); + timing.observe_head(&response.head()); + timing.observe_chunk(response.body_bytes().len()); + return WorkerXhrCompletion { + native_record: None, + + xhr_id, + network_request_headers: None, + response_filter, + skip_fetch_security_validation: synthetic, + result: Ok(WorkerXhrResponse::Materialized(Box::new(response))), + }; + } + Ok(ServiceWorkerDirectFetchResult::Failure(message)) => return failure(message), + Ok(ServiceWorkerDirectFetchResult::FallbackStream(_)) => { + return failure("XMLHttpRequest cannot upload an author stream".to_owned()); + } + Err(_) => { + return failure("service worker XHR completion channel closed".to_owned()); + } + } + } + let credentials_mode = controller + .policy_context + .network_credentials_mode(RequestMode::Cors, request.credentials_mode); + request = request.with_credentials_mode(credentials_mode); + } + let (result, network_request_headers) = super::fetch::load_worker_xhr_response( + load, + request, + cancel, + preflight_headers, + timing, + Some(redirect_owner), + ) + .await; + WorkerXhrCompletion { + native_record: None, + + xhr_id, + network_request_headers, + response_filter: None, + skip_fetch_security_validation: false, + result, + } +} diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index 611795636f8..b751923d9ed 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -3578,6 +3578,8 @@ async fn worker_main( csp_violations: Vec::new(), local_request: Some(local_request), + response_filter: None, + xhr_id, result: Err(error_text), }, 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 0aee878cb73..2de4be73660 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 @@ -2078,8 +2078,8 @@ async fn service_worker_soft_reload_exposes_native_cache_mode_on_request_copies( let request = ServiceWorkerFetchRequest { body_stream: None, - client_id: crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test( - 7, + client_id: Some( + crate::service_worker_runtime::ServiceWorkerClientId::from_u64_for_test(7), ), resulting_client_id: None, url,