fix(workers): intercept async XHR with the native client controller

This commit is contained in:
ldm0
2026-11-20 22:48:02 +08:00
parent e95cb69ef4
commit 99dca4d7e2
22 changed files with 669 additions and 76 deletions
+3 -2
View File
@@ -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";
@@ -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,
@@ -25,6 +25,7 @@ impl BufferedXhrResponse {
#[derive(Debug)]
pub(crate) struct XhrLoadResult {
pub(crate) response_filter: Option<crate::types::AsyncSubresourceFetchResponseFilter>,
pub(crate) result: Result<Response, String>,
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,
}
}
}
@@ -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<crate::context_bootstrap::ReadableStreamClonePayload>,
request_body_owner: Option<crate::context_bootstrap::RequestBodyOwner>,
}
@@ -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<crate::context_bootstrap::ReadableStreamClonePayload>, request_body_owner: Option<crate::context_bootstrap::RequestBodyOwner>) -> 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)
+1
View File
@@ -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;
@@ -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<u8>)> {
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)
}
@@ -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"
@@ -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 {
@@ -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(),
+18 -18
View File
@@ -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,
@@ -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<ServiceWorkerDirectFetchResult>,
pub(super) stream_response: bool,
pub(super) defer_network_fallback: bool,
}
impl ServiceWorkerDirectFetchCompletion {
pub(crate) fn buffered(
sender: tokio::sync::oneshot::Sender<ServiceWorkerDirectFetchResult>,
) -> Self {
Self {
sender,
stream_response: false,
defer_network_fallback: false,
}
}
pub(crate) fn streaming(
sender: tokio::sync::oneshot::Sender<ServiceWorkerDirectFetchResult>,
) -> Self {
Self {
stream_response: true,
..Self::buffered(sender)
}
}
pub(crate) fn streaming_with_network_fallback(
sender: tokio::sync::oneshot::Sender<ServiceWorkerDirectFetchResult>,
) -> 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<moli_fetch::Request>,
preflight_headers: Vec<(String, String)>,
},
Response(ServiceWorkerDirectFetchResponse),
Stream(Box<ServiceWorkerDirectFetchStream>),
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<tokio::sync::oneshot::Sender<ServiceWorkerDirectFetchResult>>,
pub(crate) direct_completion_tx: Option<ServiceWorkerDirectFetchCompletion>,
}
#[cfg(test)]
@@ -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<ServiceWorkerDirectFetchResult>,
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
@@ -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"
);
@@ -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();
@@ -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,
@@ -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<moli_fetch::FetchCancelHandle>,
pub(super) streaming_body_source_id: Option<crate::types::NetworkBodySourceId>,
pub(super) direct_completion_tx:
Option<tokio::sync::oneshot::Sender<ServiceWorkerDirectFetchResult>>,
pub(super) direct_completion_tx: Option<super::events::ServiceWorkerDirectFetchCompletion>,
}
impl ServiceWorkerFetchJob {
@@ -412,6 +412,7 @@ fn send_worker_content_security_policy_report_for_state(
.run()
.await;
});
}
@@ -149,12 +149,15 @@ pub(in crate::worker) struct PendingWorkerXhr {
pub(in crate::worker) xhr: v8::Global<v8::Object>,
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<crate::types::AsyncSubresourceFetchResponseFilter>,
pub(in crate::worker) csp_violations:
Vec<crate::content_security_policy::ContentSecurityPolicyUrlViolation>,
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.
@@ -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);
@@ -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<RefCell<WorkerGlobalState>>,
xhr_id: u32,
url: &Url,
) -> Option<WorkerXhrServiceWorkerController> {
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<WorkerXhrServiceWorkerController>,
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,
}
}
@@ -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),
},
@@ -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,