diff --git a/moli-core/src/network/mod.rs b/moli-core/src/network/mod.rs index 02088eb8145..a28d09671e1 100644 --- a/moli-core/src/network/mod.rs +++ b/moli-core/src/network/mod.rs @@ -12,5 +12,6 @@ pub use moli_renderer_v8::network::{ }; pub use moli_renderer_v8::network::{ - ResourceInterceptionBody, ResourceInterceptionPause, ResourceInterceptionReply, + ResourceInterceptionBody, ResourceInterceptionEvent, ResourceInterceptionPause, + ResourceInterceptionPolicy, ResourceInterceptionReply, }; diff --git a/moli-core/src/page/resource_command.rs b/moli-core/src/page/resource_command.rs index 08d21415fae..dd63c015822 100644 --- a/moli-core/src/page/resource_command.rs +++ b/moli-core/src/page/resource_command.rs @@ -91,6 +91,12 @@ impl super::PageDocumentCommandTarget { } } + pub fn observes_worker_network(&self) -> bool { + self.network_pause + .as_ref() + .is_some_and(ResourceInterceptionPause::observes_worker_network) + } + pub fn has_native_network_pause(&self) -> bool { self.network_pause.is_some() } diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs index dc996cc649e..3799efcbe27 100644 --- a/moli-protocol/src/conn.rs +++ b/moli-protocol/src/conn.rs @@ -855,6 +855,12 @@ impl ConnectionNetworkRequestIdAllocator { self.next_sequence } + pub(crate) fn request_id_for_native( + &mut self, + handle: moli_core::page::SubresourceNetworkRequestHandle, + ) -> String { + format!("REQ-native-{}", handle.get()) + } pub(crate) fn allocate_request_id(&mut self) -> String { format!("REQ-{}", self.allocate_sequence()) } diff --git a/moli-protocol/src/conn/browser_context/fetch_owner.rs b/moli-protocol/src/conn/browser_context/fetch_owner.rs index ea6b665c754..e54c110a3ea 100644 --- a/moli-protocol/src/conn/browser_context/fetch_owner.rs +++ b/moli-protocol/src/conn/browser_context/fetch_owner.rs @@ -101,6 +101,14 @@ fn fetch_body_stream_owner_for_target_mut<'a>( target_id: &str, ) -> Option> { let owner_key = fetch_stream_owner_key(&browser_context.id, target_id); + if browser_context.worker_resource_target(target_id).is_some() { + let target = browser_context.worker_resource_target_mut(target_id)?; + return Some(SessionFetchBodyStreamOwner { + owner_key, + fetch_owner: &mut target.fetch_owner, + runtime_slot: &mut target.runtime_slot, + }); + } let active_target = browser_context.page_target_mut(target_id)?; Some(SessionFetchBodyStreamOwner { owner_key, @@ -113,6 +121,13 @@ fn runtime_slot_for_target_scoped_stream_mut<'a>( browser_context: &'a mut BrowserContext, target_id: &str, ) -> Option<&'a mut TargetRuntimeSlot> { + if browser_context.worker_resource_target(target_id).is_some() { + return Some( + &mut browser_context + .worker_resource_target_mut(target_id)? + .runtime_slot, + ); + } browser_context .page_target_mut(target_id) .map(|target| &mut target.runtime_slot) @@ -124,6 +139,19 @@ impl TargetSessionOwnerMut<'_> { body: impl Into, ) -> Result { let owner_key = fetch_stream_owner_key(&self.browser_context.id, &self.target_id); + if let Some(target) = self + .browser_context + .worker_resource_target_mut(&self.target_id) + { + let handle = target_scoped_stream_handle( + &owner_key, + target.runtime_slot.allocate_io_stream_handle(), + ); + target + .runtime_slot + .insert_io_stream_body_source(handle.clone(), body, 0); + return Ok(handle); + } let Some(target) = self.browser_context.page_target_mut(&self.target_id) else { return Err(crate::conn::NoDocumentLoaded.into()); }; @@ -372,7 +400,7 @@ impl CdpConnection { owner: &CommandOwnerScope, body: impl Into, ) -> Result { - let Some(mut owner) = self.target_session_owner_mut_for_owner(owner) else { + let Some(mut owner) = self.resource_session_owner_mut_for_owner(owner) else { return Err(crate::conn::NoDocumentLoaded.into()); }; owner.open_scoped_io_stream_body_source(body) @@ -441,6 +469,51 @@ impl CdpConnection { .find_map(|browser_context| pending_fetch_request_route(browser_context, request_id)) } + pub(crate) fn subresource_residence_is_current( + &self, + residence: &crate::conn::PendingSubresourceFetchResidence, + ) -> bool { + match residence { + crate::conn::PendingSubresourceFetchResidence::Worker { + browser_context_id, + target_id, + .. + } => self + .browser_context_by_id(browser_context_id) + .and_then(|context| context.worker_resource_target(target_id)) + .is_some(), + _ => residence.page_owner().is_none_or(|page| { + self.subresource_document_is_current(page, residence.source_document()) + }), + } + } + pub(crate) fn start_subresource_command( + &self, + owner: &CommandOwnerScope, + residence: &crate::conn::PendingSubresourceFetchResidence, + command: moli_core::RendererPageCommand, + ) -> Result { + if let crate::conn::PendingSubresourceFetchResidence::Worker { + browser_context_id, + target_id, + .. + } = residence + { + anyhow::ensure!( + self.worker_resource_identity_for_owner(owner).as_ref() + == Some(&(browser_context_id.clone(), target_id.clone())), + "RequestNotFound" + ); + return residence.start_resource_command(command); + } + self.start_subresource_document_command( + owner, + residence.page_owner().context(SubresourceRequestNotFound)?, + residence.document_command_target(), + command, + ) + } + pub(crate) fn start_subresource_document_command( &self, owner: &CommandOwnerScope, @@ -489,22 +562,26 @@ impl CdpConnection { &self, pending: &PendingSubresourceFetchRequest, ) -> bool { - pending.page_owner().is_none_or(|page| { - self.subresource_document_is_current(page, pending.source_document()) - }) + self.subresource_residence_is_current(&pending.residence) } pub(crate) fn claim_subresource_continue_request_for_owner( &mut self, owner: &CommandOwnerScope, - expected_page_owner: &crate::conn::TargetPageResidenceIdentity, + expected_page_owner: Option<&crate::conn::TargetPageResidenceIdentity>, internal_id: u64, allow_pending_completion: bool, ) -> Option { - if !self.target_page_output_residence_is_current(expected_page_owner) { + if expected_page_owner + .is_some_and(|page| !self.target_page_output_residence_is_current(page)) + { return None; } - self.target_session_owner_mut_for_owner(owner)? + if expected_page_owner.is_none() && self.worker_resource_identity_for_owner(owner).is_none() + { + return None; + } + self.resource_session_owner_mut_for_owner(owner)? .claim_subresource_continue_request( expected_page_owner, internal_id, @@ -518,7 +595,7 @@ impl CdpConnection { owner: &CommandOwnerScope, request_id: &str, ) -> Option> { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .consume_pending_request_action(request_id) } @@ -528,7 +605,7 @@ impl CdpConnection { action_session_id: Option<&str>, request_id: &str, ) -> Option { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .take_pending_fetch_navigation_for_action_session(request_id, action_session_id) } @@ -538,7 +615,7 @@ impl CdpConnection { action_session_id: Option<&str>, request_id: &str, ) -> Option { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .take_pending_fetch_auth_navigation_for_action_session(request_id, action_session_id) } @@ -558,7 +635,7 @@ impl CdpConnection { request_id: String, pending: PendingFetchAuthNavigation, ) -> bool { - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_pending_fetch_auth_navigation(request_id, pending) }) @@ -569,7 +646,7 @@ impl CdpConnection { owner: &CommandOwnerScope, request_id: &str, ) -> Option { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .take_fetch_response_transfer_for_cancellation(request_id) } @@ -578,7 +655,7 @@ impl CdpConnection { owner: &CommandOwnerScope, request_id: &str, ) -> Option { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .pending_fetch_owner_mut()? .start_pending_fetch_response_body_read(request_id) } @@ -588,7 +665,7 @@ impl CdpConnection { owner: &CommandOwnerScope, request_id: &str, ) -> Option { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .take_available_fetch_response_transfer(request_id) } @@ -598,7 +675,7 @@ impl CdpConnection { request_id: String, transfer: PausedDocumentTransfer, ) -> bool { - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_pending_fetch_response_transfer(request_id, transfer) }) @@ -609,7 +686,7 @@ impl CdpConnection { owner: &CommandOwnerScope, completed: crate::conn::CompletedDocumentBodyRead, ) -> Option> { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .pending_fetch_owner_mut()? .finish_pending_fetch_response_body_read(completed) } @@ -620,7 +697,7 @@ impl CdpConnection { action_session_id: Option<&str>, request_id: &str, ) -> Option { - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .pending_subresource_fetch_response_request(request_id, action_session_id) } @@ -630,7 +707,7 @@ impl CdpConnection { action_session_id: Option<&str>, request_id: &str, ) -> bool { - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.mark_pending_subresource_fetch_response_body_taken_as_stream( request_id, @@ -644,7 +721,7 @@ impl CdpConnection { session_id: Option<&str>, request_id: &str, ) -> Result> { - let Some(mut owner) = self.target_session_owner_mut(session_id) else { + let Some(mut owner) = self.resource_session_owner_mut(session_id) else { return Ok(None); }; owner.open_pending_fetch_response_body_stream(request_id) @@ -657,7 +734,7 @@ impl CdpConnection { offset: Option, size: Option, ) -> PendingFetchResponseBodyStreamReadStart { - let Some(mut owner) = self.target_session_owner_mut(session_id) else { + let Some(mut owner) = self.resource_session_owner_mut(session_id) else { return PendingFetchResponseBodyStreamReadStart::NotFound; }; owner.start_pending_fetch_response_body_stream_read(handle, offset, size) @@ -696,7 +773,7 @@ impl CdpConnection { session_id: Option<&str>, completed: CompletedFetchResponseBodyStreamReadDispatch, ) -> PendingFetchResponseBodyStreamRead { - let Some(mut owner) = self.target_session_owner_mut(session_id) else { + let Some(mut owner) = self.resource_session_owner_mut(session_id) else { return PendingFetchResponseBodyStreamRead::NotFound; }; owner.finish_pending_fetch_response_body_stream_read(completed) @@ -734,7 +811,7 @@ impl CdpConnection { session_id: Option<&str>, handle: &str, ) -> bool { - self.target_session_owner_mut(session_id) + self.resource_session_owner_mut(session_id) .is_some_and(|mut owner| owner.close_pending_fetch_response_body_stream(handle)) } @@ -788,7 +865,7 @@ impl CdpConnection { request_id: &str, ) -> Option { let pending = self - .target_session_owner_mut(session_id)? + .resource_session_owner_mut(session_id)? .take_pending_subresource_fetch_request(request_id, session_id)?; self.pending_subresource_fetch_request_residence_is_current(&pending) .then_some(pending) @@ -801,7 +878,7 @@ impl CdpConnection { request_id: &str, ) -> Option { let pending = self - .target_session_owner_mut_for_owner(owner)? + .resource_session_owner_mut_for_owner(owner)? .take_pending_subresource_fetch_request(request_id, action_session_id)?; self.pending_subresource_fetch_request_residence_is_current(&pending) .then_some(pending) @@ -814,9 +891,9 @@ impl CdpConnection { request_id: &str, ) -> Option { let pending = self - .target_session_owner_mut_for_owner(owner)? + .resource_session_owner_mut_for_owner(owner)? .take_pending_subresource_fetch_auth_request(request_id, action_session_id)?; - self.subresource_document_is_current(&pending.page_owner, pending.source_document()) + self.subresource_residence_is_current(&pending.residence) .then_some(pending) } @@ -827,9 +904,9 @@ impl CdpConnection { request_id: &str, ) -> Option { let pending = self - .target_session_owner_mut_for_owner(owner)? + .resource_session_owner_mut_for_owner(owner)? .take_pending_subresource_fetch_response_request(request_id, action_session_id)?; - self.subresource_document_is_current(&pending.page_owner, pending.source_document()) + self.subresource_residence_is_current(&pending.residence) .then_some(pending) } @@ -839,7 +916,7 @@ impl CdpConnection { internal_id: u64, network_request_id: &str, ) { - if let Some(mut owner) = self.target_session_owner_mut_for_owner(owner) + if let Some(mut owner) = self.resource_session_owner_mut_for_owner(owner) && let Some(mut fetch) = owner.pending_fetch_owner_mut() { fetch.rollback_in_flight_subresource_fetch_request(internal_id, network_request_id); @@ -852,7 +929,7 @@ impl CdpConnection { internal_id: u64, ) -> Option { let (request_id, page_owner) = self - .target_session_owner_mut_for_owner(owner)? + .resource_session_owner_mut_for_owner(owner)? .in_flight_subresource_fetch_request_identity(internal_id)?; self.target_page_residence_identity_is_current(&page_owner) .then_some(request_id) @@ -865,7 +942,7 @@ impl CdpConnection { ) -> Option { let request_id = self.in_flight_subresource_fetch_request_id_for_owner(owner, internal_id)?; - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .subresource_response_is_paused(&request_id) .then_some(request_id) } @@ -890,7 +967,7 @@ impl CdpConnection { return false; } self.record_pending_subresource_network_request_identity_for_owner(owner, &pending); - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_pending_subresource_fetch_request(request_id, pending) }) @@ -906,7 +983,7 @@ impl CdpConnection { return false; } self.record_pending_subresource_network_request_identity_for_owner(owner, &pending); - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_in_flight_subresource_fetch_request(request_id, pending) }) @@ -923,7 +1000,7 @@ impl CdpConnection { return false; } self.record_pending_subresource_network_request_identity_for_owner(owner, &pending); - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_in_flight_response_stage_subresource_fetch_request( request_id, @@ -944,7 +1021,7 @@ impl CdpConnection { return false; } self.record_pending_subresource_network_request_identity_for_owner(owner, &pending); - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_in_flight_subresource_fetch_request_with_response_match_policy( request_id, @@ -970,11 +1047,11 @@ impl CdpConnection { request_id: String, pending: PendingSubresourceFetchAuthRequest, ) -> bool { - if !self.subresource_document_is_current(&pending.page_owner, pending.source_document()) { + if !self.subresource_residence_is_current(&pending.residence) { return false; } self.record_pending_subresource_auth_network_request_identity_for_owner(owner, &pending); - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_pending_subresource_fetch_auth_request(request_id, pending) }) @@ -998,13 +1075,13 @@ impl CdpConnection { request_id: String, pending: PendingSubresourceFetchResponseRequest, ) -> bool { - if !self.subresource_document_is_current(&pending.page_owner, pending.source_document()) { + if !self.subresource_residence_is_current(&pending.residence) { return false; } self.record_pending_subresource_response_network_request_identity_for_owner( owner, &pending, ); - self.target_session_owner_mut_for_owner(owner) + self.resource_session_owner_mut_for_owner(owner) .is_some_and(|mut owner| { owner.register_pending_subresource_fetch_response_request(request_id, pending) }) @@ -1079,7 +1156,22 @@ impl CdpConnection { handle_auth_requests: bool, patterns: Vec, ) -> Result> { - let Some(mut owner) = self.target_session_owner_mut_for_owner(command_owner) else { + if let Some((context, target)) = self.worker_resource_identity_for_owner(command_owner) { + let worker = self + .browser_context_by_id_mut(&context) + .and_then(|context| context.worker_resource_target_mut(&target)) + .context("Worker target closed")?; + worker.fetch_owner.configure( + command_owner.session_id().map(str::to_owned), + handle_auth_requests, + patterns, + ); + if let Some(policy) = &worker.interception_policy { + policy.set_interception(worker.fetch_owner.subresource_interception_config()); + } + return Ok(None); + } + let Some(mut owner) = self.resource_session_owner_mut_for_owner(command_owner) else { return Err(crate::conn::BrowserContextNotLoaded.into()); }; let subresource_classes = owner.configure_fetch( @@ -1109,7 +1201,7 @@ impl CdpConnection { auth_url_patterns: Vec, patterns: Vec, ) -> Result> { - let Some(mut owner) = self.target_session_owner_mut_for_owner(command_owner) else { + let Some(mut owner) = self.resource_session_owner_mut_for_owner(command_owner) else { return Err(crate::conn::BrowserContextNotLoaded.into()); }; let subresource_classes = owner.add_network_intercept( @@ -1137,7 +1229,7 @@ impl CdpConnection { intercept_id: &str, allow_global_lookup: bool, ) -> Result> { - let Some(mut owner) = self.target_session_owner_mut_for_owner(command_owner) else { + let Some(mut owner) = self.resource_session_owner_mut_for_owner(command_owner) else { return Err(crate::conn::BrowserContextNotLoaded.into()); }; let Some(subresource_classes) = owner.remove_network_intercept(intercept_id) else { @@ -1197,7 +1289,7 @@ impl CdpConnection { Option>, )> { let (pending, classes, update_required) = self - .target_session_owner_mut_for_owner(command_owner)? + .resource_session_owner_mut_for_owner(command_owner)? .reset_fetch_config_for_session_and_drain_pending_state(command_owner.session_id()); let policy = self.start_fetch_cleanup_policy(command_owner, update_required, &pending, classes); @@ -1212,7 +1304,7 @@ impl CdpConnection { Option>, )> { let (pending, classes, update_required) = self - .target_session_owner_mut_for_owner(command_owner)? + .resource_session_owner_mut_for_owner(command_owner)? .disable_target_fetch_and_drain_pending_state(); let policy = self.start_fetch_cleanup_policy(command_owner, update_required, &pending, classes); @@ -1229,6 +1321,17 @@ impl CdpConnection { if !update_required { return None; } + if let Some((context, target)) = self.worker_resource_identity_for_owner(owner) { + if let Some(policy) = self + .browser_context_by_id(&context)? + .worker_resource_target(&target)? + .interception_policy + .as_ref() + { + policy.set_interception(classes); + } + return None; + } // A native pause already carries the target's shared eligibility. // Update that fact without queuing an ACK behind another session's // still-paused synchronous load. Legacy Page APIs read this same fact. @@ -1246,11 +1349,11 @@ impl CdpConnection { } for target in auths .iter() - .filter_map(|(_, request)| request.command_target.as_ref()) + .filter_map(|(_, request)| request.residence.document_command_target()) .chain( responses .iter() - .filter_map(|(_, request)| request.command_target.as_ref()), + .filter_map(|(_, request)| request.residence.document_command_target()), ) { native |= target.update_native_interception_policy(classes); @@ -1258,7 +1361,7 @@ impl CdpConnection { if native { return None; } - let target = self.target_session_owner_mut_for_owner(owner)?; + let target = self.resource_session_owner_mut_for_owner(owner)?; target .browser_context .start_page_policy_update( @@ -1274,7 +1377,7 @@ impl CdpConnection { owner: &CommandOwnerScope, ) -> Option { Some( - self.target_session_owner_mut_for_owner(owner)? + self.resource_session_owner_mut_for_owner(owner)? .drain_fetch_pending_state(), ) } @@ -1298,7 +1401,7 @@ impl CdpConnection { owner: &CommandOwnerScope, current: &crate::conn::DocumentNavigationToken, ) -> Vec { - let Some(mut target) = self.target_session_owner_mut_for_owner(owner) else { + let Some(mut target) = self.resource_session_owner_mut_for_owner(owner) else { return Vec::new(); }; let Some(mut fetch) = target.pending_fetch_owner_mut() else { @@ -1345,6 +1448,18 @@ impl TargetSessionOwnerMut<'_> { } fn pending_fetch_owner_mut(&mut self) -> Option> { + if self + .browser_context + .worker_resource_target(&self.target_id) + .is_some() + { + return Some(SessionPendingFetchOwner( + &mut self + .browser_context + .worker_resource_target_mut(&self.target_id)? + .fetch_owner, + )); + } Some(SessionPendingFetchOwner( &mut self .browser_context @@ -1492,7 +1607,7 @@ impl TargetSessionOwnerMut<'_> { fn claim_subresource_continue_request( &mut self, - expected_page_owner: &crate::conn::TargetPageResidenceIdentity, + expected_page_owner: Option<&crate::conn::TargetPageResidenceIdentity>, internal_id: u64, session_id: Option<&str>, allow_pending_completion: bool, diff --git a/moli-protocol/src/conn/browser_context/lifecycle.rs b/moli-protocol/src/conn/browser_context/lifecycle.rs index b26f9329cda..f54ac300240 100644 --- a/moli-protocol/src/conn/browser_context/lifecycle.rs +++ b/moli-protocol/src/conn/browser_context/lifecycle.rs @@ -38,6 +38,11 @@ impl CdpConnection { .set_dedicated_worker_pause_on_start_for_devtools( self.dedicated_worker_pause_on_start_for_devtools(), ); + browser_context + .renderer_runtime() + .set_shared_worker_pause_on_start_for_devtools( + self.shared_worker_pause_on_start_for_devtools(), + ); browser_context.bind_page_navigation_engines( self.standalone_navigation_engine.runtime_config(), self.scheduler_hooks.renderer_publication_sender(), diff --git a/moli-protocol/src/conn/browser_context/mod.rs b/moli-protocol/src/conn/browser_context/mod.rs index 8673f3d5570..a0ef1d1029a 100644 --- a/moli-protocol/src/conn/browser_context/mod.rs +++ b/moli-protocol/src/conn/browser_context/mod.rs @@ -12,6 +12,7 @@ mod page_owner; mod runtime_owner; mod session_owner; mod target_session_owner; +mod worker_resource; pub(crate) use emulation_owner::TargetEmulationStateUpdate; pub(crate) use page_owner::PageLifecycleEventsEnableResult; diff --git a/moli-protocol/src/conn/browser_context/network_owner.rs b/moli-protocol/src/conn/browser_context/network_owner.rs index c07ac8cb6f9..1d58c07383b 100644 --- a/moli-protocol/src/conn/browser_context/network_owner.rs +++ b/moli-protocol/src/conn/browser_context/network_owner.rs @@ -410,7 +410,12 @@ impl CdpConnection { return target.network_enabled(session_id); } if let Some(session_id) = session_id - && let Some(target) = self.dedicated_worker_target_for_session(Some(session_id)) + && let Some(target) = self + .shared_worker_target_for_session(Some(session_id)) + .or_else(|| { + self.dedicated_worker_target_for_session(Some(session_id)) + .map(|target| &target.inner) + }) { return target.network_enabled(session_id); } @@ -538,6 +543,11 @@ impl CdpConnection { { return target.set_network_enabled(session_id, enabled); } + if let Some(session_id) = owner.session_id() + && let Some(target) = self.shared_worker_target_for_session_mut(Some(session_id)) + { + return target.set_network_enabled(session_id, enabled); + } self.with_target_session_owner_mut_for_owner(owner, |resolved| { if enabled { resolved.enable_listener() diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rs index 4d9e303ea46..abd17b186eb 100644 --- a/moli-protocol/src/conn/browser_context/target_session_owner.rs +++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs @@ -806,9 +806,30 @@ impl<'a> TargetSessionOwnerMut<'a> { f(&mut self.target_mut().owner_state) } + fn resource_fetch_owner(&self) -> &crate::conn::state::TargetFetchOwner { + if let Some(target) = self.browser_context.worker_resource_target(&self.target_id) { + &target.fetch_owner + } else { + &self.target().fetch_owner + } + } + fn resource_fetch_owner_mut(&mut self) -> &mut crate::conn::state::TargetFetchOwner { + if self + .browser_context + .worker_resource_target(&self.target_id) + .is_some() + { + &mut self + .browser_context + .worker_resource_target_mut(&self.target_id) + .unwrap() + .fetch_owner + } else { + &mut self.target_mut().fetch_owner + } + } pub(super) fn subresource_response_is_paused(&self, request_id: &str) -> bool { - self.target() - .fetch_owner + self.resource_fetch_owner() .subresource_response_is_paused(request_id) } @@ -859,14 +880,12 @@ impl<'a> TargetSessionOwnerMut<'a> { &mut self, session_id: Option<&str>, ) -> FetchDisableStateWithSubresourceConfig { - let target = self.target_mut(); - let previous_subresource_config = target.fetch_owner.subresource_interception_config(); - let removed = target.fetch_owner.remove_fetch_session(session_id); - let subresource_config = target.fetch_owner.subresource_interception_config(); + let fetch = self.resource_fetch_owner_mut(); + let previous_subresource_config = fetch.subresource_interception_config(); + let removed = fetch.remove_fetch_session(session_id); + let subresource_config = fetch.subresource_interception_config(); let pending = if removed { - target - .fetch_owner - .drain_pending_requests_for_disable_session(session_id) + fetch.drain_pending_requests_for_disable_session(session_id) } else { DrainedFetchRequests::default() }; @@ -877,16 +896,16 @@ impl<'a> TargetSessionOwnerMut<'a> { pub(super) fn disable_target_fetch_and_drain_pending_state( &mut self, ) -> FetchDisableStateWithSubresourceConfig { - let target = self.target_mut(); - let previous = target.fetch_owner.subresource_interception_config(); - target.fetch_owner.reset_config(); - let config = target.fetch_owner.subresource_interception_config(); - let pending = target.fetch_owner.drain_pending_requests(); + let fetch = self.resource_fetch_owner_mut(); + let previous = fetch.subresource_interception_config(); + fetch.reset_config(); + let config = fetch.subresource_interception_config(); + let pending = fetch.drain_pending_requests(); (pending, config, previous != config) } pub(super) fn drain_fetch_pending_state(&mut self) -> DrainedFetchRequests { - self.target_mut().fetch_owner.drain_pending_requests() + self.resource_fetch_owner_mut().drain_pending_requests() } fn take_crashed_page(&mut self) -> Option { @@ -929,6 +948,17 @@ impl<'a> TargetSessionOwnerMut<'a> { } pub(super) fn runtime_slot_mut(&mut self) -> &mut TargetRuntimeSlot { + if self + .browser_context + .worker_resource_target(&self.target_id) + .is_some() + { + return &mut self + .browser_context + .worker_resource_target_mut(&self.target_id) + .unwrap() + .runtime_slot; + } &mut self.target_mut().runtime_slot } @@ -1654,6 +1684,14 @@ impl CdpConnection { &self, owner: &CommandOwnerScope, ) -> Option { + if let Some((context, target)) = self.worker_resource_identity_for_owner(owner) { + return Some( + self.browser_context_by_id(&context)? + .worker_resource_target(&target)? + .fetch_owner + .config_snapshot(), + ); + } Some( self.target_session_owner_ref_for_owner(owner)? .aggregate_fetch_config(), @@ -2413,6 +2451,14 @@ impl CdpConnection { &mut self, owner: &CommandOwnerScope, ) -> Option<&mut TargetRuntimeSlot> { + if let Some((context, target)) = self.worker_resource_identity_for_owner(owner) { + return Some( + &mut self + .browser_context_by_id_mut(&context)? + .worker_resource_target_mut(&target)? + .runtime_slot, + ); + } let renderer_inspector_session_id = self.target_renderer_runtime_inspector_session_id_for_owner(owner); let slot = self @@ -2436,6 +2482,14 @@ impl CdpConnection { &self, owner: &CommandOwnerScope, ) -> Option<&TargetRuntimeSlot> { + if let Some((context, target)) = self.worker_resource_identity_for_owner(owner) { + return Some( + &self + .browser_context_by_id(&context)? + .worker_resource_target(&target)? + .runtime_slot, + ); + } self.target_session_owner_ref_for_owner(owner) .map(|owner| owner.runtime_slot()) } @@ -2452,6 +2506,9 @@ impl CdpConnection { &self, owner: &CommandOwnerScope, ) -> Option { + if self.worker_resource_identity_for_owner(owner).is_some() { + return None; + } self.target_session_owner_ref_for_owner(owner)? .primary_session_id() } diff --git a/moli-protocol/src/conn/browser_context/worker_resource.rs b/moli-protocol/src/conn/browser_context/worker_resource.rs new file mode 100644 index 00000000000..f5350aab3f3 --- /dev/null +++ b/moli-protocol/src/conn/browser_context/worker_resource.rs @@ -0,0 +1,89 @@ +use super::target_session_owner::TargetSessionOwnerMut; +use super::*; +use crate::conn::{CdpConnection, CdpSessionRoute, CommandOwnerScope, SharedWorkerTargetState}; +use moli_page_types::DevToolsSessionKey; + +impl BrowserContext { + pub(crate) fn worker_resource_target(&self, id: &str) -> Option<&SharedWorkerTargetState> { + self.shared_worker_target(id) + .or_else(|| self.dedicated_worker_target(id).map(|target| &target.inner)) + } + pub(crate) fn worker_resource_target_mut( + &mut self, + id: &str, + ) -> Option<&mut SharedWorkerTargetState> { + if self.shared_worker_target(id).is_some() { + return self.shared_worker_target_mut(id); + } + self.dedicated_worker_target_mut(id) + .map(|target| &mut target.inner) + } +} +impl CdpConnection { + pub(crate) fn native_network_request_id( + &mut self, + handle: moli_core::page::SubresourceNetworkRequestHandle, + ) -> String { + self.network_request_id_allocator + .request_id_for_native(handle) + } + pub(crate) fn ingest_worker_network_output( + &mut self, + context: &str, + target: &str, + item: &moli_core::page::ScriptNetworkOutputItem, + ) -> Option { + let mut allocator = std::mem::take(&mut self.network_request_id_allocator); + let delivery = self + .browser_context_by_id_mut(context) + .and_then(|context| context.worker_resource_target_mut(target)) + .map(|target| { + target + .runtime_slot + .ingest_worker_network_output(item, &mut allocator) + }); + self.network_request_id_allocator = allocator; + delivery + } + + pub(crate) fn worker_resource_identity_for_owner( + &self, + owner: &CommandOwnerScope, + ) -> Option<(String, String)> { + let (context, target) = match owner.resolve_route(self)? { + CdpSessionRoute::SharedWorkerTarget { + browser_context_id, + target_id, + } + | CdpSessionRoute::DedicatedWorkerTarget { + browser_context_id, + target_id, + } => (browser_context_id, target_id), + _ => return None, + }; + self.browser_context_by_id(&context)? + .worker_resource_target(&target)?; + Some((context, target)) + } + pub(super) fn resource_session_owner_mut_for_owner( + &mut self, + owner: &CommandOwnerScope, + ) -> Option> { + if let Some((context, target_id)) = self.worker_resource_identity_for_owner(owner) { + return Some(TargetSessionOwnerMut { + browser_context: self.browser_context_by_id_mut(&context)?, + target_id, + command_session_id: owner.session_id().map(str::to_owned), + session_key: DevToolsSessionKey::Primary, + }); + } + self.target_session_owner_mut_for_owner(owner) + } + pub(super) fn resource_session_owner_mut( + &mut self, + session: Option<&str>, + ) -> Option> { + let owner = CommandOwnerScope::capture(self, session); + self.resource_session_owner_mut_for_owner(&owner) + } +} diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rs index 86d21069748..bcf27fce92f 100644 --- a/moli-protocol/src/conn/fetch_support.rs +++ b/moli-protocol/src/conn/fetch_support.rs @@ -1408,6 +1408,12 @@ async fn capture_streaming_raw_response( /// scripts may instead own a one-shot continuation while the Page is built. #[derive(Debug, Clone, PartialEq)] pub(crate) enum PendingSubresourceFetchResidence { + Worker { + browser_context_id: String, + target_id: String, + pause: moli_core::network::ResourceInterceptionPause, + body: Option, + }, Page(super::state::TargetPageResidenceIdentity), Document { page_owner: super::state::TargetPageResidenceIdentity, @@ -1437,10 +1443,81 @@ impl PendingSubresourceFetchRequest { &mut self, body: moli_core::network::ResourceInterceptionBody, ) { - if let PendingSubresourceFetchResidence::Document { command_target, .. } = - &mut self.residence - { - *command_target = command_target.clone().with_response_body(body); + self.residence.bind_response_body(body); + } + pub(crate) fn bind_native_network_pause( + &mut self, + pause: moli_core::network::ResourceInterceptionPause, + ) { + self.residence.bind_native_network_pause(pause); + } + pub(crate) fn page_owner(&self) -> Option<&super::state::TargetPageResidenceIdentity> { + self.residence.page_owner() + } + pub(crate) fn document_command_target( + &self, + ) -> Option<&moli_core::page::PageDocumentCommandTarget> { + self.residence.document_command_target() + } + pub(crate) fn source_document(&self) -> Option { + self.residence.source_document() + } + pub(crate) fn detached_parser_script_fetch_continuation( + &self, + ) -> Option<&DetachedParserScriptFetchContinuation> { + self.residence.detached_parser_script_fetch_continuation() + } +} + +impl PendingSubresourceFetchResidence { + pub(crate) fn observes_worker_network(&self) -> bool { + matches!(self, Self::Worker { .. }) + || self + .document_command_target() + .is_some_and(|target| target.observes_worker_network()) + } + pub(crate) fn native_pause(&self) -> Option<&moli_core::network::ResourceInterceptionPause> { + match self { + Self::Worker { pause, .. } => Some(pause), + _ => None, + } + } + pub(crate) fn native_response_body( + &self, + ) -> Option<&moli_core::network::ResourceInterceptionBody> { + match self { + Self::Worker { body, pause, .. } => body.as_ref().or_else(|| pause.response_body()), + _ => self.document_command_target()?.native_response_body(), + } + } + pub(crate) fn has_native_network_pause(&self) -> bool { + self.native_pause().is_some() + || self + .document_command_target() + .is_some_and(|target| target.has_native_network_pause()) + } + pub(crate) fn start_resource_command( + &self, + command: moli_core::RendererPageCommand, + ) -> anyhow::Result { + match self { + Self::Worker { pause, .. } => Ok(moli_core::page::PendingResourceCommand::Network( + pause.dispatch(command), + )), + Self::Document { command_target, .. } => command_target.start_resource_command(command), + _ => anyhow::bail!("RequestNotFound"), + } + } + pub(crate) fn bind_response_body( + &mut self, + body: moli_core::network::ResourceInterceptionBody, + ) { + match self { + Self::Document { command_target, .. } => { + *command_target = command_target.clone().with_response_body(body) + } + Self::Worker { body: slot, .. } => *slot = Some(body), + _ => {} } } @@ -1448,27 +1525,30 @@ impl PendingSubresourceFetchRequest { &mut self, pause: moli_core::network::ResourceInterceptionPause, ) { - if let PendingSubresourceFetchResidence::Document { command_target, .. } = - &mut self.residence - { - *command_target = command_target.clone().with_network_pause(pause); + match self { + Self::Document { command_target, .. } => { + *command_target = command_target.clone().with_network_pause(pause) + } + Self::Worker { pause: slot, .. } => *slot = pause, + _ => {} } } pub(crate) fn page_owner(&self) -> Option<&super::state::TargetPageResidenceIdentity> { - match &self.residence { + match self { PendingSubresourceFetchResidence::Page(owner) | PendingSubresourceFetchResidence::Document { page_owner: owner, .. } => Some(owner), - PendingSubresourceFetchResidence::DetachedParserScript(_) => None, + PendingSubresourceFetchResidence::DetachedParserScript(_) + | PendingSubresourceFetchResidence::Worker { .. } => None, } } pub(crate) fn document_command_target( &self, ) -> Option<&moli_core::page::PageDocumentCommandTarget> { - match &self.residence { + match self { PendingSubresourceFetchResidence::Document { command_target, .. } => { Some(command_target) } @@ -1477,7 +1557,7 @@ impl PendingSubresourceFetchRequest { } pub(crate) fn source_document(&self) -> Option { - match &self.residence { + match self { PendingSubresourceFetchResidence::Document { command_target, .. } => { Some(command_target.document()) } @@ -1488,8 +1568,9 @@ impl PendingSubresourceFetchRequest { pub(crate) fn detached_parser_script_fetch_continuation( &self, ) -> Option<&DetachedParserScriptFetchContinuation> { - match &self.residence { - PendingSubresourceFetchResidence::Page(_) + match self { + PendingSubresourceFetchResidence::Worker { .. } + | PendingSubresourceFetchResidence::Page(_) | PendingSubresourceFetchResidence::Document { .. } => None, PendingSubresourceFetchResidence::DetachedParserScript(continuation) => { Some(continuation) @@ -1604,8 +1685,7 @@ pub(crate) enum ClaimedSubresourceContinueRequest { #[derive(Debug, Clone)] pub struct PendingSubresourceFetchAuthRequest { /// Page residence that owns the paused renderer authentication request. - pub(crate) page_owner: super::state::TargetPageResidenceIdentity, - pub(crate) command_target: Option, + pub(crate) residence: PendingSubresourceFetchResidence, pub owner_session_id: Option, pub action_session_id: Option, pub owner_kind: PendingSubresourceFetchOwnerKind, @@ -1627,10 +1707,6 @@ pub struct PendingSubresourceFetchAuthRequest { } impl PendingSubresourceFetchAuthRequest { - pub(crate) fn source_document(&self) -> Option { - self.command_target.as_ref().map(|target| target.document()) - } - pub fn pop_next_auth_required_pause(&mut self) -> Option { let chain = self.auth_stage_chain.as_mut()?; let next = chain.remaining_sessions.first().cloned()?; @@ -1659,8 +1735,7 @@ pub struct PendingSubresourceFetchAuthStage { #[derive(Debug, Clone)] pub struct PendingSubresourceFetchResponseRequest { /// Page residence that owns the paused renderer response request. - pub(crate) page_owner: super::state::TargetPageResidenceIdentity, - pub(crate) command_target: Option, + pub(crate) residence: PendingSubresourceFetchResidence, pub owner_session_id: Option, pub action_session_id: Option, pub owner_kind: PendingSubresourceFetchOwnerKind, @@ -1686,10 +1761,6 @@ pub struct PendingSubresourceFetchResponseRequest { } impl PendingSubresourceFetchResponseRequest { - pub(crate) fn source_document(&self) -> Option { - self.command_target.as_ref().map(|target| target.document()) - } - pub fn pop_next_response_stage_pause( &mut self, ) -> Option { diff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rs index 886b149909c..38a7772b899 100644 --- a/moli-protocol/src/conn/state/fetch.rs +++ b/moli-protocol/src/conn/state/fetch.rs @@ -752,7 +752,7 @@ impl TargetFetchState { /// owner mismatch a non-consuming observation. pub(crate) fn claim_subresource_continue_request( &mut self, - expected_page_owner: &super::TargetPageResidenceIdentity, + expected_page_owner: Option<&super::TargetPageResidenceIdentity>, internal_id: u64, session_id: Option<&str>, allow_pending_completion: bool, @@ -763,7 +763,8 @@ impl TargetFetchState { for (request_id, _) in self .pending_subresource_fetch_auths .extract_if(|_, pending| { - pending.internal_id == internal_id && &pending.page_owner == expected_page_owner + pending.internal_id == internal_id + && pending.residence.page_owner() == expected_page_owner }) { self.pending_fetch_request_ids.remove(&request_id); @@ -772,7 +773,7 @@ impl TargetFetchState { self.pending_subresource_fetch_responses .extract_if(|_, pending| { pending.internal_id == internal_id - && &pending.page_owner == expected_page_owner + && pending.residence.page_owner() == expected_page_owner }) { self.pending_fetch_request_ids.remove(&request_id); @@ -782,7 +783,7 @@ impl TargetFetchState { .in_flight_subresource_fetches .get(&internal_id) .and_then(|in_flight| in_flight.pending.page_owner()) - == Some(expected_page_owner); + == expected_page_owner; if in_flight_matches { return self .in_flight_subresource_fetches @@ -799,8 +800,8 @@ impl TargetFetchState { .find_map(|(request_id, pending)| { (pending.internal_id == internal_id && Self::pending_action_matches(pending, session_id) - && pending.page_owner() == Some(expected_page_owner)) - .then(|| request_id.clone()) + && pending.page_owner() == expected_page_owner) + .then(|| request_id.clone()) })?; self.take_pending_subresource_fetch_request(&request_id, session_id) .map(ClaimedSubresourceContinueRequest::PendingCompletion) @@ -2137,7 +2138,7 @@ impl TargetFetchOwner { pub(crate) fn claim_subresource_continue_request( &mut self, - expected_page_owner: &super::TargetPageResidenceIdentity, + expected_page_owner: Option<&super::TargetPageResidenceIdentity>, internal_id: u64, session_id: Option<&str>, allow_pending_completion: bool, @@ -2479,8 +2480,7 @@ mod tests { owner_kind: PendingSubresourceFetchOwnerKind, ) -> PendingSubresourceFetchAuthRequest { PendingSubresourceFetchAuthRequest { - command_target: None, - page_owner: test_page_owner(), + residence: crate::conn::PendingSubresourceFetchResidence::Page(test_page_owner()), owner_session_id: owner_session_id.map(str::to_owned), action_session_id: owner_session_id.map(str::to_owned), owner_kind, @@ -2524,8 +2524,7 @@ mod tests { owner_kind: PendingSubresourceFetchOwnerKind, ) -> PendingSubresourceFetchResponseRequest { PendingSubresourceFetchResponseRequest { - command_target: None, - page_owner: test_page_owner(), + residence: crate::conn::PendingSubresourceFetchResidence::Page(test_page_owner()), owner_session_id: owner_session_id.map(str::to_owned), action_session_id: owner_session_id.map(str::to_owned), owner_kind, @@ -2626,10 +2625,10 @@ mod tests { ("other-request", 8, &page, "SID-A"), ] { let mut auth = pending_subresource_auth(internal_id, Some(session)); - auth.page_owner = page.clone(); + auth.residence = crate::conn::PendingSubresourceFetchResidence::Page(page.clone()); fetch.register_pending_subresource_fetch_auth_request(format!("AUTH-{name}"), auth); let mut response = pending_subresource_response(internal_id, Some(session)); - response.page_owner = page.clone(); + response.residence = crate::conn::PendingSubresourceFetchResidence::Page(page.clone()); fetch.register_pending_subresource_fetch_response_request( format!("RESP-{name}"), response, @@ -2638,14 +2637,14 @@ mod tests { assert!( fetch - .claim_subresource_continue_request(&page, 7, Some("SID-A"), false) + .claim_subresource_continue_request(Some(&page), 7, Some("SID-A"), false) .is_none() ); assert_eq!(fetch.pending_fetch_request_ids.len(), 8); assert_eq!(fetch.pending_subresource_fetch_auths.len(), 4); assert_eq!(fetch.pending_subresource_fetch_responses.len(), 4); - let _ = fetch.claim_subresource_continue_request(&page, 7, Some("SID-A"), true); + let _ = fetch.claim_subresource_continue_request(Some(&page), 7, Some("SID-A"), true); assert_eq!(fetch.pending_subresource_fetch_auths.len(), 2); assert_eq!(fetch.pending_subresource_fetch_responses.len(), 2); assert_eq!( @@ -2670,10 +2669,11 @@ mod tests { ); } - let _ = fetch.claim_subresource_continue_request(&page, 7, Some("SID-A"), true); + let _ = fetch.claim_subresource_continue_request(Some(&page), 7, Some("SID-A"), true); assert_eq!(fetch.pending_fetch_request_ids.len(), 4); - let _ = fetch.claim_subresource_continue_request(&replacement, 7, Some("SID-A"), true); - let _ = fetch.claim_subresource_continue_request(&page, 8, Some("SID-A"), true); + let _ = + fetch.claim_subresource_continue_request(Some(&replacement), 7, Some("SID-A"), true); + let _ = fetch.claim_subresource_continue_request(Some(&page), 8, Some("SID-A"), true); assert!(fetch.is_empty()); } diff --git a/moli-protocol/src/conn/state/runtime_slot.rs b/moli-protocol/src/conn/state/runtime_slot.rs index b7d0a2d066c..0e69a986037 100644 --- a/moli-protocol/src/conn/state/runtime_slot.rs +++ b/moli-protocol/src/conn/state/runtime_slot.rs @@ -1079,6 +1079,17 @@ impl TargetRuntimeSlot { page.bind_renderer_agent_attachment(current.id()); } + pub(crate) fn ingest_worker_network_output( + &mut self, + item: &ScriptNetworkOutputItem, + allocator: &mut ConnectionNetworkRequestIdAllocator, + ) -> TargetNetworkBacklogPreparedDelivery { + self.network_agent + .ingest_renderer_output_item_and_prepare_live_delivery( + item, "", None, None, None, allocator, + ) + } + /// Appends one concrete renderer-produced network fact to the protocol /// queue for the exact committed Document that produced it. /// diff --git a/moli-protocol/src/conn/state/shared_worker_target.rs b/moli-protocol/src/conn/state/shared_worker_target.rs index 1cd6c9ed187..88e6baad1ca 100644 --- a/moli-protocol/src/conn/state/shared_worker_target.rs +++ b/moli-protocol/src/conn/state/shared_worker_target.rs @@ -41,6 +41,9 @@ pub(crate) struct SharedWorkerTargetState { pub(crate) renderer_owner_local_host_id: RendererOwnerLocalHostId, pub(crate) renderer_instance_id: SharedWorkerInstanceId, pub(crate) target_id: String, + pub(crate) runtime_slot: super::TargetRuntimeSlot, + pub(crate) fetch_owner: super::TargetFetchOwner, + pub(crate) interception_policy: Option, owner_target_id: Option, sessions: BTreeMap, pub(crate) url: String, @@ -74,6 +77,9 @@ impl SharedWorkerTargetState { name: String, ) -> Self { Self { + runtime_slot: Default::default(), + fetch_owner: Default::default(), + interception_policy: None, renderer_owner_local_host_id, renderer_instance_id, target_id, @@ -307,6 +313,8 @@ impl SharedWorkerTargetState { } pub(crate) fn detach_session(&mut self, session_id: &str) -> Option { + self.runtime_slot + .remove_attached_network_session(session_id); self.sessions .remove(session_id) .map(|_| session_id.to_owned()) @@ -373,6 +381,12 @@ impl SharedWorkerTargetState { } pub(crate) fn set_network_enabled(&mut self, session_id: &str, enabled: bool) -> bool { + if enabled { + self.runtime_slot.enable_attached_network_events(session_id); + } else { + self.runtime_slot + .disable_attached_network_events(session_id); + } let Some(state) = self.session_state_mut(session_id) else { return false; }; diff --git a/moli-protocol/src/conn/state_access/direct/projection_tests.rs b/moli-protocol/src/conn/state_access/direct/projection_tests.rs index 81e9c7d2f30..d7d03571e91 100644 --- a/moli-protocol/src/conn/state_access/direct/projection_tests.rs +++ b/moli-protocol/src/conn/state_access/direct/projection_tests.rs @@ -38,6 +38,7 @@ fn fixture() -> (ProtocolStateOwner, [RendererOutputStreamIdentity; 2]) { fn created(instance: u64) -> RendererSharedWorkerTargetEvent { RendererSharedWorkerTargetEvent::Created(RendererSharedWorkerTargetInfo { + interception_policy: None, owner_local_host_id: moli_core::RendererOwnerLocalHostId::new_for_testing(9), instance_id: SharedWorkerInstanceId::from_u64(instance), url: "https://fixture.invalid/worker.js".into(), diff --git a/moli-protocol/src/conn/state_access/worker_projection.rs b/moli-protocol/src/conn/state_access/worker_projection.rs index 9e572a4a9cd..b964c219646 100644 --- a/moli-protocol/src/conn/state_access/worker_projection.rs +++ b/moli-protocol/src/conn/state_access/worker_projection.rs @@ -11,6 +11,24 @@ use crate::domains::target::{ }; impl ProtocolWorkflowState<'_> { + pub(crate) fn prepare_worker_resource( + self, + browser_context_id: String, + target_id: String, + event: moli_core::network::ResourceInterceptionEvent, + ) -> Option<( + Vec, + Vec, + Vec, + )> { + crate::domains::target::prepare_worker_resource( + self.connection, + browser_context_id, + target_id, + event, + ) + } + pub(crate) fn project_worker_target_event( self, event: WorkerTargetLifecycleOutput, diff --git a/moli-protocol/src/conn/target/worker_auto_attach.rs b/moli-protocol/src/conn/target/worker_auto_attach.rs index 4b058c7770b..2503abf2adc 100644 --- a/moli-protocol/src/conn/target/worker_auto_attach.rs +++ b/moli-protocol/src/conn/target/worker_auto_attach.rs @@ -175,6 +175,14 @@ impl CdpConnection { self.dedicated_worker_pause_on_start_for_devtools() } + pub(crate) fn shared_worker_pause_on_start_for_devtools(&self) -> bool { + self.auto_attach_owner_sessions_for_target_type("shared_worker") + .iter() + .any(|owner| { + (owner.is_none() || self.is_browser_session_id(owner.as_deref())) + && self.auto_attach_owner_waits_for_debugger_on_start(owner.as_deref()) + }) + } pub(crate) fn dedicated_worker_pause_on_start_for_devtools(&self) -> bool { !self .dedicated_worker_pause_on_start_owner_sessions diff --git a/moli-protocol/src/domains/activity/mod.rs b/moli-protocol/src/domains/activity/mod.rs index 89f4c8a60f9..3f8bb10e909 100644 --- a/moli-protocol/src/domains/activity/mod.rs +++ b/moli-protocol/src/domains/activity/mod.rs @@ -74,3 +74,5 @@ pub(in crate::domains) async fn project_frozen_slot_for_test( } pub(crate) use subresource::stage_blocked_intercepts; + +pub(in crate::domains) use subresource::prepare_worker_subresource_continue_action; diff --git a/moli-protocol/src/domains/activity/subresource.rs b/moli-protocol/src/domains/activity/subresource.rs index 568463d3eea..40c50f94b57 100644 --- a/moli-protocol/src/domains/activity/subresource.rs +++ b/moli-protocol/src/domains/activity/subresource.rs @@ -23,7 +23,7 @@ use crate::domains::network::{ #[derive(Debug)] pub(crate) struct PreparedSubresourceContinueAction { - owner: TargetPageResidenceIdentity, + owner: Option, event: PendingSubresourceContinueEvent, request: Option, } @@ -40,7 +40,7 @@ impl PreparedSubresourceContinueAction { fn capture( conn: &mut CdpConnection, command_owner: &CommandOwnerScope, - owner: TargetPageResidenceIdentity, + owner: Option, event: PendingSubresourceContinueEvent, network_pause: Option, response_body: Option, @@ -48,7 +48,7 @@ impl PreparedSubresourceContinueAction { let internal_id = Self::internal_id(&event); let mut request = conn.claim_subresource_continue_request_for_owner( command_owner, - &owner, + owner.as_ref(), internal_id, matches!(&event, PendingSubresourceContinueEvent::Completed { .. }), ); @@ -89,7 +89,7 @@ impl PreparedSubresourceContinueAction { Some(Self::capture( conn, &command_owner, - owner, + Some(owner), event, None, None, @@ -111,7 +111,7 @@ pub(in crate::domains) fn prepare_subresource_continue_action_for_renderer_recor Some(PreparedSubresourceContinueAction::capture( conn, command_owner, - owner, + Some(owner), event, network_pause, response_body, @@ -124,7 +124,11 @@ pub(crate) fn prepare_subresource_continue_action( command_owner: &CommandOwnerScope, action: PreparedSubresourceContinueAction, ) -> Option { - if !conn.target_page_output_residence_is_current(&action.owner) { + if action + .owner + .as_ref() + .is_some_and(|owner| !conn.target_page_output_residence_is_current(owner)) + { return None; } let session_id = command_owner.session_id(); @@ -417,11 +421,7 @@ fn pending_auth_request( auth_info: &PendingSubresourceAuthInfo, ) -> PendingSubresourceFetchAuthRequest { PendingSubresourceFetchAuthRequest { - command_target: pending.document_command_target().cloned(), - page_owner: pending - .page_owner() - .expect("an in-flight auth continuation must retain its native Page residence") - .clone(), + residence: pending.residence.clone(), owner_session_id: pending.owner_session_id.clone(), action_session_id: pending.action_session_id.clone(), owner_kind: pending.owner_kind, @@ -453,11 +453,7 @@ fn pending_response_request( response_info: &PendingSubresourceResponseInfo, ) -> PendingSubresourceFetchResponseRequest { PendingSubresourceFetchResponseRequest { - command_target: pending.document_command_target().cloned(), - page_owner: pending - .page_owner() - .expect("an in-flight response continuation must retain its native Page residence") - .clone(), + residence: pending.residence.clone(), owner_session_id: pending.owner_session_id.clone(), action_session_id: pending.action_session_id.clone(), owner_kind: pending.owner_kind, @@ -540,11 +536,7 @@ pub(crate) fn flush_post_subresource_response_activity_for_owner_background_even owner: &CommandOwnerScope, pending: &PendingSubresourceFetchResponseRequest, ) { - if !conn.subresource_document_is_current_for_owner( - owner, - &pending.page_owner, - pending.source_document(), - ) { + if !conn.subresource_residence_is_current(&pending.residence) { return; } record_subresource_network_request_handle( @@ -578,11 +570,7 @@ pub(crate) fn flush_post_subresource_auth_activity_for_owner_background_events( owner: &CommandOwnerScope, pending: &PendingSubresourceFetchAuthRequest, ) { - if !conn.subresource_document_is_current_for_owner( - owner, - &pending.page_owner, - pending.source_document(), - ) { + if !conn.subresource_residence_is_current(&pending.residence) { return; } record_subresource_network_request_handle( @@ -669,7 +657,7 @@ pub(crate) struct PreparedSubresourceContinueWait { pub(crate) struct SubresourceContinueCompletion { owner: CommandOwnerScope, - binding: crate::conn::TargetRootDocumentProtocolAttachmentIdentity, + binding: Option, request: PendingSubresourceFetchRequest, } @@ -681,10 +669,17 @@ impl PreparedSubresourceContinueWait { request: PendingSubresourceFetchRequest, kind: SubresourceContinuationKind, ) -> Option { - let document = request - .source_document() - .or_else(|| conn.target_root_document_lifecycle_identity_for_owner(owner))?; - let binding = conn.target_root_document_output_identity_for_owner(owner, document)?; + let binding = if matches!( + request.residence, + crate::conn::PendingSubresourceFetchResidence::Worker { .. } + ) { + None + } else { + let document = request + .source_document() + .or_else(|| conn.target_root_document_lifecycle_identity_for_owner(owner))?; + Some(conn.target_root_document_output_identity_for_owner(owner, document)?) + }; let native = match kind { SubresourceContinuationKind::Response(internal_id) => { moli_core::RendererPageCommand::ContinuePendingSubresourceResponse { @@ -700,12 +695,7 @@ impl PreparedSubresourceContinueWait { } } }; - let pending = conn.start_subresource_document_command( - owner, - request.page_owner()?, - request.document_command_target(), - native, - ); + let pending = conn.start_subresource_command(owner, &request.residence, native); match pending { Ok(pending) => Some(Self { pending, @@ -743,7 +733,11 @@ impl SubresourceContinueCompletion { completed: Result, ) -> Vec { let mut events = Vec::new(); - if !conn.target_root_document_output_identity_is_current(&self.binding) { + if !conn.subresource_residence_is_current(&self.request.residence) + || self.binding.as_ref().is_some_and(|binding| { + !conn.target_root_document_output_identity_is_current(binding) + }) + { return events; } let result = completed.and_then(moli_core::page::CompletedResourceCommand::into_unit_reply); @@ -759,3 +753,12 @@ impl SubresourceContinueCompletion { events } } + +pub(in crate::domains) fn prepare_worker_subresource_continue_action( + conn: &mut CdpConnection, + owner: &CommandOwnerScope, + event: PendingSubresourceContinueEvent, + pause: Option, +) -> PreparedSubresourceContinueAction { + PreparedSubresourceContinueAction::capture(conn, owner, None, event, pause, None) +} diff --git a/moli-protocol/src/domains/fetch.rs b/moli-protocol/src/domains/fetch.rs index d76e183a5b3..7b35f3617a9 100644 --- a/moli-protocol/src/domains/fetch.rs +++ b/moli-protocol/src/domains/fetch.rs @@ -70,6 +70,7 @@ pub(crate) use subresource::{ detached_parser_script_fetch_pause_prepared_outputs_for_renderer_record, emit_subresource_fetch_pause_outputs, subresource_fetch_pause_prepared_outputs_for_renderer_record, + worker_fetch_pause_prepared_outputs, }; pub(in crate::domains) fn prepare_owner_disposal( diff --git a/moli-protocol/src/domains/fetch/auth.rs b/moli-protocol/src/domains/fetch/auth.rs index 5b6cde113b0..62d71b76678 100644 --- a/moli-protocol/src/domains/fetch/auth.rs +++ b/moli-protocol/src/domains/fetch/auth.rs @@ -246,12 +246,8 @@ pub(super) fn start_devtools_continue_with_auth_command_for_pending( } DevToolsAuthChallengeAction::ProvideCredentials => unreachable!(), }; - let pending_page = conn.start_subresource_document_command( - owner, - &pending.page_owner, - pending.command_target.as_ref(), - native, - ); + let pending_page = + conn.start_subresource_command(owner, &pending.residence, native); let pending_page = match pending_page { Ok(pending_page) => pending_page, Err(error) => { @@ -329,10 +325,9 @@ pub(super) fn start_devtools_continue_with_auth_command_for_pending( ))); } }; - let pending_page = conn.start_subresource_document_command( + let pending_page = conn.start_subresource_command( owner, - &pending.page_owner, - pending.command_target.as_ref(), + &pending.residence, RendererPageCommand::ContinuePendingSubresourceAuth { internal_id: pending.internal_id, auth, @@ -453,13 +448,7 @@ pub(super) fn continued_subresource_request( pending: &PendingSubresourceFetchAuthRequest, ) -> PendingSubresourceFetchRequest { PendingSubresourceFetchRequest { - residence: match pending.command_target.clone() { - Some(command_target) => crate::conn::PendingSubresourceFetchResidence::Document { - page_owner: pending.page_owner.clone(), - command_target, - }, - None => crate::conn::PendingSubresourceFetchResidence::Page(pending.page_owner.clone()), - }, + residence: pending.residence.clone(), owner_session_id: pending.owner_session_id.clone(), action_session_id: pending.action_session_id.clone(), owner_kind: pending.owner_kind, diff --git a/moli-protocol/src/domains/fetch/body_stream.rs b/moli-protocol/src/domains/fetch/body_stream.rs index fbb64e0dbcd..30a9ed194c9 100644 --- a/moli-protocol/src/domains/fetch/body_stream.rs +++ b/moli-protocol/src/domains/fetch/body_stream.rs @@ -68,11 +68,7 @@ impl FetchResponseBodySource { fn response_body_source( pending: &crate::conn::PendingSubresourceFetchResponseRequest, ) -> crate::conn::ProtocolResponseBody { - match pending - .command_target - .as_ref() - .and_then(|target| target.native_response_body()) - { + match pending.residence.native_response_body() { Some(body) => crate::conn::ProtocolResponseBody::Network(body.clone()), None => pending.response_body.clone().into(), } diff --git a/moli-protocol/src/domains/fetch/cleanup.rs b/moli-protocol/src/domains/fetch/cleanup.rs index 249dcb89c6f..9b2e22dda1c 100644 --- a/moli-protocol/src/domains/fetch/cleanup.rs +++ b/moli-protocol/src/domains/fetch/cleanup.rs @@ -129,9 +129,7 @@ impl PreparedFetchCleanup { || pending .detached_parser_script_fetch_continuation() .is_some() - || pending - .document_command_target() - .is_some_and(|target| target.has_native_network_pause())) + || pending.residence.has_native_network_pause()) { CleanupSubresource::ContinueRequest { request_id, @@ -145,10 +143,7 @@ impl PreparedFetchCleanup { if resume_navigations && pending.owner_kind.drains_on_fetch_disable() && (pending.resource_type == moli_core::page::SubresourceResourceType::Document - || pending - .command_target - .as_ref() - .is_some_and(|target| target.has_native_network_pause())) + || pending.residence.has_native_network_pause()) { CleanupSubresource::ContinueAuth { request_id, @@ -162,10 +157,7 @@ impl PreparedFetchCleanup { if resume_navigations && pending.owner_kind.drains_on_fetch_disable() && (pending.resource_type == moli_core::page::SubresourceResourceType::Document - || pending - .command_target - .as_ref() - .is_some_and(|target| target.has_native_network_pause())) + || pending.residence.has_native_network_pause()) { CleanupSubresource::ContinueResponse(pending) } else { @@ -491,7 +483,7 @@ fn admit_subresource_cleanup( return None; } ( - request.document_command_target(), + Some(&request.residence), RendererPageCommand::ContinuePendingSubresourceFetch { internal_id: request.internal_id, url, @@ -509,7 +501,7 @@ fn admit_subresource_cleanup( return None; } ( - request.document_command_target(), + Some(&request.residence), RendererPageCommand::FailPendingSubresourceFetch { internal_id: request.internal_id, error_text: reason.to_owned(), @@ -517,20 +509,20 @@ fn admit_subresource_cleanup( ) } CleanupSubresource::Auth(request) => ( - request.command_target.as_ref(), + Some(&request.residence), RendererPageCommand::FailPendingSubresourceAuth { internal_id: request.internal_id, error_text: reason.to_owned(), }, ), CleanupSubresource::ContinueAuth { pending, .. } => ( - pending.command_target.as_ref(), + Some(&pending.residence), RendererPageCommand::CancelPendingSubresourceAuth { internal_id: pending.internal_id, }, ), CleanupSubresource::ContinueResponse(request) => ( - request.command_target.as_ref(), + Some(&request.residence), RendererPageCommand::ContinuePendingSubresourceResponse { internal_id: request.internal_id, response_code: None, @@ -538,7 +530,7 @@ fn admit_subresource_cleanup( }, ), CleanupSubresource::Response(request) => ( - request.command_target.as_ref(), + Some(&request.residence), RendererPageCommand::FailPendingSubresourceResponse { internal_id: request.internal_id, error_text: reason.to_owned(), @@ -591,7 +583,9 @@ fn admit_subresource_cleanup( if matches!( &pending, moli_core::page::PendingResourceCommand::Network(Ok(_)) - ) { + ) && target.page_owner().is_some() + && !target.observes_worker_network() + { // Retiring a Document must publish its admitted cancellation before // that Document's networking tasks become ineligible. The load's // late terminal shares this ID and uses the existing once-only claim. @@ -639,7 +633,9 @@ fn admit_subresource_cleanup( } } } - let binding = conn.target_root_document_output_identity_for_owner(owner, target.document()); + let binding = target + .source_document() + .and_then(|document| conn.target_root_document_output_identity_for_owner(owner, document)); Some(PreparedSubresourceCleanup::Command(Box::new( PreparedSubresourceCommand { plan, diff --git a/moli-protocol/src/domains/fetch/commands.rs b/moli-protocol/src/domains/fetch/commands.rs index 8b72dd4149f..56a7aaa4e82 100644 --- a/moli-protocol/src/domains/fetch/commands.rs +++ b/moli-protocol/src/domains/fetch/commands.rs @@ -337,12 +337,9 @@ fn start_devtools_continue_intercepted_request_command( )); } }; - let pending_page = conn.start_subresource_document_command( + let pending_page = conn.start_subresource_command( owner, - pending - .page_owner() - .expect("native request has Page residence"), - pending.document_command_target(), + &pending.residence, RendererPageCommand::ContinuePendingSubresourceFetch { internal_id: pending.internal_id, url: parsed_url, @@ -611,12 +608,9 @@ fn start_devtools_fail_intercepted_request_command( // all Network observers, through the normal completion path. return FetchCommandTaskStep::Complete(CommandOutputPlan::success()); } - let pending_page = match conn.start_subresource_document_command( + let pending_page = match conn.start_subresource_command( owner, - pending - .page_owner() - .expect("native request has Page residence"), - pending.document_command_target(), + &pending.residence, RendererPageCommand::FailPendingSubresourceFetch { internal_id: pending.internal_id, error_text: error_text.clone(), @@ -653,10 +647,9 @@ fn start_devtools_fail_intercepted_request_command( action_session_id, &request_id, ) { - let pending_page = match conn.start_subresource_document_command( + let pending_page = match conn.start_subresource_command( owner, - &pending.page_owner, - pending.command_target.as_ref(), + &pending.residence, RendererPageCommand::FailPendingSubresourceResponse { internal_id: pending.internal_id, error_text: error_text.clone(), @@ -896,12 +889,9 @@ fn start_devtools_fulfill_intercepted_request_command( headers, }) }); - let pending_page = match conn.start_subresource_document_command( + let pending_page = match conn.start_subresource_command( owner, - pending - .page_owner() - .expect("native request has Page residence"), - pending.document_command_target(), + &pending.residence, RendererPageCommand::FulfillPendingSubresourceFetch { internal_id: pending.internal_id, request_overrides, @@ -945,10 +935,9 @@ fn start_devtools_fulfill_intercepted_request_command( action_session_id, &request_id, ) { - let pending_page = match conn.start_subresource_document_command( + let pending_page = match conn.start_subresource_command( owner, - &pending.page_owner, - pending.command_target.as_ref(), + &pending.residence, RendererPageCommand::FulfillPendingSubresourceResponse { internal_id: pending.internal_id, response_code, @@ -1487,10 +1476,9 @@ fn start_devtools_continue_intercepted_response_command( } else { response_headers }; - let pending_page = match conn.start_subresource_document_command( + let pending_page = match conn.start_subresource_command( owner, - &pending.page_owner, - pending.command_target.as_ref(), + &pending.residence, RendererPageCommand::ContinuePendingSubresourceResponse { internal_id: pending.internal_id, response_code: continue_response_code, @@ -1981,8 +1969,7 @@ mod protocol_neutral_tests { .target_page_residence_identity_for_session(Some("SID-primary")) .expect("test target should expose a Page residence identity"); let pending = PendingSubresourceFetchResponseRequest { - command_target: None, - page_owner, + residence: crate::conn::PendingSubresourceFetchResidence::Page(page_owner), owner_session_id: Some("SID-primary".to_owned()), action_session_id: Some("SID-primary".to_owned()), owner_kind: PendingSubresourceFetchOwnerKind::Fetch, diff --git a/moli-protocol/src/domains/fetch/subresource.rs b/moli-protocol/src/domains/fetch/subresource.rs index 5b423d070e1..e81dd3813d5 100644 --- a/moli-protocol/src/domains/fetch/subresource.rs +++ b/moli-protocol/src/domains/fetch/subresource.rs @@ -60,6 +60,7 @@ struct PendingSubresourceFetchPauseSource { /// Network request id is the loader id of the Document it creates. child_document: Option, native_network: bool, + observe_network: bool, request_initiator_type: SubresourceRequestInitiatorType, redirect: Option, } @@ -96,6 +97,9 @@ pub(crate) fn subresource_fetch_pause_prepared_outputs_for_renderer_record( return network::NetworkPreparedOutputs::default(); }; let native_network = network_pause.is_some(); + let observe_network = !network_pause + .as_ref() + .is_some_and(|pause| pause.observes_worker_network()); let request_initiator_type = network_pause .as_ref() .map_or(SubresourceRequestInitiatorType::Script, |pause| { @@ -123,6 +127,7 @@ pub(crate) fn subresource_fetch_pause_prepared_outputs_for_renderer_record( detached_parser_script_fetch_continuation: None, child_document, native_network, + observe_network, request_initiator_type, redirect, }], @@ -153,6 +158,7 @@ pub(crate) fn detached_parser_script_fetch_pause_prepared_outputs_for_renderer_r detached_parser_script_fetch_continuation: Some(continuation), child_document: None, native_network: false, + observe_network: true, request_initiator_type: SubresourceRequestInitiatorType::Script, redirect: None, }], @@ -175,9 +181,12 @@ fn prepare_subresource_fetch_pause_sources( .map(crate::conn::PendingSubresourceFetchResidence::Page) }); let Some((fetch_snapshot, frame_id)) = (|| { - let target_frame_id = conn - .target_session_owner_frame_tree_identity_for_owner(owner) - .map(|(target_id, _, _, _)| target_id)?; + let target_frame_id = if conn.worker_resource_identity_for_owner(owner).is_some() { + String::new() + } else { + conn.target_session_owner_frame_tree_identity_for_owner(owner) + .map(|(target_id, _, _, _)| target_id)? + }; let frame_id = frame_id.unwrap_or(&target_frame_id); Some(( conn.target_fetch_subresource_interception_snapshot_for_owner(owner)?, @@ -197,6 +206,7 @@ fn prepare_subresource_fetch_pause_sources( detached_parser_script_fetch_continuation, child_document, native_network, + observe_network, request_initiator_type, redirect, } = source; @@ -214,9 +224,7 @@ fn prepare_subresource_fetch_pause_sources( }; let network_request_id = if native_network { info.network_request_handle - .and_then(|handle| { - conn.network_request_id_for_subresource_handle_for_owner(owner, handle) - }) + .map(|handle| conn.native_network_request_id(handle)) .unwrap_or(network_request_id) } else { network_request_id @@ -279,6 +287,7 @@ fn prepare_subresource_fetch_pause_sources( &info, ) .with_fetch_request_id(request_id.clone()) + .with_network_observation(observe_network) .with_request_initiator_type(request_initiator_type) .with_child_document(child_document.clone()) .with_redirect(redirect.clone()); @@ -494,6 +503,7 @@ fn prepare_subresource_fetch_pause_sources( &info, ) .with_blocked_intercepts(blocked_intercepts) + .with_network_observation(observe_network) .with_request_initiator_type(request_initiator_type) .with_fetch_request_id(request_id.clone()) .with_child_document(child_document) @@ -531,6 +541,11 @@ pub(crate) fn emit_subresource_fetch_pause_outputs( outputs: Vec, ) { for output in outputs { + let network_session_ids = if output.network_output().observes_network() { + network_session_ids + } else { + &[] + }; let network_request_id = output.network_output().network_request_id().to_owned(); // Detached parser-script completions use the same native handle as // their pause, just like renderer-owned subresource completions. @@ -827,6 +842,39 @@ pub(super) fn next_chained_subresource_response_pause_event( Some(event) } +pub(crate) fn worker_fetch_pause_prepared_outputs( + conn: &mut CdpConnection, + owner: &CommandOwnerScope, + browser_context_id: String, + target_id: String, + info: moli_core::page::PendingSubresourceFetchInfo, + pause: moli_core::network::ResourceInterceptionPause, +) -> network::NetworkPreparedOutputs { + let redirect = pause.request_redirect().cloned().map(Into::into); + let initiator = pause.request_initiator_type(); + prepare_subresource_fetch_pause_sources( + conn, + owner, + Some(""), + None, + Some(crate::conn::PendingSubresourceFetchResidence::Worker { + browser_context_id, + target_id, + pause, + body: None, + }), + vec![PendingSubresourceFetchPauseSource { + info, + detached_parser_script_fetch_continuation: None, + child_document: None, + native_network: true, + observe_network: false, + request_initiator_type: initiator, + redirect, + }], + ) +} + #[cfg(test)] mod tests { use moli_core::page::{PendingSubresourceFetchInfo, SubresourceResourceType}; diff --git a/moli-protocol/src/domains/fetch/subresource_continuation.rs b/moli-protocol/src/domains/fetch/subresource_continuation.rs index 2719dcee655..181227fc272 100644 --- a/moli-protocol/src/domains/fetch/subresource_continuation.rs +++ b/moli-protocol/src/domains/fetch/subresource_continuation.rs @@ -17,7 +17,7 @@ pub(super) enum SubresourceResponseInterception { pub(crate) struct PreparedSubresourceAutoContinue { pending: PendingResourceCommand, correlation: PreparedSubresourceCorrelation, - binding: TargetRootDocumentProtocolAttachmentIdentity, + binding: Option, } impl PreparedSubresourceAutoContinue { @@ -29,21 +29,24 @@ impl PreparedSubresourceAutoContinue { handle_auth_requests: bool, response: SubresourceResponseInterception, ) -> Option { - let target = request.document_command_target()?.clone(); - let document = target.document(); - let binding = conn.target_root_document_output_identity_for_owner(owner, document)?; + let binding = if let Some(target) = request.document_command_target() { + Some(conn.target_root_document_output_identity_for_owner(owner, target.document())?) + } else if request.residence.native_pause().is_some() { + None + } else { + return None; + }; let intercept_response = !matches!(response, SubresourceResponseInterception::None); let internal_id = request.internal_id; - let page_owner = request.page_owner()?.clone(); + let residence = request.residence.clone(); // The renderer may publish a continuation before its command reply is // consumed. Freeze its original correlation before native dispatch. let correlation = PreparedSubresourceCorrelation::prepare_automatic( conn, owner, request_id, request, response, )?; - let pending = conn.start_subresource_document_command( + let pending = conn.start_subresource_command( owner, - &page_owner, - Some(&target), + &residence, moli_core::RendererPageCommand::ContinuePendingSubresourceFetch { internal_id, url: None, @@ -91,7 +94,7 @@ impl std::fmt::Debug for PreparedSubresourceAutoContinue { pub(crate) struct SubresourceAutoContinueCompletion { correlation: PreparedSubresourceCorrelation, - binding: TargetRootDocumentProtocolAttachmentIdentity, + binding: Option, } impl SubresourceAutoContinueCompletion { @@ -100,7 +103,11 @@ impl SubresourceAutoContinueCompletion { conn: &mut CdpConnection, completed: Result, ) { - if !conn.target_root_document_output_identity_is_current(&self.binding) { + if self + .binding + .as_ref() + .is_some_and(|binding| !conn.target_root_document_output_identity_is_current(binding)) + { self.correlation.rollback(conn); return; } diff --git a/moli-protocol/src/domains/fetch/tests/basics.rs b/moli-protocol/src/domains/fetch/tests/basics.rs index 1b5147134f3..2dd2271786e 100644 --- a/moli-protocol/src/domains/fetch/tests/basics.rs +++ b/moli-protocol/src/domains/fetch/tests/basics.rs @@ -50,11 +50,12 @@ fn pending_subresource_fetch_auth( owner_session_id: &str, ) -> PendingSubresourceFetchAuthRequest { PendingSubresourceFetchAuthRequest { - command_target: None, - page_owner: crate::conn::TargetPageResidenceIdentity::new_for_test( - "BID-session-fetch".to_owned(), - Some("TID-session-fetch".to_owned()), - 1, + residence: crate::conn::PendingSubresourceFetchResidence::Page( + crate::conn::TargetPageResidenceIdentity::new_for_test( + "BID-session-fetch".to_owned(), + Some("TID-session-fetch".to_owned()), + 1, + ), ), owner_session_id: Some(owner_session_id.to_owned()), action_session_id: Some(owner_session_id.to_owned()), diff --git a/moli-protocol/src/domains/fetch/tests/binary_request.rs b/moli-protocol/src/domains/fetch/tests/binary_request.rs index c429a8a6e10..d50d53a9f14 100644 --- a/moli-protocol/src/domains/fetch/tests/binary_request.rs +++ b/moli-protocol/src/domains/fetch/tests/binary_request.rs @@ -45,7 +45,16 @@ async fn binary_request_round_trip( let page_url = format!("http://{addr}/page"); let api_url = format!("http://{addr}/echo"); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; - let mut sessions = vec!["SID-1"]; + ctx.observe_worker_network_for_test(if matches!(scope, RequestScope::SharedWorker) { + Some(( + json!([{"urlPattern":"*/echo","requestStage":"Request"}]), + if chained { 2 } else { 1 }, + )) + } else { + None + }) + .await; + let mut sessions = vec!["SID-1".to_owned()]; if chained { ctx.with_fixture(|conn| { assert!({ @@ -55,7 +64,7 @@ async fn binary_request_round_trip( .assign_attached_session_to_target("TID-1", "SID-2".to_owned()) }) }); - sessions.push("SID-2"); + sessions.push("SID-2".to_owned()); } ctx.sent.clear(); let mut id = 1; @@ -114,6 +123,15 @@ async fn binary_request_round_trip( let response = take_response_by_id(&mut ctx, id); assert_eq!(response["result"]["result"]["value"], "scheduled"); id += 1; + if matches!(scope, RequestScope::SharedWorker) { + wait_until_scheduler_message(&mut ctx, "SharedWorker attached", |event| { + event["method"] == "Target.attachedToTarget" + && event["params"]["targetInfo"]["type"] == "shared_worker" + }) + .await; + sessions = ctx.shared_worker_fetch_sessions_for_test().await; + assert_eq!(sessions.len(), if chained { 2 } else { 1 }); + } let mut network_id = Value::Null; for (index, session) in sessions.iter().enumerate() { let paused = runtime_fetch::wait_for_request_paused_on_session( @@ -130,13 +148,18 @@ async fn binary_request_round_trip( "paused request must not reach the server" ); if inspect_paused_body { + let network_session = if matches!(scope, RequestScope::Window) { + session.clone() + } else { + ctx.worker_network_session_for_request(&network_id) + }; ctx.process_async(json!({"id":id,"method":"Network.getRequestPostData", - "sessionId":session,"params":{"requestId":network_id}})) + "sessionId":network_session,"params":{"requestId":network_id}})) .await; ctx.expect_result( id, json!({"postData":BASE64_STANDARD.encode(BODY),"base64Encoded":true}), - Some(session), + Some(network_session.as_str()), ); id += 1; } @@ -187,8 +210,13 @@ async fn binary_request_round_trip( let response = take_response_by_id(&mut ctx, id); assert_eq!(response["result"]["result"]["value"], json!(expected)); id += 1; + let network_session = if matches!(scope, RequestScope::Window) { + "SID-1".to_owned() + } else { + ctx.worker_network_session_for_request(&network_id) + }; ctx.process_async( - json!({"id":id,"method":"Network.getRequestPostData","sessionId":"SID-1", + json!({"id":id,"method":"Network.getRequestPostData","sessionId":network_session, "params":{"requestId":network_id}}), ) .await; @@ -204,7 +232,7 @@ async fn binary_request_round_trip( ctx.expect_result( id, json!({"postData":body,"base64Encoded":base64_encoded}), - Some("SID-1"), + Some(network_session.as_str()), ); } server.abort(); diff --git a/moli-protocol/src/domains/fetch/tests/command_correlation.rs b/moli-protocol/src/domains/fetch/tests/command_correlation.rs index 6462076302d..cac78e8c081 100644 --- a/moli-protocol/src/domains/fetch/tests/command_correlation.rs +++ b/moli-protocol/src/domains/fetch/tests/command_correlation.rs @@ -65,8 +65,7 @@ fn pending_auth( .expect("test request should belong to an installed Page") .clone(); PendingSubresourceFetchAuthRequest { - command_target: None, - page_owner, + residence: crate::conn::PendingSubresourceFetchResidence::Page(page_owner), owner_session_id: pending.owner_session_id, action_session_id: pending.action_session_id, owner_kind: pending.owner_kind, @@ -103,8 +102,7 @@ fn pending_response( .expect("test request should belong to an installed Page") .clone(); PendingSubresourceFetchResponseRequest { - command_target: None, - page_owner, + residence: crate::conn::PendingSubresourceFetchResidence::Page(page_owner), owner_session_id: pending.owner_session_id, action_session_id: pending.action_session_id, owner_kind: pending.owner_kind, @@ -376,7 +374,7 @@ async fn completed_continue_atomically_claims_a_pause_still_pending_publication( assert!( conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &page_owner, + Some(&page_owner), 74, false, ) @@ -387,7 +385,7 @@ async fn completed_continue_atomically_claims_a_pause_still_pending_publication( let claimed = ctx.with_fixture(|conn| { conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &page_owner, + Some(&page_owner), 74, true, ) @@ -401,7 +399,7 @@ async fn completed_continue_atomically_claims_a_pause_still_pending_publication( assert!( conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &page_owner, + Some(&page_owner), 74, true, ) @@ -431,7 +429,7 @@ async fn completed_continue_atomically_claims_a_pause_still_pending_publication( assert!( conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &page_owner, + Some(&page_owner), 75, true, ) @@ -490,7 +488,7 @@ async fn continuation_claim_preserves_state_owned_by_a_different_page_residence( assert!( conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &replacement_owner, + Some(&replacement_owner), 76, false, ) @@ -502,7 +500,7 @@ async fn continuation_claim_preserves_state_owned_by_a_different_page_residence( assert!( conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &replacement_owner, + Some(&replacement_owner), 77, true, ) @@ -519,7 +517,7 @@ async fn continuation_claim_preserves_state_owned_by_a_different_page_residence( let ClaimedSubresourceContinueRequest::InFlight(in_flight) = ctx.with_fixture(|conn| { conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &retired_owner, + Some(&retired_owner), 76, false, ) @@ -535,7 +533,7 @@ async fn continuation_claim_preserves_state_owned_by_a_different_page_residence( let ClaimedSubresourceContinueRequest::PendingCompletion(pending) = ctx.with_fixture(|conn| { conn.claim_subresource_continue_request_for_owner( &crate::conn::CommandOwnerScope::for_session("SID-1"), - &retired_owner, + Some(&retired_owner), 77, true, ) @@ -679,7 +677,10 @@ async fn continue_with_auth_registers_retry_correlation_before_renderer_completi }); ctx.with_fixture(|conn| { let mut pending = pending_auth(&page_owner, 62); - pending.command_target = Some(command_target(conn, &page_owner)); + pending.residence = crate::conn::PendingSubresourceFetchResidence::Document { + page_owner: page_owner.clone(), + command_target: command_target(conn, &page_owner), + }; assert!({ conn.register_pending_subresource_fetch_auth_request_for_session_owner( Some("SID-1"), diff --git a/moli-protocol/src/domains/fetch/tests/header_bytes.rs b/moli-protocol/src/domains/fetch/tests/header_bytes.rs index ee66b3b6864..d9144dc95e4 100644 --- a/moli-protocol/src/domains/fetch/tests/header_bytes.rs +++ b/moli-protocol/src/domains/fetch/tests/header_bytes.rs @@ -60,6 +60,7 @@ async fn check_intercepted_header_bytes(script: &str, override_headers: bool, re }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("http://{addr}/page"), "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; enable_runtime_async(&mut ctx, "SID-1", 70100).await; ctx.process_async(json!({"id": 70107, "sessionId": "SID-1", "method": "Network.enable"})) .await; @@ -244,6 +245,7 @@ async fn check_response_header_bytes(continue_response: bool, binary: bool) { }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("http://{addr}/page"), "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; enable_runtime_async(&mut ctx, "SID-1", 70200).await; ctx.process_async(json!({ "id": 70201, "sessionId": "SID-1", "method": "Fetch.enable", @@ -456,6 +458,7 @@ async fn bidi_extra_header_bytes_reach_fetch_xhr_worker_and_navigation() { }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("http://{addr}/page"), "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; enable_runtime_async(&mut ctx, "SID-1", 70400).await; let outcome = ctx .execute_owned_automation_command_for_test(AutomationCommand::SetExtraHeaders( @@ -541,6 +544,7 @@ async fn stylesheet_interception_aborts_before_transport_and_can_fulfill() { }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("http://{addr}/page"), "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; enable_runtime_async(&mut ctx, "SID-1", 70400).await; ctx.process_async(json!({"id":70401,"sessionId":"SID-1","method":"Fetch.enable","params":{"patterns":[{"urlPattern":"*/test.css","resourceType":"Stylesheet","requestStage":"Request"}]}})).await; ctx.expect_result(70401, json!({}), Some("SID-1")); diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects.rs index cff9359cace..23ec36ccac3 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects.rs @@ -14,7 +14,7 @@ pub(super) async fn command(ctx: &mut TestContext, id: u64, method: &str, params response } -async fn session_command( +pub(super) async fn session_command( ctx: &mut TestContext, session: &str, id: u64, @@ -345,7 +345,7 @@ async fn fulfilled_window_fetch_redirect_modes_and_missing_location() { .await; let expected = if mode == "manual" { json!({"status":0,"type":"opaqueredirect","body":"","redirected":false}) - } else if mode == "error" { + } else if mode == "error" && location { json!({"error":"TypeError"}) } else { json!({"status":302,"type":"basic","body":"noloc","redirected":false}) @@ -653,7 +653,9 @@ async fn check_manual_preflight_redirect(stage: Option<&str>) { assert_eq!(*observed.lock(), expected_requests, "{stage:?}/{index}"); let value = &result["result"]["result"]["value"]; if !cors_allowed - || (status == 302 && (mode == "error" || (mode == "follow" && location.is_some()))) + || (status == 302 + && ((mode == "error" && (stage.is_none() || location.is_some())) + || (mode == "follow" && location.is_some()))) { assert_eq!(value, &json!({"error":"TypeError"}), "{stage:?}/{index}"); } else if status == 302 && mode == "manual" { diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects/cors_order.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects/cors_order.rs index 99db95c9b1e..6329ef8bcef 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects/cors_order.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch/fulfilled_redirects/cors_order.rs @@ -72,19 +72,23 @@ async fn error_mode_checks_cors_before_redirect_rejection() { ).await; let response = take_response_by_id(&mut ctx, id); let value = &response["result"]["result"]["value"]; - assert_eq!( - value["error"], "TypeError", - "{stage:?}/{status}/{cors}: {response}" - ); - let message = value["message"].as_str().unwrap(); - assert!( - if cors { - message.contains("redirect") - } else { - message.contains("CORS") - }, - "{stage:?}/{status}/{cors}: {value}" - ); + if cors && stage.is_some() { + assert_eq!(value["status"], status, "{stage:?}/{status}: {value}"); + } else { + assert_eq!( + value["error"], "TypeError", + "{stage:?}/{status}/{cors}: {response}" + ); + let message = value["message"].as_str().unwrap(); + assert!( + if cors { + message.contains("redirect") + } else { + message.contains("CORS") + }, + "{stage:?}/{status}/{cors}: {value}" + ); + } assert_eq!(pauses.len(), usize::from(stage.is_some())); let network_id = ctx .sent @@ -97,7 +101,12 @@ async fn error_mode_checks_cors_before_redirect_rejection() { .expect("announced fetch request")["params"]["requestId"] .clone(); wait_until_scheduler_message(&mut ctx, "CORS/error-mode terminal", |event| { - event["method"] == "Network.loadingFailed" + event["method"] + == if cors && stage.is_some() { + "Network.loadingFinished" + } else { + "Network.loadingFailed" + } && event["params"]["requestId"] == network_id }) .await; diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr.rs index 6f08465ad70..9c5dbb1a5d6 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr.rs @@ -548,6 +548,7 @@ async fn terminating_worker_cancels_a_synchronously_paused_request() { }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("http://{addr}/page"), "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; enable_runtime_async(&mut ctx, "SID-1", 40300).await; ctx.process_async(json!({"id":40306,"method":"Network.enable","sessionId":"SID-1"})) .await; @@ -574,16 +575,31 @@ async fn terminating_worker_cancels_a_synchronously_paused_request() { ctx.process_async(json!({"id":40303,"method":"Runtime.evaluate","sessionId":"SID-1","params":{"expression":"worker.terminate();JSON.stringify(workerResult);"}})).await; let result = take_response_by_id(&mut ctx, 40303); assert_eq!(result["result"]["result"]["value"], "[]", "{result}"); - let failure = ctx - .wait_for_scheduler_message("terminated Worker's network terminal", |message| { - message["method"] == "Network.loadingFailed" - && message["params"]["requestId"] == pause["params"]["networkId"] + let observer = ctx.worker_network_session_for_request(&pause["params"]["networkId"]); + ctx.wait_for_scheduler_message("Worker target detached", |event| { + event["method"] == "Target.detachedFromTarget" && event["params"]["sessionId"] == observer + }) + .await; + // Chromium does not require a terminal after the target has disappeared. + let terminals = ctx + .sent + .iter() + .filter(|event| { + matches!( + event["method"].as_str(), + Some("Network.loadingFinished" | "Network.loadingFailed") + ) && event["params"]["requestId"] == pause["params"]["networkId"] }) - .await; - assert_eq!( - failure["params"]["errorText"], "net::ERR_ABORTED", - "{failure}" + .collect::>(); + assert!( + terminals.len() <= 1, + "native load can complete at most once: {terminals:?}" ); + for terminal in terminals { + assert_eq!(terminal["method"], "Network.loadingFailed"); + assert_eq!(terminal["params"]["errorText"], "net::ERR_ABORTED"); + assert_eq!(terminal["sessionId"], observer); + } // A terminated Worker must release the native pause and the renderer owner. // No client decision is needed to make termination complete. ctx.process_async(json!({"id":40304,"method":"Fetch.disable","sessionId":"SID-1"})) diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr/terminal_consistency.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr/terminal_consistency.rs index ec9c7aa1589..30309997ccf 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr/terminal_consistency.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch/native_xhr/terminal_consistency.rs @@ -32,6 +32,9 @@ async fn xhr_cors_decision_and_network_terminal_agree_in_every_delivery_mode() { "TID-1", ) .await; + if worker { + ctx.observe_worker_network_for_test(None).await; + } enable_runtime_async(&mut ctx, "SID-1", 41400).await; ctx.process_async( json!({"id":41401,"method":"Network.enable","sessionId":"SID-1"}), diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_delivery_abort.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_delivery_abort.rs index 88132202783..aa945dc4da7 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_delivery_abort.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_delivery_abort.rs @@ -1,13 +1,13 @@ -use super::fulfilled_redirects::command; +use super::fulfilled_redirects::{command, session_command}; use super::*; #[tokio::test(flavor = "multi_thread")] -async fn dedicated_worker_abort_before_request_delivery_finishes_original_network_request() { +async fn dedicated_worker_network_progress_is_independent_of_response_delivery() { check_worker_abort_before_request_delivery(false).await; } #[tokio::test(flavor = "multi_thread")] -async fn shared_worker_abort_before_request_delivery_finishes_original_network_request() { +async fn shared_worker_network_progress_is_independent_of_response_delivery() { check_worker_abort_before_request_delivery(true).await; } @@ -16,6 +16,8 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { let (entered_tx, entered_rx) = tokio::sync::oneshot::channel(); let (release_tx, release_rx) = tokio::sync::oneshot::channel(); let barrier = Arc::new(tokio::sync::Mutex::new(Some((entered_tx, release_rx)))); + let (transport_entered_tx, transport_entered_rx) = tokio::sync::oneshot::channel(); + let transport_entered = Arc::new(tokio::sync::Mutex::new(Some(transport_entered_tx))); let hits = Arc::new(AtomicUsize::new(0)); let server_hits = hits.clone(); let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); @@ -40,9 +42,8 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { fetch('/race', {signal:controller.signal}) .then(response => reply({status:response.status}), error => reply({error:error.name})); - // Keep this JS task running while the parent queues - // fulfill/continue. Abort before returning to the - // Worker loop that can consume that queued command. + // Hold JS delivery, while the native loader can + // process fulfill/continue without this task. importScripts('/barrier.js'); controller.abort(); } @@ -72,9 +73,11 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { "/race", get(move || { let hits = server_hits.clone(); + let entered = transport_entered.clone(); async move { hits.fetch_add(1, Ordering::SeqCst); - "unexpected network dispatch" + entered.lock().await.take().unwrap().send(()).unwrap(); + std::future::pending::<&'static str>().await } }), ), @@ -84,6 +87,9 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("{origin}/page"), "SID-1", "TID-1").await; + let patterns = json!([{"urlPattern":"*/race","resourceType":"Fetch"}]); + ctx.observe_worker_network_for_test(shared.then(|| (patterns.clone(), 1))) + .await; enable_runtime_async(&mut ctx, "SID-1", 54_000).await; command(&mut ctx, 54_001, "Network.enable", json!({})).await; command( @@ -110,9 +116,25 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { if shared {"deliveryWorker.port"} else {"deliveryWorker"}, if shared {"deliveryPort.start()"} else {"void 0"}) })).await; - let paused = - wait_for_request_paused(&mut ctx, &format!("{origin}/race"), "Worker delivery pause") - .await; + let session = if shared { + // The startup observer installs the SharedWorker's own interceptor. + wait_until_scheduler_message(&mut ctx, "SharedWorker startup", |event| { + event["method"] == "Target.attachedToTarget" + && event["params"]["targetInfo"]["type"] == "shared_worker" + }) + .await; + ctx.shared_worker_fetch_sessions_for_test().await[0].clone() + } else { + "SID-1".to_owned() + }; + let paused = wait_for_request_paused_on_session( + &mut ctx, + &session, + &format!("{origin}/race"), + None, + "Worker delivery pause", + ) + .await; // A classic script import blocks this Worker task without sharing the // Fetch interception class. Release it only after the command is queued. tokio::time::timeout( @@ -127,8 +149,9 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { params["responseCode"] = json!(200); params["body"] = json!("Ym9keQ=="); } - command( + session_command( &mut ctx, + &session, 54_004, if fulfill { "Fetch.fulfillRequest" @@ -139,15 +162,22 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { ) .await; let network_id = &paused["params"]["networkId"]; - assert!( - !ctx.sent.iter().any(|event| { - matches!( - event["method"].as_str(), - Some("Network.loadingFinished" | "Network.loadingFailed") - ) && &event["params"]["requestId"] == network_id - }), - "response delivery must still be queued at the Worker" - ); + if fulfill { + // Completion is visible before the Worker has returned from JS. + wait_until_scheduler_message(&mut ctx, "fulfilled native Worker load", |event| { + event["method"] == "Network.loadingFinished" + && &event["params"]["requestId"] == network_id + }) + .await; + } else { + tokio::time::timeout( + std::time::Duration::from_secs(5), + ctx.drive_owned_wait(transport_entered_rx), + ) + .await + .expect("native transport starts while Worker JS is blocked") + .unwrap(); + } release_tx.send(()).unwrap(); let drained = command(&mut ctx, 54_005, "Runtime.evaluate", json!({ "expression":"deliveryPort.postMessage('probe');Promise.all([deliveryOutcome,deliveryDrained])", @@ -179,9 +209,21 @@ async fn check_worker_abort_before_request_delivery(shared: bool) { 1, "shared={shared}, fulfill={fulfill}: {terminals:?}" ); - assert_eq!(terminals[0]["method"], "Network.loadingFailed"); - assert_eq!(terminals[0]["params"]["errorText"], "net::ERR_ABORTED"); - assert_eq!(hits.load(Ordering::SeqCst), 0); + assert_eq!( + terminals[0]["method"], + if fulfill { + "Network.loadingFinished" + } else { + "Network.loadingFailed" + } + ); + if !fulfill { + assert_eq!(terminals[0]["params"]["errorText"], "net::ERR_ABORTED"); + } + let observer = ctx.worker_network_session_for_request(network_id); + assert_eq!(terminals[0]["sessionId"], observer); + assert_ne!(observer, "SID-1"); + assert_eq!(hits.load(Ordering::SeqCst), usize::from(!fulfill)); command(&mut ctx, 54_006, "Runtime.evaluate", json!({ "expression":if shared {"deliveryPort.close();'closed'"} else {"deliveryWorker.terminate();'terminated'"} })).await; diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_redirect_modes.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_redirect_modes.rs index 434210b833b..9a5d51d8289 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_redirect_modes.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_redirect_modes.rs @@ -44,6 +44,7 @@ async fn fulfilled_worker_redirect_modes_are_checked_after_response_security() { }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("{origin}/page"), "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; enable_runtime_async(&mut ctx, "SID-1", 53_000).await; command(&mut ctx, 53_001, "Network.enable", json!({})).await; let ready = command(&mut ctx, 53_002, "Runtime.evaluate", json!({ @@ -134,7 +135,8 @@ async fn fulfilled_worker_redirect_modes_are_checked_after_response_security() { ) .await; let value = &response["result"]["result"]["value"]; - let failure = (status != 200 && redirect == "error") || (foreign && mode == "cors"); + let failure = + (foreign && mode == "cors") || (!fulfill && redirect == "error" && status != 200); if failure { assert_eq!( value["error"], "TypeError", diff --git a/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_requests.rs b/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_requests.rs index 1c0fb72d473..a7ef9e2c377 100644 --- a/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_requests.rs +++ b/moli-protocol/src/domains/fetch/tests/runtime_fetch/worker_requests.rs @@ -51,6 +51,7 @@ fetch('/worker-api', { let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -142,6 +143,15 @@ fetch('/worker-api', { #[tokio::test(flavor = "multi_thread")] async fn csp_report_request_stage_continue_preserves_service_worker_dispatch() { + check_csp_report_service_worker_dispatch(false).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn worker_csp_report_fetch_pause_continue_preserves_service_worker_dispatch() { + check_csp_report_service_worker_dispatch(true).await; +} + +async fn check_csp_report_service_worker_dispatch(worker_report: bool) { async fn page() -> impl IntoResponse { ( [ @@ -194,7 +204,11 @@ self.addEventListener("fetch", event => { listener, Router::new() .route("/page", get(page)) - .route("/worker.js", get(worker)), + .route("/worker.js", get(worker)) + .route("/client-worker.js", get(|| async { ( + [("content-type","text/javascript"),("content-security-policy","connect-src 'none'; report-uri /csp-report")], + "onmessage=async()=>{await fetch('/blocked-data').catch(()=>{});postMessage('blocked');};" + ) })), ) .await .unwrap(); @@ -204,6 +218,7 @@ self.addEventListener("fetch", event => { let report_url = format!("http://{addr}/csp-report"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -243,14 +258,16 @@ self.addEventListener("fetch", event => { (async () => { await navigator.serviceWorker.register("/worker.js", { scope: "/" }); await navigator.serviceWorker.ready; - await fetch("/blocked-data").catch(() => {}); + REPORT_SOURCE globalThis.__lm_csp_report_blocked = "done"; })().catch(error => { globalThis.__lm_csp_report_continue_result = "error:" + String(error && error.message); }); return "scheduled"; -})()"# +})()"#.replace("REPORT_SOURCE", if worker_report { + "const worker=new Worker('/client-worker.js');globalThis.reportWorker=worker;worker.postMessage('start');" + } else {"await fetch('/blocked-data').catch(()=>{});"}) } })) .await; @@ -287,6 +304,16 @@ self.addEventListener("fetch", event => { ) .await; + if worker_report { + let network_id = paused["params"]["networkId"].clone(); + wait_until_scheduler_message(&mut ctx, "Worker report completed through SW", |event| { + event["method"] == "Network.loadingFinished" + && event["params"]["requestId"] == network_id + }) + .await; + let session = ctx.worker_network_session_for_request(&network_id); + assert_ne!(session, "SID-1"); + } server.abort(); } @@ -329,6 +356,7 @@ async fn csp_report_response_stage_take_body_as_stream_observes_report_body() { let report_url = format!("http://{addr}/csp-report"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -518,6 +546,7 @@ self.onmessage = async () => { let report_url = format!("http://{addr}/csp-report"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -679,6 +708,7 @@ globalThis.__lm_popup_csp_report_result = "pending"; let report_url = format!("http://{addr}/csp-report"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &opener_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -837,6 +867,7 @@ async fn csp_report_request_stage_fail_request_records_network_failure() { let report_url = format!("http://{addr}/csp-report"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -961,6 +992,7 @@ async fn csp_report_request_stage_fulfill_request_records_synthetic_response() { let report_url = format!("http://{addr}/csp-report"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -1117,6 +1149,7 @@ fetch('/worker-api-two') let api_two_url = format!("http://{addr}/worker-api-two"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -1301,6 +1334,7 @@ fetch('/worker-api') let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -1397,6 +1431,7 @@ xhr.send(); let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -1493,6 +1528,7 @@ xhr.send(); let api_url = format!("http://{addr}/worker-api?aux-worker-xhr=1"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.with_fixture(|conn| { assert!({ conn.browser_context @@ -1598,6 +1634,7 @@ xhr.send('payload'); let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -1744,6 +1781,7 @@ xhr.send(); let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -1884,6 +1922,7 @@ fetch('/worker-api') let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -2015,6 +2054,7 @@ fetch('/worker-api') let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -2159,6 +2199,7 @@ onmessage = event => { let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -2324,6 +2365,7 @@ fetch('/worker-auth') let api_url = format!("http://{addr}/worker-auth"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -2486,6 +2528,7 @@ fetch('/worker-auth') let api_url = format!("http://{addr}/worker-auth"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -2731,6 +2774,7 @@ fetch('/worker-auth') let api_url = format!("http://{addr}/worker-auth"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -2933,6 +2977,7 @@ fetch('/worker-api') let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -3107,6 +3152,7 @@ fetch('/worker-api') let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -3244,6 +3290,7 @@ fetch('/worker-api') let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -3355,10 +3402,11 @@ fetch('/worker-api') ) .await; + let network_session = ctx.worker_network_session_for_request(&json!(network_id)); ctx.process_async(json!({ "id": 37_506, "method": "Network.getResponseBody", - "sessionId": "SID-1", + "sessionId": network_session, "params": { "requestId": network_id } })) .await; @@ -3368,7 +3416,7 @@ fetch('/worker-api') "body": "worker-response-synthetic", "base64Encoded": false }), - Some("SID-1"), + Some(network_session.as_str()), ); server.abort(); @@ -3417,6 +3465,7 @@ fetch('/worker-api') let api_url = format!("http://{addr}/worker-api"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ @@ -3579,6 +3628,7 @@ postMessage(JSON.stringify({ error, status: xhr.status, text: xhr.responseText } let page_url = format!("http://{addr}/page"); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &page_url, "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.sent.clear(); ctx.process_async(json!({ diff --git a/moli-protocol/src/domains/fetch/tests/subresource_auth_retry.rs b/moli-protocol/src/domains/fetch/tests/subresource_auth_retry.rs index c182420aa0d..96c3473b971 100644 --- a/moli-protocol/src/domains/fetch/tests/subresource_auth_retry.rs +++ b/moli-protocol/src/domains/fetch/tests/subresource_auth_retry.rs @@ -131,6 +131,7 @@ async fn verify_request_budgets(kind: RequestKind) { }); let mut ctx = TestContext::new(); with_loaded_http_document(&mut ctx, &format!("http://{addr}/page"), "SID-1", "TID-1").await; + ctx.observe_worker_network_for_test(None).await; ctx.process_async(json!({ "id": 2997, "method": "Network.enable", "sessionId": "SID-1" })) .await; ctx.expect_result(2997, json!({}), Some("SID-1")); diff --git a/moli-protocol/src/domains/network/activity.rs b/moli-protocol/src/domains/network/activity.rs index 3acd438bc33..8d596352c71 100644 --- a/moli-protocol/src/domains/network/activity.rs +++ b/moli-protocol/src/domains/network/activity.rs @@ -104,6 +104,52 @@ impl PreparedSubresourceProjection { } impl NetworkPreparedOutputs { + pub(crate) fn from_worker_continue( + action: crate::domains::activity::PreparedSubresourceContinueAction, + ) -> Self { + Self { + pending_subresource_continue_actions: vec![action], + ..Default::default() + } + } + pub(crate) fn project_worker( + mut self, + conn: &mut CdpConnection, + owner: &CommandOwnerScope, + ) -> ( + Vec, + Vec, + Vec, + ) { + let mut events = Vec::new(); + super::backlog::emit_prepared_renderer_network_live_background_events( + conn, + &mut events, + owner, + &mut self.renderer_live, + ); + let sessions = conn.network_event_session_ids_for_owner(owner); + fetch::emit_subresource_fetch_pause_outputs( + conn, + &mut events, + owner, + &sessions, + self.subresource_fetch_pauses, + ); + let mut pending = Vec::new(); + for action in self.pending_subresource_continue_actions { + if let Some(wait) = crate::domains::activity::prepare_subresource_continue_action( + conn, + &mut events, + owner, + action, + ) { + pending.push(wait); + } + } + (events, self.automatic_subresource_continuations, pending) + } + pub(crate) fn from_renderer_live_delivery( renderer_live: TargetNetworkBacklogPreparedDelivery, ) -> Self { diff --git a/moli-protocol/src/domains/network/agent.rs b/moli-protocol/src/domains/network/agent.rs index 742a7a619f7..c63e694b925 100644 --- a/moli-protocol/src/domains/network/agent.rs +++ b/moli-protocol/src/domains/network/agent.rs @@ -86,7 +86,10 @@ impl<'a> NetworkBacklogRequestIdPlan<'a> { let request_id = self .preferred_request_id .take_for_new_subresource(output.request_handle()) - .unwrap_or_else(|| self.request_id_allocator.allocate_request_id()); + .unwrap_or_else(|| match output.request_handle() { + Some(handle) => self.request_id_allocator.request_id_for_native(handle), + None => self.request_id_allocator.allocate_request_id(), + }); if let Some(handle) = output.request_handle() { self.subresource_artifacts .set_request_id_for_handle_if_absent(handle, request_id.clone()); diff --git a/moli-protocol/src/domains/network/backlog.rs b/moli-protocol/src/domains/network/backlog.rs index b16dd69f23f..97a5f91f7f4 100644 --- a/moli-protocol/src/domains/network/backlog.rs +++ b/moli-protocol/src/domains/network/backlog.rs @@ -469,7 +469,7 @@ fn emit_staged_subresource_request_started( event_session_ids, ); } - if !request_was_announced_by_fetch_pause { + if !request_was_announced_by_fetch_pause || output.redirect().is_some() { for event_session_id in event_session_ids { emit_request_will_be_sent( out, @@ -485,13 +485,43 @@ fn emit_staged_subresource_request_started( output.request_headers(), resource_type, output.request_initiator_type(), - None, - false, + output.redirect().map(|redirect| { + ( + &redirect.from_url, + redirect.status, + redirect.headers.as_slice(), + redirect.from_cache, + redirect.negotiated_http_version, + ) + }), + output + .redirect() + .is_some_and(|redirect| !redirect.cookie_set_reports.is_empty()), output.request_cookie_report(), &[], ); } } + if let Some(redirect) = output.redirect() { + for session in event_session_ids { + emit_redirect_response_received_extra_info( + out, + session.as_deref(), + request_id, + &redirect.headers, + redirect.status, + &redirect.cookie_set_reports, + ); + } + if let Some(slot) = conn.runtime_session_owner_slot_mut_for_owner(owner) { + slot.record_fetch_pause_announced_redirect(request_id); + } + } + if conn.worker_resource_identity_for_owner(owner).is_some() + && let Some(slot) = conn.runtime_session_owner_slot_mut_for_owner(owner) + { + slot.record_fetch_pause_announced_request_id(request_id.to_owned()); + } out.len() > initial_output_len } @@ -763,7 +793,11 @@ pub(crate) fn emit_prepared_renderer_network_live_background_events( prepared: &mut TargetNetworkBacklogPreparedDelivery, ) { let Some((frame_id, snapshot)) = (|| { - let frame_id = conn.target_owner_identity_for_owner(owner)?.1?; + let frame_id = if conn.worker_resource_identity_for_owner(owner).is_some() { + String::new() + } else { + conn.target_owner_identity_for_owner(owner)?.1? + }; let snapshot = conn .runtime_session_owner_slot_mut_for_owner(owner)? .pending_network_backlog_delivery_snapshot_from_backlog(prepared)?; diff --git a/moli-protocol/src/domains/network/events.rs b/moli-protocol/src/domains/network/events.rs index 5633cfee2e0..855b7eefe24 100644 --- a/moli-protocol/src/domains/network/events.rs +++ b/moli-protocol/src/domains/network/events.rs @@ -287,7 +287,7 @@ pub(crate) fn emit_request_will_be_sent( out, AutomationEvent::NetworkBeforeRequestSent(NetworkRequestEvent { target_id: DevToolsTargetId::from(frame_id), - frame_id: Some(DevToolsFrameId::from(frame_id)), + frame_id: (!frame_id.is_empty()).then(|| DevToolsFrameId::from(frame_id)), request_id: DevToolsRequestId::from(request_id), loader_id: Some(DevToolsLoaderId::from(loader_id)), url: request_url.as_str().to_owned(), @@ -578,7 +578,7 @@ fn emit_response_received_with_extra_info_delivery( out, AutomationEvent::NetworkResponseStarted(NetworkRequestEvent { target_id: DevToolsTargetId::from(frame_id), - frame_id: Some(DevToolsFrameId::from(frame_id)), + frame_id: (!frame_id.is_empty()).then(|| DevToolsFrameId::from(frame_id)), request_id: DevToolsRequestId::from(request_id), loader_id: Some(DevToolsLoaderId::from(loader_id)), url: final_url.as_str().to_owned(), @@ -669,7 +669,7 @@ pub(crate) fn emit_loading_finished( out, AutomationEvent::NetworkResponseCompleted(NetworkRequestEvent { target_id: DevToolsTargetId::from(frame_id), - frame_id: Some(DevToolsFrameId::from(frame_id)), + frame_id: (!frame_id.is_empty()).then(|| DevToolsFrameId::from(frame_id)), request_id: DevToolsRequestId::from(request_id), loader_id: Some(DevToolsLoaderId::from(loader_id)), url: String::new(), @@ -776,7 +776,7 @@ pub(crate) fn emit_loading_failed( out, AutomationEvent::NetworkFetchError(NetworkRequestEvent { target_id: DevToolsTargetId::from(frame_id), - frame_id: Some(DevToolsFrameId::from(frame_id)), + frame_id: (!frame_id.is_empty()).then(|| DevToolsFrameId::from(frame_id)), request_id: DevToolsRequestId::from(request_id), loader_id: Some(DevToolsLoaderId::from(loader_id)), url: String::new(), @@ -845,7 +845,6 @@ pub(crate) fn emit_cdp_network_automation_event( .resource_type .map(DevToolsNetworkResourceType::as_cdp_type) .unwrap_or_default(), - "frameId": network_event.frame_id.as_ref().map(|id| id.as_str()).unwrap_or(""), "response": { "url": network_event.url.as_str(), "status": network_event.status.unwrap_or_default(), @@ -864,6 +863,9 @@ pub(crate) fn emit_cdp_network_automation_event( }, "hasExtraInfo": network_event.has_extra_info, }); + if let Some(frame_id) = network_event.frame_id.as_ref() { + params["frameId"] = json!(frame_id.as_str()); + } if let Some(fetch_request_id) = network_event.fetch_request_id.as_ref() { params["__moliFetchRequestId"] = json!(fetch_request_id.as_str()); } @@ -964,9 +966,11 @@ fn emit_network_before_request_sent( .resource_type .map(DevToolsNetworkResourceType::as_cdp_type) .unwrap_or_default(), - "frameId": network_event.frame_id.as_ref().map(|id| id.as_str()).unwrap_or(""), "hasUserGesture": false, }); + if let Some(frame_id) = network_event.frame_id.as_ref() { + params["frameId"] = json!(frame_id.as_str()); + } if let Some(request_body) = network_event.request_body.as_ref() { params["request"]["postData"] = json!(request_body); } diff --git a/moli-protocol/src/domains/network/output.rs b/moli-protocol/src/domains/network/output.rs index df839360016..55a1f6c2b9c 100644 --- a/moli-protocol/src/domains/network/output.rs +++ b/moli-protocol/src/domains/network/output.rs @@ -60,6 +60,7 @@ impl TargetSubresourceFetchPauseOutput { #[derive(Clone, Debug, PartialEq)] pub(crate) struct TargetSubresourceFetchPauseNetworkOutput { + observe_network: bool, network_request_id: String, request_handle: Option, frame_id: String, @@ -90,6 +91,7 @@ impl TargetSubresourceFetchPauseNetworkOutput { info: &PendingSubresourceFetchInfo, ) -> Self { Self { + observe_network: true, network_request_id, request_handle: info.network_request_handle, frame_id, @@ -111,6 +113,13 @@ impl TargetSubresourceFetchPauseNetworkOutput { } } + pub(crate) fn with_network_observation(mut self, observe: bool) -> Self { + self.observe_network = observe; + self + } + pub(crate) fn observes_network(&self) -> bool { + self.observe_network + } pub(crate) fn with_redirect( mut self, redirect: Option, diff --git a/moli-protocol/src/domains/network/output_queue.rs b/moli-protocol/src/domains/network/output_queue.rs index 901ff7de562..a1d1e1511d9 100644 --- a/moli-protocol/src/domains/network/output_queue.rs +++ b/moli-protocol/src/domains/network/output_queue.rs @@ -1363,6 +1363,7 @@ impl TargetSubresourcePlanOutput { #[derive(Clone, Debug, Eq, PartialEq)] pub(crate) struct TargetSubresourceRequestStartedOutput { + redirect: Option>, delivery_order_index: usize, index: usize, loader_id: String, @@ -1387,6 +1388,7 @@ impl TargetSubresourceRequestStartedOutput { request: &SubresourceRequestStarted, ) -> Self { Self { + redirect: request.redirect().cloned().map(Box::new), delivery_order_index, index, loader_id: loader_id.to_owned(), @@ -1404,6 +1406,9 @@ impl TargetSubresourceRequestStartedOutput { } } + pub(crate) fn redirect(&self) -> Option<&moli_core::page::NavigationRedirect> { + self.redirect.as_deref() + } pub(crate) fn delivery_order_index(&self) -> usize { self.delivery_order_index } diff --git a/moli-protocol/src/domains/network/tests/blocked_urls.rs b/moli-protocol/src/domains/network/tests/blocked_urls.rs index 01a9fb7f796..79ce5b127d1 100644 --- a/moli-protocol/src/domains/network/tests/blocked_urls.rs +++ b/moli-protocol/src/domains/network/tests/blocked_urls.rs @@ -495,6 +495,7 @@ async fn set_blocked_urls_worker_fetch_emits_loading_failed() { bc.attach_active_session("SID-1"); ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc)); + ctx.observe_worker_network_for_test(None).await; ctx.process_async(json!({ "id": 28_101, "method": "Network.enable", @@ -579,7 +580,10 @@ async fn set_blocked_urls_worker_fetch_emits_loading_failed() { .find(|message| message["method"] == json!("Network.loadingFailed")) .cloned() .expect("network loadingFailed event"); - assert_eq!(failed["sessionId"], "SID-1"); + assert_eq!( + failed["sessionId"], + ctx.worker_network_session_for_request(&failed["params"]["requestId"]) + ); assert_eq!(failed["params"]["type"], "Fetch"); assert_eq!(failed["params"]["errorText"], "net::ERR_BLOCKED_BY_CLIENT"); let request_id = failed["params"]["requestId"] @@ -639,6 +643,7 @@ async fn set_blocked_urls_worker_xhr_emits_loading_failed() { bc.attach_active_session("SID-1"); ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc)); + ctx.observe_worker_network_for_test(None).await; ctx.process_async(json!({ "id": 28_102, "method": "Network.enable", @@ -724,7 +729,10 @@ async fn set_blocked_urls_worker_xhr_emits_loading_failed() { .find(|message| message["method"] == json!("Network.loadingFailed")) .cloned() .expect("network loadingFailed event"); - assert_eq!(failed["sessionId"], "SID-1"); + assert_eq!( + failed["sessionId"], + ctx.worker_network_session_for_request(&failed["params"]["requestId"]) + ); assert_eq!(failed["params"]["type"], "XHR"); assert_eq!(failed["params"]["errorText"], "net::ERR_BLOCKED_BY_CLIENT"); let request_id = failed["params"]["requestId"] @@ -779,6 +787,7 @@ async fn set_blocked_urls_worker_websocket_emits_dedicated_failure_events() { bc.attach_active_session("SID-1"); ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc)); + ctx.observe_worker_network_for_test(None).await; ctx.process_async(json!({ "id": 28_103, "method": "Network.enable", @@ -902,6 +911,7 @@ async fn emulate_network_conditions_offline_worker_fetch_emits_loading_failed() .enable_primary_network_events(); ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc)); + ctx.observe_worker_network_for_test(None).await; ctx.process_async(json!({ "id": 2821, "method": "Page.navigate", @@ -974,7 +984,10 @@ async fn emulate_network_conditions_offline_worker_fetch_emits_loading_failed() .find(|message| message["method"] == json!("Network.loadingFailed")) .cloned() .expect("network loadingFailed event"); - assert_eq!(failed["sessionId"], "SID-1"); + assert_eq!( + failed["sessionId"], + ctx.worker_network_session_for_request(&failed["params"]["requestId"]) + ); assert_eq!(failed["params"]["type"], "Fetch"); assert_eq!(failed["params"]["errorText"], "Network emulation offline"); ctx.process_async(json!({ @@ -1018,6 +1031,7 @@ async fn emulate_network_conditions_offline_worker_xhr_emits_loading_failed() { .enable_primary_network_events(); ctx.with_fixture(|conn| conn.install_browser_context_fixture_for_test(bc)); + ctx.observe_worker_network_for_test(None).await; ctx.process_async(json!({ "id": 2826, "method": "Page.navigate", @@ -1091,7 +1105,10 @@ async fn emulate_network_conditions_offline_worker_xhr_emits_loading_failed() { .find(|message| message["method"] == json!("Network.loadingFailed")) .cloned() .expect("network loadingFailed event"); - assert_eq!(failed["sessionId"], "SID-1"); + assert_eq!( + failed["sessionId"], + ctx.worker_network_session_for_request(&failed["params"]["requestId"]) + ); assert_eq!(failed["params"]["type"], "XHR"); assert_eq!(failed["params"]["errorText"], "Network emulation offline"); ctx.process_async(json!({ diff --git a/moli-protocol/src/domains/target.rs b/moli-protocol/src/domains/target.rs index 90d252c258f..0b4d2b3f157 100644 --- a/moli-protocol/src/domains/target.rs +++ b/moli-protocol/src/domains/target.rs @@ -48,8 +48,8 @@ pub(crate) use worker_target::{ CapturedWorkerAttachment, DedicatedWorkerRetirementIdentity, PreparedDedicatedWorkerProjectionDisposal, PreparedDedicatedWorkerRetirement, RemovedSharedWorkerAttachment, WorkerRetirementFailureCleanup, WorkerTargetLifecycleOutput, - WorkerTargetOutputProjection, prepare_worker_inspector_projection, project_worker_target_event, - retain_events, + WorkerTargetOutputProjection, prepare_worker_inspector_projection, prepare_worker_resource, + project_worker_target_event, retain_events, }; pub(crate) enum TargetCommandFailureCleanup { @@ -218,6 +218,9 @@ fn sync_dedicated_worker_pause_on_start_for_devtools(conn: &CdpConnection) { .collect::>(); for runtime in runtimes { runtime.set_dedicated_worker_pause_on_start_for_devtools(pause); + runtime.set_shared_worker_pause_on_start_for_devtools( + conn.shared_worker_pause_on_start_for_devtools(), + ); } } diff --git a/moli-protocol/src/domains/target/worker_target.rs b/moli-protocol/src/domains/target/worker_target.rs index af79b508e48..cb71ca27f53 100644 --- a/moli-protocol/src/domains/target/worker_target.rs +++ b/moli-protocol/src/domains/target/worker_target.rs @@ -53,6 +53,8 @@ use serde_json::Value; use super::events; +mod resource_loading; +pub(crate) use resource_loading::prepare as prepare_worker_resource; mod lifecycle_projection; use lifecycle_projection::*; mod dedicated_worker; @@ -98,6 +100,11 @@ pub(in crate::domains) struct TargetPreparedOutputs { #[derive(Debug, PartialEq)] pub(crate) enum WorkerTargetLifecycleOutput { + Resource { + browser_context_id: String, + target_id: String, + event: moli_core::network::ResourceInterceptionEvent, + }, DedicatedWorkerEvents { browser_context_id: String, renderer_instance_id: u64, diff --git a/moli-protocol/src/domains/target/worker_target/event_projection.rs b/moli-protocol/src/domains/target/worker_target/event_projection.rs index a37217b3083..7735d39bcc6 100644 --- a/moli-protocol/src/domains/target/worker_target/event_projection.rs +++ b/moli-protocol/src/domains/target/worker_target/event_projection.rs @@ -31,6 +31,13 @@ impl WorkerTargetOutputProjection { for event in self.events { let result: Result<()> = async { match event { + WorkerTargetLifecycleOutput::Resource { browser_context_id, target_id, event } => { + if let Some((events, automatic, pending)) = context.with_state(driver, move |state, _| state.prepare_worker_resource(browser_context_id,target_id,event))? { + retain_events(context,events); + for continuation in automatic { continuation.run(driver).await?; } + for continuation in pending { retain_events(context,continuation.run(driver).await?); } + } + } WorkerTargetLifecycleOutput::DedicatedWorkerDetached { target_delta, cleanup_plan, @@ -318,6 +325,9 @@ pub(crate) fn project_worker_target_event( let mut side_effects = events::TargetProtocolSideEffects::default(); for event in std::iter::once(event) { match event { + WorkerTargetLifecycleOutput::Resource { .. } => { + unreachable!("Worker resource projection is asynchronous") + } WorkerTargetLifecycleOutput::DedicatedWorkerEvents { browser_context_id, renderer_instance_id, diff --git a/moli-protocol/src/domains/target/worker_target/lifecycle_projection.rs b/moli-protocol/src/domains/target/worker_target/lifecycle_projection.rs index b5e9355e8bf..2fd304bcdc0 100644 --- a/moli-protocol/src/domains/target/worker_target/lifecycle_projection.rs +++ b/moli-protocol/src/domains/target/worker_target/lifecycle_projection.rs @@ -52,6 +52,21 @@ pub(super) fn shared_worker_target_lifecycle_outputs_for_events( let mut outputs = TargetPreparedOutputs::default(); for event in events { match event { + RendererSharedWorkerTargetEvent::Resource { instance_id, event } => { + if let Some(target_id) = conn + .browser_context_by_id(&browser_context_id) + .and_then(|context| { + context.shared_worker_target_id_for_renderer_instance(instance_id) + }) + .map(str::to_owned) + { + outputs.push(WorkerTargetLifecycleOutput::Resource { + browser_context_id: browser_context_id.clone(), + target_id, + event, + }); + } + } RendererSharedWorkerTargetEvent::Created(info) => { let owner_target_id = conn.browser_context_by_id(&browser_context_id) @@ -174,6 +189,19 @@ pub(super) fn dedicated_worker_target_lifecycle_outputs_for_events( let mut outputs = TargetPreparedOutputs::default(); for event in events { match event { + RendererDedicatedWorkerTargetEvent::Resource { instance_id, event } => { + if let Some(target_id) = conn + .browser_context_by_id(&browser_context_id) + .and_then(|context| context.dedicated_worker_targets.get(&instance_id)) + .map(|target| target.target_id.clone()) + { + outputs.push(WorkerTargetLifecycleOutput::Resource { + browser_context_id: browser_context_id.clone(), + target_id, + event, + }); + } + } RendererDedicatedWorkerTargetEvent::Created(info) => { outputs.extend(register_dedicated_worker_target( conn, diff --git a/moli-protocol/src/domains/target/worker_target/resource_loading.rs b/moli-protocol/src/domains/target/worker_target/resource_loading.rs new file mode 100644 index 00000000000..0cb95c1d7ce --- /dev/null +++ b/moli-protocol/src/domains/target/worker_target/resource_loading.rs @@ -0,0 +1,56 @@ +use super::*; +use moli_core::network::ResourceInterceptionEvent; + +pub(crate) fn prepare( + conn: &mut CdpConnection, + browser_context_id: String, + target_id: String, + event: ResourceInterceptionEvent, +) -> Option<( + Vec, + Vec, + Vec, +)> { + conn.browser_context_by_id(&browser_context_id)? + .worker_resource_target(&target_id)?; + let route = if conn + .browser_context_by_id(&browser_context_id)? + .shared_worker_target(&target_id) + .is_some() + { + CdpSessionRoute::SharedWorkerTarget { + browser_context_id: browser_context_id.clone(), + target_id: target_id.clone(), + } + } else { + CdpSessionRoute::DedicatedWorkerTarget { + browser_context_id: browser_context_id.clone(), + target_id: target_id.clone(), + } + }; + let owner = CommandOwnerScope::for_route(route); + let outputs = match event { + ResourceInterceptionEvent::Network(item) => { + let delivery = + conn.ingest_worker_network_output(&browser_context_id, &target_id, &item)?; + network::NetworkPreparedOutputs::from_renderer_live_delivery(delivery) + } + ResourceInterceptionEvent::Request { info, pause } => { + crate::domains::fetch::worker_fetch_pause_prepared_outputs( + conn, + &owner, + browser_context_id, + target_id, + *info, + pause, + ) + } + ResourceInterceptionEvent::Continue { event, pause } => { + let action = crate::domains::activity::prepare_worker_subresource_continue_action( + conn, &owner, *event, pause, + ); + network::NetworkPreparedOutputs::from_worker_continue(action) + } + }; + Some(outputs.project_worker(conn, &owner)) +} diff --git a/moli-protocol/src/domains/target/worker_target/shared_worker.rs b/moli-protocol/src/domains/target/worker_target/shared_worker.rs index 68d4136a465..dd99fbf969a 100644 --- a/moli-protocol/src/domains/target/worker_target/shared_worker.rs +++ b/moli-protocol/src/domains/target/worker_target/shared_worker.rs @@ -30,14 +30,16 @@ pub(super) fn register_shared_worker_target( let Some(context) = conn.browser_context_by_id_mut(browser_context_id) else { return outputs; }; - context.insert_shared_worker_target(SharedWorkerTargetState::new( + let mut state = SharedWorkerTargetState::new( info.owner_local_host_id, info.instance_id, target_id.clone(), owner_target_id, info.url, info.name, - )); + ); + state.interception_policy = info.interception_policy; + context.insert_shared_worker_target(state); let snapshot = context.devtools_target_info(&target_id); debug_assert!(snapshot.is_some()); snapshot diff --git a/moli-protocol/src/domains/target/worker_target/tests.rs b/moli-protocol/src/domains/target/worker_target/tests.rs index f0cdc052926..9a9b8c92542 100644 --- a/moli-protocol/src/domains/target/worker_target/tests.rs +++ b/moli-protocol/src/domains/target/worker_target/tests.rs @@ -134,6 +134,7 @@ fn commit_worker_attach_outputs_for_test( fn shared_worker_info(instance_id: u64) -> RendererSharedWorkerTargetInfo { RendererSharedWorkerTargetInfo { + interception_policy: None, owner_local_host_id: moli_core::RendererOwnerLocalHostId::new_for_testing(1), instance_id: SharedWorkerInstanceId::from_u64(instance_id), url: "https://example.test/shared-worker.js".to_owned(), diff --git a/moli-protocol/src/domains/target/worker_target_attachment_tests.rs b/moli-protocol/src/domains/target/worker_target_attachment_tests.rs index 62eda860c68..810b2560247 100644 --- a/moli-protocol/src/domains/target/worker_target_attachment_tests.rs +++ b/moli-protocol/src/domains/target/worker_target_attachment_tests.rs @@ -24,6 +24,7 @@ const INSTANCE_ID: u64 = 701; fn renderer_info(instance_id: u64) -> RendererSharedWorkerTargetInfo { RendererSharedWorkerTargetInfo { + interception_policy: None, owner_local_host_id: RendererOwnerLocalHostId::new_for_testing(17), instance_id: SharedWorkerInstanceId::from_u64(instance_id), url: "https://worker.test/shared.js".to_owned(), diff --git a/moli-protocol/src/testing.rs b/moli-protocol/src/testing.rs index d3851337dbf..f5893f4fc3b 100644 --- a/moli-protocol/src/testing.rs +++ b/moli-protocol/src/testing.rs @@ -44,6 +44,8 @@ const TEST_SCHEDULER_INPUT_TIMEOUT: Duration = Duration::from_secs(30); pub struct TestContext { pub state: crate::ProtocolStateOwner, pub sent: Vec, + #[cfg(test)] + worker_network_observer: Option, pending_runtime_deferred_replies: VecDeque, pending_protocol_scheduler_work: VecDeque, pending_owned_protocol_work: @@ -202,6 +204,8 @@ impl TestContext { ready = &mut wait => return ready, turn = Box::pin(self.wait_for_one_test_scheduler_turn()) => { assert!(matches!(turn, TestSchedulerTurnOutcome::Processed(_)), "owned wait lost scheduler inputs"); + #[cfg(test)] + Box::pin(self.service_test_worker_observers()).await; } } } @@ -816,6 +820,8 @@ impl TestContext { Self { state: crate::ProtocolStateOwner::new(conn), sent: Vec::new(), + #[cfg(test)] + worker_network_observer: None, pending_runtime_deferred_replies: VecDeque::new(), pending_protocol_scheduler_work: VecDeque::new(), pending_owned_protocol_work: FuturesUnordered::new(), @@ -1053,6 +1059,8 @@ impl TestContext { { Box::pin(self.wait_for_test_command_response(command_id, response_start)).await; } + #[cfg(test)] + Box::pin(self.service_test_worker_observers()).await; } /// Navigate as a CDP client that subscribes to Page notifications. @@ -2178,6 +2186,12 @@ impl TestContext { } async fn wait_for_one_test_scheduler_turn(&mut self) -> TestSchedulerTurnOutcome { + let result = Box::pin(self.wait_for_one_test_scheduler_turn_unobserved()).await; + Box::pin(self.service_test_worker_observers()).await; + result + } + + async fn wait_for_one_test_scheduler_turn_unobserved(&mut self) -> TestSchedulerTurnOutcome { let ready = Box::pin(self.run_one_ready_test_scheduler_turn()).await; if matches!(ready, TestSchedulerTurnOutcome::Processed(_)) { return ready; @@ -2752,6 +2766,7 @@ impl TestContext { let scheduler_events = self.with_fixture(|conn| conn.take_scheduler_events()); Box::pin(self.route_test_scheduler_causal_batch(Vec::new(), scheduler_events)).await; let _ = Box::pin(self.run_one_ready_test_scheduler_turn()).await; + Box::pin(self.service_test_worker_observers()).await; } // ── Internal ────────────────────────────────────────────────────────────── @@ -3098,6 +3113,8 @@ mod tests { let mut ctx = TestContext { state: crate::ProtocolStateOwner::new(conn), sent: Vec::new(), + #[cfg(test)] + worker_network_observer: None, pending_runtime_deferred_replies: VecDeque::new(), pending_protocol_scheduler_work: VecDeque::new(), pending_owned_protocol_work: FuturesUnordered::new(), @@ -3154,3 +3171,166 @@ mod tests { )); } } + +#[cfg(test)] +#[derive(Default)] +struct TestWorkerNetworkObserver { + sessions: std::collections::HashSet, + shared_sessions: Vec, + requests: std::collections::HashMap, + shared_fetch: Option<(Value, usize)>, + servicing: bool, +} +#[cfg(test)] +impl TestContext { + pub(crate) async fn observe_worker_network_for_test( + &mut self, + shared_fetch: Option<(Value, usize)>, + ) { + self.worker_network_observer = Some(TestWorkerNetworkObserver { + shared_fetch, + ..Default::default() + }); + self.process_async(serde_json::json!({"id":90_000_000,"method":"Target.setAutoAttach","params":{"autoAttach":true,"waitForDebuggerOnStart":true,"flatten":true,"filter":[{"type":"worker","exclude":false},{"type":"shared_worker","exclude":false},{"exclude":true}]}})).await; + self.expect_result(90_000_000, serde_json::json!({}), None); + self.process_async(serde_json::json!({"id":90_000_006,"sessionId":"SID-1","method":"Target.setAutoAttach","params":{"autoAttach":true,"waitForDebuggerOnStart":true,"flatten":true,"filter":[{"type":"worker","exclude":false},{"exclude":true}]}})).await; + self.expect_result(90_000_006, serde_json::json!({}), Some("SID-1")); + } + pub(crate) fn worker_network_session_for_request(&self, id: &Value) -> String { + self.worker_network_observer + .as_ref() + .and_then(|observer| observer.requests.get(id.as_str()?)) + .cloned() + .expect("request must have been announced by the actual Worker Network session") + } + pub(crate) async fn shared_worker_fetch_sessions_for_test(&mut self) -> Vec { + tokio::time::timeout(TEST_SCHEDULER_INPUT_TIMEOUT, async { + loop { + Box::pin(self.service_test_worker_observers()).await; + if !self + .worker_network_observer + .as_ref() + .unwrap() + .shared_sessions + .is_empty() + { + break; + } + Box::pin(self.wait_for_one_test_scheduler_turn()).await; + } + }) + .await + .expect("SharedWorker target attaches and its observer is configured"); + self.worker_network_observer + .as_ref() + .unwrap() + .shared_sessions + .clone() + } + async fn service_test_worker_observers(&mut self) { + let Some(observer) = &mut self.worker_network_observer else { + return; + }; + if observer.servicing { + return; + } + observer.servicing = true; + loop { + let next = self + .sent + .iter() + .find(|message| { + message["method"] == "Target.attachedToTarget" + && matches!( + message["params"]["targetInfo"]["type"].as_str(), + Some("worker" | "shared_worker") + ) + && message["params"]["sessionId"].as_str().is_some_and(|id| { + !self + .worker_network_observer + .as_ref() + .unwrap() + .sessions + .contains(id) + }) + }) + .cloned(); + let Some(next) = next else { + break; + }; + let session = next["params"]["sessionId"].as_str().unwrap().to_owned(); + let shared = next["params"]["targetInfo"]["type"] == "shared_worker"; + self.worker_network_observer + .as_mut() + .unwrap() + .sessions + .insert(session.clone()); + self.process_async( + serde_json::json!({"id":90_000_001,"method":"Network.enable","sessionId":session}), + ) + .await; + self.expect_result(90_000_001, serde_json::json!({}), Some(session.as_str())); + if shared { + self.worker_network_observer + .as_mut() + .unwrap() + .shared_sessions + .push(session.clone()); + if let Some((patterns, count)) = self + .worker_network_observer + .as_ref() + .unwrap() + .shared_fetch + .clone() + { + self.process_async(serde_json::json!({"id":90_000_002,"method":"Fetch.enable","sessionId":session,"params":{"patterns":patterns}})).await; + self.expect_result(90_000_002, serde_json::json!({}), Some(session.as_str())); + for _ in 1..count { + self.process_async(serde_json::json!({"id":90_000_003,"method":"Target.attachToTarget","params":{"targetId":next["params"]["targetInfo"]["targetId"],"flatten":true}})).await; + let response = self + .sent + .iter() + .find(|message| message["id"] == 90_000_003) + .cloned() + .expect("second Worker session attaches"); + let peer = response["result"]["sessionId"].as_str().unwrap().to_owned(); + self.worker_network_observer + .as_mut() + .unwrap() + .sessions + .insert(peer.clone()); + self.worker_network_observer + .as_mut() + .unwrap() + .shared_sessions + .push(peer.clone()); + self.sent.retain(|message| message["id"] != 90_000_003); + self.process_async(serde_json::json!({"id":90_000_004,"method":"Fetch.enable","sessionId":peer,"params":{"patterns":patterns}})).await; + self.expect_result(90_000_004, serde_json::json!({}), Some(peer.as_str())); + } + } + } + self.process_async(serde_json::json!({"id":90_000_005,"method":"Runtime.runIfWaitingForDebugger","sessionId":session})).await; + self.expect_result(90_000_005, serde_json::json!({}), Some(session.as_str())); + } + let observer = self.worker_network_observer.as_mut().unwrap(); + for message in &self.sent { + if message["method"] == "Network.requestWillBeSent" + && message["sessionId"] + .as_str() + .is_some_and(|id| observer.sessions.contains(id)) + { + assert!( + message["params"].get("frameId").is_none(), + "Worker request has no frameId: {message}" + ); + assert_eq!(message["params"]["loaderId"], ""); + observer.requests.insert( + message["params"]["requestId"].as_str().unwrap().to_owned(), + message["sessionId"].as_str().unwrap().to_owned(), + ); + } + } + observer.servicing = false; + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs index d9fd91acf77..e0f66ed2f1b 100644 --- a/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs +++ b/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs @@ -314,7 +314,6 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( resolved_url.to_string(), creator_request_client.clone(), ) - .with_interception_context(host.native_interception_context()) .with_script_kind(worker_options.worker_type) .with_module_credentials_mode(worker_options.credentials_mode.0) .with_module_static_import_initiator_url(base_url.clone()) @@ -338,19 +337,16 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( if let Some(client_id) = reserved_service_worker_client_id { options = options.with_reserved_service_worker_client_id(client_id); } - let worker_handle = spawn_worker_with_options(options); - let worker_id = - host.register_worker(scope, worker, worker_handle, execution_context_owner); - let recorded = host.record_dedicated_worker_target_created( - worker_id, + let wait_for_debugger = options.pause_evaluation_until_debugger; + let worker_id = host.register_worker( + scope, + worker, + options, + execution_context_owner, base_url.clone(), request_url, worker_options.name.clone(), ); - debug_assert!( - recorded, - "newly registered local DedicatedWorker must publish its target" - ); let recorded = host.record_dedicated_worker_target_script_loaded( worker_id, resolved_url.to_string(), @@ -360,6 +356,10 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( recorded, "newly registered local DedicatedWorker must publish its main script response" ); + host.publish_live_turn_output_prefix(); + if !wait_for_debugger { + host.start_registered_local_worker(worker_id); + } worker_id } else { let cross_origin_http_worker_script = diff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs index aba0a11f7b8..6c87e8edd87 100644 --- a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs +++ b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs @@ -38,10 +38,10 @@ pub(crate) fn dispatch_worker_event<'s>( *event_kind, ) } + #[cfg(test)] + WorkerToParentMessage::PendingSubresourceFetch(_) + | WorkerToParentMessage::SubresourceContinue(_) => false, WorkerToParentMessage::SubresourceNetwork(_) - | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } - | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) | WorkerToParentMessage::WebSocketFrame(_) diff --git a/moli-renderer-v8/src/native_bridge/context_host/activity.rs b/moli-renderer-v8/src/native_bridge/context_host/activity.rs index ad6513c07bd..2bd70cdc01f 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/activity.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/activity.rs @@ -544,7 +544,7 @@ impl PageScriptHost { &mut self, ) -> Option { Some( - crate::network::interception_output::ResourceInterceptionContext { + crate::network::interception_output::ResourceInterceptionContext::Document { source_document: self.root_document_lifecycle_identity()?, output: self.native_interception_output()?, }, diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs index 2792863cf52..d5f314524f4 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/core.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs @@ -600,7 +600,6 @@ impl PageScriptHost { pending_subresource_fetch_infos: Vec::new(), running_subresource_fetches: HashMap::new(), streaming_subresource_fetches: HashMap::new(), - in_flight_worker_subresource_fetches: HashMap::new(), #[cfg(test)] pending_subresource_continue_events: Vec::new(), pending_network_body_sources: HashMap::new(), diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs index 0d7182a647b..2a509ab059e 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs @@ -35,9 +35,8 @@ use crate::{ shared_worker_runtime::SharedWorkerClientEndpointOwner, style_engine::MoliStyleEngine, types::{ - BroadcastChannelId, DedicatedWorkerId, ImageRequestKey, - InFlightWorkerSubresourceFetchState, MessagePortId, NetworkBodySourceId, - PendingSubresourceAuthState, PendingSubresourceFetchState, + BroadcastChannelId, DedicatedWorkerId, ImageRequestKey, MessagePortId, + NetworkBodySourceId, PendingSubresourceAuthState, PendingSubresourceFetchState, PendingSubresourceResponseState, PendingWebSocketResponseState, RunningSubresourceFetchState, ScriptErrorConstructorKind, ScriptNetworkOutputItem, StreamingSubresourceFetchState, @@ -1106,7 +1105,6 @@ pub(crate) struct PageScriptHost { pending_subresource_fetch_infos: Vec, running_subresource_fetches: HashMap, streaming_subresource_fetches: HashMap, - in_flight_worker_subresource_fetches: HashMap, #[cfg(test)] pending_subresource_continue_events: Vec, pub(crate) pending_network_body_sources: diff --git a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs index 45825a6acf1..8ef8101580c 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs @@ -1,35 +1,21 @@ use super::{OwnerDispatchScope, PageScriptHost}; use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind, ResourceLoadLease}; -use crate::types::DedicatedWorkerId; use crate::{ module_runtime::{ModuleAttributesKey, PendingDynamicModuleImport, WasmModuleRecord}, page_task_queue::RendererResourceCompletionSender, renderer_resource_scheduler::RendererResourceScheduler, types::{ - InFlightWorkerSubresourceFetchState, NetworkBodySourceId, PendingSubresourceAuthInfo, - PendingSubresourceAuthState, PendingSubresourceContinuation, + NetworkBodySourceId, PendingSubresourceAuthState, PendingSubresourceContinuation, PendingSubresourceContinueEvent, PendingSubresourceExecutionContext, - PendingSubresourceFetchInfo, PendingSubresourceFetchState, PendingSubresourceResponseInfo, - PendingSubresourceResponseState, PendingWebSocketConnection, PendingWebSocketResponseState, - RunningSubresourceFetchState, ScriptNetworkOutput, ScriptNetworkOutputItem, - StreamingSubresourceFetchState, SubresourceBodyFinished, SubresourceFetchRegistration, - SubresourceNetworkRecord, SubresourceNetworkRequestHandle, SubresourceRequestInitiatorType, + PendingSubresourceFetchInfo, PendingSubresourceFetchState, PendingSubresourceResponseState, + PendingWebSocketConnection, PendingWebSocketResponseState, RunningSubresourceFetchState, + ScriptNetworkOutput, ScriptNetworkOutputItem, StreamingSubresourceFetchState, + SubresourceBodyFinished, SubresourceFetchRegistration, SubresourceNetworkRecord, + SubresourceNetworkRequestHandle, SubresourceRequestInitiatorType, SubresourceRequestStarted, SubresourceResourceType, SubresourceResponseBody, SubresourceResponseStarted, }, }; -use moli_shared_worker::SharedWorkerInstanceId; - -fn navigation_response_from_subresource_body( - body: &SubresourceResponseBody, - head: moli_fetch::ResponseHead, -) -> crate::types::NavigationResponse { - let bytes = body.materialize_bytes().unwrap_or_default(); - crate::types::NavigationResponse::from_head_and_materialized_body( - head, - moli_fetch::ResponseBody::materialized_bytes(bytes), - ) -} impl PageScriptHost { #[cfg(test)] @@ -757,235 +743,6 @@ impl PageScriptHost { internal_id } - pub(crate) fn record_pending_worker_subresource_fetch( - &mut self, - context: v8::Global, - worker_id: DedicatedWorkerId, - fetch_id: u32, - load: ResourceLoadLease, - credentials_mode: moli_fetch::RequestCredentialsMode, - request_mode: moli_fetch::RequestMode, - network_partition_key: Option, - mut info: PendingSubresourceFetchInfo, - ) { - self.assign_pending_subresource_fetch_identity(&mut info); - self.push_pending_subresource_fetch_info(info.clone()); - self.pending_subresource_fetches.insert( - info.internal_id, - PendingSubresourceFetchState { - dispatch: None, - redirect_headers: None, - request_origin: moli_url::WebOrigin::from_url(&info.document_url), - info, - load, - execution_context: PendingSubresourceExecutionContext::adapter( - OwnerDispatchScope::Top, - context, - ), - credentials_mode, - request_mode, - network_partition_key, - policy_context: Default::default(), - continuation: PendingSubresourceContinuation::WorkerFetch { - worker_id, - fetch_id, - }, - deferred_request_started: false, - }, - ); - self.note_subresource_activity(); - } - - pub(crate) fn record_pending_worker_subresource_xhr( - &mut self, - context: v8::Global, - worker_id: DedicatedWorkerId, - xhr_id: u32, - load: ResourceLoadLease, - credentials_mode: moli_fetch::RequestCredentialsMode, - network_partition_key: Option, - mut info: PendingSubresourceFetchInfo, - ) { - self.assign_pending_subresource_fetch_identity(&mut info); - self.push_pending_subresource_fetch_info(info.clone()); - self.pending_subresource_fetches.insert( - info.internal_id, - PendingSubresourceFetchState { - dispatch: None, - redirect_headers: None, - request_origin: moli_url::WebOrigin::from_url(&info.document_url), - info, - load, - execution_context: PendingSubresourceExecutionContext::adapter( - OwnerDispatchScope::Top, - context, - ), - credentials_mode, - request_mode: moli_fetch::RequestMode::Cors, - network_partition_key, - policy_context: Default::default(), - continuation: PendingSubresourceContinuation::WorkerXhr { worker_id, xhr_id }, - deferred_request_started: false, - }, - ); - self.note_subresource_activity(); - } - - pub(crate) fn record_pending_worker_subresource_csp_report( - &mut self, - context: v8::Global, - worker_id: DedicatedWorkerId, - report_id: u32, - load: ResourceLoadLease, - credentials_mode: moli_fetch::RequestCredentialsMode, - request_mode: moli_fetch::RequestMode, - network_partition_key: Option, - mut info: PendingSubresourceFetchInfo, - ) { - self.assign_pending_subresource_fetch_identity(&mut info); - self.push_pending_subresource_fetch_info(info.clone()); - self.pending_subresource_fetches.insert( - info.internal_id, - PendingSubresourceFetchState { - dispatch: None, - redirect_headers: None, - request_origin: moli_url::WebOrigin::from_url(&info.document_url), - info, - load, - execution_context: PendingSubresourceExecutionContext::adapter( - OwnerDispatchScope::Top, - context, - ), - credentials_mode, - request_mode, - network_partition_key, - policy_context: Default::default(), - continuation: PendingSubresourceContinuation::WorkerCspReport { - worker_id, - report_id, - }, - deferred_request_started: false, - }, - ); - self.note_subresource_activity(); - } - - pub(crate) fn record_pending_shared_worker_subresource_fetch( - &mut self, - context: v8::Global, - instance_id: SharedWorkerInstanceId, - fetch_id: u32, - load: ResourceLoadLease, - credentials_mode: moli_fetch::RequestCredentialsMode, - request_mode: moli_fetch::RequestMode, - network_partition_key: Option, - mut info: PendingSubresourceFetchInfo, - ) { - self.assign_pending_subresource_fetch_identity(&mut info); - self.push_pending_subresource_fetch_info(info.clone()); - self.pending_subresource_fetches.insert( - info.internal_id, - PendingSubresourceFetchState { - dispatch: None, - redirect_headers: None, - request_origin: moli_url::WebOrigin::from_url(&info.document_url), - info, - load, - execution_context: PendingSubresourceExecutionContext::adapter( - OwnerDispatchScope::Top, - context, - ), - credentials_mode, - request_mode, - network_partition_key, - policy_context: Default::default(), - continuation: PendingSubresourceContinuation::SharedWorkerFetch { - instance_id, - fetch_id, - }, - deferred_request_started: false, - }, - ); - self.note_subresource_activity(); - } - - pub(crate) fn record_pending_shared_worker_subresource_xhr( - &mut self, - context: v8::Global, - instance_id: SharedWorkerInstanceId, - xhr_id: u32, - load: ResourceLoadLease, - credentials_mode: moli_fetch::RequestCredentialsMode, - network_partition_key: Option, - mut info: PendingSubresourceFetchInfo, - ) { - self.assign_pending_subresource_fetch_identity(&mut info); - self.push_pending_subresource_fetch_info(info.clone()); - self.pending_subresource_fetches.insert( - info.internal_id, - PendingSubresourceFetchState { - dispatch: None, - redirect_headers: None, - request_origin: moli_url::WebOrigin::from_url(&info.document_url), - info, - load, - execution_context: PendingSubresourceExecutionContext::adapter( - OwnerDispatchScope::Top, - context, - ), - credentials_mode, - request_mode: moli_fetch::RequestMode::Cors, - network_partition_key, - policy_context: Default::default(), - continuation: PendingSubresourceContinuation::SharedWorkerXhr { - instance_id, - xhr_id, - }, - deferred_request_started: false, - }, - ); - self.note_subresource_activity(); - } - - pub(crate) fn record_pending_shared_worker_subresource_csp_report( - &mut self, - context: v8::Global, - instance_id: SharedWorkerInstanceId, - report_id: u32, - load: ResourceLoadLease, - credentials_mode: moli_fetch::RequestCredentialsMode, - request_mode: moli_fetch::RequestMode, - network_partition_key: Option, - mut info: PendingSubresourceFetchInfo, - ) { - self.assign_pending_subresource_fetch_identity(&mut info); - self.push_pending_subresource_fetch_info(info.clone()); - self.pending_subresource_fetches.insert( - info.internal_id, - PendingSubresourceFetchState { - dispatch: None, - redirect_headers: None, - request_origin: moli_url::WebOrigin::from_url(&info.document_url), - info, - load, - execution_context: PendingSubresourceExecutionContext::adapter( - OwnerDispatchScope::Top, - context, - ), - credentials_mode, - request_mode, - network_partition_key, - policy_context: Default::default(), - continuation: PendingSubresourceContinuation::SharedWorkerCspReport { - instance_id, - report_id, - }, - deferred_request_started: false, - }, - ); - self.note_subresource_activity(); - } - pub(crate) fn record_async_subresource_fetch( &mut self, fetch_context: super::WindowFetchContext, @@ -1882,146 +1639,6 @@ impl PageScriptHost { self.restore_pending_subresource_fetch(pending); } - pub(crate) fn cancel_pending_worker_subresource_fetch( - &mut self, - worker_id: DedicatedWorkerId, - fetch_id: u32, - error_text: String, - ) -> bool { - let Some(internal_id) = self - .pending_subresource_fetches - .iter() - .chain( - self.in_flight_worker_subresource_fetches - .iter() - .map(|(internal_id, state)| (internal_id, &state.pending)), - ) - .find_map(|(internal_id, pending)| match &pending.continuation { - PendingSubresourceContinuation::WorkerFetch { - worker_id: pending_worker_id, - fetch_id: pending_fetch_id, - } if *pending_worker_id == worker_id && *pending_fetch_id == fetch_id => { - Some(*internal_id) - } - PendingSubresourceContinuation::WorkerXhr { - worker_id: pending_worker_id, - xhr_id: pending_xhr_id, - } if *pending_worker_id == worker_id && *pending_xhr_id == fetch_id => { - Some(*internal_id) - } - PendingSubresourceContinuation::WorkerCspReport { - worker_id: pending_worker_id, - report_id: pending_report_id, - } if *pending_worker_id == worker_id && *pending_report_id == fetch_id => { - Some(*internal_id) - } - _ => None, - }) - else { - return false; - }; - let Some(pending) = self - .pending_subresource_fetches - .remove(&internal_id) - .or_else(|| { - self.in_flight_worker_subresource_fetches - .remove(&internal_id) - .map(|state| state.pending) - }) - else { - return false; - }; - #[cfg(test)] - self.pending_subresource_fetch_infos - .retain(|info| info.internal_id != internal_id); - self.record_pending_subresource_failure(&pending.info, error_text); - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::Completed { internal_id }, - ); - true - } - - pub(crate) fn cancel_pending_shared_worker_subresource_fetch( - &mut self, - instance_id: SharedWorkerInstanceId, - fetch_id: u32, - error_text: String, - ) -> bool { - let Some(internal_id) = self - .pending_subresource_fetches - .iter() - .chain( - self.in_flight_worker_subresource_fetches - .iter() - .map(|(internal_id, state)| (internal_id, &state.pending)), - ) - .find_map(|(internal_id, pending)| match &pending.continuation { - PendingSubresourceContinuation::SharedWorkerFetch { - instance_id: pending_instance_id, - fetch_id: pending_fetch_id, - } if *pending_instance_id == instance_id && *pending_fetch_id == fetch_id => { - Some(*internal_id) - } - PendingSubresourceContinuation::SharedWorkerXhr { - instance_id: pending_instance_id, - xhr_id: pending_xhr_id, - } if *pending_instance_id == instance_id && *pending_xhr_id == fetch_id => { - Some(*internal_id) - } - PendingSubresourceContinuation::SharedWorkerCspReport { - instance_id: pending_instance_id, - report_id: pending_report_id, - } if *pending_instance_id == instance_id && *pending_report_id == fetch_id => { - Some(*internal_id) - } - _ => None, - }) - else { - return false; - }; - let Some(pending) = self - .pending_subresource_fetches - .remove(&internal_id) - .or_else(|| { - self.in_flight_worker_subresource_fetches - .remove(&internal_id) - .map(|state| state.pending) - }) - else { - return false; - }; - #[cfg(test)] - self.pending_subresource_fetch_infos - .retain(|info| info.internal_id != internal_id); - self.record_pending_subresource_failure(&pending.info, error_text); - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::Completed { internal_id }, - ); - true - } - - fn record_pending_subresource_failure( - &mut self, - info: &PendingSubresourceFetchInfo, - error_text: String, - ) { - let mut record = SubresourceNetworkRecord::failure( - info.frame_id.clone(), - info.document_url.clone(), - info.url.clone(), - info.method.clone(), - info.request_headers.clone(), - info.request_body.clone(), - info.resource_type, - error_text, - ) - .with_request_body_bytes(info.request_body_bytes.clone()); - if let Some(handle) = info.network_request_handle { - record = record.with_request_handle(handle); - } - self.record_subresource_network(record); - } - pub(crate) fn record_running_subresource_fetch(&mut self, state: RunningSubresourceFetchState) { self.running_subresource_fetches .insert(state.pending.info.internal_id, state); @@ -2247,15 +1864,6 @@ impl PageScriptHost { self.streaming_subresource_fetches.remove(&internal_id) } - pub(crate) fn record_in_flight_worker_subresource_fetch( - &mut self, - state: InFlightWorkerSubresourceFetchState, - ) { - self.in_flight_worker_subresource_fetches - .insert(state.pending.info.internal_id, state); - self.note_subresource_activity(); - } - pub(crate) fn take_running_subresource_fetch( &mut self, internal_id: u64, @@ -2432,18 +2040,6 @@ impl PageScriptHost { return true; } - if let Some(in_flight) = self - .in_flight_worker_subresource_fetches - .remove(&internal_id) - { - self.record_observable_abort_before_response(&in_flight.pending); - in_flight.pending.load.cancel(); - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::Completed { internal_id }, - ); - return true; - } - if let Some(running) = self.running_subresource_fetches.remove(&internal_id) { self.record_observable_abort_before_response(&running.pending); running.pending.load.cancel(); @@ -2487,11 +2083,6 @@ impl PageScriptHost { fn subresource_fetch_states(&self) -> impl Iterator { self.pending_subresource_fetches .values() - .chain( - self.in_flight_worker_subresource_fetches - .values() - .map(|state| &state.pending), - ) .chain( self.running_subresource_fetches .values() @@ -2595,9 +2186,6 @@ impl PageScriptHost { for pending in self.pending_subresource_fetches.values_mut() { apply(pending); } - for state in self.in_flight_worker_subresource_fetches.values_mut() { - apply(&mut state.pending); - } for state in self.running_subresource_fetches.values_mut() { apply(&mut state.pending); } @@ -2935,70 +2523,6 @@ impl PageScriptHost { retired } - pub(crate) fn cancel_subresource_fetches_for_worker( - &mut self, - worker_id: DedicatedWorkerId, - ) -> usize { - let mut internal_ids = - self.pending_subresource_fetches - .iter() - .filter_map(|(internal_id, pending)| { - (pending.continuation.dedicated_worker_id() == Some(worker_id)) - .then_some(*internal_id) - }) - .chain(self.in_flight_worker_subresource_fetches.iter().filter_map( - |(internal_id, running)| { - (running.pending.continuation.dedicated_worker_id() == Some(worker_id)) - .then_some(*internal_id) - }, - )) - .chain(self.running_subresource_fetches.iter().filter_map( - |(internal_id, running)| { - (running.pending.continuation.dedicated_worker_id() == Some(worker_id)) - .then_some(*internal_id) - }, - )) - .chain(self.streaming_subresource_fetches.iter().filter_map( - |(internal_id, streaming)| { - (streaming.pending.continuation.dedicated_worker_id() == Some(worker_id)) - .then_some(*internal_id) - }, - )) - .chain(self.pending_subresource_auths.iter().filter_map( - |(internal_id, pending)| { - (pending.pending.continuation.dedicated_worker_id() == Some(worker_id)) - .then_some(*internal_id) - }, - )) - .chain(self.pending_subresource_responses.iter().filter_map( - |(internal_id, pending)| { - (pending.pending.continuation.dedicated_worker_id() == Some(worker_id)) - .then_some(*internal_id) - }, - )) - .collect::>(); - internal_ids.sort_unstable(); - internal_ids.dedup(); - let mut cancelled = 0; - for internal_id in internal_ids.iter().copied() { - let _ = self - .browser_context_runtime - .abort_service_worker_fetch(internal_id); - cancelled += usize::from(self.abort_subresource_fetch(internal_id)); - } - #[cfg(test)] - self.pending_subresource_fetch_infos - .retain(|info| !internal_ids.contains(&info.internal_id)); - if cancelled > 0 { - tracing::debug!( - worker_id = worker_id.as_u64(), - cancelled, - "cancelled subresource requests for retired DedicatedWorker" - ); - } - cancelled - } - pub(crate) fn cancel_stylesheet_subresource_fetches_for_document_owner( &mut self, owner: crate::frame_owner_model::FrameDocumentTaskOwner, @@ -3213,112 +2737,6 @@ impl PageScriptHost { self.note_subresource_activity(); } - pub(crate) fn record_worker_subresource_response_pause( - &mut self, - info: PendingSubresourceResponseInfo, - ) { - if let Some(in_flight) = self - .in_flight_worker_subresource_fetches - .remove(&info.internal_id) - { - self.record_pending_subresource_response(PendingSubresourceResponseState { - pending: in_flight.pending, - request_url: in_flight.request_url, - request_method: in_flight.request_method, - request_headers: in_flight.request_headers, - request_body: in_flight.request_body, - encoded: None, - response_status_text: None, - skip_fetch_security_validation: false, - response_filter: None, - response: navigation_response_from_subresource_body( - &info.response_body, - moli_fetch::ResponseHead { - status_text: None, - final_url: info.url.clone(), - status: info.response_status, - headers: info.response_headers.clone(), - request_cookie_report: info.request_cookie_report.clone(), - cookie_set_reports: Vec::new(), - redirected: false, - redirect_chain: Vec::new(), - from_cache: info.from_cache, - cache_state: info.cache_state, - negotiated_http_version: None, - }, - ) - .with_network_request_headers(info.network_request_headers.clone()), - }); - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::ResponsePaused(info), - ); - } else { - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::Completed { - internal_id: info.internal_id, - }, - ); - } - } - - pub(crate) fn record_worker_subresource_auth_pause( - &mut self, - info: PendingSubresourceAuthInfo, - ) { - if let Some(in_flight) = self - .in_flight_worker_subresource_fetches - .remove(&info.internal_id) - { - self.record_pending_subresource_auth(PendingSubresourceAuthState { - pending: in_flight.pending, - request_url: info.url.clone(), - request_method: info.method.clone(), - request_headers: info.request_headers.clone(), - request_body: info.request_body.clone(), - intercept_response: info.intercept_response, - initial_network_request_headers: info.network_request_headers.clone(), - encoded: None, - response_status_text: None, - skip_fetch_security_validation: false, - response_filter: None, - response: navigation_response_from_subresource_body( - &info.response_body, - moli_fetch::ResponseHead { - status_text: None, - final_url: info.response_final_url.clone(), - status: info.response_status, - headers: info.response_headers.clone(), - request_cookie_report: info.request_cookie_report.clone(), - cookie_set_reports: Vec::new(), - redirected: false, - redirect_chain: Vec::new(), - from_cache: info.response_from_cache, - cache_state: info.response_cache_state, - negotiated_http_version: None, - }, - ) - .with_network_request_headers(info.network_request_headers.clone()), - }); - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::AuthRequired(info), - ); - } else { - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::Completed { - internal_id: info.internal_id, - }, - ); - } - } - - pub(crate) fn record_worker_subresource_completed(&mut self, internal_id: u64) { - self.in_flight_worker_subresource_fetches - .remove(&internal_id); - self.record_pending_subresource_continue_event( - PendingSubresourceContinueEvent::Completed { internal_id }, - ); - } - pub(crate) fn record_pending_websocket_response( &mut self, state: PendingWebSocketResponseState, @@ -3372,7 +2790,6 @@ impl PageScriptHost { + self.pending_subresource_responses.len() + self.pending_websocket_responses.len() + self.streaming_subresource_fetches.len() - + self.in_flight_worker_subresource_fetches.len() } pub(crate) fn note_subresource_activity(&mut self) { diff --git a/moli-renderer-v8/src/native_bridge/context_host/shared_workers.rs b/moli-renderer-v8/src/native_bridge/context_host/shared_workers.rs index 6dd30cb804d..a672ff3fc7e 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/shared_workers.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/shared_workers.rs @@ -1,13 +1,9 @@ use super::*; -use crate::{ - RendererSyntheticResponseBody, - shared_worker_runtime::{ - AppliedSharedWorkerClientErrorTarget, SharedWorkerClientEndpointDisposition, - SharedWorkerClientEndpointReceiver, - }, - worker::{WorkerPendingFetchContinue, WorkerPendingXhrContinue}, +use crate::shared_worker_runtime::{ + AppliedSharedWorkerClientErrorTarget, SharedWorkerClientEndpointDisposition, + SharedWorkerClientEndpointReceiver, }; -use moli_shared_worker::{SharedWorkerClientOwnerId, SharedWorkerInstanceId}; +use moli_shared_worker::SharedWorkerClientOwnerId; impl PageScriptHost { pub(crate) fn browser_context_runtime(&self) -> crate::runtime::RendererBrowserContextRuntime { @@ -122,221 +118,4 @@ impl PageScriptHost { self.shared_worker_clients .disconnect_all_for_context_token(context_token) } - - pub(crate) fn continue_shared_worker_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.browser_context_runtime - .continue_shared_worker_fetch(instance_id, request) - } - - pub(crate) fn continue_shared_worker_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - ) -> bool { - self.browser_context_runtime - .continue_shared_worker_xhr(instance_id, request) - } - - pub(crate) fn continue_shared_worker_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.browser_context_runtime - .continue_shared_worker_csp_report(instance_id, request) - } - - pub(crate) fn continue_shared_worker_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.browser_context_runtime - .continue_shared_worker_fetch_response( - instance_id, - request, - response_code, - response_headers, - ) - } - - pub(crate) fn continue_shared_worker_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.browser_context_runtime - .continue_shared_worker_xhr_response( - instance_id, - request, - response_code, - response_headers, - ) - } - - pub(crate) fn fail_shared_worker_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.browser_context_runtime - .fail_shared_worker_fetch(instance_id, request, error_text) - } - - pub(crate) fn fail_shared_worker_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.browser_context_runtime - .fail_shared_worker_xhr(instance_id, request, error_text) - } - - pub(crate) fn fail_shared_worker_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.browser_context_runtime - .fail_shared_worker_csp_report(instance_id, request, error_text) - } - - pub(crate) fn fail_shared_worker_fetch_auth( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.browser_context_runtime - .fail_shared_worker_fetch_auth(instance_id, request, error_text) - } - - pub(crate) fn fail_shared_worker_xhr_auth( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.browser_context_runtime - .fail_shared_worker_xhr_auth(instance_id, request, error_text) - } - - pub(crate) fn fail_shared_worker_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.browser_context_runtime - .fail_shared_worker_fetch_response(instance_id, request, error_text) - } - - pub(crate) fn fail_shared_worker_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.browser_context_runtime - .fail_shared_worker_xhr_response(instance_id, request, error_text) - } - - pub(crate) fn fulfill_shared_worker_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.browser_context_runtime.fulfill_shared_worker_fetch( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - } - - pub(crate) fn fulfill_shared_worker_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.browser_context_runtime.fulfill_shared_worker_xhr( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - } - - pub(crate) fn fulfill_shared_worker_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.browser_context_runtime - .fulfill_shared_worker_csp_report( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - } - - pub(crate) fn fulfill_shared_worker_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.browser_context_runtime - .fulfill_shared_worker_fetch_response( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - } - - pub(crate) fn fulfill_shared_worker_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.browser_context_runtime - .fulfill_shared_worker_xhr_response( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - } } diff --git a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs index 8e09c74a916..62ea021e64c 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs @@ -5,7 +5,6 @@ use super::{ WorkerConnectionState, WorkerExecutionState, WorkerModuleStaticImportPolicySnapshot, WorkerRelayTerminalState, }; -use crate::RendererSyntheticResponseBody; use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind, ResourceLoadLease}; use crate::page_task_queue::{ RendererDedicatedWorkerClientEvent, RendererDedicatedWorkerMessageEvent, @@ -16,9 +15,8 @@ use crate::service_worker_runtime::{ServiceWorkerClientId, ServiceWorkerRequestD use crate::structured_clone::V8StructuredClonePayload; use crate::types::{DedicatedWorkerId, SubresourcePolicyContext}; use crate::worker::{ - WorkerGlobalKind, WorkerHandle, WorkerNetworkPolicy, WorkerPendingFetchContinue, - WorkerPendingXhrContinue, WorkerRuntimeEvent, WorkerScriptKind, WorkerScriptSource, - WorkerSecureContextPolicy, WorkerSpawnOptions, spawn_worker_with_options, + WorkerGlobalKind, WorkerHandle, WorkerNetworkPolicy, WorkerRuntimeEvent, WorkerScriptKind, + WorkerScriptSource, WorkerSecureContextPolicy, WorkerSpawnOptions, spawn_worker_with_options, }; use moli_storage_key::MoliStorageKey; use url::Url; @@ -150,18 +148,32 @@ impl PageScriptHost { }); } + #[allow(clippy::too_many_arguments)] pub(crate) fn register_worker( &mut self, scope: &mut v8::PinScope<'_, '_>, wrapper: v8::Local<'_, v8::Object>, - mut worker_handle: WorkerHandle, + options: WorkerSpawnOptions, owner: super::super::WindowExecutionContextBinding, + document_url: Url, + request_url: Url, + name: String, ) -> DedicatedWorkerId { let worker_id = DedicatedWorkerId::new(self.next_worker_id); self.next_worker_id += 1; let renderer_instance_id = self .browser_context_runtime() .allocate_dedicated_worker_instance_id(); + let page_token = self + .page_dedicated_worker_client_event_sender() + .page_token(); + self.publish_live_turn_output_prefix(); + let context = self.dedicated_worker_interception_context_for_instance(renderer_instance_id); + let mut worker_handle = spawn_worker_with_options( + options + .with_interception_context(context) + .with_pause_evaluation_until_debugger(true), + ); self.browser_context_runtime() .attach_dedicated_worker_devtools_handle( renderer_instance_id, @@ -179,7 +191,7 @@ impl PageScriptHost { worker_id, WorkerConnectionState { renderer_instance_id, - target_created: false, + target_created: true, wrapper: v8::Global::new(scope, wrapper), owner, client_event_producer, @@ -189,9 +201,37 @@ impl PageScriptHost { }, }, ); + self.append_dedicated_worker_target_lifecycle( + crate::runtime::RendererDedicatedWorkerTargetEvent::Created( + crate::runtime::RendererDedicatedWorkerTargetInfo { + owner_local_host_id: page_token.local_host_id(), + page_id: page_token.page_id(), + instance_id: renderer_instance_id, + request_url: request_url.to_string(), + document_url: document_url.to_string(), + name, + }, + ), + ); + self.publish_live_turn_output_prefix(); worker_id } + pub(crate) fn start_registered_local_worker(&self, worker_id: DedicatedWorkerId) { + let instance_id = self + .workers + .get(&worker_id) + .expect("registered local Worker") + .renderer_instance_id; + let started = self + .browser_context_runtime() + .run_dedicated_worker_if_waiting_for_debugger_for_devtools(instance_id); + assert!( + started, + "registered local Worker has its native DevTools handle" + ); + } + pub(crate) fn register_loading_worker( &mut self, scope: &mut v8::PinScope<'_, '_>, @@ -428,6 +468,7 @@ impl PageScriptHost { worker_id: DedicatedWorkerId, script_url: String, script_source: WorkerScriptSource, + network_response: Option>, script_kind: WorkerScriptKind, secure_context: bool, response_referrer_policy: Option, @@ -522,10 +563,10 @@ impl PageScriptHost { }; let mut spawn_options = WorkerSpawnOptions::with_source_and_request_client( script_source, - script_url, + script_url.clone(), request_client, ) - .with_interception_context(self.native_interception_context()) + .with_interception_context(self.dedicated_worker_interception_context(worker_id)) .with_script_kind(script_kind) .with_module_credentials_mode(module_credentials_mode) .with_referrer_policy(response_referrer_policy) @@ -542,10 +583,7 @@ impl PageScriptHost { .with_creator_message_security(creator_message_security) .with_storage_bucket_store(Some(self.storage_bucket_store())) .with_indexed_db_manager(self.indexed_db_manager()) - .with_pause_evaluation_until_debugger( - self.browser_context_runtime() - .dedicated_worker_pause_on_start_for_devtools(), - ); + .with_pause_evaluation_until_debugger(true); if let Some(policy) = module_static_import_policy { spawn_options = spawn_options .with_module_static_import_initiator_url(policy.initiator_url) @@ -590,6 +628,16 @@ impl PageScriptHost { state.execution = WorkerExecutionState::Running { handle: worker_handle, }; + if let Some(response) = network_response { + self.record_dedicated_worker_target_script_loaded(worker_id, script_url, response); + self.publish_live_turn_output_prefix(); + } + if !self + .browser_context_runtime() + .dedicated_worker_pause_on_start_for_devtools() + { + self.start_registered_local_worker(worker_id); + } true } @@ -628,6 +676,40 @@ impl PageScriptHost { true } + pub(crate) fn dedicated_worker_interception_context( + &mut self, + worker_id: DedicatedWorkerId, + ) -> Option { + let instance_id = self.workers.get(&worker_id)?.renderer_instance_id; + self.dedicated_worker_interception_context_for_instance(instance_id) + } + fn dedicated_worker_interception_context_for_instance( + &mut self, + instance_id: u64, + ) -> Option { + self.publish_live_turn_output_prefix(); + let journal = self.renderer_output_journal()?; + Some( + crate::network::interception_output::ResourceInterceptionContext::worker( + self.native_interception_context(), + move |event| { + let record = crate::runtime::PendingRendererOutputRecord::owner_action( + None, + crate::runtime::RendererOwnerAction::DedicatedWorkerTargetLifecycle( + crate::runtime::RendererDedicatedWorkerTargetEvent::Resource { + instance_id, + event, + }, + ), + ) + .resolve() + .expect("Worker target has a resolved source identity"); + journal.try_publish_record(record) + }, + ), + ) + } + /// Publishes one Worker lifecycle fact without conflating a test-only /// missing output sink with a disappeared Worker. /// @@ -771,350 +853,6 @@ impl PageScriptHost { .unwrap_or(false) } - pub(crate) fn continue_worker_fetch( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.continue_pending_fetch(request); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn continue_worker_xhr( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingXhrContinue, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.continue_pending_xhr(request); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn continue_worker_csp_report( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.continue_pending_csp_report(request); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn continue_worker_fetch_response( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.continue_pending_fetch_response( - request, - response_code, - response_headers, - ); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn continue_worker_xhr_response( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.continue_pending_xhr_response(request, response_code, response_headers); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fail_worker_fetch( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fail_pending_fetch(request, error_text); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fail_worker_xhr( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fail_pending_xhr(request, error_text); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fail_worker_csp_report( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fail_pending_csp_report(request, error_text); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fail_worker_fetch_response( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fail_pending_fetch_response(request, error_text); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fail_worker_xhr_response( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fail_pending_xhr_response(request, error_text); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fail_worker_fetch_auth( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fail_pending_fetch_auth(request, error_text); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fail_worker_xhr_auth( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fail_pending_xhr_auth(request, error_text); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fulfill_worker_fetch( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fulfill_pending_fetch( - request, - response_code, - response_headers, - response_body, - ); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fulfill_worker_xhr( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fulfill_pending_xhr( - request, - response_code, - response_headers, - response_body, - ); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fulfill_worker_csp_report( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fulfill_pending_csp_report( - request, - response_code, - response_headers, - response_body, - ); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fulfill_worker_fetch_response( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fulfill_pending_fetch_response( - request, - response_code, - response_headers, - response_body, - ); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - - pub(crate) fn fulfill_worker_xhr_response( - &mut self, - worker_id: DedicatedWorkerId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.workers - .get_mut(&worker_id) - .map(|state| match &mut state.execution { - WorkerExecutionState::Running { handle } => { - handle.fulfill_pending_xhr_response( - request, - response_code, - response_headers, - response_body, - ); - true - } - WorkerExecutionState::Loading { .. } => false, - }) - .unwrap_or(false) - } - pub(crate) fn terminate_worker(&mut self, worker_id: DedicatedWorkerId) -> bool { let browser_context_runtime = self.browser_context_runtime(); self.workers @@ -1356,7 +1094,6 @@ impl PageScriptHost { } pub(crate) fn forget_worker(&mut self, worker_id: DedicatedWorkerId) { - let retired_subresource_count = self.cancel_subresource_fetches_for_worker(worker_id); let browser_context_runtime = self.browser_context_runtime(); if let Some(state) = self.workers.remove(&worker_id) { self.browser_context_runtime() @@ -1394,7 +1131,6 @@ impl PageScriptHost { ?owner, ?realm_token, execution_state, - retired_subresource_count, "forgot DedicatedWorker execution-context state" ); } diff --git a/moli-renderer-v8/src/network/context/worker.rs b/moli-renderer-v8/src/network/context/worker.rs index d2c347fd2dd..0dce2aa1f7e 100644 --- a/moli-renderer-v8/src/network/context/worker.rs +++ b/moli-renderer-v8/src/network/context/worker.rs @@ -41,6 +41,7 @@ struct WorkerResourceLoaderAuthority { owner: WorkerResourceOwner, state: Mutex, loads: ResourceLoadRegistry, + interception: Mutex>, } impl Drop for WorkerResourceLoaderAuthority { @@ -48,6 +49,9 @@ impl Drop for WorkerResourceLoaderAuthority { // Normal Worker shutdown detaches before V8 teardown. Keep destruction // itself safe as well so bootstrap failures cannot leave an ordinary // transport running without its WorkerGlobalScope. + if let Some(context) = self.interception.get_mut() { + context.close_worker_observer(); + } self.loads.begin_detach(); } } @@ -80,10 +84,18 @@ impl WorkerResourceLoader { owner, state: Mutex::new(WorkerResourceLoaderState::Active), loads, + interception: Mutex::new(None), }), } } + pub(crate) fn set_interception_context( + &self, + context: Option, + ) { + *self.authority.interception.lock() = context; + } + pub(crate) fn register_load( &self, kind: ResourceLoadKind, @@ -118,6 +130,9 @@ impl WorkerResourceLoader { } *state = WorkerResourceLoaderState::Detaching; drop(state); + if let Some(context) = &*self.authority.interception.lock() { + context.close_worker_observer(); + } self.authority.loads.begin_detach(); true } diff --git a/moli-renderer-v8/src/network/interception_control.rs b/moli-renderer-v8/src/network/interception_control.rs index 9741112dab0..53589e0702e 100644 --- a/moli-renderer-v8/src/network/interception_control.rs +++ b/moli-renderer-v8/src/network/interception_control.rs @@ -21,6 +21,7 @@ pub(crate) enum InterceptionPhase { #[derive(Clone, Debug)] pub struct ResourceInterceptionPause { internal_id: u64, + worker_network: bool, phase: InterceptionPhase, target_policy: crate::network::PageNetworkPolicy, request_redirect: Option>, @@ -78,6 +79,7 @@ impl ResourceInterceptionPause { ( Self { internal_id, + worker_network: false, phase, target_policy, request_redirect: None, @@ -97,6 +99,13 @@ impl ResourceInterceptionPause { self } + pub(crate) fn with_worker_network(mut self, worker: bool) -> Self { + self.worker_network = worker; + self + } + pub fn observes_worker_network(&self) -> bool { + self.worker_network + } pub fn request_redirect(&self) -> Option<&moli_fetch::RedirectInfo> { self.request_redirect.as_deref() } diff --git a/moli-renderer-v8/src/network/interception_output.rs b/moli-renderer-v8/src/network/interception_output.rs index 7701d56bf71..afa900c6c20 100644 --- a/moli-renderer-v8/src/network/interception_output.rs +++ b/moli-renderer-v8/src/network/interception_output.rs @@ -8,10 +8,17 @@ use crate::{ types::AsyncSubresourceFetchEvent, }; +mod worker; +pub(crate) use worker::WorkerInterceptionOutput; +pub use worker::{ResourceInterceptionEvent, ResourceInterceptionPolicy}; + #[derive(Clone, Debug)] -pub(crate) struct ResourceInterceptionContext { - pub(crate) source_document: crate::runtime::RendererDocumentLifecycleIdentity, - pub(crate) output: InterceptionOutput, +pub(crate) enum ResourceInterceptionContext { + Document { + source_document: crate::runtime::RendererDocumentLifecycleIdentity, + output: InterceptionOutput, + }, + Worker(Arc), } /// Native network facts normally join the Document's networking task source. @@ -27,6 +34,7 @@ struct InterceptionOutputInner { journal: RendererTurnOutputJournal, completion: RendererResourceCompletionSender, state: Mutex, + closed_notify: tokio::sync::Notify, } #[derive(Debug, Default)] @@ -73,6 +81,7 @@ impl InterceptionOutput { journal, completion, state: Mutex::new(InterceptionOutputState::default()), + closed_notify: tokio::sync::Notify::new(), }), } } @@ -81,17 +90,6 @@ impl InterceptionOutput { self.publish_record(PendingRendererOutputRecord::owner_action(None, action)) } - pub(crate) fn record_subresource_network( - &self, - source_document: crate::runtime::RendererDocumentLifecycleIdentity, - record: crate::types::SubresourceNetworkRecord, - ) -> bool { - self.publish_network( - source_document, - moli_page_types::ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record)), - ) - } - pub(crate) fn publish_network( &self, source_document: crate::runtime::RendererDocumentLifecycleIdentity, @@ -147,6 +145,23 @@ impl InterceptionOutput { let mut state = self.inner.state.lock(); state.closed = true; state.pending.clear(); + self.inner.closed_notify.notify_waiters(); + } + + pub(crate) fn is_closed(&self) -> bool { + self.inner.state.lock().closed + } + + pub(crate) async fn shutdown(&self) { + loop { + let notified = self.inner.closed_notify.notified(); + tokio::pin!(notified); + notified.as_mut().enable(); + if self.is_closed() { + return; + } + notified.await; + } } /// Called on the selected networking task, after earlier Page output. diff --git a/moli-renderer-v8/src/network/interception_output/worker.rs b/moli-renderer-v8/src/network/interception_output/worker.rs new file mode 100644 index 00000000000..df4148ef834 --- /dev/null +++ b/moli-renderer-v8/src/network/interception_output/worker.rs @@ -0,0 +1,222 @@ +use std::sync::{ + Arc, + atomic::{AtomicBool, Ordering}, +}; + +use crate::{ + network::ResourceInterceptionPause, + runtime::RendererOwnerAction, + types::{ + PendingSubresourceContinueEvent, PendingSubresourceFetchInfo, ScriptNetworkOutputItem, + SubresourceNetworkRecord, + }, +}; + +use super::ResourceInterceptionContext; + +/// Native loader facts. No V8 object, Worker-local request id or Page command +/// is needed to deliver an interceptor's decision to its waiting request. +#[derive(Clone, Debug, PartialEq)] +pub enum ResourceInterceptionEvent { + Request { + info: Box, + pause: ResourceInterceptionPause, + }, + Continue { + event: Box, + pause: Option, + }, + Network(Box), +} + +pub(crate) struct WorkerInterceptionOutput { + control: Option, + publish: Arc bool + Send + Sync>, + closed: AtomicBool, + closed_notify: tokio::sync::Notify, +} + +impl std::fmt::Debug for WorkerInterceptionOutput { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("WorkerInterceptionOutput") + .field("closed", &self.closed.load(Ordering::Acquire)) + .finish_non_exhaustive() + } +} + +impl ResourceInterceptionContext { + pub(crate) fn is_worker(&self) -> bool { + matches!(self, Self::Worker(_)) + } + pub(crate) fn worker( + control: Option, + publish: impl Fn(ResourceInterceptionEvent) -> bool + Send + Sync + 'static, + ) -> Self { + Self::Worker(Arc::new(WorkerInterceptionOutput { + control, + publish: Arc::new(publish), + closed: AtomicBool::new(false), + closed_notify: tokio::sync::Notify::new(), + })) + } + + pub(crate) fn fork_worker_observer(&self) -> Self { + match self { + Self::Document { .. } => self.clone(), + Self::Worker(output) => Self::Worker(Arc::new(WorkerInterceptionOutput { + control: output.control.clone(), + publish: output.publish.clone(), + closed: AtomicBool::new(false), + closed_notify: tokio::sync::Notify::new(), + })), + } + } + pub(crate) fn worker_control_closed(&self) -> bool { + let mut control = self; + loop { + match control { + Self::Document { output, .. } => return output.is_closed(), + Self::Worker(output) => match &output.control { + Some(parent) => control = parent, + None => return output.closed.load(Ordering::Acquire), + }, + } + } + } + pub(crate) async fn worker_control_shutdown(&self) { + let mut control = self; + loop { + match control { + Self::Document { output, .. } => return output.shutdown().await, + Self::Worker(output) => { + if let Some(parent) = &output.control { + control = parent; + continue; + } + loop { + let notified = output.closed_notify.notified(); + tokio::pin!(notified); + notified.as_mut().enable(); + if output.closed.load(Ordering::Acquire) { + return; + } + notified.await; + } + } + } + } + } + + pub(crate) fn close_worker_observer(&self) { + if let Self::Worker(output) = self { + output.closed.store(true, Ordering::Release); + output.closed_notify.notify_waiters(); + } + } + + pub(crate) fn request_action( + &self, + info: PendingSubresourceFetchInfo, + pause: ResourceInterceptionPause, + ) -> RendererOwnerAction { + let Self::Document { + source_document, .. + } = self + else { + panic!("only a Document can prepare a Page-turn request admission"); + }; + RendererOwnerAction::SubresourceFetchPause { + source_document: *source_document, + info: Box::new(info), + network_pause: Some(pause), + child_document: None, + redirect: None, + } + } + + pub(crate) fn publish_request( + &self, + info: PendingSubresourceFetchInfo, + pause: ResourceInterceptionPause, + ) -> bool { + match self { + Self::Document { output, .. } => output.publish(self.request_action(info, pause)), + Self::Worker(output) => { + if let Some(control) = &output.control { + return control.publish_request(info, pause); + } + if output.closed.load(Ordering::Acquire) { + return false; + } + (output.publish)(ResourceInterceptionEvent::Request { + info: Box::new(info), + pause, + }) + } + } + } + + pub(crate) fn publish_continue( + &self, + event: PendingSubresourceContinueEvent, + pause: Option, + ) -> bool { + match self { + Self::Document { + source_document, + output, + } => output.publish(RendererOwnerAction::SubresourceContinue { + source_document: *source_document, + response_body: None, + event: Box::new(event), + network_pause: pause, + }), + Self::Worker(output) => { + if let Some(control) = &output.control { + return control.publish_continue(event, pause); + } + if output.closed.load(Ordering::Acquire) { + return false; + } + (output.publish)(ResourceInterceptionEvent::Continue { + event: Box::new(event), + pause, + }) + } + } + } + + pub(crate) fn publish_network(&self, item: ScriptNetworkOutputItem) -> bool { + match self { + Self::Document { + source_document, + output, + } => output.publish_network(*source_document, item), + Self::Worker(output) => { + !output.closed.load(Ordering::Acquire) + && (output.publish)(ResourceInterceptionEvent::Network(Box::new(item))) + } + } + } + + pub(crate) fn record_subresource_network(&self, record: SubresourceNetworkRecord) -> bool { + self.publish_network(ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new( + record, + ))) + } +} + +/// The interception configuration of a Worker target, independent of clients. +#[derive(Clone, Debug)] +pub struct ResourceInterceptionPolicy(pub(crate) crate::network::PageNetworkPolicy); +impl ResourceInterceptionPolicy { + pub fn set_interception(&self, classes: crate::types::SubresourceInterceptionClasses) { + self.0.set_subresource_interception(classes); + } +} +impl PartialEq for ResourceInterceptionPolicy { + fn eq(&self, other: &Self) -> bool { + self.0.shares_state_with(&other.0) + } +} +impl Eq for ResourceInterceptionPolicy {} diff --git a/moli-renderer-v8/src/network/loads/registry.rs b/moli-renderer-v8/src/network/loads/registry.rs index 0b9e4b96d6b..9f6caabc811 100644 --- a/moli-renderer-v8/src/network/loads/registry.rs +++ b/moli-renderer-v8/src/network/loads/registry.rs @@ -30,10 +30,6 @@ impl ResourceLoadId { .expect("resource load id exhausted"), ) } - - fn as_u64(self) -> u64 { - self.0 - } } #[derive(Clone, Copy, Debug, Eq, PartialEq)] @@ -475,10 +471,6 @@ impl ResourceLoadLease { .try_restart() } - pub(crate) fn id_for_diagnostics(&self) -> u64 { - self.registration.id.as_u64() - } - pub(crate) fn registry_id(&self) -> u64 { self.registration .lifecycle @@ -512,14 +504,6 @@ impl ResourceLoadLease { .network_offline() } - pub(crate) fn blocks_url(&self, url: &url::Url) -> bool { - self.registration - .request_client - .page_network_policy() - .snapshot() - .blocks_url(url) - } - pub(crate) fn attach_cancel_handle(&self, cancel_handle: FetchCancelHandle) { let (cancel_immediately, detached_keepalive) = { let mut lifecycle = self.registration.lifecycle.lock(); diff --git a/moli-renderer-v8/src/network/mod.rs b/moli-renderer-v8/src/network/mod.rs index d94b55a2da4..3f0e94e2971 100644 --- a/moli-renderer-v8/src/network/mod.rs +++ b/moli-renderer-v8/src/network/mod.rs @@ -60,5 +60,6 @@ pub(crate) mod interception_control; pub use interception_body::ResourceInterceptionBody; pub(crate) mod interception_output; pub use interception_control::{ResourceInterceptionPause, ResourceInterceptionReply}; +pub use interception_output::{ResourceInterceptionEvent, ResourceInterceptionPolicy}; pub(crate) mod synchronous_load; diff --git a/moli-renderer-v8/src/network/request_client.rs b/moli-renderer-v8/src/network/request_client.rs index 171ef036022..3d7f0c8fc06 100644 --- a/moli-renderer-v8/src/network/request_client.rs +++ b/moli-renderer-v8/src/network/request_client.rs @@ -202,6 +202,12 @@ impl ResourceRequestClient { client } + pub(crate) fn fork_for_shared_worker_target(&self) -> Self { + let mut client = self.fork_with_isolated_page_network_policy(); + client.browser_site_context = self.browser_site_context.clone(); + client + } + /// Materializes a text response at callers that require a buffered body. /// /// New renderer resource loads should prefer `fetch_text_stream()` or diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs index fca493b03de..9d06ab14e10 100644 --- a/moli-renderer-v8/src/network_host.rs +++ b/moli-renderer-v8/src/network_host.rs @@ -37,12 +37,10 @@ use moli_fetch::{Request, Response, observe_cookie_access_report_for_request}; use crate::network::ResourceRequestClient; pub(crate) use self::async_fetch::{ - browser_request_needs_manual_preflight_redirects, collect_image_response_into_parkable, - fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata, + collect_image_response_into_parkable, fetch_browser_subresource_with_preflight_and_network_metadata, - fetch_browser_subresource_with_preflight_headers, - fetch_browser_subresource_with_preflight_headers_and_network_metadata, - fetch_intercepted_window_hop, spawn_async_subresource_fetch, + fetch_browser_subresource_with_preflight_headers, fetch_intercepted_window_hop, + spawn_async_subresource_fetch, }; pub(crate) use self::beacon::{navigator_send_beacon_callback, send_link_audit_ping}; pub(super) use self::bindings::install_window_network_bindings; @@ -61,10 +59,9 @@ pub(in crate::network_host) use self::body_source::{ consume_network_body_value_from_object, consume_network_body_value_from_object_with_chunk_callback, network_body_source_from_object, network_body_source_object_from_bytes, network_body_stream_from_response_body, - network_body_stream_from_subresource_body, set_filtered_response_internal_body_from_bytes, + set_filtered_response_internal_body_from_bytes, set_filtered_response_internal_body_from_pending_stream, - set_filtered_response_internal_body_from_response_body, - set_filtered_response_internal_body_from_subresource_body, set_network_body_owned_bytes, + set_filtered_response_internal_body_from_response_body, set_network_body_owned_bytes, take_network_body_bytes_from_object, try_network_body_bytes_from_object, }; pub(crate) use self::body_source::{ @@ -160,7 +157,6 @@ pub(crate) use self::response::{ MaterializedResponseHead, build_fetch_response_object_for_request_mode, build_fetch_response_object_from_body_source_for_request_mode_with_metadata, build_fetch_response_object_from_stream_for_request_mode_with_metadata, - build_fetch_response_object_from_subresource_body_for_request_mode, build_filtered_cached_response_object, build_navigation_preload_response_object_from_stream_for_request_mode, cors_preflight_request_headers, filter_cors_exposed_response_headers, diff --git a/moli-renderer-v8/src/network_host/async_fetch.rs b/moli-renderer-v8/src/network_host/async_fetch.rs index 1412b5a9177..bc5b354f9b9 100644 --- a/moli-renderer-v8/src/network_host/async_fetch.rs +++ b/moli-renderer-v8/src/network_host/async_fetch.rs @@ -421,18 +421,15 @@ pub(crate) fn next_redirect_url( }) } -pub(crate) async fn fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata( +#[cfg(test)] +async fn fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata( loader: &ResourceRequestClient, request: Request, - cancel_handle: Option, - preflight_request_headers: Vec<(String, String)>, + cancel: Option, + headers: Vec<(String, String)>, ) -> Result, String> { fetch_browser_subresource_raw_stream_with_preflight_headers_and_observer( - loader, - request, - cancel_handle, - preflight_request_headers, - None, + loader, request, cancel, headers, None, ) .await } diff --git a/moli-renderer-v8/src/network_host/body_source.rs b/moli-renderer-v8/src/network_host/body_source.rs index 795f9c000c2..1232620a342 100644 --- a/moli-renderer-v8/src/network_host/body_source.rs +++ b/moli-renderer-v8/src/network_host/body_source.rs @@ -10,7 +10,6 @@ use crate::context_bootstrap::{ close_stream, enqueue_byte_chunk, error_stream, readable_stream_error, readable_stream_has_pipe_owner, }; -use crate::protocol_types::SubresourceResponseBody; use crate::types::NetworkBodySourceId; use crate::util::{PendingPromiseResolver, get_private_value, set_private_value}; use crate::web_api_interfaces; @@ -38,7 +37,6 @@ const BODY_SOURCE_BLOB_SLOT: &str = "__lmNetworkBodySourceBlob"; const BODY_SOURCE_KIND_STREAM: &str = "stream"; const BODY_SOURCE_ORIGINAL_SLOT: &str = "__lmNetworkBodySourceOriginal"; const BODY_SOURCE_KIND_REGISTRY_BYTES: &str = "registry-bytes"; -const BODY_SOURCE_KIND_SUBRESOURCE_BODY: &str = "subresource-body"; const BODY_SOURCE_KIND_PENDING_STREAM: &str = "pending-stream"; const FILTERED_RESPONSE_INTERNAL_BODY_SOURCE_SLOT: &str = "__lmFilteredResponseInternalBodySource"; const FILTERED_RESPONSE_INTERNAL_BODY_STREAM_SLOT: &str = "__lmFilteredResponseInternalBodyStream"; @@ -122,12 +120,6 @@ enum NetworkBodySourceState { offset: usize, len: usize, }, - // Reuses the protocol/CDP subresource carrier so worker fetch can hand large - // bodies to Web consumers without first rebuilding a single materialized Vec. - Subresource { - body: SubresourceResponseBody, - offset: usize, - }, } impl NetworkBodySourceState { @@ -171,7 +163,6 @@ impl NetworkBodySourceState { Ok(bytes.get(*offset..).map(<[u8]>::to_vec).unwrap_or_default()) } Self::File { path, offset, .. } => read_network_body_spool_remaining(path, *offset), - Self::Subresource { body, offset } => body.materialize_bytes_from(*offset), } } @@ -196,7 +187,6 @@ impl NetworkBodySourceState { file.read_to_end(&mut bytes)?; Ok(bytes) } - Self::Subresource { body, offset } => body.materialize_bytes_from(*offset), } } @@ -234,15 +224,6 @@ impl NetworkBodySourceState { *offset = offset.saturating_add(read); Ok(Some(chunk)) } - Self::Subresource { body, offset } => { - let chunk = body.read_chunk(*offset, chunk_size)?; - if chunk.is_empty() { - *offset = body.len(); - return Ok(None); - } - *offset = offset.saturating_add(chunk.len()); - Ok(Some(chunk)) - } } } @@ -250,7 +231,6 @@ impl NetworkBodySourceState { match self { Self::Memory { bytes, offset } => *offset >= bytes.len(), Self::File { offset, len, .. } => *offset >= *len, - Self::Subresource { body, offset } => *offset >= body.len(), } } } @@ -707,15 +687,6 @@ pub(in crate::network_host) fn set_filtered_response_internal_body_from_bytes<'s set_filtered_response_internal_body_source_object(scope, object, source); } -pub(in crate::network_host) fn set_filtered_response_internal_body_from_subresource_body<'s>( - scope: &mut v8::PinScope<'s, '_>, - object: v8::Local<'s, v8::Object>, - body: SubresourceResponseBody, -) { - let source = network_body_source_object_from_subresource_body(scope, Some(object), body); - set_filtered_response_internal_body_source_object(scope, object, source); -} - fn set_network_body_registry_bytes<'s>( scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>, @@ -742,23 +713,6 @@ pub(in crate::network_host) fn network_body_source_object_from_bytes<'s>( source } -pub(in crate::network_host) fn network_body_source_object_from_subresource_body<'s>( - scope: &mut v8::PinScope<'s, '_>, - owner: Option>, - body: SubresourceResponseBody, -) -> v8::Local<'s, v8::Object> { - let id = register_network_body_subresource_body(body); - let source = RegisteredNetworkBodySourceDeclaration::new( - BODY_SOURCE_KIND_SUBRESOURCE_BODY, - v8::BigInt::new_from_u64(scope, id), - owner, - ) - .bind(scope) - .expect("subresource network body source declaration should bind"); - track_registry_body_source_lifetime(scope, source, id); - source -} - pub(in crate::network_host) fn network_body_stream_from_response_body<'s>( scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>, @@ -767,16 +721,6 @@ pub(in crate::network_host) fn network_body_stream_from_response_body<'s>( set_network_body_response_body(scope, object, body) } -pub(in crate::network_host) fn network_body_stream_from_subresource_body<'s>( - scope: &mut v8::PinScope<'s, '_>, - object: v8::Local<'s, v8::Object>, - body: SubresourceResponseBody, -) -> v8::Local<'s, v8::Object> { - let source = network_body_source_object_from_subresource_body(scope, Some(object), body); - set_network_body_source_object(scope, object, source); - new_readable_stream_from_source(scope, source) -} - pub(crate) fn pending_network_body_stream<'s>( scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>, @@ -1255,16 +1199,7 @@ fn try_network_body_bytes_from_storage<'s>( try_clone_remaining_network_body_bytes(id) }; } - Some(BODY_SOURCE_KIND_SUBRESOURCE_BODY) => { - let Some(id) = registry_body_source_id(scope, object) else { - return Ok(None); - }; - return if consume_registry_body { - try_take_remaining_network_body_bytes(id) - } else { - try_clone_remaining_network_body_bytes(id) - }; - } + Some(kind) if kind != BODY_SOURCE_KIND_BYTES => return Ok(None), _ => {} } @@ -1813,15 +1748,6 @@ fn register_network_body_bytes(bytes: Vec) -> NetworkBodySourceId { id } -fn register_network_body_subresource_body(body: SubresourceResponseBody) -> NetworkBodySourceId { - let id = new_network_body_source_id(); - NETWORK_BODY_SOURCES - .get_or_init(|| Mutex::new(HashMap::new())) - .lock() - .insert(id, NetworkBodySourceState::Subresource { body, offset: 0 }); - id -} - fn read_network_body_spool_remaining(path: &Path, offset: usize) -> io::Result> { let mut file = File::open(path)?; file.seek(SeekFrom::Start(offset as u64))?; @@ -2442,22 +2368,6 @@ fn call_controller_method<'s>( mod tests { use super::*; - #[test] - fn network_body_source_subresource_reads_through_fallible_source() { - let body = SubresourceResponseBody::from_bytes(b"hello world".to_vec()); - let id = register_network_body_subresource_body(body); - - assert_eq!( - try_clone_remaining_network_body_bytes(id).unwrap().unwrap(), - b"hello world" - ); - assert_eq!( - try_take_next_network_body_chunk(id).unwrap().unwrap(), - b"hello world" - ); - assert!(!network_body_source_has_remaining(id)); - } - #[test] fn network_body_source_file_read_errors_are_not_silent_empty_bodies() { let id = new_network_body_source_id(); diff --git a/moli-renderer-v8/src/network_host/controlled_xhr.rs b/moli-renderer-v8/src/network_host/controlled_xhr.rs index 8b4fb5801b3..9c808dbbe3d 100644 --- a/moli-renderer-v8/src/network_host/controlled_xhr.rs +++ b/moli-renderer-v8/src/network_host/controlled_xhr.rs @@ -1,12 +1,14 @@ -//! Shared native interception transport for XHR and stylesheet resources. +//! Native interception transport shared by Worker fetch, XHR and stylesheets. mod context; +mod fetch; mod result; +mod service_worker; mod stream; pub(crate) use context::{ControlledXhrContext, XhrInterceptionRoute}; use result::BufferedXhrResponse; pub(crate) use result::{XhrLoadResult, start_buffered_xhr}; -pub(crate) use stream::{ControlledXhrCompletion, ControlledXhrStream}; +pub(crate) use stream::{ControlledResourceStream, ControlledXhrCompletion}; use moli_fetch::{FetchCancelHandle, Request, Response, ResponseHead}; use tokio::sync::oneshot; @@ -18,24 +20,32 @@ use crate::{ interception_control::{ InterceptionPhase, ResourceInterceptionDecision, ResourceInterceptionPause, }, - interception_output::InterceptionOutput, loads::ResourceLoadLease, }, - runtime::{RendererDocumentLifecycleIdentity, RendererOwnerAction}, + runtime::RendererOwnerAction, types::{ PendingSubresourceAuthInfo, PendingSubresourceContinueEvent, PendingSubresourceFetchInfo, PendingSubresourceResponseInfo, SubresourceRequestInitiatorType, SubresourceResponseBody, }, }; +#[derive(Clone, Copy)] +enum ResourceResponsePolicy { + Xhr, + Fetch(crate::types::SubresourcePolicyContext), +} + pub(crate) struct ControlledResourceLoad { + response_policy: ResourceResponsePolicy, + service_worker: Option, + response_filter: Option, request: Request, info: PendingSubresourceFetchInfo, load: ResourceLoadLease, cancel: FetchCancelHandle, - source_document: RendererDocumentLifecycleIdentity, - output: InterceptionOutput, + interception: crate::network::interception_output::ResourceInterceptionContext, connect_policy: Option, + csp_violations: Vec, preflight_headers: Vec<(String, String)>, initial_decision: Option>, request_initiator_type: SubresourceRequestInitiatorType, @@ -47,7 +57,7 @@ impl LoadedResponse { async fn deliver( &self, info: &PendingSubresourceFetchInfo, - stream: Option<&mut ControlledXhrStream>, + stream: Option<&mut ControlledResourceStream>, network_request_headers: Option>, ) -> Result, String> { if let Some(stream) = stream { @@ -81,6 +91,14 @@ impl LoadedResponse { } impl ControlledResourceLoad { + pub(crate) fn with_fetch_policy( + mut self, + policy: crate::types::SubresourcePolicyContext, + ) -> Self { + self.response_policy = ResourceResponsePolicy::Fetch(policy); + self + } + pub(crate) fn for_stylesheet( interception: crate::network::interception_output::ResourceInterceptionContext, request: Request, @@ -90,13 +108,16 @@ impl ControlledResourceLoad { request_initiator_type: SubresourceRequestInitiatorType, ) -> Self { Self { + response_policy: ResourceResponsePolicy::Xhr, + service_worker: None, + response_filter: None, request, info, load, cancel, - source_document: interception.source_document, - output: interception.output, + interception, connect_policy: None, + csp_violations: Vec::new(), preflight_headers: Vec::new(), initial_decision: None, request_initiator_type, @@ -109,13 +130,7 @@ impl ControlledResourceLoad { pub(crate) fn prepare_initial_pause(&mut self) -> RendererOwnerAction { let (pause, decision) = self.pause(InterceptionPhase::Request); self.initial_decision = Some(decision); - RendererOwnerAction::SubresourceFetchPause { - redirect: None, - source_document: self.source_document, - info: Box::new(self.info.clone()), - child_document: None, - network_pause: Some(pause), - } + self.interception.request_action(self.info.clone(), pause) } pub(crate) async fn run(self) -> XhrLoadResult { @@ -129,10 +144,12 @@ impl ControlledResourceLoad { pub(crate) async fn run_with_stream( mut self, - mut stream: Option, + mut stream: Option, ) -> ControlledXhrCompletion { let result = self.run_inner(stream.as_mut()).await; - if let Some(body_source_id) = stream.as_ref().and_then(|stream| stream.body_source_id) { + let result = self.normalize_cancellation(result); + self.load.finish(); + if let Some(body_source_id) = stream.as_ref().and_then(|stream| stream.body_source_id()) { self.publish_completed(); return ControlledXhrCompletion::Streamed { internal_id: self.info.internal_id, @@ -148,14 +165,14 @@ impl ControlledResourceLoad { Err(error) => (Err(error), None), }; let mut completed = XhrLoadResult::new(self.info.clone(), result, network_headers); + completed.csp_violations = std::mem::take(&mut self.csp_violations); completed.network_record = completed .network_record .with_request_initiator_type(self.request_initiator_type); if completed.info.network_request_handle.is_some() { // Redirects already crossed their own native request-pause boundary. // Diagnostics retain the full chain; protocol sees only the terminal. - self.output.record_subresource_network( - self.source_document, + self.interception.record_subresource_network( completed .network_record .clone() @@ -166,17 +183,21 @@ impl ControlledResourceLoad { ControlledXhrCompletion::Buffered(Box::new(completed)) } + fn normalize_cancellation(&self, result: Result) -> Result { + if result.is_err() && (self.cancel.is_cancelled() || self.load.is_cancelled()) { + Err("net::ERR_ABORTED".into()) + } else { + result + } + } + fn publish_completed(&self) { - let _ = self - .output - .publish(RendererOwnerAction::SubresourceContinue { - response_body: None, - source_document: self.source_document, - event: Box::new(PendingSubresourceContinueEvent::Completed { - internal_id: self.info.internal_id, - }), - network_pause: None, - }); + let _ = self.interception.publish_continue( + PendingSubresourceContinueEvent::Completed { + internal_id: self.info.internal_id, + }, + None, + ); } fn pause( @@ -196,6 +217,7 @@ impl ControlledResourceLoad { .flatten(); ( pause + .with_worker_network(self.interception.is_worker()) .with_request_redirect(redirect) .with_request_initiator_type(self.request_initiator_type), rx, @@ -205,10 +227,18 @@ impl ControlledResourceLoad { async fn decision( &self, rx: oneshot::Receiver, + phase: InterceptionPhase, ) -> Result { tokio::select! { biased; () = self.cancel.cancelled() => Err("net::ERR_ABORTED".into()), + () = self.interception.worker_control_shutdown() => if self.load.disposition() != crate::network::loads::ResourceLoadDisposition::Keepalive { + Err("net::ERR_ABORTED".into()) + } else { Ok(match phase { + InterceptionPhase::Request => ResourceInterceptionDecision::ContinueRequest {url:None,method:None,body:None,headers:None,intercept_response:false,handle_auth_requests:false}, + InterceptionPhase::Response => ResourceInterceptionDecision::ContinueResponse {status:None,headers:None}, + InterceptionPhase::Auth => ResourceInterceptionDecision::CancelAuth, + }) }, result = rx => result.map_err(|_| "network interception owner was dropped".into()), } } @@ -226,39 +256,108 @@ impl ControlledResourceLoad { } fn apply_request_overrides(&mut self, overrides: moli_fetch::RequestOverrides) { + let request_changed = overrides.url.is_some() + || overrides.method.is_some() + || overrides.body.is_some() + || overrides.headers.is_some(); let headers_changed = overrides.headers.is_some(); overrides.apply(&mut self.request); if headers_changed { self.preflight_headers = self.request.request_headers.to_byte_strings(); } self.sync_info(); + if request_changed && self.interception.is_worker() { + // The request ID is already announced before its Fetch pause. An + // updated snapshot refreshes body capture and subsequent response + // metadata; Network's existing announcement claim suppresses a + // second requestWillBeSent for this hop. + self.publish_worker_request(None); + } } - fn check_request(&self) -> Result<(), String> { + fn publish_worker_request(&self, redirect: Option) { + let handle = self + .info + .network_request_handle + .expect("native resource load has a handle"); + self.interception.publish_network( + crate::types::ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new( + crate::types::SubresourceRequestStarted::new( + handle, + self.info.frame_id.clone(), + self.info.document_url.clone(), + self.info.url.clone(), + self.info.method.clone(), + self.info.request_headers.clone(), + self.info.request_body.clone(), + self.info.resource_type, + self.request_initiator_type, + self.info.request_cookie_report.clone(), + ) + .with_request_body_bytes(self.info.request_body_bytes.clone()) + .with_redirect(redirect) + .with_keepalive( + self.load.disposition() + == crate::network::loads::ResourceLoadDisposition::Keepalive, + ), + )), + ); + } + + fn check_request(&mut self) -> Result<(), String> { let redirect_status = if self.request.redirect_count() == 0 { crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect } else { crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect }; + if self.interception.is_worker() + && self.request.redirect_count() != 0 + && let Some(mut violation) = self.connect_policy.as_ref().and_then(|policy| { + policy.report_only_violation( + &self.info.document_url, + &self.request.url, + redirect_status, + ) + }) + { + violation.blocked_uri = self.request.redirect_chain()[0].from_url.to_string(); + self.csp_violations.push(violation); + } if let Some(policy) = &self.connect_policy - && let Some(violation) = policy.enforce_violation( + && let Some(mut violation) = policy.enforce_violation( &self.info.document_url, &self.request.url, redirect_status, ) { - return Err( - crate::document_runtime::document_content_security_policy_error_message( - &violation, - "XMLHttpRequest", - ), + if self.request.redirect_count() != 0 { + violation.blocked_uri = self + .request + .redirect_chain() + .first() + .expect("redirect chain is nonempty") + .from_url + .to_string(); + } + let message = crate::document_runtime::document_content_security_policy_error_message( + &violation, + "XMLHttpRequest", ); + if self.interception.is_worker() { + self.csp_violations.push(violation); + } + return Err(message); } if self.connect_policy.is_none() { self.request .admit_request_url(&self.request.url) .map_err(|error| error.to_string())?; } + if matches!(self.response_policy, ResourceResponsePolicy::Fetch(_)) + && matches!(self.request.url.scheme(), "blob" | "data") + { + return Ok(()); + } moli_url_policy::ensure_http_network_transport_url(&self.request.url) .map_err(|error| error.to_string()) } @@ -286,24 +385,48 @@ impl ControlledResourceLoad { async fn run_inner( &mut self, - mut stream: Option<&mut ControlledXhrStream>, + mut stream: Option<&mut ControlledResourceStream>, ) -> Result<(Option, Option>), String> { use ResourceInterceptionDecision as D; - let mut next_request_pause = true; + let mut next_request_pause = self.initial_decision.is_some() + || self + .load + .request_client() + .page_network_policy() + .should_intercept_subresource(self.info.resource_type); + let mut announce_request = self.interception.is_worker(); let mut intercept_response = false; let mut handle_auth_requests = false; let mut synthetic = None; let mut network_request_headers = None; let preflight_observer = super::preflight_events::CorsPreflightNetworkObserver::for_native_xhr( - self.output.clone(), - self.source_document, + self.interception.clone(), &self.info, ); loop { if self.cancel.is_cancelled() || self.load.is_cancelled() { return Err("net::ERR_ABORTED".into()); } + if announce_request { + self.sync_info(); + self.publish_worker_request( + self.request + .redirect_chain() + .last() + .cloned() + .map(Into::into), + ); + announce_request = false; + } + if self.interception.worker_control_closed() { + if self.load.disposition() + != crate::network::loads::ResourceLoadDisposition::Keepalive + { + return Err("net::ERR_ABORTED".into()); + } + next_request_pause = false; + } if next_request_pause { // ExtraInfo describes the first on-wire request of this hop. // Authentication retries retain it; a redirect starts a new hop. @@ -313,21 +436,14 @@ impl ControlledResourceLoad { rx } else { let (pause, rx) = self.pause(InterceptionPhase::Request); - if !self - .output - .publish(RendererOwnerAction::SubresourceFetchPause { - redirect: None, - source_document: self.source_document, - info: Box::new(self.info.clone()), - child_document: None, - network_pause: Some(pause), - }) + if !self.interception.publish_request(self.info.clone(), pause) + && !self.interception.worker_control_closed() { return Err("network interception output owner is closed".into()); } rx }; - match self.decision(rx).await? { + match self.decision(rx, InterceptionPhase::Request).await? { D::ContinueRequest { url, method, @@ -363,11 +479,31 @@ impl ControlledResourceLoad { } } self.check_request()?; + if synthetic.is_none() && matches!(self.request.url.scheme(), "blob" | "data") { + synthetic = Some( + crate::network_host::local_url_response_result( + &self.request.url, + &self.request.method, + ) + .expect("local resource routing") + .map_err(|error| error.to_string())?, + ); + } + self.response_filter = None; + if synthetic.is_none() + && let Some(source) = self.service_worker.clone() + && let Some(response) = self.fetch_service_worker_hop(source).await? + { + synthetic = Some(response); + } let loader: ResourceRequestClient = self.load.request_client(); let hop_cancel = self.cancel.child_for_subrequest(); let (response, mut is_synthetic, observed_request_headers) = match synthetic.take() { Some(response) => (LoadedResponse::from_response(response), true, None), None => { + if self.load.network_offline() { + return Err("Network emulation offline".into()); + } let observed = super::async_fetch::fetch_subresource_hop( &loader, self.request.clone(), @@ -393,37 +529,31 @@ impl ControlledResourceLoad { { let (pause, rx) = self.pause(InterceptionPhase::Auth); let pause = pause.with_response_body(response.body.clone()); - if !self - .output - .publish(RendererOwnerAction::SubresourceContinue { - response_body: None, - source_document: self.source_document, - event: Box::new(PendingSubresourceContinueEvent::AuthRequired( - PendingSubresourceAuthInfo { - internal_id: self.info.internal_id, - url: self.request.url.clone(), - method: self.request.method.clone(), - request_headers: self.request.request_headers.clone(), - request_body: self.info.request_body.clone(), - resource_type: self.info.resource_type, - request_cookie_report: response.head.request_cookie_report.clone(), - network_request_headers: network_request_headers.clone(), - challenge, - intercept_response, - response_final_url: response.head.final_url.clone(), - response_status: response.head.status, - response_headers: response.head.headers.clone(), - response_body: SubresourceResponseBody::from_bytes(Vec::new()), - response_from_cache: response.head.from_cache, - response_cache_state: response.head.cache_state, - }, - )), - network_pause: Some(pause), - }) + if !self.interception.publish_continue( + PendingSubresourceContinueEvent::AuthRequired(PendingSubresourceAuthInfo { + internal_id: self.info.internal_id, + url: self.request.url.clone(), + method: self.request.method.clone(), + request_headers: self.request.request_headers.clone(), + request_body: self.info.request_body.clone(), + resource_type: self.info.resource_type, + request_cookie_report: response.head.request_cookie_report.clone(), + network_request_headers: network_request_headers.clone(), + challenge, + intercept_response, + response_final_url: response.head.final_url.clone(), + response_status: response.head.status, + response_headers: response.head.headers.clone(), + response_body: SubresourceResponseBody::from_bytes(Vec::new()), + response_from_cache: response.head.from_cache, + response_cache_state: response.head.cache_state, + }), + Some(pause), + ) && !self.interception.worker_control_closed() { return Err("network authentication output owner is closed".into()); } - match self.decision(rx).await? { + match self.decision(rx, InterceptionPhase::Auth).await? { D::Auth(auth) => { if !self.load.try_restart_with_auth() { return Err(moli_fetch::AuthRetryBudget::ERROR_TEXT.into()); @@ -440,35 +570,31 @@ impl ControlledResourceLoad { if intercept_response { let (pause, rx) = self.pause(InterceptionPhase::Response); let pause = pause.with_response_body(response.body.clone()); - if !self - .output - .publish(RendererOwnerAction::SubresourceContinue { - response_body: None, - source_document: self.source_document, - event: Box::new(PendingSubresourceContinueEvent::ResponsePaused( - PendingSubresourceResponseInfo { - internal_id: self.info.internal_id, - url: self.request.url.clone(), - final_url: response.head.final_url.clone(), - method: self.request.method.clone(), - request_headers: self.request.request_headers.clone(), - request_body: self.info.request_body.clone(), - resource_type: self.info.resource_type, - request_cookie_report: response.head.request_cookie_report.clone(), - network_request_headers: network_request_headers.clone(), - response_status: response.head.status, - response_headers: response.head.headers.clone(), - response_body: SubresourceResponseBody::from_bytes(Vec::new()), - from_cache: response.head.from_cache, - cache_state: response.head.cache_state, - }, - )), - network_pause: Some(pause), - }) + if !self.interception.publish_continue( + PendingSubresourceContinueEvent::ResponsePaused( + PendingSubresourceResponseInfo { + internal_id: self.info.internal_id, + url: self.request.url.clone(), + final_url: response.head.final_url.clone(), + method: self.request.method.clone(), + request_headers: self.request.request_headers.clone(), + request_body: self.info.request_body.clone(), + resource_type: self.info.resource_type, + request_cookie_report: response.head.request_cookie_report.clone(), + network_request_headers: network_request_headers.clone(), + response_status: response.head.status, + response_headers: response.head.headers.clone(), + response_body: SubresourceResponseBody::from_bytes(Vec::new()), + from_cache: response.head.from_cache, + cache_state: response.head.cache_state, + }, + ), + Some(pause), + ) && !self.interception.worker_control_closed() { return Err("network response output owner is closed".into()); } - match self.decision(rx).await? { + match self.decision(rx, InterceptionPhase::Response).await? { D::ContinueResponse { status, headers } => { if let Some(status) = status { response.head.status = status; @@ -487,6 +613,7 @@ impl ControlledResourceLoad { response = LoadedResponse::from_response( self.synthetic_response(status, headers, body), ); + self.response_filter = None; is_synthetic = true; } D::Fail(error) => return Err(error), @@ -496,17 +623,46 @@ impl ControlledResourceLoad { use super::response_hop::{ SubresourceResponseTransition, advance_subresource_response, }; - let transition = - advance_subresource_response(&mut self.request, response.head.clone(), false)?; - if let SubresourceResponseTransition::ManualResponse { .. } = transition { + let transition = if matches!(self.response_policy, ResourceResponsePolicy::Fetch(_)) + && is_synthetic + && self.request.redirect_mode() == moli_fetch::RequestRedirectMode::Error + && !response + .head + .headers + .iter() + .any(|(name, _)| name.eq_ignore_ascii_case("location")) + { + if self.response_filter.is_none() { + self.request.validate_cors_response_for_url( + &response.head.final_url, + &response.head.headers, + )?; + } + SubresourceResponseTransition::FinalResponse + } else if self.response_filter.is_some() { + super::response_hop::advance_validated_subresource_response( + &mut self.request, + response.head.clone(), + false, + )? + } else { + advance_subresource_response(&mut self.request, response.head.clone(), false)? + }; + let manual = matches!( + transition, + SubresourceResponseTransition::ManualResponse { .. } + ); + if manual && matches!(self.response_policy, ResourceResponsePolicy::Xhr) { return Err("XHR requests must follow redirects".into()); } - if transition == SubresourceResponseTransition::FinalResponse { + if manual || transition == SubresourceResponseTransition::FinalResponse { response.head.redirect_chain = self.request.redirect_chain().to_vec(); response.head.redirected = !response.head.redirect_chain.is_empty(); // Client-provided responses have the same CORS obligations as // transport responses. Validate before any success is published. - if self.request.request_mode == moli_fetch::RequestMode::Cors { + if self.response_filter.is_none() + && self.request.request_mode == moli_fetch::RequestMode::Cors + { super::validate_cors_response_chain( self.request .request_origin() @@ -518,10 +674,17 @@ impl ControlledResourceLoad { if !is_synthetic { self.cancel.adopt_response_progress(&hop_cancel); } + if let Some(stream) = stream.as_deref_mut() { + stream.policy_violations(std::mem::take(&mut self.csp_violations)); + } let delivered = response .deliver( &self.info, - if is_synthetic { + if is_synthetic + || manual + || (matches!(self.response_policy, ResourceResponsePolicy::Fetch(_)) + && self.request.request_mode == moli_fetch::RequestMode::NoCors) + { None } else { stream.as_deref_mut() @@ -534,16 +697,18 @@ impl ControlledResourceLoad { self.preflight_headers = self.request.request_headers.to_byte_strings(); // Retire the previous hop's protocol correlation before installing // its next one. The stable native network handle keeps Network ID. - self.output - .publish(RendererOwnerAction::SubresourceContinue { - response_body: None, - source_document: self.source_document, - event: Box::new(PendingSubresourceContinueEvent::Completed { - internal_id: self.info.internal_id, - }), - network_pause: None, - }); - next_request_pause = true; + self.interception.publish_continue( + PendingSubresourceContinueEvent::Completed { + internal_id: self.info.internal_id, + }, + None, + ); + next_request_pause = self + .load + .request_client() + .page_network_policy() + .should_intercept_subresource(self.info.resource_type); + announce_request = self.interception.is_worker(); } } } diff --git a/moli-renderer-v8/src/network_host/controlled_xhr/context.rs b/moli-renderer-v8/src/network_host/controlled_xhr/context.rs index 5cbf576a9ab..bc4b8487add 100644 --- a/moli-renderer-v8/src/network_host/controlled_xhr/context.rs +++ b/moli-renderer-v8/src/network_host/controlled_xhr/context.rs @@ -5,7 +5,7 @@ use crate::{ }; /// Chosen once, before dispatch. Compatibility is the explicit asynchronous -/// adapter for embeddings without a native protocol owner (and SharedWorkers). +/// adapter for embeddings without a native protocol owner. /// An incomplete native owner is an error, never an ordinary network route. pub(crate) enum XhrInterceptionRoute { Ordinary, @@ -33,24 +33,44 @@ pub(crate) struct ControlledXhrContext { impl ControlledXhrContext { pub(crate) fn load( self, - request: moli_fetch::Request, + mut request: moli_fetch::Request, mut info: PendingSubresourceFetchInfo, load: ResourceLoadLease, cancel: moli_fetch::FetchCancelHandle, preflight_headers: Vec<(String, String)>, ) -> super::ControlledResourceLoad { + request = load.request_client().bind_browser_site_context(request); info.request_headers = request.interception_request_headers(); super::ControlledResourceLoad { + response_policy: super::ResourceResponsePolicy::Xhr, + service_worker: None, + response_filter: None, request, info, load, cancel, - source_document: self.interception.source_document, - output: self.interception.output, + interception: self.interception, connect_policy: Some(self.connect_policy), + csp_violations: Vec::new(), preflight_headers, initial_decision: None, request_initiator_type: crate::types::SubresourceRequestInitiatorType::Script, } } } + +impl ControlledXhrContext { + pub(crate) fn fetch_load( + self, + request: moli_fetch::Request, + info: PendingSubresourceFetchInfo, + load: ResourceLoadLease, + cancel: moli_fetch::FetchCancelHandle, + policy: crate::types::SubresourcePolicyContext, + ) -> super::ControlledResourceLoad { + let headers = request.request_headers.to_byte_strings(); + let mut controlled = self.load(request, info, load, cancel, headers); + controlled.response_policy = super::ResourceResponsePolicy::Fetch(policy); + controlled + } +} diff --git a/moli-renderer-v8/src/network_host/controlled_xhr/fetch.rs b/moli-renderer-v8/src/network_host/controlled_xhr/fetch.rs new file mode 100644 index 00000000000..e79a80a3d34 --- /dev/null +++ b/moli-renderer-v8/src/network_host/controlled_xhr/fetch.rs @@ -0,0 +1,279 @@ +use moli_fetch::{RequestCredentialsMode, RequestMode, ResponseHead}; +use tokio::sync::mpsc; + +use crate::{ + network::{ResourceInterceptionBody, interception_output::ResourceInterceptionContext}, + types::{ + NetworkBodySourceId, PendingSubresourceFetchInfo, ScriptNetworkOutputItem, + SubresourceBodyFinished, SubresourceDataReceived, SubresourcePolicyContext, + SubresourceResponseStarted, + }, + worker::{ + WorkerFetchEvent, WorkerFetchStreamingChunk, WorkerFetchStreamingFinished, + WorkerFetchStreamingStarted, + }, +}; + +/// JS delivery and the Network observer consume the same native response; +/// neither needs the creator Page to resume a Worker command. +pub(crate) struct ControlledFetchStream { + completion: mpsc::UnboundedSender, + fetch_id: u32, + interception: ResourceInterceptionContext, + mode: RequestMode, + credentials: RequestCredentialsMode, + policy: SubresourcePolicyContext, + pub(super) body_source_id: Option, + response: Option< + Box<( + PendingSubresourceFetchInfo, + ResponseHead, + ResourceInterceptionBody, + )>, + >, + delivered: usize, +} + +impl ControlledFetchStream { + pub(super) fn policy_violations( + &self, + violations: Vec, + ) { + if !violations.is_empty() { + let _ = self + .completion + .send(WorkerFetchEvent::PolicyViolations(violations)); + } + } + + pub(super) fn new( + completion: mpsc::UnboundedSender, + fetch_id: u32, + interception: ResourceInterceptionContext, + mode: RequestMode, + credentials: RequestCredentialsMode, + policy: SubresourcePolicyContext, + ) -> Self { + Self { + completion, + fetch_id, + interception, + mode, + credentials, + policy, + body_source_id: None, + response: None, + delivered: 0, + } + } + + pub(super) fn start( + &mut self, + info: &PendingSubresourceFetchInfo, + head: ResponseHead, + network_request_headers: Option>, + body: ResourceInterceptionBody, + ) -> Result<(), String> { + super::super::validate_fetch_response_security_policy_with_body_classified( + &info.document_url, + &head, + &[], + self.mode, + self.credentials, + self.policy, + ) + .map_err(|error| error.into_message())?; + let handle = info + .network_request_handle + .expect("native Fetch owns its request handle"); + self.interception + .publish_network(ScriptNetworkOutputItem::SubresourceResponseStarted( + Box::new( + SubresourceResponseStarted::new( + handle, + head.redirect_chain + .clone() + .into_iter() + .map(Into::into) + .collect(), + head.final_url.clone(), + head.status, + head.headers.clone(), + head.cookie_set_reports.clone(), + ) + .with_status_text(head.status_text.clone()) + .with_from_cache(head.from_cache) + .with_network_request_headers(network_request_headers.clone()) + .with_negotiated_http_version(head.negotiated_http_version), + ), + )); + let body_source_id = super::super::new_network_body_source_id(); + self.body_source_id = Some(body_source_id); + let _ = self.completion.send(WorkerFetchEvent::StreamingStarted( + WorkerFetchStreamingStarted { + fetch_id: self.fetch_id, + body_source_id, + head: head.clone(), + }, + )); + self.response = Some(Box::new((info.clone(), head, body))); + Ok(()) + } + + pub(super) fn chunk(&mut self, bytes: Vec) -> Result<(), String> { + let handle = self + .response + .as_ref() + .expect("response precedes body") + .0 + .network_request_handle + .unwrap(); + self.delivered += bytes.len(); + self.interception + .publish_network(ScriptNetworkOutputItem::SubresourceDataReceived( + SubresourceDataReceived::new(handle, bytes.len(), bytes.len()), + )); + // A detached JS consumer does not cancel a keepalive transport. Its + // resource lease, rather than this delivery channel, owns cancellation. + let _ = self.completion.send(WorkerFetchEvent::StreamingChunk( + WorkerFetchStreamingChunk { + body_source_id: self.body_source_id.unwrap(), + bytes, + }, + )); + Ok(()) + } + + pub(super) fn finish(&mut self, result: Result<(), String>) { + let (info, head, source) = *self + .response + .take() + .expect("streamed response must have headers"); + let handle = info.network_request_handle.unwrap(); + let body = source.finish_capture(self.delivered); + let terminal = match &result { + Ok(()) => SubresourceBodyFinished::ready_after_streaming(handle, body.clone()), + Err(error) => SubresourceBodyFinished::failed_with_partial_body( + handle, + network_error(error), + body.clone(), + ), + }; + self.interception + .publish_network(ScriptNetworkOutputItem::SubresourceBodyFinished(Box::new( + terminal, + ))); + let _ = self.completion.send(WorkerFetchEvent::StreamingFinished( + WorkerFetchStreamingFinished { + fetch_id: self.fetch_id, + body_source_id: self.body_source_id.unwrap(), + head, + result: result.map(|()| body), + }, + )); + } +} + +fn network_error(error: &str) -> String { + if super::super::is_cors_policy_failure_message(error) { + super::super::FAILED_ERROR_TEXT.to_owned() + } else { + error.to_owned() + } +} + +impl super::ControlledResourceLoad { + pub(crate) async fn run_fetch( + mut self, + completion: mpsc::UnboundedSender, + fetch_id: u32, + ) { + let super::ResourceResponsePolicy::Fetch(policy) = self.response_policy else { + panic!("Worker fetch requires Fetch response policy"); + }; + let mut stream = super::ControlledResourceStream::WorkerFetch(ControlledFetchStream::new( + completion.clone(), + fetch_id, + self.interception.clone(), + self.request.request_mode, + self.request.credentials_mode, + policy, + )); + let result = self.run_inner(Some(&mut stream)).await; + let result = self.normalize_cancellation(result); + stream.policy_violations(std::mem::take(&mut self.csp_violations)); + if stream.body_source_id().is_some() { + let super::ControlledResourceStream::WorkerFetch(stream) = &mut stream else { + unreachable!() + }; + stream.finish(result.map(|_| ())); + self.load.finish(); + self.publish_completed(); + return; + } + let (mut result, headers) = match result { + Ok((Some(response), headers)) => (Ok(response), headers), + Ok((None, _)) => unreachable!("no stream was started"), + Err(error) => (Err(error), None), + }; + let mut blocked_opaque = false; + if self.response_filter.is_none() + && let Ok(delivered) = &result + { + match super::super::validate_fetch_response_security_policy_with_body_classified( + &self.info.document_url, + &delivered.response.head(), + delivered.response.body_bytes(), + self.request.request_mode, + self.request.credentials_mode, + policy, + ) { + Ok(()) => {} + Err(super::super::FetchResponseSecurityViolation::OpaqueResponseBlocked(_)) => { + blocked_opaque = true + } + Err(error) => result = Err(error.into_message()), + } + } + let mut record = super::result::XhrLoadResult::new(self.info.clone(), result, headers); + if let Err(error) = &record.result { + record.network_record = failure_record(&self.info, network_error(error)); + } else if blocked_opaque { + record.network_record = + failure_record(&self.info, super::super::ABORTED_ERROR_TEXT.to_owned()); + } + self.load.finish(); + self.interception + .record_subresource_network(record.network_record); + self.publish_completed(); + let _ = completion.send(WorkerFetchEvent::Completion(Box::new( + crate::worker::WorkerFetchCompletion { + fetch_id, + result: record + .result + .map(|response| crate::worker::WorkerFetchResponse { + response: Box::new(response), + filter: self.response_filter, + }), + }, + ))); + } +} + +fn failure_record( + info: &PendingSubresourceFetchInfo, + error: String, +) -> crate::types::SubresourceNetworkRecord { + crate::types::SubresourceNetworkRecord::failure( + info.frame_id.clone(), + info.document_url.clone(), + info.url.clone(), + info.method.clone(), + info.request_headers.clone(), + info.request_body.clone(), + info.resource_type, + error, + ) + .with_request_handle(info.network_request_handle.expect("native Fetch identity")) + .with_request_body_bytes(info.request_body_bytes.clone()) +} diff --git a/moli-renderer-v8/src/network_host/controlled_xhr/result.rs b/moli-renderer-v8/src/network_host/controlled_xhr/result.rs index d8cdab0d485..784bb6e5c80 100644 --- a/moli-renderer-v8/src/network_host/controlled_xhr/result.rs +++ b/moli-renderer-v8/src/network_host/controlled_xhr/result.rs @@ -28,6 +28,8 @@ pub(crate) struct XhrLoadResult { pub(crate) result: Result, pub(crate) info: PendingSubresourceFetchInfo, pub(crate) network_record: SubresourceNetworkRecord, + pub(crate) csp_violations: + Vec, } impl XhrLoadResult { @@ -95,6 +97,7 @@ impl XhrLoadResult { info, result: result.map(|delivered| delivered.response), network_record, + csp_violations: Vec::new(), } } } diff --git a/moli-renderer-v8/src/network_host/controlled_xhr/service_worker.rs b/moli-renderer-v8/src/network_host/controlled_xhr/service_worker.rs new file mode 100644 index 00000000000..1292f3abec2 --- /dev/null +++ b/moli-renderer-v8/src/network_host/controlled_xhr/service_worker.rs @@ -0,0 +1,106 @@ +use super::*; +use crate::service_worker_runtime::{ + ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerFetchDispatch, + ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination, + ServiceWorkerRuntimeService, +}; + +#[derive(Clone)] +pub(crate) struct WorkerServiceWorkerFetch { + pub(crate) runtime: ServiceWorkerRuntimeService, + pub(crate) client_id: ServiceWorkerClientId, + pub(crate) metadata: ServiceWorkerFetchRequestMetadata, +} +impl ControlledResourceLoad { + pub(crate) fn with_service_worker( + mut self, + runtime: Option, + client_id: Option, + metadata: ServiceWorkerFetchRequestMetadata, + ) -> Self { + if let (Some(runtime), Some(client_id)) = (runtime, client_id) { + self.service_worker = Some(WorkerServiceWorkerFetch { + runtime, + client_id, + metadata, + }); + } + self + } + pub(super) async fn fetch_service_worker_hop( + &mut self, + source: WorkerServiceWorkerFetch, + ) -> Result, String> { + if self.load.request_client().bypass_service_worker() + || source + .runtime + .matching_controller_for_client_fetch(source.client_id, &self.request.url) + .is_none() + { + return Ok(None); + } + let (tx, rx) = tokio::sync::oneshot::channel(); + let ResourceResponsePolicy::Fetch(policy_context) = self.response_policy else { + return Ok(None); + }; + let dispatch = ServiceWorkerFetchDispatch { + internal_id: self.info.internal_id, + request: ServiceWorkerFetchRequest { + client_id: source.client_id, + resulting_client_id: None, + url: self.request.url.clone(), + method: self.request.method.clone(), + headers: self.request.request_headers.to_byte_strings(), + body: self.request.body.clone(), + destination: ServiceWorkerRequestDestination::for_subresource_resource_type( + self.info.resource_type, + ) + .unwrap_or(ServiceWorkerRequestDestination::Empty), + request_mode: self.request.request_mode, + credentials_mode: self.request.credentials_mode, + redirect_mode: self.request.redirect_mode(), + priority: self.request.priority_hints.fetch_priority, + is_reload: false, + metadata: source.metadata, + }, + cors_preflight_request_headers: self.preflight_headers.clone(), + request_cookie_report: None, + network_context: crate::types::AsyncSubresourceNetworkContext { + frame_id: None, + document_url: self.info.document_url.clone(), + request_origin: self + .request + .browser_origin() + .map_err(|e| e.to_string())? + .clone(), + resource_type: self.info.resource_type, + policy_context, + }, + completion_tx: + crate::page_task_queue::RendererResourceCompletionSender::direct_completion_only(), + request_client: self.load.request_client(), + resource_task_runner: self.load.task_runner(), + cancel_handle: self.cancel.clone(), + direct_completion_tx: Some(tx), + }; + if !source + .runtime + .dispatch_controlled_fetch_hop(dispatch, self.request.clone()) + { + return Err("service worker fetch dispatch failed".into()); + } + let result = tokio::select! { + biased; + () = self.cancel.cancelled() => { source.runtime.abort_controlled_fetch(self.info.internal_id); return Err("net::ERR_ABORTED".into()); } + result = rx => result.map_err(|_|"service worker response channel closed".to_owned())?, + }; + match result { + ServiceWorkerDirectFetchResult::Fallback => Ok(None), + ServiceWorkerDirectFetchResult::Failure(error) => Err(error), + ServiceWorkerDirectFetchResult::Response(response) => { + self.response_filter = response.response_filter; + Ok(Some((*response.response).into())) + } + } + } +} diff --git a/moli-renderer-v8/src/network_host/controlled_xhr/stream.rs b/moli-renderer-v8/src/network_host/controlled_xhr/stream.rs index 17776cb9a97..d485a469a3e 100644 --- a/moli-renderer-v8/src/network_host/controlled_xhr/stream.rs +++ b/moli-renderer-v8/src/network_host/controlled_xhr/stream.rs @@ -19,12 +19,12 @@ pub(crate) enum ControlledXhrCompletion { /// The transport sends native networking tasks; only their ordinary owner /// delivery can enter XHR callbacks. Body capture uses the existing disk pool. -pub(crate) struct ControlledXhrStream { +pub(crate) struct DocumentResourceStream { completion: RendererResourceCompletionSender, pub(super) body_source_id: Option, } -impl ControlledXhrStream { +impl DocumentResourceStream { pub(crate) fn new(completion: RendererResourceCompletionSender) -> Self { Self { completion, @@ -76,3 +76,47 @@ impl ControlledXhrStream { .map_err(|_| "XHR stream delivery owner is closed".to_owned()) } } + +pub(crate) enum ControlledResourceStream { + Document(DocumentResourceStream), + WorkerFetch(super::fetch::ControlledFetchStream), +} + +impl ControlledResourceStream { + pub(super) fn policy_violations( + &self, + violations: Vec, + ) { + if let Self::WorkerFetch(stream) = self { + stream.policy_violations(violations); + } + } + + pub(crate) fn new(completion: RendererResourceCompletionSender) -> Self { + Self::Document(DocumentResourceStream::new(completion)) + } + pub(super) fn body_source_id(&self) -> Option { + match self { + Self::Document(stream) => stream.body_source_id, + Self::WorkerFetch(stream) => stream.body_source_id, + } + } + pub(super) fn start( + &mut self, + info: &PendingSubresourceFetchInfo, + head: ResponseHead, + headers: Option>, + body: crate::network::ResourceInterceptionBody, + ) -> Result<(), String> { + match self { + Self::Document(stream) => stream.start(info, head, headers, body), + Self::WorkerFetch(stream) => stream.start(info, head, headers, body), + } + } + pub(super) fn chunk(&mut self, bytes: Vec) -> Result<(), String> { + match self { + Self::Document(stream) => stream.chunk(bytes), + Self::WorkerFetch(stream) => stream.chunk(bytes), + } + } +} diff --git a/moli-renderer-v8/src/network_host/preflight_events.rs b/moli-renderer-v8/src/network_host/preflight_events.rs index 75c4548e8e9..6605f3c966f 100644 --- a/moli-renderer-v8/src/network_host/preflight_events.rs +++ b/moli-renderer-v8/src/network_host/preflight_events.rs @@ -19,10 +19,7 @@ pub(in crate::network_host) struct CorsPreflightNetworkObserver { #[derive(Clone)] enum PreflightNetworkOutput { Document(RendererResourceCompletionSender), - Native { - output: crate::network::interception_output::InterceptionOutput, - source_document: crate::runtime::RendererDocumentLifecycleIdentity, - }, + Native(crate::network::interception_output::ResourceInterceptionContext), } impl CorsPreflightNetworkObserver { @@ -39,15 +36,11 @@ impl CorsPreflightNetworkObserver { } pub(super) fn for_native_xhr( - output: crate::network::interception_output::InterceptionOutput, - source_document: crate::runtime::RendererDocumentLifecycleIdentity, + output: crate::network::interception_output::ResourceInterceptionContext, info: &crate::types::PendingSubresourceFetchInfo, ) -> Self { Self { - output: PreflightNetworkOutput::Native { - output, - source_document, - }, + output: PreflightNetworkOutput::Native(output), frame_id: info.frame_id.clone(), document_url: info.document_url.clone(), resource_type: info.resource_type, @@ -112,11 +105,8 @@ impl CorsPreflightNetworkObserver { AsyncSubresourceFetchEvent::ObservedNetworkRecord(Box::new(record)), ); } - PreflightNetworkOutput::Native { - output, - source_document, - } => { - output.record_subresource_network(*source_document, record); + PreflightNetworkOutput::Native(output) => { + output.record_subresource_network(record); } } } diff --git a/moli-renderer-v8/src/network_host/response.rs b/moli-renderer-v8/src/network_host/response.rs index f9583bd2db7..f7f818668f2 100644 --- a/moli-renderer-v8/src/network_host/response.rs +++ b/moli-renderer-v8/src/network_host/response.rs @@ -32,7 +32,6 @@ pub(crate) use self::materialize::{ build_fetch_response_object_for_request_mode, build_fetch_response_object_from_body_source_for_request_mode_with_metadata, build_fetch_response_object_from_stream_for_request_mode_with_metadata, - build_fetch_response_object_from_subresource_body_for_request_mode, build_filtered_cached_response_object, build_navigation_preload_response_object_from_stream_for_request_mode, materialize_response_object_body, materialize_response_object_body_preserving_error, diff --git a/moli-renderer-v8/src/network_host/response/materialize.rs b/moli-renderer-v8/src/network_host/response/materialize.rs index 4f9f2e07f49..137b0cae0ec 100644 --- a/moli-renderer-v8/src/network_host/response/materialize.rs +++ b/moli-renderer-v8/src/network_host/response/materialize.rs @@ -135,26 +135,6 @@ pub(crate) fn build_fetch_response_object_from_body_source_for_request_mode_with finish_fetch_response_object_with_body_stream(scope, obj, &head, body_stream, filter) } -pub(crate) fn build_fetch_response_object_from_subresource_body_for_request_mode<'s>( - scope: &mut v8::PinScope<'s, '_>, - request: FetchResponseRequest<'_>, - head: moli_fetch::ResponseHead, - body: crate::protocol_types::SubresourceResponseBody, - metadata: FetchResponseMetadata, -) -> v8::Local<'s, v8::Object> { - let filter = metadata.response_type; - let obj = build_fetch_response_object_head(scope, &head, &metadata, None); - let body_stream = if request.has_null_body(head.status) { - None - } else if filtered_response_exposes_body(filter) { - Some(network_body_stream_from_subresource_body(scope, obj, body)) - } else { - set_filtered_response_internal_body_from_subresource_body(scope, obj, body); - None - }; - finish_fetch_response_object_with_body_stream(scope, obj, &head, body_stream, filter) -} - #[cfg(test)] pub(crate) fn build_fetch_response_object_from_stream_for_request_mode<'s>( scope: &mut v8::PinScope<'s, '_>, diff --git a/moli-renderer-v8/src/network_host/response_hop.rs b/moli-renderer-v8/src/network_host/response_hop.rs index 9b2530c72ef..8f091dfe762 100644 --- a/moli-renderer-v8/src/network_host/response_hop.rs +++ b/moli-renderer-v8/src/network_host/response_hop.rs @@ -20,6 +20,14 @@ pub(super) fn advance_subresource_response( // Preserve transport-refined snapshots, including cached/internal hops. request.observe_redirect_requests(&head.redirect_chain); request.validate_cors_response_for_url(&head.final_url, &head.headers)?; + advance_validated_subresource_response(request, head, network_extra_info_available) +} + +pub(super) fn advance_validated_subresource_response( + request: &mut Request, + head: ResponseHead, + network_extra_info_available: bool, +) -> Result { // Error mode rejects redirect statuses without consulting Location. if request.redirect_mode() == RequestRedirectMode::Error { if matches!(head.status, 301 | 302 | 303 | 307 | 308) { diff --git a/moli-renderer-v8/src/network_host/xhr/send/paths.rs b/moli-renderer-v8/src/network_host/xhr/send/paths.rs index 13112c37412..50c85481613 100644 --- a/moli-renderer-v8/src/network_host/xhr/send/paths.rs +++ b/moli-renderer-v8/src/network_host/xhr/send/paths.rs @@ -349,10 +349,10 @@ pub(super) fn spawn_network_xhr_fetch( host.append_live_turn_owner_action(controlled.prepare_initial_pause()); runner.spawn(async move { use crate::network_host::controlled_xhr::{ - ControlledXhrCompletion, ControlledXhrStream, + ControlledResourceStream, ControlledXhrCompletion, }; let completed = controlled - .run_with_stream(Some(ControlledXhrStream::new(completion_tx.clone()))) + .run_with_stream(Some(ControlledResourceStream::new(completion_tx.clone()))) .await; let event = match completed { ControlledXhrCompletion::Buffered(completed) => { diff --git a/moli-renderer-v8/src/page_task_queue/worker_host_bridge.rs b/moli-renderer-v8/src/page_task_queue/worker_host_bridge.rs index 26dcbe46e42..52d8459e94c 100644 --- a/moli-renderer-v8/src/page_task_queue/worker_host_bridge.rs +++ b/moli-renderer-v8/src/page_task_queue/worker_host_bridge.rs @@ -51,12 +51,17 @@ impl RendererPageWorkerHostBridgeOwner { } pub(crate) fn is_worker_host_bridge_message(message: &WorkerToParentMessage) -> bool { + #[cfg(test)] + if matches!( + message, + WorkerToParentMessage::PendingSubresourceFetch(_) + | WorkerToParentMessage::SubresourceContinue(_) + ) { + return true; + } matches!( message, WorkerToParentMessage::SubresourceNetwork(_) - | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } - | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) | WorkerToParentMessage::WebSocketFrame(_) @@ -267,10 +272,11 @@ mod tests { sender .send(WorkerRuntimeEvent::Message { worker_id, - message: Box::new(WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id, - error_text: "closed".to_owned(), - }), + message: Box::new(WorkerToParentMessage::SubresourceContinue( + crate::types::PendingSubresourceContinueEvent::Completed { + internal_id: fetch_id, + }, + )), }) .expect("DedicatedWorker host record should send"); } @@ -287,10 +293,7 @@ mod tests { } if queued_worker_id == worker_id && matches!( message.as_ref(), - WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id, - .. - } if *fetch_id == expected_fetch_id + WorkerToParentMessage::SubresourceContinue(crate::types::PendingSubresourceContinueEvent::Completed { internal_id }) if *internal_id == expected_fetch_id ) )); } @@ -311,10 +314,9 @@ mod tests { sender .send(WorkerRuntimeEvent::SharedWorkerMessage { instance_id, - message: Box::new(WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id: 99, - error_text: "blocked".to_owned(), - }), + message: Box::new(WorkerToParentMessage::SubresourceContinue( + crate::types::PendingSubresourceContinueEvent::Completed { internal_id: 99 }, + )), }) .expect("SharedWorker host record should send"); diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime.rs index 74e4bdef79d..68a507585c0 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime.rs @@ -162,6 +162,7 @@ impl RendererProducerRegistrar { #[derive(Clone, Debug)] pub(crate) struct RendererWorkerContextRuntime { debugger_enabled: bool, + shared_worker_pause_on_start: Arc, message_port_registry: crate::message_port_runtime::SharedMessagePortRegistry, broadcast_channel_registry: crate::broadcast_channel_runtime::SharedBroadcastChannelRegistry, storage_partition_identity: RendererStoragePartitionIdentity, @@ -209,6 +210,7 @@ struct RendererBrowserContextRuntimeInner { next_dedicated_worker_instance_id: AtomicU64, dedicated_worker_devtools_targets: Mutex>, dedicated_worker_pause_on_start_for_devtools: AtomicBool, + shared_worker_pause_on_start_for_devtools: Arc, javascript_dialog_handler_enabled: AtomicBool, browser_owns_auxiliary_document_responses: AtomicBool, renderer_output_transport_tx: RendererOutputTransportSenderSlot, @@ -613,6 +615,7 @@ impl RendererBrowserContextRuntime { next_dedicated_worker_instance_id: AtomicU64::default(), dedicated_worker_devtools_targets: Mutex::new(HashMap::new()), dedicated_worker_pause_on_start_for_devtools: AtomicBool::new(false), + shared_worker_pause_on_start_for_devtools: Arc::new(AtomicBool::new(false)), javascript_dialog_handler_enabled: AtomicBool::new(false), browser_owns_auxiliary_document_responses: AtomicBool::new(false), renderer_output_transport_tx, @@ -780,6 +783,10 @@ impl RendererBrowserContextRuntime { pub(crate) fn worker_context_runtime(&self) -> RendererWorkerContextRuntime { RendererWorkerContextRuntime { debugger_enabled: self.inner.debugger_enabled, + shared_worker_pause_on_start: self + .inner + .shared_worker_pause_on_start_for_devtools + .clone(), message_port_registry: self.message_port_registry(), broadcast_channel_registry: self.broadcast_channel_registry(), storage_partition_identity: self.storage_partition_identity(), @@ -1043,6 +1050,7 @@ impl RendererWorkerContextRuntime { ) -> Self { Self { debugger_enabled, + shared_worker_pause_on_start: Arc::new(AtomicBool::new(false)), message_port_registry, broadcast_channel_registry, storage_partition_identity, @@ -1055,6 +1063,9 @@ impl RendererWorkerContextRuntime { self.message_port_registry.clone() } + pub(crate) fn shared_worker_pause_on_start_for_devtools(&self) -> bool { + self.shared_worker_pause_on_start.load(Ordering::Acquire) + } pub(crate) fn debugger_enabled(&self) -> bool { self.debugger_enabled } diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs index f8ae8d0aa6d..afb56e67204 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs @@ -58,6 +58,11 @@ impl RendererBrowserContextRuntime { .remove(&instance_id); } + pub fn set_shared_worker_pause_on_start_for_devtools(&self, pause: bool) { + self.inner + .shared_worker_pause_on_start_for_devtools + .store(pause, std::sync::atomic::Ordering::Release); + } pub fn set_dedicated_worker_pause_on_start_for_devtools(&self, pause: bool) { self.inner .dedicated_worker_pause_on_start_for_devtools diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs index f9ca2640a2a..9b1b1f86c8e 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs @@ -1,10 +1,8 @@ use crate::runtime::WorkerInspectorError; use crate::{ - RendererSyntheticResponseBody, shared_worker_runtime::{ SharedWorkerLaunchParams, SharedWorkerRuntimeOwnerWake, SharedWorkerRuntimeOwnerWakeSender, }, - worker::{WorkerPendingFetchContinue, WorkerPendingXhrContinue}, worker_owner_wake::WorkerOwnerWakeRoutes, }; use anyhow::Result; @@ -209,247 +207,6 @@ impl RendererBrowserContextRuntime { } } - pub(crate) fn continue_shared_worker_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| runtime.continue_pending_fetch(instance_id, request)) - } - - pub(crate) fn continue_shared_worker_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| runtime.continue_pending_xhr(instance_id, request)) - } - - pub(crate) fn continue_shared_worker_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| runtime.continue_pending_csp_report(instance_id, request)) - } - - pub(crate) fn continue_shared_worker_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.continue_pending_fetch_response( - instance_id, - request, - response_code, - response_headers, - ) - }) - } - - pub(crate) fn continue_shared_worker_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.continue_pending_xhr_response( - instance_id, - request, - response_code, - response_headers, - ) - }) - } - - pub(crate) fn fail_shared_worker_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| runtime.fail_pending_fetch(instance_id, request, error_text)) - } - - pub(crate) fn fail_shared_worker_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| runtime.fail_pending_xhr(instance_id, request, error_text)) - } - - pub(crate) fn fail_shared_worker_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fail_pending_csp_report(instance_id, request, error_text) - }) - } - - pub(crate) fn fail_shared_worker_fetch_auth( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fail_pending_fetch_auth(instance_id, request, error_text) - }) - } - - pub(crate) fn fail_shared_worker_xhr_auth( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| runtime.fail_pending_xhr_auth(instance_id, request, error_text)) - } - - pub(crate) fn fail_shared_worker_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fail_pending_fetch_response(instance_id, request, error_text) - }) - } - - pub(crate) fn fail_shared_worker_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fail_pending_xhr_response(instance_id, request, error_text) - }) - } - - pub(crate) fn fulfill_shared_worker_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fulfill_pending_fetch( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - }) - } - - pub(crate) fn fulfill_shared_worker_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fulfill_pending_xhr( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - }) - } - - pub(crate) fn fulfill_shared_worker_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fulfill_pending_csp_report( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - }) - } - - pub(crate) fn fulfill_shared_worker_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fulfill_pending_fetch_response( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - }) - } - - pub(crate) fn fulfill_shared_worker_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.shared_worker_runtime_if_initialized() - .is_some_and(|runtime| { - runtime.fulfill_pending_xhr_response( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - }) - } - pub fn attach_shared_worker_runtime_inspector_session( &self, instance_id: SharedWorkerInstanceId, diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rs index f422ad75ba4..2f082f43227 100644 --- a/moli-renderer-v8/src/runtime/page_surface.rs +++ b/moli-renderer-v8/src/runtime/page_surface.rs @@ -597,6 +597,7 @@ impl RendererPendingWindowOpenEvent { } #[derive(Debug, Clone, PartialEq, Eq)] pub struct RendererSharedWorkerTargetInfo { + pub interception_policy: Option, pub owner_local_host_id: super::RendererOwnerLocalHostId, pub instance_id: SharedWorkerInstanceId, pub url: String, @@ -612,6 +613,10 @@ pub struct RendererSharedWorkerConsoleMessage { #[derive(Debug, Clone, PartialEq)] pub enum RendererSharedWorkerTargetEvent { + Resource { + instance_id: SharedWorkerInstanceId, + event: crate::network::ResourceInterceptionEvent, + }, Created(RendererSharedWorkerTargetInfo), Destroyed { instance_id: SharedWorkerInstanceId, @@ -646,6 +651,10 @@ pub struct RendererDedicatedWorkerTargetInfo { /// complete Page subresource record. #[derive(Debug, Clone)] pub enum RendererDedicatedWorkerTargetEvent { + Resource { + instance_id: u64, + event: crate::network::ResourceInterceptionEvent, + }, Created(RendererDedicatedWorkerTargetInfo), ScriptLoaded { instance_id: u64, @@ -675,6 +684,16 @@ pub enum RendererDedicatedWorkerTargetEvent { impl PartialEq for RendererDedicatedWorkerTargetEvent { fn eq(&self, other: &Self) -> bool { match (self, other) { + ( + Self::Resource { + instance_id: a, + event: ae, + }, + Self::Resource { + instance_id: b, + event: be, + }, + ) => a == b && ae == be, (Self::Created(left), Self::Created(right)) => left == right, ( Self::ScriptLoaded { diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker/worker_messages_and_service_workers.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker/worker_messages_and_service_workers.rs index 84951d9a74f..a30c40b1d00 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/worker/worker_messages_and_service_workers.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker/worker_messages_and_service_workers.rs @@ -66,6 +66,8 @@ async fn dedicated_worker_main_scripts_publish_split_target_lifecycle_records() page_vm.page_id, ), ); + let (output_tx, mut output_rx) = crate::runtime::renderer_output_transport_channel(); + output_journal.bind_transport(output_tx); page_vm .vm_mut() .bind_renderer_output_journal_for_test(output_journal.clone()); @@ -109,12 +111,18 @@ async fn dedicated_worker_main_scripts_publish_split_target_lifecycle_records() page_vm.vm_mut().take_network_output().is_empty(), "DedicatedWorker main scripts are not complete Page subresources" ); - let publication = output_journal - .settle() - .expect("DedicatedWorker target events should settle as Page output"); + output_journal.publish_pending(); + let mut records = Vec::new(); + while let Ok(message) = output_rx.try_recv() { + if let crate::runtime::RendererOutputTransportMessage::Publication( + publication, + ) = message + { + records.extend(publication.into_records()); + } + } anyhow::Ok( - publication - .into_records() + records .into_iter() .filter_map(|record| match record.into_parts().1 { RendererOutputItem::OwnerAction( diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker_host_bridge.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker_host_bridge.rs index fd525803e0a..77d289e2052 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/worker_host_bridge.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker_host_bridge.rs @@ -36,10 +36,7 @@ Promise.resolve().then(() => { .worker_host_bridge_sender_for_test() .send(WorkerRuntimeEvent::SharedWorkerMessage { instance_id: moli_shared_worker::SharedWorkerInstanceId::from_u64(1), - message: Box::new(WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id: 7, - error_text: "canceled".to_owned(), - }), + message: Box::new(worker_host_bridge_network_probe(7)), }) .expect("SharedWorker host record should enter the stable Networking source"); let task = page_vm @@ -109,10 +106,7 @@ Promise.resolve().then(() => { .worker_host_bridge_sender_for_test() .send(WorkerRuntimeEvent::SharedWorkerMessage { instance_id: moli_shared_worker::SharedWorkerInstanceId::from_u64(1), - message: Box::new(WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id: 8, - error_text: "canceled-again".to_owned(), - }), + message: Box::new(worker_host_bridge_network_probe(8)), }) .expect("a second host record should enter the same stable source"); assert!( @@ -152,10 +146,7 @@ Promise.resolve().then(() => { .worker_host_bridge_sender_for_test() .send(WorkerRuntimeEvent::Message { worker_id, - message: Box::new(WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id: 9, - error_text: "dedicated-canceled".to_owned(), - }), + message: Box::new(worker_host_bridge_network_probe(9)), }) .expect("a DedicatedWorker host record should enter the stable source"); assert!( @@ -498,3 +489,16 @@ Promise.resolve().then(() => { }, ); } + +fn worker_host_bridge_network_probe(id: u64) -> WorkerToParentMessage { + WorkerToParentMessage::SubresourceNetwork(crate::types::SubresourceNetworkRecord::failure( + None, + Url::parse("https://worker-host-bridge.test/").unwrap(), + Url::parse(&format!("https://worker-host-bridge.test/probe/{id}")).unwrap(), + "GET".to_owned(), + Default::default(), + None, + crate::types::SubresourceResourceType::Fetch, + "net::ERR_ABORTED".to_owned(), + )) +} diff --git a/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rs b/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rs index 8a0637475f6..9d885b760d1 100644 --- a/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rs +++ b/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rs @@ -410,6 +410,9 @@ fn shared_worker_event_transport_charge_bytes( event: &crate::runtime::RendererSharedWorkerTargetEvent, ) -> usize { match event { + crate::runtime::RendererSharedWorkerTargetEvent::Resource { event, .. } => { + resource_event_transport_charge_bytes(event) + } crate::runtime::RendererSharedWorkerTargetEvent::Created(info) => { string_charge(&info.url).saturating_add(string_charge(&info.name)) } @@ -536,6 +539,9 @@ fn dedicated_worker_event_transport_charge_bytes( event: &crate::runtime::RendererDedicatedWorkerTargetEvent, ) -> usize { match event { + crate::runtime::RendererDedicatedWorkerTargetEvent::Resource { event, .. } => { + resource_event_transport_charge_bytes(event) + } crate::runtime::RendererDedicatedWorkerTargetEvent::Created(info) => [ info.request_url.as_str(), info.document_url.as_str(), @@ -600,3 +606,14 @@ fn navigation_response_transport_charge_bytes( .unwrap_or(0), ) } + +fn resource_event_transport_charge_bytes( + event: &crate::network::ResourceInterceptionEvent, +) -> usize { + use crate::network::ResourceInterceptionEvent as E; + match event { + E::Request { info, .. } => info.renderer_transport_charge_bytes(), + E::Continue { event, .. } => event.renderer_transport_charge_bytes(), + E::Network(item) => item.renderer_transport_charge_bytes(), + } +} diff --git a/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs b/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs index a96b9daadcd..84945c21b4d 100644 --- a/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs +++ b/moli-renderer-v8/src/runtime/protocol_output/turn_journal.rs @@ -355,11 +355,19 @@ impl RendererTurnOutputJournal { /// have no enclosing Page turn, so this operation is their atomic /// append/settle/admit boundary. pub(crate) fn publish_record(&self, record: RendererOutputRecord) { - let mut state = self.state.lock(); assert!( - !state.closed, + self.try_publish_record(record), "renderer output cannot be published after stream closure" ); + } + + /// Asynchronous resource completion can race retirement of its observer. + /// The same stream lock admits the record or observes terminal retirement. + pub(crate) fn try_publish_record(&self, record: RendererOutputRecord) -> bool { + let mut state = self.state.lock(); + if state.closed { + return false; + } let cursor = Self::reserve_cursor_locked(&mut state); let publication = RendererOutputPublication::new(cursor, vec![record]); if let Some(transport) = state.transport.as_ref() { @@ -372,6 +380,7 @@ impl RendererTurnOutputJournal { // browser context binds its protocol transport. state.deferred_publications.push(publication); } + true } /// Binds the browser-context protocol transport to a stream that may have diff --git a/moli-renderer-v8/src/script_vm/dedicated_worker_client_event_body.rs b/moli-renderer-v8/src/script_vm/dedicated_worker_client_event_body.rs index 81819c10957..fd5c9644015 100644 --- a/moli-renderer-v8/src/script_vm/dedicated_worker_client_event_body.rs +++ b/moli-renderer-v8/src/script_vm/dedicated_worker_client_event_body.rs @@ -72,21 +72,11 @@ impl ScriptVm { content_security_report_only_policies, content_security_reporting_endpoints, } => { - let recorded = self - ._context_host - .borrow_mut() - .record_dedicated_worker_target_script_loaded( - worker_id, - script_url.clone(), - network_response, - ); - if !recorded { - return Ok(DedicatedWorkerClientEventBodyEffect::CurrentTargetDisappeared); - } let handled = self._context_host.borrow_mut().finish_loading_worker( worker_id, script_url, script_source, + Some(network_response), script_kind, secure_context, response_referrer_policy, diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch.rs index 8b8e6229525..7fc40039c6a 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch.rs @@ -1,5 +1,4 @@ use anyhow::{Result, anyhow, bail}; -use moli_shared_worker::SharedWorkerInstanceId; use std::cell::RefCell; use std::pin::pin; use std::rc::Rc; @@ -31,92 +30,16 @@ use crate::types::{ AsyncSubresourceFetchResponseFilter, AsyncSubresourceFetchResult, ChildBlockingStylesheetLoadCompletion, ChildClassicScriptLoadCompletion, ChildDocumentLoadCompletion, ChildModuleDependencyFetchCompletion, - ChildModulepreloadFetchCompletion, ChildParserModuleRootFetchCompletion, DedicatedWorkerId, - NetworkBodySourceId, PendingSubresourceAuthInfo, PendingSubresourceAuthState, - PendingSubresourceContinuation, PendingSubresourceContinueEvent, - PendingSubresourceContinueOutcome, PendingSubresourceFetchInfo, PendingSubresourceFetchState, - PendingSubresourceResponseInfo, PendingSubresourceResponseState, - PopupClassicScriptLoadCompletion, PopupDocumentLoadCompletion, RunningSubresourceFetchState, - StreamingSubresourceFetchState, SubresourceNetworkRecord, SubresourceNetworkRequestHandle, + ChildModulepreloadFetchCompletion, ChildParserModuleRootFetchCompletion, NetworkBodySourceId, + PendingSubresourceAuthInfo, PendingSubresourceAuthState, PendingSubresourceContinuation, + PendingSubresourceContinueEvent, PendingSubresourceContinueOutcome, + PendingSubresourceFetchInfo, PendingSubresourceFetchState, PendingSubresourceResponseInfo, + PendingSubresourceResponseState, PopupClassicScriptLoadCompletion, PopupDocumentLoadCompletion, + RunningSubresourceFetchState, StreamingSubresourceFetchState, SubresourceNetworkRequestHandle, SubresourceRequestInitiatorType, SubresourceResourceType, SubresourceResponseBody, }; use crate::util::v8_string; -#[derive(Clone, Copy)] -enum WorkerOwnedFetchTarget { - Dedicated { - worker_id: DedicatedWorkerId, - fetch_id: u32, - }, - Shared { - instance_id: SharedWorkerInstanceId, - fetch_id: u32, - }, -} - -impl WorkerOwnedFetchTarget { - fn from_continuation(continuation: &PendingSubresourceContinuation) -> Option { - match continuation { - PendingSubresourceContinuation::WorkerFetch { - worker_id, - fetch_id, - } => Some(Self::Dedicated { - worker_id: *worker_id, - fetch_id: *fetch_id, - }), - PendingSubresourceContinuation::SharedWorkerFetch { - instance_id, - fetch_id, - } => Some(Self::Shared { - instance_id: *instance_id, - fetch_id: *fetch_id, - }), - _ => None, - } - } - - fn fetch_id(self) -> u32 { - match self { - Self::Dedicated { fetch_id, .. } | Self::Shared { fetch_id, .. } => fetch_id, - } - } - - fn continuation(self) -> PendingSubresourceContinuation { - match self { - Self::Dedicated { - worker_id, - fetch_id, - } => PendingSubresourceContinuation::WorkerFetch { - worker_id, - fetch_id, - }, - Self::Shared { - instance_id, - fetch_id, - } => PendingSubresourceContinuation::SharedWorkerFetch { - instance_id, - fetch_id, - }, - } - } - - fn unavailable_message(self) -> String { - match self { - Self::Dedicated { - worker_id, - fetch_id, - } => format!("worker `{worker_id}` is not available for pending fetch `{fetch_id}`"), - Self::Shared { - instance_id, - fetch_id, - } => format!( - "shared worker `{}` is not available for pending fetch `{fetch_id}`", - instance_id.as_u64() - ), - } - } -} - fn document_connect_csp_redirect_failure_message<'s>( scope: &mut v8::PinScope<'s, '_>, context_host: &Rc>, @@ -536,145 +459,6 @@ fn window_subresource_realm_is_current( && binding.is_current(&context_host.borrow()) } -#[derive(Clone, Copy)] -enum WorkerOwnedXhrTarget { - Dedicated { - worker_id: DedicatedWorkerId, - xhr_id: u32, - }, - Shared { - instance_id: SharedWorkerInstanceId, - xhr_id: u32, - }, -} - -impl WorkerOwnedXhrTarget { - fn from_continuation(continuation: &PendingSubresourceContinuation) -> Option { - match continuation { - PendingSubresourceContinuation::WorkerXhr { worker_id, xhr_id } => { - Some(Self::Dedicated { - worker_id: *worker_id, - xhr_id: *xhr_id, - }) - } - PendingSubresourceContinuation::SharedWorkerXhr { - instance_id, - xhr_id, - } => Some(Self::Shared { - instance_id: *instance_id, - xhr_id: *xhr_id, - }), - _ => None, - } - } - - fn xhr_id(self) -> u32 { - match self { - Self::Dedicated { xhr_id, .. } | Self::Shared { xhr_id, .. } => xhr_id, - } - } - - fn continuation(self) -> PendingSubresourceContinuation { - match self { - Self::Dedicated { worker_id, xhr_id } => { - PendingSubresourceContinuation::WorkerXhr { worker_id, xhr_id } - } - Self::Shared { - instance_id, - xhr_id, - } => PendingSubresourceContinuation::SharedWorkerXhr { - instance_id, - xhr_id, - }, - } - } - - fn unavailable_message(self) -> String { - match self { - Self::Dedicated { worker_id, xhr_id } => { - format!("worker `{worker_id}` is not available for pending xhr `{xhr_id}`") - } - Self::Shared { - instance_id, - xhr_id, - } => format!( - "shared worker `{}` is not available for pending xhr `{xhr_id}`", - instance_id.as_u64() - ), - } - } -} - -#[derive(Clone, Copy)] -enum WorkerOwnedCspReportTarget { - Dedicated { - worker_id: DedicatedWorkerId, - report_id: u32, - }, - Shared { - instance_id: SharedWorkerInstanceId, - report_id: u32, - }, -} - -impl WorkerOwnedCspReportTarget { - fn from_continuation(continuation: &PendingSubresourceContinuation) -> Option { - match continuation { - PendingSubresourceContinuation::WorkerCspReport { - worker_id, - report_id, - } => Some(Self::Dedicated { - worker_id: *worker_id, - report_id: *report_id, - }), - PendingSubresourceContinuation::SharedWorkerCspReport { - instance_id, - report_id, - } => Some(Self::Shared { - instance_id: *instance_id, - report_id: *report_id, - }), - _ => None, - } - } - - fn report_id(self) -> u32 { - match self { - Self::Dedicated { report_id, .. } | Self::Shared { report_id, .. } => report_id, - } - } - - fn unavailable_message(self) -> String { - match self { - Self::Dedicated { - worker_id, - report_id, - } => format!( - "worker `{worker_id}` is not available for pending CSP report `{report_id}`" - ), - Self::Shared { - instance_id, - report_id, - } => format!( - "shared worker `{}` is not available for pending CSP report `{report_id}`", - instance_id.as_u64() - ), - } - } -} - -fn with_pending_subresource_record_identity( - record: SubresourceNetworkRecord, - request_body_bytes: Option, - request_handle: Option, -) -> SubresourceNetworkRecord { - let mut record = record.with_request_body_bytes(request_body_bytes); - if let Some(handle) = request_handle { - record = record.with_request_handle(handle); - } - record -} - impl ScriptVm {} #[derive(Clone, Copy, Default)] @@ -781,12 +565,6 @@ fn pending_subresource_continuation_kind( PendingSubresourceContinuation::Xhr { .. } => "xhr", PendingSubresourceContinuation::WebSocket(_) => "websocket", PendingSubresourceContinuation::ChildDocument(_) => "child_document", - PendingSubresourceContinuation::WorkerFetch { .. } => "worker_fetch", - PendingSubresourceContinuation::WorkerXhr { .. } => "worker_xhr", - PendingSubresourceContinuation::WorkerCspReport { .. } => "worker_csp_report", - PendingSubresourceContinuation::SharedWorkerFetch { .. } => "shared_worker_fetch", - PendingSubresourceContinuation::SharedWorkerXhr { .. } => "shared_worker_xhr", - PendingSubresourceContinuation::SharedWorkerCspReport { .. } => "shared_worker_csp_report", } } diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs index b236d6b5ab8..12590862c48 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs @@ -924,13 +924,7 @@ impl ScriptVm { | PendingSubresourceContinuation::CspReport { .. } | PendingSubresourceContinuation::EventSource(_) | PendingSubresourceContinuation::WebSocket(_) - | PendingSubresourceContinuation::ChildDocument(_) - | PendingSubresourceContinuation::WorkerFetch { .. } - | PendingSubresourceContinuation::WorkerXhr { .. } - | PendingSubresourceContinuation::WorkerCspReport { .. } - | PendingSubresourceContinuation::SharedWorkerFetch { .. } - | PendingSubresourceContinuation::SharedWorkerXhr { .. } - | PendingSubresourceContinuation::SharedWorkerCspReport { .. } => {} + | PendingSubresourceContinuation::ChildDocument(_) => {} } trace_async_subresource_stage( "async_subresource_continuation_delivered", @@ -1056,13 +1050,7 @@ impl ScriptVm { | PendingSubresourceContinuation::CspReport { .. } | PendingSubresourceContinuation::EventSource(_) | PendingSubresourceContinuation::WebSocket(_) - | PendingSubresourceContinuation::ChildDocument(_) - | PendingSubresourceContinuation::WorkerFetch { .. } - | PendingSubresourceContinuation::WorkerXhr { .. } - | PendingSubresourceContinuation::WorkerCspReport { .. } - | PendingSubresourceContinuation::SharedWorkerFetch { .. } - | PendingSubresourceContinuation::SharedWorkerXhr { .. } - | PendingSubresourceContinuation::SharedWorkerCspReport { .. } => {} + | PendingSubresourceContinuation::ChildDocument(_) => {} } trace_async_subresource_stage( "async_subresource_continuation_delivered", diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_fetch.rs index 59aab34331e..c082075f298 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_fetch.rs @@ -70,371 +70,4 @@ impl ScriptVm { ); load } - pub(super) fn continue_worker_owned_fetch( - &self, - target: WorkerOwnedFetchTarget, - request: crate::worker::WorkerPendingFetchContinue, - ) -> bool { - match target { - WorkerOwnedFetchTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .continue_worker_fetch(worker_id, request), - WorkerOwnedFetchTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .continue_shared_worker_fetch(instance_id, request), - } - } - pub(super) fn continue_worker_owned_xhr( - &self, - target: WorkerOwnedXhrTarget, - request: crate::worker::WorkerPendingXhrContinue, - ) -> bool { - match target { - WorkerOwnedXhrTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .continue_worker_xhr(worker_id, request), - WorkerOwnedXhrTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .continue_shared_worker_xhr(instance_id, request), - } - } - pub(super) fn continue_worker_owned_csp_report( - &self, - target: WorkerOwnedCspReportTarget, - request: crate::worker::WorkerPendingFetchContinue, - ) -> bool { - match target { - WorkerOwnedCspReportTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .continue_worker_csp_report(worker_id, request), - WorkerOwnedCspReportTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .continue_shared_worker_csp_report(instance_id, request), - } - } - pub(super) fn fail_worker_owned_fetch( - &self, - target: WorkerOwnedFetchTarget, - request: crate::worker::WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - match target { - WorkerOwnedFetchTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fail_worker_fetch(worker_id, request, error_text), - WorkerOwnedFetchTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fail_shared_worker_fetch(instance_id, request, error_text), - } - } - pub(super) fn fail_worker_owned_xhr( - &self, - target: WorkerOwnedXhrTarget, - request: crate::worker::WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - match target { - WorkerOwnedXhrTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fail_worker_xhr(worker_id, request, error_text), - WorkerOwnedXhrTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fail_shared_worker_xhr(instance_id, request, error_text), - } - } - pub(super) fn fail_worker_owned_csp_report( - &self, - target: WorkerOwnedCspReportTarget, - request: crate::worker::WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - match target { - WorkerOwnedCspReportTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fail_worker_csp_report(worker_id, request, error_text), - WorkerOwnedCspReportTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fail_shared_worker_csp_report(instance_id, request, error_text), - } - } - pub(super) fn fail_worker_owned_fetch_auth( - &self, - target: WorkerOwnedFetchTarget, - request: crate::worker::WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - match target { - WorkerOwnedFetchTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fail_worker_fetch_auth(worker_id, request, error_text), - WorkerOwnedFetchTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fail_shared_worker_fetch_auth(instance_id, request, error_text), - } - } - pub(super) fn fail_worker_owned_xhr_auth( - &self, - target: WorkerOwnedXhrTarget, - request: crate::worker::WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - match target { - WorkerOwnedXhrTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fail_worker_xhr_auth(worker_id, request, error_text), - WorkerOwnedXhrTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fail_shared_worker_xhr_auth(instance_id, request, error_text), - } - } - pub(super) fn continue_worker_owned_fetch_response( - &self, - target: WorkerOwnedFetchTarget, - request: crate::worker::WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - match target { - WorkerOwnedFetchTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .continue_worker_fetch_response( - worker_id, - request, - response_code, - response_headers, - ), - WorkerOwnedFetchTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .continue_shared_worker_fetch_response( - instance_id, - request, - response_code, - response_headers, - ), - } - } - pub(super) fn continue_worker_owned_xhr_response( - &self, - target: WorkerOwnedXhrTarget, - request: crate::worker::WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - match target { - WorkerOwnedXhrTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .continue_worker_xhr_response(worker_id, request, response_code, response_headers), - WorkerOwnedXhrTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .continue_shared_worker_xhr_response( - instance_id, - request, - response_code, - response_headers, - ), - } - } - pub(super) fn fail_worker_owned_fetch_response( - &self, - target: WorkerOwnedFetchTarget, - request: crate::worker::WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - match target { - WorkerOwnedFetchTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fail_worker_fetch_response(worker_id, request, error_text), - WorkerOwnedFetchTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fail_shared_worker_fetch_response(instance_id, request, error_text), - } - } - pub(super) fn fail_worker_owned_xhr_response( - &self, - target: WorkerOwnedXhrTarget, - request: crate::worker::WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - match target { - WorkerOwnedXhrTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fail_worker_xhr_response(worker_id, request, error_text), - WorkerOwnedXhrTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fail_shared_worker_xhr_response(instance_id, request, error_text), - } - } - pub(super) fn fulfill_worker_owned_fetch( - &self, - target: WorkerOwnedFetchTarget, - request: crate::worker::WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - match target { - WorkerOwnedFetchTarget::Dedicated { worker_id, .. } => { - self._context_host.borrow_mut().fulfill_worker_fetch( - worker_id, - request, - response_code, - response_headers, - response_body, - ) - } - WorkerOwnedFetchTarget::Shared { instance_id, .. } => { - self._context_host.borrow_mut().fulfill_shared_worker_fetch( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - } - } - } - pub(super) fn fulfill_worker_owned_xhr( - &self, - target: WorkerOwnedXhrTarget, - request: crate::worker::WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - match target { - WorkerOwnedXhrTarget::Dedicated { worker_id, .. } => { - self._context_host.borrow_mut().fulfill_worker_xhr( - worker_id, - request, - response_code, - response_headers, - response_body, - ) - } - WorkerOwnedXhrTarget::Shared { instance_id, .. } => { - self._context_host.borrow_mut().fulfill_shared_worker_xhr( - instance_id, - request, - response_code, - response_headers, - response_body, - ) - } - } - } - pub(super) fn fulfill_worker_owned_csp_report( - &self, - target: WorkerOwnedCspReportTarget, - request: crate::worker::WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - match target { - WorkerOwnedCspReportTarget::Dedicated { worker_id, .. } => { - self._context_host.borrow_mut().fulfill_worker_csp_report( - worker_id, - request, - response_code, - response_headers, - response_body, - ) - } - WorkerOwnedCspReportTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fulfill_shared_worker_csp_report( - instance_id, - request, - response_code, - response_headers, - response_body, - ), - } - } - pub(super) fn fulfill_worker_owned_fetch_response( - &self, - target: WorkerOwnedFetchTarget, - request: crate::worker::WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - match target { - WorkerOwnedFetchTarget::Dedicated { worker_id, .. } => self - ._context_host - .borrow_mut() - .fulfill_worker_fetch_response( - worker_id, - request, - response_code, - response_headers, - response_body, - ), - WorkerOwnedFetchTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fulfill_shared_worker_fetch_response( - instance_id, - request, - response_code, - response_headers, - response_body, - ), - } - } - pub(super) fn fulfill_worker_owned_xhr_response( - &self, - target: WorkerOwnedXhrTarget, - request: crate::worker::WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - match target { - WorkerOwnedXhrTarget::Dedicated { worker_id, .. } => { - self._context_host.borrow_mut().fulfill_worker_xhr_response( - worker_id, - request, - response_code, - response_headers, - response_body, - ) - } - WorkerOwnedXhrTarget::Shared { instance_id, .. } => self - ._context_host - .borrow_mut() - .fulfill_shared_worker_xhr_response( - instance_id, - request, - response_code, - response_headers, - response_body, - ), - } - } } diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_redirects.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_redirects.rs index 4775b67ec90..c45169bb280 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_redirects.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/intercepted_redirects.rs @@ -16,7 +16,12 @@ pub(super) fn follow_intercepted_redirect( // A fulfilled network response has the same CORS gate as a real hop. // Preserve that failure before rejecting an error-mode redirect. request.validate_cors_response_for_url(&head.final_url, &head.headers)?; - if request.redirect_mode() == RequestRedirectMode::Error { + if request.redirect_mode() == RequestRedirectMode::Error + && head + .headers + .iter() + .any(|(name, _)| name.eq_ignore_ascii_case("location")) + { return Err("fetch: redirect mode is error".to_owned()); } } diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs index fadcc0e54f1..a4ee0156eb8 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs @@ -211,151 +211,7 @@ impl ScriptVm { PendingSubresourceContinueOutcome::Started, )); } - continuation @ (PendingSubresourceContinuation::WorkerFetch { .. } - | PendingSubresourceContinuation::SharedWorkerFetch { .. }) => { - let target = WorkerOwnedFetchTarget::from_continuation(&continuation) - .expect("fetch continuation target"); - let fetch_id = target.fetch_id(); - let request_url = info.url.clone(); - let request_method = info.method.clone(); - let request_body = info.request_body.clone(); - let request_headers = info.request_headers.clone(); - let continued = self.continue_worker_owned_fetch( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: redirect_headers.clone(), - fetch_id, - internal_id, - network_request_handle: info.network_request_handle, - url: request_url.clone(), - method: request_method.clone(), - body: info.request_body_bytes.clone(), - headers: request_headers.clone(), - intercept_response, - handle_auth_requests, - auth: None, - }, - ); - if !continued { - bail!(target.unavailable_message()); - } - self._context_host - .borrow_mut() - .record_in_flight_worker_subresource_fetch( - crate::types::InFlightWorkerSubresourceFetchState { - pending: PendingSubresourceFetchState { - dispatch, - redirect_headers, - request_origin, - info, - load, - execution_context, - credentials_mode, - request_mode, - network_partition_key, - policy_context, - continuation: target.continuation(), - deferred_request_started, - }, - request_url, - request_method, - request_headers, - request_body, - }, - ); - return Ok(AsyncSubresourceCommandExecution::without_window_realm( - PendingSubresourceContinueOutcome::Started, - )); - } - continuation @ (PendingSubresourceContinuation::WorkerXhr { .. } - | PendingSubresourceContinuation::SharedWorkerXhr { .. }) => { - let target = WorkerOwnedXhrTarget::from_continuation(&continuation) - .expect("xhr continuation target"); - let xhr_id = target.xhr_id(); - let request_url = info.url.clone(); - let request_method = info.method.clone(); - let request_body = info.request_body.clone(); - let request_headers = info.request_headers.clone(); - let continued = self.continue_worker_owned_xhr( - target, - crate::worker::WorkerPendingXhrContinue { - redirect_headers: redirect_headers.clone(), - xhr_id, - internal_id, - network_request_handle: info.network_request_handle, - url: request_url.clone(), - method: request_method.clone(), - body: info.request_body_bytes.clone(), - headers: request_headers.clone(), - intercept_response, - handle_auth_requests, - auth: None, - }, - ); - if !continued { - bail!(target.unavailable_message()); - } - if intercept_response || handle_auth_requests { - self._context_host - .borrow_mut() - .record_in_flight_worker_subresource_fetch( - crate::types::InFlightWorkerSubresourceFetchState { - pending: PendingSubresourceFetchState { - dispatch, - redirect_headers: redirect_headers.clone(), - request_origin, - info, - load, - execution_context, - credentials_mode, - request_mode, - network_partition_key: network_partition_key.clone(), - policy_context, - continuation: target.continuation(), - deferred_request_started, - }, - request_url, - request_method, - request_headers, - request_body, - }, - ); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm( - PendingSubresourceContinueOutcome::Started, - )); - } - continuation @ (PendingSubresourceContinuation::WorkerCspReport { .. } - | PendingSubresourceContinuation::SharedWorkerCspReport { .. }) => { - let target = WorkerOwnedCspReportTarget::from_continuation(&continuation) - .expect("CSP report continuation target"); - let report_id = target.report_id(); - let request_url = info.url.clone(); - let request_method = info.method.clone(); - let request_headers = info.request_headers.clone(); - let continued = self.continue_worker_owned_csp_report( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: redirect_headers.clone(), - fetch_id: report_id, - internal_id, - network_request_handle: info.network_request_handle, - url: request_url, - method: request_method, - body: info.request_body_bytes.clone(), - headers: request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - ); - if !continued { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm( - PendingSubresourceContinueOutcome::Started, - )); - } + PendingSubresourceContinuation::CspReport { client_id } => { let request_url = info.url.clone(); let request_method = info.method.clone(); @@ -742,83 +598,7 @@ impl ScriptVm { )); } // A redirect may have discarded the upload before the auth challenge. - if let Some(target) = WorkerOwnedFetchTarget::from_continuation(&pending_fetch.continuation) - { - let request_headers = original_request_headers; - let continued = self.continue_worker_owned_fetch( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: pending_fetch.redirect_headers.clone(), - fetch_id: target.fetch_id(), - internal_id, - network_request_handle: pending_fetch.info.network_request_handle, - url: request_url.clone(), - method: request_method.clone(), - body: request_body - .as_ref() - .and_then(|_| pending_fetch.info.request_body_bytes.clone()), - headers: request_headers.clone(), - intercept_response, - handle_auth_requests: true, - auth: Some(auth), - }, - ); - if !continued { - bail!(target.unavailable_message()); - } - self._context_host - .borrow_mut() - .record_in_flight_worker_subresource_fetch( - crate::types::InFlightWorkerSubresourceFetchState { - pending: pending_fetch, - request_url, - request_method, - request_headers, - request_body, - }, - ); - return Ok(AsyncSubresourceCommandExecution::without_window_realm( - PendingSubresourceContinueOutcome::Started, - )); - } - if let Some(target) = WorkerOwnedXhrTarget::from_continuation(&pending_fetch.continuation) { - let request_headers = original_request_headers; - let continued = self.continue_worker_owned_xhr( - target, - crate::worker::WorkerPendingXhrContinue { - redirect_headers: pending_fetch.redirect_headers.clone(), - xhr_id: target.xhr_id(), - internal_id, - network_request_handle: pending_fetch.info.network_request_handle, - url: request_url.clone(), - method: request_method.clone(), - body: request_body - .as_ref() - .and_then(|_| pending_fetch.info.request_body_bytes.clone()), - headers: request_headers.clone(), - intercept_response, - handle_auth_requests: true, - auth: Some(auth), - }, - ); - if !continued { - bail!(target.unavailable_message()); - } - self._context_host - .borrow_mut() - .record_in_flight_worker_subresource_fetch( - crate::types::InFlightWorkerSubresourceFetchState { - pending: pending_fetch, - request_url, - request_method, - request_headers, - request_body, - }, - ); - return Ok(AsyncSubresourceCommandExecution::without_window_realm( - PendingSubresourceContinueOutcome::Started, - )); - } + let loader = pending_fetch.load.request_client(); let mut request = request_for_pending_subresource( &pending_fetch, @@ -896,73 +676,7 @@ impl ScriptVm { .borrow_mut() .take_pending_subresource_auth(internal_id) .ok_or_else(|| anyhow!("unknown pending subresource auth `{internal_id}`"))?; - if let Some(target) = - WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) - { - let result = Err(error_text.clone()); - self.record_subresource_fetch_network_result( - &pending.pending, - &pending.request_url, - &pending.request_method, - &pending.request_headers, - &pending.request_body, - &result, - ); - let failed = self.fail_worker_owned_fetch_auth( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.fetch_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - error_text, - ); - if !failed { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - if let Some(target) = WorkerOwnedXhrTarget::from_continuation(&pending.pending.continuation) - { - let result = Err(error_text.clone()); - self.record_subresource_fetch_network_result( - &pending.pending, - &pending.request_url, - &pending.request_method, - &pending.request_headers, - &pending.request_body, - &result, - ); - let failed = self.fail_worker_owned_xhr_auth( - target, - crate::worker::WorkerPendingXhrContinue { - redirect_headers: None, - xhr_id: target.xhr_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - error_text, - ); - if !failed { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } + let activity = self.resolve_pending_subresource_fetch_body( pending.pending, pending.request_url, @@ -1086,141 +800,7 @@ impl ScriptVm { .map_err(|error| anyhow!(error))?; return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); } - continuation @ (PendingSubresourceContinuation::WorkerFetch { .. } - | PendingSubresourceContinuation::SharedWorkerFetch { .. }) => { - let target = WorkerOwnedFetchTarget::from_continuation(&continuation) - .expect("fetch continuation target"); - let failed = self.fail_worker_owned_fetch( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.fetch_id(), - internal_id: 0, - network_request_handle: info.network_request_handle, - url: info.url.clone(), - method: info.method.clone(), - body: info.request_body_bytes.clone(), - headers: info.request_headers.clone(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - error_text.clone(), - ); - if !failed { - bail!(target.unavailable_message()); - } - let request_body_bytes = info.request_body_bytes.clone(); - let request_handle = info.network_request_handle; - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::failure( - info.frame_id, - info.document_url, - info.url, - info.method, - info.request_headers, - info.request_body, - info.resource_type, - error_text, - ), - request_body_bytes, - request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - continuation @ (PendingSubresourceContinuation::WorkerXhr { .. } - | PendingSubresourceContinuation::SharedWorkerXhr { .. }) => { - let target = WorkerOwnedXhrTarget::from_continuation(&continuation) - .expect("xhr continuation target"); - let failed = self.fail_worker_owned_xhr( - target, - crate::worker::WorkerPendingXhrContinue { - redirect_headers: None, - xhr_id: target.xhr_id(), - internal_id: 0, - network_request_handle: info.network_request_handle, - url: info.url.clone(), - method: info.method.clone(), - body: info.request_body_bytes.clone(), - headers: info.request_headers.clone(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - error_text.clone(), - ); - if !failed { - bail!(target.unavailable_message()); - } - let request_body_bytes = info.request_body_bytes.clone(); - let request_handle = info.network_request_handle; - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::failure( - info.frame_id, - info.document_url, - info.url, - info.method, - info.request_headers, - info.request_body, - info.resource_type, - error_text, - ), - request_body_bytes, - request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - continuation @ (PendingSubresourceContinuation::WorkerCspReport { .. } - | PendingSubresourceContinuation::SharedWorkerCspReport { .. }) => { - let target = WorkerOwnedCspReportTarget::from_continuation(&continuation) - .expect("CSP report continuation target"); - let failed = self.fail_worker_owned_csp_report( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.report_id(), - internal_id: 0, - network_request_handle: info.network_request_handle, - url: info.url.clone(), - method: info.method.clone(), - body: info.request_body_bytes.clone(), - headers: info.request_headers.clone(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - error_text.clone(), - ); - if !failed { - bail!(target.unavailable_message()); - } - let request_body_bytes = info.request_body_bytes.clone(); - let request_handle = info.network_request_handle; - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::failure( - info.frame_id, - info.document_url, - info.url, - info.method, - info.request_headers, - info.request_body, - info.resource_type, - error_text, - ), - request_body_bytes, - request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } + continuation => PendingSubresourceFetchState { dispatch, redirect_headers: None, @@ -1276,44 +856,7 @@ impl ScriptVm { response_body, ); } - if let Some(target) = WorkerOwnedFetchTarget::from_continuation(&pending.continuation) { - let in_flight = crate::types::InFlightWorkerSubresourceFetchState { - request_url: pending.info.url.clone(), - request_method: pending.info.method.clone(), - request_headers: pending.info.request_headers.clone(), - request_body: pending.info.request_body.clone(), - pending, - }; - let info = &in_flight.pending.info; - let fulfilled = self.fulfill_worker_owned_fetch( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.fetch_id(), - internal_id, - network_request_handle: info.network_request_handle, - url: info.url.clone(), - method: info.method.clone(), - body: info.request_body_bytes.clone(), - headers: info.request_headers.clone(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - response_code, - response_headers, - response_body, - ); - if !fulfilled { - bail!(target.unavailable_message()); - } - // Retain the original identity until the Worker reports its result. - // It may abort before consuming the queued fulfillment command. - self._context_host - .borrow_mut() - .record_in_flight_worker_subresource_fetch(in_flight); - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } + let PendingSubresourceFetchState { dispatch, redirect_headers: _, @@ -1383,170 +926,7 @@ impl ScriptVm { let _ = response_body; return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); } - continuation @ (PendingSubresourceContinuation::WorkerXhr { .. } - | PendingSubresourceContinuation::SharedWorkerXhr { .. }) => { - let target = WorkerOwnedXhrTarget::from_continuation(&continuation) - .expect("xhr continuation target"); - let request_url = info.url.clone(); - let request_method = info.method.clone(); - let request_headers = info.request_headers.clone(); - let request_body = info.request_body.clone(); - let validation = crate::network_host::validate_cors_response_chain( - &info.document_url, - &head, - credentials_mode, - ); - match validation { - Ok(()) => { - let fulfilled = self.fulfill_worker_owned_xhr( - target, - crate::worker::WorkerPendingXhrContinue { - redirect_headers: None, - xhr_id: target.xhr_id(), - internal_id: 0, - network_request_handle: info.network_request_handle, - url: request_url.clone(), - method: request_method.clone(), - body: info.request_body_bytes.clone(), - headers: request_headers.clone(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - response_code, - response_headers.clone(), - response_body.clone(), - ); - if !fulfilled { - bail!(target.unavailable_message()); - } - let request_body_bytes = info.request_body_bytes.clone(); - let request_handle = info.network_request_handle; - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::success_with_body( - info.frame_id, - info.document_url, - request_url, - request_method, - request_headers, - request_body, - info.resource_type, - info.request_cookie_report, - Vec::new(), - info.url, - response_code, - response_headers, - response_body.into_subresource_response_body(), - Vec::new(), - ), - request_body_bytes, - request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - } - Err(message) => { - let failed = self.fail_worker_owned_xhr( - target, - crate::worker::WorkerPendingXhrContinue { - redirect_headers: None, - xhr_id: target.xhr_id(), - internal_id: 0, - network_request_handle: info.network_request_handle, - url: request_url.clone(), - method: request_method.clone(), - body: info.request_body_bytes.clone(), - headers: request_headers.clone(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - message.clone(), - ); - if !failed { - bail!(target.unavailable_message()); - } - let request_body_bytes = info.request_body_bytes.clone(); - let request_handle = info.network_request_handle; - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::failure( - info.frame_id, - info.document_url, - request_url, - request_method, - request_headers, - request_body, - info.resource_type, - message, - ), - request_body_bytes, - request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - } - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - continuation @ (PendingSubresourceContinuation::WorkerCspReport { .. } - | PendingSubresourceContinuation::SharedWorkerCspReport { .. }) => { - let target = WorkerOwnedCspReportTarget::from_continuation(&continuation) - .expect("CSP report continuation target"); - let request_url = info.url.clone(); - let request_method = info.method.clone(); - let request_headers = info.request_headers.clone(); - let request_body = info.request_body.clone(); - let fulfilled = self.fulfill_worker_owned_csp_report( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.report_id(), - internal_id: 0, - network_request_handle: info.network_request_handle, - url: request_url.clone(), - method: request_method.clone(), - body: info.request_body_bytes.clone(), - headers: request_headers.clone(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - response_code, - response_headers.clone(), - response_body.clone(), - ); - if !fulfilled { - bail!(target.unavailable_message()); - } - let request_body_bytes = info.request_body_bytes.clone(); - let request_handle = info.network_request_handle; - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::success_with_body( - info.frame_id, - info.document_url, - request_url, - request_method, - request_headers, - request_body, - info.resource_type, - info.request_cookie_report, - Vec::new(), - info.url, - response_code, - response_headers, - response_body.into_subresource_response_body(), - Vec::new(), - ), - request_body_bytes, - request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } + continuation => PendingSubresourceFetchState { dispatch, redirect_headers: None, @@ -1577,79 +957,7 @@ impl ScriptVm { )?; Ok(AsyncSubresourceCommandExecution::after_body((), activity)) } - pub(in crate::script_vm) fn record_subresource_fetch_network_result( - &mut self, - pending: &PendingSubresourceFetchState, - request_url: &Url, - request_method: &str, - request_headers: &moli_fetch::RequestHeaders, - request_body: &Option, - result: &std::result::Result, - ) { - match result { - Ok(response) => { - let request_cookie_report = response - .request_cookie_report - .clone() - .or_else(|| pending.info.request_cookie_report.clone()); - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::success_with_body( - pending.info.frame_id.clone(), - pending.info.document_url.clone(), - request_url.clone(), - request_method.to_owned(), - request_headers.clone(), - request_body.clone(), - pending.info.resource_type, - request_cookie_report, - response.redirect_chain.clone().into_iter().collect(), - response.final_url.clone(), - response.status, - response.headers.clone(), - SubresourceResponseBody::from_navigation_response(response), - response.cookie_set_reports.clone(), - ) - .with_from_cache(response.from_cache) - .with_negotiated_http_version(response.negotiated_http_version) - .with_network_request_headers( - response - .network_request_headers() - .map(|headers| headers.to_vec()), - ), - pending.info.request_body_bytes.clone(), - pending.info.network_request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - } - Err(error_text) => { - let network_error_text = - if crate::network_host::is_cors_policy_failure_message(error_text) { - crate::network_host::FAILED_ERROR_TEXT.to_owned() - } else { - error_text.clone() - }; - let network_record = with_pending_subresource_record_identity( - crate::types::SubresourceNetworkRecord::failure( - pending.info.frame_id.clone(), - pending.info.document_url.clone(), - request_url.clone(), - request_method.to_owned(), - request_headers.clone(), - request_body.clone(), - pending.info.resource_type, - network_error_text, - ), - pending.info.request_body_bytes.clone(), - pending.info.network_request_handle, - ); - self._context_host - .borrow_mut() - .record_subresource_network(network_record); - } - } - } + pub(crate) fn continue_pending_subresource_response_body( &mut self, internal_id: u64, @@ -1689,94 +997,7 @@ impl ScriptVm { .borrow_mut() .take_pending_subresource_response(internal_id) .ok_or_else(|| anyhow!("unknown pending subresource response `{internal_id}`"))?; - if let Some(target) = - WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) - { - let request = crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.fetch_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }; - let continued = self.continue_worker_owned_fetch_response( - target, - request, - response_code, - response_headers, - ); - if !continued { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - if let Some(target) = WorkerOwnedXhrTarget::from_continuation(&pending.pending.continuation) - { - let response = crate::protocol_types::NavigationResponse::with_status_headers_from( - &pending.response, - response_code.unwrap_or(pending.response.status), - response_headers - .clone() - .unwrap_or_else(|| pending.response.headers.clone()), - ); - let result = if pending.pending.request_mode == moli_fetch::RequestMode::NoCors { - Ok(response) - } else { - crate::network_host::validate_cors_response_chain( - &pending.pending.info.document_url, - &response.head(), - pending.pending.credentials_mode, - ) - .map(|()| response) - }; - self.record_subresource_fetch_network_result( - &pending.pending, - &pending.request_url, - &pending.request_method, - &pending.request_headers, - &pending.request_body, - &result, - ); - let request = crate::worker::WorkerPendingXhrContinue { - redirect_headers: None, - xhr_id: target.xhr_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }; - match result { - Ok(_) => { - let continued = self.continue_worker_owned_xhr_response( - target, - request, - response_code, - response_headers, - ); - if !continued { - bail!(target.unavailable_message()); - } - } - Err(message) => { - let failed = self.fail_worker_owned_xhr_response(target, request, message); - if !failed { - bail!(target.unavailable_message()); - } - } - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } + let response = crate::protocol_types::NavigationResponse::with_status_headers_from( &pending.response, response_code.unwrap_or(pending.response.status), @@ -1823,70 +1044,7 @@ impl ScriptVm { .borrow_mut() .take_pending_subresource_response(internal_id) .ok_or_else(|| anyhow!("unknown pending subresource response `{internal_id}`"))?; - if let Some(target) = - WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) - { - let result = Err(error_text.clone()); - self.record_subresource_fetch_network_result( - &pending.pending, - &pending.request_url, - &pending.request_method, - &pending.request_headers, - &pending.request_body, - &result, - ); - let failed = self.fail_worker_owned_fetch_response( - target, - crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.fetch_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }, - error_text, - ); - if !failed { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - if let Some(target) = WorkerOwnedXhrTarget::from_continuation(&pending.pending.continuation) - { - let result = Err(error_text.clone()); - self.record_subresource_fetch_network_result( - &pending.pending, - &pending.request_url, - &pending.request_method, - &pending.request_headers, - &pending.request_body, - &result, - ); - let request = crate::worker::WorkerPendingXhrContinue { - redirect_headers: None, - xhr_id: target.xhr_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }; - let failed = self.fail_worker_owned_xhr_response(target, request, error_text); - if !failed { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } + let activity = self.resolve_pending_subresource_fetch_body( pending.pending, pending.request_url, @@ -1950,99 +1108,7 @@ impl ScriptVm { { fetch.discard_response_body(); } - if let Some(target) = - WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) - { - let request = crate::worker::WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id: target.fetch_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }; - let fulfilled = self.fulfill_worker_owned_fetch_response( - target, - request, - response_code, - response_headers, - response_body, - ); - if !fulfilled { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - if let Some(target) = WorkerOwnedXhrTarget::from_continuation(&pending.pending.continuation) - { - let response = response_body.clone_as_navigation_response(moli_fetch::ResponseHead { - status_text: None, - final_url: pending.response.final_url.clone(), - status: response_code, - headers: response_headers.clone(), - request_cookie_report: pending.response.request_cookie_report.clone(), - cookie_set_reports: Vec::new(), - redirected: false, - redirect_chain: Vec::new(), - from_cache: pending.response.from_cache, - cache_state: pending.response.cache_state, - negotiated_http_version: pending.response.negotiated_http_version, - }); - let result = if pending.pending.request_mode == moli_fetch::RequestMode::NoCors { - Ok(response) - } else { - crate::network_host::validate_cors_response_chain( - &pending.pending.info.document_url, - &response.head(), - pending.pending.credentials_mode, - ) - .map(|()| response) - }; - self.record_subresource_fetch_network_result( - &pending.pending, - &pending.request_url, - &pending.request_method, - &pending.request_headers, - &pending.request_body, - &result, - ); - let request = crate::worker::WorkerPendingXhrContinue { - redirect_headers: None, - xhr_id: target.xhr_id(), - internal_id, - network_request_handle: pending.pending.info.network_request_handle, - url: pending.request_url, - method: pending.request_method, - body: pending.pending.info.request_body_bytes.clone(), - headers: pending.request_headers, - intercept_response: false, - handle_auth_requests: false, - auth: None, - }; - if let Err(message) = result { - let failed = self.fail_worker_owned_xhr_response(target, request, message); - if !failed { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } - let fulfilled = self.fulfill_worker_owned_xhr_response( - target, - request, - response_code, - response_headers, - response_body, - ); - if !fulfilled { - bail!(target.unavailable_message()); - } - return Ok(AsyncSubresourceCommandExecution::without_window_realm(())); - } + let activity = self.resolve_pending_subresource_fetch_body( pending.pending, pending.request_url, diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs index 4d456e95ce7..310a50ea51b 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs @@ -882,13 +882,7 @@ impl ScriptVm { PendingSubresourceContinuation::Beacon | PendingSubresourceContinuation::CspReport { .. } | PendingSubresourceContinuation::WebSocket(_) - | PendingSubresourceContinuation::ChildDocument(_) - | PendingSubresourceContinuation::WorkerFetch { .. } - | PendingSubresourceContinuation::WorkerXhr { .. } - | PendingSubresourceContinuation::WorkerCspReport { .. } - | PendingSubresourceContinuation::SharedWorkerFetch { .. } - | PendingSubresourceContinuation::SharedWorkerXhr { .. } - | PendingSubresourceContinuation::SharedWorkerCspReport { .. } => {} + | PendingSubresourceContinuation::ChildDocument(_) => {} } defer_subresource_owner_async_scope( &self._context_host, @@ -1164,13 +1158,7 @@ impl ScriptVm { | PendingSubresourceContinuation::CspReport { .. } | PendingSubresourceContinuation::Xhr { .. } | PendingSubresourceContinuation::WebSocket(_) - | PendingSubresourceContinuation::ChildDocument(_) - | PendingSubresourceContinuation::WorkerFetch { .. } - | PendingSubresourceContinuation::WorkerXhr { .. } - | PendingSubresourceContinuation::WorkerCspReport { .. } - | PendingSubresourceContinuation::SharedWorkerFetch { .. } - | PendingSubresourceContinuation::SharedWorkerXhr { .. } - | PendingSubresourceContinuation::SharedWorkerCspReport { .. } => {} + | PendingSubresourceContinuation::ChildDocument(_) => {} } let pending_owner = pending.execution_context.dispatch_scope(); diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs index 4557628abc6..15f808821a1 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_events.rs @@ -600,182 +600,7 @@ async fn csp_report_fetch_pause_continue_preserves_service_worker_dispatch() { .await .expect("service worker paused CSP report server should finish"); } -#[tokio::test] -async fn worker_csp_report_fetch_pause_continue_preserves_service_worker_dispatch() { - let (base_url, server) = spawn_service_worker_response_server_with_headers(vec![ - ( - "/app/worker.js", - "text/javascript; charset=utf-8", - Vec::new(), - r#" - self.addEventListener("install", event => { - event.waitUntil(Promise.resolve()); - }); - self.addEventListener("activate", event => { - event.waitUntil(clients.claim()); - }); - self.addEventListener("fetch", event => { - const url = new URL(event.request.url); - if (url.pathname === "/app/client-worker.js") { - return; - } - if (url.pathname === "/app/csp-report") { - event.respondWith(new Response([ - "destination=" + event.request.destination, - "mode=" + event.request.mode, - "credentials=" + event.request.credentials, - "method=" + event.request.method, - "from=service-worker", - "client=" + (event.clientId.length > 0) - ].join("|"))); - } - }); - "#, - ), - ( - "/app/client-worker.js", - "text/javascript; charset=utf-8", - vec![( - "Content-Security-Policy", - "connect-src 'none'; report-uri /app/csp-report", - )], - r#" - let violationSeen = false; - self.addEventListener("securitypolicyviolation", event => { - violationSeen = event.type === "securitypolicyviolation" && - event.effectiveDirective === "connect-src" && - event.violatedDirective === "connect-src" && - event.blockedURI.endsWith("/app/blocked-data") && - event.disposition === "enforce" && - event instanceof SecurityPolicyViolationEvent; - }); - self.onmessage = async () => { - await fetch("blocked-data").catch(() => {}); - postMessage("blocked:" + violationSeen); - }; - "#, - ), - ]) - .await; - let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); - let (mut vm, browser_context_runtime) = - new_service_worker_page_test_vm_with_loader_and_browser_context_runtime( - &format!("{base_url}/app/page.html"), - &loader, - ); - vm.eval( - r#" - (() => { - globalThis.__pausedWorkerCspReportProbe = "pending"; - (async () => { - await navigator.serviceWorker.register("worker.js", { scope: "./" }); - await navigator.serviceWorker.ready; - globalThis.__pausedWorkerCspReportProbe = "ready"; - })().catch((error) => { - globalThis.__pausedWorkerCspReportProbe = - "error:" + String(error && error.message); - }); - })() - "#, - ) - .expect("paused worker CSP report setup should evaluate"); - - drain_service_worker_test_until_eval_equals( - &mut vm, - &browser_context_runtime, - &loader, - "String(globalThis.__pausedWorkerCspReportProbe)", - "ready", - ) - .await; - - vm.set_fetch_subresource_interception( - crate::types::SubresourceInterceptionClasses::for_resource_type( - crate::types::SubresourceResourceType::CspReport, - ), - ); - vm.eval( - r#" - (() => { - const worker = new Worker("client-worker.js"); - worker.onmessage = event => { - globalThis.__pausedWorkerCspReportProbe = String(event.data); - }; - worker.onerror = event => { - globalThis.__pausedWorkerCspReportProbe = "error:" + event.message; - }; - worker.postMessage("start"); - })() - "#, - ) - .expect("paused worker CSP report trigger should evaluate"); - - drain_service_worker_test_until_eval_equals( - &mut vm, - &browser_context_runtime, - &loader, - "String(globalThis.__pausedWorkerCspReportProbe)", - "blocked:true", - ) - .await; - - let report_url = format!("{base_url}/app/csp-report"); - let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); - let paused_report = loop { - let mut infos = vm.take_pending_subresource_fetch_infos(); - if let Some(index) = infos.iter().position(|info| { - info.resource_type == crate::types::SubresourceResourceType::CspReport - && info.url.as_str() == report_url - }) { - break infos.remove(index); - } - assert!( - std::time::Instant::now() < deadline, - "timed out waiting for paused worker CSP report" - ); - drain_service_worker_test_turn(&mut vm, &browser_context_runtime, &loader).await; - }; - assert_eq!(paused_report.method, "POST"); - - let outcome = vm - .continue_pending_subresource_fetch( - paused_report.internal_id, - None, - None, - None, - None, - false, - false, - ) - .expect("paused worker CSP report continue should start"); - assert_eq!( - outcome, - crate::types::PendingSubresourceContinueOutcome::Started - ); - - let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); - let mut items = Vec::new(); - loop { - items.extend(vm.take_network_output().into_items()); - if service_worker_csp_report_seen( - &items, - &report_url, - "destination=report|mode=no-cors|credentials=same-origin|method=POST|from=service-worker|client=true", - ) { - break; - } - assert!( - std::time::Instant::now() < deadline, - "continued paused worker CSP report did not settle through Service Worker: {items:?}" - ); - drain_service_worker_test_turn(&mut vm, &browser_context_runtime, &loader).await; - } - - server - .await - .expect("paused worker CSP report destination server should finish"); -} #[tokio::test] async fn navigator_service_worker_fetch_event_request_preserves_window_fetch_policy_metadata() { let (base_url, server) = spawn_service_worker_response_server(vec![( diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface/redirect_modes.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface/redirect_modes.rs index fa017cf1f06..c52435c52ff 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface/redirect_modes.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/service_worker_surface/redirect_modes.rs @@ -58,9 +58,7 @@ async fn service_worker_synthetic_redirect_without_location_preserves_client_mod for stream in [false, true] { for status in [200, 301, 302, 303, 307, 308] { for redirect in ["error", "manual", "follow"] { - let expected = if status != 200 && redirect == "error" { - serde_json::json!({"error":"TypeError"}) - } else if status != 200 && redirect == "manual" { + let expected = if status != 200 && redirect == "manual" { serde_json::json!({"type":"opaqueredirect","status":0,"bodyNull":true, "header":null,"body":"","cloneType":"opaqueredirect","cloneBody":""}) } else { diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs b/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs index 56ea64f9402..b60506683f2 100644 --- a/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs +++ b/moli-renderer-v8/src/script_vm/tests/extracted/window_apis.rs @@ -313,7 +313,6 @@ fn window_fetch_retirement_covers_every_host_stage() { PendingWindowFetchTestStage::Streaming, PendingWindowFetchTestStage::Auth, PendingWindowFetchTestStage::Response, - PendingWindowFetchTestStage::ServiceWorkerInFlight, ]; let mut ordinary = Vec::new(); let mut keepalive = Vec::new(); diff --git a/moli-renderer-v8/src/script_vm/tests/idb_sqlite_factory/deletion_tests.rs b/moli-renderer-v8/src/script_vm/tests/idb_sqlite_factory/deletion_tests.rs index 574a0d1ddb1..fcc77029791 100644 --- a/moli-renderer-v8/src/script_vm/tests/idb_sqlite_factory/deletion_tests.rs +++ b/moli-renderer-v8/src/script_vm/tests/idb_sqlite_factory/deletion_tests.rs @@ -28,7 +28,12 @@ async fn idb_sqlite_bucket_delete_clears_storage_and_invalidates_retained_object tx.onabort = () => resolve('abort'); tx.oncomplete = () => resolve('unexpected-commit'); }); - tx.objectStore('records').put({blob:new Blob(['discarded'])}).onerror = event => event.preventDefault(); + const store = tx.objectStore('records'); + store.put({blob:new Blob(['discarded'])}).onerror = event => event.preventDefault(); + // Deletion is asynchronous. Keep this transaction active until bucket + // retirement aborts it, rather than racing its normal auto-commit. + const keepActive = () => { store.get(1).onsuccess = keepActive; }; + keepActive(); await Promise.all([navigator.storageBuckets.delete('remove'),navigator.storageBuckets.delete('remove')]); let closed = false, stale = false; try { db.transaction('records'); } catch (error) { closed = error.name === 'InvalidStateError'; } diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 4c7293367c6..7e86e506572 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -297,7 +297,6 @@ enum PendingWindowFetchTestStage { Streaming, Auth, Response, - ServiceWorkerInFlight, } fn register_pending_window_fetch_for_test( @@ -449,17 +448,6 @@ fn register_pending_window_fetch_for_test( }, ); } - PendingWindowFetchTestStage::ServiceWorkerInFlight => { - host.record_in_flight_worker_subresource_fetch( - crate::types::InFlightWorkerSubresourceFetchState { - pending, - request_url: url, - request_method: "GET".to_owned(), - request_headers: Vec::new().into(), - request_body: None, - }, - ); - } } } diff --git a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/url_and_initializer_semantics.rs b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/url_and_initializer_semantics.rs index 8beacb173a8..56ca19fd20d 100644 --- a/moli-renderer-v8/src/script_vm/tests/webidl_fetch/url_and_initializer_semantics.rs +++ b/moli-renderer-v8/src/script_vm/tests/webidl_fetch/url_and_initializer_semantics.rs @@ -1528,7 +1528,7 @@ fn fetched_null_bodies_discard_payloads_without_registering_pending_streams() { ("GET", 101), ("GET", 103), ("GET", 204), ("GET", 205), ("GET", 304), ] { for opaque in [false, true] { - for source in ["response", "bytes", "subresource", "stream", "preload"] { + for source in ["response", "bytes", "stream", "preload"] { let request = FetchResponseRequest { method, mode: if opaque { moli_fetch::RequestMode::NoCors } else { moli_fetch::RequestMode::Cors }, @@ -1558,10 +1558,6 @@ fn fetched_null_bodies_discard_payloads_without_registering_pending_streams() { moli_fetch::ResponseBody::materialized_bytes(b"discard me".to_vec()), metadata, ), - "subresource" => crate::network_host::build_fetch_response_object_from_subresource_body_for_request_mode( - scope, request, head, - crate::protocol_types::SubresourceResponseBody::from_bytes(b"discard me".to_vec()), metadata, - ), "stream" => crate::network_host::build_fetch_response_object_from_stream_for_request_mode( scope, &document_url, request, head, id, ), diff --git a/moli-renderer-v8/src/script_vm/tests/websocket.rs b/moli-renderer-v8/src/script_vm/tests/websocket.rs index ac6135d8e27..54a686a51b9 100644 --- a/moli-renderer-v8/src/script_vm/tests/websocket.rs +++ b/moli-renderer-v8/src/script_vm/tests/websocket.rs @@ -505,6 +505,7 @@ fn loading_worker_terminate_blocks_late_script_loaded_transition() { crate::worker::WorkerScriptSource::text( "postMessage('late'); self.close();".to_owned(), ), + None, crate::worker::WorkerScriptKind::Classic, true, None, diff --git a/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs b/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs index 0f42ec45cdf..768960e3ae5 100644 --- a/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs +++ b/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs @@ -15,10 +15,10 @@ use moli_shared_worker::SharedWorkerInstanceId; use super::ScriptVm; use crate::{ native_bridge::PageScriptHost, - types::{DedicatedWorkerId, PendingSubresourceContinueEvent, SubresourceResourceType}, + types::DedicatedWorkerId, worker::{ - WorkerPendingSubresourceFetch, WorkerRuntimeEvent, WorkerToParentMessage, - WorkerWebSocketFrameEvent, WorkerWebSocketLifecycleEvent, + WorkerRuntimeEvent, WorkerToParentMessage, WorkerWebSocketFrameEvent, + WorkerWebSocketLifecycleEvent, }, }; @@ -55,123 +55,6 @@ enum WorkerHostRecordOwner { } impl WorkerHostRecordOwner { - fn record_pending_fetch( - self, - scope: &mut v8::PinScope<'_, '_>, - context_host: &Rc>, - pending: WorkerPendingSubresourceFetch, - ) { - let context = v8::Global::new(scope, scope.get_current_context()); - match (self, pending.info.resource_type) { - (Self::Dedicated(worker_id), SubresourceResourceType::Xhr) => { - context_host - .borrow_mut() - .record_pending_worker_subresource_xhr( - context, - worker_id, - pending.fetch_id, - pending.load, - pending.credentials_mode, - pending.network_partition_key, - pending.info, - ); - } - (Self::Dedicated(worker_id), SubresourceResourceType::CspReport) => { - context_host - .borrow_mut() - .record_pending_worker_subresource_csp_report( - context, - worker_id, - pending.fetch_id, - pending.load, - pending.credentials_mode, - pending.request_mode, - pending.network_partition_key, - pending.info, - ); - } - (Self::Dedicated(worker_id), _) => { - context_host - .borrow_mut() - .record_pending_worker_subresource_fetch( - context, - worker_id, - pending.fetch_id, - pending.load, - pending.credentials_mode, - pending.request_mode, - pending.network_partition_key, - pending.info, - ); - } - (Self::Shared(instance_id), SubresourceResourceType::Xhr) => { - context_host - .borrow_mut() - .record_pending_shared_worker_subresource_xhr( - context, - instance_id, - pending.fetch_id, - pending.load, - pending.credentials_mode, - pending.network_partition_key, - pending.info, - ); - } - (Self::Shared(instance_id), SubresourceResourceType::CspReport) => { - context_host - .borrow_mut() - .record_pending_shared_worker_subresource_csp_report( - context, - instance_id, - pending.fetch_id, - pending.load, - pending.credentials_mode, - pending.request_mode, - pending.network_partition_key, - pending.info, - ); - } - (Self::Shared(instance_id), _) => { - context_host - .borrow_mut() - .record_pending_shared_worker_subresource_fetch( - context, - instance_id, - pending.fetch_id, - pending.load, - pending.credentials_mode, - pending.request_mode, - pending.network_partition_key, - pending.info, - ); - } - } - } - - fn cancel_pending_fetch( - self, - context_host: &Rc>, - fetch_id: u32, - error_text: String, - ) { - match self { - Self::Dedicated(worker_id) => { - context_host - .borrow_mut() - .cancel_pending_worker_subresource_fetch(worker_id, fetch_id, error_text); - } - Self::Shared(instance_id) => { - context_host - .borrow_mut() - .cancel_pending_shared_worker_subresource_fetch( - instance_id, - fetch_id, - error_text, - ); - } - } - } - fn encoded_websocket_id(self, local_socket_id: u64) -> u64 { match self { Self::Dedicated(worker_id) => { @@ -400,41 +283,19 @@ impl ScriptVm { } fn apply_worker_host_bridge_record_in_scope( - scope: &mut v8::PinScope<'_, '_>, + _scope: &mut v8::PinScope<'_, '_>, context_host: &Rc>, owner: WorkerHostRecordOwner, message: WorkerToParentMessage, ) -> Result<()> { match message { + #[cfg(test)] + WorkerToParentMessage::PendingSubresourceFetch(_) + | WorkerToParentMessage::SubresourceContinue(_) => {} WorkerToParentMessage::SubresourceNetwork(record) => { context_host.borrow_mut().record_subresource_network(record); } - WorkerToParentMessage::PendingSubresourceFetch(pending) => { - owner.record_pending_fetch(scope, context_host, pending); - } - WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id, - error_text, - } => { - owner.cancel_pending_fetch(context_host, fetch_id, error_text); - } - WorkerToParentMessage::SubresourceContinue(event) => match event { - PendingSubresourceContinueEvent::ResponsePaused(info) => { - context_host - .borrow_mut() - .record_worker_subresource_response_pause(info); - } - PendingSubresourceContinueEvent::AuthRequired(info) => { - context_host - .borrow_mut() - .record_worker_subresource_auth_pause(info); - } - PendingSubresourceContinueEvent::Completed { internal_id } => { - context_host - .borrow_mut() - .record_worker_subresource_completed(internal_id); - } - }, + WorkerToParentMessage::WebSocketSubresource(record) => { let Some(local_socket_id) = record.websocket_socket_id() else { return Ok(()); diff --git a/moli-renderer-v8/src/service_worker_runtime/host.rs b/moli-renderer-v8/src/service_worker_runtime/host.rs index 3be05a00dc9..f5b453c8ed7 100644 --- a/moli-renderer-v8/src/service_worker_runtime/host.rs +++ b/moli-renderer-v8/src/service_worker_runtime/host.rs @@ -742,8 +742,10 @@ fn spawn_parent_message_pump( service.enqueue_periodic_sync_event_completed(completion); } WorkerToParentMessage::ServiceWorkerShowNotification(request) => { - service - .enqueue_show_notification_requested(request, Arc::clone(&source_host)); + service.enqueue_show_notification_requested( + *request, + Arc::clone(&source_host), + ); } WorkerToParentMessage::ServiceWorkerGetNotifications(request) => { service @@ -873,12 +875,12 @@ fn spawn_parent_message_pump( WorkerToParentMessage::RuntimeInspectorResponse(publication) => { let _ = publication.commit(None); } + #[cfg(test)] + WorkerToParentMessage::PendingSubresourceFetch(_) + | WorkerToParentMessage::SubresourceContinue(_) => {} WorkerToParentMessage::Post(_) | WorkerToParentMessage::SharedWorkerClosed | WorkerToParentMessage::SubresourceNetwork(_) - | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } - | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) | WorkerToParentMessage::WebSocketFrame(_) => {} diff --git a/moli-renderer-v8/src/service_worker_runtime/service.rs b/moli-renderer-v8/src/service_worker_runtime/service.rs index 600289c33bf..453f375c8b5 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service.rs @@ -903,6 +903,7 @@ mod tests { cancel_handle: moli_fetch::FetchCancelHandle, ) -> ServiceWorkerFetchJob { ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs index 252e6743b7f..9b0d84b0323 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/event_dispatch.rs @@ -276,6 +276,31 @@ impl ServiceWorkerRuntimeService { &self, dispatch: ServiceWorkerFetchDispatch, native_request: moli_fetch::Request, + ) -> bool { + self.dispatch_fetch_with_delivery( + dispatch, + native_request, + super::super::state::ServiceWorkerFetchResponseDelivery::Client, + ) + } + + pub(crate) fn dispatch_controlled_fetch_hop( + &self, + dispatch: ServiceWorkerFetchDispatch, + native_request: moli_fetch::Request, + ) -> bool { + self.dispatch_fetch_with_delivery( + dispatch, + native_request, + super::super::state::ServiceWorkerFetchResponseDelivery::LoaderHop, + ) + } + + fn dispatch_fetch_with_delivery( + &self, + dispatch: ServiceWorkerFetchDispatch, + native_request: moli_fetch::Request, + response_delivery: super::super::state::ServiceWorkerFetchResponseDelivery, ) -> bool { let request = dispatch.request.clone(); // Synthetic redirects advance this retained request before a network @@ -285,6 +310,7 @@ impl ServiceWorkerRuntimeService { .bind_browser_site_context(native_request); let initial_redirect_count = native_request.redirect_count(); let fetch_job = ServiceWorkerFetchJob { + response_delivery, request: native_request, initial_redirect_count, internal_id: dispatch.internal_id, diff --git a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs index 40dab37c95a..83402a87c97 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/fetch_settlement.rs @@ -583,7 +583,13 @@ impl ServiceWorkerRuntimeService { self.complete_fetch_with_failure(job, message); return; } - if is_redirect_status(response.head.status) + if job.response_delivery == super::super::state::ServiceWorkerFetchResponseDelivery::Client + && is_redirect_status(response.head.status) + && response + .head + .headers + .iter() + .any(|(name, _)| name.eq_ignore_ascii_case("location")) && job.request.redirect_mode() == moli_fetch::RequestRedirectMode::Error { self.complete_fetch_with_network_failure( @@ -593,7 +599,8 @@ impl ServiceWorkerRuntimeService { ); return; } - if is_redirect_status(response.head.status) + if job.response_delivery == super::super::state::ServiceWorkerFetchResponseDelivery::Client + && is_redirect_status(response.head.status) && job.request.redirect_mode() == moli_fetch::RequestRedirectMode::Follow { match service_worker_redirect_target(&job, &response) { @@ -1156,6 +1163,7 @@ mod tests { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); @@ -2030,6 +2038,7 @@ mod tests { let completion_queue = crate::page_task_queue::RendererResourceCompletionTestHarness::new(); let request_url = url("https://example.test/app/post"); let mut job = ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&request_url); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs index 3d2cd832ce7..4cd43cf7e58 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/fetch_events.rs @@ -736,6 +736,7 @@ fn pending_unregistration_waits_for_active_fetch_to_complete_before_delete() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); @@ -1204,6 +1205,7 @@ fn restart_start_failure_rejects_pending_fetch_job() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); @@ -2294,6 +2296,7 @@ fn empty_fetch_handler_pending_start_fetch_falls_back_after_worker_start() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); @@ -2423,6 +2426,7 @@ fn fetch_completion_schedules_idle_timeout_for_running_active_worker() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); @@ -2654,6 +2658,7 @@ fn active_fetch_completion_queues_waiting_activation_after_controllees_are_gone( state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); @@ -2848,6 +2853,7 @@ fn activating_new_worker_fails_replaced_active_fetch_and_pending_start_events() state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&document_url); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/functional_events.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/functional_events.rs index c1454a569e4..a5ff6796ce2 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/functional_events.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/functional_events.rs @@ -263,7 +263,7 @@ self.addEventListener("message", event => { } crate::worker::WorkerToParentMessage::ServiceWorkerShowNotification(request) => { service.finish_show_notification_requested( - request, + *request, stale_run.clone(), host.clone(), ); diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs index 687a6c294d0..9700066f8e3 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/registration_jobs.rs @@ -265,6 +265,7 @@ fn pending_unregistration_deletion_clears_owner_state() { state.pending_fetch_jobs.insert( event_id, ServiceWorkerFetchJob { + response_delivery: Default::default(), initial_redirect_count: 0, request: { let origin = moli_url::WebOrigin::from_url(&request_url); diff --git a/moli-renderer-v8/src/service_worker_runtime/state.rs b/moli-renderer-v8/src/service_worker_runtime/state.rs index 1a9c8f2fdaf..83e01fffcc2 100644 --- a/moli-renderer-v8/src/service_worker_runtime/state.rs +++ b/moli-renderer-v8/src/service_worker_runtime/state.rs @@ -768,7 +768,15 @@ pub(super) enum ServiceWorkerPeriodicSyncStart { Dropped, } +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub(super) enum ServiceWorkerFetchResponseDelivery { + #[default] + Client, + LoaderHop, +} + pub(super) struct ServiceWorkerFetchJob { + pub(super) response_delivery: ServiceWorkerFetchResponseDelivery, pub(super) request: moli_fetch::Request, // Only redirects followed during this job transfer network fallback to it. pub(super) initial_redirect_count: usize, diff --git a/moli-renderer-v8/src/shared_worker_runtime.rs b/moli-renderer-v8/src/shared_worker_runtime.rs index f547a9673ed..cdd316568de 100644 --- a/moli-renderer-v8/src/shared_worker_runtime.rs +++ b/moli-renderer-v8/src/shared_worker_runtime.rs @@ -27,8 +27,6 @@ mod owner_wake; mod protocol_commands; mod protocol_routing; mod pump; -mod resource_commands; -mod resource_routing; mod routing; mod service; mod service_lane; diff --git a/moli-renderer-v8/src/shared_worker_runtime/events.rs b/moli-renderer-v8/src/shared_worker_runtime/events.rs index bc81e89af98..1ffc7251a70 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/events.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/events.rs @@ -18,6 +18,9 @@ impl RendererSharedWorkerHost { script_url: &str, ) { match message { + #[cfg(test)] + WorkerToParentMessage::PendingSubresourceFetch(_) + | WorkerToParentMessage::SubresourceContinue(_) => {} WorkerToParentMessage::Error { message, filename, @@ -147,9 +150,6 @@ impl RendererSharedWorkerHost { self.send_host_bridge_message(message, script_url); } WorkerToParentMessage::SubresourceNetwork(_) - | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } - | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) | WorkerToParentMessage::WebSocketFrame(_) diff --git a/moli-renderer-v8/src/shared_worker_runtime/host_target_output.rs b/moli-renderer-v8/src/shared_worker_runtime/host_target_output.rs index ffd18b42a2b..ac40c23e473 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/host_target_output.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/host_target_output.rs @@ -16,8 +16,27 @@ use super::host::RendererSharedWorkerHost; use super::host::SharedWorkerRuntimeResponsePublicationState; impl RendererSharedWorkerHost { - pub(super) fn publish_created_target_event(&self) { - self.publish_target_event(RendererSharedWorkerTargetEvent::Created(self.target_info())); + pub(super) fn publish_resource_event(&self, event: crate::network::ResourceInterceptionEvent) { + let record = PendingRendererOutputRecord::owner_action( + None, + RendererOwnerAction::SharedWorkerTargetLifecycle( + RendererSharedWorkerTargetEvent::Resource { + instance_id: self.instance_id(), + event, + }, + ), + ) + .resolve() + .expect("native Worker resource has a source identity"); + self.target_output().try_publish_record(record); + } + pub(super) fn publish_created_target_event( + &self, + policy: Option, + ) { + self.publish_target_event(RendererSharedWorkerTargetEvent::Created( + self.target_info(policy), + )); } pub(super) fn publish_destroyed_target_event(self: &Arc) { @@ -187,8 +206,12 @@ impl RendererSharedWorkerHost { self.runtime_service().is_running_host(self) } - fn target_info(&self) -> RendererSharedWorkerTargetInfo { + fn target_info( + &self, + interception_policy: Option, + ) -> RendererSharedWorkerTargetInfo { RendererSharedWorkerTargetInfo { + interception_policy, owner_local_host_id: self.owner_local_host_id(), instance_id: self.instance_id(), url: self.current_script_url(), @@ -275,7 +298,7 @@ mod tests { let host = test_support::loading_host_with_runtime_service(instance_id, &key, &runtime_service); - host.publish_created_target_event(); + host.publish_created_target_event(None); let (tx, mut rx) = crate::runtime::renderer_output_transport_channel(); runtime_service.bind_target_output_transport(tx); @@ -315,7 +338,7 @@ mod tests { let (tx, mut rx) = crate::runtime::renderer_output_transport_channel(); runtime_service.bind_target_output_transport(tx); - host.publish_created_target_event(); + host.publish_created_target_event(None); host.publish_destroyed_target_event(); assert!(matches!( diff --git a/moli-renderer-v8/src/shared_worker_runtime/host_worker.rs b/moli-renderer-v8/src/shared_worker_runtime/host_worker.rs index 345670babb8..973f0a0e123 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/host_worker.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/host_worker.rs @@ -15,7 +15,7 @@ use super::{ impl RendererSharedWorkerHost { pub(super) fn start_running( - &self, + self: &Arc, script: SharedWorkerLoadedScript, params: SharedWorkerLaunchParams, ) -> bool { @@ -34,11 +34,32 @@ impl RendererSharedWorkerHost { .unwrap_or(execution_policy.policy_context) }; let reserved_service_worker_client_id = params.reserved_service_worker_client_id; + let request_client = launch_context + .request_client + .fork_for_shared_worker_target(); + let policy = + crate::network::ResourceInterceptionPolicy(request_client.page_network_policy()); + let weak_host = Arc::downgrade(self); + let interception = crate::network::interception_output::ResourceInterceptionContext::worker( + None, + move |event| { + let Some(host) = weak_host.upgrade() else { + return false; + }; + let state = host.state.lock(); + if !matches!(*state, RendererSharedWorkerHostState::Running { .. }) { + return false; + } + host.publish_resource_event(event); + true + }, + ); let options = WorkerSpawnOptions::new_with_request_client( script_source, script_url.clone(), - launch_context.request_client, + request_client, ) + .with_interception_context(Some(interception)) .with_script_kind(execution_policy.script_kind) .with_module_static_import_initiator_url( execution_policy.module_static_import_initiator_url, @@ -58,6 +79,11 @@ impl RendererSharedWorkerHost { .with_network_policy(execution_policy.network_policy) .with_policy_context(policy_context) .with_worker_context_runtime(execution_policy.worker_context_runtime.clone()) + .with_pause_evaluation_until_debugger( + execution_policy + .worker_context_runtime + .shared_worker_pause_on_start_for_devtools(), + ) .with_global_kind(WorkerGlobalKind::Shared { name: name.clone(), storage_key: params.key.storage_key().clone(), @@ -76,16 +102,16 @@ impl RendererSharedWorkerHost { } else { options }; - let mut handle = spawn_worker_with_options(options); - let tx = handle.tx.clone(); - let parent_rx = handle.take_receiver(); let mut state = self.state.lock(); if !matches!(*state, RendererSharedWorkerHostState::Loading { .. }) { drop(state); - handle.terminate_and_join(); return false; } self.set_current_script_url(script_url); + self.publish_created_target_event(Some(policy)); + let mut handle = spawn_worker_with_options(options); + let tx = handle.tx.clone(); + let parent_rx = handle.take_receiver(); *state = RendererSharedWorkerHostState::Running { tx, handle: Some(handle), diff --git a/moli-renderer-v8/src/shared_worker_runtime/load_completion.rs b/moli-renderer-v8/src/shared_worker_runtime/load_completion.rs index c9f3c92609e..a3a88437cc0 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/load_completion.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/load_completion.rs @@ -68,7 +68,6 @@ fn finish_loading_with_runtime_service( ); return; } - host.publish_created_target_event(); host.start_parent_message_pump(); for client_id in host.connect_pending_clients(clients) { runtime_service.remove_client(client_id); diff --git a/moli-renderer-v8/src/shared_worker_runtime/resource_commands.rs b/moli-renderer-v8/src/shared_worker_runtime/resource_commands.rs deleted file mode 100644 index 6d40776e496..00000000000 --- a/moli-renderer-v8/src/shared_worker_runtime/resource_commands.rs +++ /dev/null @@ -1,198 +0,0 @@ -use crate::{ - RendererSyntheticResponseBody, - worker::{WorkerMessage, WorkerPendingFetchContinue, WorkerPendingXhrContinue}, -}; - -use super::host::RendererSharedWorkerHost; - -impl RendererSharedWorkerHost { - pub(super) fn continue_pending_fetch(&self, request: WorkerPendingFetchContinue) -> bool { - self.send_worker_message(WorkerMessage::ContinuePendingFetch(request)) - } - - pub(super) fn continue_pending_xhr(&self, request: WorkerPendingXhrContinue) -> bool { - self.send_worker_message(WorkerMessage::ContinuePendingXhr(request)) - } - - pub(super) fn continue_pending_csp_report(&self, request: WorkerPendingFetchContinue) -> bool { - self.send_worker_message(WorkerMessage::ContinuePendingCspReport(request)) - } - - pub(super) fn continue_pending_fetch_response( - &self, - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.send_worker_message(WorkerMessage::ContinuePendingFetchResponse { - request, - response_code, - response_headers, - }) - } - - pub(super) fn continue_pending_xhr_response( - &self, - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.send_worker_message(WorkerMessage::ContinuePendingXhrResponse { - request, - response_code, - response_headers, - }) - } - - pub(super) fn fail_pending_fetch( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.send_worker_message(WorkerMessage::FailPendingFetch { - request, - error_text, - }) - } - - pub(super) fn fail_pending_xhr( - &self, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.send_worker_message(WorkerMessage::FailPendingXhr { - request, - error_text, - }) - } - - pub(super) fn fail_pending_csp_report( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.send_worker_message(WorkerMessage::FailPendingCspReport { - request, - error_text, - }) - } - - pub(super) fn fail_pending_fetch_auth( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.send_worker_message(WorkerMessage::FailPendingFetchAuth { - request, - error_text, - }) - } - - pub(super) fn fail_pending_xhr_auth( - &self, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.send_worker_message(WorkerMessage::FailPendingXhrAuth { - request, - error_text, - }) - } - - pub(super) fn fail_pending_fetch_response( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.send_worker_message(WorkerMessage::FailPendingFetchResponse { - request, - error_text, - }) - } - - pub(super) fn fail_pending_xhr_response( - &self, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.send_worker_message(WorkerMessage::FailPendingXhrResponse { - request, - error_text, - }) - } - - pub(super) fn fulfill_pending_fetch( - &self, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.send_worker_message(WorkerMessage::FulfillPendingFetch { - request, - response_code, - response_headers, - response_body, - }) - } - - pub(super) fn fulfill_pending_xhr( - &self, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.send_worker_message(WorkerMessage::FulfillPendingXhr { - request, - response_code, - response_headers, - response_body, - }) - } - - pub(super) fn fulfill_pending_csp_report( - &self, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.send_worker_message(WorkerMessage::FulfillPendingCspReport { - request, - response_code, - response_headers, - response_body, - }) - } - - pub(super) fn fulfill_pending_fetch_response( - &self, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.send_worker_message(WorkerMessage::FulfillPendingFetchResponse { - request, - response_code, - response_headers, - response_body, - }) - } - - pub(super) fn fulfill_pending_xhr_response( - &self, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.send_worker_message(WorkerMessage::FulfillPendingXhrResponse { - request, - response_code, - response_headers, - response_body, - }) - } -} diff --git a/moli-renderer-v8/src/shared_worker_runtime/resource_routing.rs b/moli-renderer-v8/src/shared_worker_runtime/resource_routing.rs deleted file mode 100644 index f07d1e7684c..00000000000 --- a/moli-renderer-v8/src/shared_worker_runtime/resource_routing.rs +++ /dev/null @@ -1,550 +0,0 @@ -use moli_shared_worker::SharedWorkerInstanceId; - -use crate::{ - RendererSyntheticResponseBody, - worker::{WorkerPendingFetchContinue, WorkerPendingXhrContinue}, -}; - -use super::{host::RendererSharedWorkerHost, service::SharedWorkerRuntimeService}; - -enum SharedWorkerResourceCommand { - ContinueFetch { - request: WorkerPendingFetchContinue, - }, - ContinueXhr { - request: WorkerPendingXhrContinue, - }, - ContinueCspReport { - request: WorkerPendingFetchContinue, - }, - ContinueFetchResponse { - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - }, - ContinueXhrResponse { - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - }, - FailFetch { - request: WorkerPendingFetchContinue, - error_text: String, - }, - FailXhr { - request: WorkerPendingXhrContinue, - error_text: String, - }, - FailCspReport { - request: WorkerPendingFetchContinue, - error_text: String, - }, - FailFetchAuth { - request: WorkerPendingFetchContinue, - error_text: String, - }, - FailXhrAuth { - request: WorkerPendingXhrContinue, - error_text: String, - }, - FailFetchResponse { - request: WorkerPendingFetchContinue, - error_text: String, - }, - FailXhrResponse { - request: WorkerPendingXhrContinue, - error_text: String, - }, - FulfillFetch { - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - FulfillXhr { - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - FulfillCspReport { - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - FulfillFetchResponse { - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - FulfillXhrResponse { - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, -} - -impl SharedWorkerResourceCommand { - fn dispatch(self, host: &RendererSharedWorkerHost) -> bool { - match self { - Self::ContinueFetch { request } => host.continue_pending_fetch(request), - Self::ContinueXhr { request } => host.continue_pending_xhr(request), - Self::ContinueCspReport { request } => host.continue_pending_csp_report(request), - Self::ContinueFetchResponse { - request, - response_code, - response_headers, - } => host.continue_pending_fetch_response(request, response_code, response_headers), - Self::ContinueXhrResponse { - request, - response_code, - response_headers, - } => host.continue_pending_xhr_response(request, response_code, response_headers), - Self::FailFetch { - request, - error_text, - } => host.fail_pending_fetch(request, error_text), - Self::FailXhr { - request, - error_text, - } => host.fail_pending_xhr(request, error_text), - Self::FailCspReport { - request, - error_text, - } => host.fail_pending_csp_report(request, error_text), - Self::FailFetchAuth { - request, - error_text, - } => host.fail_pending_fetch_auth(request, error_text), - Self::FailXhrAuth { - request, - error_text, - } => host.fail_pending_xhr_auth(request, error_text), - Self::FailFetchResponse { - request, - error_text, - } => host.fail_pending_fetch_response(request, error_text), - Self::FailXhrResponse { - request, - error_text, - } => host.fail_pending_xhr_response(request, error_text), - Self::FulfillFetch { - request, - response_code, - response_headers, - response_body, - } => { - host.fulfill_pending_fetch(request, response_code, response_headers, response_body) - } - Self::FulfillXhr { - request, - response_code, - response_headers, - response_body, - } => host.fulfill_pending_xhr(request, response_code, response_headers, response_body), - Self::FulfillCspReport { - request, - response_code, - response_headers, - response_body, - } => host.fulfill_pending_csp_report( - request, - response_code, - response_headers, - response_body, - ), - Self::FulfillFetchResponse { - request, - response_code, - response_headers, - response_body, - } => host.fulfill_pending_fetch_response( - request, - response_code, - response_headers, - response_body, - ), - Self::FulfillXhrResponse { - request, - response_code, - response_headers, - response_body, - } => host.fulfill_pending_xhr_response( - request, - response_code, - response_headers, - response_body, - ), - } - } -} - -impl SharedWorkerRuntimeService { - fn dispatch_resource_command( - &self, - instance_id: SharedWorkerInstanceId, - command: SharedWorkerResourceCommand, - ) -> bool { - self.route_running_host(instance_id, |host| command.dispatch(host)) - } - - pub(crate) fn continue_pending_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::ContinueFetch { request }, - ) - } - - pub(crate) fn continue_pending_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::ContinueXhr { request }, - ) - } - - pub(crate) fn continue_pending_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::ContinueCspReport { request }, - ) - } - - pub(crate) fn continue_pending_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::ContinueFetchResponse { - request, - response_code, - response_headers, - }, - ) - } - - pub(crate) fn continue_pending_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::ContinueXhrResponse { - request, - response_code, - response_headers, - }, - ) - } - - pub(crate) fn fail_pending_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FailFetch { - request, - error_text, - }, - ) - } - - pub(crate) fn fail_pending_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FailXhr { - request, - error_text, - }, - ) - } - - pub(crate) fn fail_pending_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FailCspReport { - request, - error_text, - }, - ) - } - - pub(crate) fn fail_pending_fetch_auth( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FailFetchAuth { - request, - error_text, - }, - ) - } - - pub(crate) fn fail_pending_xhr_auth( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FailXhrAuth { - request, - error_text, - }, - ) - } - - pub(crate) fn fail_pending_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - error_text: String, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FailFetchResponse { - request, - error_text, - }, - ) - } - - pub(crate) fn fail_pending_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - error_text: String, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FailXhrResponse { - request, - error_text, - }, - ) - } - - pub(crate) fn fulfill_pending_fetch( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FulfillFetch { - request, - response_code, - response_headers, - response_body, - }, - ) - } - - pub(crate) fn fulfill_pending_xhr( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FulfillXhr { - request, - response_code, - response_headers, - response_body, - }, - ) - } - - pub(crate) fn fulfill_pending_csp_report( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FulfillCspReport { - request, - response_code, - response_headers, - response_body, - }, - ) - } - - pub(crate) fn fulfill_pending_fetch_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FulfillFetchResponse { - request, - response_code, - response_headers, - response_body, - }, - ) - } - - pub(crate) fn fulfill_pending_xhr_response( - &self, - instance_id: SharedWorkerInstanceId, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) -> bool { - self.dispatch_resource_command( - instance_id, - SharedWorkerResourceCommand::FulfillXhrResponse { - request, - response_code, - response_headers, - response_body, - }, - ) - } -} - -#[cfg(test)] -mod tests { - use moli_shared_worker::{SharedWorkerConnectAction, SharedWorkerDescriptor}; - use tokio::sync::mpsc; - use url::Url; - - use crate::worker::WorkerMessage; - - use super::{ - super::{host::RendererSharedWorkerHostState, test_support}, - *, - }; - - fn pending_fetch(fetch_id: u32) -> WorkerPendingFetchContinue { - WorkerPendingFetchContinue { - redirect_headers: None, - fetch_id, - internal_id: u64::from(fetch_id), - network_request_handle: None, - url: Url::parse("https://example.test/shared-worker-fetch").unwrap(), - method: "GET".to_owned(), - body: None, - headers: Vec::new().into(), - intercept_response: false, - handle_auth_requests: false, - auth: None, - } - } - - #[test] - fn shared_worker_resource_commands_route_only_to_running_instance() { - let service = test_support::runtime_service(); - let key = test_support::shared_worker_key(); - let action = test_support::connect_matching( - &service, - key.clone(), - SharedWorkerDescriptor::default(), - ); - let SharedWorkerConnectAction::StartLoading { instance_id, .. } = action else { - panic!("first shared worker connection should start a loading instance"); - }; - - assert!( - !service.continue_pending_fetch(instance_id, pending_fetch(1)), - "resource commands must not route to loading SharedWorker hosts" - ); - - let host = test_support::loading_host_with_runtime_service(instance_id, &key, &service); - let (tx, mut rx) = mpsc::unbounded_channel(); - *host.state.lock() = RendererSharedWorkerHostState::Running { - tx, - handle: None, - parent_rx: None, - }; - let ready = - test_support::finish_loading_matching(&service, &key, instance_id, host.clone()); - assert!( - matches!( - ready, - moli_shared_worker::SharedWorkerLoadReady::Running { .. } - ), - "shared worker matching store should publish the running host" - ); - - assert!(service.continue_pending_fetch(instance_id, pending_fetch(7))); - match rx - .try_recv() - .expect("running host should receive fetch command") - { - WorkerMessage::ContinuePendingFetch(request) => { - assert_eq!(request.fetch_id, 7); - assert_eq!(request.internal_id, 7); - } - other => panic!("expected ContinuePendingFetch, got {other:?}"), - } - - assert!( - !service.continue_pending_fetch( - SharedWorkerInstanceId::from_u64(instance_id.as_u64() + 1), - pending_fetch(8), - ), - "resource commands must fail closed for stale or missing SharedWorker instances" - ); - assert!( - rx.try_recv().is_err(), - "stale SharedWorker resource command must not be delivered to the live host" - ); - } -} diff --git a/moli-renderer-v8/src/shared_worker_runtime/routing.rs b/moli-renderer-v8/src/shared_worker_runtime/routing.rs index 66cba50171d..d8dac850bb3 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/routing.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/routing.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use moli_shared_worker::SharedWorkerInstanceId; use super::{ - host::{RendererSharedWorkerHost, SharedRendererSharedWorkerHost}, + host::SharedRendererSharedWorkerHost, service::{SharedWorkerRuntimeService, WeakSharedWorkerRuntimeService}, }; @@ -14,24 +14,6 @@ impl SharedWorkerRuntimeService { ) -> Option { self.running_matching_host(instance_id) } - - pub(super) fn route_running_host( - &self, - instance_id: SharedWorkerInstanceId, - route: impl FnOnce(&RendererSharedWorkerHost) -> bool, - ) -> bool { - let Some(host) = self.running_host_for_route(instance_id) else { - return false; - }; - route(&host) - } - - fn running_host_for_route( - &self, - instance_id: SharedWorkerInstanceId, - ) -> Option { - self.running_host_for_instance(instance_id) - } } impl WeakSharedWorkerRuntimeService { diff --git a/moli-renderer-v8/src/shared_worker_runtime/worker_close.rs b/moli-renderer-v8/src/shared_worker_runtime/worker_close.rs index fab0a2ab0a5..b6a175769a8 100644 --- a/moli-renderer-v8/src/shared_worker_runtime/worker_close.rs +++ b/moli-renderer-v8/src/shared_worker_runtime/worker_close.rs @@ -80,7 +80,7 @@ mod tests { let (tx, mut rx) = crate::runtime::renderer_output_transport_channel(); host.target_output().bind_transport(tx); - host.publish_created_target_event(); + host.publish_created_target_event(None); host.publish_destroyed_target_event(); host.publish_destroyed_target_event(); diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs index 673c6c6283c..9d9acd18da4 100644 --- a/moli-renderer-v8/src/types.rs +++ b/moli-renderer-v8/src/types.rs @@ -114,30 +114,6 @@ pub(super) enum PendingSubresourceContinuation { WebSocket(PendingWebSocketConnection), /// A child frame navigation held before its request leaves the renderer. ChildDocument(Box), - WorkerFetch { - worker_id: DedicatedWorkerId, - fetch_id: u32, - }, - WorkerXhr { - worker_id: DedicatedWorkerId, - xhr_id: u32, - }, - WorkerCspReport { - worker_id: DedicatedWorkerId, - report_id: u32, - }, - SharedWorkerFetch { - instance_id: moli_shared_worker::SharedWorkerInstanceId, - fetch_id: u32, - }, - SharedWorkerXhr { - instance_id: moli_shared_worker::SharedWorkerInstanceId, - xhr_id: u32, - }, - SharedWorkerCspReport { - instance_id: moli_shared_worker::SharedWorkerInstanceId, - report_id: u32, - }, } #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] @@ -183,15 +159,6 @@ impl PendingSubresourceContinuation { ) } - pub(super) fn dedicated_worker_id(&self) -> Option { - match self { - Self::WorkerFetch { worker_id, .. } - | Self::WorkerXhr { worker_id, .. } - | Self::WorkerCspReport { worker_id, .. } => Some(*worker_id), - _ => None, - } - } - pub(super) fn stylesheet_subresource_owner( &self, ) -> Option { @@ -653,14 +620,6 @@ pub(super) struct RunningSubresourceFetchState { pub(super) initial_auth_network_request_headers: Option>, } -pub(super) struct InFlightWorkerSubresourceFetchState { - pub(super) pending: PendingSubresourceFetchState, - pub(super) request_url: Url, - pub(super) request_method: String, - pub(super) request_headers: moli_fetch::RequestHeaders, - pub(super) request_body: Option, -} - #[derive(Debug)] pub(super) struct AsyncSubresourceFetchCompletion { pub(super) internal_id: u64, diff --git a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs index 71a3fcb3d76..c61203985b7 100644 --- a/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs +++ b/moli-renderer-v8/src/worker/global_scope/content_security_policy.rs @@ -3,38 +3,22 @@ use std::rc::Rc; use url::Url; -use crate::RendererSyntheticResponseBody; use crate::content_security_policy::{ ContentSecurityPolicyDisposition, ContentSecurityPolicyRedirectStatus, ContentSecurityPolicyResourceKind, ContentSecurityPolicyUrlViolation, ContentSecurityPolicyViolationEventFields, content_security_policy_report_requests, content_security_policy_trusted_types_sink_violation_with_disposition_and_reporting_endpoints, - content_security_policy_url_violation_for_checked_url_with_redirect_status_disposition_and_reporting_endpoints, content_security_policy_url_violation_with_redirect_status_disposition_and_reporting_endpoints, create_security_policy_violation_event, send_content_security_policy_reports, }; use crate::context_bootstrap::dispatch_simple_event_target_event; -use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind, ResourceLoadLease}; -use crate::protocol_types::{ - PendingSubresourceContinueEvent, PendingSubresourceFetchInfo, SubresourceNetworkRecord, - SubresourceNetworkRequestHandle, SubresourceResponseBody, -}; -use crate::service_worker_runtime::{ - ServiceWorkerDirectFetchResult, ServiceWorkerFetchDispatch, ServiceWorkerFetchRequest, - ServiceWorkerRequestDestination, service_worker_fetch_request_metadata, -}; -use crate::types::{AsyncSubresourceNetworkContext, SubresourceResourceType}; -use crate::worker::handle::WorkerPendingSubresourceFetch; -use crate::worker::{WorkerPendingFetchContinue, WorkerToParentMessage}; -use moli_fetch::{ - BrowserRequestMetadata, FetchCancelHandle, Request, RequestResourceType, - should_request_be_blocked_due_to_bad_port, -}; +use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind}; +use crate::protocol_types::PendingSubresourceFetchInfo; +use crate::service_worker_runtime::service_worker_fetch_request_metadata; +use crate::types::SubresourceResourceType; +use moli_fetch::{BrowserRequestMetadata, Request}; -use super::{ - PendingWorkerCspReport, WorkerGlobalState, get_worker_state, next_fetch_id, - record_worker_subresource_failure_with_handle, request_body_text, -}; +use super::{WorkerGlobalState, get_worker_state, request_body_text}; pub(super) fn dispatch_worker_content_security_policy_violation_event<'s>( scope: &mut v8::PinScope<'s, '_>, @@ -127,640 +111,73 @@ fn send_worker_content_security_policy_report_for_state( if !matches!(request.url.scheme(), "http" | "https") { return; } - let request_body = request_body_text(&request.body); - let Some(( - document_url, - loader, - network_partition_key, - policy_context, - service_worker_runtime, - service_worker_client_id, - )) = worker_content_security_policy_report_context(state) - else { - return; + let (loader, document_url, partition, policy_context, runtime, client_id) = { + let state = state.borrow(); + let Some(document_url) = state.current_script_url.clone() else { + return; + }; + ( + state.loader.clone(), + document_url, + state.network_partition_key.clone(), + state.policy_context, + state.service_worker_runtime.clone(), + state.service_worker_client_id, + ) }; let request = request .with_initiator_url(&document_url) .with_request_origin(moli_url::WebOrigin::from_url(&document_url)) - .with_network_partition_key(network_partition_key.clone()) + .with_network_partition_key(partition) .with_browser_request_metadata(BrowserRequestMetadata::Fetch); + let cancel = moli_fetch::FetchCancelHandle::new(); let Some(load) = loader.register_load( ResourceLoadKind::CspReport, ResourceLoadDisposition::Keepalive, - None, + Some(cancel.clone()), ) else { - record_worker_content_security_policy_report_failure( - state, - None, - None, - document_url, - request, - request_body, - "csp report: worker global is shutting down".to_owned(), - ); return; }; - - if should_request_be_blocked_due_to_bad_port(&request.url) { - let message = format!("csp report: blocked bad port for `{}`", request.url); - record_worker_content_security_policy_report_failure( - state, - None, - None, - document_url, - request, - request_body, - message, - ); - return; - } - if load.blocks_url(&request.url) { - record_worker_content_security_policy_report_failure( - state, - None, - None, - document_url, - request, - request_body, - crate::network_host::BLOCKED_BY_CLIENT_ERROR_TEXT.to_owned(), - ); - return; - } - - if should_intercept_worker_content_security_policy_report(state) { - pause_worker_content_security_policy_report_for_fetch_interception( - state, - load, - policy_context, - service_worker_runtime, - service_worker_client_id, - document_url, - request, - request_body, - ); - return; - } - - if load.network_offline() { - record_worker_content_security_policy_report_failure( - state, - None, - None, - document_url, - request, - request_body, - "Network emulation offline".to_owned(), - ); - return; - } - - if let (Some(runtime), Some(client_id)) = (service_worker_runtime, service_worker_client_id) - && runtime - .matching_controller_for_client_fetch(client_id, &request.url) - .is_some() - { - dispatch_worker_content_security_policy_report_to_service_worker( - state.borrow().parent_tx.clone(), - runtime, - client_id, - load, - policy_context, - None, - None, - document_url, - request, - request_body, - ); - return; - } - - spawn_worker_content_security_policy_report_network( - state.borrow().parent_tx.clone(), - load, - None, - None, - document_url, - request, - request_body, - ); -} - -fn should_intercept_worker_content_security_policy_report( - state: &Rc>, -) -> bool { - let state = state.borrow(); - state - .subresource_interception_config() - .intercepts(SubresourceResourceType::CspReport) -} - -fn pause_worker_content_security_policy_report_for_fetch_interception( - state: &Rc>, - load: ResourceLoadLease, - policy_context: crate::types::SubresourcePolicyContext, - service_worker_runtime: Option, - service_worker_client_id: Option, - document_url: Url, - request: Request, - request_body: Option, -) { - let request_body_bytes = request.body.clone(); let info = PendingSubresourceFetchInfo { - internal_id: 0, - network_request_handle: None, + internal_id: crate::network::interception_control::next_subresource_request_id(), + network_request_handle: Some( + crate::network::interception_control::next_subresource_network_handle(), + ), frame_id: None, - document_url: document_url.clone(), + document_url, url: request.url.clone(), websocket_socket_id: None, method: request.method.clone(), - request_headers: request.request_headers.clone(), - request_body: request_body.clone(), - request_body_bytes, + request_headers: request.interception_request_headers(), + request_body: request_body_text(&request.body), + request_body_bytes: request.body.clone(), resource_type: SubresourceResourceType::CspReport, request_cookie_report: None, }; - let mut state = state.borrow_mut(); - let report_id = next_fetch_id(&mut state); - let network_partition_key = request.network_partition_key().map(str::to_owned); - let credentials_mode = request.credentials_mode; - let request_mode = request.request_mode; - state.pending_csp_reports.insert( - report_id, - PendingWorkerCspReport { - load: load.clone(), - document_url, + let interception = state + .borrow() + .interception_context + .clone() + .expect("Worker resource output"); + let metadata = service_worker_fetch_request_metadata(&request); + let runner = load.task_runner(); + runner.spawn(async move { + crate::network_host::controlled_xhr::ControlledResourceLoad::for_stylesheet( + interception, request, - request_body, - policy_context, - service_worker_runtime, - service_worker_client_id, - }, - ); - let _ = state - .parent_tx - .send(WorkerToParentMessage::PendingSubresourceFetch( - WorkerPendingSubresourceFetch { - fetch_id: report_id, - load, - credentials_mode, - request_mode, - network_partition_key, - info, - }, - )); -} - -type WorkerContentSecurityPolicyReportContext = ( - Url, - crate::network::context::WorkerResourceLoader, - Option, - crate::types::SubresourcePolicyContext, - Option, - Option, -); - -fn worker_content_security_policy_report_context( - state: &Rc>, -) -> Option { - let state = state.borrow(); - Some(( - state.current_script_url.clone()?, - state.loader.clone(), - state.network_partition_key.clone(), - state.policy_context, - state.service_worker_runtime.clone(), - state.service_worker_client_id, - )) -} - -#[allow(clippy::too_many_arguments)] -fn dispatch_worker_content_security_policy_report_to_service_worker( - parent_tx: tokio::sync::mpsc::UnboundedSender, - runtime: crate::service_worker_runtime::ServiceWorkerRuntimeService, - client_id: crate::service_worker_runtime::ServiceWorkerClientId, - load: ResourceLoadLease, - policy_context: crate::types::SubresourcePolicyContext, - request_handle: Option, - continue_internal_id: Option, - document_url: Url, - request: Request, - request_body: Option, -) { - let internal_id = load.id_for_diagnostics(); - let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); - let cancel_handle = FetchCancelHandle::new(); - load.attach_cancel_handle(cancel_handle.clone()); - let request_metadata = service_worker_fetch_request_metadata(&request); - let dispatch = ServiceWorkerFetchDispatch { - internal_id, - request: ServiceWorkerFetchRequest { - client_id, - resulting_client_id: None, - url: request.url.clone(), - method: request.method.clone(), - headers: request.request_headers.to_byte_strings(), - body: request.body.clone(), - destination: ServiceWorkerRequestDestination::Report, - request_mode: request.request_mode, - credentials_mode: request.credentials_mode, - redirect_mode: request.redirect_mode(), - priority: request.priority_hints.fetch_priority, - is_reload: false, - metadata: request_metadata, - }, - cors_preflight_request_headers: Vec::new(), - request_cookie_report: None, - network_context: AsyncSubresourceNetworkContext { - frame_id: None, - request_origin: moli_url::WebOrigin::from_url(&document_url), - document_url: document_url.clone(), - resource_type: SubresourceResourceType::CspReport, - policy_context, - }, - completion_tx: - crate::page_task_queue::RendererResourceCompletionSender::direct_completion_only(), - request_client: load.request_client(), - resource_task_runner: load.task_runner(), - cancel_handle, - direct_completion_tx: Some(direct_completion_tx), - }; - - if !runtime.dispatch_controlled_fetch(dispatch) { - load.finish(); - send_worker_content_security_policy_report_failure( - parent_tx, - request_handle, - continue_internal_id, - document_url, - request, - request_body, - "service worker csp report fetch dispatch failed".to_owned(), - ); - return; - } - - let task_runner = load.task_runner(); - task_runner.spawn(async move { - match direct_completion_rx.await { - Ok(ServiceWorkerDirectFetchResult::Fallback) => { - spawn_worker_content_security_policy_report_network( - parent_tx, - load, - request_handle, - continue_internal_id, - document_url, - request, - request_body, - ); - } - Ok(ServiceWorkerDirectFetchResult::Response(response)) => { - let response: moli_fetch::Response = (*response.response).into(); - let head = response.head(); - let body = SubresourceResponseBody::from_fetch_response(&response); - load.finish(); - send_worker_content_security_policy_report_success( - parent_tx, - request_handle, - continue_internal_id, - document_url, - request, - request_body, - head, - body, - ); - } - Ok(ServiceWorkerDirectFetchResult::Failure(message)) => { - load.finish(); - send_worker_content_security_policy_report_failure( - parent_tx, - request_handle, - continue_internal_id, - document_url, - request, - request_body, - message, - ); - } - Err(_) => { - load.finish(); - send_worker_content_security_policy_report_failure( - parent_tx, - request_handle, - continue_internal_id, - document_url, - request, - request_body, - "service worker csp report fetch completion channel closed".to_owned(), - ); - } - } + info, + load, + cancel, + crate::types::SubresourceRequestInitiatorType::Script, + ) + .with_fetch_policy(policy_context) + .with_service_worker(runtime, client_id, metadata) + .run() + .await; }); } -fn spawn_worker_content_security_policy_report_network( - parent_tx: tokio::sync::mpsc::UnboundedSender, - load: ResourceLoadLease, - request_handle: Option, - continue_internal_id: Option, - document_url: Url, - request: Request, - request_body: Option, -) { - let callback_document_url = document_url.clone(); - let callback_request = request.clone(); - let callback_request_body = request_body.clone(); - let callback_load = load.clone(); - let callback_parent_tx = parent_tx.clone(); - if let Err(error) = load - .request_client() - .fetch_text_callback(request.clone(), move |result| { - callback_load.finish(); - match result { - Ok(response) => { - let head = response.head(); - let body = SubresourceResponseBody::from_fetch_response(&response); - send_worker_content_security_policy_report_success( - callback_parent_tx, - request_handle, - continue_internal_id, - callback_document_url, - callback_request, - callback_request_body, - head, - body, - ); - } - Err(error) => send_worker_content_security_policy_report_failure( - callback_parent_tx, - request_handle, - continue_internal_id, - callback_document_url, - callback_request, - callback_request_body, - format!("csp report: {error}"), - ), - } - }) - { - load.finish(); - send_worker_content_security_policy_report_failure( - parent_tx, - request_handle, - continue_internal_id, - document_url, - request, - request_body, - format!("csp report: {error}"), - ); - } -} - -pub(in crate::worker) fn continue_pending_worker_csp_report( - state: &Rc>, - continuation: WorkerPendingFetchContinue, -) { - let Some(pending) = state - .borrow_mut() - .pending_csp_reports - .remove(&continuation.fetch_id) - else { - return; - }; - let request_body = request_body_text(&continuation.body); - let request = match Request::new_bytes( - &continuation.method, - continuation.url.as_str(), - continuation.body.clone(), - continuation.headers.clone(), - ) { - Ok(request) => request - .with_redirect_headers(continuation.redirect_headers) - .with_initiator_url(&pending.document_url) - .with_request_origin(moli_url::WebOrigin::from_url(&pending.document_url)) - .with_resource_type(RequestResourceType::CspReport) - .with_request_mode(pending.request.request_mode) - .with_credentials_mode(pending.request.credentials_mode) - .with_redirect_mode(pending.request.redirect_mode()) - .with_network_partition_key(pending.request.network_partition_key().map(str::to_owned)) - .with_browser_request_metadata(BrowserRequestMetadata::Fetch), - Err(error) => { - record_worker_content_security_policy_report_failure( - state, - continuation.network_request_handle, - Some(continuation.internal_id), - pending.document_url, - pending.request, - pending.request_body, - format!("csp report: {error}"), - ); - return; - } - }; - - let parent_tx = state.borrow().parent_tx.clone(); - let document_url = pending.document_url; - let load = pending.load; - let policy_context = pending.policy_context; - let service_worker_runtime = pending.service_worker_runtime; - let service_worker_client_id = pending.service_worker_client_id; - - if should_request_be_blocked_due_to_bad_port(&request.url) { - let message = format!("csp report: blocked bad port for `{}`", request.url); - record_worker_content_security_policy_report_failure( - state, - continuation.network_request_handle, - Some(continuation.internal_id), - document_url, - request, - request_body, - message, - ); - return; - } - if load.blocks_url(&request.url) { - record_worker_content_security_policy_report_failure( - state, - continuation.network_request_handle, - Some(continuation.internal_id), - document_url, - request, - request_body, - crate::network_host::BLOCKED_BY_CLIENT_ERROR_TEXT.to_owned(), - ); - return; - } - if load.network_offline() { - record_worker_content_security_policy_report_failure( - state, - continuation.network_request_handle, - Some(continuation.internal_id), - document_url, - request, - request_body, - "Network emulation offline".to_owned(), - ); - return; - } - - if let (Some(runtime), Some(client_id)) = (service_worker_runtime, service_worker_client_id) - && runtime - .matching_controller_for_client_fetch(client_id, &request.url) - .is_some() - { - dispatch_worker_content_security_policy_report_to_service_worker( - parent_tx, - runtime, - client_id, - load, - policy_context, - continuation.network_request_handle, - Some(continuation.internal_id), - document_url, - request, - request_body, - ); - return; - } - - spawn_worker_content_security_policy_report_network( - parent_tx, - load, - continuation.network_request_handle, - Some(continuation.internal_id), - document_url, - request, - request_body, - ); -} - -pub(in crate::worker) fn fail_pending_worker_csp_report( - state: &Rc>, - continuation: WorkerPendingFetchContinue, - _error_text: String, -) { - state - .borrow_mut() - .pending_csp_reports - .remove(&continuation.fetch_id); -} - -pub(in crate::worker) fn fulfill_pending_worker_csp_report( - state: &Rc>, - continuation: WorkerPendingFetchContinue, - _response_code: u16, - _response_headers: Vec<(String, Vec)>, - _response_body: RendererSyntheticResponseBody, -) { - state - .borrow_mut() - .pending_csp_reports - .remove(&continuation.fetch_id); -} - -fn record_worker_content_security_policy_report_failure( - state: &Rc>, - request_handle: Option, - continue_internal_id: Option, - document_url: Url, - request: Request, - request_body: Option, - message: String, -) { - let state = state.borrow(); - record_worker_subresource_failure_with_handle( - &state, - request_handle, - document_url, - request.url, - request.method, - request.request_headers.clone(), - request_body.map(bytes::Bytes::from), - SubresourceResourceType::CspReport, - message, - ); - send_worker_content_security_policy_report_continue_completed( - &state.parent_tx, - continue_internal_id, - ); -} - -fn send_worker_content_security_policy_report_success( - parent_tx: tokio::sync::mpsc::UnboundedSender, - request_handle: Option, - continue_internal_id: Option, - document_url: Url, - request: Request, - request_body: Option, - head: moli_fetch::ResponseHead, - body: SubresourceResponseBody, -) { - let mut record = SubresourceNetworkRecord::success_with_body( - None, - document_url, - request.url, - request.method, - request.request_headers.clone(), - request_body, - SubresourceResourceType::CspReport, - head.request_cookie_report.clone(), - head.redirect_chain - .clone() - .into_iter() - .map(Into::into) - .collect(), - head.final_url.clone(), - head.status, - head.headers.clone(), - body, - head.cookie_set_reports.clone(), - ) - .with_from_cache(head.from_cache) - .with_negotiated_http_version(head.negotiated_http_version); - if let Some(handle) = request_handle { - record = record.with_request_handle(handle); - } - let _ = parent_tx.send(WorkerToParentMessage::SubresourceNetwork(record)); - send_worker_content_security_policy_report_continue_completed(&parent_tx, continue_internal_id); -} - -fn send_worker_content_security_policy_report_failure( - parent_tx: tokio::sync::mpsc::UnboundedSender, - request_handle: Option, - continue_internal_id: Option, - document_url: Url, - request: Request, - request_body: Option, - message: String, -) { - let mut record = SubresourceNetworkRecord::failure( - None, - document_url, - request.url, - request.method, - request.request_headers.clone(), - request_body, - SubresourceResourceType::CspReport, - message, - ); - if let Some(handle) = request_handle { - record = record.with_request_handle(handle); - } - let _ = parent_tx.send(WorkerToParentMessage::SubresourceNetwork(record)); - send_worker_content_security_policy_report_continue_completed(&parent_tx, continue_internal_id); -} - -fn send_worker_content_security_policy_report_continue_completed( - parent_tx: &tokio::sync::mpsc::UnboundedSender, - continue_internal_id: Option, -) { - let Some(internal_id) = continue_internal_id else { - return; - }; - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { internal_id }, - )); -} - +#[allow(clippy::too_many_arguments)] pub(super) fn worker_content_security_policy_violation( state: &WorkerGlobalState, protected_url: &Url, @@ -794,26 +211,6 @@ pub(super) fn worker_content_security_policy_violation_with_redirect_status( ) } -pub(super) fn worker_content_security_policy_violation_for_checked_url_with_redirect_status( - state: &WorkerGlobalState, - protected_url: &Url, - checked_url: &Url, - blocked_url: &Url, - kind: ContentSecurityPolicyResourceKind, - redirect_status: ContentSecurityPolicyRedirectStatus, -) -> Option { - content_security_policy_url_violation_for_checked_url_with_redirect_status_disposition_and_reporting_endpoints( - &state.content_security_policies, - protected_url, - checked_url, - blocked_url, - kind, - redirect_status, - ContentSecurityPolicyDisposition::Enforce, - &state.content_security_reporting_endpoints, - ) -} - pub(super) fn worker_content_security_policy_report_only_violation( state: &WorkerGlobalState, protected_url: &Url, @@ -847,26 +244,6 @@ pub(super) fn worker_content_security_policy_report_only_violation_with_redirect ) } -pub(super) fn worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status( - state: &WorkerGlobalState, - protected_url: &Url, - checked_url: &Url, - blocked_url: &Url, - kind: ContentSecurityPolicyResourceKind, - redirect_status: ContentSecurityPolicyRedirectStatus, -) -> Option { - content_security_policy_url_violation_for_checked_url_with_redirect_status_disposition_and_reporting_endpoints( - &state.content_security_report_only_policies, - protected_url, - checked_url, - blocked_url, - kind, - redirect_status, - ContentSecurityPolicyDisposition::Report, - &state.content_security_reporting_endpoints, - ) -} - pub(super) fn dispatch_worker_content_security_policy_report_only_violation_for_state<'s>( scope: &mut v8::PinScope<'s, '_>, state: &Rc>, @@ -909,33 +286,6 @@ pub(super) fn dispatch_worker_content_security_policy_report_only_violation_with } } -pub(super) fn dispatch_worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status_for_state< - 's, ->( - scope: &mut v8::PinScope<'s, '_>, - state: &Rc>, - protected_url: &Url, - checked_url: &Url, - blocked_url: &Url, - kind: ContentSecurityPolicyResourceKind, - redirect_status: ContentSecurityPolicyRedirectStatus, -) { - let violation = { - let state_ref = state.borrow(); - worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status( - &state_ref, - protected_url, - checked_url, - blocked_url, - kind, - redirect_status, - ) - }; - if let Some(violation) = violation { - dispatch_worker_content_security_policy_violation_event_for_state(scope, state, &violation); - } -} - pub(super) fn worker_content_security_policy_error_message( violation: &ContentSecurityPolicyUrlViolation, operation: &'static str, diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index 2b6b063be98..d643217ed72 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -1,11 +1,8 @@ use super::*; +mod native_load; use crate::network_host::{FetchArgumentError, combined_headers_entries, convert_fetch_arguments}; -use crate::service_worker_runtime::{ - ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerFetchDispatch, - ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination, - ServiceWorkerRuntimeService, -}; -use crate::types::{AsyncSubresourceNetworkContext, SubresourcePolicyContext}; +use crate::service_worker_runtime::ServiceWorkerFetchRequestMetadata; +use crate::types::SubresourcePolicyContext; pub(in crate::worker) fn record_worker_subresource_failure( state: &WorkerGlobalState, @@ -55,266 +52,9 @@ pub(in crate::worker) fn record_worker_subresource_failure_with_handle( if let Some(handle) = request_handle { record = record.with_request_handle(handle); } - let _ = state - .parent_tx - .send(WorkerToParentMessage::SubresourceNetwork(record)); -} - -pub(in crate::worker) fn record_worker_subresource_success_with_handle( - state: &WorkerGlobalState, - request_handle: Option, - document_url: Url, - url: Url, - method: String, - request_headers: moli_fetch::RequestHeaders, - request_body_bytes: Option, - resource_type: SubresourceResourceType, - network_request_headers: Option>, - head: ResponseHead, - body: SubresourceResponseBody, -) { - let mut record = SubresourceNetworkRecord::success_with_body( - None, - document_url, - url, - method, - request_headers, - request_body_text(&request_body_bytes), - resource_type, - head.request_cookie_report.clone(), - head.redirect_chain - .clone() - .into_iter() - .map(Into::into) - .collect(), - head.final_url.clone(), - head.status, - head.headers.clone(), - body, - head.cookie_set_reports.clone(), - ) - .with_request_body_bytes(request_body_bytes) - .with_from_cache(head.from_cache) - .with_negotiated_http_version(head.negotiated_http_version) - .with_network_request_headers(network_request_headers); - if let Some(handle) = request_handle { - record = record.with_request_handle(handle); + if let Some(output) = &state.interception_context { + output.record_subresource_network(record); } - let _ = state - .parent_tx - .send(WorkerToParentMessage::SubresourceNetwork(record)); -} - -fn worker_network_result_parts( - observed: moli_fetch::NetworkFetchResult, -) -> (R, Option>) { - let (response, request_observation) = observed.into_parts(); - ( - response, - request_observation.map(|observation| observation.into_headers()), - ) -} - -pub(in crate::worker) fn spawn_worker_fetch_network( - load: ResourceLoadLease, - completion_tx: mpsc::UnboundedSender, - fetch_id: u32, - cancel_handle: FetchCancelHandle, - document_url: Url, - referrer_policy: Option, - network_partition_key: Option, - resolved_url: Url, - method: String, - body: Option, - headers: moli_fetch::RequestHeaders, - request_mode: RequestMode, - credentials_mode: RequestCredentialsMode, - redirect_mode: RequestRedirectMode, - priority: Option, - request_metadata: ServiceWorkerFetchRequestMetadata, - auth: Option, - allow_headers_first: bool, - redirect_headers: Option, - redirect_chain: Vec, -) { - tokio::task::spawn_local(async move { - let loader = load.request_client(); - let (result, network_request_headers) = if let Err(error) = - moli_fetch::FetchUrlList::new(&resolved_url, &[]) - .validate_request_mode(request_mode, &moli_url::WebOrigin::from_url(&document_url)) - { - (Err(error.to_string()), None) - } else if let Some(result) = local_url_response_result(&resolved_url, &method) { - ( - result - .map(|response| WorkerFetchResponse::Materialized(Box::new(response))) - .map_err(|error| format!("fetch: {error}")), - None, - ) - } else { - let cors_preflight_request_headers = headers.to_byte_strings(); - match Request::new_browser_bytes( - &method, - resolved_url.as_str(), - body, - headers.clone(), - moli_url::WebOrigin::from_url(&document_url), - ) - .and_then(|request| request.with_fetch_referrer(&request_metadata.referrer)) - { - Ok(request) => { - let cache_mode = request_metadata - .cache - .parse::() - .unwrap_or_default(); - let mut request = request - .with_redirect_headers(redirect_headers) - .with_redirect_chain(redirect_chain) - .with_initiator_url(&document_url) - .with_request_mode(request_mode) - .with_credentials_mode(credentials_mode) - .with_redirect_mode(redirect_mode) - .with_cache_mode(cache_mode) - .with_fetch_priority_hint(priority) - .with_network_partition_key(network_partition_key.clone()) - .with_browser_request_metadata(BrowserRequestMetadata::Fetch); - if let Some(metadata) = - worker_fetch_script_metadata(referrer_policy, &request_metadata) - { - request = request.with_script_fetch_metadata(metadata); - } - if let Some(auth) = auth { - request = request.with_auth(auth.into()); - } - if request.auth_requires_buffered_transport() - || request.request_mode == RequestMode::NoCors - || !request.transport_follows_redirects() - || browser_request_needs_manual_preflight_redirects( - &request, - &cors_preflight_request_headers, - ) - { - match fetch_browser_subresource_with_preflight_headers_and_network_metadata( - loader.clone(), - request, - Some(cancel_handle), - cors_preflight_request_headers, - ) - .await - { - Ok(observed) => { - let (response, network_request_headers) = - worker_network_result_parts(observed); - ( - Ok(WorkerFetchResponse::Materialized(Box::new(response))), - network_request_headers, - ) - } - Err(error) => (Err(format!("fetch: {error}")), None), - } - } else if !allow_headers_first { - // Worker fetch still resolves after the full response, but ordinary - // transfers can keep their body in the same chunked/pooled carrier that - // CDP Network capture uses instead of forcing a single buffered Response. - match fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata( - &loader, - request, - Some(cancel_handle), - cors_preflight_request_headers, - ) - .await - { - Ok(observed) => { - let (mut response, network_request_headers) = - worker_network_result_parts(observed); - let head = response.head(); - let mut body_writer = - SubresourceResponseBodyWriter::with_disk_pool( - loader.disk_pool(), - ); - while let Some(chunk) = response.next_chunk().await { - body_writer.append(&chunk); - } - let result = match response.finish().await { - Ok(()) => Ok(WorkerFetchResponse::Streamed { - head: Box::new(head), - body: body_writer.finish(), - }), - Err(error) => Err(format!("fetch: {error}")), - }; - (result, network_request_headers) - } - Err(error) => (Err(format!("fetch: {error}")), None), - } - } else { - match fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata( - &loader, - request, - Some(cancel_handle), - cors_preflight_request_headers, - ) - .await - { - Ok(observed) => { - let (mut response, network_request_headers) = - worker_network_result_parts(observed); - let body_source_id = - crate::network_host::new_network_body_source_id(); - let head = response.head(); - let _ = completion_tx.send(WorkerFetchEvent::StreamingStarted( - WorkerFetchStreamingStarted { - fetch_id, - body_source_id, - head: head.clone(), - network_request_headers, - }, - )); - let mut body_writer = - SubresourceResponseBodyWriter::with_disk_pool( - loader.disk_pool(), - ); - while let Some(chunk) = response.next_chunk().await { - body_writer.append(&chunk); - let _ = completion_tx.send(WorkerFetchEvent::StreamingChunk( - WorkerFetchStreamingChunk { - body_source_id, - bytes: chunk, - }, - )); - } - let result = response - .finish() - .await - .map(|()| body_writer.finish()) - .map_err(|error| format!("fetch: {error}")); - let _ = completion_tx.send(WorkerFetchEvent::StreamingFinished( - WorkerFetchStreamingFinished { - fetch_id, - body_source_id, - head, - result, - }, - )); - return; - } - Err(error) => (Err(format!("fetch: {error}")), None), - } - } - } - Err(error) => ( - Err(format!("fetch: failed to build request: {error}")), - None, - ), - } - }; - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers, - result, - }, - ))); - }); } fn worker_fetch_script_metadata( @@ -336,917 +76,7 @@ fn worker_fetch_script_metadata( }) } -fn worker_service_worker_controller( - state: &WorkerGlobalState, - resolved_url: &Url, -) -> Option<(ServiceWorkerRuntimeService, ServiceWorkerClientId)> { - if !matches!(resolved_url.scheme(), "http" | "https") { - return None; - } - let runtime = state.service_worker_runtime.clone()?; - let client_id = state.service_worker_client_id?; - runtime.matching_controller_for_client_fetch(client_id, resolved_url)?; - Some((runtime, client_id)) -} - #[allow(clippy::too_many_arguments)] -fn spawn_worker_fetch_service_worker( - runtime: ServiceWorkerRuntimeService, - client_id: ServiceWorkerClientId, - load: ResourceLoadLease, - completion_tx: mpsc::UnboundedSender, - fetch_id: u32, - cancel_handle: FetchCancelHandle, - document_url: Url, - referrer_policy: Option, - network_partition_key: Option, - policy_context: SubresourcePolicyContext, - resolved_url: Url, - method: String, - body: Option, - headers: moli_fetch::RequestHeaders, - request_mode: RequestMode, - credentials_mode: RequestCredentialsMode, - redirect_mode: RequestRedirectMode, - priority: Option, - request_metadata: ServiceWorkerFetchRequestMetadata, -) { - let (direct_completion_tx, direct_completion_rx) = tokio::sync::oneshot::channel(); - let dispatch = ServiceWorkerFetchDispatch { - internal_id: u64::from(fetch_id), - request: ServiceWorkerFetchRequest { - client_id, - resulting_client_id: None, - url: resolved_url.clone(), - method: method.clone(), - headers: headers.to_byte_strings(), - body: body.clone(), - destination: ServiceWorkerRequestDestination::Empty, - request_mode, - credentials_mode, - redirect_mode, - priority, - is_reload: false, - metadata: request_metadata.clone(), - }, - cors_preflight_request_headers: headers.to_byte_strings(), - request_cookie_report: None, - network_context: AsyncSubresourceNetworkContext { - frame_id: None, - request_origin: moli_url::WebOrigin::from_url(&document_url), - document_url: document_url.clone(), - resource_type: SubresourceResourceType::Fetch, - policy_context, - }, - completion_tx: - crate::page_task_queue::RendererResourceCompletionSender::direct_completion_only(), - request_client: load.request_client(), - resource_task_runner: load.task_runner(), - cancel_handle: cancel_handle.clone(), - direct_completion_tx: Some(direct_completion_tx), - }; - - if !runtime.dispatch_controlled_fetch(dispatch) { - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers: None, - result: Err("service worker fetch dispatch failed".to_owned()), - }, - ))); - return; - } - - tokio::task::spawn_local(async move { - match direct_completion_rx.await { - Ok(ServiceWorkerDirectFetchResult::Fallback) => spawn_worker_fetch_network( - load, - completion_tx, - fetch_id, - cancel_handle, - document_url, - referrer_policy, - network_partition_key, - resolved_url, - method, - body, - headers, - request_mode, - credentials_mode, - redirect_mode, - priority, - request_metadata, - None, - true, - None, - Vec::new(), - ), - Ok(ServiceWorkerDirectFetchResult::Response(response)) => { - let body = Box::new((*response.response).into()); - let response = match response.response_filter { - Some(filter) => WorkerFetchResponse::Filtered { - response: body, - filter, - }, - None => WorkerFetchResponse::Materialized(body), - }; - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers: None, - result: Ok(response), - }, - ))); - } - Ok(ServiceWorkerDirectFetchResult::Failure(message)) => { - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers: None, - result: Err(message), - }, - ))); - } - Err(_) => { - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers: None, - result: Err("service worker fetch completion channel closed".to_owned()), - }, - ))); - } - } - }); -} - -pub(in crate::worker) fn spawn_worker_xhr_network( - load: ResourceLoadLease, - completion_tx: mpsc::UnboundedSender, - xhr_id: u32, - cancel_handle: FetchCancelHandle, - document_url: Url, - referrer_policy: Option, - network_partition_key: Option, - resolved_url: Url, - method: String, - body: Option, - headers: moli_fetch::RequestHeaders, - credentials_mode: RequestCredentialsMode, - use_cors_preflight: bool, - auth: Option, - redirect_headers: Option, - redirect_chain: Vec, -) { - load.task_runner().spawn(async move { - let loader = load.request_client(); - let cors_preflight_request_headers = headers.to_byte_strings(); - let request = Request::new_browser_bytes( - &method, - resolved_url.as_str(), - body, - headers.clone(), - moli_url::WebOrigin::from_url(&document_url), - ) - .map(|request| { - let mut request = request - .with_redirect_headers(redirect_headers) - .with_redirect_chain(redirect_chain) - .with_initiator_url(&document_url) - .with_credentials_mode(credentials_mode) - .with_network_partition_key(network_partition_key.clone()) - .with_browser_request_metadata(BrowserRequestMetadata::Xhr) - .with_use_cors_preflight(use_cors_preflight); - if let Some(referrer_policy) = referrer_policy { - request = - request.with_script_fetch_metadata(moli_fetch::ScriptFetchRequestMetadata { - document_referrer_policy: Some(referrer_policy), - ..moli_fetch::ScriptFetchRequestMetadata::default() - }); - } - if let Some(auth) = auth { - request = request.with_auth(auth.into()); - } - request - }); - - let (result, network_request_headers) = match request { - Ok(request) - if request.auth_requires_buffered_transport() - || browser_request_needs_manual_preflight_redirects( - &request, - &cors_preflight_request_headers, - ) => - { - match fetch_browser_subresource_with_preflight_headers_and_network_metadata( - loader.clone(), - request, - Some(cancel_handle), - cors_preflight_request_headers, - ) - .await - { - Ok(observed) => { - let (response, network_request_headers) = - worker_network_result_parts(observed); - ( - Ok(WorkerXhrResponse::Materialized(Box::new(response))), - network_request_headers, - ) - } - Err(error) => (Err(format!("xhr: {error}")), None), - } - } - Ok(request) => { - // Ordinary worker XHR can keep the network/cache path streaming - // and pool large bodies until the XHR DONE boundary. - match fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata( - &loader, - request, - Some(cancel_handle), - cors_preflight_request_headers, - ) - .await - { - Ok(observed) => { - let (mut response, network_request_headers) = - worker_network_result_parts(observed); - let head = response.head(); - let mut body_writer = SubresourceResponseBodyWriter::with_disk_pool( - loader.disk_pool(), - ); - while let Some(chunk) = response.next_chunk().await { - body_writer.append(&chunk); - } - let result = match response.finish().await { - Ok(()) => Ok(WorkerXhrResponse::Streamed { - head: Box::new(head), - body: body_writer.finish(), - }), - Err(error) => Err(format!("xhr: {error}")), - }; - (result, network_request_headers) - } - Err(error) => (Err(format!("xhr: {error}")), None), - } - } - Err(error) => (Err(format!("xhr: failed to build request: {error}")), None), - }; - let _ = completion_tx.send(WorkerXhrCompletion { - native_record: None, - xhr_id, - network_request_headers, - result, - }); - }); -} - -pub(in crate::worker) fn continue_pending_worker_fetch( - state: &Rc>, - request: WorkerPendingFetchContinue, -) { - let redirect_chain = if request.auth.is_some() { - state - .borrow() - .pending_fetches - .get(&request.fetch_id) - .and_then(|pending| pending.paused_response.as_ref()) - .map(|response| response.head.redirect_chain.clone()) - .unwrap_or_default() - } else { - Vec::new() - }; - let redirect_headers = if !redirect_chain.is_empty() { - None - } else if request.auth.is_some() { - state - .borrow() - .pending_fetches - .get(&request.fetch_id) - .and_then(|pending| pending.network_record.as_ref()) - .and_then(|record| record.redirect_headers.clone()) - } else { - request.redirect_headers.clone() - }; - let allow_headers_first = !request.intercept_response && !request.handle_auth_requests; - let ( - load, - completion_tx, - cancel_handle, - document_url, - request_mode, - credentials_mode, - redirect_mode, - network_partition_key, - fetch_id, - resolved_url, - method, - body, - headers, - priority, - request_metadata, - auth, - ) = { - let mut state = state.borrow_mut(); - let completion_tx = state.fetch_completion_tx.clone(); - let network_partition_key = state.network_partition_key.clone(); - let Some(pending) = state.pending_fetches.get_mut(&request.fetch_id) else { - return; - }; - let cancel_handle = FetchCancelHandle::new(); - pending.load.attach_cancel_handle(cancel_handle.clone()); - pending.network_request_handle = request.network_request_handle; - let initial_network_request_headers = pending - .network_record - .as_ref() - .and_then(|record| record.initial_network_request_headers.clone()); - // Authentication retries use the challenged URL, but Network events - // still describe the original request and its complete redirect chain. - if request.auth.is_none() || pending.network_record.is_none() { - pending.network_record = Some(PendingWorkerFetchNetworkRecord { - redirect_headers: redirect_headers.clone(), - internal_id: request.internal_id, - url: request.url.clone(), - method: request.method.clone(), - request_headers: request.headers.clone(), - request_body_bytes: request.body.clone(), - initial_network_request_headers, - intercept_response: request.intercept_response, - handle_auth_requests: request.handle_auth_requests, - }); - } - ( - pending.load.clone(), - completion_tx, - cancel_handle, - pending.document_url.clone(), - pending.request_mode, - pending.credentials_mode, - pending.redirect_mode, - network_partition_key, - request.fetch_id, - request.url, - request.method, - request.body, - request.headers, - pending.request_priority, - pending.request_metadata.clone(), - request.auth, - ) - }; - - spawn_worker_fetch_network( - load, - completion_tx, - fetch_id, - cancel_handle, - document_url, - state.borrow().referrer_policy.clone(), - network_partition_key, - resolved_url, - method, - body, - headers, - request_mode, - credentials_mode, - redirect_mode, - priority, - request_metadata, - auth, - allow_headers_first, - redirect_headers, - redirect_chain, - ); -} - -pub(in crate::worker) fn fail_pending_worker_fetch( - state: &Rc>, - request: WorkerPendingFetchContinue, - error_text: String, -) { - let fetch_id = request.fetch_id; - let completion_tx = { - let mut state = state.borrow_mut(); - let completion_tx = state.fetch_completion_tx.clone(); - if let Some(pending) = state.pending_fetches.get_mut(&fetch_id) - && request.internal_id != 0 - { - pending.network_request_handle = request.network_request_handle; - pending.network_record = Some(PendingWorkerFetchNetworkRecord { - redirect_headers: None, - internal_id: request.internal_id, - url: request.url, - method: request.method, - request_headers: request.headers, - request_body_bytes: request.body, - initial_network_request_headers: None, - intercept_response: false, - handle_auth_requests: false, - }); - } - completion_tx - }; - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers: None, - result: Err(error_text), - }, - ))); -} - -pub(in crate::worker) fn fail_pending_worker_fetch_auth( - state: &Rc>, - request: WorkerPendingFetchContinue, - error_text: String, -) { - let fetch_id = request.fetch_id; - let completion_tx = { - let mut state = state.borrow_mut(); - let completion_tx = state.fetch_completion_tx.clone(); - if let Some(pending) = state.pending_fetches.get_mut(&fetch_id) { - pending.network_request_handle = request.network_request_handle; - pending.network_record = None; - pending.paused_response = None; - } - completion_tx - }; - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers: None, - result: Err(error_text), - }, - ))); -} - -pub(in crate::worker) fn fulfill_pending_worker_fetch( - state: &Rc>, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, -) { - let fetch_id = request.fetch_id; - let completion = { - let mut state = state.borrow_mut(); - let completion_tx = state.fetch_completion_tx.clone(); - let Some(pending) = state.pending_fetches.get_mut(&fetch_id) else { - return; - }; - pending.network_request_handle = request.network_request_handle; - if request.internal_id != 0 { - pending.network_record = Some(PendingWorkerFetchNetworkRecord { - redirect_headers: None, - internal_id: request.internal_id, - url: request.url.clone(), - method: request.method.clone(), - request_headers: request.headers.clone(), - request_body_bytes: request.body.clone(), - initial_network_request_headers: None, - intercept_response: false, - handle_auth_requests: false, - }); - } - let response = - worker_response_from_body(request.url, response_code, response_headers, response_body); - (completion_tx, response, fetch_id) - }; - let _ = completion.0.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id: completion.2, - network_request_headers: None, - result: Ok(WorkerFetchResponse::Materialized(Box::new(completion.1))), - }, - ))); -} - -pub(in crate::worker) fn continue_pending_worker_fetch_response( - state: &Rc>, - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, -) { - let fetch_id = request.fetch_id; - let completion = { - let mut state = state.borrow_mut(); - let completion_tx = state.fetch_completion_tx.clone(); - let Some(pending) = state.pending_fetches.get_mut(&fetch_id) else { - return; - }; - if let Some(record) = pending.network_record.as_mut() { - record.intercept_response = false; - record.handle_auth_requests = false; - } - pending.network_request_handle = request.network_request_handle; - let Some(mut response) = pending.paused_response.take() else { - return; - }; - if let Some(response_code) = response_code { - if response.head.status != response_code { - response.head.status_text = None; - } - response.head.status = response_code; - } - if let Some(response_headers) = response_headers { - response.head.headers = response_headers; - } - (completion_tx, response, fetch_id) - }; - let _ = completion.0.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id: completion.2, - network_request_headers: None, - result: Ok(WorkerFetchResponse::Streamed { - head: Box::new(completion.1.head), - body: completion.1.body, - }), - }, - ))); -} - -pub(in crate::worker) fn fail_pending_worker_fetch_response( - state: &Rc>, - request: WorkerPendingFetchContinue, - error_text: String, -) { - let fetch_id = request.fetch_id; - let completion_tx = { - let mut state = state.borrow_mut(); - let completion_tx = state.fetch_completion_tx.clone(); - let Some(pending) = state.pending_fetches.get_mut(&fetch_id) else { - return; - }; - if let Some(record) = pending.network_record.as_mut() { - record.intercept_response = false; - } - pending.network_request_handle = request.network_request_handle; - pending.network_record = None; - pending.paused_response = None; - completion_tx - }; - let _ = completion_tx.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id, - network_request_headers: None, - result: Err(error_text), - }, - ))); -} - -pub(in crate::worker) fn fulfill_pending_worker_fetch_response( - state: &Rc>, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, -) { - let fetch_id = request.fetch_id; - let completion = { - let mut state = state.borrow_mut(); - let completion_tx = state.fetch_completion_tx.clone(); - let Some(pending) = state.pending_fetches.get_mut(&fetch_id) else { - return; - }; - if let Some(record) = pending.network_record.as_mut() { - record.intercept_response = false; - record.handle_auth_requests = false; - } - pending.network_request_handle = request.network_request_handle; - let Some(mut response) = pending.paused_response.take() else { - return; - }; - response.head.status = response_code; - response.head.status_text = None; - response.head.headers = response_headers; - response.body = response_body.into_subresource_response_body(); - (completion_tx, response, fetch_id) - }; - let _ = completion.0.send(WorkerFetchEvent::Completion(Box::new( - WorkerFetchCompletion { - fetch_id: completion.2, - network_request_headers: None, - result: Ok(WorkerFetchResponse::Streamed { - head: Box::new(completion.1.head), - body: completion.1.body, - }), - }, - ))); -} - -pub(in crate::worker) fn continue_pending_worker_xhr( - state: &Rc>, - request: WorkerPendingXhrContinue, -) { - let redirect_chain = if request.auth.is_some() { - state - .borrow() - .pending_xhrs - .get(&request.xhr_id) - .and_then(|pending| pending.paused_response.as_ref()) - .map(|response| response.head.redirect_chain.clone()) - .unwrap_or_default() - } else { - Vec::new() - }; - let redirect_headers = if !redirect_chain.is_empty() { - None - } else if request.auth.is_some() { - state - .borrow() - .pending_xhrs - .get(&request.xhr_id) - .and_then(|pending| pending.network_record.as_ref()) - .and_then(|record| record.redirect_headers.clone()) - } else { - request.redirect_headers.clone() - }; - let ( - load, - completion_tx, - cancel_handle, - document_url, - network_partition_key, - credentials_mode, - use_cors_preflight, - xhr_id, - resolved_url, - method, - body, - headers, - auth, - ) = { - let mut state = state.borrow_mut(); - let completion_tx = state.xhr_completion_tx.clone(); - let network_partition_key = state.network_partition_key.clone(); - let Some(pending) = state.pending_xhrs.get_mut(&request.xhr_id) else { - return; - }; - let cancel_handle = FetchCancelHandle::new(); - pending.load.attach_cancel_handle(cancel_handle.clone()); - pending.request_paused = false; - pending.network_request_handle = request.network_request_handle; - let initial_network_request_headers = pending - .network_record - .as_ref() - .and_then(|record| record.initial_network_request_headers.clone()); - // Authentication retries use the challenged URL, but Network events - // still describe the original request and its complete redirect chain. - if request.auth.is_none() || pending.network_record.is_none() { - pending.network_record = Some(PendingWorkerFetchNetworkRecord { - redirect_headers: redirect_headers.clone(), - internal_id: request.internal_id, - url: request.url.clone(), - method: request.method.clone(), - request_headers: request.headers.clone(), - request_body_bytes: request.body.clone(), - initial_network_request_headers, - intercept_response: request.intercept_response, - handle_auth_requests: request.handle_auth_requests, - }); - } - ( - pending.load.clone(), - completion_tx, - cancel_handle, - pending.document_url.clone(), - network_partition_key, - pending.credentials_mode, - pending.use_cors_preflight, - request.xhr_id, - request.url, - request.method, - request.body, - request.headers, - request.auth, - ) - }; - - spawn_worker_xhr_network( - load, - completion_tx, - xhr_id, - cancel_handle, - document_url, - state.borrow().referrer_policy.clone(), - network_partition_key, - resolved_url, - method, - body, - headers, - credentials_mode, - use_cors_preflight, - auth, - redirect_headers, - redirect_chain, - ); -} - -pub(in crate::worker) fn fail_pending_worker_xhr( - state: &Rc>, - request: WorkerPendingXhrContinue, - error_text: String, -) { - let xhr_id = request.xhr_id; - let completion_tx = { - let mut state = state.borrow_mut(); - let completion_tx = state.xhr_completion_tx.clone(); - if let Some(pending) = state.pending_xhrs.get_mut(&xhr_id) - && request.internal_id != 0 - { - pending.request_paused = false; - pending.network_request_handle = request.network_request_handle; - pending.network_record = Some(PendingWorkerFetchNetworkRecord { - redirect_headers: None, - internal_id: request.internal_id, - url: request.url, - method: request.method, - request_headers: request.headers, - request_body_bytes: request.body, - initial_network_request_headers: None, - intercept_response: false, - handle_auth_requests: false, - }); - } - completion_tx - }; - let _ = completion_tx.send(WorkerXhrCompletion { - native_record: None, - xhr_id, - network_request_headers: None, - result: Err(error_text), - }); -} - -pub(in crate::worker) fn fail_pending_worker_xhr_auth( - state: &Rc>, - request: WorkerPendingXhrContinue, - error_text: String, -) { - let xhr_id = request.xhr_id; - let completion_tx = { - let mut state = state.borrow_mut(); - let completion_tx = state.xhr_completion_tx.clone(); - if let Some(pending) = state.pending_xhrs.get_mut(&xhr_id) { - pending.request_paused = false; - pending.network_request_handle = request.network_request_handle; - pending.network_record = None; - pending.paused_response = None; - } - completion_tx - }; - let _ = completion_tx.send(WorkerXhrCompletion { - native_record: None, - xhr_id, - network_request_headers: None, - result: Err(error_text), - }); -} - -pub(in crate::worker) fn fulfill_pending_worker_xhr( - state: &Rc>, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, -) { - let xhr_id = request.xhr_id; - let completion = { - let mut state = state.borrow_mut(); - let completion_tx = state.xhr_completion_tx.clone(); - let Some(pending) = state.pending_xhrs.get_mut(&xhr_id) else { - return; - }; - pending.request_paused = false; - pending.network_request_handle = request.network_request_handle; - if request.internal_id != 0 { - pending.network_record = Some(PendingWorkerFetchNetworkRecord { - redirect_headers: None, - internal_id: request.internal_id, - url: request.url.clone(), - method: request.method.clone(), - request_headers: request.headers.clone(), - request_body_bytes: request.body.clone(), - initial_network_request_headers: None, - intercept_response: false, - handle_auth_requests: false, - }); - } - let response = - worker_response_from_body(request.url, response_code, response_headers, response_body); - (completion_tx, response, xhr_id) - }; - let _ = completion.0.send(WorkerXhrCompletion { - native_record: None, - xhr_id: completion.2, - network_request_headers: None, - result: Ok(WorkerXhrResponse::Materialized(Box::new(completion.1))), - }); -} - -pub(in crate::worker) fn continue_pending_worker_xhr_response( - state: &Rc>, - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, -) { - let xhr_id = request.xhr_id; - let completion = { - let mut state = state.borrow_mut(); - let completion_tx = state.xhr_completion_tx.clone(); - let Some(pending) = state.pending_xhrs.get_mut(&xhr_id) else { - return; - }; - if let Some(record) = pending.network_record.as_mut() { - record.intercept_response = false; - } - pending.network_request_handle = request.network_request_handle; - pending.network_record = None; - let Some(mut response) = pending.paused_response.take() else { - return; - }; - if let Some(response_code) = response_code { - if response.head.status != response_code { - response.head.status_text = None; - } - response.head.status = response_code; - } - if let Some(response_headers) = response_headers { - response.head.headers = response_headers; - } - (completion_tx, response, xhr_id) - }; - let _ = completion.0.send(WorkerXhrCompletion { - native_record: None, - xhr_id: completion.2, - network_request_headers: None, - result: Ok(WorkerXhrResponse::Streamed { - head: Box::new(completion.1.head), - body: completion.1.body, - }), - }); -} - -pub(in crate::worker) fn fail_pending_worker_xhr_response( - state: &Rc>, - request: WorkerPendingXhrContinue, - error_text: String, -) { - let xhr_id = request.xhr_id; - let completion_tx = { - let mut state = state.borrow_mut(); - let completion_tx = state.xhr_completion_tx.clone(); - let Some(pending) = state.pending_xhrs.get_mut(&xhr_id) else { - return; - }; - if let Some(record) = pending.network_record.as_mut() { - record.intercept_response = false; - } - pending.network_request_handle = request.network_request_handle; - pending.network_record = None; - pending.paused_response = None; - completion_tx - }; - let _ = completion_tx.send(WorkerXhrCompletion { - native_record: None, - xhr_id, - network_request_headers: None, - result: Err(error_text), - }); -} - -pub(in crate::worker) fn fulfill_pending_worker_xhr_response( - state: &Rc>, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, -) { - let xhr_id = request.xhr_id; - let completion = { - let mut state = state.borrow_mut(); - let completion_tx = state.xhr_completion_tx.clone(); - let Some(pending) = state.pending_xhrs.get_mut(&xhr_id) else { - return; - }; - if let Some(record) = pending.network_record.as_mut() { - record.intercept_response = false; - } - pending.network_request_handle = request.network_request_handle; - pending.network_record = None; - pending.paused_response = None; - let response = - worker_response_from_body(request.url, response_code, response_headers, response_body); - (completion_tx, response, xhr_id) - }; - let _ = completion.0.send(WorkerXhrCompletion { - native_record: None, - xhr_id: completion.2, - network_request_headers: None, - result: Ok(WorkerXhrResponse::Materialized(Box::new(completion.1))), - }); -} - pub(in crate::worker) fn record_worker_websocket_subresource_failure( state: &WorkerGlobalState, socket_id: u64, @@ -1995,12 +825,12 @@ pub(in crate::worker) fn worker_fetch_callback<'s>( }; let ( - loader, + _loader, document_url, extra_http_headers, - network_offline, + _network_offline, blocked_url_patterns, - fetch_subresource_interception_classes, + _fetch_subresource_interception_classes, policy_context, ) = { let state = state.borrow(); @@ -2165,225 +995,51 @@ pub(in crate::worker) fn worker_fetch_callback<'s>( return; } - // Local URLs are resolved by the worker fetch task without interception. - if !matches!(resolved_url.scheme(), "blob" | "data") - && fetch_subresource_interception_classes.intercepts(SubresourceResourceType::Fetch) { - let Some(resolver) = v8::PromiseResolver::new(scope) else { - rv.set_undefined(); - return; + let metadata = + worker_fetch_script_metadata(state.borrow().referrer_policy.clone(), &request_metadata); + let request = Request::new_browser( + &method, + resolved_url.clone(), + body.clone(), + headers.clone(), + moli_url::WebOrigin::from_url(&document_url), + ) + .with_initiator_url(&document_url) + .with_request_mode(request_mode) + .with_credentials_mode(credentials_mode) + .with_redirect_mode(redirect_mode) + .with_cache_mode(request_metadata.cache.parse().unwrap_or_default()) + .with_network_partition_key(state.borrow().network_partition_key.clone()) + .with_fetch_priority_hint(priority) + .with_browser_request_metadata(BrowserRequestMetadata::Fetch); + let request = match request.with_fetch_referrer(&request_metadata.referrer) { + Ok(mut request) => { + if let Some(metadata) = metadata { + request = request.with_script_fetch_metadata(metadata); + } + request + } + Err(error) => { + rv.set(make_rejected_promise(scope, &error.to_string()).into()); + return; + } }; - let promise = resolver.get_promise(scope); let signal_id = signal.and_then(|signal| worker_abort_signal_id(scope, signal)); - let cancel_handle = FetchCancelHandle::new(); - let disposition = if request_metadata.keepalive { - ResourceLoadDisposition::Keepalive + if let Some(promise) = native_load::start( + scope, + &state, + request, + document_url, + signal_id, + request_metadata, + policy_context, + ) { + rv.set(promise.into()); } else { - ResourceLoadDisposition::Ordinary - }; - let Some(load) = loader.register_load( - ResourceLoadKind::Fetch, - disposition, - Some(cancel_handle.clone()), - ) else { - rv.set(make_rejected_promise(scope, "fetch: worker global is shutting down").into()); - return; - }; - let request_body = request_body_text(&body); - let fetch_id = { - let mut state = state.borrow_mut(); - let fetch_id = next_fetch_id(&mut state); - state.pending_fetches.insert( - fetch_id, - PendingWorkerFetch { - resource_timing: crate::context_bootstrap::FetchResourceTiming::capture( - scope, - &(&document_url).into(), - ), - resolver: v8::Global::new(scope, resolver), - document_url: document_url.clone(), - credentials_mode, - request_mode, - redirect_mode, - request_priority: priority, - request_metadata: request_metadata.clone(), - policy_context, - signal_id, - load: load.clone(), - request_url: resolved_url.clone(), - request_method: method.clone(), - request_headers: headers.clone(), - request_body: request_body.clone(), - network_request_handle: None, - network_record: None, - paused_response: None, - streaming_body_source_id: None, - }, - ); - fetch_id - }; - let info = PendingSubresourceFetchInfo { - internal_id: 0, - network_request_handle: None, - frame_id: None, - document_url, - url: resolved_url, - websocket_socket_id: None, - method, - request_headers: headers, - request_body_bytes: body, - request_body, - resource_type: SubresourceResourceType::Fetch, - request_cookie_report: None, - }; - let _ = state - .borrow() - .parent_tx - .send(WorkerToParentMessage::PendingSubresourceFetch( - WorkerPendingSubresourceFetch { - fetch_id, - load, - credentials_mode, - request_mode, - network_partition_key: state.borrow().network_partition_key.clone(), - info, - }, - )); - rv.set(promise.into()); - return; - } - - if network_offline { - let message = "Network emulation offline".to_owned(); - record_worker_subresource_failure( - &state.borrow(), - document_url, - resolved_url, - method, - headers, - request_body_text(&body), - SubresourceResourceType::Fetch, - message.clone(), - ); - rv.set(make_rejected_promise(scope, &message).into()); - return; - } - - let promise = { - let Some(resolver) = v8::PromiseResolver::new(scope) else { rv.set_undefined(); - return; - }; - let promise = resolver.get_promise(scope); - let signal_id = signal.and_then(|signal| worker_abort_signal_id(scope, signal)); - let cancel_handle = FetchCancelHandle::new(); - let disposition = if request_metadata.keepalive { - ResourceLoadDisposition::Keepalive - } else { - ResourceLoadDisposition::Ordinary - }; - let Some(load) = loader.register_load( - ResourceLoadKind::Fetch, - disposition, - Some(cancel_handle.clone()), - ) else { - rv.set(make_rejected_promise(scope, "fetch: worker global is shutting down").into()); - return; - }; - let request_body = request_body_text(&body); - let fetch_id = { - let mut state = state.borrow_mut(); - let fetch_id = next_fetch_id(&mut state); - state.pending_fetches.insert( - fetch_id, - PendingWorkerFetch { - resource_timing: crate::context_bootstrap::FetchResourceTiming::capture( - scope, - &(&document_url).into(), - ), - resolver: v8::Global::new(scope, resolver), - document_url: document_url.clone(), - credentials_mode, - request_mode, - redirect_mode, - request_priority: priority, - request_metadata: request_metadata.clone(), - policy_context, - signal_id, - load: load.clone(), - request_url: resolved_url.clone(), - request_method: method.clone(), - request_headers: headers.clone(), - request_body, - network_request_handle: None, - network_record: None, - paused_response: None, - streaming_body_source_id: None, - }, - ); - fetch_id - }; - let (completion_tx, referrer_policy, network_partition_key, service_worker_controller) = { - let state = state.borrow(); - ( - state.fetch_completion_tx.clone(), - state.referrer_policy.clone(), - state.network_partition_key.clone(), - worker_service_worker_controller(&state, &resolved_url), - ) - }; - - if let Some((service_worker_runtime, service_worker_client_id)) = service_worker_controller - { - spawn_worker_fetch_service_worker( - service_worker_runtime, - service_worker_client_id, - load, - completion_tx, - fetch_id, - cancel_handle, - document_url, - referrer_policy, - network_partition_key, - policy_context, - resolved_url, - method, - body, - headers, - request_mode, - credentials_mode, - redirect_mode, - priority, - request_metadata, - ); - } else { - spawn_worker_fetch_network( - load, - completion_tx, - fetch_id, - cancel_handle, - document_url, - referrer_policy, - network_partition_key, - resolved_url, - method, - body, - headers, - request_mode, - credentials_mode, - redirect_mode, - priority, - request_metadata, - None, - true, - None, - Vec::new(), - ); } - - promise - }; - rv.set(promise.into()); + } } pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( @@ -2411,93 +1067,38 @@ pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( } rejected }; - for (fetch_id, pending) in rejected { + for (_, pending) in rejected { crate::context_bootstrap::record_resource_performance_entry( scope, pending.resource_timing.failed(&pending.request_url), ); - let PendingWorkerFetch { - resolver, - load, - document_url, - network_record, - network_request_handle, - streaming_body_source_id: body_source_id, - .. - } = pending; - load.cancel(); - if let Some(runtime) = state.borrow().service_worker_runtime.clone() { - runtime.abort_controlled_fetch(u64::from(fetch_id)); - } - if let Some(record) = network_record { - let state = state.borrow(); - record_worker_subresource_failure_with_handle( - &state, - network_request_handle, - document_url, - record.url, - record.method, - record.request_headers, - record.request_body_bytes, - SubresourceResourceType::Fetch, - ABORTED_ERROR_TEXT.to_owned(), - ); - let _ = state - .parent_tx - .send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { - internal_id: record.internal_id, - }, - )); - } else { - let _ = state.borrow().parent_tx.send( - WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id, - error_text: ABORTED_ERROR_TEXT.to_owned(), - }, - ); - } - if let Some(body_source_id) = body_source_id { + pending.load.cancel(); + if let Some(body_source_id) = pending.streaming_body_source_id { error_pending_network_body_stream_with_reason( scope, body_source_id, - ABORTED_ERROR_TEXT.to_owned(), + "net::ERR_ABORTED".into(), reason, ); - } else { - let resolver = v8::Local::new(scope, &resolver); - let _ = resolver.reject(scope, reason); } + let resolver = v8::Local::new(scope, &pending.resolver); + let _ = resolver.reject(scope, reason); } } -pub(in crate::worker) fn worker_response_from_body( - final_url: Url, - status: u16, - headers: Vec<(String, Vec)>, - body: RendererSyntheticResponseBody, -) -> Response { - body.into_fetch_response(ResponseHead { - status_text: None, - final_url, - status, - headers, - request_cookie_report: None, - cookie_set_reports: Vec::new(), - redirected: false, - redirect_chain: Vec::new(), - from_cache: false, - cache_state: Default::default(), - negotiated_http_version: None, - }) -} - pub(in crate::worker) fn drain_worker_fetch_completion( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, event: WorkerFetchEvent, ) { match event { + WorkerFetchEvent::PolicyViolations(violations) => { + for violation in violations { + dispatch_worker_content_security_policy_violation_event_for_state( + scope, state, &violation, + ); + } + } WorkerFetchEvent::Completion(completion) => { drain_worker_fetch_completion_result(scope, state, *completion) } @@ -2519,70 +1120,10 @@ pub(in crate::worker) fn start_worker_streaming_fetch( started: WorkerFetchStreamingStarted, ) { let mut reject = None; - if let Some(network_request_headers) = started.network_request_headers.as_ref() - && let Some(record) = state - .borrow_mut() - .pending_fetches - .get_mut(&started.fetch_id) - .and_then(|pending| pending.network_record.as_mut()) - { - record - .initial_network_request_headers - .get_or_insert_with(|| network_request_headers.clone()); - } - let redirect_status = if started.head.redirect_chain.is_empty() { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect - } else { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - }; - if redirect_status - == crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - { - let (document_url, request_url) = { - let state_ref = state.borrow(); - let Some(pending) = state_ref.pending_fetches.get(&started.fetch_id) else { - return; - }; - (pending.document_url.clone(), pending.request_url.clone()) - }; - dispatch_worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status_for_state( - scope, - state, - &document_url, - &started.head.final_url, - &request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - redirect_status, - ); - } - let csp_failure = { - let state_ref = state.borrow(); - let Some(pending) = state_ref.pending_fetches.get(&started.fetch_id) else { - return; - }; - worker_content_security_policy_violation_for_checked_url_with_redirect_status( - &state_ref, - &pending.document_url, - &started.head.final_url, - &pending.request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - redirect_status, - ) - }; - let response_input = if let Some(violation) = csp_failure { - let resolver = { - let mut state_ref = state.borrow_mut(); - let Some(pending) = state_ref.pending_fetches.get_mut(&started.fetch_id) else { - return; - }; - pending.load.cancel(); - pending.resolver.clone() - }; - dispatch_worker_content_security_policy_violation_event_for_state(scope, state, &violation); - let message = worker_content_security_policy_error_message(&violation, "fetch"); - reject = Some((resolver, message)); - None - } else { + + // The native loader admits every hop before dispatch and delivers CSP + // violations separately. JS only filters and settles the response here. + let response_input = { let mut state_ref = state.borrow_mut(); let Some(pending) = state_ref.pending_fetches.get_mut(&started.fetch_id) else { return; @@ -2621,7 +1162,6 @@ pub(in crate::worker) fn start_worker_streaming_fetch( scope, pending.resource_timing.failed(&pending.request_url), ); - record_worker_fetch_failure(&state.borrow(), &pending, message.clone()); } if let Some(message) = v8_string(scope, &message) { let resolver = v8::Local::new(scope, &resolver); @@ -2652,7 +1192,6 @@ pub(in crate::worker) fn finish_worker_streaming_fetch( state: &Rc>, finished: WorkerFetchStreamingFinished, ) { - let parent_tx = state.borrow().parent_tx.clone(); let Some(pending) = state .borrow_mut() .pending_fetches @@ -2676,25 +1215,6 @@ pub(in crate::worker) fn finish_worker_streaming_fetch( ), ); close_pending_network_body_stream(scope, finished.body_source_id); - if let Some(record) = pending.network_record { - let internal_id = record.internal_id; - record_worker_subresource_success_with_handle( - &state.borrow(), - pending.network_request_handle, - pending.document_url, - record.url, - record.method, - record.request_headers, - record.request_body_bytes, - SubresourceResourceType::Fetch, - record.initial_network_request_headers, - head, - body, - ); - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { internal_id }, - )); - } } Err(error_text) => { crate::context_bootstrap::record_resource_performance_entry( @@ -2710,235 +1230,15 @@ pub(in crate::worker) fn finish_worker_streaming_fetch( error_text.clone(), reason, ); - record_worker_fetch_failure(&state.borrow(), &pending, error_text); } } } -pub(in crate::worker) fn record_worker_fetch_failure( - state: &WorkerGlobalState, - pending: &PendingWorkerFetch, - message: String, -) { - let network_error_text = if is_cors_policy_failure_message(&message) { - FAILED_ERROR_TEXT.to_owned() - } else { - message - }; - if let Some(record) = pending.network_record.as_ref() { - record_worker_subresource_failure_with_handle( - state, - pending.network_request_handle, - pending.document_url.clone(), - record.url.clone(), - record.method.clone(), - record.request_headers.clone(), - record.request_body_bytes.clone(), - SubresourceResourceType::Fetch, - network_error_text, - ); - let _ = state - .parent_tx - .send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { - internal_id: record.internal_id, - }, - )); - return; - } - - record_worker_subresource_failure_with_handle( - state, - pending.network_request_handle, - pending.document_url.clone(), - pending.request_url.clone(), - pending.request_method.clone(), - pending.request_headers.clone(), - pending - .request_body - .as_ref() - .map(|body| bytes::Bytes::copy_from_slice(body.as_bytes())), - SubresourceResourceType::Fetch, - network_error_text, - ); -} - pub(in crate::worker) fn drain_worker_fetch_completion_result( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, completion: WorkerFetchCompletion, ) { - let global = scope.get_current_context().global(scope); - let _ = global; - let parent_tx = state.borrow().parent_tx.clone(); - if let Some(network_request_headers) = completion.network_request_headers.as_ref() - && let Some(record) = state - .borrow_mut() - .pending_fetches - .get_mut(&completion.fetch_id) - .and_then(|pending| pending.network_record.as_mut()) - { - record - .initial_network_request_headers - .get_or_insert_with(|| network_request_headers.clone()); - } - if let Ok(response) = &completion.result { - let response_head = response.head(); - let redirect_status = if response_head.redirect_chain.is_empty() { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect - } else { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - }; - if redirect_status - == crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - { - let (document_url, request_url) = { - let state_ref = state.borrow(); - let Some(pending) = state_ref.pending_fetches.get(&completion.fetch_id) else { - return; - }; - (pending.document_url.clone(), pending.request_url.clone()) - }; - dispatch_worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status_for_state( - scope, - state, - &document_url, - &response_head.final_url, - &request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - redirect_status, - ); - } - let csp_failure = { - let state_ref = state.borrow(); - let Some(pending) = state_ref.pending_fetches.get(&completion.fetch_id) else { - return; - }; - worker_content_security_policy_violation_for_checked_url_with_redirect_status( - &state_ref, - &pending.document_url, - &response_head.final_url, - &pending.request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - if response_head.redirect_chain.is_empty() { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect - } else { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - }, - ) - }; - if let Some(violation) = csp_failure { - dispatch_worker_content_security_policy_violation_event_for_state( - scope, state, &violation, - ); - let message = worker_content_security_policy_error_message(&violation, "fetch"); - let Some(pending) = state - .borrow_mut() - .pending_fetches - .remove(&completion.fetch_id) - else { - return; - }; - pending.load.finish(); - let resolver = v8::Local::new(scope, &pending.resolver); - crate::context_bootstrap::record_resource_performance_entry( - scope, - pending.resource_timing.failed(&pending.request_url), - ); - record_worker_fetch_failure(&state.borrow(), &pending, message.clone()); - if let Some(message) = v8_string(scope, &message) { - let _ = resolver.reject(scope, v8::Exception::type_error(scope, message)); - } else { - let _ = resolver.reject(scope, v8::undefined(scope).into()); - } - return; - } - let auth_required = { - let mut state_ref = state.borrow_mut(); - let Some(pending) = state_ref.pending_fetches.get_mut(&completion.fetch_id) else { - return; - }; - pending.network_record.clone().and_then(|mut record| { - if record.handle_auth_requests - && matches!(response_head.status, 401 | 407) - && let Some(challenge) = - extract_subresource_auth_challenge(&response_head.headers) - { - record.follow_redirects(&response_head); - let response_body = response.subresource_response_body(); - pending.paused_response = Some(PausedWorkerSubresourceResponse { - head: response_head.clone(), - body: response_body.clone(), - }); - Some(PendingSubresourceAuthInfo { - internal_id: record.internal_id, - url: record.url.clone(), - method: record.method.clone(), - request_headers: record.request_headers.clone(), - request_body: request_body_text(&record.request_body_bytes), - resource_type: SubresourceResourceType::Fetch, - request_cookie_report: response_head.request_cookie_report.clone(), - network_request_headers: record.initial_network_request_headers.clone(), - challenge, - intercept_response: record.intercept_response, - response_final_url: response_head.final_url.clone(), - response_status: response_head.status, - response_headers: response_head.headers.clone(), - response_body, - response_from_cache: response_head.from_cache, - response_cache_state: response_head.cache_state, - }) - } else { - None - } - }) - }; - if let Some(info) = auth_required { - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::AuthRequired(info), - )); - return; - } - let response_paused = { - let mut state = state.borrow_mut(); - let Some(pending) = state.pending_fetches.get_mut(&completion.fetch_id) else { - return; - }; - match pending.network_record.as_ref() { - Some(record) if record.intercept_response => { - let response_body = response.subresource_response_body(); - let info = PendingSubresourceResponseInfo { - internal_id: record.internal_id, - url: record.url.clone(), - final_url: response_head.final_url.clone(), - method: record.method.clone(), - request_headers: record.request_headers.clone(), - request_body: request_body_text(&record.request_body_bytes), - resource_type: SubresourceResourceType::Fetch, - request_cookie_report: response_head.request_cookie_report.clone(), - network_request_headers: record.initial_network_request_headers.clone(), - response_status: response_head.status, - response_headers: response_head.headers.clone(), - response_body: response_body.clone(), - from_cache: response_head.from_cache, - cache_state: response_head.cache_state, - }; - pending.paused_response = Some(PausedWorkerSubresourceResponse { - head: response_head, - body: response_body, - }); - Some(info) - } - _ => None, - } - }; - if let Some(info) = response_paused { - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::ResponsePaused(info), - )); - return; - } - } let Some(pending) = state .borrow_mut() .pending_fetches @@ -2966,50 +1266,14 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( // Its exposed headers cannot be revalidated as a raw CORS response. Ok(()) } else { - match &response { - WorkerFetchResponse::Materialized(response) - | WorkerFetchResponse::Filtered { response, .. } => { - validate_fetch_response_security_policy_with_body_classified( - &pending.document_url, - &response_head, - response.body_bytes(), - pending.request_mode, - pending.credentials_mode, - pending.policy_context, - ) - } - WorkerFetchResponse::Streamed { body, .. } => body - .try_bytes() - .map_err(|error| { - FetchResponseSecurityViolation::Rejected(format!( - "fetch: failed to read response body: {error}" - )) - }) - .and_then(|body_bytes| { - validate_fetch_response_security_policy_with_body_classified( - &pending.document_url, - &response_head, - &body_bytes, - pending.request_mode, - pending.credentials_mode, - pending.policy_context, - ) - }), - } - }; - let security_validation = match security_validation { - Ok(()) | Err(FetchResponseSecurityViolation::OpaqueResponseBlocked(_)) - if pending.redirect_mode == RequestRedirectMode::Error - && matches!(response_head.status, 301 | 302 | 303 | 307 | 308) => - { - // Interception can supply this status without taking the - // transport's redirect path. Reject after security checks, - // before recording success or exposing an opaque response. - Err(FetchResponseSecurityViolation::Rejected( - "fetch: redirect mode is error".to_owned(), - )) - } - validation => validation, + validate_fetch_response_security_policy_with_body_classified( + &pending.document_url, + &response_head, + response.response.body_bytes(), + pending.request_mode, + pending.credentials_mode, + pending.policy_context, + ) }; let opaque_response_blocked = match security_validation { Ok(()) => false, @@ -3020,7 +1284,6 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( pending.resource_timing.failed(&pending.request_url), ); let message = violation.into_message(); - record_worker_fetch_failure(&state.borrow(), &pending, message.clone()); if let Some(message) = v8_string(scope, &message) { let _ = resolver.reject(scope, v8::Exception::type_error(scope, message)); } else { @@ -3029,34 +1292,7 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( return; } }; - if opaque_response_blocked { - record_worker_fetch_failure( - &state.borrow(), - &pending, - ABORTED_ERROR_TEXT.to_owned(), - ); - } - if !opaque_response_blocked && let Some(record) = pending.network_record.as_ref() { - let response_body = response.subresource_response_body(); - record_worker_subresource_success_with_handle( - &state.borrow(), - pending.network_request_handle, - pending.document_url.clone(), - record.url.clone(), - record.method.clone(), - record.request_headers.clone(), - record.request_body_bytes.clone(), - SubresourceResourceType::Fetch, - record.initial_network_request_headers.clone(), - response_head.clone(), - response_body.clone(), - ); - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { - internal_id: record.internal_id, - }, - )); - } + let entry = if opaque_response_blocked { pending.resource_timing.failed(&pending.request_url) } else { @@ -3092,44 +1328,14 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( pending.credentials_mode, ) }; - let response_obj = match response.into_fetch_parts() { - WorkerFetchResponseParts::Materialized { mut head, body } => { - head.headers = filtered_headers; - let body = if opaque_response_blocked { - ResponseBody::materialized_bytes(Vec::new()) - } else { - *body - }; - crate::network_host::build_fetch_response_object_from_body_source_for_request_mode_with_metadata( - scope, - crate::network_host::FetchResponseRequest { - method: &pending.request_method, - mode: pending.request_mode, - }, - head, - body, - metadata, - ) - } - WorkerFetchResponseParts::Subresource { mut head, body } => { - head.headers = filtered_headers; - let body = if opaque_response_blocked { - SubresourceResponseBody::from_bytes(Vec::new()) - } else { - body - }; - build_fetch_response_object_from_subresource_body_for_request_mode( - scope, - crate::network_host::FetchResponseRequest { - method: &pending.request_method, - mode: pending.request_mode, - }, - head, - body, - metadata, - ) - } + let (mut head, body) = response.into_fetch_parts(); + head.headers = filtered_headers; + let body = if opaque_response_blocked { + ResponseBody::materialized_bytes(Vec::new()) + } else { + body }; + let response_obj = crate::network_host::build_fetch_response_object_from_body_source_for_request_mode_with_metadata(scope,crate::network_host::FetchResponseRequest {method:&pending.request_method,mode:pending.request_mode},head,body,metadata); let _ = resolver.resolve(scope, response_obj.into()); } Err(message) => { @@ -3137,7 +1343,6 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( scope, pending.resource_timing.failed(&pending.request_url), ); - record_worker_fetch_failure(&state.borrow(), &pending, message.clone()); if let Some(message) = v8_string(scope, &message) { let _ = resolver.reject(scope, v8::Exception::type_error(scope, message)); } else { diff --git a/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs new file mode 100644 index 00000000000..3fe810890a2 --- /dev/null +++ b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs @@ -0,0 +1,97 @@ +use super::*; + +pub(super) fn start<'s>( + scope: &mut v8::PinScope<'s, '_>, + state: &Rc>, + request: Request, + document_url: Url, + signal_id: Option, + metadata: ServiceWorkerFetchRequestMetadata, + policy_context: SubresourcePolicyContext, +) -> Option> { + let resolver = v8::PromiseResolver::new(scope)?; + let promise = resolver.get_promise(scope); + let cancel = FetchCancelHandle::new(); + let loader = state.borrow().loader.clone(); + let Some(load) = loader.register_load( + ResourceLoadKind::Fetch, + if metadata.keepalive { + ResourceLoadDisposition::Keepalive + } else { + ResourceLoadDisposition::Ordinary + }, + Some(cancel.clone()), + ) else { + return Some(make_rejected_promise( + scope, + "fetch: worker global is shutting down", + )); + }; + let handle = crate::network::interception_control::next_subresource_network_handle(); + let info = PendingSubresourceFetchInfo { + internal_id: crate::network::interception_control::next_subresource_request_id(), + network_request_handle: Some(handle), + request_headers: request.interception_request_headers(), + request_body: request_body_text(&request.body), + + frame_id: None, + document_url: document_url.clone(), + url: request.url.clone(), + websocket_socket_id: None, + method: request.method.clone(), + + request_body_bytes: request.body.clone(), + resource_type: SubresourceResourceType::Fetch, + request_cookie_report: None, + }; + let (fetch_id, completion, control) = { + let mut state = state.borrow_mut(); + let fetch_id = next_fetch_id(&mut state); + state.pending_fetches.insert( + fetch_id, + PendingWorkerFetch { + resolver: v8::Global::new(scope, resolver), + resource_timing: crate::context_bootstrap::FetchResourceTiming::capture( + scope, + &(&document_url).into(), + ), + document_url, + credentials_mode: request.credentials_mode, + request_mode: request.request_mode, + redirect_mode: request.redirect_mode(), + + policy_context, + signal_id, + load: load.clone(), + request_url: request.url.clone(), + request_method: request.method.clone(), + + streaming_body_source_id: None, + }, + ); + let control = crate::network_host::controlled_xhr::ControlledXhrContext { + interception: state + .interception_context + .clone() + .expect("native Worker fetch has an output owner"), + connect_policy: + crate::document_runtime::DocumentConnectPolicySnapshot::from_worker_policies( + state.content_security_policies.clone(), + state.content_security_report_only_policies.clone(), + state.content_security_reporting_endpoints.clone(), + ), + }; + (fetch_id, state.fetch_completion_tx.clone(), control) + }; + let service_worker = state.borrow().service_worker_runtime.clone(); + let service_worker_client = state.borrow().service_worker_client_id; + let task_runner = load.task_runner(); + task_runner.spawn(async move { + control + .fetch_load(request, info, load, cancel, policy_context) + .with_service_worker(service_worker, service_worker_client, metadata) + .run_fetch(completion, fetch_id) + .await; + }); + Some(promise) +} diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index c35aedc2603..210c22534f0 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -15,7 +15,6 @@ use std::sync::{ use std::time::{Instant, SystemTime, UNIX_EPOCH}; use crate::{ - RendererSyntheticResponseBody, broadcast_channel_runtime::SharedBroadcastChannelRegistry, content_security_policy::ContentSecurityPolicyReportingEndpoints, message_port_runtime::SharedMessagePortRegistry, @@ -43,8 +42,7 @@ use url::Url; use super::{ decode_data_url_script_source, handle::{ - WorkerConsoleMessage, WorkerFetchHandlerType, WorkerPendingFetchContinue, - WorkerPendingSubresourceFetch, WorkerPendingXhrContinue, WorkerToParentMessage, + WorkerConsoleMessage, WorkerFetchHandlerType, WorkerToParentMessage, WorkerWebSocketFrameEvent, WorkerWebSocketLifecycleEvent, }, }; @@ -56,33 +54,27 @@ use crate::context_bootstrap::{ use crate::network::loads::{ResourceLoadDisposition, ResourceLoadKind, ResourceLoadLease}; use crate::network_host::xhr_has_upload_listeners; use crate::network_host::{ - ABORTED_ERROR_TEXT, BLOCKED_BY_CLIENT_ERROR_TEXT, FAILED_ERROR_TEXT, - FetchResponseSecurityViolation, HeadersGuard, PreparedXhrSendBody, XHR_ABORTED_SLOT, - XHR_ACTIVE_INTERNAL_ID_SLOT, XHR_ASYNC_SLOT, XHR_METHOD_SLOT, XHR_OPEN_GENERATION_SLOT, - XHR_SEND_FLAG_SLOT, XHR_TIMEOUT_SLOT, XHR_TIMEOUT_START_MS_SLOT, XHR_TIMEOUT_TIMER_SLOT, - XHR_URL_SLOT, XHR_WITH_CREDENTIALS_SLOT, append_default_body_content_type, apply_xhr_failure, - apply_xhr_response, apply_xhr_response_body_source, apply_xhr_timeout, begin_xhr_send, - browser_request_needs_manual_preflight_redirects, - build_fetch_response_object_from_subresource_body_for_request_mode, + BLOCKED_BY_CLIENT_ERROR_TEXT, FetchResponseSecurityViolation, HeadersGuard, + PreparedXhrSendBody, XHR_ABORTED_SLOT, XHR_ACTIVE_INTERNAL_ID_SLOT, XHR_ASYNC_SLOT, + XHR_METHOD_SLOT, XHR_OPEN_GENERATION_SLOT, XHR_SEND_FLAG_SLOT, XHR_TIMEOUT_SLOT, + XHR_TIMEOUT_START_MS_SLOT, XHR_TIMEOUT_TIMER_SLOT, XHR_URL_SLOT, XHR_WITH_CREDENTIALS_SLOT, + append_default_body_content_type, apply_xhr_failure, apply_xhr_response, + apply_xhr_response_body_source, apply_xhr_timeout, begin_xhr_send, close_pending_network_body_stream, convert_xhr_send_body_from_args, dispatch_xhr_loadstart, dispatch_xhr_upload_complete, enqueue_pending_network_body_chunk, - error_pending_network_body_stream_with_reason, extract_subresource_auth_challenge, - fetch_browser_subresource_raw_stream_with_preflight_headers_and_network_metadata, - fetch_browser_subresource_with_preflight_headers_and_network_metadata, - filter_cors_exposed_response_headers, filter_headers_for_guard, is_cors_policy_failure_message, - local_url_response_result, parse_fetch_init, request_object_credentials_mode, - resolve_context_url, set_xhr_state_number, throw_synchronous_xhr_failure, - validate_fetch_response_security_policy, + error_pending_network_body_stream_with_reason, filter_cors_exposed_response_headers, + filter_headers_for_guard, local_url_response_result, parse_fetch_init, + request_object_credentials_mode, resolve_context_url, set_xhr_state_number, + throw_synchronous_xhr_failure, validate_fetch_response_security_policy, validate_fetch_response_security_policy_with_body_classified, xhr_author_request_headers, xhr_ensure_send_allowed, xhr_state_bool_property, xhr_state_number_property, xhr_state_string_property, }; use crate::opfs_task_result::OpfsTaskResult; use crate::protocol_types::{ - PendingSubresourceAuthInfo, PendingSubresourceContinueEvent, PendingSubresourceFetchInfo, - PendingSubresourceResponseInfo, SubresourceInterceptionClasses, SubresourceNetworkRecord, + PendingSubresourceFetchInfo, SubresourceInterceptionClasses, SubresourceNetworkRecord, SubresourceNetworkRequestHandle, SubresourceResourceType, SubresourceResponseBody, - SubresourceResponseBodyWriter, WebSocketFrameDirection, WebSocketFrameOpcode, + WebSocketFrameDirection, WebSocketFrameOpcode, }; use crate::queue_microtask::worker_queue_microtask_callback; use crate::runtime::{ @@ -138,10 +130,6 @@ pub(crate) use self::service_worker_api::{ }; use content_security_policy::*; -pub(in crate::worker) use content_security_policy::{ - continue_pending_worker_csp_report, fail_pending_worker_csp_report, - fulfill_pending_worker_csp_report, -}; pub(crate) use fetch::*; use import_scripts::*; use timers::*; @@ -204,14 +192,14 @@ pub(crate) use nested_workers::{ NestedWorkerContext, forget_nested_worker_context, reserve_nested_worker_context, }; pub(super) use network_state::{ - PausedWorkerSubresourceResponse, PendingWorkerCspReport, PendingWorkerFetch, - PendingWorkerFetchNetworkRecord, PendingWorkerXhr, WorkerFetchCompletion, WorkerFetchEvent, - WorkerFetchResponse, WorkerFetchStreamingChunk, WorkerFetchStreamingFinished, - WorkerFetchStreamingStarted, WorkerWebSocketState, WorkerXhrCompletion, WorkerXhrResponse, + PendingWorkerFetch, PendingWorkerXhr, WorkerWebSocketState, WorkerXhrCompletion, +}; +pub(crate) use network_state::{ + WorkerFetchCompletion, WorkerFetchEvent, WorkerFetchResponse, WorkerFetchStreamingChunk, + WorkerFetchStreamingFinished, WorkerFetchStreamingStarted, }; use network_state::{ - WorkerFetchResponseParts, merge_worker_request_headers, next_fetch_id, next_websocket_id, - next_xhr_id, worker_url_blocked, + merge_worker_request_headers, next_fetch_id, next_websocket_id, next_xhr_id, worker_url_blocked, }; pub(crate) use origin::worker_global_origin; use origin::{WorkerGlobalOriginDeclaration, WorkerGlobalOriginPrototypeDeclaration}; diff --git a/moli-renderer-v8/src/worker/global_scope/network_state.rs b/moli-renderer-v8/src/worker/global_scope/network_state.rs index abac5689f84..803b229c7a0 100644 --- a/moli-renderer-v8/src/worker/global_scope/network_state.rs +++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs @@ -9,149 +9,66 @@ pub(in crate::worker) struct PendingWorkerFetch { pub(in crate::worker) credentials_mode: RequestCredentialsMode, pub(in crate::worker) request_mode: moli_fetch::RequestMode, pub(in crate::worker) redirect_mode: RequestRedirectMode, - pub(in crate::worker) request_priority: Option, - pub(in crate::worker) request_metadata: - crate::service_worker_runtime::ServiceWorkerFetchRequestMetadata, + pub(in crate::worker) policy_context: crate::types::SubresourcePolicyContext, pub(in crate::worker) signal_id: Option, pub(in crate::worker) load: ResourceLoadLease, pub(in crate::worker) request_url: Url, pub(in crate::worker) request_method: String, - pub(in crate::worker) request_headers: moli_fetch::RequestHeaders, - pub(in crate::worker) request_body: Option, - pub(in crate::worker) network_request_handle: Option, - pub(in crate::worker) network_record: Option, - pub(in crate::worker) paused_response: Option, + pub(in crate::worker) streaming_body_source_id: Option, } -pub(in crate::worker) enum WorkerFetchEvent { +pub(crate) enum WorkerFetchEvent { + PolicyViolations(Vec), Completion(Box), StreamingStarted(WorkerFetchStreamingStarted), StreamingChunk(WorkerFetchStreamingChunk), StreamingFinished(WorkerFetchStreamingFinished), } -pub(in crate::worker) struct WorkerFetchCompletion { - pub(super) fetch_id: u32, - pub(super) network_request_headers: Option>, - pub(super) result: Result, +pub(crate) struct WorkerFetchCompletion { + pub(crate) fetch_id: u32, + + pub(crate) result: Result, } -pub(in crate::worker) struct WorkerFetchStreamingStarted { - pub(super) fetch_id: u32, - pub(super) body_source_id: NetworkBodySourceId, - pub(super) head: ResponseHead, - pub(super) network_request_headers: Option>, +pub(crate) struct WorkerFetchStreamingStarted { + pub(crate) fetch_id: u32, + pub(crate) body_source_id: NetworkBodySourceId, + pub(crate) head: ResponseHead, } -pub(in crate::worker) struct WorkerFetchStreamingChunk { - pub(super) body_source_id: NetworkBodySourceId, - pub(super) bytes: Vec, +pub(crate) struct WorkerFetchStreamingChunk { + pub(crate) body_source_id: NetworkBodySourceId, + pub(crate) bytes: Vec, } -pub(in crate::worker) struct WorkerFetchStreamingFinished { - pub(super) fetch_id: u32, - pub(super) body_source_id: NetworkBodySourceId, - pub(super) head: ResponseHead, - pub(super) result: Result, +pub(crate) struct WorkerFetchStreamingFinished { + pub(crate) fetch_id: u32, + pub(crate) body_source_id: NetworkBodySourceId, + pub(crate) head: ResponseHead, + pub(crate) result: Result, } -pub(in crate::worker) enum WorkerFetchResponse { - Materialized(Box), - Filtered { - response: Box, - filter: crate::types::AsyncSubresourceFetchResponseFilter, - }, - Streamed { - head: Box, - body: SubresourceResponseBody, - }, +pub(crate) struct WorkerFetchResponse { + pub(crate) response: Box, + pub(crate) filter: Option, } - impl WorkerFetchResponse { pub(super) fn response_filter( &self, ) -> Option { - match self { - Self::Filtered { filter, .. } => Some(filter.clone()), - _ => None, - } + self.filter.clone() } - pub(super) fn head(&self) -> ResponseHead { - match self { - Self::Materialized(response) | Self::Filtered { response, .. } => response.head(), - Self::Streamed { head, .. } => head.as_ref().clone(), - } + self.response.head() } - pub(super) fn subresource_response_body(&self) -> SubresourceResponseBody { - match self { - Self::Materialized(response) | Self::Filtered { response, .. } => { - SubresourceResponseBody::from_fetch_response(response) - } - Self::Streamed { body, .. } => body.clone(), - } + SubresourceResponseBody::from_fetch_response(&self.response) } - - pub(super) fn into_fetch_parts(self) -> WorkerFetchResponseParts { - match self { - Self::Materialized(response) | Self::Filtered { response, .. } => { - let (head, body) = response.into_body(); - WorkerFetchResponseParts::Materialized { - head, - body: Box::new(body), - } - } - Self::Streamed { head, body } => { - WorkerFetchResponseParts::Subresource { head: *head, body } - } - } - } -} - -pub(super) enum WorkerFetchResponseParts { - Materialized { - head: ResponseHead, - body: Box, - }, - Subresource { - head: ResponseHead, - body: SubresourceResponseBody, - }, -} - -#[derive(Clone)] -pub(in crate::worker) struct PendingWorkerFetchNetworkRecord { - pub(crate) redirect_headers: Option, - pub(in crate::worker) internal_id: u64, - pub(in crate::worker) url: Url, - pub(in crate::worker) method: String, - pub(in crate::worker) request_headers: moli_fetch::RequestHeaders, - pub(in crate::worker) request_body_bytes: Option, - pub(in crate::worker) initial_network_request_headers: Option>, - pub(in crate::worker) intercept_response: bool, - pub(in crate::worker) handle_auth_requests: bool, -} - -impl PendingWorkerFetchNetworkRecord { - pub(super) fn follow_redirects(&mut self, head: &ResponseHead) { - if head.redirect_chain.is_empty() { - return; - } - let mut request = Request::get_with_url(self.url.clone()) - .with_redirect_headers(self.redirect_headers.take()); - request.method = std::mem::take(&mut self.method); - request.body = self.request_body_bytes.clone(); - request.request_headers = std::mem::take(&mut self.request_headers); - for redirect in &head.redirect_chain { - request.apply_redirect_status(redirect.status); - } - self.url = head.final_url.clone(); - self.method = request.method; - self.request_headers = request.request_headers; - self.request_body_bytes = request.body; + pub(super) fn into_fetch_parts(self) -> (ResponseHead, ResponseBody) { + self.response.into_body() } } @@ -159,85 +76,19 @@ pub(in crate::worker) struct PendingWorkerXhr { pub(in crate::worker) xhr: v8::Global, pub(in crate::worker) document_url: Url, pub(in crate::worker) credentials_mode: RequestCredentialsMode, - pub(in crate::worker) use_cors_preflight: bool, - pub(in crate::worker) load: ResourceLoadLease, - pub(in crate::worker) request_paused: bool, - pub(in crate::worker) request_url: Url, - pub(in crate::worker) request_method: String, - pub(in crate::worker) request_headers: moli_fetch::RequestHeaders, - pub(in crate::worker) request_body: Option, - pub(in crate::worker) network_request_handle: Option, - pub(in crate::worker) network_record: Option, - pub(in crate::worker) paused_response: Option, -} -pub(in crate::worker) struct PendingWorkerCspReport { pub(in crate::worker) load: ResourceLoadLease, - pub(in crate::worker) document_url: Url, - pub(in crate::worker) request: Request, - pub(in crate::worker) request_body: Option, - pub(in crate::worker) policy_context: crate::types::SubresourcePolicyContext, - pub(in crate::worker) service_worker_runtime: - Option, - pub(in crate::worker) service_worker_client_id: - Option, -} - -pub(in crate::worker) struct PausedWorkerSubresourceResponse { - pub(in crate::worker) head: ResponseHead, - pub(in crate::worker) body: SubresourceResponseBody, } pub(in crate::worker) struct WorkerXhrCompletion { - pub(in crate::worker) native_record: Option, + pub(in crate::worker) csp_violations: + Vec, pub(in crate::worker) xhr_id: u32, - pub(in crate::worker) network_request_headers: Option>, - pub(in crate::worker) result: Result, -} + // Rejections admitted before a native load use the Worker networking task. + // Aborting or reopening before that task runs suppresses their delivery. + pub(in crate::worker) local_request: Option>, -pub(in crate::worker) enum WorkerXhrResponse { - Materialized(Box), - Streamed { - head: Box, - body: SubresourceResponseBody, - }, -} - -impl WorkerXhrResponse { - pub(super) fn head(&self) -> ResponseHead { - match self { - Self::Materialized(response) => response.head(), - Self::Streamed { head, .. } => head.as_ref().clone(), - } - } - - pub(super) fn subresource_response_body(&self) -> SubresourceResponseBody { - match self { - Self::Materialized(response) => SubresourceResponseBody::from_fetch_response(response), - Self::Streamed { body, .. } => body.clone(), - } - } - - pub(super) fn into_body_source(self) -> Result<(ResponseHead, ResponseBody), String> { - match self { - Self::Materialized(response) => Ok(response.into_body()), - Self::Streamed { head, body } => body - .materialize_bytes() - .map(|bytes| (*head, ResponseBody::materialized_bytes(bytes))) - .map_err(|error| format!("failed to materialize worker XHR body: {error}")), - } - } -} - -pub(in crate::worker) struct WorkerWebSocketState { - pub(in crate::worker) wrapper: v8::Global, - pub(in crate::worker) connection: WebSocketConnectionHandle, - pub(in crate::worker) document_url: Url, - pub(in crate::worker) url: Url, - pub(in crate::worker) loader: crate::network::context::WorkerResourceLoader, - pub(in crate::worker) load: Option, - pub(in crate::worker) opened: bool, - pub(in crate::worker) network_recorded: bool, + pub(in crate::worker) result: Result, } pub(super) fn next_fetch_id(state: &mut WorkerGlobalState) -> u32 { @@ -279,3 +130,14 @@ pub(super) fn merge_worker_request_headers( headers.overlay(request_headers.clone()); headers } + +pub(in crate::worker) struct WorkerWebSocketState { + pub(in crate::worker) wrapper: v8::Global, + pub(in crate::worker) connection: WebSocketConnectionHandle, + pub(in crate::worker) document_url: Url, + pub(in crate::worker) url: Url, + pub(in crate::worker) loader: crate::network::context::WorkerResourceLoader, + pub(in crate::worker) load: Option, + pub(in crate::worker) opened: bool, + pub(in crate::worker) network_recorded: bool, +} diff --git a/moli-renderer-v8/src/worker/global_scope/service_worker_api.rs b/moli-renderer-v8/src/worker/global_scope/service_worker_api.rs index 35fcdb47287..6d4ef47c948 100644 --- a/moli-renderer-v8/src/worker/global_scope/service_worker_api.rs +++ b/moli-renderer-v8/src/worker/global_scope/service_worker_api.rs @@ -273,7 +273,7 @@ pub(super) fn service_worker_registration_show_notification_callback<'s>( }; if parent_tx .send(WorkerToParentMessage::ServiceWorkerShowNotification( - crate::runtime::ServiceWorkerShowNotification { + Box::new(crate::runtime::ServiceWorkerShowNotification { request_id, registration_id, version_id, @@ -282,7 +282,7 @@ pub(super) fn service_worker_registration_show_notification_callback<'s>( metadata: options.metadata, actions: options.actions, data: options.data, - }, + }), )) .is_err() { diff --git a/moli-renderer-v8/src/worker/global_scope/state.rs b/moli-renderer-v8/src/worker/global_scope/state.rs index 7e3f6438195..7f0ed311c46 100644 --- a/moli-renderer-v8/src/worker/global_scope/state.rs +++ b/moli-renderer-v8/src/worker/global_scope/state.rs @@ -107,7 +107,6 @@ pub(crate) struct WorkerGlobalState { /// Worker XHR id counter. pub(in crate::worker) next_xhr_id: u32, /// Worker-owned CSP report requests paused for Fetch domain request-stage interception. - pub(in crate::worker) pending_csp_reports: HashMap, /// Worker-local AbortController/AbortSignal runtime state. pub(in crate::worker) abort: Rc>, /// Worker-thread view of the creator's browser-context/partition runtime. diff --git a/moli-renderer-v8/src/worker/global_scope/xhr.rs b/moli-renderer-v8/src/worker/global_scope/xhr.rs index 462fc284337..32d39c6e551 100644 --- a/moli-renderer-v8/src/worker/global_scope/xhr.rs +++ b/moli-renderer-v8/src/worker/global_scope/xhr.rs @@ -1,8 +1,6 @@ use super::*; use crate::network_host::ResolveContextUrlError; -use crate::network_host::controlled_xhr::{ - ControlledXhrContext, XhrInterceptionRoute, start_buffered_xhr, -}; +use crate::network_host::controlled_xhr::{ControlledXhrContext, start_buffered_xhr}; use crossbeam_channel::{after, never, select}; use moli_webapi_declare::WebApiObject; use std::time::{Duration, SystemTime, UNIX_EPOCH}; @@ -43,7 +41,6 @@ impl std::error::Error for WorkerXhrSendPrepareError { } } -pub(in crate::worker) const WORKER_XHR_TIMEOUT_ERROR_TEXT: &str = "XMLHttpRequest timeout"; pub(in crate::worker) const WORKER_XHR_TIMEOUT_DATA_XHR: &str = "xhr"; pub(in crate::worker) const WORKER_XHR_TIMEOUT_DATA_XHR_ID: &str = "xhrId"; @@ -229,34 +226,6 @@ pub(in crate::worker) fn worker_xhr_timeout_callback( let pending = state.borrow_mut().pending_xhrs.remove(&scheduled_xhr_id); if let Some(pending) = pending { pending.load.cancel(); - if let Some(record) = pending.network_record { - let state = state.borrow(); - record_worker_subresource_failure_with_handle( - &state, - pending.network_request_handle, - pending.document_url, - record.url, - record.method, - record.request_headers, - record.request_body_bytes, - SubresourceResourceType::Xhr, - WORKER_XHR_TIMEOUT_ERROR_TEXT.to_owned(), - ); - let _ = state - .parent_tx - .send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { - internal_id: record.internal_id, - }, - )); - } else if pending.request_paused { - let _ = state.borrow().parent_tx.send( - WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id: scheduled_xhr_id, - error_text: WORKER_XHR_TIMEOUT_ERROR_TEXT.to_owned(), - }, - ); - } } apply_xhr_timeout(scope, xhr); rv.set_undefined(); @@ -409,14 +378,10 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( let loader = state.borrow().loader.clone(); let cancel_handle = state.borrow().network_cancel.child_for_subrequest(); - let route = if local_response.is_some() { - XhrInterceptionRoute::Ordinary - } else { - prepare_worker_xhr_interception_route(&state.borrow()) - }; + let control = prepare_worker_xhr_control(&state.borrow()); if !async_request { - send_synchronous_worker_xhr(scope, &state, xhr, prepared, loader, route); + send_synchronous_worker_xhr(scope, &state, xhr, prepared, loader, control); return true; } @@ -432,23 +397,14 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( let xhr_id = { let mut state = state.borrow_mut(); let xhr_id = next_xhr_id(&mut state); - let request_body = request_body_text(&prepared.send_body); state.pending_xhrs.insert( xhr_id, PendingWorkerXhr { xhr: v8::Global::new(scope, xhr), document_url: prepared.document_url.clone(), credentials_mode: prepared.credentials_mode, - use_cors_preflight: prepared.use_cors_preflight, + load: load.clone(), - request_paused: matches!(route, XhrInterceptionRoute::Compatibility), - request_url: prepared.resolved_url.clone(), - request_method: prepared.method.clone(), - request_headers: prepared.request_headers.clone(), - request_body, - network_request_handle: None, - network_record: None, - paused_response: None, }, ); xhr_id @@ -460,89 +416,35 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( // Local responses and network errors still complete asynchronously, so // abort(), open() and timeout processing use the ordinary pending XHR. let _ = state.borrow().xhr_completion_tx.send(WorkerXhrCompletion { - native_record: None, xhr_id, - network_request_headers: None, - result: result.map(|response| WorkerXhrResponse::Materialized(Box::new(response))), + result, + local_request: Some(Box::new(native_worker_xhr_info(&prepared))), + csp_violations: Vec::new(), }); return true; } - match route { - XhrInterceptionRoute::Native(control) => { - let completion_tx = state.borrow().xhr_completion_tx.clone(); - let info = native_worker_xhr_info(&prepared); - let request = worker_xhr_request(&state.borrow(), &prepared); - state - .borrow_mut() - .pending_xhrs - .get_mut(&xhr_id) - .unwrap() - .network_request_handle = info.network_request_handle; - load.task_runner().spawn(async move { - let completed = control - .load( - request, - info, - load, - cancel_handle, - prepared.request_headers.to_byte_strings(), - ) - .run() - .await; - let _ = completion_tx.send(WorkerXhrCompletion { - xhr_id, - network_request_headers: None, - native_record: Some(completed.network_record), - result: completed - .result - .map(|response| WorkerXhrResponse::Materialized(Box::new(response))), - }); - }); - return true; - } - XhrInterceptionRoute::Compatibility => { - // SharedWorker and standalone Worker embeddings use the public - // parent-owned continuation API, never an implicit native fallback. - let info = worker_xhr_info(&prepared); - let _ = state - .borrow() - .parent_tx - .send(WorkerToParentMessage::PendingSubresourceFetch( - WorkerPendingSubresourceFetch { - fetch_id: xhr_id, - load: load.clone(), - credentials_mode: prepared.credentials_mode, - request_mode: RequestMode::Cors, - network_partition_key: state.borrow().network_partition_key.clone(), - info, - }, - )); - return true; - } - XhrInterceptionRoute::Ordinary => {} - } - let completion_tx = state.borrow().xhr_completion_tx.clone(); - spawn_worker_xhr_network( - load, - completion_tx, - xhr_id, - cancel_handle, - prepared.document_url, - state.borrow().referrer_policy.clone(), - state.borrow().network_partition_key.clone(), - prepared.resolved_url, - prepared.method, - prepared.send_body, - prepared.request_headers, - prepared.credentials_mode, - prepared.use_cors_preflight, - None, - None, - Vec::new(), - ); - + let info = native_worker_xhr_info(&prepared); + let request = worker_xhr_request(&state.borrow(), &prepared); + load.task_runner().spawn(async move { + let completed = control + .load( + request, + info, + load, + cancel_handle, + prepared.request_headers.to_byte_strings(), + ) + .run() + .await; + let _ = completion_tx.send(WorkerXhrCompletion { + xhr_id, + local_request: None, + csp_violations: completed.csp_violations, + result: completed.result, + }); + }); true } @@ -573,26 +475,19 @@ fn worker_xhr_request( } request } - -fn prepare_worker_xhr_interception_route(state: &WorkerGlobalState) -> XhrInterceptionRoute { - if !state - .subresource_interception_config() - .intercepts(SubresourceResourceType::Xhr) - { - return XhrInterceptionRoute::Ordinary; - } - let Some(interception) = state.interception_context.clone() else { - return XhrInterceptionRoute::Compatibility; - }; - XhrInterceptionRoute::Native(ControlledXhrContext { - interception, +fn prepare_worker_xhr_control(state: &WorkerGlobalState) -> ControlledXhrContext { + ControlledXhrContext { + interception: state + .interception_context + .clone() + .expect("Worker XHR owns a native loader"), connect_policy: crate::document_runtime::DocumentConnectPolicySnapshot::from_worker_policies( state.content_security_policies.clone(), state.content_security_report_only_policies.clone(), state.content_security_reporting_endpoints.clone(), ), - }) + } } fn worker_xhr_info(prepared: &PreparedWorkerXhrSendRequest) -> PendingSubresourceFetchInfo { @@ -619,204 +514,67 @@ fn native_worker_xhr_info(prepared: &PreparedWorkerXhrSendRequest) -> PendingSub Some(crate::network::interception_control::next_subresource_network_handle()); info } - fn send_synchronous_worker_xhr( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, xhr: v8::Local<'_, v8::Object>, prepared: PreparedWorkerXhrSendRequest, loader: crate::network::context::WorkerResourceLoader, - route: XhrInterceptionRoute, + control: ControlledXhrContext, ) { let request_url_text = prepared.resolved_url.to_string(); - let control = match route.synchronous() { - Ok(control) => control, - Err(error) => { - record_worker_subresource_failure( - &state.borrow(), - prepared.document_url, - prepared.resolved_url, - prepared.method, - prepared.request_headers, - request_body_text(&prepared.send_body), - SubresourceResourceType::Xhr, - error.into(), - ); - throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError"); - return; - } - }; let request = worker_xhr_request(&state.borrow(), &prepared); - let request_url = prepared.resolved_url.clone(); - let request_method = prepared.method.clone(); - let request_headers = prepared.request_headers.clone(); - let preflight_headers = request_headers.to_byte_strings(); - let timeout_document_url = prepared.document_url.clone(); - let timeout_request_url = request_url.clone(); - let timeout_request_method = request_method.clone(); - let timeout_request_headers = request_headers.clone(); - - let cancel_handle = state.borrow().network_cancel.child_for_subrequest(); + let cancel = state.borrow().network_cancel.child_for_subrequest(); let Some(load) = loader.register_load( ResourceLoadKind::Xhr, ResourceLoadDisposition::Ordinary, - Some(cancel_handle.clone()), + Some(cancel.clone()), ) else { throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError"); return; }; - let info = if control.is_some() { - native_worker_xhr_info(&prepared) - } else { - worker_xhr_info(&prepared) - }; - let native_handle = control.as_ref().and(info.network_request_handle); let xhr_timeout = synchronous_worker_xhr_timeout(scope, xhr); let timeout_rx = xhr_timeout .as_ref() .map(|timeout| after(timeout.wait_delay)) .unwrap_or_else(never); - let native = control.is_some(); let response_rx = start_buffered_xhr( request, - info, + native_worker_xhr_info(&prepared), load.clone(), - cancel_handle, - preflight_headers, - control, + cancel, + prepared.request_headers.to_byte_strings(), + Some(control), ); - let result = select! { - recv(response_rx) -> result => result.unwrap_or_else(|_| { - Err("worker sync XHR resource task dropped response channel".to_owned()) - }), - recv(timeout_rx) -> _ => { - let timeout = xhr_timeout.as_ref().expect("never channel should not fire without xhr timeout"); - load.cancel(); - record_worker_subresource_failure_with_handle( - &state.borrow(), - native_handle, - timeout_document_url, - timeout_request_url, - timeout_request_method, - timeout_request_headers, - prepared.send_body.clone(), - SubresourceResourceType::Xhr, - format!( - "Synchronous XMLHttpRequest timed out after {} ms", - timeout.configured_timeout.as_millis() - ), - ); - throw_synchronous_xhr_failure( - scope, - xhr, - &request_url_text, - "TimeoutError", - ); - return; - } - }; - - if state.borrow().network_cancel.is_cancelled() { - return; - } - let completed = match result { - Ok(completed) => completed, - Err(error) => { - record_worker_subresource_failure_with_handle( - &state.borrow(), - native_handle, - prepared.document_url, - request_url, - request_method, - request_headers, - prepared.send_body, - SubresourceResourceType::Xhr, - error, - ); - throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError"); + recv(response_rx) -> result => result.unwrap_or_else(|_| Err("worker sync XHR resource task dropped response channel".into())), + recv(timeout_rx) -> _ => { + load.cancel(); + throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "TimeoutError"); return; } }; - let request_url = completed.info.url; - let request_method = completed.info.method; - let request_headers = completed.info.request_headers; - let request_body_bytes = completed.info.request_body_bytes; - let network_record = completed.network_record; - match completed.result { - Ok(response) => { - let response_head = response.head(); - let redirect_status = if response_head.redirect_chain.is_empty() { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect - } else { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - }; - if redirect_status - == crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - { - dispatch_worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status_for_state( - scope, - state, - &prepared.document_url, - &response_head.final_url, - &request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - redirect_status, - ); - } - let csp_violation = { - let state_ref = state.borrow(); - worker_content_security_policy_violation_for_checked_url_with_redirect_status( - &state_ref, - &prepared.document_url, - &response_head.final_url, - &request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - if response_head.redirect_chain.is_empty() { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect - } else { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - }, - ) - }; - if !native && let Some(violation) = csp_violation { - dispatch_worker_content_security_policy_violation_event_for_state( - scope, state, &violation, - ); - let message = worker_content_security_policy_error_message(&violation, "xhr"); - record_worker_subresource_failure_with_handle( - &state.borrow(), - native_handle, - prepared.document_url, - request_url, - request_method, - request_headers, - request_body_bytes.clone(), - SubresourceResourceType::Xhr, - message, - ); - throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError"); - return; - } - let _ = state - .borrow() - .parent_tx - .send(WorkerToParentMessage::SubresourceNetwork(network_record)); - apply_xhr_response(scope, xhr, response); + if state.borrow().network_cancel.is_cancelled() { + return; + } + // The loader has already published the network result independently of JS. + if let Ok(completed) = &result { + for violation in &completed.csp_violations { + dispatch_worker_content_security_policy_violation_event_for_state( + scope, state, violation, + ); } - Err(_) => { - let _ = state - .borrow() - .parent_tx - .send(WorkerToParentMessage::SubresourceNetwork(network_record)); - throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError"); + } + match result.map(|completion| completion.result) { + Ok(Ok(response)) => apply_xhr_response(scope, xhr, response), + Ok(Err(_)) | Err(_) => { + throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError") } } } struct SynchronousWorkerXhrTimeout { wait_delay: Duration, - configured_timeout: Duration, } fn synchronous_worker_xhr_timeout( @@ -825,7 +583,6 @@ fn synchronous_worker_xhr_timeout( ) -> Option { Some(SynchronousWorkerXhrTimeout { wait_delay: Duration::from_millis(worker_xhr_timeout_remaining_delay_ms(scope, xhr)?), - configured_timeout: Duration::from_millis(worker_xhr_configured_timeout_ms(scope, xhr)?), }) } @@ -857,88 +614,12 @@ pub(crate) fn try_worker_xhr_abort_callback( }; if let Some(pending) = pending { pending.load.cancel(); - if let Some(record) = pending.network_record { - let state = state.borrow(); - record_worker_subresource_failure_with_handle( - &state, - pending.network_request_handle, - pending.document_url, - record.url, - record.method, - record.request_headers, - record.request_body_bytes, - SubresourceResourceType::Xhr, - ABORTED_ERROR_TEXT.to_owned(), - ); - let _ = state - .parent_tx - .send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { - internal_id: record.internal_id, - }, - )); - } else if pending.request_paused { - let _ = state.borrow().parent_tx.send( - WorkerToParentMessage::PendingSubresourceFetchCanceled { - fetch_id: internal_id, - error_text: ABORTED_ERROR_TEXT.to_owned(), - }, - ); - } } crate::network_host::finish_xhr_abort(scope, xhr); true } -pub(in crate::worker) fn record_worker_xhr_failure( - state: &WorkerGlobalState, - pending: &PendingWorkerXhr, - message: String, -) { - let network_error_text = if is_cors_policy_failure_message(&message) { - FAILED_ERROR_TEXT.to_owned() - } else { - message - }; - if let Some(record) = pending.network_record.as_ref() { - record_worker_subresource_failure_with_handle( - state, - pending.network_request_handle, - pending.document_url.clone(), - record.url.clone(), - record.method.clone(), - record.request_headers.clone(), - record.request_body_bytes.clone(), - SubresourceResourceType::Xhr, - network_error_text, - ); - let _ = state - .parent_tx - .send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { - internal_id: record.internal_id, - }, - )); - return; - } - - record_worker_subresource_failure_with_handle( - state, - pending.network_request_handle, - pending.document_url.clone(), - pending.request_url.clone(), - pending.request_method.clone(), - pending.request_headers.clone(), - pending - .request_body - .as_ref() - .map(|body| bytes::Bytes::copy_from_slice(body.as_bytes())), - SubresourceResourceType::Xhr, - network_error_text, - ); -} - pub(in crate::worker) fn drain_worker_xhr_completion( scope: &mut v8::PinScope<'_, '_>, state: &Rc>, @@ -961,276 +642,38 @@ pub(in crate::worker) fn drain_worker_xhr_completion( } return; } - if let Some(record) = completion.native_record { - if let Ok(response) = &completion.result { - let head = response.head(); - if !head.redirect_chain.is_empty() { - let document_url = state - .borrow() - .pending_xhrs - .get(&completion.xhr_id) - .map(|pending| pending.document_url.clone()); - if let Some(document_url) = document_url { - dispatch_worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status_for_state( - scope, state, &document_url, &head.final_url, record.url(), - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect, - ); - } - } - } - let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) else { - return; - }; - pending.load.finish(); - cancel_worker_xhr_timeout(scope, xhr); - let _ = state - .borrow() - .parent_tx - .send(WorkerToParentMessage::SubresourceNetwork(record)); - match completion.result { - Ok(response) => match response.into_body_source() { - Ok((mut head, body)) => { - head.headers = filter_cors_exposed_response_headers( - &pending.document_url, - &head, - pending.credentials_mode, - ); - apply_xhr_response_body_source(scope, xhr, head, body); - } - Err(_) => apply_xhr_failure(scope, xhr), - }, - Err(_) => apply_xhr_failure(scope, xhr), - } - return; - } - let parent_tx = state.borrow().parent_tx.clone(); - if let Some(network_request_headers) = completion.network_request_headers.as_ref() - && let Some(record) = state - .borrow_mut() - .pending_xhrs - .get_mut(&completion.xhr_id) - .and_then(|pending| pending.network_record.as_mut()) - { - record - .initial_network_request_headers - .get_or_insert_with(|| network_request_headers.clone()); - } - if let Ok(response) = &completion.result { - let response_head = response.head(); - let redirect_status = if response_head.redirect_chain.is_empty() { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect - } else { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - }; - if redirect_status - == crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - { - let (document_url, request_url) = { - let state_ref = state.borrow(); - let Some(pending) = state_ref.pending_xhrs.get(&completion.xhr_id) else { - return; - }; - (pending.document_url.clone(), pending.request_url.clone()) - }; - dispatch_worker_content_security_policy_report_only_violation_for_checked_url_with_redirect_status_for_state( - scope, - state, - &document_url, - &response_head.final_url, - &request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - redirect_status, - ); - } - let csp_failure = { - let state_ref = state.borrow(); - let Some(pending) = state_ref.pending_xhrs.get(&completion.xhr_id) else { - return; - }; - worker_content_security_policy_violation_for_checked_url_with_redirect_status( - &state_ref, - &pending.document_url, - &response_head.final_url, - &pending.request_url, - crate::content_security_policy::ContentSecurityPolicyResourceKind::WorkerConnect, - if response_head.redirect_chain.is_empty() { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect - } else { - crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect - }, - ) - }; - if let Some(violation) = csp_failure { - dispatch_worker_content_security_policy_violation_event_for_state( - scope, state, &violation, - ); - let message = worker_content_security_policy_error_message(&violation, "xhr"); - let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) else { - return; - }; - pending.load.finish(); - let xhr = v8::Local::new(scope, &pending.xhr); - cancel_worker_xhr_timeout(scope, xhr); - record_worker_xhr_failure(&state.borrow(), &pending, message); - apply_xhr_failure(scope, xhr); - return; - } - let auth_required = { - let mut state_ref = state.borrow_mut(); - let Some(pending) = state_ref.pending_xhrs.get_mut(&completion.xhr_id) else { - return; - }; - let response_head = response.head(); - pending.network_record.clone().and_then(|mut record| { - if record.handle_auth_requests - && matches!(response_head.status, 401 | 407) - && let Some(challenge) = - extract_subresource_auth_challenge(&response_head.headers) - { - record.follow_redirects(&response_head); - let response_body = response.subresource_response_body(); - pending.paused_response = Some(PausedWorkerSubresourceResponse { - head: response_head.clone(), - body: response_body.clone(), - }); - Some(PendingSubresourceAuthInfo { - internal_id: record.internal_id, - url: record.url.clone(), - method: record.method.clone(), - request_headers: record.request_headers.clone(), - request_body: request_body_text(&record.request_body_bytes), - resource_type: SubresourceResourceType::Xhr, - request_cookie_report: response_head.request_cookie_report.clone(), - network_request_headers: record.initial_network_request_headers.clone(), - challenge, - intercept_response: record.intercept_response, - response_final_url: response_head.final_url.clone(), - response_status: response_head.status, - response_headers: response_head.headers.clone(), - response_body, - response_from_cache: response_head.from_cache, - response_cache_state: response_head.cache_state, - }) - } else { - None - } - }) - }; - if let Some(info) = auth_required { - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::AuthRequired(info), - )); - return; - } - let response_paused = { - let mut state = state.borrow_mut(); - let Some(pending) = state.pending_xhrs.get_mut(&completion.xhr_id) else { - return; - }; - let response_head = response.head(); - match pending.network_record.as_ref() { - Some(record) if record.intercept_response => { - let response_body = response.subresource_response_body(); - let info = PendingSubresourceResponseInfo { - internal_id: record.internal_id, - url: record.url.clone(), - final_url: response_head.final_url.clone(), - method: record.method.clone(), - request_headers: record.request_headers.clone(), - request_body: request_body_text(&record.request_body_bytes), - resource_type: SubresourceResourceType::Xhr, - request_cookie_report: response_head.request_cookie_report.clone(), - network_request_headers: record.initial_network_request_headers.clone(), - response_status: response_head.status, - response_headers: response_head.headers.clone(), - response_body: response_body.clone(), - from_cache: response_head.from_cache, - cache_state: response_head.cache_state, - }; - pending.paused_response = Some(PausedWorkerSubresourceResponse { - head: response_head, - body: response_body, - }); - Some(info) - } - _ => None, - } - }; - if let Some(info) = response_paused { - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::ResponsePaused(info), - )); - return; - } - } - let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) else { return; }; pending.load.finish(); - let xhr = v8::Local::new(scope, &pending.xhr); cancel_worker_xhr_timeout(scope, xhr); + if let (Some(info), Err(error)) = (&completion.local_request, &completion.result) { + record_worker_subresource_failure_with_handle( + &state.borrow(), + info.network_request_handle, + info.document_url.clone(), + info.url.clone(), + info.method.clone(), + info.request_headers.clone(), + info.request_body_bytes.clone(), + info.resource_type, + error.clone(), + ); + } + for violation in completion.csp_violations { + dispatch_worker_content_security_policy_violation_event_for_state(scope, state, &violation); + } match completion.result { Ok(response) => { - let response_head = response.head(); - match crate::network_host::validate_cors_response_chain( + let (mut head, body) = response.into_body(); + head.headers = filter_cors_exposed_response_headers( &pending.document_url, - &response_head, + &head, pending.credentials_mode, - ) { - Ok(()) => { - let response_body = pending - .network_record - .as_ref() - .map(|_| response.subresource_response_body()); - match response.into_body_source() { - Ok((mut response_head, body)) => { - if let Some(record) = pending.network_record.as_ref() - && let Some(response_body) = response_body - { - record_worker_subresource_success_with_handle( - &state.borrow(), - pending.network_request_handle, - pending.document_url.clone(), - record.url.clone(), - record.method.clone(), - record.request_headers.clone(), - record.request_body_bytes.clone(), - SubresourceResourceType::Xhr, - record.initial_network_request_headers.clone(), - response_head.clone(), - response_body, - ); - let _ = parent_tx.send(WorkerToParentMessage::SubresourceContinue( - PendingSubresourceContinueEvent::Completed { - internal_id: record.internal_id, - }, - )); - } - response_head.headers = filter_cors_exposed_response_headers( - &pending.document_url, - &response_head, - pending.credentials_mode, - ); - apply_xhr_response_body_source(scope, xhr, response_head, body); - } - Err(message) => { - record_worker_xhr_failure(&state.borrow(), &pending, message); - apply_xhr_failure(scope, xhr); - } - } - } - Err(message) => { - record_worker_xhr_failure(&state.borrow(), &pending, message); - apply_xhr_failure(scope, xhr); - } - } - } - Err(message) => { - record_worker_xhr_failure(&state.borrow(), &pending, message); - apply_xhr_failure(scope, xhr); + ); + apply_xhr_response_body_source(scope, xhr, head, body); } + Err(_) => apply_xhr_failure(scope, xhr), } } diff --git a/moli-renderer-v8/src/worker/handle.rs b/moli-renderer-v8/src/worker/handle.rs index 5b859403fa6..2f9e77256ba 100644 --- a/moli-renderer-v8/src/worker/handle.rs +++ b/moli-renderer-v8/src/worker/handle.rs @@ -1,10 +1,7 @@ //! Worker-side message types and parent-facing handle. -use crate::RendererSyntheticResponseBody; use crate::protocol_types::{ - PendingSubresourceContinueEvent, PendingSubresourceFetchInfo, SubresourceAuthCredentials, - SubresourceNetworkRecord, SubresourceNetworkRequestHandle, WebSocketFrameDirection, - WebSocketFrameOpcode, + SubresourceNetworkRecord, WebSocketFrameDirection, WebSocketFrameOpcode, }; use crate::runtime::WorkerInspectorError; use crate::runtime::{ @@ -37,7 +34,7 @@ use crate::types::{BroadcastChannelId, DedicatedWorkerId, MessagePortId, Network use crate::worker::inspector_task_runner::{WorkerInspectorTaskMode, WorkerInspectorTaskRunner}; use anyhow::Result; use moli_crypto::sha256_hex; -use moli_fetch::{RequestCredentialsMode, ResponseHead}; +use moli_fetch::ResponseHead; use moli_shared_worker::SharedWorkerInstanceId; use parking_lot::Mutex; use serde_json::Value; @@ -183,94 +180,6 @@ pub(crate) enum WorkerMessage { SetCacheDisabled(bool), /// Update the Network.setBlockedURLs state visible to worker-owned fetch/XHR. SetBlockedUrlPatterns(Vec), - /// Continue a worker-owned fetch() that was paused for Fetch domain interception. - ContinuePendingFetch(WorkerPendingFetchContinue), - /// Continue a worker-owned XHR that was paused for Fetch domain interception. - ContinuePendingXhr(WorkerPendingXhrContinue), - /// Continue a worker-owned CSP report that was paused for Fetch domain interception. - ContinuePendingCspReport(WorkerPendingFetchContinue), - /// Continue a worker-owned fetch() response that was paused for Fetch domain interception. - ContinuePendingFetchResponse { - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - }, - /// Continue a worker-owned XHR response that was paused for Fetch domain interception. - ContinuePendingXhrResponse { - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - }, - /// Fail a worker-owned fetch() that was paused for Fetch domain interception. - FailPendingFetch { - request: WorkerPendingFetchContinue, - error_text: String, - }, - /// Fail a worker-owned XHR that was paused for Fetch domain interception. - FailPendingXhr { - request: WorkerPendingXhrContinue, - error_text: String, - }, - /// Fail a worker-owned CSP report that was paused for Fetch domain interception. - FailPendingCspReport { - request: WorkerPendingFetchContinue, - error_text: String, - }, - /// Fail a worker-owned fetch() that was paused for Fetch domain auth handling. - FailPendingFetchAuth { - request: WorkerPendingFetchContinue, - error_text: String, - }, - /// Fail a worker-owned XHR that was paused for Fetch domain auth handling. - FailPendingXhrAuth { - request: WorkerPendingXhrContinue, - error_text: String, - }, - /// Fail a worker-owned fetch() response that was paused for Fetch domain interception. - FailPendingFetchResponse { - request: WorkerPendingFetchContinue, - error_text: String, - }, - /// Fail a worker-owned XHR response that was paused for Fetch domain interception. - FailPendingXhrResponse { - request: WorkerPendingXhrContinue, - error_text: String, - }, - /// Fulfill a worker-owned fetch() that was paused for Fetch domain interception. - FulfillPendingFetch { - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - /// Fulfill a worker-owned XHR that was paused for Fetch domain interception. - FulfillPendingXhr { - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - /// Fulfill a worker-owned CSP report that was paused for Fetch domain interception. - FulfillPendingCspReport { - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - /// Fulfill a worker-owned fetch() response that was paused for Fetch domain interception. - FulfillPendingFetchResponse { - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, - /// Fulfill a worker-owned XHR response that was paused for Fetch domain interception. - FulfillPendingXhrResponse { - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - }, /// Request the worker to terminate. Terminate, } @@ -335,7 +244,7 @@ pub(crate) enum WorkerToParentMessage { /// A Service Worker periodic sync event finished dispatch and all `waitUntil()` promises. ServiceWorkerPeriodicSyncCompleted(ServiceWorkerPeriodicSyncCompletion), /// A Service Worker requested display/recording of a notification. - ServiceWorkerShowNotification(ServiceWorkerShowNotification), + ServiceWorkerShowNotification(Box), /// A Service Worker requested stored notification snapshots. ServiceWorkerGetNotifications(ServiceWorkerGetNotifications), /// A Service Worker requested registration of a one-shot background sync tag. @@ -389,10 +298,12 @@ pub(crate) enum WorkerToParentMessage { /// Worker-owned subresource activity that should be surfaced through the page/CDP host. SubresourceNetwork(SubresourceNetworkRecord), /// Worker-owned fetch/XHR that should be paused by the page/CDP Fetch domain. + #[cfg(test)] PendingSubresourceFetch(WorkerPendingSubresourceFetch), /// Worker-owned fetch/XHR was canceled before CDP made a Fetch-domain decision. - PendingSubresourceFetchCanceled { fetch_id: u32, error_text: String }, + /// Completion signal for a worker-owned fetch/XHR that was continued after interception. + #[cfg(test)] SubresourceContinue(PendingSubresourceContinueEvent), /// Worker-owned WebSocket handshake activity. The embedded socket id is worker-local; the /// parent remaps it before exposing it through page-level CDP state. @@ -562,26 +473,18 @@ pub(crate) enum WorkerErrorSource { InitialScriptEvaluation, } +#[cfg(test)] #[derive(Debug, Clone)] pub(crate) struct WorkerPendingSubresourceFetch { - /// Opaque worker-local request id. Historically named `fetch_id`; also used for XHR pauses. - pub(crate) fetch_id: u32, - /// Request-time authority. Parent-side CDP continuation must use this - /// captured client instead of resolving whichever Worker or Document is - /// current when the command eventually arrives. - pub(crate) load: crate::network::loads::ResourceLoadLease, - pub(crate) credentials_mode: RequestCredentialsMode, - pub(crate) request_mode: moli_fetch::RequestMode, + pub(crate) fetch_id: u64, pub(crate) network_partition_key: Option, pub(crate) info: PendingSubresourceFetchInfo, } +#[cfg(test)] #[derive(Debug, Clone)] pub(crate) struct WorkerPendingFetchContinue { - pub(crate) redirect_headers: Option, - pub(crate) fetch_id: u32, - pub(crate) internal_id: u64, - pub(crate) network_request_handle: Option, + pub(crate) fetch_id: u64, pub(crate) url: Url, pub(crate) method: String, /// Upload bytes after applying explicit overrides, including an empty body. @@ -592,12 +495,10 @@ pub(crate) struct WorkerPendingFetchContinue { pub(crate) auth: Option, } +#[cfg(test)] #[derive(Debug, Clone)] pub(crate) struct WorkerPendingXhrContinue { - pub(crate) redirect_headers: Option, - pub(crate) xhr_id: u32, - pub(crate) internal_id: u64, - pub(crate) network_request_handle: Option, + pub(crate) xhr_id: u64, pub(crate) url: Url, pub(crate) method: String, /// Upload bytes after applying explicit overrides, including an empty body. @@ -1185,200 +1086,20 @@ impl WorkerHandle { .send(WorkerMessage::ServiceWorkerShowNotificationResult(result)); } - pub(crate) fn continue_pending_fetch(&self, request: WorkerPendingFetchContinue) { - let _ = self.tx.send(WorkerMessage::ContinuePendingFetch(request)); - } - - pub(crate) fn continue_pending_xhr(&self, request: WorkerPendingXhrContinue) { - let _ = self.tx.send(WorkerMessage::ContinuePendingXhr(request)); - } - - pub(crate) fn continue_pending_csp_report(&self, request: WorkerPendingFetchContinue) { - let _ = self - .tx - .send(WorkerMessage::ContinuePendingCspReport(request)); - } - - pub(crate) fn continue_pending_fetch_response( - &self, - request: WorkerPendingFetchContinue, - response_code: Option, - response_headers: Option)>>, - ) { - let _ = self.tx.send(WorkerMessage::ContinuePendingFetchResponse { - request, - response_code, - response_headers, - }); - } - - pub(crate) fn continue_pending_xhr_response( - &self, - request: WorkerPendingXhrContinue, - response_code: Option, - response_headers: Option)>>, - ) { - let _ = self.tx.send(WorkerMessage::ContinuePendingXhrResponse { - request, - response_code, - response_headers, - }); - } - - pub(crate) fn fail_pending_fetch( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) { - let _ = self.tx.send(WorkerMessage::FailPendingFetch { - request, - error_text, - }); - } - - pub(crate) fn fail_pending_xhr(&self, request: WorkerPendingXhrContinue, error_text: String) { - let _ = self.tx.send(WorkerMessage::FailPendingXhr { - request, - error_text, - }); - } - - pub(crate) fn fail_pending_csp_report( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) { - let _ = self.tx.send(WorkerMessage::FailPendingCspReport { - request, - error_text, - }); - } - - pub(crate) fn fail_pending_fetch_auth( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) { - let _ = self.tx.send(WorkerMessage::FailPendingFetchAuth { - request, - error_text, - }); - } - - pub(crate) fn fail_pending_xhr_auth( - &self, - request: WorkerPendingXhrContinue, - error_text: String, - ) { - let _ = self.tx.send(WorkerMessage::FailPendingXhrAuth { - request, - error_text, - }); - } - - pub(crate) fn fail_pending_fetch_response( - &self, - request: WorkerPendingFetchContinue, - error_text: String, - ) { - let _ = self.tx.send(WorkerMessage::FailPendingFetchResponse { - request, - error_text, - }); - } - - pub(crate) fn fail_pending_xhr_response( - &self, - request: WorkerPendingXhrContinue, - error_text: String, - ) { - let _ = self.tx.send(WorkerMessage::FailPendingXhrResponse { - request, - error_text, - }); - } - - pub(crate) fn fulfill_pending_fetch( - &self, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) { - let _ = self.tx.send(WorkerMessage::FulfillPendingFetch { - request, - response_code, - response_headers, - response_body, - }); - } - - pub(crate) fn fulfill_pending_xhr( - &self, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) { - let _ = self.tx.send(WorkerMessage::FulfillPendingXhr { - request, - response_code, - response_headers, - response_body, - }); - } - - pub(crate) fn fulfill_pending_csp_report( - &self, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) { - let _ = self.tx.send(WorkerMessage::FulfillPendingCspReport { - request, - response_code, - response_headers, - response_body, - }); - } - - pub(crate) fn fulfill_pending_fetch_response( - &self, - request: WorkerPendingFetchContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) { - let _ = self.tx.send(WorkerMessage::FulfillPendingFetchResponse { - request, - response_code, - response_headers, - response_body, - }); - } - - pub(crate) fn fulfill_pending_xhr_response( - &self, - request: WorkerPendingXhrContinue, - response_code: u16, - response_headers: Vec<(String, Vec)>, - response_body: RendererSyntheticResponseBody, - ) { - let _ = self.tx.send(WorkerMessage::FulfillPendingXhrResponse { - request, - response_code, - response_headers, - response_body, - }); - } - pub(crate) fn take_receiver( &mut self, ) -> Option> { self.rx.take() } + #[cfg(test)] + pub(crate) fn replace_test_receiver( + &mut self, + rx: mpsc::UnboundedReceiver, + ) { + self.rx = Some(rx); + } + #[cfg(test)] pub(crate) async fn recv(&mut self) -> Option { self.rx.as_mut()?.recv().await @@ -1415,3 +1136,8 @@ impl Drop for WorkerHandle { let _ = self.join_handle.take(); } } + +#[cfg(test)] +use crate::protocol_types::{ + PendingSubresourceContinueEvent, PendingSubresourceFetchInfo, SubresourceAuthCredentials, +}; diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index 1a86b4a4c43..394e974e78e 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -19,6 +19,7 @@ mod inspector_task_runner; mod module_mime; mod module_runtime; mod networking_tasks; +mod resource_output; mod script_loading; mod script_mime; mod thread; @@ -31,8 +32,10 @@ pub(crate) use thread::perform_callback_cleanup_checkpoint_if_worker; pub(crate) use data_url::decode_data_url_script_source; pub(crate) use global_scope::{ - NestedWorkerContext, WorkerGlobalState, WorkerOpfsCompletion, WorkerWebCryptoCompletion, - cancel_worker_opfs_task, check_worker_websocket_csp, close_worker_websocket, + NestedWorkerContext, WorkerFetchCompletion, WorkerFetchEvent, WorkerFetchResponse, + WorkerFetchStreamingChunk, WorkerFetchStreamingFinished, WorkerFetchStreamingStarted, + WorkerGlobalState, WorkerOpfsCompletion, WorkerWebCryptoCompletion, cancel_worker_opfs_task, + check_worker_websocket_csp, close_worker_websocket, dispatch_worker_trusted_types_sink_violation_event, ensure_worker_opfs_directory_iterator_registry, ensure_worker_opfs_handle_registry, forget_nested_worker_context, forget_worker_broadcast_channel_wrapper, @@ -58,8 +61,7 @@ pub(crate) use handle::WorkerMessage; pub(crate) use handle::{ WorkerBootstrapCompletion, WorkerBootstrapFailure, WorkerBootstrapSuccess, WorkerConsoleMessage, WorkerErrorPhase, WorkerErrorSource, WorkerFetchHandlerType, - WorkerParentErrorEventKind, WorkerPendingFetchContinue, WorkerPendingSubresourceFetch, - WorkerPendingXhrContinue, WorkerRuntimeEvent, WorkerRuntimeInspectorMessageBatch, + WorkerParentErrorEventKind, WorkerRuntimeEvent, WorkerRuntimeInspectorMessageBatch, WorkerScriptResource, WorkerScriptResourceKind, WorkerToParentMessage, WorkerWebSocketFrameEvent, WorkerWebSocketLifecycleEvent, }; @@ -78,3 +80,8 @@ pub(crate) use thread::{ WorkerGlobalKind, WorkerScriptKind, WorkerScriptSource, WorkerSpawnOptions, dispatch_current_worker_callback_exception, spawn_worker_with_options, }; + +#[cfg(test)] +pub(crate) use handle::{ + WorkerPendingFetchContinue, WorkerPendingSubresourceFetch, WorkerPendingXhrContinue, +}; diff --git a/moli-renderer-v8/src/worker/resource_output.rs b/moli-renderer-v8/src/worker/resource_output.rs new file mode 100644 index 00000000000..e3f97cd0cbb --- /dev/null +++ b/moli-renderer-v8/src/worker/resource_output.rs @@ -0,0 +1,67 @@ +use super::WorkerToParentMessage; +use crate::{ + network::{ResourceInterceptionEvent, interception_output::ResourceInterceptionContext}, + types::{ScriptExecutionReport, ScriptNetworkOutput}, +}; + +pub(crate) fn record_output( + report: &mut ScriptExecutionReport, + item: crate::types::ScriptNetworkOutputItem, +) -> Vec { + let mut output = ScriptNetworkOutput::default(); + output.push_item(item); + report.extend_network_output(output); + report.take_subresource_network_records() +} + +pub(crate) fn unobserved( + parent: tokio::sync::mpsc::UnboundedSender, +) -> ResourceInterceptionContext { + let report = parking_lot::Mutex::new(ScriptExecutionReport::default()); + ResourceInterceptionContext::worker(None, move |event| { + use ResourceInterceptionEvent as E; + match event { + E::Network(item) => { + for record in record_output(&mut report.lock(), *item) { + let _ = parent.send(WorkerToParentMessage::SubresourceNetwork(record)); + } + } + E::Request { info, pause } => { + let _ = pause.dispatch( + crate::RendererPageCommand::ContinuePendingSubresourceFetch { + internal_id: info.internal_id, + url: None, + method: None, + body: None, + headers: None, + intercept_response: false, + handle_auth_requests: false, + }, + ); + } + E::Continue { + event, + pause: Some(pause), + } => { + let command = match *event { + crate::types::PendingSubresourceContinueEvent::ResponsePaused(info) => { + crate::RendererPageCommand::ContinuePendingSubresourceResponse { + internal_id: info.internal_id, + response_code: None, + response_headers: None, + } + } + crate::types::PendingSubresourceContinueEvent::AuthRequired(info) => { + crate::RendererPageCommand::CancelPendingSubresourceAuth { + internal_id: info.internal_id, + } + } + crate::types::PendingSubresourceContinueEvent::Completed { .. } => return true, + }; + let _ = pause.dispatch(command); + } + E::Continue { .. } => {} + } + true + }) +} diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index a96fd7101ad..7b268780a5a 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -73,13 +73,11 @@ use runtime_inspector::WorkerRuntimeInspector; use super::global_scope::{ WorkerFetchEvent, WorkerGlobalState, WorkerIsolateTimerQueues, WorkerOpfsCompletion, WorkerWebCryptoCompletion, WorkerXhrCompletion, close_worker_owned_broadcast_channels, - close_worker_owned_message_ports, continue_pending_worker_csp_report, - continue_pending_worker_fetch, continue_pending_worker_fetch_response, - continue_pending_worker_xhr, continue_pending_worker_xhr_response, - dispatch_nested_worker_event, dispatch_worker_csp_violation_event, - dispatch_worker_websocket_event, drain_service_worker_client_focus_result, - drain_service_worker_client_navigate_result, drain_service_worker_client_query_result, - drain_service_worker_clients_open_window_result, drain_service_worker_get_notifications_result, + close_worker_owned_message_ports, dispatch_nested_worker_event, + dispatch_worker_csp_violation_event, dispatch_worker_websocket_event, + drain_service_worker_client_focus_result, drain_service_worker_client_navigate_result, + drain_service_worker_client_query_result, drain_service_worker_clients_open_window_result, + drain_service_worker_get_notifications_result, drain_service_worker_periodic_sync_get_tags_result, drain_service_worker_periodic_sync_registration_result, drain_service_worker_periodic_sync_unregistration_result, @@ -87,12 +85,7 @@ use super::global_scope::{ drain_service_worker_push_unsubscribe_result, drain_service_worker_show_notification_result, drain_service_worker_sync_get_tags_result, drain_service_worker_sync_registration_result, drain_worker_fetch_completion, drain_worker_opfs_completion, drain_worker_webcrypto_completion, - drain_worker_xhr_completion, fail_pending_worker_csp_report, fail_pending_worker_fetch, - fail_pending_worker_fetch_auth, fail_pending_worker_fetch_response, fail_pending_worker_xhr, - fail_pending_worker_xhr_auth, fail_pending_worker_xhr_response, - fulfill_pending_worker_csp_report, fulfill_pending_worker_fetch, - fulfill_pending_worker_fetch_response, fulfill_pending_worker_xhr, - fulfill_pending_worker_xhr_response, install_worker_global_scope, + drain_worker_xhr_completion, install_worker_global_scope, prepare_worker_global_scope_templates, service_worker_fetch_handler_type, }; use super::handle::{ @@ -224,6 +217,8 @@ pub(crate) struct WorkerTestHandle { handle: Option, request_client: ResourceRequestClient, _request_client_owner: Option, + native_pauses: + Arc>>, } #[cfg(test)] @@ -1243,8 +1238,76 @@ fn worker_test_request_client() -> ResourceRequestClientOwner { pub(crate) fn spawn_test_worker_with_options(mut options: WorkerSpawnOptions) -> WorkerTestHandle { let request_client_owner = options.test_request_client_owner.take(); let request_client = options.request_client.clone(); - let handle = spawn_worker_with_options(options); + let (tx, rx) = mpsc::unbounded_channel(); + let pauses = Arc::new(Mutex::new(std::collections::HashMap::< + u64, + crate::network::ResourceInterceptionPause, + >::new())); + let native_pauses = pauses.clone(); + let output = tx.clone(); + let report = Mutex::new(crate::types::ScriptExecutionReport::default()); + let partition = options.network_policy.network_partition_key.clone(); + options.interception_context = Some( + crate::network::interception_output::ResourceInterceptionContext::worker( + None, + move |event| { + use crate::network::ResourceInterceptionEvent as E; + match event { + E::Network(item) => { + for record in + super::resource_output::record_output(&mut report.lock(), *item) + { + let _ = output.send(WorkerToParentMessage::SubresourceNetwork(record)); + } + } + E::Request { info, pause } => { + let id = info.internal_id; + pauses.lock().insert(id, pause); + let _ = output.send(WorkerToParentMessage::PendingSubresourceFetch( + crate::worker::WorkerPendingSubresourceFetch { + fetch_id: id, + network_partition_key: partition.clone(), + info: *info, + }, + )); + } + E::Continue { event, pause } => { + let id = match event.as_ref() { + crate::types::PendingSubresourceContinueEvent::Completed { + internal_id, + } => *internal_id, + crate::types::PendingSubresourceContinueEvent::ResponsePaused(info) => { + info.internal_id + } + crate::types::PendingSubresourceContinueEvent::AuthRequired(info) => { + info.internal_id + } + }; + if let Some(pause) = pause { + pauses.lock().insert(id, pause); + } else { + pauses.lock().remove(&id); + return true; + } + let _ = output.send(WorkerToParentMessage::SubresourceContinue(*event)); + } + } + true + }, + ), + ); + let mut handle = spawn_worker_with_options(options); + let mut parent = handle.take_receiver().unwrap(); + tokio::spawn(async move { + while let Some(message) = parent.recv().await { + if tx.send(message).is_err() { + break; + } + } + }); + handle.replace_test_receiver(rx); WorkerTestHandle { + native_pauses, handle: Some(handle), request_client, _request_client_owner: request_client_owner, @@ -1484,12 +1547,18 @@ async fn worker_main( let mut bootstrap_completion = WorkerBootstrapCompletionReporter::new(bootstrap_completion_tx); let resource_task_runner = crate::network::RendererResourceTaskRunner::from_current_tokio() .expect("Worker owner loop must expose its resource task runner"); + let interception_context = Some( + interception_context + .map(|context| context.fork_worker_observer()) + .unwrap_or_else(|| super::resource_output::unobserved(parent_tx.clone())), + ); let loader = resource_loader_for_worker_context( request_client, &network_policy, &global_kind, resource_task_runner, ); + loader.set_interception_context(interception_context.clone()); // ── Create worker-level V8 isolate ───────────────────────────────────── let worker_indexed_db_manager = indexed_db_manager.clone(); @@ -1634,7 +1703,6 @@ async fn worker_main( xhr_completion_tx, pending_xhrs: std::collections::HashMap::new(), next_xhr_id: 0, - pending_csp_reports: std::collections::HashMap::new(), abort: Rc::new(RefCell::new(super::abort::WorkerAbortStore::default())), worker_context_runtime, service_worker_runtime, @@ -2782,151 +2850,6 @@ async fn worker_main( .request_client() .set_blocked_url_patterns(&patterns_for_loader); } - WorkerLoopWake::Message(Some(WorkerMessage::ContinuePendingFetch(request))) => { - continue_pending_worker_fetch(&state, request); - } - WorkerLoopWake::Message(Some(WorkerMessage::ContinuePendingXhr(request))) => { - continue_pending_worker_xhr(&state, request); - } - WorkerLoopWake::Message(Some(WorkerMessage::ContinuePendingCspReport(request))) => { - continue_pending_worker_csp_report(&state, request); - } - WorkerLoopWake::Message(Some(WorkerMessage::ContinuePendingFetchResponse { - request, - response_code, - response_headers, - })) => { - continue_pending_worker_fetch_response( - &state, - request, - response_code, - response_headers, - ); - } - WorkerLoopWake::Message(Some(WorkerMessage::ContinuePendingXhrResponse { - request, - response_code, - response_headers, - })) => { - continue_pending_worker_xhr_response( - &state, - request, - response_code, - response_headers, - ); - } - WorkerLoopWake::Message(Some(WorkerMessage::FailPendingFetch { - request, - error_text, - })) => { - fail_pending_worker_fetch(&state, request, error_text); - } - WorkerLoopWake::Message(Some(WorkerMessage::FailPendingXhr { - request, - error_text, - })) => { - fail_pending_worker_xhr(&state, request, error_text); - } - WorkerLoopWake::Message(Some(WorkerMessage::FailPendingCspReport { - request, - error_text, - })) => { - fail_pending_worker_csp_report(&state, request, error_text); - } - WorkerLoopWake::Message(Some(WorkerMessage::FailPendingFetchAuth { - request, - error_text, - })) => { - fail_pending_worker_fetch_auth(&state, request, error_text); - } - WorkerLoopWake::Message(Some(WorkerMessage::FailPendingXhrAuth { - request, - error_text, - })) => { - fail_pending_worker_xhr_auth(&state, request, error_text); - } - WorkerLoopWake::Message(Some(WorkerMessage::FailPendingFetchResponse { - request, - error_text, - })) => { - fail_pending_worker_fetch_response(&state, request, error_text); - } - WorkerLoopWake::Message(Some(WorkerMessage::FailPendingXhrResponse { - request, - error_text, - })) => { - fail_pending_worker_xhr_response(&state, request, error_text); - } - WorkerLoopWake::Message(Some(WorkerMessage::FulfillPendingFetch { - request, - response_code, - response_headers, - response_body, - })) => { - fulfill_pending_worker_fetch( - &state, - request, - response_code, - response_headers, - response_body, - ); - } - WorkerLoopWake::Message(Some(WorkerMessage::FulfillPendingXhr { - request, - response_code, - response_headers, - response_body, - })) => { - fulfill_pending_worker_xhr( - &state, - request, - response_code, - response_headers, - response_body, - ); - } - WorkerLoopWake::Message(Some(WorkerMessage::FulfillPendingCspReport { - request, - response_code, - response_headers, - response_body, - })) => { - fulfill_pending_worker_csp_report( - &state, - request, - response_code, - response_headers, - response_body, - ); - } - WorkerLoopWake::Message(Some(WorkerMessage::FulfillPendingFetchResponse { - request, - response_code, - response_headers, - response_body, - })) => { - fulfill_pending_worker_fetch_response( - &state, - request, - response_code, - response_headers, - response_body, - ); - } - WorkerLoopWake::Message(Some(WorkerMessage::FulfillPendingXhrResponse { - request, - response_code, - response_headers, - response_body, - })) => { - fulfill_pending_worker_xhr_response( - &state, - request, - response_code, - response_headers, - response_body, - ); - } WorkerLoopWake::Message(Some(WorkerMessage::Terminate)) => { trace!(url = %script_url, "worker terminated by parent"); break; @@ -3573,6 +3496,8 @@ fn evaluate_classic_worker_bootstrap_script( } } +#[cfg(test)] +mod test_resource_driver; #[cfg(test)] mod tests; diff --git a/moli-renderer-v8/src/worker/thread/test_resource_driver.rs b/moli-renderer-v8/src/worker/thread/test_resource_driver.rs new file mode 100644 index 00000000000..c141374ec5f --- /dev/null +++ b/moli-renderer-v8/src/worker/thread/test_resource_driver.rs @@ -0,0 +1,171 @@ +use super::*; +use crate::{RendererPageCommand as C, RendererSyntheticResponseBody}; +impl WorkerTestHandle { + pub(crate) async fn native_response_body( + &self, + id: u64, + ) -> crate::types::SubresourceResponseBody { + let body = self + .native_pauses + .lock() + .get(&id) + .unwrap() + .response_body() + .unwrap() + .clone(); + body.capture(64 * 1024 * 1024).await.unwrap() + } + + fn decide(&self, id: u64, command: C) { + self.native_pauses + .lock() + .get(&id) + .expect("a test decision requires its exact native pause") + .dispatch(command) + .expect("native test decision"); + } + pub(crate) fn continue_pending_fetch(&self, r: crate::worker::WorkerPendingFetchContinue) { + let id = r.fetch_id; + let command = match r.auth { + Some(auth) => C::ContinuePendingSubresourceAuth { + internal_id: id, + auth, + }, + None => C::ContinuePendingSubresourceFetch { + internal_id: id, + url: Some(r.url), + method: Some(r.method), + body: Some(r.body), + headers: Some(r.headers.into()), + intercept_response: r.intercept_response, + handle_auth_requests: r.handle_auth_requests, + }, + }; + self.decide(id, command); + } + pub(crate) fn continue_pending_xhr(&self, r: crate::worker::WorkerPendingXhrContinue) { + let id = r.xhr_id; + let command = match r.auth { + Some(auth) => C::ContinuePendingSubresourceAuth { + internal_id: id, + auth, + }, + None => C::ContinuePendingSubresourceFetch { + internal_id: id, + url: Some(r.url), + method: Some(r.method), + body: Some(r.body), + headers: Some(r.headers.into()), + intercept_response: r.intercept_response, + handle_auth_requests: r.handle_auth_requests, + }, + }; + self.decide(id, command); + } + pub(crate) fn fulfill_pending_fetch( + &self, + r: crate::worker::WorkerPendingFetchContinue, + status: u16, + headers: Vec<(String, Vec)>, + body: RendererSyntheticResponseBody, + ) { + self.fulfill(r.fetch_id, status, headers, body); + } + pub(crate) fn fulfill_pending_xhr( + &self, + r: crate::worker::WorkerPendingXhrContinue, + status: u16, + headers: Vec<(String, Vec)>, + body: RendererSyntheticResponseBody, + ) { + self.fulfill(r.xhr_id, status, headers, body); + } + fn fulfill( + &self, + id: u64, + status: u16, + headers: Vec<(String, Vec)>, + body: RendererSyntheticResponseBody, + ) { + self.decide( + id, + C::FulfillPendingSubresourceFetch { + internal_id: id, + request_overrides: None, + response_code: status, + response_headers: headers, + response_body: body, + }, + ); + } + + pub(crate) fn fail_pending_xhr( + &self, + r: crate::worker::WorkerPendingXhrContinue, + error_text: String, + ) { + self.decide( + r.xhr_id, + C::FailPendingSubresourceFetch { + internal_id: r.xhr_id, + error_text, + }, + ); + } + pub(crate) fn fail_pending_fetch_auth( + &self, + r: crate::worker::WorkerPendingFetchContinue, + error_text: String, + ) { + self.decide( + r.fetch_id, + C::FailPendingSubresourceAuth { + internal_id: r.fetch_id, + error_text, + }, + ); + } + pub(crate) fn fail_pending_xhr_auth( + &self, + r: crate::worker::WorkerPendingXhrContinue, + error_text: String, + ) { + self.decide( + r.xhr_id, + C::FailPendingSubresourceAuth { + internal_id: r.xhr_id, + error_text, + }, + ); + } + pub(crate) fn continue_pending_fetch_response( + &self, + r: crate::worker::WorkerPendingFetchContinue, + status: Option, + headers: Option)>>, + ) { + self.decide( + r.fetch_id, + C::ContinuePendingSubresourceResponse { + internal_id: r.fetch_id, + response_code: status, + response_headers: headers, + }, + ); + } + pub(crate) fn continue_pending_xhr_response( + &self, + r: crate::worker::WorkerPendingXhrContinue, + status: Option, + headers: Option)>>, + ) { + self.decide( + r.xhr_id, + C::ContinuePendingSubresourceResponse { + internal_id: r.xhr_id, + response_code: status, + response_headers: headers, + }, + ); + } +} diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs index b3db6e74fe3..88475cc4201 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs @@ -123,7 +123,6 @@ async fn dispatch_service_worker_fetch_event_and_handled_console_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rs index b6c678f5e92..b20a47b6e33 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/background_apis_and_worker_events.rs @@ -498,7 +498,6 @@ self.addEventListener("notificationclick", event => { | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -658,7 +657,6 @@ self.addEventListener("notificationclose", event => { | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -862,12 +860,9 @@ async fn worker_xmlhttprequest_abort_cancels_inflight_request_and_ignores_late_c loader, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); + let msg = recv_post_json(&mut handle).await; assert_eq!( - expect_post_json(msg), + msg, r#"{"readyState":0,"status":0,"responseURL":"","events":["abort","loadend:4:0"]}"# ); server.abort(); @@ -923,12 +918,9 @@ async fn worker_xmlhttprequest_timeout_cancels_inflight_request_and_ignores_late loader, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); + let msg = recv_post_json(&mut handle).await; assert_eq!( - expect_post_json(msg), + msg, r#"{"readyState":4,"status":0,"statusText":"","responseText":"","responseURL":"","contentType":null,"allHeaders":"","events":["readystatechange:1","readystatechange:4","timeout","loadend:4:0"]}"# ); server.abort(); diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/client_lifecycle_and_sync.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/client_lifecycle_and_sync.rs index 6d4d15db15d..9c75a3249a3 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/client_lifecycle_and_sync.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/client_lifecycle_and_sync.rs @@ -196,7 +196,6 @@ self.addEventListener("message", event => { | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -340,7 +339,6 @@ self.addEventListener("message", event => { | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -557,7 +555,6 @@ self.addEventListener("message", event => { | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs index 890121a86b4..302ad4d9893 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs @@ -261,7 +261,6 @@ async fn service_worker_fetch_handler_throw_without_respond_with_still_falls_bac | WorkerToParentMessage::RuntimeInspectorMessages(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -440,7 +439,6 @@ async fn service_worker_fetch_respond_with_readable_stream_body_posts_stream_chu WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -1207,7 +1205,6 @@ async fn service_worker_fetch_event_request_signal_aborts_with_parent_reason() { | WorkerToParentMessage::RuntimeInspectorMessages(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -1426,7 +1423,6 @@ async fn service_worker_fetch_respond_with_keeps_response_when_handler_throws_af | WorkerToParentMessage::RuntimeInspectorMessages(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/messages_clients_and_windows.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/messages_clients_and_windows.rs index 85b896fc223..4eee9db8cce 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/messages_clients_and_windows.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/messages_clients_and_windows.rs @@ -600,7 +600,6 @@ async fn service_worker_skip_waiting_posts_runtime_request() { } WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -689,7 +688,6 @@ async fn service_worker_clients_claim_posts_runtime_request() { } WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -957,7 +955,6 @@ async fn service_worker_clients_match_all_and_get_resolve_from_parent_query_resu | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -1319,7 +1316,6 @@ self.addEventListener("message", event => { | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -1463,7 +1459,6 @@ self.addEventListener("message", event => { | WorkerToParentMessage::ServiceWorkerClientsClaim { .. } | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs index 1b8b79c82f5..b42d9459077 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_errors_and_teardown.rs @@ -1170,7 +1170,6 @@ async fn worker_error_report_ignores_throwing_accessors() { WorkerToParentMessage::Post(_) => panic!("expected worker error"), WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs index 0f191fdd3a3..2285e39edc2 100644 --- a/moli-renderer-v8/src/worker/thread/tests/mod.rs +++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs @@ -47,7 +47,7 @@ use crate::network::ResourceRequestClient; use crate::protocol_types::{ PendingSubresourceContinueEvent, SubresourceAuthCredentials, SubresourceAuthScheme, SubresourceAuthTarget, SubresourceNetworkOutcome, SubresourceNetworkRecord, - SubresourceNetworkRequestHandle, SubresourceResourceType, + SubresourceResourceType, }; use crate::runtime::{ ServiceWorkerEventId, ServiceWorkerFetchCompletion, ServiceWorkerFetchEvent, @@ -350,7 +350,6 @@ async fn recv_post_json(handle: &mut WorkerHandle) -> String { WorkerToParentMessage::Post(payload) => return stringify_payload(&payload), WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -412,7 +411,6 @@ async fn dispatch_service_worker_lifecycle_event_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -508,7 +506,6 @@ async fn dispatch_service_worker_fetch_event_with_request_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -594,7 +591,6 @@ async fn dispatch_service_worker_message_event_object_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -657,7 +653,6 @@ async fn dispatch_service_worker_notification_event_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -726,7 +721,6 @@ async fn dispatch_service_worker_push_event_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -797,7 +791,6 @@ async fn dispatch_service_worker_sync_event_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -869,7 +862,6 @@ async fn dispatch_service_worker_periodic_sync_event_for_test( WorkerToParentMessage::Post(_) | WorkerToParentMessage::SubresourceNetwork(_) | WorkerToParentMessage::PendingSubresourceFetch(_) - | WorkerToParentMessage::PendingSubresourceFetchCanceled { .. } | WorkerToParentMessage::SubresourceContinue(_) | WorkerToParentMessage::WebSocketSubresource(_) | WorkerToParentMessage::WebSocketLifecycle(_) @@ -910,21 +902,13 @@ async fn dispatch_service_worker_periodic_sync_event_for_test( } } -fn owner_assigned_request_handle(internal_id: u64) -> SubresourceNetworkRequestHandle { - SubresourceNetworkRequestHandle::new(10_000 + internal_id) -} - fn pending_worker_fetch_continue( - fetch_id: u32, - internal_id: u64, + fetch_id: u64, info: &crate::protocol_types::PendingSubresourceFetchInfo, intercept_response: bool, ) -> WorkerPendingFetchContinue { WorkerPendingFetchContinue { - redirect_headers: None, fetch_id, - internal_id, - network_request_handle: Some(owner_assigned_request_handle(internal_id)), url: info.url.clone(), method: info.method.clone(), body: info.request_body_bytes.clone(), @@ -936,16 +920,12 @@ fn pending_worker_fetch_continue( } fn pending_worker_xhr_continue( - xhr_id: u32, - internal_id: u64, + xhr_id: u64, info: &crate::protocol_types::PendingSubresourceFetchInfo, intercept_response: bool, ) -> WorkerPendingXhrContinue { WorkerPendingXhrContinue { - redirect_headers: None, xhr_id, - internal_id, - network_request_handle: Some(owner_assigned_request_handle(internal_id)), url: info.url.clone(), method: info.method.clone(), body: info.request_body_bytes.clone(), @@ -1086,7 +1066,7 @@ async fn spawn_connection_drop_http_server(path: &'static str) -> (String, JoinH async fn spawn_redirect_loop_http_server(path: &'static str) -> (String, JoinHandle<()>) { // Keep each hop CORS-eligible so the test reaches the redirect limit. - const REDIRECT_LOOP_REQUESTS: usize = 11; + const REDIRECT_LOOP_REQUESTS: usize = 21; let listener = TcpListener::bind("127.0.0.1:0") .await .expect("bind worker redirect-loop http server"); diff --git a/moli-renderer-v8/src/worker/thread/tests/network/fetch_network.rs b/moli-renderer-v8/src/worker/thread/tests/network/fetch_network.rs index bdf3124b1ea..2cc9d6ceeaa 100644 --- a/moli-renderer-v8/src/worker/thread/tests/network/fetch_network.rs +++ b/moli-renderer-v8/src/worker/thread/tests/network/fetch_network.rs @@ -36,12 +36,9 @@ async fn worker_fetch_uses_worker_script_base_url_and_resolves_response_text() { loader, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); + let msg = recv_post_json(&mut handle).await; assert_eq!( - expect_post_json(msg), + msg, format!( r#"{{"ok":true,"status":200,"url":"{base_url}/assets/data.txt","text":"hello from worker fetch"}}"# ) @@ -96,25 +93,13 @@ async fn worker_fetch_resolves_response_before_delayed_body() { loader, ); - let headers = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out waiting for headers-first worker fetch") - .expect("worker channel closed"); - assert_eq!( - expect_post_json(headers), - r#"{"phase":"headers","status":200}"# - ); + let headers = recv_post_json(&mut handle).await; + assert_eq!(headers, r#"{"phase":"headers","status":200}"#); release_body_tx .send(()) .expect("delayed body receiver should still be waiting"); - let body = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out waiting for delayed worker fetch body") - .expect("worker channel closed"); - assert_eq!( - expect_post_json(body), - r#"{"phase":"body","text":"hello world"}"# - ); + let body = recv_post_json(&mut handle).await; + assert_eq!(body, r#"{"phase":"body","text":"hello world"}"#); server .await .expect("delayed worker fetch server should finish"); @@ -160,11 +145,8 @@ async fn worker_fetch_streams_spooled_response_body_chunks() { loader, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); - let payload = expect_post_json(msg); + let msg = recv_post_json(&mut handle).await; + let payload = msg; let payload = serde_json::from_str::(&payload) .expect("worker fetch stream result should be JSON"); assert_eq!(payload["status"], 200); @@ -233,11 +215,8 @@ async fn worker_fetch_applies_network_policy_extra_http_headers() { }, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); - assert_eq!(expect_post_json(msg), r#""works-worker""#); + let msg = recv_post_json(&mut handle).await; + assert_eq!(msg, r#""works-worker""#); server.await.expect("worker header server should finish"); } @@ -280,7 +259,7 @@ async fn worker_fetch_request_stage_interception_can_fulfill_synthetic_response( let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker fetch pause, got {pending:?}"); }; - assert!(pending.info.network_request_handle.is_none()); + assert!(pending.info.network_request_handle.is_some()); assert_eq!(pending.info.resource_type, SubresourceResourceType::Fetch); assert_eq!( pending.info.url.as_str(), @@ -291,7 +270,7 @@ async fn worker_fetch_request_stage_interception_can_fulfill_synthetic_response( Some("credentialless-worker-fetch") ); - let request = pending_worker_fetch_continue(pending.fetch_id, 17, &pending.info, false); + let request = pending_worker_fetch_continue(pending.fetch_id, &pending.info, false); handle.fulfill_pending_fetch( request, 202, @@ -362,22 +341,24 @@ async fn worker_subresource_request_handles_are_owner_unique() { }; assert!( - first_pending.info.network_request_handle.is_none(), - "worker pause should not allocate a local request handle" + first_pending.info.network_request_handle.is_some(), + "native Worker pause already owns its globally unique handle" ); assert!( - second_pending.info.network_request_handle.is_none(), - "worker pause should not allocate a local request handle" + second_pending.info.network_request_handle.is_some(), + "native Worker pause already owns its globally unique handle" ); let first_request = - pending_worker_fetch_continue(first_pending.fetch_id, 101, &first_pending.info, false); + pending_worker_fetch_continue(first_pending.fetch_id, &first_pending.info, false); let second_request = - pending_worker_fetch_continue(second_pending.fetch_id, 202, &second_pending.info, false); - let first_handle = first_request + pending_worker_fetch_continue(second_pending.fetch_id, &second_pending.info, false); + let first_handle = first_pending + .info .network_request_handle .expect("first owner-assigned worker fetch handle"); - let second_handle = second_request + let second_handle = second_pending + .info .network_request_handle .expect("second owner-assigned worker fetch handle"); assert_ne!( @@ -486,7 +467,7 @@ async fn worker_fetch_continue_request_resolves_response_before_delayed_body() { let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected continued worker fetch pause, got {pending:?}"); }; - let request = pending_worker_fetch_continue(pending.fetch_id, 61, &pending.info, false); + let request = pending_worker_fetch_continue(pending.fetch_id, &pending.info, false); handle.continue_pending_fetch(request); assert_eq!( @@ -549,7 +530,7 @@ async fn worker_fetch_response_stage_interception_pauses_before_resolving_respon let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker fetch pause, got {pending:?}"); }; - let request = pending_worker_fetch_continue(pending.fetch_id, 23, &pending.info, true); + let request = pending_worker_fetch_continue(pending.fetch_id, &pending.info, true); handle.continue_pending_fetch(request.clone()); let response_pause = timeout(TIMEOUT, handle.recv()) @@ -562,10 +543,15 @@ async fn worker_fetch_response_stage_interception_pauses_before_resolving_respon else { panic!("expected worker response-stage pause, got {response_pause:?}"); }; - assert_eq!(info.internal_id, 23); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!(info.response_status, 200); assert_eq!( - info.response_body.try_bytes().unwrap().as_ref(), + handle + .native_response_body(info.internal_id) + .await + .materialize_bytes() + .unwrap() + .as_slice(), b"origin-worker-body" ); @@ -638,7 +624,7 @@ async fn worker_fetch_response_stage_continue_preserves_large_spooled_body_strea let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected large worker fetch pause, got {pending:?}"); }; - let request = pending_worker_fetch_continue(pending.fetch_id, 71, &pending.info, true); + let request = pending_worker_fetch_continue(pending.fetch_id, &pending.info, true); handle.continue_pending_fetch(request.clone()); let response_pause = timeout(TIMEOUT, handle.recv()) @@ -651,9 +637,11 @@ async fn worker_fetch_response_stage_continue_preserves_large_spooled_body_strea else { panic!("expected large worker fetch response-stage pause, got {response_pause:?}"); }; - assert_eq!(info.internal_id, 71); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!( - info.response_body + handle + .native_response_body(info.internal_id) + .await .read_chunk(expected_len - 1, 1) .expect("spooled body tail should be readable"), b"x" @@ -709,7 +697,7 @@ async fn worker_fetch_auth_required_then_continue_with_auth_resolves() { let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker fetch auth request pause, got {pending:?}"); }; - let mut request = pending_worker_fetch_continue(pending.fetch_id, 47, &pending.info, false); + let mut request = pending_worker_fetch_continue(pending.fetch_id, &pending.info, false); request.handle_auth_requests = true; handle.continue_pending_fetch(request.clone()); @@ -723,7 +711,7 @@ async fn worker_fetch_auth_required_then_continue_with_auth_resolves() { else { panic!("expected worker fetch auth challenge, got {auth_pause:?}"); }; - assert_eq!(info.internal_id, 47); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!(info.resource_type, SubresourceResourceType::Fetch); assert_eq!(info.challenge.source, "Server"); assert_eq!(info.challenge.scheme, "basic"); @@ -731,7 +719,7 @@ async fn worker_fetch_auth_required_then_continue_with_auth_resolves() { assert!(!info.intercept_response); assert_initial_worker_auth_network_headers(info.network_request_headers.as_deref()); - let expected_request_handle = Some(owner_assigned_request_handle(47)); + let expected_request_handle = pending.info.network_request_handle; request.auth = Some(server_basic_auth_credentials()); handle.continue_pending_fetch(request); @@ -796,7 +784,7 @@ async fn worker_fetch_auth_required_then_fail_rejects_without_exposing_challenge let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker fetch auth request pause, got {pending:?}"); }; - let mut request = pending_worker_fetch_continue(pending.fetch_id, 53, &pending.info, false); + let mut request = pending_worker_fetch_continue(pending.fetch_id, &pending.info, false); request.handle_auth_requests = true; handle.continue_pending_fetch(request.clone()); @@ -810,10 +798,10 @@ async fn worker_fetch_auth_required_then_fail_rejects_without_exposing_challenge else { panic!("expected worker fetch auth challenge, got {auth_pause:?}"); }; - assert_eq!(info.internal_id, 53); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!(info.challenge.realm, "worker-fetch-area"); - let expected_request_handle = Some(owner_assigned_request_handle(53)); + let expected_request_handle = pending.info.network_request_handle; handle.fail_pending_fetch_auth(request, "worker fetch auth aborted".to_owned()); let network = timeout(TIMEOUT, handle.recv()) @@ -1978,7 +1966,7 @@ async fn worker_fetch_redirect_loop_rejects_and_reports_subresource_failure() { #[tokio::test] async fn worker_fetch_cross_origin_redirect_without_cors_rejects_and_reports_failure() { ensure_v8(); - let (source_base_url, _, source_server, target_server) = + let (source_base_url, target_base_url, source_server, target_server) = spawn_cross_origin_redirect_without_cors_http_servers( "/worker-fetch-cors-redirect-deny", "/worker-fetch-cors-denied-target", @@ -2035,7 +2023,10 @@ async fn worker_fetch_cross_origin_redirect_without_cors_rejects_and_reports_fai .await .expect("worker CORS redirect target server should finish"); let record = network.expect("worker fetch CORS redirect should record network failure"); - assert_eq!(record.url().as_str(), url); + assert_eq!( + record.url().as_str(), + format!("{target_base_url}/worker-fetch-cors-denied-target") + ); assert_eq!(record.resource_type(), SubresourceResourceType::Fetch); let SubresourceNetworkOutcome::Failure { error_text } = record.outcome() else { panic!("expected CORS network failure, got {:?}", record.outcome()); @@ -2116,11 +2107,13 @@ async fn worker_fetch_cross_origin_redirect_final_url_obeys_connect_src() { source_server .await .expect("worker CSP redirect source server should finish"); - target_server - .await - .expect("worker CSP redirect target server should finish"); + assert!( + !target_server.is_finished(), + "CSP refuses the redirected transport before dispatch" + ); + target_server.abort(); let record = network.expect("worker fetch CSP redirect should record network failure"); - assert_eq!(record.url().as_str(), url); + assert_eq!(record.url().path(), "/worker-fetch-csp-target"); assert_eq!(record.resource_type(), SubresourceResourceType::Fetch); assert!(matches!( record.outcome(), @@ -2135,6 +2128,53 @@ async fn worker_fetch_cross_origin_redirect_final_url_obeys_connect_src() { ); } +#[tokio::test] +async fn worker_fetch_redirect_reports_csp_once_before_response_delivery() { + ensure_v8(); + let (source_url, _, source_server, target_server) = + spawn_cross_origin_redirect_with_cors_http_servers( + "/report-redirect", + "/report-target", + "reported-body", + ) + .await; + let url = format!("{source_url}/report-redirect"); + let literal = serde_json::to_string(&url).unwrap(); + let loader = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let mut handle = spawn_test_worker_with_options( + WorkerSpawnOptions::new( + format!( + r#" + (async () => {{ + const violations = []; + addEventListener("securitypolicyviolation", event => violations.push({{ + blockedURI: event.blockedURI, + disposition: event.disposition, + }})); + const response = await fetch({literal}); + const text = await response.text(); + postMessage({{ text, violations }}); + close(); + }})(); + "# + ), + format!("{source_url}/worker/main.js"), + ) + .with_request_client(loader) + .with_content_security_report_only_policies(vec!["connect-src 'self'".into()]), + ); + let post: serde_json::Value = serde_json::from_str(&recv_post_json(&mut handle).await).unwrap(); + assert_eq!( + post, + serde_json::json!({ + "text": "reported-body", + "violations": [{"blockedURI": url, "disposition": "report"}], + }) + ); + source_server.await.unwrap(); + target_server.await.unwrap(); +} + #[tokio::test] async fn worker_blocked_url_pattern_update_reaches_running_worker() { ensure_v8(); @@ -2246,17 +2286,26 @@ async fn worker_fetch_projects_cache_modes_to_native_wire_requests() { spawn_worker_with_request_client(script, format!("http://{address}/worker.js"), loader); let mut result = None; let mut miss = None; - for _ in 0..2 { + while result.is_none() || miss.is_none() { match timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() { WorkerToParentMessage::Post(payload) => result = Some(stringify_payload(&payload)), - WorkerToParentMessage::SubresourceNetwork(record) => miss = Some(record), + WorkerToParentMessage::SubresourceNetwork(record) => { + if record.url().path() == "/wire/miss" { + miss = Some(record); + } else { + assert!(matches!( + record.outcome(), + SubresourceNetworkOutcome::Success { .. } + )); + } + } other => panic!("unexpected Worker cache result: {other:?}"), } } assert_eq!(result.as_deref(), Some("\"passed\"")); let miss = miss.expect("cache-only rejection must retain its network diagnostic"); assert_eq!(miss.url().path(), "/wire/miss"); - assert_eq!(miss.request_handle(), None); + assert!(miss.request_handle().is_some()); assert!(matches!( miss.outcome(), SubresourceNetworkOutcome::Failure { error_text } @@ -2384,3 +2433,141 @@ async fn worker_fetch_resource_timing_overflow_can_clear_and_refill_its_own_buff serde_json::json!({"firstCount":1,"trusted":true,"remaining":["/second"]}) ); } + +#[tokio::test] +async fn worker_fetch_and_xhr_cancel_only_their_own_native_request() { + ensure_v8(); + let mut handle = spawn_worker_with_request_client( + r#" + let xhr; + onmessage = event => { + if (event.data === 'abort') { xhr.abort(); return; } + fetch('/fetch').then(r => r.text()).then(text => postMessage({fetch:text})); + xhr = new XMLHttpRequest(); + xhr.open('GET', '/xhr'); + xhr.onabort = () => postMessage({xhr:'aborted'}); + xhr.send(); + }; + "# + .into(), + "http://example.test/worker.js".into(), + ResourceRequestClient::new(&FetchConfig::default()).unwrap(), + ); + handle.set_fetch_subresource_interception( + SubresourceInterceptionClasses::for_resource_type(SubresourceResourceType::Fetch).union( + SubresourceInterceptionClasses::for_resource_type(SubresourceResourceType::Xhr), + ), + ); + handle.post_message(serialize_test_string("start")); + let mut pauses = Vec::new(); + while pauses.len() != 2 { + if let WorkerToParentMessage::PendingSubresourceFetch(pause) = + timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() + { + pauses.push(pause); + } + } + let fetch = pauses + .iter() + .find(|p| p.info.resource_type == SubresourceResourceType::Fetch) + .unwrap(); + let xhr = pauses + .iter() + .find(|p| p.info.resource_type == SubresourceResourceType::Xhr) + .unwrap(); + assert_ne!(fetch.info.internal_id, xhr.info.internal_id); + assert_ne!( + fetch.info.network_request_handle, + xhr.info.network_request_handle + ); + handle.post_message(serialize_test_string("abort")); + let mut xhr_post = false; + let mut xhr_terminal = false; + while !xhr_post || !xhr_terminal { + match timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() { + WorkerToParentMessage::Post(payload) => { + assert_eq!(stringify_payload(&payload), r#"{"xhr":"aborted"}"#); + xhr_post = true; + } + WorkerToParentMessage::SubresourceNetwork(record) => { + assert_eq!(record.request_handle(), xhr.info.network_request_handle); + assert!( + matches!(record.outcome(), SubresourceNetworkOutcome::Failure { error_text } if error_text == "net::ERR_ABORTED") + ); + xhr_terminal = true; + } + WorkerToParentMessage::SubresourceContinue(_) => {} + other => panic!("unexpected cancellation output: {other:?}"), + } + } + let request = pending_worker_fetch_continue(fetch.fetch_id, &fetch.info, false); + handle.fulfill_pending_fetch( + request, + 200, + vec![("content-type".into(), b"text/plain".to_vec())], + RendererSyntheticResponseBody::from_bytes(b"fetch survives".to_vec()), + ); + let mut fetch_post = false; + let mut fetch_terminal = false; + while !fetch_post || !fetch_terminal { + match timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() { + WorkerToParentMessage::Post(payload) => { + assert_eq!(stringify_payload(&payload), r#"{"fetch":"fetch survives"}"#); + fetch_post = true; + } + WorkerToParentMessage::SubresourceNetwork(record) => { + assert_eq!(record.request_handle(), fetch.info.network_request_handle); + assert!(matches!( + record.outcome(), + SubresourceNetworkOutcome::Success { .. } + )); + fetch_terminal = true; + } + WorkerToParentMessage::SubresourceContinue(_) => {} + other => panic!("unexpected fetch output: {other:?}"), + } + } + handle.terminate_and_join(); +} + +#[tokio::test] +async fn worker_keepalive_continues_when_its_interceptor_and_js_owner_close() { + ensure_v8(); + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let addr = listener.local_addr().unwrap(); + let (entered_tx, entered_rx) = oneshot::channel(); + let (release_tx, release_rx) = oneshot::channel(); + let server = tokio::spawn(async move { + let (mut socket, _) = listener.accept().await.unwrap(); + let request = read_http_request_head(&mut socket).await.unwrap(); + assert!(request.starts_with("GET /keepalive HTTP/1.1\r\n")); + entered_tx.send(()).unwrap(); + release_rx.await.unwrap(); + socket + .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok") + .await + .unwrap(); + }); + let loader = ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let mut handle = spawn_worker_with_request_client( + r#"onmessage=event=>{if(event.data==='close'){close();return;}fetch('/keepalive',{keepalive:true});};"#.into(), + format!("http://{addr}/worker.js"), + loader.handle(), + ); + handle.set_fetch_subresource_interception(SubresourceInterceptionClasses::for_resource_type( + SubresourceResourceType::Fetch, + )); + handle.post_message(serialize_test_string("start")); + let WorkerToParentMessage::PendingSubresourceFetch(_) = + timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() + else { + panic!("keepalive must first be paused"); + }; + handle.post_message(serialize_test_string("close")); + // A disappearing target releases its interceptor; no Page/Worker command + // is needed to settle the native decision port. The keepalive lease stays. + timeout(TIMEOUT, entered_rx).await.unwrap().unwrap(); + handle.terminate_and_join(); + release_tx.send(()).unwrap(); + timeout(TIMEOUT, server).await.unwrap().unwrap(); +} diff --git a/moli-renderer-v8/src/worker/thread/tests/network/file_and_xhr.rs b/moli-renderer-v8/src/worker/thread/tests/network/file_and_xhr.rs index 5db88e5aa86..91c8be4ce0b 100644 --- a/moli-renderer-v8/src/worker/thread/tests/network/file_and_xhr.rs +++ b/moli-renderer-v8/src/worker/thread/tests/network/file_and_xhr.rs @@ -268,12 +268,9 @@ async fn worker_xmlhttprequest_uses_worker_script_base_url_and_event_target_list loader, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); + let msg = recv_post_json(&mut handle).await; assert_eq!( - expect_post_json(msg), + msg, format!( r#"{{"ctor":"function","eventTarget":true,"uploadTag":"[object XMLHttpRequestUpload]","status":200,"url":"{base_url}/assets/data.txt","text":"hello from worker xhr","readyState":4,"events":["prop-rs:readystatechange:1","rs:readystatechange:1","prop-rs:readystatechange:2","rs:readystatechange:2","prop-rs:readystatechange:3","rs:readystatechange:3","prop-rs:readystatechange:4","rs:readystatechange:4","prop-load:200","load:200:hello from worker xhr","prop-loadend:4","loadend:4"]}}"# ) @@ -321,7 +318,7 @@ async fn worker_xhr_request_stage_interception_can_fulfill_synthetic_response() let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker xhr pause, got {pending:?}"); }; - assert!(pending.info.network_request_handle.is_none()); + assert!(pending.info.network_request_handle.is_some()); assert_eq!(pending.info.resource_type, SubresourceResourceType::Xhr); assert_eq!( pending.info.url.as_str(), @@ -333,7 +330,7 @@ async fn worker_xhr_request_stage_interception_can_fulfill_synthetic_response() Some("credentialless-worker-xhr") ); - let request = pending_worker_xhr_continue(pending.fetch_id, 31, &pending.info, false); + let request = pending_worker_xhr_continue(pending.fetch_id, &pending.info, false); handle.fulfill_pending_xhr( request, 204, @@ -395,6 +392,13 @@ async fn worker_sync_xhr_request_stage_interception_reports_explicit_failure() { )); handle.post_message(serialize_test_string("go")); + let WorkerToParentMessage::PendingSubresourceFetch(pending) = + timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap() + else { + panic!("native synchronous XHR pauses before transport"); + }; + let request = pending_worker_xhr_continue(pending.fetch_id, &pending.info, false); + handle.fail_pending_xhr(request, "native sync failure".into()); let mut post = None; let mut network = None; for _ in 0..2 { @@ -424,7 +428,7 @@ async fn worker_sync_xhr_request_stage_interception_reports_explicit_failure() { assert!(matches!( record.outcome(), SubresourceNetworkOutcome::Failure { error_text } - if error_text == "Synchronous XMLHttpRequest interception requires a protocol output owner" + if error_text == "native sync failure" )); assert_eq!( post.expect("sync worker XHR interception should post final surface"), @@ -479,7 +483,7 @@ async fn worker_xhr_response_stage_interception_pauses_before_done() { let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker xhr pause, got {pending:?}"); }; - let request = pending_worker_xhr_continue(pending.fetch_id, 37, &pending.info, true); + let request = pending_worker_xhr_continue(pending.fetch_id, &pending.info, true); handle.continue_pending_xhr(request.clone()); let response_pause = timeout(TIMEOUT, handle.recv()) @@ -492,11 +496,16 @@ async fn worker_xhr_response_stage_interception_pauses_before_done() { else { panic!("expected worker xhr response-stage pause, got {response_pause:?}"); }; - assert_eq!(info.internal_id, 37); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!(info.resource_type, SubresourceResourceType::Xhr); assert_eq!(info.response_status, 200); assert_eq!( - info.response_body.try_bytes().unwrap().as_ref(), + handle + .native_response_body(info.internal_id) + .await + .materialize_bytes() + .unwrap() + .as_slice(), b"origin-worker-xhr" ); @@ -579,7 +588,7 @@ async fn worker_sync_xhr_timeout_cancels_fetch_and_throws_without_progress_event responseText: xhr.responseText, events, }); - close(); + // Keep this observer alive for native cancellation. })(); "# .into(), @@ -612,7 +621,7 @@ async fn worker_sync_xhr_timeout_cancels_fetch_and_throws_without_progress_event matches!( outcome, SubresourceNetworkOutcome::Failure { error_text } - if error_text == "Synchronous XMLHttpRequest timed out after 30 ms" + if error_text == "net::ERR_ABORTED" ), "expected sync worker XHR timeout failure, got {outcome:?}" ); @@ -774,7 +783,7 @@ async fn worker_xhr_response_stage_continue_preserves_large_spooled_body() { let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected large worker xhr pause, got {pending:?}"); }; - let request = pending_worker_xhr_continue(pending.fetch_id, 67, &pending.info, true); + let request = pending_worker_xhr_continue(pending.fetch_id, &pending.info, true); handle.continue_pending_xhr(request.clone()); let response_pause = timeout(TIMEOUT, handle.recv()) @@ -787,9 +796,11 @@ async fn worker_xhr_response_stage_continue_preserves_large_spooled_body() { else { panic!("expected large worker xhr response-stage pause, got {response_pause:?}"); }; - assert_eq!(info.internal_id, 67); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!( - info.response_body + handle + .native_response_body(info.internal_id) + .await .read_chunk(expected_len - 1, 1) .expect("spooled body tail should be readable"), b"x" @@ -847,7 +858,7 @@ async fn worker_xhr_auth_required_then_continue_with_auth_resolves() { let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker xhr auth request pause, got {pending:?}"); }; - let mut request = pending_worker_xhr_continue(pending.fetch_id, 41, &pending.info, false); + let mut request = pending_worker_xhr_continue(pending.fetch_id, &pending.info, false); request.handle_auth_requests = true; handle.continue_pending_xhr(request.clone()); @@ -861,7 +872,7 @@ async fn worker_xhr_auth_required_then_continue_with_auth_resolves() { else { panic!("expected worker xhr auth challenge, got {auth_pause:?}"); }; - assert_eq!(info.internal_id, 41); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!(info.resource_type, SubresourceResourceType::Xhr); assert_eq!(info.challenge.source, "Server"); assert_eq!(info.challenge.scheme, "basic"); @@ -935,7 +946,7 @@ async fn worker_xhr_auth_required_then_fail_errors_without_exposing_challenge_bo let WorkerToParentMessage::PendingSubresourceFetch(pending) = pending else { panic!("expected worker xhr auth request pause, got {pending:?}"); }; - let mut request = pending_worker_xhr_continue(pending.fetch_id, 43, &pending.info, false); + let mut request = pending_worker_xhr_continue(pending.fetch_id, &pending.info, false); request.handle_auth_requests = true; handle.continue_pending_xhr(request.clone()); @@ -949,7 +960,7 @@ async fn worker_xhr_auth_required_then_fail_errors_without_exposing_challenge_bo else { panic!("expected worker xhr auth challenge, got {auth_pause:?}"); }; - assert_eq!(info.internal_id, 43); + assert_eq!(info.internal_id, pending.info.internal_id); assert_eq!(info.challenge.realm, "worker-xhr-area"); handle.fail_pending_xhr_auth(request, "worker xhr auth aborted".to_owned()); @@ -1005,12 +1016,9 @@ async fn worker_xmlhttprequest_arraybuffer_preserves_response_bytes() { loader, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); + let msg = recv_post_json(&mut handle).await; assert_eq!( - expect_post_json(msg), + msg, r#"{"status":200,"bytes":"65,0,66","responseTextState":"InvalidStateError"}"# ); server @@ -1077,12 +1085,9 @@ async fn worker_xmlhttprequest_upload_dispatches_completion_events() { loader, ); - let msg = timeout(TIMEOUT, handle.recv()) - .await - .expect("timed out") - .expect("channel closed"); + let msg = recv_post_json(&mut handle).await; assert_eq!( - expect_post_json(msg), + msg, r#"{"status":200,"response":"{\"ok\":true}","uploadEvents":["loadstart:true:true:true:0:20","progress:true:true:true:20:20","load:true:true:true:20:20","loadend:true:true:true:20:20"],"uploadOrder":["xhr:loadstart","listener-before:loadstart","handler:loadstart","listener-after:loadstart","listener-before:progress","handler:progress","listener-after:progress","listener-before:load","handler:load","listener-after:load","listener-before:loadend","handler:loadend","listener-after:loadend"]}"# ); server @@ -1168,7 +1173,6 @@ async fn worker_xhr_upload_listener_preflight_survives_sync_and_interception() { }; handle.continue_pending_xhr(pending_worker_xhr_continue( pending.fetch_id, - 47, &pending.info, false, )); @@ -1741,7 +1745,7 @@ async fn worker_xmlhttprequest_redirect_loop_reports_error_after_loadstart() { #[tokio::test] async fn worker_xmlhttprequest_cross_origin_redirect_without_cors_reports_error_after_loadstart() { ensure_v8(); - let (source_base_url, _, source_server, target_server) = + let (source_base_url, target_base_url, source_server, target_server) = spawn_cross_origin_redirect_without_cors_http_servers( "/worker-xhr-cors-redirect-deny", "/worker-xhr-cors-denied-target", @@ -1809,7 +1813,10 @@ async fn worker_xmlhttprequest_cross_origin_redirect_without_cors_reports_error_ .await .expect("worker XHR CORS redirect target server should finish"); let record = network.expect("worker XHR CORS redirect should record network failure"); - assert_eq!(record.url().as_str(), url); + assert_eq!( + record.url().as_str(), + format!("{target_base_url}/worker-xhr-cors-denied-target") + ); assert_eq!(record.resource_type(), SubresourceResourceType::Xhr); assert!(matches!( record.outcome(), @@ -1911,11 +1918,13 @@ async fn worker_xmlhttprequest_cross_origin_redirect_final_url_obeys_connect_src source_server .await .expect("worker XHR CSP redirect source server should finish"); - target_server - .await - .expect("worker XHR CSP redirect target server should finish"); + assert!( + !target_server.is_finished(), + "CSP refuses the redirect before the target receives a request" + ); + target_server.abort(); let record = network.expect("worker XHR CSP redirect should record network failure"); - assert_eq!(record.url().as_str(), url); + assert_eq!(record.url().path(), "/worker-xhr-csp-target"); assert_eq!(record.resource_type(), SubresourceResourceType::Xhr); assert!(matches!( record.outcome(), diff --git a/moli-types/moli-page-types/src/lib.rs b/moli-types/moli-page-types/src/lib.rs index a3e2cda0f38..5384ed34ea5 100644 --- a/moli-types/moli-page-types/src/lib.rs +++ b/moli-types/moli-page-types/src/lib.rs @@ -916,6 +916,17 @@ impl ScriptExecutionReport { &self.inspector_issues } + /// Incremental consumers can release completed captures while other loads remain in flight. + pub fn take_subresource_network_records(&mut self) -> Vec { + let records = std::mem::take(&mut self.subresource_network_records); + if let Some(state) = self.staged_subresource_lifecycle.as_mut() { + for handle in records.iter().filter_map(|record| record.request_handle()) { + state.completed_handles.remove(&handle.get()); + } + } + records + } + pub fn subresource_network_records(&self) -> &[SubresourceNetworkRecord] { &self.subresource_network_records } @@ -1130,6 +1141,7 @@ impl SubresourceNetworkRequestHandle { #[derive(Debug, Clone, PartialEq, Eq)] pub struct SubresourceRequestStarted { + redirect: Option>, handle: SubresourceNetworkRequestHandle, frame_id: Option, document_url: Url, @@ -1231,6 +1243,7 @@ impl SubresourceRequestStarted { ) -> Self { let request_body_bytes = request_body_text_bytes(&request_body); Self { + redirect: None, handle, frame_id, document_url, @@ -1246,6 +1259,14 @@ impl SubresourceRequestStarted { } } + pub fn with_redirect(mut self, redirect: Option) -> Self { + self.redirect = redirect.map(Box::new); + self + } + pub fn redirect(&self) -> Option<&NavigationRedirect> { + self.redirect.as_deref() + } + pub fn handle(&self) -> SubresourceNetworkRequestHandle { self.handle }