From ed9ad079c25e165ac4d0995d5358bdf3b7f4f952 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Mon, 16 Nov 2026 02:32:15 +0800 Subject: [PATCH] refactor(worker): own fetch and XHR loading natively Give each load a stable native network handle and single-use interception ports. Keep Worker Promise settlement separate from network completion, route observations to Worker targets, and remove the parent request table and continuation messages. Cover cancellation, streaming, request overrides, authentication, CSP and Service Worker responses. Keep the bucket-deletion test transaction active until retirement instead of racing its normal auto-commit. --- moli-core/src/network/mod.rs | 3 +- moli-core/src/page/resource_command.rs | 6 + moli-protocol/src/conn.rs | 6 + .../src/conn/browser_context/fetch_owner.rs | 215 +- .../src/conn/browser_context/lifecycle.rs | 5 + moli-protocol/src/conn/browser_context/mod.rs | 1 + .../src/conn/browser_context/network_owner.rs | 12 +- .../browser_context/target_session_owner.rs | 87 +- .../conn/browser_context/worker_resource.rs | 89 + moli-protocol/src/conn/fetch_support.rs | 123 +- moli-protocol/src/conn/state/fetch.rs | 36 +- moli-protocol/src/conn/state/runtime_slot.rs | 11 + .../src/conn/state/shared_worker_target.rs | 14 + .../state_access/direct/projection_tests.rs | 1 + .../conn/state_access/worker_projection.rs | 18 + .../src/conn/target/worker_auto_attach.rs | 8 + moli-protocol/src/domains/activity/mod.rs | 2 + .../src/domains/activity/subresource.rs | 79 +- moli-protocol/src/domains/fetch.rs | 1 + moli-protocol/src/domains/fetch/auth.rs | 21 +- .../src/domains/fetch/body_stream.rs | 6 +- moli-protocol/src/domains/fetch/cleanup.rs | 34 +- moli-protocol/src/domains/fetch/commands.rs | 39 +- .../src/domains/fetch/subresource.rs | 60 +- .../domains/fetch/subresource_continuation.rs | 27 +- .../src/domains/fetch/tests/basics.rs | 11 +- .../src/domains/fetch/tests/binary_request.rs | 40 +- .../fetch/tests/command_correlation.rs | 27 +- .../src/domains/fetch/tests/header_bytes.rs | 4 + .../runtime_fetch/fulfilled_redirects.rs | 8 +- .../fulfilled_redirects/cors_order.rs | 37 +- .../fetch/tests/runtime_fetch/native_xhr.rs | 32 +- .../native_xhr/terminal_consistency.rs | 3 + .../runtime_fetch/worker_delivery_abort.rs | 88 +- .../runtime_fetch/worker_redirect_modes.rs | 4 +- .../tests/runtime_fetch/worker_requests.rs | 60 +- .../fetch/tests/subresource_auth_retry.rs | 1 + moli-protocol/src/domains/network/activity.rs | 46 + moli-protocol/src/domains/network/agent.rs | 5 +- moli-protocol/src/domains/network/backlog.rs | 42 +- moli-protocol/src/domains/network/events.rs | 16 +- moli-protocol/src/domains/network/output.rs | 9 + .../src/domains/network/output_queue.rs | 5 + .../src/domains/network/tests/blocked_urls.rs | 25 +- moli-protocol/src/domains/target.rs | 7 +- .../src/domains/target/worker_target.rs | 7 + .../target/worker_target/event_projection.rs | 10 + .../worker_target/lifecycle_projection.rs | 28 + .../target/worker_target/resource_loading.rs | 56 + .../target/worker_target/shared_worker.rs | 6 +- .../src/domains/target/worker_target/tests.rs | 1 + .../target/worker_target_attachment_tests.rs | 1 + moli-protocol/src/testing.rs | 180 ++ .../worker_host/constructor.rs | 20 +- .../context_bootstrap/worker_host/dispatch.rs | 6 +- .../native_bridge/context_host/activity.rs | 2 +- .../src/native_bridge/context_host/core.rs | 1 - .../src/native_bridge/context_host/mod.rs | 6 +- .../context_host/resource_loading.rs | 595 +---- .../context_host/shared_workers.rs | 229 +- .../context_host/workers/registration.rs | 452 +--- .../src/network/context/worker.rs | 15 + .../src/network/interception_control.rs | 9 + .../src/network/interception_output.rs | 43 +- .../src/network/interception_output/worker.rs | 222 ++ .../src/network/loads/registry.rs | 16 - moli-renderer-v8/src/network/mod.rs | 1 + .../src/network/request_client.rs | 6 + moli-renderer-v8/src/network_host.rs | 14 +- .../src/network_host/async_fetch.rs | 13 +- .../src/network_host/body_source.rs | 92 +- .../src/network_host/controlled_xhr.rs | 407 +++- .../network_host/controlled_xhr/context.rs | 28 +- .../src/network_host/controlled_xhr/fetch.rs | 279 +++ .../src/network_host/controlled_xhr/result.rs | 3 + .../controlled_xhr/service_worker.rs | 106 + .../src/network_host/controlled_xhr/stream.rs | 48 +- .../src/network_host/preflight_events.rs | 20 +- moli-renderer-v8/src/network_host/response.rs | 1 - .../src/network_host/response/materialize.rs | 20 - .../src/network_host/response_hop.rs | 8 + .../src/network_host/xhr/send/paths.rs | 4 +- .../src/page_task_queue/worker_host_bridge.rs | 32 +- .../src/runtime/browser_context_runtime.rs | 11 + .../dedicated_workers.rs | 5 + .../browser_context_runtime/shared_workers.rs | 243 -- moli-renderer-v8/src/runtime/page_surface.rs | 19 + .../worker_messages_and_service_workers.rs | 18 +- .../page_vm/tests/worker_host_bridge.rs | 28 +- .../protocol_output/transport_memory.rs | 17 + .../runtime/protocol_output/turn_journal.rs | 13 +- .../dedicated_worker_client_event_body.rs | 12 +- .../src/script_vm/subresource_fetch.rs | 234 +- .../subresource_fetch/fetch_dispatch.rs | 16 +- .../subresource_fetch/intercepted_fetch.rs | 367 ---- .../intercepted_redirects.rs | 7 +- .../subresource_fetch/pending_fetch.rs | 954 +------- .../script_vm/subresource_fetch/streaming.rs | 16 +- .../misc/extracted/service_worker_events.rs | 175 -- .../service_worker_surface/redirect_modes.rs | 4 +- .../script_vm/tests/extracted/window_apis.rs | 1 - .../idb_sqlite_factory/deletion_tests.rs | 7 +- moli-renderer-v8/src/script_vm/tests/mod.rs | 12 - .../url_and_initializer_semantics.rs | 6 +- .../src/script_vm/tests/websocket.rs | 1 + .../src/script_vm/worker_host_bridge_body.rs | 155 +- .../src/service_worker_runtime/host.rs | 12 +- .../src/service_worker_runtime/service.rs | 1 + .../service/event_dispatch.rs | 26 + .../service/fetch_settlement.rs | 13 +- .../service/tests/extracted/fetch_events.rs | 6 + .../tests/extracted/functional_events.rs | 2 +- .../tests/extracted/registration_jobs.rs | 1 + .../src/service_worker_runtime/state.rs | 8 + moli-renderer-v8/src/shared_worker_runtime.rs | 2 - .../src/shared_worker_runtime/events.rs | 6 +- .../host_target_output.rs | 33 +- .../src/shared_worker_runtime/host_worker.rs | 38 +- .../shared_worker_runtime/load_completion.rs | 1 - .../resource_commands.rs | 198 -- .../shared_worker_runtime/resource_routing.rs | 550 ----- .../src/shared_worker_runtime/routing.rs | 20 +- .../src/shared_worker_runtime/worker_close.rs | 2 +- moli-renderer-v8/src/types.rs | 41 - .../global_scope/content_security_policy.rs | 750 +------ .../src/worker/global_scope/fetch.rs | 1955 +---------------- .../worker/global_scope/fetch/native_load.rs | 97 + .../src/worker/global_scope/mod.rs | 50 +- .../src/worker/global_scope/network_state.rs | 228 +- .../worker/global_scope/service_worker_api.rs | 4 +- .../src/worker/global_scope/state.rs | 1 - .../src/worker/global_scope/xhr.rs | 719 +----- moli-renderer-v8/src/worker/handle.rs | 324 +-- moli-renderer-v8/src/worker/mod.rs | 15 +- .../src/worker/resource_output.rs | 67 + moli-renderer-v8/src/worker/thread/mod.rs | 245 +-- .../src/worker/thread/test_resource_driver.rs | 171 ++ .../src/worker/thread/tests/lifecycle.rs | 1 - .../background_apis_and_worker_events.rs | 16 +- .../lifecycle/client_lifecycle_and_sync.rs | 3 - .../lifecycle/fetch_events_and_messages.rs | 4 - .../lifecycle/messages_clients_and_windows.rs | 5 - .../lifecycle/worker_errors_and_teardown.rs | 1 - .../src/worker/thread/tests/mod.rs | 28 +- .../thread/tests/network/fetch_network.rs | 313 ++- .../thread/tests/network/file_and_xhr.rs | 83 +- moli-types/moli-page-types/src/lib.rs | 21 + 147 files changed, 3844 insertions(+), 8899 deletions(-) create mode 100644 moli-protocol/src/conn/browser_context/worker_resource.rs create mode 100644 moli-protocol/src/domains/target/worker_target/resource_loading.rs create mode 100644 moli-renderer-v8/src/network/interception_output/worker.rs create mode 100644 moli-renderer-v8/src/network_host/controlled_xhr/fetch.rs create mode 100644 moli-renderer-v8/src/network_host/controlled_xhr/service_worker.rs delete mode 100644 moli-renderer-v8/src/shared_worker_runtime/resource_commands.rs delete mode 100644 moli-renderer-v8/src/shared_worker_runtime/resource_routing.rs create mode 100644 moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs create mode 100644 moli-renderer-v8/src/worker/resource_output.rs create mode 100644 moli-renderer-v8/src/worker/thread/test_resource_driver.rs 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 }