mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
fix(workers): intercept async XHR with the native client controller
This commit is contained in:
@@ -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)
|
||||
|
||||
@@ -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"
|
||||
|
||||
+204
@@ -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(),
|
||||
|
||||
@@ -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"
|
||||
);
|
||||
|
||||
+35
-7
@@ -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();
|
||||
|
||||
+3
-1
@@ -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,
|
||||
|
||||
Reference in New Issue
Block a user