From fcdb5dc6e4a4d72eb4329dfeb6d52c4450fa3ad2 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Mon, 19 Oct 2026 01:24:40 +0800 Subject: [PATCH] feat(fetch): preload stylesheets from Document response headers --- moli-renderer-v8/src/network/preloads.rs | 10 +- moli-renderer-v8/src/network_host/preload.rs | 160 ++++++++++++------ moli-renderer-v8/src/response_links.rs | 93 ++++++++++ .../page_vm/tests/response_preloads.rs | 152 +++++++++++++++++ .../src/script_vm/response_links.rs | 6 +- .../subresource_fetch/response_preload.rs | 22 +-- .../script_vm/subresource_fetch/streaming.rs | 5 +- moli-renderer-v8/src/stylesheet_blocking.rs | 31 +++- moli-renderer-v8/src/types.rs | 2 +- 9 files changed, 408 insertions(+), 73 deletions(-) diff --git a/moli-renderer-v8/src/network/preloads.rs b/moli-renderer-v8/src/network/preloads.rs index 0fae5675e71..b777fb6d363 100644 --- a/moli-renderer-v8/src/network/preloads.rs +++ b/moli-renderer-v8/src/network/preloads.rs @@ -55,9 +55,15 @@ impl PreloadKey { { return None; } + let mut url = request.url.clone(); let destination = match request.browser_request_metadata()? { BrowserRequestMetadata::Script => "script", - BrowserRequestMetadata::Style | BrowserRequestMetadata::StyleModule => "style", + BrowserRequestMetadata::Style | BrowserRequestMetadata::StyleModule => { + // StylesheetResourceKey also removes fragments before preparing + // a consumer request. Both paths must name the same resource. + url.set_fragment(None); + "style" + } BrowserRequestMetadata::Image => "image", BrowserRequestMetadata::Font => "font", BrowserRequestMetadata::TextTrack => "track", @@ -65,7 +71,7 @@ impl PreloadKey { _ => return None, }; Some(Self { - url: request.url.clone(), + url, destination, mode: request.request_mode, credentials: request.credentials_mode, diff --git a/moli-renderer-v8/src/network_host/preload.rs b/moli-renderer-v8/src/network_host/preload.rs index fb18972b087..ed6441cbd51 100644 --- a/moli-renderer-v8/src/network_host/preload.rs +++ b/moli-renderer-v8/src/network_host/preload.rs @@ -1,7 +1,7 @@ use super::*; use crate::{ native_bridge::{PageScriptHost, WindowDocumentTaskTarget}, - response_links::{DocumentResponseLinks, ResponseScriptPreload}, + response_links::{DocumentResponseLinks, ResponsePreloadOptions}, service_worker_runtime::{ ServiceWorkerFetchDispatch, ServiceWorkerRequestDestination, service_worker_fetch_request_metadata, @@ -15,6 +15,7 @@ use moli_fetch::{ BrowserRequestMetadata, FetchCancelHandle, RequestCredentialsMode, RequestMode, RequestRedirectMode, RequestResourceType, }; +use url::Url; pub(crate) fn start_document_response_links( scope: &mut v8::PinScope<'_, '_>, @@ -23,20 +24,37 @@ pub(crate) fn start_document_response_links( links: &DocumentResponseLinks, ) { start_response_dictionary_loads(scope, host, target, &links.dictionaries); - if !host.owner_scripting_enabled(target.dispatch_scope()) { - return; - } - for preload in &links.scripts { + let scripting_enabled = host.owner_scripting_enabled(target.dispatch_scope()); + for (url, options) in links + .scripts + .iter() + .filter(|_| scripting_enabled) + .map(|preload| { + ( + &preload.url, + ResponsePreloadOptions::Script(preload.metadata.clone()), + ) + }) + .chain(links.styles.iter().map(|preload| { + ( + &preload.url, + ResponsePreloadOptions::Style(preload.options.clone()), + ) + })) + { if !host.window_document_owner_is_current_for_dispatch_scope( target.owner(), target.dispatch_scope(), ) { break; } - if let Err(error) = start_script_preload(scope, host, target, preload) { - tracing::debug!(url = %preload.url, error, "response script preload was not loaded"); + if let Err(error) = start_resource_preload(scope, host, target, url, options) { + tracing::debug!(%url, error, "response preload was not loaded"); } } + if !scripting_enabled { + return; + } if let ( crate::native_bridge::OwnerDispatchScope::Child(handle), crate::native_bridge::WindowDocumentOwner::Frame(owner), @@ -72,27 +90,42 @@ pub(crate) fn apply_response_preload_request_metadata( request: Request, preload: &PendingResponsePreload, ) -> Request { - request - .with_browser_request_metadata(BrowserRequestMetadata::Script) - .with_resource_type(RequestResourceType::Script) - .with_link_preload() - .with_script_fetch_metadata(moli_fetch::ScriptFetchRequestMetadata { - cross_origin: preload.metadata.cross_origin.clone(), - referrer_policy: preload.metadata.referrer_policy.clone(), - document_referrer_policy: preload.document_referrer_policy.clone(), - charset: None, - integrity: preload.metadata.integrity.clone(), - nonce: preload.metadata.nonce.clone(), - fetch_priority: preload.metadata.fetch_priority, - scheduler_priority: None, - }) + let request = match &preload.options { + ResponsePreloadOptions::Script(metadata) => request + .with_browser_request_metadata(BrowserRequestMetadata::Script) + .with_resource_type(RequestResourceType::Script) + .with_script_fetch_metadata(moli_fetch::ScriptFetchRequestMetadata { + cross_origin: metadata.cross_origin.clone(), + referrer_policy: metadata.referrer_policy.clone(), + document_referrer_policy: preload.document_referrer_policy.clone(), + charset: None, + integrity: metadata.integrity.clone(), + nonce: metadata.nonce.clone(), + fetch_priority: metadata.fetch_priority, + scheduler_priority: None, + }), + ResponsePreloadOptions::Style(options) => { + let options = options + .clone() + .with_document_referrer_policy(preload.document_referrer_policy.clone()); + crate::stylesheet_blocking::apply_stylesheet_request_parameters( + request.with_resource_type(RequestResourceType::CssStyleSheet), + &options, + ) + .with_fetch_priority_hint(moli_fetch::FetchPriorityHint::from_attribute( + options.fetch_priority(), + )) + } + }; + request.with_link_preload() } -fn start_script_preload( +fn start_resource_preload( scope: &mut v8::PinScope<'_, '_>, host: &mut PageScriptHost, target: WindowDocumentTaskTarget, - preload: &ResponseScriptPreload, + url: &Url, + options: ResponsePreloadOptions, ) -> Result<(), String> { let owner = target.dispatch_scope(); let resource_loader = host @@ -113,14 +146,48 @@ fn start_script_preload( ); let policy = host .document_connect_policy_snapshot_for_owner(owner) - .ok_or("preload policy owner is unavailable")? - .for_script_preload(preload.metadata.clone()); + .ok_or("preload policy owner is unavailable")?; + let (policy, request_mode, credentials_mode, resource_type, destination) = match &options { + ResponsePreloadOptions::Script(metadata) => { + let mode = if metadata.cross_origin.is_some() { + RequestMode::Cors + } else { + RequestMode::NoCors + }; + let credentials = if metadata + .cross_origin + .as_deref() + .is_some_and(|value| !value.eq_ignore_ascii_case("use-credentials")) + { + RequestCredentialsMode::SameOrigin + } else { + RequestCredentialsMode::Include + }; + ( + policy.for_script_preload(metadata.clone()), + mode, + credentials, + SubresourceResourceType::Script, + ServiceWorkerRequestDestination::Script, + ) + } + ResponsePreloadOptions::Style(options) => { + let (mode, credentials) = options.request_mode_and_credentials(); + ( + policy.for_style_preload(options.nonce().map(str::to_owned)), + mode, + credentials, + SubresourceResourceType::Stylesheet, + ServiceWorkerRequestDestination::Style, + ) + } + }; let report_context = capture_window_csp_report_request_context(scope, host, owner) .ok_or("preload reporting owner is unavailable")?; let (reports, enforced) = policy .check_url( &document_url, - &preload.url, + url, crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect, ) .into_violations(); @@ -135,29 +202,14 @@ fn start_script_preload( host.dispatch_document_connect_csp_violation_event_for_exact_owner_without_report_best_effort(scope, host_ptr, report_context.identity(), &violation); } if blocked { - host.record_document_resource_timing(scope, target, timing.failed(&preload.url)); - return Err("script preload blocked by Content Security Policy".into()); + host.record_document_resource_timing(scope, target, timing.failed(url)); + return Err("preload blocked by Content Security Policy".into()); } - let request_mode = if preload.metadata.cross_origin.is_some() { - RequestMode::Cors - } else { - RequestMode::NoCors - }; - let credentials_mode = if preload - .metadata - .cross_origin - .as_deref() - .is_some_and(|value| !value.eq_ignore_ascii_case("use-credentials")) - { - RequestCredentialsMode::SameOrigin - } else { - RequestCredentialsMode::Include - }; let network_partition_key = active_subresource_network_partition_key(host, owner); let policy_context = effective_subresource_policy_context(scope, host, owner); let client_id = host.service_worker_client_id_for_subresource_owner(owner); let mut pending = PendingResponsePreload { - metadata: preload.metadata.clone(), + options, document_referrer_policy: host.document_response_preload_referrer_policy(owner), redirect_state: FetchCspRedirectState::new(&policy), policy, @@ -166,7 +218,7 @@ fn start_script_preload( timing, }; let mut request = apply_response_preload_request_metadata( - Request::get_with_url(preload.url.clone()) + Request::get_with_url(url.clone()) .with_page_network_policy() .with_initiator_url(&document_url) .with_request_origin(request_origin.clone()), @@ -194,13 +246,13 @@ fn start_script_preload( network_request_handle: None, frame_id: frame_id.clone(), document_url: document_url.clone(), - url: preload.url.clone(), + url: url.clone(), websocket_socket_id: None, method: "GET".into(), request_headers: Default::default(), request_body: None, request_body_bytes: None, - resource_type: SubresourceResourceType::Script, + resource_type, request_cookie_report: None, }, ) @@ -214,11 +266,11 @@ fn start_script_preload( frame_id, request_origin, document_url: document_url.clone(), - resource_type: SubresourceResourceType::Script, + resource_type, policy_context, }; if host - .service_worker_controller_for_fetch(client_id, &document_url, &preload.url) + .service_worker_controller_for_fetch(client_id, &document_url, url) .is_some() { let dispatch = ServiceWorkerFetchDispatch { @@ -226,11 +278,11 @@ fn start_script_preload( internal_id, request: host.service_worker_fetch_request( client_id, - preload.url.clone(), + url.clone(), "GET".into(), Vec::new(), None, - ServiceWorkerRequestDestination::Script, + destination, request_mode, credentials_mode, RequestRedirectMode::Follow, @@ -253,7 +305,7 @@ fn start_script_preload( let _ = host.resource_completion_sender().send_async_subresource( AsyncSubresourceFetchCompletion { internal_id, - request_url: preload.url.clone(), + request_url: url.clone(), request_method: "GET".into(), request_headers: Default::default(), request_body: None, @@ -265,7 +317,7 @@ fn start_script_preload( }, ); } - } else if host.should_intercept_subresource(SubresourceResourceType::Script) { + } else if host.should_intercept_subresource(resource_type) { host.pause_pending_subresource_fetch(internal_id); } else { spawn_async_subresource_fetch( @@ -277,7 +329,7 @@ fn start_script_preload( Vec::new(), internal_id, network_context, - preload.url.clone(), + url.clone(), "GET".into(), Default::default(), None, diff --git a/moli-renderer-v8/src/response_links.rs b/moli-renderer-v8/src/response_links.rs index d2a91b12642..86d26138932 100644 --- a/moli-renderer-v8/src/response_links.rs +++ b/moli-renderer-v8/src/response_links.rs @@ -12,6 +12,7 @@ use crate::planning::ScriptFetchMetadata; pub(crate) struct DocumentResponseLinks { pub(crate) dictionaries: Vec, pub(crate) scripts: Vec, + pub(crate) styles: Vec, pub(crate) modules: Vec, } @@ -21,6 +22,34 @@ pub(crate) struct ResponseScriptPreload { pub(crate) metadata: ScriptFetchMetadata, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct ResponseStylePreload { + pub(crate) url: Url, + pub(crate) options: crate::stylesheet_blocking::StylesheetFetchOptions, +} + +#[derive(Debug, Clone)] +pub(crate) enum ResponsePreloadOptions { + Script(ScriptFetchMetadata), + Style(crate::stylesheet_blocking::StylesheetFetchOptions), +} + +impl ResponsePreloadOptions { + pub(crate) fn destination(&self) -> moli_web_mime::FetchDestination { + match self { + Self::Script(_) => moli_web_mime::FetchDestination::Script, + Self::Style(_) => moli_web_mime::FetchDestination::Style, + } + } + + pub(crate) fn integrity(&self) -> Option<&str> { + match self { + Self::Script(metadata) => metadata.integrity.as_deref(), + Self::Style(options) => options.integrity(), + } + } +} + #[derive(Debug, Clone, PartialEq, Eq)] pub(crate) struct ResponseModulepreload { pub(crate) url: Url, @@ -87,6 +116,31 @@ impl DocumentResponseLinks { result.scripts.push(preload); } } + if link.has_relation("preload") + && link + .parameter("as") + .is_some_and(|value| value.eq_ignore_ascii_case("style")) + && link.parameter("media").is_none_or(|value| { + crate::modulepreload::modulepreload_media_attribute_matches(Some(value)) + }) + && crate::link_as::LinkAsDestination::Style + .preload_type_matches(link.parameter("type")) + { + let preload = ResponseStylePreload { + url: url.clone(), + options: crate::stylesheet_blocking::StylesheetFetchOptions::from_link_attributes( + link.parameter("crossorigin"), + link.parameter("referrerpolicy"), + link.parameter("integrity"), + link.parameter("nonce"), + None, + link.parameter("fetchpriority"), + ), + }; + if !result.styles.contains(&preload) { + result.styles.push(preload); + } + } let destination = crate::modulepreload::modulepreload_as_state_from_attribute( link.parameter("as"), ); @@ -204,6 +258,45 @@ fn parse_link<'a>( mod tests { use super::*; + #[test] + fn response_stylesheet_preloads_use_canonical_stylesheet_options() { + let base = Url::parse("https://example.test/pages/document").unwrap(); + let field = br#"<../theme.css#fragment>;rel=preload;as=style;type="text/css; charset=utf-8";nonce=az;nonce=wrong;crossorigin=use-credentials;referrerpolicy=no-referrer;integrity="sha256-value";fetchpriority=high, <../theme.css#fragment>;rel=preload;as=style;type="text/css; charset=utf-8";nonce=az;crossorigin=use-credentials;referrerpolicy=no-referrer;integrity="sha256-value";fetchpriority=high"#; + let parsed = DocumentResponseLinks::parse(&base, &[("Link".into(), field.to_vec())]); + assert!(parsed.scripts.is_empty()); + assert!(parsed.modules.is_empty()); + assert_eq!(parsed.styles.len(), 1); + let preload = &parsed.styles[0]; + assert_eq!(preload.url, base.join("../theme.css#fragment").unwrap()); + assert_eq!(preload.options.nonce(), Some("az")); + assert_eq!(preload.options.integrity(), Some("sha256-value")); + assert_eq!(preload.options.referrer_policy(), Some("no-referrer")); + assert_eq!(preload.options.fetch_priority(), Some("high")); + assert_eq!( + preload.options.request_mode_and_credentials(), + ( + moli_fetch::RequestMode::Cors, + moli_fetch::RequestCredentialsMode::Include + ) + ); + } + + #[test] + fn response_stylesheet_preload_eligibility_precedes_fetch() { + let base = Url::parse("https://example.test/page").unwrap(); + let field = br#";rel=preload;as=style;anchor="/other", ;rel=preload;as=style;media="not all", ;rel=preload;as=style;type="text/plain", ;rel=alternate;rel=preload;as=style, ;rel=preload;as=style, ;rel=preload;;as=style;"#; + let parsed = DocumentResponseLinks::parse(&base, &[("Link".into(), field.to_vec())]); + assert_eq!(parsed.styles.len(), 1); + assert_eq!(parsed.styles[0].url, base.join("/style.css").unwrap()); + assert_eq!( + parsed.styles[0].options.request_mode_and_credentials(), + ( + moli_fetch::RequestMode::NoCors, + moli_fetch::RequestCredentialsMode::Include + ) + ); + } + #[test] fn response_links_ignore_empty_semicolon_parameter_segments() { let base = Url::parse("https://example.test/pages/document").unwrap(); diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/response_preloads.rs b/moli-renderer-v8/src/runtime/page_vm/tests/response_preloads.rs index 779e54f0e68..eb06fbd4c41 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/response_preloads.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/response_preloads.rs @@ -12,6 +12,158 @@ async fn request_head(stream: &mut tokio::net::TcpStream) -> anyhow::Result;rel=preload;as=style;nonce=az;referrerpolicy=no-referrer\r\nContent-Security-Policy: script-src 'nonce-az';style-src 'nonce-az'\r\n", r#""#) + } else { + assert!(request.to_ascii_lowercase().contains("sec-fetch-dest: style\r\n"), "{request}"); + assert!(!request.to_ascii_lowercase().contains("\r\nreferer:"), "{request}"); + ("text/css", "", "p { color: rgb(1, 2, 3); }") + }; + let response = format!("HTTP/1.1 200 OK\r\nContent-Type: {content_type}\r\nCache-Control: no-store\r\n{fields}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len()); + stream.write_all(response.as_bytes()).await?; + stream.shutdown().await?; + } + anyhow::Ok(()) + }); + let mut page_vm = test_page_vm_with_document_url(Url::parse(&format!("{base}/parent"))?); + let executor = page_vm.local_executor.clone(); + executor.run(async move { + page_vm.vm_mut().eval(r#" +addEventListener('message',event=>{globalThis.stylePreloadResult=event.data;}); +const child=document.createElement('iframe');child.src='/pages/child';document.body.appendChild(child); +"#)?; + drive_websocket_until_done(&mut page_vm,"String(globalThis.stylePreloadResult !== undefined)","response stylesheet preload consumption").await?; + let result = page_vm.vm_mut().eval("JSON.stringify(stylePreloadResult)")?; + assert_eq!(serde_json::from_str::(&result)?, json!({"before":{"links":0,"sheets":0},"links":1,"sheets":1,"color":"rgb(1, 2, 3)","timings":["link"]})); + assert_eq!(page_vm.vm_mut().eval("String(performance.getEntriesByType('resource').some(entry=>new URL(entry.name).pathname==='/asset.css'))")?, "false"); + server.await??; + anyhow::Ok(()) + }).await.expect("response stylesheet preloads retain their Document owner"); + anyhow::Ok(()) + }).await.expect("response stylesheet preload fixture"); +} + +async fn assert_controlled_response_stylesheet_preload(response_kind: &'static str) { + run_page_vm_async_test(async move { + let listener = TcpListener::bind("127.0.0.1:0").await?; + let base = format!("http://{}", listener.local_addr()?); + let css = "p { color: rgb(1, 2, 3); --label: 水🌍; }"; + let quoted_css = serde_json::to_string(css)?; + let response = match response_kind { + "fallback" => String::new(), + "stream" => format!(r#"event.respondWith(new Response(new ReadableStream({{start(controller) {{ + controller.enqueue(new TextEncoder().encode({quoted_css})); controller.close(); + }}}}), {{headers: {{'Content-Type': 'text/css'}}}}));"#), + _ => unreachable!(), + }; + let worker = format!(r#" +addEventListener('install', event => event.waitUntil(skipWaiting())); +addEventListener('activate', event => event.waitUntil(clients.claim())); +addEventListener('fetch', event => {{ + if (new URL(event.request.url).pathname !== '/asset.css') return; + event.waitUntil(fetch('/seen?destination=' + event.request.destination + '&policy=' + event.request.referrerPolicy)); + {response} +}}); +"#); + let server = tokio::spawn(async move { + for _ in 0..if response_kind == "fallback" { 4 } else { 3 } { + let (mut stream, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await??; + let request = request_head(&mut stream).await?; + let path = request.split_ascii_whitespace().nth(1).unwrap(); + let (kind, fields, body) = match path { + "/sw.js" => ("text/javascript", "", worker.as_str()), + "/controlled/child" => ("text/html", "Link: ;rel=preload;as=style;referrerpolicy=no-referrer\r\n", r#""#), + "/seen?destination=style&policy=no-referrer" => ("text/plain", "", "observed"), + "/asset.css" if response_kind == "fallback" => { + assert!(request.to_ascii_lowercase().contains("sec-fetch-dest: style\r\n"), "{request}"); + assert!(!request.to_ascii_lowercase().contains("\r\nreferer:"), "{request}"); + ("text/css", "", css) + } + _ => panic!("unexpected streamed stylesheet preload request: {request}"), + }; + let response = format!("HTTP/1.1 200 OK\r\nContent-Type: {kind}\r\nCache-Control: no-store\r\n{fields}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len()); + stream.write_all(response.as_bytes()).await?; + stream.shutdown().await?; + } + anyhow::Ok(()) + }); + let mut page_vm = test_page_vm_with_document_url(Url::parse(&format!("{base}/parent"))?); + let executor = page_vm.local_executor.clone(); + executor.run(async move { + page_vm.vm_mut().eval(r#" +addEventListener('message', event => {globalThis.streamedStylePreloadResult = event.data;}); +(async () => { + const registration = await navigator.serviceWorker.register('/sw.js', {scope:'/controlled/'}); + const worker = registration.installing || registration.waiting || registration.active; + if (worker.state !== 'activated') await new Promise(resolve => worker.addEventListener('statechange', () => {if (worker.state === 'activated') resolve();})); + const child = document.createElement('iframe');child.src = '/controlled/child';document.body.appendChild(child); +})().catch(error => {globalThis.streamedStylePreloadResult = {error:String(error)};}); +"#)?; + drive_page_work_until_done_with_explicit_producer_admission( + &mut page_vm, + "String(globalThis.streamedStylePreloadResult !== undefined)", + "controlled response stylesheet preload consumption", + |page_vm| { + page_vm.runtime_hooks.browser_context_runtime.drain_service_worker_service_lane(); + }, + ).await?; + let result = page_vm.vm_mut().eval("JSON.stringify(streamedStylePreloadResult)")?; + assert_eq!(serde_json::from_str::(&result)?, json!({"before":{"links":0,"sheets":0},"controlled":true,"color":"rgb(1, 2, 3)","label":"水🌍","timings":["link"]})); + server.await??; + anyhow::Ok(()) + }).await.expect("streamed stylesheet preloads preserve their body and ownership"); + anyhow::Ok(()) + }).await.expect("streamed stylesheet preload fixture"); +} + +#[tokio::test] +async fn response_stylesheet_preload_preserves_streamed_service_worker_text() { + assert_controlled_response_stylesheet_preload("stream").await; +} + +#[tokio::test] +async fn response_stylesheet_preload_preserves_service_worker_network_fallback() { + assert_controlled_response_stylesheet_preload("fallback").await; +} + #[tokio::test] async fn response_script_preload_is_consumed_once_in_its_child_document() { run_page_vm_async_test(async move { diff --git a/moli-renderer-v8/src/script_vm/response_links.rs b/moli-renderer-v8/src/script_vm/response_links.rs index c33f19a3d51..065fbaa911d 100644 --- a/moli-renderer-v8/src/script_vm/response_links.rs +++ b/moli-renderer-v8/src/script_vm/response_links.rs @@ -5,7 +5,11 @@ impl ScriptVm { &mut self, links: &crate::response_links::DocumentResponseLinks, ) -> Result<()> { - if links.dictionaries.is_empty() && links.scripts.is_empty() && links.modules.is_empty() { + if links.dictionaries.is_empty() + && links.scripts.is_empty() + && links.styles.is_empty() + && links.modules.is_empty() + { return Ok(()); } let owner = self.current_main_document_task_owner(); diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/response_preload.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/response_preload.rs index 050b24a4c07..63fed11bc03 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/response_preload.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/response_preload.rs @@ -29,13 +29,12 @@ impl ScriptVm { pending.credentials_mode, ) }); - let entry = if pending.request_mode == moli_fetch::RequestMode::NoCors { - preload.timing.classic_script_response( - &pending.info.url, - &pending.request_origin, - &response.head(), - response.body_bytes().len(), - ) + let blocked_by_nosniff = moli_web_mime::should_response_be_blocked_due_to_nosniff( + &response.headers, + preload.options.destination(), + ); + let entry = if blocked_by_nosniff { + preload.timing.failed(&pending.info.url) } else { preload.timing.completed( &pending.info.url, @@ -46,10 +45,11 @@ impl ScriptVm { Some(&filter), ) }; - let response = - if crate::subresource_integrity::response_matches_subresource_integrity_metadata( + let response = if blocked_by_nosniff { + Err("preload response blocked by X-Content-Type-Options nosniff".to_owned()) + } else if crate::subresource_integrity::response_matches_subresource_integrity_metadata( response.body_bytes(), - preload.metadata.integrity.as_deref(), + preload.options.integrity(), filter.is_readable(), ) { Ok(crate::network::preloads::DocumentPreloadResponse { @@ -60,7 +60,7 @@ impl ScriptVm { .then(|| response.final_url.clone()), }) } else { - Err("script preload failed its integrity check".to_owned()) + Err("preload failed its integrity check".to_owned()) }; (entry, response) } diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs index a9826751578..b11801ac536 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs @@ -1609,10 +1609,9 @@ impl ScriptVm { response_body .try_bytes() .map(|bytes| { - crate::protocol_types::NavigationResponse::from_head_and_body( + crate::protocol_types::NavigationResponse::from_head_and_materialized_body( streaming.head.clone(), - String::new(), - bytes.to_vec(), + moli_fetch::ResponseBody::lossy_text_from_bytes(bytes.to_vec()), ) }) .map_err(|error| error.to_string()) diff --git a/moli-renderer-v8/src/stylesheet_blocking.rs b/moli-renderer-v8/src/stylesheet_blocking.rs index 69f1c6acef9..6b2bc20b6fa 100644 --- a/moli-renderer-v8/src/stylesheet_blocking.rs +++ b/moli-renderer-v8/src/stylesheet_blocking.rs @@ -638,7 +638,7 @@ impl StylesheetResponseProvenance { moli_fetch::RequestRedirectMode::Follow, web_security_disabled, ) - .is_none(), + .is_none_or(|filter| filter.is_readable()), Self::ServiceWorker { filter } => { filter.as_ref().is_none_or(|filter| filter.is_readable()) } @@ -1094,6 +1094,35 @@ mod tests { } } + #[test] + fn consumed_stylesheet_preloads_retain_their_response_readability() { + use moli_fetch::{FetchResponseType, PreloadResponseFilter, ResponsePreloadState}; + + let url = Url::parse("https://page.example.test/app.css").unwrap(); + let origin = moli_url::WebOrigin::from_url(&url); + for (filter, readable) in [ + (FetchResponseType::Basic, true), + (FetchResponseType::Cors, true), + (FetchResponseType::Opaque, false), + (FetchResponseType::OpaqueRedirect, false), + ] { + let mut response = stylesheet_response(&url, Some("text/css"), "p { color: green; }"); + response.preload_state = ResponsePreloadState::Consumed { + filter: Some(PreloadResponseFilter::Network(filter)), + from_service_worker: false, + }; + let terminal = stylesheet_terminal_from_response( + &origin, + &url, + &StylesheetFetchOptions::default(), + response, + StylesheetResponseProvenance::Network, + ); + assert!(terminal.is_ready(), "{filter:?}"); + assert_eq!(terminal.origin_clean(), Some(readable), "{filter:?}"); + } + } + #[test] fn stylesheet_integrity_checks_service_worker_response_filter() { let document_url = Url::parse("https://page.example.test/").unwrap(); diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs index ce6d41b5277..b1e53d36ebc 100644 --- a/moli-renderer-v8/src/types.rs +++ b/moli-renderer-v8/src/types.rs @@ -157,7 +157,7 @@ pub(super) struct PendingDictionaryFetch { } pub(super) struct PendingResponsePreload { - pub(super) metadata: crate::planning::ScriptFetchMetadata, + pub(super) options: crate::response_links::ResponsePreloadOptions, pub(super) document_referrer_policy: Option, pub(super) policy: crate::document_runtime::DocumentRequestPolicySnapshot, pub(super) redirect_state: crate::network_host::FetchCspRedirectState,