Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

refactor(network): share resource request preparation and dispatch

ldm079dec637d78e
diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs
index f26f6ce47..164a2c346 100644
--- a/moli-renderer-v8/src/network_host.rs
+++ b/moli-renderer-v8/src/network_host.rs
@@ -18,6 +18,7 @@ mod request;
mod request_scope;
mod response;
mod stylesheet_subresource;
+mod subresource;
mod text_track;
mod url_helpers;
mod xhr;
diff --git a/moli-renderer-v8/src/network_host/font_face.rs b/moli-renderer-v8/src/network_host/font_face.rs
index 6e4491aff..f13578e04 100644
--- a/moli-renderer-v8/src/network_host/font_face.rs
+++ b/moli-renderer-v8/src/network_host/font_face.rs
@@ -1,18 +1,8 @@
+use super::subresource::{PreparedSubresourceFetch, SubresourceFetchOptions};
use super::*;
-use crate::service_worker_runtime::{
- ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination,
- service_worker_fetch_request_metadata,
-};
use crate::{
native_bridge::JsContextHost,
- types::{
- AsyncSubresourceNetworkContext, PendingSubresourceFetchInfo,
- SubresourceRequestInitiatorType, SubresourceResourceType,
- },
-};
-use moli_fetch::{
- BrowserRequestMetadata, FetchCancelHandle, RequestCredentialsMode, RequestMode,
- RequestResourceType,
+ types::{SubresourceRequestInitiatorType, SubresourceResourceType},
};
pub(crate) enum FontFaceFetchStart {
@@ -66,17 +56,14 @@ pub(crate) fn start_font_face_fetch(
let environment = host
.subresource_request_environment(&resource_loader, owner)
.ok_or_else(|| "Font request has no live document request environment".to_owned())?;
- let crate::network::context::SubresourceRequestEnvironment {
- document_url,
- base_url,
- request_origin,
- frame_id,
- } = environment;
- let request_url = base_url.join(source).map_err(|e| e.to_string())?;
+ let request_url = environment
+ .base_url
+ .join(source)
+ .map_err(|e| e.to_string())?;
if !host.font_request_allowed_by_csp(
scope,
owner,
- &document_url,
+ &environment.document_url,
&request_url,
crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect,
) {
@@ -90,8 +77,8 @@ pub(crate) fn start_font_face_fetch(
Err("Font request failed".to_owned())
};
host.record_get_subresource_network_result_with_initiator(
- frame_id,
- document_url,
+ environment.frame_id,
+ environment.document_url,
request_url,
SubresourceResourceType::Font,
SubresourceRequestInitiatorType::Script,
@@ -99,124 +86,28 @@ pub(crate) fn start_font_face_fetch(
);
return result;
}
- let loader = resource_loader.request_client().clone();
- let network_partition_key = active_subresource_network_partition_key(host, owner);
- let policy_context = effective_subresource_policy_context(scope, host, owner);
- let request_cookie_report = observe_subresource_request_cookie_report(
- &loader,
- &document_url,
- &request_origin,
- &request_url,
- "GET",
- RequestCredentialsMode::SameOrigin,
- );
- let request = Request::new("GET", request_url.as_str(), None, Vec::new())
- .map_err(|e| e.to_string())?
- .with_initiator_url(&document_url)
- .with_request_origin(request_origin.clone())
- .with_resource_type(RequestResourceType::Font)
- .with_page_network_policy()
- .with_request_mode(RequestMode::Cors)
- .with_credentials_mode(RequestCredentialsMode::SameOrigin)
- .with_network_partition_key(network_partition_key.clone())
- .with_browser_request_metadata(BrowserRequestMetadata::Font)
- .with_subframe_context(frame_id.is_some());
- let cancel_handle = FetchCancelHandle::new();
+ let prepared = PreparedSubresourceFetch::prepare(
+ scope,
+ host,
+ owner,
+ &resource_loader,
+ environment,
+ request_url,
+ SubresourceFetchOptions::FONT,
+ )?;
let internal_id = host.record_async_font_face_fetch(
v8::Global::new(scope, scope.get_current_context()),
v8::Global::new(scope, face),
owner,
- cancel_handle.clone(),
- network_partition_key,
- policy_context,
- PendingSubresourceFetchInfo {
- internal_id: 0,
- network_request_handle: None,
- frame_id: frame_id.clone(),
- document_url: document_url.clone(),
- url: request_url.clone(),
- websocket_socket_id: None,
- method: "GET".into(),
- request_headers: Default::default(),
- request_body: None,
- request_body_bytes: None,
- resource_type: SubresourceResourceType::Font,
- request_cookie_report: request_cookie_report.clone(),
- },
+ prepared.cancel_handle.clone(),
+ prepared.network_partition_key.clone(),
+ prepared.network_context.policy_context,
+ prepared.pending_info.clone(),
);
- let client_id = host.service_worker_client_id_for_subresource_owner(owner);
- if matches!(request_url.scheme(), "http" | "https")
- && host
- .service_worker_controller_for_fetch(client_id, &document_url, &request_url)
- .is_some()
- {
- let dispatch = ServiceWorkerFetchDispatch {
- internal_id,
- request: host.service_worker_fetch_request(
- client_id,
- request_url.clone(),
- "GET".into(),
- Vec::new(),
- None,
- ServiceWorkerRequestDestination::Font,
- RequestMode::Cors,
- RequestCredentialsMode::SameOrigin,
- moli_fetch::RequestRedirectMode::Follow,
- request.priority_hints.fetch_priority,
- service_worker_fetch_request_metadata(&request),
- ),
- cors_preflight_request_headers: Vec::new(),
- request_cookie_report,
- network_context: AsyncSubresourceNetworkContext {
- request_origin: request_origin.clone(),
- frame_id,
- document_url,
- resource_type: SubresourceResourceType::Font,
- policy_context,
- },
- completion_tx: host.resource_completion_sender(),
- request_client: loader,
- resource_task_runner: resource_loader.task_runner(),
- cancel_handle,
- direct_completion_tx: None,
- };
- if !host.dispatch_service_worker_fetch(dispatch) {
- let _ = host.resource_completion_sender().send_async_subresource(
- crate::types::AsyncSubresourceFetchCompletion {
- internal_id,
- request_url,
- request_method: "GET".into(),
- request_headers: Default::default(),
- request_body: None,
- response_status_text: None,
- skip_fetch_security_validation: false,
- response_filter: None,
- network_error_text: None,
- result: Err("service worker font request dispatch failed".into()).into(),
- },
- );
- }
- return Ok(FontFaceFetchStart::Pending);
- }
- spawn_async_subresource_fetch(
- resource_loader.task_runner(),
- host.resource_completion_sender(),
- loader,
- request,
- Some(cancel_handle),
- Vec::new(),
+ prepared.dispatch(
+ host,
internal_id,
- AsyncSubresourceNetworkContext {
- request_origin,
- frame_id,
- document_url,
- resource_type: SubresourceResourceType::Font,
- policy_context,
- },
- request_url,
- "GET".into(),
- Default::default(),
- None,
+ "service worker font request dispatch failed",
);
Ok(FontFaceFetchStart::Pending)
}
diff --git a/moli-renderer-v8/src/network_host/stylesheet_subresource.rs b/moli-renderer-v8/src/network_host/stylesheet_subresource.rs
index 3c46337cc..8d78854b7 100644
--- a/moli-renderer-v8/src/network_host/stylesheet_subresource.rs
+++ b/moli-renderer-v8/src/network_host/stylesheet_subresource.rs
@@ -1,3 +1,4 @@
+use super::subresource::{PreparedSubresourceFetch, SubresourceFetchOptions};
use super::*;
use crate::{
css_resource_urls::{
@@ -6,18 +7,7 @@ use crate::{
},
frame_owner_model::StylesheetSubresourceLoadDelayBinding,
native_bridge::{JsContextHost, OwnerDispatchScope},
- service_worker_runtime::{
- ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination,
- service_worker_fetch_request_metadata,
- },
- types::{
- AsyncSubresourceFetchCompletion, AsyncSubresourceNetworkContext,
- PendingSubresourceFetchInfo, SubresourceRequestInitiatorType, SubresourceResourceType,
- },
-};
-use moli_fetch::{
- BrowserRequestMetadata, FetchCancelHandle, RequestCredentialsMode, RequestMode,
- RequestRedirectMode, RequestResourceType,
+ types::SubresourceRequestInitiatorType,
};
#[derive(Debug)]
@@ -50,12 +40,6 @@ pub(crate) fn start_stylesheet_subresource_fetch(
let environment = host
.subresource_request_environment(&resource_loader, owner)
.ok_or_else(|| "stylesheet Document request environment is unavailable".to_owned())?;
- let crate::network::context::SubresourceRequestEnvironment {
- document_url,
- request_origin,
- frame_id,
- ..
- } = environment;
let resource_kind = resource.kind();
if css_image.is_some() && resource_kind != StylesheetLoadBlockingResourceKind::Image {
return Err("a stylesheet CSS image identity was bound to a non-image resource".to_owned());
@@ -72,31 +56,11 @@ pub(crate) fn start_stylesheet_subresource_fetch(
}
}
let (request_url, web_font) = resource.into_parts();
- let (
- resource_type,
- request_resource_type,
- metadata,
- destination,
- request_mode,
- credentials_mode,
- ) = match resource_kind {
- StylesheetLoadBlockingResourceKind::Image => (
- SubresourceResourceType::Image,
- RequestResourceType::Image,
- BrowserRequestMetadata::Image,
- ServiceWorkerRequestDestination::Image,
- RequestMode::NoCors,
- RequestCredentialsMode::Include,
- ),
- StylesheetLoadBlockingResourceKind::Font => (
- SubresourceResourceType::Font,
- RequestResourceType::Font,
- BrowserRequestMetadata::Font,
- ServiceWorkerRequestDestination::Font,
- RequestMode::Cors,
- RequestCredentialsMode::SameOrigin,
- ),
+ let options = match resource_kind {
+ StylesheetLoadBlockingResourceKind::Image => SubresourceFetchOptions::CSS_IMAGE,
+ StylesheetLoadBlockingResourceKind::Font => SubresourceFetchOptions::FONT,
};
+ let resource_type = options.resource_type;
if let Some(response) = local_url_response(&request_url) {
let mut response: crate::protocol_types::NavigationResponse = response.into();
@@ -143,8 +107,8 @@ pub(crate) fn start_stylesheet_subresource_fetch(
let result = Ok(response);
if let Some(encoded) = encoded {
host.record_get_subresource_network_result_with_body_and_initiator(
- frame_id,
- document_url,
+ environment.frame_id,
+ environment.document_url,
request_url,
resource_type,
SubresourceRequestInitiatorType::Css,
@@ -153,8 +117,8 @@ pub(crate) fn start_stylesheet_subresource_fetch(
);
} else {
host.record_get_subresource_network_result_with_initiator(
- frame_id,
- document_url,
+ environment.frame_id,
+ environment.document_url,
request_url,
resource_type,
SubresourceRequestInitiatorType::Css,
@@ -165,141 +129,45 @@ pub(crate) fn start_stylesheet_subresource_fetch(
return Ok(terminal);
}
- let loader = resource_loader.request_client().clone();
- if !loader.optional_resource_fetch_enabled(resource_type) {
+ if !resource_loader
+ .request_client()
+ .optional_resource_fetch_enabled(resource_type)
+ {
if let Some(identity) = css_image.as_ref() {
let _ = host.fail_stylesheet_css_image(identity);
}
host.settle_stylesheet_subresource_load_delay(binding);
return Ok(synchronous_failure_terminal(is_web_font, web_font));
}
- let network_partition_key = active_subresource_network_partition_key(host, owner);
- let policy_context = effective_subresource_policy_context(scope, host, owner);
- let request_cookie_report = observe_subresource_request_cookie_report(
- &loader,
- &document_url,
- &request_origin,
- &request_url,
- "GET",
- credentials_mode,
- );
- let request = Request::new("GET", request_url.as_str(), None, Vec::new())
- .map_err(|error| error.to_string())?
- .with_initiator_url(&document_url)
- .with_request_origin(request_origin.clone())
- .with_resource_type(request_resource_type)
- .with_page_network_policy()
- .with_request_mode(request_mode)
- .with_credentials_mode(credentials_mode)
- .with_network_partition_key(network_partition_key.clone())
- .with_redirect_mode(RequestRedirectMode::Follow)
- .with_browser_request_metadata(metadata)
- .with_subframe_context(frame_id.is_some());
- let cancel_handle = FetchCancelHandle::new();
+ let prepared = PreparedSubresourceFetch::prepare(
+ scope,
+ host,
+ owner,
+ &resource_loader,
+ environment,
+ request_url,
+ options,
+ )?;
let Some(internal_id) = host.record_async_stylesheet_subresource_fetch(
v8::Global::new(scope, scope.get_current_context()),
binding,
owner,
- cancel_handle.clone(),
- credentials_mode,
- request_mode,
- network_partition_key,
- policy_context,
+ prepared.cancel_handle.clone(),
+ options.credentials_mode,
+ options.request_mode,
+ prepared.network_partition_key.clone(),
+ prepared.network_context.policy_context,
web_font,
css_image,
- PendingSubresourceFetchInfo {
- internal_id: 0,
- network_request_handle: None,
- frame_id: frame_id.clone(),
- document_url: document_url.clone(),
- url: request_url.clone(),
- websocket_socket_id: None,
- method: "GET".to_owned(),
- request_headers: Default::default(),
- request_body: None,
- request_body_bytes: None,
- resource_type,
- request_cookie_report: request_cookie_report.clone(),
- },
+ prepared.pending_info.clone(),
) else {
return Err("stylesheet subresource owner changed before request binding".to_owned());
};
- let client_id = host.service_worker_client_id_for_subresource_owner(owner);
- if matches!(request_url.scheme(), "http" | "https")
- && host
- .service_worker_controller_for_fetch(client_id, &document_url, &request_url)
- .is_some()
- {
- let dispatch = ServiceWorkerFetchDispatch {
- internal_id,
- request: host.service_worker_fetch_request(
- client_id,
- request_url.clone(),
- "GET".to_owned(),
- Vec::new(),
- None,
- destination,
- request_mode,
- credentials_mode,
- RequestRedirectMode::Follow,
- request.priority_hints.fetch_priority,
- service_worker_fetch_request_metadata(&request),
- ),
- cors_preflight_request_headers: Vec::new(),
- request_cookie_report,
- network_context: AsyncSubresourceNetworkContext {
- frame_id,
- request_origin: request_origin.clone(),
- document_url,
- resource_type,
- policy_context,
- },
- completion_tx: host.resource_completion_sender(),
- request_client: loader,
- resource_task_runner: resource_loader.task_runner(),
- cancel_handle,
- direct_completion_tx: None,
- };
- if !host.dispatch_service_worker_fetch(dispatch) {
- let _ = host.resource_completion_sender().send_async_subresource(
- AsyncSubresourceFetchCompletion {
- internal_id,
- request_url,
- request_method: "GET".to_owned(),
- request_headers: Default::default(),
- request_body: None,
- response_status_text: None,
- skip_fetch_security_validation: false,
- response_filter: None,
- network_error_text: None,
- result: Err("service worker stylesheet subresource dispatch failed".to_owned())
- .into(),
- },
- );
- }
- return Ok(StylesheetSubresourceFetchStart::Pending);
- }
-
- spawn_async_subresource_fetch(
- resource_loader.task_runner(),
- host.resource_completion_sender(),
- loader,
- request,
- Some(cancel_handle),
- Vec::new(),
+ prepared.dispatch(
+ host,
internal_id,
- AsyncSubresourceNetworkContext {
- frame_id,
- request_origin: request_origin.clone(),
- document_url,
- resource_type,
- policy_context,
- },
- request_url,
- "GET".to_owned(),
- Default::default(),
- None,
+ "service worker stylesheet subresource dispatch failed",
);
Ok(StylesheetSubresourceFetchStart::Pending)
}
diff --git a/moli-renderer-v8/src/network_host/subresource.rs b/moli-renderer-v8/src/network_host/subresource.rs
new file mode 100644
index 000000000..523918be4
--- /dev/null
+++ b/moli-renderer-v8/src/network_host/subresource.rs
@@ -0,0 +1,205 @@
+use super::*;
+use crate::{
+ native_bridge::{JsContextHost, OwnerDispatchScope},
+ network::context::{DocumentResourceLoader, SubresourceRequestEnvironment},
+ service_worker_runtime::{
+ ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination,
+ service_worker_fetch_request_metadata,
+ },
+ types::{
+ AsyncSubresourceFetchCompletion, AsyncSubresourceNetworkContext,
+ PendingSubresourceFetchInfo, SubresourceResourceType,
+ },
+};
+use moli_fetch::{
+ BrowserRequestMetadata, FetchCancelHandle, RequestCredentialsMode, RequestMode,
+ RequestRedirectMode, RequestResourceType,
+};
+
+#[derive(Clone, Copy)]
+pub(super) struct SubresourceFetchOptions {
+ pub(super) resource_type: SubresourceResourceType,
+ pub(super) request_mode: RequestMode,
+ pub(super) credentials_mode: RequestCredentialsMode,
+ request_resource_type: RequestResourceType,
+ metadata: BrowserRequestMetadata,
+ destination: ServiceWorkerRequestDestination,
+}
+
+impl SubresourceFetchOptions {
+ pub(super) const FONT: Self = Self {
+ resource_type: SubresourceResourceType::Font,
+ request_mode: RequestMode::Cors,
+ credentials_mode: RequestCredentialsMode::SameOrigin,
+ request_resource_type: RequestResourceType::Font,
+ metadata: BrowserRequestMetadata::Font,
+ destination: ServiceWorkerRequestDestination::Font,
+ };
+
+ pub(super) const CSS_IMAGE: Self = Self {
+ resource_type: SubresourceResourceType::Image,
+ request_mode: RequestMode::NoCors,
+ credentials_mode: RequestCredentialsMode::Include,
+ request_resource_type: RequestResourceType::Image,
+ metadata: BrowserRequestMetadata::Image,
+ destination: ServiceWorkerRequestDestination::Image,
+ };
+}
+
+/// Captures one resource request without starting it. The caller first admits
+/// it through CSP/local-resource policy and binds its own pending continuation,
+/// then dispatches using the assigned request identity.
+pub(super) struct PreparedSubresourceFetch {
+ pub(super) cancel_handle: FetchCancelHandle,
+ pub(super) network_partition_key: Option<String>,
+ pub(super) network_context: AsyncSubresourceNetworkContext,
+ pub(super) pending_info: PendingSubresourceFetchInfo,
+ request: Request,
+ resource_loader: DocumentResourceLoader,
+ owner: OwnerDispatchScope,
+ destination: ServiceWorkerRequestDestination,
+}
+
+impl PreparedSubresourceFetch {
+ pub(super) fn prepare(
+ scope: &mut v8::PinScope<'_, '_>,
+ host: &JsContextHost,
+ owner: OwnerDispatchScope,
+ resource_loader: &DocumentResourceLoader,
+ environment: SubresourceRequestEnvironment,
+ request_url: url::Url,
+ options: SubresourceFetchOptions,
+ ) -> Result<Self, String> {
+ let SubresourceRequestEnvironment {
+ document_url,
+ request_origin,
+ frame_id,
+ ..
+ } = environment;
+ let network_partition_key = active_subresource_network_partition_key(host, owner);
+ let policy_context = effective_subresource_policy_context(scope, host, owner);
+ let request_cookie_report = observe_subresource_request_cookie_report(
+ resource_loader.request_client(),
+ &document_url,
+ &request_origin,
+ &request_url,
+ "GET",
+ options.credentials_mode,
+ );
+ let request = Request::new("GET", request_url.as_str(), None, Vec::new())
+ .map_err(|error| error.to_string())?
+ .with_initiator_url(&document_url)
+ .with_request_origin(request_origin.clone())
+ .with_resource_type(options.request_resource_type)
+ .with_page_network_policy()
+ .with_request_mode(options.request_mode)
+ .with_credentials_mode(options.credentials_mode)
+ .with_network_partition_key(network_partition_key.clone())
+ .with_redirect_mode(RequestRedirectMode::Follow)
+ .with_browser_request_metadata(options.metadata)
+ .with_subframe_context(frame_id.is_some());
+ let pending_info = PendingSubresourceFetchInfo {
+ internal_id: 0,
+ network_request_handle: None,
+ frame_id: frame_id.clone(),
+ document_url: document_url.clone(),
+ url: request_url,
+ websocket_socket_id: None,
+ method: "GET".to_owned(),
+ request_headers: Default::default(),
+ request_body: None,
+ request_body_bytes: None,
+ resource_type: options.resource_type,
+ request_cookie_report,
+ };
+ Ok(Self {
+ cancel_handle: FetchCancelHandle::new(),
+ network_partition_key,
+ network_context: AsyncSubresourceNetworkContext {
+ request_origin,
+ frame_id,
+ document_url,
+ resource_type: options.resource_type,
+ policy_context,
+ },
+ pending_info,
+ request,
+ resource_loader: resource_loader.clone(),
+ owner,
+ destination: options.destination,
+ })
+ }
+
+ pub(super) fn dispatch(
+ self,
+ host: &mut JsContextHost,
+ internal_id: u64,
+ service_worker_failure: &str,
+ ) {
+ let loader = self.resource_loader.request_client().clone();
+ let task_runner = self.resource_loader.task_runner();
+ let info = self.pending_info;
+ let client_id = host.service_worker_client_id_for_subresource_owner(self.owner);
+ if matches!(info.url.scheme(), "http" | "https")
+ && host
+ .service_worker_controller_for_fetch(client_id, &info.document_url, &info.url)
+ .is_some()
+ {
+ let dispatch = ServiceWorkerFetchDispatch {
+ internal_id,
+ request: host.service_worker_fetch_request(
+ client_id,
+ info.url.clone(),
+ info.method.clone(),
+ Vec::new(),
+ None,
+ self.destination,
+ self.request.request_mode,
+ self.request.credentials_mode,
+ RequestRedirectMode::Follow,
+ self.request.priority_hints.fetch_priority,
+ service_worker_fetch_request_metadata(&self.request),
+ ),
+ cors_preflight_request_headers: Vec::new(),
+ request_cookie_report: info.request_cookie_report,
+ network_context: self.network_context,
+ completion_tx: host.resource_completion_sender(),
+ request_client: loader,
+ resource_task_runner: task_runner,
+ cancel_handle: self.cancel_handle,
+ direct_completion_tx: None,
+ };
+ if !host.dispatch_service_worker_fetch(dispatch) {
+ let _ = host.resource_completion_sender().send_async_subresource(
+ AsyncSubresourceFetchCompletion {
+ internal_id,
+ request_url: info.url,
+ request_method: info.method,
+ request_headers: info.request_headers,
+ request_body: info.request_body,
+ response_status_text: None,
+ skip_fetch_security_validation: false,
+ response_filter: None,
+ network_error_text: None,
+ result: Err(service_worker_failure.to_owned()).into(),
+ },
+ );
+ }
+ return;
+ }
+ spawn_async_subresource_fetch(
+ task_runner,
+ host.resource_completion_sender(),
+ loader,
+ self.request,
+ Some(self.cancel_handle),
+ Vec::new(),
+ internal_id,
+ self.network_context,
+ info.url,
+ info.method,
+ info.request_headers,
+ info.request_body,
+ );
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs
index 95714d1a8..dda829f46 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface.rs
@@ -660,6 +660,95 @@ async fn navigator_service_worker_intercepts_element_resource_destinations_once(
.await
.expect("service worker element-resource destination server should finish");
}
+#[tokio::test]
+async fn navigator_service_worker_intercepts_script_font_face_with_font_request_policy() {
+ let (base_url, server) = spawn_service_worker_response_server(vec![(
+ "/app/worker.js",
+ "text/javascript; charset=utf-8",
+ r#"
+ self.addEventListener("activate", event => event.waitUntil(clients.claim()));
+ self.addEventListener("fetch", event => {
+ event.respondWith(new Response([
+ event.request.destination,
+ event.request.mode,
+ event.request.credentials,
+ event.request.method,
+ event.request.redirect
+ ].join("|")));
+ });
+ "#,
+ )])
+ .await;
+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
+ let (mut vm, browser_context_runtime) =
+ new_service_worker_page_test_vm_with_loader_and_browser_context_runtime(
+ &format!("{base_url}/app/page.html"),
+ &loader,
+ );
+ vm.eval(
+ r#"
+ globalThis.fontProbe = "pending";
+ (async () => {
+ await navigator.serviceWorker.register("worker.js", {scope:"./"});
+ await navigator.serviceWorker.ready;
+ const face = new FontFace("ServiceWorkerFont", 'url("script-font.woff2")');
+ document.fonts.add(face);
+ await face.load().then(
+ () => { fontProbe = "unexpected success"; },
+ error => { fontProbe = `${error.name}|${face.status}`; });
+ })().catch(error => { fontProbe = String(error); });
+ "#,
+ )
+ .expect("script FontFace service worker probe should evaluate");
+ // The diagnostic response is deliberately not a font. Its network success
+ // must reach FontFace validation and settle the retained JS continuation.
+ drain_service_worker_test_until_eval_equals(
+ &mut vm,
+ &browser_context_runtime,
+ &loader,
+ "fontProbe",
+ "NetworkError|error",
+ )
+ .await;
+ let expected_url = format!("{base_url}/app/script-font.woff2");
+ let items = vm.take_network_output().into_items().collect::<Vec<_>>();
+ let requests = items
+ .iter()
+ .filter_map(|item| {
+ let crate::types::ScriptNetworkOutputItem::SubresourceRequestStarted(request) = item
+ else {
+ return None;
+ };
+ (request.url().as_str() == expected_url).then_some(request)
+ })
+ .collect::<Vec<_>>();
+ assert_eq!(requests.len(), 1, "{items:?}");
+ assert_eq!(
+ requests[0].resource_type(),
+ crate::types::SubresourceResourceType::Font
+ );
+ assert_eq!(
+ requests[0].request_initiator_type(),
+ crate::types::SubresourceRequestInitiatorType::Script
+ );
+ assert!(
+ items.iter().any(|item| {
+ let crate::types::ScriptNetworkOutputItem::SubresourceNetworkRecord(record) = item
+ else {
+ return false;
+ };
+ record.request_handle() == Some(requests[0].handle())
+ && matches!(record.outcome(), crate::types::SubresourceNetworkOutcome::Success {
+ status: 200, response_body, ..
+ } if response_body.diagnostic_bytes().as_ref() == b"font|cors|same-origin|GET|follow")
+ }),
+ "{items:?}"
+ );
+ server
+ .await
+ .expect("service worker script server should finish");
+}
+
#[tokio::test]
async fn navigator_service_worker_intercepts_stylesheet_font_face_destination() {
let (base_url, server) = spawn_service_worker_response_server(vec![(
@@ -684,6 +773,13 @@ async fn navigator_service_worker_intercepts_stylesheet_font_face_destination()
}));
return;
}
+ if (expected === "font" && (
+ event.request.mode !== "cors" || event.request.credentials !== "same-origin" ||
+ event.request.method !== "GET" || event.request.redirect !== "follow"
+ )) {
+ event.respondWith(new Response("wrong font request policy", {status:500}));
+ return;
+ }
if (expected === "style") {
event.respondWith(new Response(`
@font-face {