From 68bc3ebd0cf9384cc8d7c449de74667d3e1bcfbd Mon Sep 17 00:00:00 2001 From: ldm0 Date: Mon, 19 Oct 2026 00:14:03 +0800 Subject: [PATCH] feat(modules): preload modules from Document response Link headers --- moli-core/tests/scripts.rs | 2 +- .../content_security_policy/module_fetch.rs | 72 ++-- .../document_module_graph/fetch_metadata.rs | 1 + .../src/document_runtime/security_policy.rs | 64 +++- moli-renderer-v8/src/frame_owner_model.rs | 1 + .../src/frame_owner_model/module_clients.rs | 123 +++++-- .../module_graph/modulepreload.rs | 60 ++-- .../module_graph/tests/document_modulator.rs | 132 +++++++- moli-renderer-v8/src/module_runtime.rs | 2 + .../src/module_runtime/fetch_context.rs | 256 ++++++++++++++ moli-renderer-v8/src/module_runtime/graph.rs | 134 ++++++-- moli-renderer-v8/src/modulepreload.rs | 18 +- .../child_frames/module_scripts.rs | 64 +++- .../src/network/loads/registry.rs | 51 +++ moli-renderer-v8/src/network_host/preload.rs | 29 ++ .../main_modulepreload.rs | 16 + .../src/renderer_resource_scheduler.rs | 60 +++- moli-renderer-v8/src/response_links.rs | 150 ++++++++- .../service_workers.rs | 31 +- .../page_resource_completion/child_module.rs | 25 ++ .../page_resource_completion/main_module.rs | 7 + .../tests/main_modulepreload_completion.rs | 6 +- .../page_vm/tests/response_preloads.rs | 316 ++++++++++++++++++ .../src/script_vm/child_module_fetch.rs | 34 +- .../src/script_vm/native_module.rs | 1 + .../native_module/document_scripts.rs | 27 +- .../script_vm/native_module/fetch_context.rs | 41 +++ .../script_vm/native_module/module_fetch.rs | 34 +- .../src/script_vm/response_links.rs | 40 ++- .../subresource_fetch/document_completion.rs | 25 ++ moli-renderer-v8/src/types.rs | 16 + 31 files changed, 1643 insertions(+), 195 deletions(-) create mode 100644 moli-renderer-v8/src/module_runtime/fetch_context.rs create mode 100644 moli-renderer-v8/src/script_vm/native_module/fetch_context.rs diff --git a/moli-core/tests/scripts.rs b/moli-core/tests/scripts.rs index 1aaa11a0b9b..e53c0b4531e 100644 --- a/moli-core/tests/scripts.rs +++ b/moli-core/tests/scripts.rs @@ -5278,7 +5278,7 @@ async fn module_source_phase_wasm_import_reuses_modulepreload_resource() -> Resu ); assert_eq!( diagnostic_global(&page, "moduleSourcePhasePreloadInitiator"), - Some(&JsValueSnapshot::String("link".to_owned())) + Some(&JsValueSnapshot::String("script".to_owned())) ); assert_eq!( diagnostic_global(&page, "moduleSourcePhasePreloadImportIsModule"), diff --git a/moli-renderer-v8/src/content_security_policy/module_fetch.rs b/moli-renderer-v8/src/content_security_policy/module_fetch.rs index 7a6766d23a9..541b5c54237 100644 --- a/moli-renderer-v8/src/content_security_policy/module_fetch.rs +++ b/moli-renderer-v8/src/content_security_policy/module_fetch.rs @@ -10,8 +10,8 @@ type Check = dyn Fn( &Url, ContentSecurityPolicyRedirectStatus, ) -> ( - Option, - Option, + Vec, + Vec, ) + Send + Sync; @@ -49,22 +49,26 @@ impl PartialEq for ModuleFetchCspContext { impl Eq for ModuleFetchCspContext {} impl ModuleFetchCspContext { - pub(crate) fn new( + pub(crate) fn new( original_url: Url, owner_scope: Option, - check: impl Fn( - &Url, - &Url, - ContentSecurityPolicyRedirectStatus, - ) -> ( - Option, - Option, - ) + Send + check: impl Fn(&Url, &Url, ContentSecurityPolicyRedirectStatus) -> (R, E) + + Send + Sync + 'static, - ) -> Self { + ) -> Self + where + R: IntoIterator, + E: IntoIterator, + { Self(Arc::new(Inner { - check: Box::new(check), + check: Box::new(move |url, original, status| { + let (reports, enforced) = check(url, original, status); + ( + reports.into_iter().collect(), + enforced.into_iter().collect(), + ) + }), original_url, owner_scope, state: Mutex::new(State::default()), @@ -102,38 +106,38 @@ impl ModuleFetchCspContext { ContentSecurityPolicyRedirectStatus::FollowedRedirect }, ); + let message = enforce.first().map(|violation| { + format!( + "Module request blocked by Content Security Policy directive `{}`", + violation.effective_directive + ) + }); let mut state = self.0.state.lock(); - if state + if !state .checked_hops .iter() - .any(|(checked_ordinal, checked_url)| *checked_ordinal == ordinal && checked_url == url) + .any(|(n, checked)| *n == ordinal && checked == url) { - if let Some(enforce) = enforce { - anyhow::bail!( - "Module request blocked by Content Security Policy directive `{}`", - enforce.effective_directive - ); - } - return Ok(()); + state.checked_hops.push((ordinal, url.clone())); + state.violations.extend(report); + state.violations.extend(enforce); } - state.checked_hops.push((ordinal, url.clone())); - if let Some(report) = report { - state.violations.push(report); + match message { + Some(message) => anyhow::bail!(message), + None => Ok(()), } - if let Some(enforce) = enforce { - let message = format!( - "Module request blocked by Content Security Policy directive `{}`", - enforce.effective_directive - ); - state.violations.push(enforce); - anyhow::bail!(message); - } - Ok(()) } // Coalesced/cache consumers still validate every recorded redirect against // their own policy. The transport owner's checks are not another owner's authority. pub(crate) fn check_response(&self, response: &moli_fetch::Response) -> anyhow::Result<()> { + self.check_response_head(&response.head()) + } + + pub(crate) fn check_response_head( + &self, + response: &moli_fetch::ResponseHead, + ) -> anyhow::Result<()> { for (index, redirect) in response.redirect_chain.iter().enumerate() { self.check_hop(&redirect.to_url, index + 1)?; } diff --git a/moli-renderer-v8/src/document_module_graph/fetch_metadata.rs b/moli-renderer-v8/src/document_module_graph/fetch_metadata.rs index 57c481ff61a..03b9dcc9d38 100644 --- a/moli-renderer-v8/src/document_module_graph/fetch_metadata.rs +++ b/moli-renderer-v8/src/document_module_graph/fetch_metadata.rs @@ -31,6 +31,7 @@ impl ModuleFetchMetadata { pub(crate) fn from_modulepreload_script_fetch_metadata(metadata: &ScriptFetchMetadata) -> Self { let mut mapped = Self::from_script_fetch_metadata_inner(metadata); mapped.request_metadata.integrity = metadata.integrity.clone(); + mapped.request_metadata.nonce = metadata.nonce.clone(); mapped.request_metadata.fetch_priority = None; mapped } diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rs index 75d9833c2c7..f67b04e2726 100644 --- a/moli-renderer-v8/src/document_runtime/security_policy.rs +++ b/moli-renderer-v8/src/document_runtime/security_policy.rs @@ -81,10 +81,16 @@ pub(crate) enum DocumentNavigationEmbeddingContext<'a> { Nested(&'a [Option]), } +#[derive(Debug, Clone)] +enum DocumentPreloadPolicyMetadata { + Script(crate::planning::ScriptFetchMetadata), + Style(Option), +} + #[derive(Debug, Clone)] pub(crate) struct DocumentRequestPolicySnapshot { resource_kind: ContentSecurityPolicyResourceKind, - script_metadata: Option>, + preload_metadata: Option>, policy_self_url: Option>, enforce_policies: Vec, report_only_policies: Vec, @@ -138,7 +144,13 @@ impl DocumentRequestPolicySnapshot { metadata: crate::planning::ScriptFetchMetadata, ) -> Self { self.resource_kind = ContentSecurityPolicyResourceKind::DocumentScriptElement; - self.script_metadata = Some(Box::new(metadata)); + self.preload_metadata = Some(Box::new(DocumentPreloadPolicyMetadata::Script(metadata))); + self + } + + pub(crate) fn for_style_preload(mut self, nonce: Option) -> Self { + self.resource_kind = ContentSecurityPolicyResourceKind::DocumentStyleElement; + self.preload_metadata = Some(Box::new(DocumentPreloadPolicyMetadata::Style(nonce))); self } @@ -154,7 +166,7 @@ impl DocumentRequestPolicySnapshot { ) -> Self { Self { resource_kind: ContentSecurityPolicyResourceKind::DocumentConnect, - script_metadata: None, + preload_metadata: None, policy_self_url: None, enforce_policies: document_response_content_security_policies( &enforce_policies, @@ -209,7 +221,45 @@ impl DocumentRequestPolicySnapshot { redirect_status: ContentSecurityPolicyRedirectStatus, ) -> DocumentContentSecurityPolicyCheck { let policy_url = self.policy_self_url.as_deref().unwrap_or(document_url); - if let Some(metadata) = self.script_metadata.as_ref() { + if let Some(DocumentPreloadPolicyMetadata::Style(nonce)) = self.preload_metadata.as_deref() + { + let check = |policies: Vec, disposition| { + let mut violations = + document_style_element_url_policy_violations_from_document_policies( + policies, + policy_url, + request_url, + redirect_status, + disposition, + ContentSecurityPolicyStyleElementRequest { + nonce: nonce.as_deref(), + }, + ); + for violation in &mut violations { + violation.document_uri = + crate::content_security_policy::csp_url_for_report(document_url); + violation.source_file = + crate::content_security_policy::csp_url_for_report(document_url); + } + violations + }; + return DocumentContentSecurityPolicyCheck { + enforced_violations: check( + self.enforce_policies.clone(), + ContentSecurityPolicyDisposition::Enforce, + ), + report_only_violations: check( + document_response_content_security_policy_strings( + &self.report_only_policies, + &self.reporting_endpoints, + ), + ContentSecurityPolicyDisposition::Report, + ), + }; + } + if let Some(DocumentPreloadPolicyMetadata::Script(metadata)) = + self.preload_metadata.as_deref() + { let request = ContentSecurityPolicyScriptElementRequest { nonce: metadata.nonce.as_deref(), integrity: metadata.integrity.as_deref(), @@ -302,7 +352,7 @@ impl DocumentRequestPolicySnapshot { request_url: &Url, redirect_status: ContentSecurityPolicyRedirectStatus, ) -> Option { - if self.script_metadata.is_some() { + if self.preload_metadata.is_some() { return self .check_url(document_url, request_url, redirect_status) .enforced_violations @@ -333,7 +383,7 @@ impl DocumentRequestPolicySnapshot { request_url: &Url, redirect_status: ContentSecurityPolicyRedirectStatus, ) -> Option { - if self.script_metadata.is_some() { + if self.preload_metadata.is_some() { return self .check_url(document_url, request_url, redirect_status) .report_only_violations @@ -1433,7 +1483,7 @@ impl DocumentRuntime { } DocumentConnectPolicySnapshot { resource_kind: ContentSecurityPolicyResourceKind::DocumentConnect, - script_metadata: None, + preload_metadata: None, policy_self_url: policy .content_security_policy_self_url .clone() diff --git a/moli-renderer-v8/src/frame_owner_model.rs b/moli-renderer-v8/src/frame_owner_model.rs index 4389df3d7e5..305b244bb0a 100644 --- a/moli-renderer-v8/src/frame_owner_model.rs +++ b/moli-renderer-v8/src/frame_owner_model.rs @@ -109,6 +109,7 @@ pub(crate) use module_clients::FrameDocumentModulepreloadEventActionRunner; pub(crate) use module_clients::FrameDocumentModulepreloadFetchTask; pub(crate) use module_clients::FrameDocumentModulepreloadLinkClient; pub(crate) use module_clients::FrameDocumentModulepreloadMaterializedWork; +pub(crate) use module_clients::FrameDocumentModulepreloadSource; pub(crate) use module_clients::FrameDocumentModulepreloadTerminalOutcome; pub(crate) use module_clients::FrameDocumentModulepreloadTerminalWork; pub(crate) use module_clients::FrameDocumentModulepreloadWorkAwaitingRealm; diff --git a/moli-renderer-v8/src/frame_owner_model/module_clients.rs b/moli-renderer-v8/src/frame_owner_model/module_clients.rs index 6a293b19df7..7340c826d53 100644 --- a/moli-renderer-v8/src/frame_owner_model/module_clients.rs +++ b/moli-renderer-v8/src/frame_owner_model/module_clients.rs @@ -576,10 +576,48 @@ impl FrameDocumentModuleDependencyTerminalWork { #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct FrameDocumentModulepreloadFetchPayload { - client: FrameDocumentModulepreloadLinkClient, + source: FrameDocumentModulepreloadSource, request: NativeModuleSingleFetchRequest, } +/// The request belongs to the Document even when no element receives events. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum FrameDocumentModulepreloadSource { + Link(FrameDocumentModulepreloadLinkClient), + ResponseHeader { + child_handle: DomHandle, + owner: FrameDocumentTaskOwner, + }, +} + +impl FrameDocumentModulepreloadSource { + pub(crate) fn owner(self) -> FrameDocumentTaskOwner { + match self { + Self::Link(client) => client.owner(), + Self::ResponseHeader { owner, .. } => owner, + } + } + + pub(crate) fn child_handle(self) -> DomHandle { + match self { + Self::Link(client) => client.child_handle(), + Self::ResponseHeader { child_handle, .. } => child_handle, + } + } + + pub(crate) fn link_client(self) -> Option { + match self { + Self::Link(client) => Some(client), + Self::ResponseHeader { .. } => None, + } + } + + pub(crate) fn link_handle(self) -> Option { + self.link_client() + .map(FrameDocumentModulepreloadLinkClient::link_handle) + } +} + /// Modulepreload work discovered before its child default realm is ready. /// /// The parser can establish the exact Document owner before any V8 realm has @@ -589,14 +627,16 @@ pub(crate) struct FrameDocumentModulepreloadFetchPayload { #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct FrameDocumentModulepreloadWorkAwaitingRealm { expected_realm_id: Option, - client: FrameDocumentModulepreloadLinkClient, kind: FrameDocumentModulepreloadWorkAwaitingRealmKind, } #[derive(Clone, Debug, PartialEq, Eq)] enum FrameDocumentModulepreloadWorkAwaitingRealmKind { - FetchStart(Box), - LinkError, + FetchStart { + source: FrameDocumentModulepreloadSource, + request: Box, + }, + LinkError(FrameDocumentModulepreloadLinkClient), } #[derive(Clone, Debug, PartialEq, Eq)] @@ -608,13 +648,15 @@ pub(crate) enum FrameDocumentModulepreloadMaterializedWork { impl FrameDocumentModulepreloadWorkAwaitingRealm { pub(crate) fn fetch_start( expected_realm_id: Option, - client: FrameDocumentModulepreloadLinkClient, + source: FrameDocumentModulepreloadSource, request: NativeModuleSingleFetchRequest, ) -> Self { Self { expected_realm_id, - client, - kind: FrameDocumentModulepreloadWorkAwaitingRealmKind::FetchStart(Box::new(request)), + kind: FrameDocumentModulepreloadWorkAwaitingRealmKind::FetchStart { + source, + request: Box::new(request), + }, } } @@ -624,13 +666,21 @@ impl FrameDocumentModulepreloadWorkAwaitingRealm { ) -> Self { Self { expected_realm_id, - client, - kind: FrameDocumentModulepreloadWorkAwaitingRealmKind::LinkError, + kind: FrameDocumentModulepreloadWorkAwaitingRealmKind::LinkError(client), + } + } + + fn source(&self) -> FrameDocumentModulepreloadSource { + match &self.kind { + FrameDocumentModulepreloadWorkAwaitingRealmKind::FetchStart { source, .. } => *source, + FrameDocumentModulepreloadWorkAwaitingRealmKind::LinkError(client) => { + FrameDocumentModulepreloadSource::Link(*client) + } } } pub(crate) fn owner(&self) -> FrameDocumentTaskOwner { - self.client.owner() + self.source().owner() } pub(crate) fn expected_realm_id(&self) -> Option { @@ -644,19 +694,19 @@ impl FrameDocumentModulepreloadWorkAwaitingRealm { } pub(crate) fn child_handle(&self) -> DomHandle { - self.client.child_handle() + self.source().child_handle() } - pub(crate) fn link_handle(&self) -> DomHandle { - self.client.link_handle() + pub(crate) fn link_handle(&self) -> Option { + self.source().link_handle() } pub(crate) fn request(&self) -> Option<&NativeModuleSingleFetchRequest> { match &self.kind { - FrameDocumentModulepreloadWorkAwaitingRealmKind::FetchStart(request) => { + FrameDocumentModulepreloadWorkAwaitingRealmKind::FetchStart { request, .. } => { Some(request.as_ref()) } - FrameDocumentModulepreloadWorkAwaitingRealmKind::LinkError => None, + FrameDocumentModulepreloadWorkAwaitingRealmKind::LinkError(_) => None, } } @@ -671,21 +721,16 @@ impl FrameDocumentModulepreloadWorkAwaitingRealm { return None; } Some(match self.kind { - FrameDocumentModulepreloadWorkAwaitingRealmKind::FetchStart(request) => { + FrameDocumentModulepreloadWorkAwaitingRealmKind::FetchStart { source, request } => { FrameDocumentModulepreloadMaterializedWork::FetchStart(Box::new( - FrameDocumentModulepreloadFetchTask::from_modulepreload_fetch_parts( - realm_id, - self.client, - *request, + FrameDocumentModulepreloadFetchTask::from_source_parts( + realm_id, source, *request, ), )) } - FrameDocumentModulepreloadWorkAwaitingRealmKind::LinkError => { + FrameDocumentModulepreloadWorkAwaitingRealmKind::LinkError(client) => { FrameDocumentModulepreloadMaterializedWork::LinkError( - FrameDocumentModulepreloadTerminalWork::from_link_error_parts( - realm_id, - self.client, - ), + FrameDocumentModulepreloadTerminalWork::from_link_error_parts(realm_id, client), ) } }) @@ -1200,27 +1245,39 @@ impl FrameDocumentModulepreloadFetchTask { client: FrameDocumentModulepreloadLinkClient, request: NativeModuleSingleFetchRequest, ) -> Self { - Self::new( - client.owner(), + Self::from_source_parts( realm_id, - FrameDocumentModulepreloadFetchPayload { client, request }, + FrameDocumentModulepreloadSource::Link(client), + request, ) } - pub(crate) fn link_handle(&self) -> DomHandle { - self.payload().client.link_handle() + pub(crate) fn from_source_parts( + realm_id: FrameRealmId, + source: FrameDocumentModulepreloadSource, + request: NativeModuleSingleFetchRequest, + ) -> Self { + Self::new( + source.owner(), + realm_id, + FrameDocumentModulepreloadFetchPayload { source, request }, + ) + } + + pub(crate) fn link_handle(&self) -> Option { + self.payload().source.link_handle() } pub(crate) fn target(&self) -> ChildDocumentModuleFetchTarget { ChildDocumentModuleFetchTarget::new( - self.payload().client.child_handle(), + self.payload().source.child_handle(), self.owner(), self.realm_id(), ) } - pub(crate) fn client(&self) -> FrameDocumentModulepreloadLinkClient { - self.payload().client + pub(crate) fn client(&self) -> Option { + self.payload().source.link_client() } pub(crate) fn request(&self) -> &NativeModuleSingleFetchRequest { diff --git a/moli-renderer-v8/src/frame_owner_model/module_graph/modulepreload.rs b/moli-renderer-v8/src/frame_owner_model/module_graph/modulepreload.rs index 1a5e0a4bbbf..45f07758dc1 100644 --- a/moli-renderer-v8/src/frame_owner_model/module_graph/modulepreload.rs +++ b/moli-renderer-v8/src/frame_owner_model/module_graph/modulepreload.rs @@ -17,7 +17,7 @@ use super::ChildDocumentModulatorStore; pub(crate) enum FrameDocumentModulepreloadStartAction { ScheduleFetch { target: ChildDocumentModuleFetchTarget, - link_handle: DomHandle, + link_handle: Option, key: ModuleMapKey, load_id: u64, request: Box, @@ -25,19 +25,19 @@ pub(crate) enum FrameDocumentModulepreloadStartAction { JoinedFetching { owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: ModuleMapKey, }, JoinedTerminalSuccess { owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: ModuleMapKey, }, JoinedTerminalFailure { owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: ModuleMapKey, }, } @@ -52,7 +52,7 @@ pub(crate) trait FrameDocumentModulepreloadStartActionHooks { fn schedule_modulepreload_fetch( &mut self, target: ChildDocumentModuleFetchTarget, - link_handle: DomHandle, + link_handle: Option, key: ModuleMapKey, load_id: u64, request: Box, @@ -62,7 +62,7 @@ pub(crate) trait FrameDocumentModulepreloadStartActionHooks { &mut self, owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: &ModuleMapKey, ); @@ -70,7 +70,7 @@ pub(crate) trait FrameDocumentModulepreloadStartActionHooks { &mut self, owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: &ModuleMapKey, ); @@ -78,7 +78,7 @@ pub(crate) trait FrameDocumentModulepreloadStartActionHooks { &mut self, owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: &ModuleMapKey, ); } @@ -436,11 +436,13 @@ impl ChildDocumentModulatorStore { let target = task.target(); let link_handle = task.link_handle(); let key = task.request().module_key().clone(); - let link_client = NativeModulepreloadLinkClient::new_for_frame_document( - link_handle, - key.clone(), - task.client(), - ); + let link_client = task.client().map(|client| { + NativeModulepreloadLinkClient::new_for_frame_document( + client.link_handle(), + key.clone(), + client, + ) + }); let document_modulator_entry = self.document_modulator_entry_mut(owner, realm_id); let disposition = document_modulator_entry .document_modulator @@ -450,9 +452,11 @@ impl ChildDocumentModulatorStore { let (load_id, fetch_request) = document_modulator_entry .document_modulator .reserve_modulepreload_fetch(task.into_request()); - document_modulator_entry - .document_modulator - .add_modulepreload_link_client(key.clone(), link_client); + if let Some(link_client) = link_client { + document_modulator_entry + .document_modulator + .add_modulepreload_link_client(key.clone(), link_client); + } FrameDocumentModulepreloadStartAction::ScheduleFetch { target, link_handle, @@ -462,9 +466,11 @@ impl ChildDocumentModulatorStore { } } ModuleMapFetchDisposition::JoinedFetching(_entry_id) => { - document_modulator_entry - .document_modulator - .add_modulepreload_link_client(key.clone(), link_client); + if let Some(link_client) = link_client { + document_modulator_entry + .document_modulator + .add_modulepreload_link_client(key.clone(), link_client); + } FrameDocumentModulepreloadStartAction::JoinedFetching { owner, realm_id, @@ -474,9 +480,11 @@ impl ChildDocumentModulatorStore { } ModuleMapFetchDisposition::AlreadyFetched(_) | ModuleMapFetchDisposition::AlreadyCompiled(_) => { - document_modulator_entry - .document_modulator - .add_terminal_modulepreload_link_client(key.clone(), link_client); + if let Some(link_client) = link_client { + document_modulator_entry + .document_modulator + .add_terminal_modulepreload_link_client(key.clone(), link_client); + } FrameDocumentModulepreloadStartAction::JoinedTerminalSuccess { owner, realm_id, @@ -485,9 +493,11 @@ impl ChildDocumentModulatorStore { } } ModuleMapFetchDisposition::AlreadyFailed(_) => { - document_modulator_entry - .document_modulator - .add_terminal_modulepreload_link_client(key.clone(), link_client); + if let Some(link_client) = link_client { + document_modulator_entry + .document_modulator + .add_terminal_modulepreload_link_client(key.clone(), link_client); + } FrameDocumentModulepreloadStartAction::JoinedTerminalFailure { owner, realm_id, diff --git a/moli-renderer-v8/src/frame_owner_model/module_graph/tests/document_modulator.rs b/moli-renderer-v8/src/frame_owner_model/module_graph/tests/document_modulator.rs index c017163709e..4fbc0b03803 100644 --- a/moli-renderer-v8/src/frame_owner_model/module_graph/tests/document_modulator.rs +++ b/moli-renderer-v8/src/frame_owner_model/module_graph/tests/document_modulator.rs @@ -1,6 +1,122 @@ use super::*; use crate::frame_owner_model::FrameDocumentModuleScriptTerminalTask; +#[test] +fn response_modulepreload_joins_the_module_map_without_manufacturing_link_events() { + use crate::frame_owner_model::FrameDocumentModulepreloadSource; + let mut store = ChildDocumentModulatorStore::default(); + let owner = + FrameDocumentTaskOwner::new(FrameSchedulerLaneId(1), LocalWindowId(2), DocumentId(3)); + let realm_id = FrameRealmId(4); + let request = modulepreload_request("header-entry.mjs"); + let source = FrameDocumentModulepreloadSource::ResponseHeader { + child_handle: DomHandle::new(1), + owner, + }; + let task = + FrameDocumentModulepreloadFetchTask::from_source_parts(realm_id, source, request.clone()); + let duplicate = task.clone(); + let FrameDocumentModulepreloadStartAction::ScheduleFetch { + target, + link_handle, + load_id, + .. + } = store.start_modulepreload_fetch_task(task) + else { + panic!("header modulepreload must reserve its own Document module entry"); + }; + assert_eq!(target.task_owner(), owner); + assert_eq!(target.realm_id(), realm_id); + assert_eq!(target.child_handle(), DomHandle::new(1)); + assert!(link_handle.is_none()); + assert!(matches!( + store.start_modulepreload_fetch_task(duplicate.clone()), + FrameDocumentModulepreloadStartAction::JoinedFetching { + link_handle: None, + .. + } + )); + let link_handle = DomHandle::new(77); + let link = FrameDocumentModulepreloadFetchTask::from_modulepreload_fetch_parts( + realm_id, + modulepreload_link_client(owner, link_handle), + request.clone(), + ); + assert!( + matches!(store.start_modulepreload_fetch_task(link), FrameDocumentModulepreloadStartAction::JoinedFetching { link_handle: Some(actual), .. } if actual == link_handle) + ); + let inflight = store + .take_modulepreload_graph_fetch(owner.document_owner(), realm_id, load_id) + .unwrap(); + let batch = store + .finish_modulepreload_fetch( + owner, + realm_id, + inflight, + Ok(ModuleGraphFetchedSource::new( + request.source_url().clone(), + ModuleSource::text("export const value = 1;"), + )), + ) + .unwrap(); + let events = batch.into_modulepreload_terminal_works(); + assert_eq!(events.len(), 1); + assert_eq!(events[0].link_handle(), link_handle); + assert!(events[0].successful()); + assert!(matches!( + store.start_modulepreload_fetch_task(duplicate), + FrameDocumentModulepreloadStartAction::JoinedTerminalSuccess { + link_handle: None, + .. + } + )); + assert!( + store + .take_ready_document_modulator_terminal_batches(owner, realm_id) + .is_empty() + ); +} + +#[test] +fn response_modulepreload_awaiting_a_realm_retains_exact_document_and_realm_guards() { + use crate::frame_owner_model::{ + FrameDocumentModulepreloadMaterializedWork, FrameDocumentModulepreloadSource, + FrameDocumentModulepreloadWorkAwaitingRealm, + }; + let owner = + FrameDocumentTaskOwner::new(FrameSchedulerLaneId(1), LocalWindowId(2), DocumentId(3)); + let realm_id = FrameRealmId(4); + let source = FrameDocumentModulepreloadSource::ResponseHeader { + child_handle: DomHandle::new(1), + owner, + }; + let mut work = FrameDocumentModulepreloadWorkAwaitingRealm::fetch_start( + None, + source, + modulepreload_request("header-pending.mjs"), + ); + assert_eq!(work.owner(), owner); + assert_eq!(work.child_handle(), DomHandle::new(1)); + assert!(work.link_handle().is_none()); + work.bind_first_established_realm(realm_id); + work.bind_first_established_realm(FrameRealmId(5)); + assert!( + work.clone() + .into_materialized_work(FrameRealmId(5)) + .is_none() + ); + let FrameDocumentModulepreloadMaterializedWork::FetchStart(task) = + work.into_materialized_work(realm_id).unwrap() + else { + panic!("header hint cannot manufacture a link error event"); + }; + assert_eq!( + task.target(), + ChildDocumentModuleFetchTarget::new(DomHandle::new(1), owner, realm_id) + ); + assert!(task.client().is_none()); +} + #[test] fn modulepreload_start_action_reserves_fetch_in_modulator_store() { let mut store = ChildDocumentModulatorStore::default(); @@ -31,7 +147,7 @@ fn modulepreload_start_action_reserves_fetch_in_modulator_store() { assert_eq!(target.child_handle(), DomHandle::new(1)); assert_eq!(target.task_owner(), owner); assert_eq!(target.realm_id(), realm_id); - assert_eq!(action_link_handle, link_handle); + assert_eq!(action_link_handle, Some(link_handle)); assert_eq!(action_key, key); assert_eq!(fetch_request.source_url(), request.source_url()); let inflight = store @@ -63,7 +179,7 @@ impl FrameDocumentModulepreloadStartActionHooks for FakeModulepreloadStartHooks fn schedule_modulepreload_fetch( &mut self, _target: ChildDocumentModuleFetchTarget, - _link_handle: DomHandle, + _link_handle: Option, _key: ModuleMapKey, _load_id: u64, _request: Box, @@ -75,7 +191,7 @@ impl FrameDocumentModulepreloadStartActionHooks for FakeModulepreloadStartHooks &mut self, _owner: FrameDocumentOwner, _realm_id: FrameRealmId, - _link_handle: DomHandle, + _link_handle: Option, _key: &ModuleMapKey, ) { self.joined_fetching_records += 1; @@ -85,7 +201,7 @@ impl FrameDocumentModulepreloadStartActionHooks for FakeModulepreloadStartHooks &mut self, _owner: FrameDocumentOwner, _realm_id: FrameRealmId, - _link_handle: DomHandle, + _link_handle: Option, _key: &ModuleMapKey, ) { self.joined_terminal_success_records += 1; @@ -95,7 +211,7 @@ impl FrameDocumentModulepreloadStartActionHooks for FakeModulepreloadStartHooks &mut self, _owner: FrameDocumentOwner, _realm_id: FrameRealmId, - _link_handle: DomHandle, + _link_handle: Option, _key: &ModuleMapKey, ) { self.joined_terminal_failure_records += 1; @@ -141,7 +257,7 @@ fn modulepreload_start_action_runner_posts_terminal_followup() { let action = FrameDocumentModulepreloadStartAction::JoinedTerminalSuccess { owner: document_owner, realm_id, - link_handle, + link_handle: Some(link_handle), key, }; let hooks = FakeModulepreloadStartHooks { @@ -336,7 +452,7 @@ fn modulepreload_start_action_joins_fetching_entry_in_modulator_store() { assert_eq!(action_owner, document_owner); assert_eq!(action_realm_id, realm_id); - assert_eq!(link_handle, joined_link); + assert_eq!(link_handle, Some(joined_link)); assert_eq!(action_key, key); } @@ -381,7 +497,7 @@ fn modulepreload_start_action_joins_terminal_entry_as_terminal_work() { }; assert_eq!(action_owner, document_owner); assert_eq!(action_realm_id, realm_id); - assert_eq!(action_link_handle, link_handle); + assert_eq!(action_link_handle, Some(link_handle)); assert_eq!(action_key, key); let batch = store.take_ready_document_modulator_terminal_batches(owner, realm_id); diff --git a/moli-renderer-v8/src/module_runtime.rs b/moli-renderer-v8/src/module_runtime.rs index 681e891ccad..a621b68eddd 100644 --- a/moli-renderer-v8/src/module_runtime.rs +++ b/moli-renderer-v8/src/module_runtime.rs @@ -1,6 +1,7 @@ mod driver; mod dynamic_resolver; mod evaluation; +mod fetch_context; mod frame_document_parser_tree; mod graph; mod graph_fetch_store; @@ -47,6 +48,7 @@ pub(crate) use self::dynamic_resolver::{ PendingDynamicModuleImport, }; pub(crate) use self::evaluation::ModuleEvaluationRecord; +pub(crate) use self::fetch_context::NativeModuleFetchContext; pub(crate) use self::import_attributes::{import_attributes_key, module_request_attributes}; pub(crate) use self::import_map::ImportMapRegistryState; pub(crate) use self::json::{json_module_exception_source_url, parse_json_module}; diff --git a/moli-renderer-v8/src/module_runtime/fetch_context.rs b/moli-renderer-v8/src/module_runtime/fetch_context.rs new file mode 100644 index 00000000000..695c9210e1b --- /dev/null +++ b/moli-renderer-v8/src/module_runtime/fetch_context.rs @@ -0,0 +1,256 @@ +use crate::types::AsyncSubresourceFetchResponseFilter; +use std::sync::Arc; + +use moli_fetch::{FetchCancelHandle, Request, RequestRedirectCheck}; +use parking_lot::Mutex; +use url::Url; + +use crate::{ + context_bootstrap::{FetchResourceTiming, ResourcePerformanceEntry}, + document_runtime::{ + DocumentContentSecurityPolicyViolation, DocumentRequestPolicySnapshot, + document_content_security_policy_error_message, + }, + dynamic_script_owner::DynamicScriptServiceWorkerContext, + native_bridge::{OwnerDispatchScope, PageScriptHost}, + network::loads::ResourceLoadLease, + network_host::{FetchCspRedirectState, WindowCspReportRequestContext}, + protocol_types::NavigationResponse, + service_worker_runtime::ServiceWorkerRequestDestination, + types::SubresourceResourceType, +}; + +use super::{ModuleFetchMetadata, ModuleKind}; + +/// Native settings of the Document that starts one module fetch. Neither +/// caller realms nor element wrappers are retained by asynchronous transport. +pub(crate) struct NativeModuleFetchContext { + policy: DocumentRequestPolicySnapshot, + report_context: WindowCspReportRequestContext, + redirects: FetchCspRedirectState, + violations: Arc>>, + service_worker: DynamicScriptServiceWorkerContext, + request_origin: moli_url::WebOrigin, + destination: ServiceWorkerRequestDestination, + resource_type: SubresourceResourceType, + timing: Mutex, + entry: Mutex>, +} + +impl std::fmt::Debug for NativeModuleFetchContext { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("NativeModuleFetchContext") + .field("identity", &self.report_context.identity()) + .finish_non_exhaustive() + } +} + +impl NativeModuleFetchContext { + pub(crate) fn capture( + scope: &mut v8::PinScope<'_, '_>, + host: &mut PageScriptHost, + owner: OwnerDispatchScope, + kind: ModuleKind, + metadata: &ModuleFetchMetadata, + ) -> Option> { + let loader = host.document_resource_loader_for_dispatch_scope(owner)?; + let mut policy = host.document_connect_policy_snapshot_for_owner(owner)?; + policy = if kind == ModuleKind::Css { + policy.for_style_preload(metadata.nonce().map(str::to_owned)) + } else { + policy.for_script_preload(crate::planning::ScriptFetchMetadata { + nonce: metadata.nonce().map(str::to_owned), + integrity: metadata.integrity().map(str::to_owned), + ..Default::default() + }) + }; + let report_context = + crate::network_host::capture_window_csp_report_request_context(scope, host, owner)?; + let redirects = FetchCspRedirectState::new(&policy); + Some(Arc::new(Self { + policy, + report_context, + redirects, + violations: Arc::default(), + service_worker: DynamicScriptServiceWorkerContext { + browser_context_runtime: host.browser_context_runtime(), + client_id: host.service_worker_client_id_for_subresource_owner(owner), + document_url: loader.fetch_context().document_url().clone(), + }, + request_origin: loader.fetch_context().request_origin(), + destination: if kind == ModuleKind::Css { + ServiceWorkerRequestDestination::Style + } else { + ServiceWorkerRequestDestination::Script + }, + resource_type: if kind == ModuleKind::Css { + SubresourceResourceType::Stylesheet + } else { + SubresourceResourceType::Script + }, + // Modulepreload uses the single-module script fetch algorithm, + // including its script initiator, regardless of its DOM source. + timing: Mutex::new(FetchResourceTiming::from_captured_initiator( + "script", + loader.fetch_context().document_url().as_str().to_owned(), + )), + entry: Mutex::default(), + })) + } + + pub(crate) fn check_initial(&self, url: &Url) -> Result<(), String> { + self.check_url( + url, + crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect, + ) + } + + fn check_url( + &self, + url: &Url, + redirect: crate::content_security_policy::ContentSecurityPolicyRedirectStatus, + ) -> Result<(), String> { + let (reports, enforced) = self + .policy + .check_url(&self.service_worker.document_url, url, redirect) + .into_violations(); + let error = enforced + .first() + .map(|v| document_content_security_policy_error_message(v, "modulepreload")); + self.violations + .lock() + .extend(reports.into_iter().chain(enforced)); + error.map_or(Ok(()), Err) + } + + pub(crate) fn redirect_check( + self: &Arc, + request_url: &Url, + ) -> Option { + // A Service Worker can retain a redirect guard after its client + // cancels. Keep only report data, not the Document/browser runtime. + let violations = self.violations.clone(); + self.redirects.redirect_check( + self.policy.clone(), + self.service_worker.document_url.clone(), + request_url.clone(), + move |violation| violations.lock().push(violation), + ) + } + + pub(crate) fn check_response_url(&self, response: &NavigationResponse) -> Result<(), String> { + if response.redirected && !self.redirects.was_checked(&response.final_url) { + self.check_url(&response.final_url, crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect) + } else { + Ok(()) + } + } + + pub(crate) fn record_response( + &self, + request: &Request, + response: &NavigationResponse, + filter: Option<&AsyncSubresourceFetchResponseFilter>, + native: Option, + ) { + let timing = self.timing.lock(); + if let Some(native) = native { + timing.observe_native_timing(native); + } + let filter = filter.cloned().unwrap_or_else(|| { + crate::network_host::FetchResponseRequest { + method: "GET", + mode: request.request_mode, + redirect_mode: request.redirect_mode, + } + .network_response_filter( + &self.request_origin, + &response.head(), + request.credentials_mode, + ) + }); + *self.entry.lock() = Some(timing.completed( + &request.url, + &self.request_origin, + request.request_mode, + &response.head(), + response.body_bytes().len(), + Some(&filter), + )); + } + + pub(crate) fn record_failure(&self, url: &Url) { + let entry = self.timing.lock().failed(url); + *self.entry.lock() = Some(entry); + } + + pub(crate) fn take_performance_entry(&self) -> Option { + self.entry.lock().take() + } + + pub(crate) fn report_violations( + &self, + scope: &mut v8::PinScope<'_, '_>, + host: &mut PageScriptHost, + dispatch_dom_events: bool, + ) { + let violations = std::mem::take(&mut *self.violations.lock()); + let host_ptr = host as *mut PageScriptHost; + for violation in violations { + crate::network_host::send_content_security_policy_violation_report_from_window_context( + host, + &self.report_context, + &violation, + ); + if dispatch_dom_events { + host.dispatch_document_connect_csp_violation_event_for_exact_owner_without_report_best_effort(scope, host_ptr, self.report_context.identity(), &violation); + } + } + } + + pub(crate) fn fetch( + self: Arc, + load: ResourceLoadLease, + request: Request, + callback: impl FnOnce( + anyhow::Result<( + NavigationResponse, + Option, + bool, + )>, + Option, + ) + Send + + 'static, + ) { + let runner = load.task_runner(); + let request_client = load.request_client(); + let (cancel_tx, cancel_rx) = tokio::sync::oneshot::channel(); + let cancel = FetchCancelHandle::new(); + load.attach_cancel_handle(cancel.clone()); + load.attach_consumer_cancel(move || { + let _ = cancel_tx.send(()); + }); + runner.clone().spawn(Box::pin(async move { + let result = tokio::select! { + result = async { + match self.service_worker.browser_context_runtime.fetch_service_worker_subresource_for_client_with_metadata_and_cancellation(self.service_worker.client_id, self.service_worker.document_url.clone(), &request, &request_client, runner, self.destination, self.resource_type, cancel.clone()).await? { + Some(response) => Ok((*response.response, response.response_filter, !response.from_network_fallback)), + None => { + // The SDK owns its cache/preload consumer hook. + // Hand off the same lease after the SW stage ends. + load.release_consumer_cancel(); + let (response_tx, response_rx) = tokio::sync::oneshot::channel(); + request_client.fetch_cacheable_script_text_callback_with_load(request, load.clone(), move |response| { let _ = response_tx.send(response); })?; + let response = response_rx.await.map_err(|_| anyhow::anyhow!("module fetch response channel closed"))??; + Ok((NavigationResponse::from(response), None, false)) + } + } + } => result, + Ok(()) = cancel_rx => { cancel.cancel(); Err(anyhow::anyhow!("modulepreload fetch cancelled when its Document retired")) } + }; + let native = load.response_timing(); + load.finish(); + callback(result, native); + })); + } +} diff --git a/moli-renderer-v8/src/module_runtime/graph.rs b/moli-renderer-v8/src/module_runtime/graph.rs index 046902ed09d..615947913fb 100644 --- a/moli-renderer-v8/src/module_runtime/graph.rs +++ b/moli-renderer-v8/src/module_runtime/graph.rs @@ -100,6 +100,7 @@ pub(crate) struct NativeModuleGraphFetchRequest { module_key: Option, dependency: Option, csp_context: Option, + fetch_context: Option>, } pub(crate) struct ModuleScriptGraphFetchContinuation { @@ -231,6 +232,7 @@ impl NativeModuleGraphFetchRequest { module_key: None, dependency: None, csp_context: None, + fetch_context: None, } } @@ -377,6 +379,22 @@ impl NativeModuleGraphFetchRequest { self.fetch_metadata.request_metadata.integrity.as_deref() } + pub(crate) fn with_fetch_context( + mut self, + context: std::sync::Arc, + ) -> Self { + self.fetch_context = Some(context); + self + } + + pub(crate) fn fetch_context(&self) -> Option<&std::sync::Arc> { + self.fetch_context.as_ref() + } + + pub(crate) fn module_kind(&self) -> ModuleKind { + self.kind + } + pub(crate) fn request(&self, request_origin: &moli_url::WebOrigin) -> anyhow::Result { // The client's default is captured for this fetch, not for the compiled // module. Empty script policies must observe later document policy changes. @@ -481,15 +499,32 @@ impl NativeModuleGraphFetchRequest { let source_url = self.source_url.clone(); let kind = self.kind; let integrity = self.fetch_metadata.request_metadata.integrity.clone(); - let request = self.request(&request_origin)?; + let context = self.fetch_context.clone(); + let mut request = self.request(&request_origin)?; + if let Some(check) = context + .as_ref() + .filter(|_| self.csp_context.is_none()) + .and_then(|context| context.redirect_check(&self.source_url)) + { + request = request.with_redirect_check(check); + } + let observed_request = request.clone(); + let response_context = context.clone(); let request_mode = request.request_mode; let credentials_mode = request.credentials_mode; let csp_context = self.csp_context.clone(); let web_security_disabled = loader.web_security_disabled(); - let completion = move |response: anyhow::Result| { - let mut network_result: Option = None; - let result = response + let completion = + move |response: anyhow::Result<( + NavigationResponse, + Option, + bool, + )>, + native_timing: Option| { + let mut network_result: Option = None; + let result = response .map_err(|error| { + if let Some(context) = &response_context { context.record_failure(&source_url); } ModuleLoadError::new( ModuleLoadStage::Fetch, format!("failed to fetch module `{source_url}`: {error} (FailedToLoad)"), @@ -497,16 +532,19 @@ impl NativeModuleGraphFetchRequest { .message() .to_owned() }) - .and_then(|response| { - // Main/child parser, runtime, dynamic import and modulepreload - // all convert responses here, including cached/coalesced results. - // Decide CSP from the admitted request snapshot before source - // construction; owner completions only dispatch its reports. + .and_then(|(response, service_worker_filter, from_service_worker)| { if let Some(context) = &csp_context { - context.check_response(&response).map_err(|error| error.to_string())?; + context.check_response_head(&response.head()).map_err(|error| error.to_string())?; } - let response = NavigationResponse::from(response); network_result = Some(std::sync::Arc::new(Ok(response.clone()))); + if let Some(context) = &response_context { + if csp_context.is_none() + && let Err(error) = context.check_response_url(&response) { + context.record_failure(&source_url); + return Err(error); + } + context.record_response(&observed_request, &response, service_worker_filter.as_ref(), native_timing); + } if !(200..=299).contains(&response.status) { return Err(ModuleLoadError::new( ModuleLoadStage::Fetch, @@ -544,19 +582,28 @@ impl NativeModuleGraphFetchRequest { &response.headers, ); let (head, body_bytes) = response.into_byte_parts(); - crate::network_host::validate_cors_response_chain( - &request_origin, - &head, - credentials_mode, - web_security_disabled, - ).map_err(|error| ModuleLoadError::new(ModuleLoadStage::Fetch, error).message().to_owned())?; - let response_is_eligible = crate::network_host::network_response_filter( - &request_origin, - &head, - request_mode, - moli_fetch::RequestRedirectMode::Follow, - web_security_disabled, - ).is_none(); + if !from_service_worker { + crate::network_host::validate_cors_response_chain( + &request_origin, + &head, + credentials_mode, + web_security_disabled, + ).map_err(|error| ModuleLoadError::new(ModuleLoadStage::Fetch, error).message().to_owned())?; + } + let response_is_eligible = if from_service_worker { + service_worker_filter.as_ref().is_none_or(crate::types::AsyncSubresourceFetchResponseFilter::is_readable) + } else { + crate::network_host::network_response_filter( + &request_origin, + &head, + request_mode, + moli_fetch::RequestRedirectMode::Follow, + web_security_disabled, + ).is_none() + }; + if from_service_worker && !response_is_eligible { + return Err("Service Worker returned an unreadable module response".to_owned()); + } if !crate::subresource_integrity::response_matches_subresource_integrity_metadata( &body_bytes, integrity.as_deref(), @@ -587,14 +634,31 @@ impl NativeModuleGraphFetchRequest { .with_response_referrer_policy(response_referrer_policy), }) }); - if network_result.is_none() - && let Err(error) = &result + if network_result.is_none() + && let Err(error) = &result + { + network_result = Some(std::sync::Arc::new(Err(error.clone()))); + } + callback(result, network_result); + }; + if let Some(context) = context { + if self.csp_context.is_none() + && let Err(error) = context.check_initial(&self.source_url) { - network_result = Some(std::sync::Arc::new(Err(error.clone()))); + load.finish(); + completion(Err(anyhow::anyhow!(error)), None); + return Ok(()); } - callback(result, network_result); - }; - loader.fetch_cacheable_script_text_callback_with_load(request, load, completion) + context.fetch(load, request, completion); + Ok(()) + } else { + loader.fetch_cacheable_script_text_callback_with_load(request, load, move |response| { + completion( + response.map(|response| (NavigationResponse::from(response), None, false)), + None, + ) + }) + } } } @@ -3376,6 +3440,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -3453,6 +3518,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -3505,6 +3571,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -3544,6 +3611,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -3602,6 +3670,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -3652,6 +3721,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -3691,6 +3761,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -3723,6 +3794,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", @@ -4508,6 +4580,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, }; let (tx, rx) = oneshot::channel(); let registry = ResourceLoadRegistry::new( @@ -4581,6 +4654,7 @@ import "./c.mjs"; module_key: None, dependency: None, csp_context: None, + fetch_context: None, } .request(&moli_url::WebOrigin::from_url(&url( "https://app.example.test/page", diff --git a/moli-renderer-v8/src/modulepreload.rs b/moli-renderer-v8/src/modulepreload.rs index 0dedd76fb68..eebf1af1f4b 100644 --- a/moli-renderer-v8/src/modulepreload.rs +++ b/moli-renderer-v8/src/modulepreload.rs @@ -173,7 +173,6 @@ pub(crate) fn modulepreload_fetch_candidate( return None; } let state = modulepreload_as_state(element); - let attributes = modulepreload_attributes_for_state(state)?; let fetch_metadata = crate::planning::ScriptFetchMetadata::from_script_attributes( element.attribute("crossorigin"), element.attribute("referrerpolicy"), @@ -189,6 +188,23 @@ pub(crate) fn modulepreload_fetch_candidate( element.attribute("integrity"), import_map_integrity, ); + modulepreload_fetch_candidate_for_options( + state, + fetch_metadata, + request_url, + document_url, + document_referrer_policy, + ) +} + +pub(crate) fn modulepreload_fetch_candidate_for_options( + state: ModulepreloadAsState, + fetch_metadata: crate::planning::ScriptFetchMetadata, + request_url: Url, + document_url: &Url, + document_referrer_policy: Option, +) -> Option { + let attributes = modulepreload_attributes_for_state(state)?; let key = ModuleMapKey::from_url_and_attributes(&request_url, &attributes).ok()?; Some(ModulepreloadFetchCandidate { key: key.clone(), diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frames/module_scripts.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frames/module_scripts.rs index 1d36aafaa5a..2d2c961c30b 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/child_frames/module_scripts.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/child_frames/module_scripts.rs @@ -7,10 +7,10 @@ use crate::{ ChildDocumentModuleFetchTarget, FrameDocumentModuleClientReservation, FrameDocumentModuleDependencyFetchTask, FrameDocumentModuleFetchClientStart, FrameDocumentModuleFetchDisposition, FrameDocumentModulepreloadFetchTask, - FrameDocumentModulepreloadMaterializedWork, FrameDocumentModulepreloadTerminalWork, - FrameDocumentModulepreloadWorkAwaitingRealm, FrameDocumentParserModuleRootFetchStart, - FrameDocumentParserModuleRootStartTask, FrameDocumentTaskOwner, FrameRealmId, - FrameRequestKind, + FrameDocumentModulepreloadMaterializedWork, FrameDocumentModulepreloadSource, + FrameDocumentModulepreloadTerminalWork, FrameDocumentModulepreloadWorkAwaitingRealm, + FrameDocumentParserModuleRootFetchStart, FrameDocumentParserModuleRootStartTask, + FrameDocumentTaskOwner, FrameRealmId, FrameRequestKind, }, module_runtime::{ ModuleFetchMetadata, ModuleGraphFetchedSource, ModuleMapKey, NativeModuleGraphFetchRequest, @@ -495,6 +495,42 @@ impl PageScriptHost { return false; }; + self.queue_child_modulepreload_fetch_for_source( + FrameDocumentModulepreloadSource::Link(client), + request, + ) + } + + pub(crate) fn queue_child_response_modulepreload( + &mut self, + handle: DomHandle, + owner: FrameDocumentTaskOwner, + request: NativeModuleSingleFetchRequest, + ) -> bool { + self.queue_child_modulepreload_fetch_for_source( + FrameDocumentModulepreloadSource::ResponseHeader { + child_handle: handle, + owner, + }, + request, + ) + } + + fn queue_child_modulepreload_fetch_for_source( + &mut self, + source: FrameDocumentModulepreloadSource, + request: NativeModuleSingleFetchRequest, + ) -> bool { + let handle = source.child_handle(); + let owner = source.owner(); + if !self.child_browsing_contexts.contains_key(&handle) + || !self + .frame_owner_store + .child_document_task_owner_is_current(handle, owner) + { + return false; + } + let expected_realm_id = self .frame_owner_store .current_reserved_realm_id_for_document_task_owner(owner); @@ -506,7 +542,7 @@ impl PageScriptHost { return self.queue_child_modulepreload_work_awaiting_realm( FrameDocumentModulepreloadWorkAwaitingRealm::fetch_start( expected_realm_id, - client, + source, request, ), ); @@ -516,16 +552,22 @@ impl PageScriptHost { tracing::warn!( ?handle, ?owner, - ?link_handle, + ?source, "child modulepreload found a materialized context without an exact realm" ); return false; }; - self.route_child_modulepreload_start( - FrameDocumentModulepreloadFetchTask::from_modulepreload_fetch_parts( - realm_id, client, request, - ), - ) + let task = match source { + FrameDocumentModulepreloadSource::Link(client) => { + FrameDocumentModulepreloadFetchTask::from_modulepreload_fetch_parts( + realm_id, client, request, + ) + } + FrameDocumentModulepreloadSource::ResponseHeader { .. } => { + FrameDocumentModulepreloadFetchTask::from_source_parts(realm_id, source, request) + } + }; + self.route_child_modulepreload_start(task) } fn queue_child_modulepreload_work_awaiting_realm( diff --git a/moli-renderer-v8/src/network/loads/registry.rs b/moli-renderer-v8/src/network/loads/registry.rs index c7c67d4b4c3..da9f92ac72a 100644 --- a/moli-renderer-v8/src/network/loads/registry.rs +++ b/moli-renderer-v8/src/network/loads/registry.rs @@ -554,6 +554,14 @@ impl ResourceLoadLease { } } + /// Ends one asynchronous consumer before the next stage takes this lease. + /// Retirement still marks the lease cancelled, so a subsequent attachment + /// observes cancellation even when retirement wins during the handoff. + pub(crate) fn release_consumer_cancel(&self) { + let previous = self.registration.lifecycle.lock().consumer_cancel.take(); + drop(previous); + } + pub(crate) fn cancel(&self) { self.registration.cancel(); } @@ -681,6 +689,49 @@ mod tests { assert!(other_request.try_restart_with_auth()); } + #[tokio::test(flavor = "current_thread")] + async fn modulepreload_consumer_handoff_preserves_retirement_cancellation() { + for retirement_stage in 0..3 { + let registry = registry(); + let lease = lease( + ®istry, + ResourceLoadDisposition::Ordinary, + FetchCancelHandle::new(), + ); + let first_cancelled = Arc::new(AtomicU64::new(0)); + lease.attach_consumer_cancel({ + let first_cancelled = first_cancelled.clone(); + move || { + first_cancelled.fetch_add(1, Ordering::AcqRel); + } + }); + if retirement_stage == 0 { + registry.begin_detach(); + } + lease.release_consumer_cancel(); + if retirement_stage == 1 { + registry.begin_detach(); + } + let next_cancelled = Arc::new(AtomicU64::new(0)); + lease.attach_consumer_cancel({ + let next_cancelled = next_cancelled.clone(); + move || { + next_cancelled.fetch_add(1, Ordering::AcqRel); + } + }); + if retirement_stage == 2 { + registry.begin_detach(); + } + assert!(lease.is_cancelled()); + assert_eq!( + first_cancelled.load(Ordering::Acquire), + u64::from(retirement_stage == 0) + ); + assert_eq!(next_cancelled.load(Ordering::Acquire), 1); + assert_eq!(registry.diagnostics().active_ordinary_load_count, 0); + } + } + #[tokio::test(flavor = "current_thread")] async fn document_retirement_cancels_ordinary_loads() { let registry = registry(); diff --git a/moli-renderer-v8/src/network_host/preload.rs b/moli-renderer-v8/src/network_host/preload.rs index 2d7e5b8fcdb..fb18972b087 100644 --- a/moli-renderer-v8/src/network_host/preload.rs +++ b/moli-renderer-v8/src/network_host/preload.rs @@ -37,6 +37,35 @@ pub(crate) fn start_document_response_links( tracing::debug!(url = %preload.url, error, "response script preload was not loaded"); } } + if let ( + crate::native_bridge::OwnerDispatchScope::Child(handle), + crate::native_bridge::WindowDocumentOwner::Frame(owner), + ) = (target.dispatch_scope(), target.owner()) + { + for preload in &links.modules { + if !host.window_document_owner_is_current_for_dispatch_scope( + target.owner(), + target.dispatch_scope(), + ) { + break; + } + let Some(loader) = host.document_resource_loader_for_window_owner(target.owner()) + else { + break; + }; + let Some(environment) = + host.subresource_request_environment(&loader, target.dispatch_scope()) + else { + break; + }; + if let Some(candidate) = preload.fetch_candidate( + &environment.document_url, + host.document_response_preload_referrer_policy(target.dispatch_scope()), + ) { + host.queue_child_response_modulepreload(handle, owner, candidate.request); + } + } + } } pub(crate) fn apply_response_preload_request_metadata( diff --git a/moli-renderer-v8/src/page_resource_completion/main_modulepreload.rs b/moli-renderer-v8/src/page_resource_completion/main_modulepreload.rs index 6e310fe0adb..bb175f1a482 100644 --- a/moli-renderer-v8/src/page_resource_completion/main_modulepreload.rs +++ b/moli-renderer-v8/src/page_resource_completion/main_modulepreload.rs @@ -38,6 +38,7 @@ pub(crate) struct MainModulepreloadFetchCompletion { result: std::result::Result, network_result: Option, network_attribution: MainModuleFetchNetworkAttribution, + fetch_context: Option>, } impl MainModulepreloadFetchCompletion { @@ -52,9 +53,24 @@ impl MainModulepreloadFetchCompletion { result, network_result, network_attribution, + fetch_context: None, } } + pub(crate) fn with_fetch_context( + mut self, + context: Option>, + ) -> Self { + self.fetch_context = context; + self + } + + pub(crate) fn fetch_context( + &self, + ) -> Option<&std::sync::Arc> { + self.fetch_context.as_ref() + } + pub(crate) fn target(&self) -> MainModulepreloadFetchTarget { self.target } diff --git a/moli-renderer-v8/src/renderer_resource_scheduler.rs b/moli-renderer-v8/src/renderer_resource_scheduler.rs index 06a5e4c263d..173bb701488 100644 --- a/moli-renderer-v8/src/renderer_resource_scheduler.rs +++ b/moli-renderer-v8/src/renderer_resource_scheduler.rs @@ -68,6 +68,23 @@ impl MainModuleFetchSchedule { result: std::result::Result, network_result: Option, network_attribution: MainModuleFetchNetworkAttribution, + ) { + self.send_completion_with_context( + completion_tx, + result, + network_result, + network_attribution, + None, + ); + } + + fn send_completion_with_context( + self, + completion_tx: &RendererResourceCompletionSender, + result: std::result::Result, + network_result: Option, + network_attribution: MainModuleFetchNetworkAttribution, + fetch_context: Option>, ) { match self { Self::Parser(target) => { @@ -107,7 +124,8 @@ impl MainModuleFetchSchedule { result, network_result, network_attribution, - ), + ) + .with_fetch_context(fetch_context), ); } } @@ -117,11 +135,23 @@ impl MainModuleFetchSchedule { #[derive(Clone)] pub(crate) struct RendererResourceScheduler { completion_tx: RendererResourceCompletionSender, + module_fetch_context: Option>, } impl RendererResourceScheduler { pub(crate) fn new(completion_tx: RendererResourceCompletionSender) -> Self { - Self { completion_tx } + Self { + completion_tx, + module_fetch_context: None, + } + } + + pub(crate) fn with_module_fetch_context( + mut self, + context: Arc, + ) -> Self { + self.module_fetch_context = Some(context); + self } pub(crate) fn schedule_main_parser_module_graph_fetch( @@ -297,6 +327,13 @@ impl RendererResourceScheduler { let requester = schedule.requester(); let ordering = schedule.ordering(); let request = prioritized_module_graph_fetch_request(requester, ordering, request); + let request = if let Some(context) = &self.module_fetch_context { + request.with_fetch_context(context.clone()) + } else { + request + }; + let fetch_context = request.fetch_context().cloned(); + let callback_context = fetch_context.clone(); let request_url = request.source_url().clone(); let network_attribution = MainModuleFetchNetworkAttribution::new(document_url, request_url.clone()); @@ -315,11 +352,12 @@ impl RendererResourceScheduler { &callback_request_url, result.is_ok(), ); - schedule.send_completion( + schedule.send_completion_with_context( &completion_tx, result, network_result, callback_attribution, + callback_context, ); }; if let Err(error) = request.fetch_source_for_document(&loader, send_completion) { @@ -331,11 +369,12 @@ impl RendererResourceScheduler { &request_url, &error, ); - schedule.send_completion( + schedule.send_completion_with_context( &self.completion_tx, Err(error.clone()), Some(Arc::new(Err(error))), network_attribution, + fetch_context, ); } } @@ -409,6 +448,13 @@ impl RendererResourceScheduler { let requester = ModuleGraphFetchRequester::ModulePreload; let ordering = ModuleGraphFetchOrdering::BackgroundPreload; let request = prioritized_module_graph_fetch_request(requester, ordering, request); + let request = if let Some(context) = &self.module_fetch_context { + request.with_fetch_context(context.clone()) + } else { + request + }; + let fetch_context = request.fetch_context().cloned(); + let callback_context = fetch_context.clone(); let request_url = request.source_url().clone(); trace_module_graph_fetch_scheduled(load_id, requester, ordering, &request_url); @@ -432,7 +478,8 @@ impl RendererResourceScheduler { result, network_result, callback_attribution, - ), + ) + .with_fetch_context(callback_context), ); }; if let Err(error) = request.fetch_source_for_document(&loader, send_completion) { @@ -451,7 +498,8 @@ impl RendererResourceScheduler { Err(error.clone()), Some(Arc::new(Err(error))), network_attribution, - ), + ) + .with_fetch_context(fetch_context), ); } } diff --git a/moli-renderer-v8/src/response_links.rs b/moli-renderer-v8/src/response_links.rs index 103dc6f28df..f266e0c256b 100644 --- a/moli-renderer-v8/src/response_links.rs +++ b/moli-renderer-v8/src/response_links.rs @@ -3,6 +3,7 @@ use std::collections::HashSet; use moli_header_field::{HeaderFieldTokenMode, HeaderFieldTokenizer}; use url::Url; +use crate::modulepreload::{ModulepreloadAsState, ModulepreloadFetchCandidate}; use crate::planning::ScriptFetchMetadata; /// Response hints retain the response URL as their base, independently of @@ -11,6 +12,7 @@ use crate::planning::ScriptFetchMetadata; pub(crate) struct DocumentResponseLinks { pub(crate) dictionaries: Vec, pub(crate) scripts: Vec, + pub(crate) modules: Vec, } #[derive(Debug, Clone, PartialEq, Eq)] @@ -19,6 +21,29 @@ pub(crate) struct ResponseScriptPreload { pub(crate) metadata: ScriptFetchMetadata, } +#[derive(Debug, Clone, PartialEq, Eq)] +pub(crate) struct ResponseModulepreload { + pub(crate) url: Url, + pub(crate) destination: ModulepreloadAsState, + pub(crate) metadata: ScriptFetchMetadata, +} + +impl ResponseModulepreload { + pub(crate) fn fetch_candidate( + &self, + document_url: &Url, + document_referrer_policy: Option, + ) -> Option { + crate::modulepreload::modulepreload_fetch_candidate_for_options( + self.destination, + self.metadata.clone(), + self.url.clone(), + document_url, + document_referrer_policy, + ) + } +} + impl DocumentResponseLinks { pub(crate) fn parse(base: &Url, headers: &[(String, Vec)]) -> Self { let mut result = Self::default(); @@ -55,20 +80,31 @@ impl DocumentResponseLinks { .preload_type_matches(link.parameter("type")) { let preload = ResponseScriptPreload { - url, - metadata: ScriptFetchMetadata::from_script_attributes( - link.parameter("crossorigin"), - link.parameter("referrerpolicy"), - None, - link.parameter("integrity"), - link.parameter("nonce"), - link.parameter("fetchpriority"), - ), + url: url.clone(), + metadata: link.script_fetch_metadata(), }; if !result.scripts.contains(&preload) { result.scripts.push(preload); } } + let destination = crate::modulepreload::modulepreload_as_state_from_attribute( + link.parameter("as"), + ); + if link.has_relation("modulepreload") + && destination != ModulepreloadAsState::Invalid + && crate::modulepreload::modulepreload_media_attribute_matches( + link.parameter("media"), + ) + { + let preload = ResponseModulepreload { + url, + destination, + metadata: link.script_fetch_metadata(), + }; + if !result.modules.contains(&preload) { + result.modules.push(preload); + } + } } if !parser.consume(',') { break; @@ -85,6 +121,17 @@ struct ResponseLink<'a> { } impl ResponseLink<'_> { + fn script_fetch_metadata(&self) -> ScriptFetchMetadata { + ScriptFetchMetadata::from_script_attributes( + self.parameter("crossorigin"), + self.parameter("referrerpolicy"), + None, + self.parameter("integrity"), + self.parameter("nonce"), + self.parameter("fetchpriority"), + ) + } + fn parameter(&self, name: &str) -> Option<&str> { self.parameters .iter() @@ -151,6 +198,91 @@ fn parse_link<'a>( mod tests { use super::*; + #[test] + fn response_modulepreload_keeps_module_options_and_the_response_url_base() { + let base = Url::parse("https://example.test/pages/document").unwrap(); + let headers = vec![("Link".into(), br#"<../entry.mjs#module>; REL="alternate MODULEPRELOAD"; nonce="a\"z"; nonce=wrong; crossorigin=use-credentials; referrerpolicy=no-referrer; integrity="sha256-value", ; rel=alternate; rel=modulepreload, ;rel=modulepreload;as=image, ;rel=modulepreload;media="not all", ;rel=modulepreload;anchor="/other", <../entry.mjs#module>;REL="alternate MODULEPRELOAD";nonce="a\"z";crossorigin=use-credentials;referrerpolicy=no-referrer;integrity="sha256-value", ;rel=modulepreload;as=style, ;rel=modulepreload;as=json"#.to_vec())]; + let parsed = DocumentResponseLinks::parse(&base, &headers); + assert!(parsed.scripts.is_empty()); + assert_eq!(parsed.modules.len(), 3); + let hint = &parsed.modules[0]; + assert_eq!(hint.url, base.join("../entry.mjs#module").unwrap()); + assert_eq!(hint.destination, ModulepreloadAsState::ScriptLike); + let candidate = hint + .fetch_candidate(&base, Some("same-origin".into())) + .unwrap(); + assert_eq!(candidate.key.url(), &hint.url); + let fetch = candidate.request.fetch_request(); + let metadata = candidate.request.fetch_metadata(); + assert_eq!(metadata.nonce(), Some("a\"z")); + assert_eq!(metadata.integrity(), Some("sha256-value")); + assert_eq!( + metadata.credentials_mode, + moli_fetch::RequestCredentialsMode::Include + ); + assert_eq!( + metadata.request_metadata.referrer_policy.as_deref(), + Some("no-referrer") + ); + assert_eq!(fetch.initiator_url(), &base); + assert_eq!(parsed.modules[1].destination, ModulepreloadAsState::Style); + assert_eq!( + parsed.modules[1] + .fetch_candidate(&base, None) + .unwrap() + .key + .kind(), + crate::module_runtime::ModuleKind::Css + ); + assert_eq!(parsed.modules[2].destination, ModulepreloadAsState::Json); + assert_eq!( + parsed.modules[2] + .fetch_candidate(&base, None) + .unwrap() + .key + .kind(), + crate::module_runtime::ModuleKind::Json + ); + } + + #[test] + fn modulepreload_style_policy_uses_style_nonce_and_the_captured_document() { + use crate::content_security_policy::ContentSecurityPolicyRedirectStatus; + use crate::document_runtime::DocumentRequestPolicySnapshot; + let document = Url::parse("https://example.test/page").unwrap(); + let target = Url::parse("https://cdn.test/entry.css").unwrap(); + let policy = DocumentRequestPolicySnapshot::from_policies( + vec!["script-src 'none'; style-src 'nonce-az'".into()], + Vec::new(), + Default::default(), + ); + let allowed = policy.clone().for_style_preload(Some("az".into())); + assert!( + allowed + .check_url( + &document, + &target, + ContentSecurityPolicyRedirectStatus::NoRedirect + ) + .has_no_violations() + ); + assert!( + allowed + .check_redirect(&document, &target) + .has_no_violations() + ); + assert!( + !policy + .for_style_preload(Some("wrong".into())) + .check_url( + &document, + &target, + ContentSecurityPolicyRedirectStatus::NoRedirect + ) + .has_no_violations() + ); + } + #[test] fn response_preloads_preserve_first_parameters_and_quoted_delimiters() { let base = Url::parse("https://example.test/pages/document").unwrap(); diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs index 0f761f839a1..37403992bbe 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/service_workers.rs @@ -258,6 +258,30 @@ impl RendererBrowserContextRuntime { resource_task_runner: RendererResourceTaskRunner, destination: ServiceWorkerRequestDestination, resource_type: SubresourceResourceType, + ) -> Result> { + self.fetch_service_worker_subresource_for_client_with_metadata_and_cancellation( + client_id, + document_url, + request, + request_client, + resource_task_runner, + destination, + resource_type, + FetchCancelHandle::new(), + ) + .await + } + + pub(crate) async fn fetch_service_worker_subresource_for_client_with_metadata_and_cancellation( + &self, + client_id: ServiceWorkerClientId, + document_url: Url, + request: &Request, + request_client: &ResourceRequestClient, + resource_task_runner: RendererResourceTaskRunner, + destination: ServiceWorkerRequestDestination, + resource_type: SubresourceResourceType, + cancel_handle: FetchCancelHandle, ) -> Result> { if let Some(preload) = request_client.consume_document_preload(request) { let preload = preload @@ -288,8 +312,11 @@ impl RendererBrowserContextRuntime { let completion_tx = crate::page_task_queue::RendererResourceCompletionSender::direct_completion_only(); let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); + let redirect_request = request.clone(); let dispatch = ServiceWorkerFetchDispatch { - redirect_check: None, + redirect_check: Some(moli_fetch::RequestRedirectCheck::new(move |next_url| { + redirect_request.check_redirect_target(next_url) + })), internal_id: 0, request: ServiceWorkerFetchRequest { client_id, @@ -318,7 +345,7 @@ impl RendererBrowserContextRuntime { completion_tx, request_client: request_client.clone(), resource_task_runner, - cancel_handle: FetchCancelHandle::new(), + cancel_handle, direct_completion_tx: Some(direct_completion_tx), }; diff --git a/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/child_module.rs b/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/child_module.rs index 409a6c74f2c..9ee3d92e693 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/child_module.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/child_module.rs @@ -48,8 +48,10 @@ impl PageVm { self.vm_mut() .record_current_child_module_fetch_network_result( + completion.target(), completion.network_attribution(), completion.network_result(), + None, ); let _followup = self .vm_mut() @@ -82,8 +84,10 @@ impl PageVm { self.vm_mut() .record_current_child_module_fetch_network_result( + completion.target(), completion.network_attribution(), completion.network_result(), + None, ); let _followup = self .vm_mut() @@ -117,8 +121,10 @@ impl PageVm { let output_effect = PageResourceCompletionOutputEffect::capture_if( self.vm_mut() .record_current_child_module_fetch_network_result( + completion.target(), completion.network_attribution(), completion.network_result(), + None, ), ); let _followup = self @@ -140,6 +146,10 @@ impl PageVm { completion: ChildModulepreloadFetchCompletion, ) -> Result { let current_owner = self.current_page_resource_completion_owner(owner); + if let Some(context) = completion.fetch_context() { + self.vm_mut() + .report_module_fetch_context(context, current_owner == Some(owner)); + } if current_owner != Some(owner) { return Ok(self.discard_stale_child_module_terminal( source, @@ -150,11 +160,26 @@ impl PageVm { )); } + let entry = completion + .fetch_context() + .and_then(|context| context.take_performance_entry()) + .or_else(|| { + completion.network_result().map(|result| { + crate::context_bootstrap::ResourcePerformanceEntry::from_network_result( + completion.network_attribution().request_url().as_str(), + "script", + None, + result.as_ref(), + ) + }) + }); let output_effect = PageResourceCompletionOutputEffect::capture_if( self.vm_mut() .record_current_child_module_fetch_network_result( + completion.target(), completion.network_attribution(), completion.network_result(), + entry, ), ); let _followup = self diff --git a/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/main_module.rs b/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/main_module.rs index b461fe7be8f..ab329a41994 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/main_module.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_resource_completion/main_module.rs @@ -296,6 +296,10 @@ impl PageVm { completion: MainModulepreloadFetchCompletion, ) -> Result { let current_owner = self.current_page_resource_completion_owner(owner); + if let Some(context) = completion.fetch_context() { + self.vm_mut() + .report_module_fetch_context(context, current_owner == Some(owner)); + } if current_owner != Some(owner) { let output_effect = if let Some(network_result) = completion.network_result() { self.vm_mut() @@ -338,6 +342,9 @@ impl PageVm { completion.network_attribution().document_url().clone(), completion.network_attribution().request_url().clone(), network_result.as_ref(), + completion + .fetch_context() + .and_then(|context| context.take_performance_entry()), ); PageResourceCompletionOutputEffect::CaptureRequired } else { diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/main_modulepreload_completion.rs b/moli-renderer-v8/src/runtime/page_vm/tests/main_modulepreload_completion.rs index 1d004e12625..9f78796b437 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/main_modulepreload_completion.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/main_modulepreload_completion.rs @@ -270,7 +270,7 @@ async fn production_main_modulepreload_uses_stable_typed_route_and_applies_modul assert_eq!(records[0].resource_type(), SubresourceResourceType::Script); assert_eq!( modulepreload_performance_summary(&mut page_vm, &request_url)?, - "link", + "script", "modulepreload should retain its producer-attributed Resource Timing initiator" ); assert!(!queue.has_ready_completion()); @@ -380,7 +380,7 @@ async fn failed_main_modulepreload_queues_joined_client_fanout_for_a_later_turn( assert!(matches!(body.result(), SubresourceBodyFinishedResult::Failed(error) if error == "net::ERR_ABORTED")); assert_eq!( modulepreload_performance_summary(&mut page_vm, &request_url)?, - "link", + "script", "failed fetches still produce a modulepreload Resource Timing entry" ); assert!(page_vm.vm_mut().has_ready_native_module_owner_actions()); @@ -713,7 +713,7 @@ fn real_page_vm_replacement_rejects_naturally_colliding_main_modulepreload_targe &mut page_vm, &replacement_request_url, )?, - "link" + "script" ); assert_eq!( modulepreload_performance_summary(&mut page_vm, &old_request_url)?, 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 33067be73c5..779e54f0e68 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 @@ -277,3 +277,319 @@ document.body.appendChild(preloadFrame); }).await.expect("header preload Document retirement regression"); }).await; } + +#[tokio::test] +async fn response_modulepreload_is_imported_from_its_child_document_module_map() { + run_page_vm_async_test(async move { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let base = format!("http://{}", listener.local_addr().unwrap()); + let server = tokio::spawn(async move { + for path in ["/pages/module-child", "/header-module.mjs"] { + let (mut stream, _) = tokio::time::timeout(Duration::from_secs(5), listener.accept()).await??; + let head = request_head(&mut stream).await?; + assert!(head.starts_with(&format!("GET {path} ")), "{head}"); + let (kind, fields, body) = if path == "/pages/module-child" { + ("text/html", "Link: <../header-module.mjs#preloaded>;rel=modulepreload;nonce=az\r\nContent-Security-Policy: script-src 'nonce-az'\r\n", r#""#) + } else { + ("text/javascript", "", "globalThis.headerModuleExecutions = (globalThis.headerModuleExecutions || 0) + 1; export const value = 42;") + }; + stream.write_all(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()).as_bytes()).await?; + stream.shutdown().await?; + } + anyhow::Ok(()) + }); + let mut page_vm = test_page_vm_with_document_url(Url::parse(&format!("{base}/parent")).unwrap()); + let executor = page_vm.local_executor.clone(); + executor.run(async move { + page_vm.vm_mut().eval(r#" +addEventListener('message', event => { globalThis.headerModuleResult = event.data; }); +const frame = document.createElement('iframe'); frame.src = '/pages/module-child'; +document.body.appendChild(frame); +"#)?; + drive_websocket_until_done(&mut page_vm, "String(globalThis.headerModuleResult !== undefined)", "header modulepreload module-map consumption").await?; + let result = page_vm.vm_mut().eval("JSON.stringify(headerModuleResult)")?; + assert_eq!(serde_json::from_str::(&result)?, json!({"before": 0, "executions": 1, "value": 42, "links": 0, "timings": ["script"]})); + assert_eq!(page_vm.vm_mut().eval("String(performance.getEntriesByType('resource').some(entry => entry.name.includes('/header-module.mjs')))")?, "false"); + server.await??; + anyhow::Ok(()) + }).await.expect("header modulepreload child regression"); + }).await; +} + +async fn assert_controlled_response_module_preload(response_kind: &'static str) { + run_page_vm_async_test(async move { + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let base = format!("http://{}", listener.local_addr().unwrap()); + let script = "globalThis.controlledPreloadExecutions = (globalThis.controlledPreloadExecutions || 0) + 1; export const answer = 42;"; + let quoted_script = serde_json::to_string(script).unwrap(); + let response = match response_kind { + "fallback" => String::new(), + "forward" => "event.respondWith(fetch(event.request));".to_owned(), + "response" => format!("event.respondWith(new Response({quoted_script}, {{headers: {{'Content-Type': 'text/javascript'}}}}));"), + "stream" => format!("event.respondWith(new Response(new ReadableStream({{start(controller) {{controller.enqueue(new TextEncoder().encode({quoted_script})); controller.close();}}}}), {{headers: {{'Content-Type': 'text/javascript'}}}}));"), + _ => 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.js') return; + event.waitUntil(fetch('/seen?destination=' + event.request.destination + '&referrer=' + encodeURIComponent(event.request.referrer) + '&policy=' + encodeURIComponent(event.request.referrerPolicy))); + {response} +}}); +"#); + let child = r#""#; + let network_script = matches!(response_kind, "fallback" | "forward"); + let server = tokio::spawn(async move { + let mut paths = Vec::new(); + for _ in 0..if network_script { 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().to_owned(); + let (content_type, fields, body) = match path.as_str() { + "/sw.js" => ("text/javascript", "", worker.as_str()), + "/controlled/child" => ("text/html", "Link: ;rel=modulepreload;referrerpolicy=no-referrer\r\n", child), + "/seen?destination=script&referrer=&policy=no-referrer" => ("text/plain", "", "observed"), + "/asset.js" if network_script => { + let expected_destination = if response_kind == "fallback" { "script" } else { "empty" }; + assert!(request.to_ascii_lowercase().contains(&format!("sec-fetch-dest: {expected_destination}\r\n")), "{request}"); + assert!(!request.to_ascii_lowercase().contains("\r\nreferer:"), "{request}"); + ("text/javascript", "", script) + } + _ => panic!("unexpected controlled preload request: {request}"), + }; + 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?; + paths.push(path); + } + assert_eq!(paths.iter().filter(|path| path.as_str() == "/seen?destination=script&referrer=&policy=no-referrer").count(), 1); + assert_eq!(paths.iter().filter(|path| path.as_str() == "/asset.js").count(), usize::from(network_script)); + anyhow::Ok(()) + }); + let mut page_vm = test_page_vm_with_document_url(Url::parse(&format!("{base}/parent")).unwrap()); + let executor = page_vm.local_executor.clone(); + executor.run(async move { + page_vm.vm_mut().eval(r#" +addEventListener('message', event => { globalThis.controlledPreloadResult = 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 frame = document.createElement('iframe'); frame.src = '/controlled/child'; + document.body.appendChild(frame); +})().catch(error => { globalThis.controlledPreloadResult = {error: String(error)}; }); +"#)?; + drive_page_work_until_done_with_explicit_producer_admission( + &mut page_vm, + "String(globalThis.controlledPreloadResult !== undefined)", + "controlled header preload should complete before its consumer", + |page_vm| { + page_vm.runtime_hooks.browser_context_runtime.drain_service_worker_service_lane(); + }, + ).await?; + let result = page_vm.vm_mut().eval("JSON.stringify(controlledPreloadResult)")?; + assert_eq!(serde_json::from_str::(&result)?, json!({"before": 0, "executions": 1, "controlled": true, "links": 0, "timings": ["script"], "answer": 42})); + assert_eq!(page_vm.vm_mut().eval("String(performance.getEntriesByType('resource').some(entry => entry.name.endsWith('/asset.js')))")?, "false"); + server.await??; + anyhow::Ok(()) + }).await.expect("controlled response modulepreload regression"); + }).await; +} + +#[tokio::test] +async fn response_modulepreload_service_worker_network_fallback_uses_its_document_module_map() { + assert_controlled_response_module_preload("fallback").await; +} + +#[tokio::test] +async fn response_modulepreload_service_worker_forwarding_uses_its_document_module_map() { + assert_controlled_response_module_preload("forward").await; +} + +#[tokio::test] +async fn response_modulepreload_service_worker_generated_response_uses_its_document_module_map() { + assert_controlled_response_module_preload("response").await; +} + +#[tokio::test] +async fn response_modulepreload_service_worker_stream_uses_its_document_module_map() { + assert_controlled_response_module_preload("stream").await; +} + +#[tokio::test(flavor = "current_thread")] +async fn response_modulepreload_reports_csp_without_dispatching_into_replacement_realm() { + run_page_vm_async_test(async move { + for replace_realm in [false, true] { + let (base, report_rx, report_server) = spawn_request_capture_http_server().await; + let document_url = Url::parse(&format!("{base}/source.html"))?; + let blocked_url = Url::parse(&format!("{base}/blocked.js"))?; + let mut page_vm = test_page_vm_with_document_url(document_url); + page_vm + .vm_mut() + .set_response_content_security_policies(&[format!( + "script-src 'nonce-az' 'unsafe-eval'; report-uri {base}/csp-report" + )]); + page_vm.vm_mut().eval( + "globalThis.modulepreloadCspEvents = 0; \ + const frame = document.createElement('iframe'); \ + frame.id = 'modulepreload-csp-realm'; document.body.appendChild(frame);", + )?; + let handle = page_vm + .vm() + .element_handle_by_id_for_test("modulepreload-csp-realm") + .expect("child handle"); + materialize_child_realm_through_page_turn_for_test( + &mut page_vm, + "modulepreload-csp-realm", + )?; + let target = page_vm + .vm() + .current_child_document_module_fetch_target(handle) + .expect("source child realm"); + let context = page_vm + .vm_mut() + .capture_module_fetch_context( + crate::native_bridge::OwnerDispatchScope::Child(handle), + crate::module_runtime::ModuleKind::JavaScript, + &crate::module_runtime::ModuleFetchMetadata::default(), + ) + .map_err(anyhow::Error::msg)?; + let error = context + .check_initial(&blocked_url) + .expect_err("missing preload nonce must be blocked"); + if replace_realm { + page_vm.vm_mut().retire_child_frame_realm_for_test(handle); + materialize_child_realm_through_page_turn_for_test( + &mut page_vm, + "modulepreload-csp-realm", + )?; + let replacement = page_vm + .vm() + .current_child_document_module_fetch_target(handle) + .expect("replacement child realm"); + assert_eq!(target.task_owner(), replacement.task_owner()); + assert_ne!(target.realm_id(), replacement.realm_id()); + } + page_vm.vm_mut().eval( + "document.getElementById('modulepreload-csp-realm').contentDocument \ + .addEventListener('securitypolicyviolation', () => modulepreloadCspEvents++);", + )?; + let root = page_vm.document_lifecycle.identity().document; + let completion = test_child_modulepreload_completion_for_target( + target, + 701, + "modulepreload-csp-realm", + Some(&error), + ) + .with_fetch_context(Some(context)); + let mut source = RendererPageNetworkingSource::new_for_test(); + source.enqueue_local_for_test( + RendererPageResourceCompletion::child_modulepreload_fetch(root, completion), + ); + let outcome = page_vm + .apply_one_page_resource_terminal_owner_admission_for_test(&mut source)? + .expect("one modulepreload completion"); + assert_eq!( + matches!( + outcome.action.document_effect, + PageResourceCompletionDocumentEffect::DiscardedStaleOwner { .. } + ), + replace_realm + ); + let events = page_vm + .vm_mut() + .drain_pre_domcontentloaded_content_security_policy_violation_tasks_for_test(); + assert_eq!(events, usize::from(!replace_realm)); + assert_eq!( + page_vm.vm_mut().eval("String(modulepreloadCspEvents)")?, + if replace_realm { "0" } else { "1" } + ); + let report = tokio::time::timeout(Duration::from_secs(5), report_rx).await??; + assert!(report.starts_with("POST /csp-report HTTP/1.1"), "{report}"); + let body = report.split_once("\r\n\r\n").expect("report body").1; + let body: serde_json::Value = serde_json::from_str(body)?; + assert_eq!(body["csp-report"]["blocked-uri"], blocked_url.as_str()); + assert_eq!(body["csp-report"]["effective-directive"], "script-src-elem"); + report_server.await?; + } + anyhow::Ok(()) + }) + .await + .expect("modulepreload CSP source realm regression"); +} + +#[tokio::test(flavor = "current_thread")] +async fn response_modulepreload_redirect_guard_does_not_retain_its_document_fetch_context() { + run_page_vm_async_test(async move { + let mut page_vm = test_page_vm_with_document_url(Url::parse( + "https://modulepreload-redirect-context.test/page.html", + )?); + page_vm + .vm_mut() + .set_response_content_security_policies(&["script-src 'self'".to_owned()]); + let context = page_vm + .vm_mut() + .capture_module_fetch_context( + crate::native_bridge::OwnerDispatchScope::Top, + crate::module_runtime::ModuleKind::JavaScript, + &crate::module_runtime::ModuleFetchMetadata::default(), + ) + .map_err(anyhow::Error::msg)?; + let source = Url::parse("https://modulepreload-redirect-context.test/module.js")?; + let guard = context + .redirect_check(&source) + .expect("captured CSP requires a redirect guard"); + let weak = Arc::downgrade(&context); + drop(context); + assert!( + weak.upgrade().is_none(), + "a retained SW redirect guard must not keep the Document/browser fetch context alive" + ); + let request = moli_fetch::Request::get(source.as_str())?.with_redirect_check(guard); + assert!( + request + .check_redirect_target(&Url::parse( + "https://modulepreload-redirect-context.test/allowed.js" + )?) + .is_ok() + ); + assert!( + request + .check_redirect_target(&Url::parse("https://other.test/blocked.js")?) + .is_err() + ); + anyhow::Ok(()) + }) + .await + .expect("modulepreload redirect guard ownership regression"); +} diff --git a/moli-renderer-v8/src/script_vm/child_module_fetch.rs b/moli-renderer-v8/src/script_vm/child_module_fetch.rs index 1be064bdcbe..1ac6f6aa5c0 100644 --- a/moli-renderer-v8/src/script_vm/child_module_fetch.rs +++ b/moli-renderer-v8/src/script_vm/child_module_fetch.rs @@ -360,12 +360,14 @@ impl<'vm> ChildModuleFetchOwner<'vm> { &mut self, completion: ChildModulepreloadFetchCompletion, ) -> FrameDocumentModuleTerminalQueueFollowup { + let policy_checked = completion.fetch_context().is_some(); let (target, load_id, result) = completion.into_module_terminal_parts(); self.finish_modulepreload_fetch_completion( target.task_owner(), target.realm_id(), load_id, result, + policy_checked, ) } @@ -375,6 +377,7 @@ impl<'vm> ChildModuleFetchOwner<'vm> { realm_id: FrameRealmId, load_id: u64, result: std::result::Result, + _policy_checked: bool, ) -> FrameDocumentModuleTerminalQueueFollowup { let owner = task_owner.document_owner(); let Some(request) = self @@ -457,7 +460,7 @@ impl FrameDocumentModulepreloadStartActionHooks for ScriptVmChildModulepreloadSt fn schedule_modulepreload_fetch( &mut self, target: ChildDocumentModuleFetchTarget, - link_handle: DomHandle, + link_handle: Option, key: ModuleMapKey, load_id: u64, request: Box, @@ -505,8 +508,31 @@ impl FrameDocumentModulepreloadStartActionHooks for ScriptVmChildModulepreloadSt .send_child_modulepreload_fetch(completion); return; }; + let context = match self.vm.capture_module_fetch_context( + crate::native_bridge::OwnerDispatchScope::Child(target.child_handle()), + request.module_kind(), + request.fetch_metadata(), + ) { + Ok(context) => context, + Err(error) => { + let _ = self + .vm + ._context_host + .borrow() + .resource_completion_sender() + .send_child_modulepreload_fetch(ChildModulepreloadFetchCompletion::new( + target, + load_id, + Err(error.clone()), + Some(std::sync::Arc::new(Err(error))), + network_attribution, + )); + return; + } + }; self.vm .resource_scheduler() + .with_module_fetch_context(context) .schedule_child_modulepreload_graph_fetch( loader, target, @@ -527,7 +553,7 @@ impl FrameDocumentModulepreloadStartActionHooks for ScriptVmChildModulepreloadSt &mut self, owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: &ModuleMapKey, ) { tracing::debug!( @@ -543,7 +569,7 @@ impl FrameDocumentModulepreloadStartActionHooks for ScriptVmChildModulepreloadSt &mut self, owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: &ModuleMapKey, ) { tracing::debug!( @@ -559,7 +585,7 @@ impl FrameDocumentModulepreloadStartActionHooks for ScriptVmChildModulepreloadSt &mut self, owner: FrameDocumentOwner, realm_id: FrameRealmId, - link_handle: DomHandle, + link_handle: Option, key: &ModuleMapKey, ) { tracing::debug!( diff --git a/moli-renderer-v8/src/script_vm/native_module.rs b/moli-renderer-v8/src/script_vm/native_module.rs index 1e7b0818f31..c3a90601061 100644 --- a/moli-renderer-v8/src/script_vm/native_module.rs +++ b/moli-renderer-v8/src/script_vm/native_module.rs @@ -83,6 +83,7 @@ use crate::wasm_module_support::{ mod child_dynamic_import; mod document_scripts; +mod fetch_context; mod module_fetch; mod module_graph; mod module_reactions; diff --git a/moli-renderer-v8/src/script_vm/native_module/document_scripts.rs b/moli-renderer-v8/src/script_vm/native_module/document_scripts.rs index a67dec423bd..ad343c75680 100644 --- a/moli-renderer-v8/src/script_vm/native_module/document_scripts.rs +++ b/moli-renderer-v8/src/script_vm/native_module/document_scripts.rs @@ -614,10 +614,20 @@ impl ScriptVm { )); Ok(()) } + #[cfg(test)] pub(super) fn apply_main_modulepreload_fetch_result( &mut self, load_id: u64, result: std::result::Result, + ) -> Result> { + self.apply_main_modulepreload_fetch_result_with_policy(load_id, result, false) + } + + fn apply_main_modulepreload_fetch_result_with_policy( + &mut self, + load_id: u64, + result: std::result::Result, + _policy_checked: bool, ) -> Result> { let Some(preload) = self .document_runtime @@ -660,12 +670,17 @@ impl ScriptVm { ) -> Result<()> { let completion = authorization.into_completion(); let target = completion.target(); - self.apply_main_modulepreload_fetch_result(target.load_id(), completion.into_result())? - .ok_or_else(|| { - anyhow::anyhow!( - "authorized main modulepreload terminal lost its exact in-flight request" - ) - })?; + let policy_checked = completion.fetch_context().is_some(); + self.apply_main_modulepreload_fetch_result_with_policy( + target.load_id(), + completion.into_result(), + policy_checked, + )? + .ok_or_else(|| { + anyhow::anyhow!( + "authorized main modulepreload terminal lost its exact in-flight request" + ) + })?; Ok(()) } pub(crate) fn accept_main_parser_async_module_script( diff --git a/moli-renderer-v8/src/script_vm/native_module/fetch_context.rs b/moli-renderer-v8/src/script_vm/native_module/fetch_context.rs new file mode 100644 index 00000000000..8c143518724 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/native_module/fetch_context.rs @@ -0,0 +1,41 @@ +use crate::{ + module_runtime::{ModuleFetchMetadata, ModuleKind, NativeModuleFetchContext}, + native_bridge::OwnerDispatchScope, +}; +use std::sync::Arc; + +impl crate::script_vm::ScriptVm { + pub(crate) fn capture_module_fetch_context( + &mut self, + owner: OwnerDispatchScope, + kind: ModuleKind, + metadata: &ModuleFetchMetadata, + ) -> Result, String> { + self.with_default_context_scope(|scope, host_ptr| { + NativeModuleFetchContext::capture( + scope, + unsafe { &mut *host_ptr }, + owner, + kind, + metadata, + ) + .ok_or_else(|| anyhow::anyhow!("modulepreload lost its exact Document fetch context")) + }) + .map_err(|error| error.to_string()) + } + + pub(crate) fn report_module_fetch_context( + &mut self, + context: &NativeModuleFetchContext, + dispatch_dom_events: bool, + ) { + if let Err(error) = self.with_default_context_scope(|scope, host_ptr| { + context.report_violations(scope, unsafe { &mut *host_ptr }, dispatch_dom_events); + Ok(()) + }) { + self.record_runtime_warning(format_args!( + "modulepreload CSP reporting failed: {error}" + )); + } + } +} diff --git a/moli-renderer-v8/src/script_vm/native_module/module_fetch.rs b/moli-renderer-v8/src/script_vm/native_module/module_fetch.rs index f9f0ad6de37..67ec3c4d99b 100644 --- a/moli-renderer-v8/src/script_vm/native_module/module_fetch.rs +++ b/moli-renderer-v8/src/script_vm/native_module/module_fetch.rs @@ -237,7 +237,12 @@ impl ScriptVm { let document_owner = self.current_main_document_task_owner().ok_or_else(|| { "main modulepreload fetch started without a current Document owner".to_owned() })?; - let resource_scheduler = self.resource_scheduler(); + let context = self.capture_module_fetch_context( + crate::native_bridge::OwnerDispatchScope::Top, + request.module_key().kind(), + request.fetch_metadata(), + )?; + let resource_scheduler = self.resource_scheduler().with_module_fetch_context(context); let outcome = self .document_runtime .start_main_document_modulepreload_fetch(document_owner, &resource_scheduler, request) @@ -252,7 +257,12 @@ impl ScriptVm { let document_owner = self.current_main_document_task_owner().ok_or_else(|| { "main modulepreload fetch started without a current Document owner".to_owned() })?; - let resource_scheduler = self.resource_scheduler(); + let context = self.capture_module_fetch_context( + crate::native_bridge::OwnerDispatchScope::Top, + request.module_key().kind(), + request.fetch_metadata(), + )?; + let resource_scheduler = self.resource_scheduler().with_module_fetch_context(context); let outcome = self .document_runtime .start_main_document_modulepreload_link_fetch( @@ -753,6 +763,7 @@ impl ScriptVm { document_url: Url, request_url: Url, network_result: &std::result::Result, + native_entry: Option, ) { self._context_host .borrow_mut() @@ -764,7 +775,11 @@ impl ScriptVm { SubresourceRequestInitiatorType::Parser, network_result, ); - self.record_modulepreload_resource_performance_entry(&request_url, network_result); + if let Some(entry) = native_entry { + self.record_modulepreload_performance_entry(entry); + } else { + self.record_modulepreload_resource_performance_entry(&request_url, network_result); + } } pub(crate) fn record_historical_main_modulepreload_network_result( &mut self, @@ -791,17 +806,24 @@ impl ScriptVm { let performance_entry = crate::context_bootstrap::ResourcePerformanceEntry::from_network_result( request_url.as_str(), - "link", + "script", None, network_result, ); + self.record_modulepreload_performance_entry(performance_entry); + } + + fn record_modulepreload_performance_entry( + &mut self, + performance_entry: crate::context_bootstrap::ResourcePerformanceEntry, + ) { if let Err(error) = self.with_default_context_scope(|scope, _host_ptr| { crate::context_bootstrap::record_resource_performance_entry(scope, performance_entry); Ok(()) }) { self.record_runtime_warning(format_args!( - "failed to record native modulepreload performance entry for `{}`: {}", - request_url, error + "failed to record native modulepreload performance entry: {}", + error )); } } diff --git a/moli-renderer-v8/src/script_vm/response_links.rs b/moli-renderer-v8/src/script_vm/response_links.rs index 393baea631d..c33f19a3d51 100644 --- a/moli-renderer-v8/src/script_vm/response_links.rs +++ b/moli-renderer-v8/src/script_vm/response_links.rs @@ -5,18 +5,40 @@ impl ScriptVm { &mut self, links: &crate::response_links::DocumentResponseLinks, ) -> Result<()> { - if links.dictionaries.is_empty() && links.scripts.is_empty() { + if links.dictionaries.is_empty() && links.scripts.is_empty() && links.modules.is_empty() { return Ok(()); } - self.with_default_context_scope(|scope, host_ptr| { - let host = unsafe { &mut *host_ptr }; - if let Some(target) = host.current_window_document_task_target_for_dispatch_scope( - crate::native_bridge::OwnerDispatchScope::Top, - ) { - crate::network_host::start_document_response_links(scope, host, target, links); + let owner = self.current_main_document_task_owner(); + let (scripting_enabled, referrer_policy) = + self.with_default_context_scope(|scope, host_ptr| { + let host = unsafe { &mut *host_ptr }; + let dispatch_scope = crate::native_bridge::OwnerDispatchScope::Top; + let scripting_enabled = host.owner_scripting_enabled(dispatch_scope); + let referrer_policy = + host.document_response_preload_referrer_policy(dispatch_scope); + if let Some(target) = + host.current_window_document_task_target_for_dispatch_scope(dispatch_scope) + { + crate::network_host::start_document_response_links(scope, host, target, links); + } + Ok((scripting_enabled, referrer_policy)) + })?; + if !scripting_enabled || owner.is_none() { + return Ok(()); + } + for preload in &links.modules { + if self.current_main_document_task_owner() != owner { + break; } - Ok(()) - }) + if let Some(candidate) = preload.fetch_candidate( + self.document_runtime.document_url(), + referrer_policy.clone(), + ) && let Err(error) = self.register_native_modulepreload_for_owner(candidate.request) + { + tracing::debug!(url = %preload.url, error, "response modulepreload was not loaded"); + } + } + Ok(()) } #[cfg(all(test, feature = "devtools"))] diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/document_completion.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/document_completion.rs index 69963fa3c0b..e00e4fc5f90 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/document_completion.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/document_completion.rs @@ -245,8 +245,10 @@ impl ScriptVm { } pub(crate) fn record_current_child_module_fetch_network_result( &mut self, + target: crate::frame_owner_model::ChildDocumentModuleFetchTarget, attribution: &crate::types::ChildModuleFetchNetworkAttribution, network_result: Option<&crate::types::SharedNavigationResponseResult>, + native_entry: Option, ) -> bool { let Some(network_result) = network_result else { return false; @@ -254,6 +256,29 @@ impl ScriptVm { self._context_host .borrow_mut() .record_current_child_module_fetch_network_result(attribution, network_result.as_ref()); + let entry = native_entry.unwrap_or_else(|| { + crate::context_bootstrap::ResourcePerformanceEntry::from_network_result( + attribution.request_url().as_str(), + "script", + None, + network_result.as_ref(), + ) + }); + if let Err(error) = self.with_default_context_scope(|scope, host_ptr| { + unsafe { &mut *host_ptr }.record_document_resource_timing( + scope, + crate::native_bridge::WindowDocumentTaskTarget::new( + crate::native_bridge::WindowDocumentOwner::Frame(target.task_owner()), + crate::native_bridge::OwnerDispatchScope::Child(target.child_handle()), + ), + entry, + ); + Ok(()) + }) { + self.record_runtime_warning(format_args!( + "failed to record child module resource timing: {error}" + )); + } true } pub(crate) fn record_historical_child_module_fetch_network_result( diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs index 6eb4bf6350f..ce6d41b5277 100644 --- a/moli-renderer-v8/src/types.rs +++ b/moli-renderer-v8/src/types.rs @@ -1851,6 +1851,7 @@ pub(super) struct ChildModulepreloadFetchCompletion { result: std::result::Result, network_result: Option, network_attribution: ChildModuleFetchNetworkAttribution, + fetch_context: Option>, } impl ChildModulepreloadFetchCompletion { @@ -1867,9 +1868,24 @@ impl ChildModulepreloadFetchCompletion { result, network_result, network_attribution, + fetch_context: None, } } + pub(crate) fn with_fetch_context( + mut self, + context: Option>, + ) -> Self { + self.fetch_context = context; + self + } + + pub(crate) fn fetch_context( + &self, + ) -> Option<&std::sync::Arc> { + self.fetch_context.as_ref() + } + pub(super) fn target(&self) -> crate::frame_owner_model::ChildDocumentModuleFetchTarget { self.target }