Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.rsindex 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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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 {