mirror of
https://github.com/lexmount/moli.git
synced 2026-11-18 16:08:37 +00:00
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.
This commit is contained in:
@@ -12,5 +12,6 @@ pub use moli_renderer_v8::network::{
|
||||
};
|
||||
|
||||
pub use moli_renderer_v8::network::{
|
||||
ResourceInterceptionBody, ResourceInterceptionPause, ResourceInterceptionReply,
|
||||
ResourceInterceptionBody, ResourceInterceptionEvent, ResourceInterceptionPause,
|
||||
ResourceInterceptionPolicy, ResourceInterceptionReply,
|
||||
};
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
|
||||
@@ -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())
|
||||
}
|
||||
|
||||
@@ -101,6 +101,14 @@ fn fetch_body_stream_owner_for_target_mut<'a>(
|
||||
target_id: &str,
|
||||
) -> Option<SessionFetchBodyStreamOwner<'a>> {
|
||||
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<crate::conn::ProtocolResponseBody>,
|
||||
) -> Result<String> {
|
||||
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<crate::conn::ProtocolResponseBody>,
|
||||
) -> Result<String> {
|
||||
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<moli_core::page::PendingResourceCommand> {
|
||||
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<crate::conn::ClaimedSubresourceContinueRequest> {
|
||||
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<Result<(), &'static str>> {
|
||||
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<PendingFetchNavigation> {
|
||||
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<PendingFetchAuthNavigation> {
|
||||
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<PausedDocumentTransfer> {
|
||||
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<crate::conn::PendingDocumentBodyRead> {
|
||||
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<PausedDocumentTransfer> {
|
||||
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<T>,
|
||||
) -> Option<Result<T>> {
|
||||
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<PendingSubresourceFetchResponseRequest> {
|
||||
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<Option<String>> {
|
||||
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<usize>,
|
||||
size: Option<usize>,
|
||||
) -> 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<PendingSubresourceFetchRequest> {
|
||||
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<PendingSubresourceFetchRequest> {
|
||||
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<PendingSubresourceFetchAuthRequest> {
|
||||
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<PendingSubresourceFetchResponseRequest> {
|
||||
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<String> {
|
||||
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<String> {
|
||||
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<FetchInterceptionPattern>,
|
||||
) -> Result<Option<moli_core::page::PendingPageCommand>> {
|
||||
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<String>,
|
||||
patterns: Vec<FetchInterceptionPattern>,
|
||||
) -> Result<Option<moli_core::page::PendingPageCommand>> {
|
||||
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<Option<moli_core::page::PendingPageCommand>> {
|
||||
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<Result<moli_core::page::PendingPageCommand>>,
|
||||
)> {
|
||||
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<Result<moli_core::page::PendingPageCommand>>,
|
||||
)> {
|
||||
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<DrainedFetchRequests> {
|
||||
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<crate::conn::NavigationDispatchState> {
|
||||
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<SessionPendingFetchOwner<'_>> {
|
||||
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,
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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<Page> {
|
||||
@@ -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<TargetFetchConfig> {
|
||||
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<String> {
|
||||
if self.worker_resource_identity_for_owner(owner).is_some() {
|
||||
return None;
|
||||
}
|
||||
self.target_session_owner_ref_for_owner(owner)?
|
||||
.primary_session_id()
|
||||
}
|
||||
|
||||
@@ -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<crate::domains::network::TargetNetworkBacklogPreparedDelivery> {
|
||||
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<TargetSessionOwnerMut<'_>> {
|
||||
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<TargetSessionOwnerMut<'_>> {
|
||||
let owner = CommandOwnerScope::capture(self, session);
|
||||
self.resource_session_owner_mut_for_owner(&owner)
|
||||
}
|
||||
}
|
||||
@@ -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<moli_core::network::ResourceInterceptionBody>,
|
||||
},
|
||||
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<moli_core::RendererDocumentLifecycleIdentity> {
|
||||
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<moli_core::page::PendingResourceCommand> {
|
||||
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<moli_core::RendererDocumentLifecycleIdentity> {
|
||||
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<moli_core::page::PageDocumentCommandTarget>,
|
||||
pub(crate) residence: PendingSubresourceFetchResidence,
|
||||
pub owner_session_id: Option<String>,
|
||||
pub action_session_id: Option<String>,
|
||||
pub owner_kind: PendingSubresourceFetchOwnerKind,
|
||||
@@ -1627,10 +1707,6 @@ pub struct PendingSubresourceFetchAuthRequest {
|
||||
}
|
||||
|
||||
impl PendingSubresourceFetchAuthRequest {
|
||||
pub(crate) fn source_document(&self) -> Option<moli_core::RendererDocumentLifecycleIdentity> {
|
||||
self.command_target.as_ref().map(|target| target.document())
|
||||
}
|
||||
|
||||
pub fn pop_next_auth_required_pause(&mut self) -> Option<PendingSubresourceFetchAuthStage> {
|
||||
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<moli_core::page::PageDocumentCommandTarget>,
|
||||
pub(crate) residence: PendingSubresourceFetchResidence,
|
||||
pub owner_session_id: Option<String>,
|
||||
pub action_session_id: Option<String>,
|
||||
pub owner_kind: PendingSubresourceFetchOwnerKind,
|
||||
@@ -1686,10 +1761,6 @@ pub struct PendingSubresourceFetchResponseRequest {
|
||||
}
|
||||
|
||||
impl PendingSubresourceFetchResponseRequest {
|
||||
pub(crate) fn source_document(&self) -> Option<moli_core::RendererDocumentLifecycleIdentity> {
|
||||
self.command_target.as_ref().map(|target| target.document())
|
||||
}
|
||||
|
||||
pub fn pop_next_response_stage_pause(
|
||||
&mut self,
|
||||
) -> Option<PendingSubresourceFetchResponseStage> {
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
|
||||
|
||||
@@ -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.
|
||||
///
|
||||
|
||||
@@ -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<moli_core::network::ResourceInterceptionPolicy>,
|
||||
owner_target_id: Option<String>,
|
||||
sessions: BTreeMap<String, SharedWorkerTargetSessionState>,
|
||||
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<String> {
|
||||
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;
|
||||
};
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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<crate::conn::BackgroundProtocolEvent>,
|
||||
Vec<crate::domains::fetch::PreparedSubresourceAutoContinue>,
|
||||
Vec<crate::domains::activity::PreparedSubresourceContinueWait>,
|
||||
)> {
|
||||
crate::domains::target::prepare_worker_resource(
|
||||
self.connection,
|
||||
browser_context_id,
|
||||
target_id,
|
||||
event,
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn project_worker_target_event(
|
||||
self,
|
||||
event: WorkerTargetLifecycleOutput,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -23,7 +23,7 @@ use crate::domains::network::{
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct PreparedSubresourceContinueAction {
|
||||
owner: TargetPageResidenceIdentity,
|
||||
owner: Option<TargetPageResidenceIdentity>,
|
||||
event: PendingSubresourceContinueEvent,
|
||||
request: Option<ClaimedSubresourceContinueRequest>,
|
||||
}
|
||||
@@ -40,7 +40,7 @@ impl PreparedSubresourceContinueAction {
|
||||
fn capture(
|
||||
conn: &mut CdpConnection,
|
||||
command_owner: &CommandOwnerScope,
|
||||
owner: TargetPageResidenceIdentity,
|
||||
owner: Option<TargetPageResidenceIdentity>,
|
||||
event: PendingSubresourceContinueEvent,
|
||||
network_pause: Option<moli_core::network::ResourceInterceptionPause>,
|
||||
response_body: Option<moli_core::network::ResourceInterceptionBody>,
|
||||
@@ -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<PreparedSubresourceContinueWait> {
|
||||
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<crate::conn::TargetRootDocumentProtocolAttachmentIdentity>,
|
||||
request: PendingSubresourceFetchRequest,
|
||||
}
|
||||
|
||||
@@ -681,10 +669,17 @@ impl PreparedSubresourceContinueWait {
|
||||
request: PendingSubresourceFetchRequest,
|
||||
kind: SubresourceContinuationKind,
|
||||
) -> Option<Self> {
|
||||
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<moli_core::page::CompletedResourceCommand>,
|
||||
) -> Vec<BackgroundProtocolEvent> {
|
||||
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<moli_core::network::ResourceInterceptionPause>,
|
||||
) -> PreparedSubresourceContinueAction {
|
||||
PreparedSubresourceContinueAction::capture(conn, owner, None, event, pause, None)
|
||||
}
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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(),
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -60,6 +60,7 @@ struct PendingSubresourceFetchPauseSource {
|
||||
/// Network request id is the loader id of the Document it creates.
|
||||
child_document: Option<moli_core::page::ChildDocumentFetchRequest>,
|
||||
native_network: bool,
|
||||
observe_network: bool,
|
||||
request_initiator_type: SubresourceRequestInitiatorType,
|
||||
redirect: Option<moli_page_types::NavigationRedirect>,
|
||||
}
|
||||
@@ -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<network::TargetSubresourceFetchPauseOutput>,
|
||||
) {
|
||||
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};
|
||||
|
||||
@@ -17,7 +17,7 @@ pub(super) enum SubresourceResponseInterception {
|
||||
pub(crate) struct PreparedSubresourceAutoContinue {
|
||||
pending: PendingResourceCommand,
|
||||
correlation: PreparedSubresourceCorrelation,
|
||||
binding: TargetRootDocumentProtocolAttachmentIdentity,
|
||||
binding: Option<TargetRootDocumentProtocolAttachmentIdentity>,
|
||||
}
|
||||
|
||||
impl PreparedSubresourceAutoContinue {
|
||||
@@ -29,21 +29,24 @@ impl PreparedSubresourceAutoContinue {
|
||||
handle_auth_requests: bool,
|
||||
response: SubresourceResponseInterception,
|
||||
) -> Option<Self> {
|
||||
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<TargetRootDocumentProtocolAttachmentIdentity>,
|
||||
}
|
||||
|
||||
impl SubresourceAutoContinueCompletion {
|
||||
@@ -100,7 +103,11 @@ impl SubresourceAutoContinueCompletion {
|
||||
conn: &mut CdpConnection,
|
||||
completed: Result<CompletedResourceCommand>,
|
||||
) {
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -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()),
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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"),
|
||||
|
||||
@@ -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"));
|
||||
|
||||
@@ -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" {
|
||||
|
||||
+23
-14
@@ -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;
|
||||
|
||||
@@ -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::<Vec<_>>();
|
||||
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"}))
|
||||
|
||||
@@ -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"}),
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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!({
|
||||
|
||||
@@ -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"));
|
||||
|
||||
@@ -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<crate::conn::BackgroundProtocolEvent>,
|
||||
Vec<fetch::PreparedSubresourceAutoContinue>,
|
||||
Vec<crate::domains::activity::PreparedSubresourceContinueWait>,
|
||||
) {
|
||||
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 {
|
||||
|
||||
@@ -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());
|
||||
|
||||
@@ -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)?;
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -60,6 +60,7 @@ impl TargetSubresourceFetchPauseOutput {
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub(crate) struct TargetSubresourceFetchPauseNetworkOutput {
|
||||
observe_network: bool,
|
||||
network_request_id: String,
|
||||
request_handle: Option<SubresourceNetworkRequestHandle>,
|
||||
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<moli_page_types::NavigationRedirect>,
|
||||
|
||||
@@ -1363,6 +1363,7 @@ impl TargetSubresourcePlanOutput {
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
pub(crate) struct TargetSubresourceRequestStartedOutput {
|
||||
redirect: Option<Box<moli_core::page::NavigationRedirect>>,
|
||||
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
|
||||
}
|
||||
|
||||
@@ -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!({
|
||||
|
||||
@@ -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::<Vec<_>>();
|
||||
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(),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<BackgroundProtocolEvent>,
|
||||
Vec<crate::domains::fetch::PreparedSubresourceAutoContinue>,
|
||||
Vec<crate::domains::activity::PreparedSubresourceContinueWait>,
|
||||
)> {
|
||||
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))
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -44,6 +44,8 @@ const TEST_SCHEDULER_INPUT_TIMEOUT: Duration = Duration::from_secs(30);
|
||||
pub struct TestContext {
|
||||
pub state: crate::ProtocolStateOwner,
|
||||
pub sent: Vec<Value>,
|
||||
#[cfg(test)]
|
||||
worker_network_observer: Option<TestWorkerNetworkObserver>,
|
||||
pending_runtime_deferred_replies: VecDeque<PendingTestRuntimeDeferredReply>,
|
||||
pending_protocol_scheduler_work: VecDeque<ProtocolSchedulerWork>,
|
||||
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<String>,
|
||||
shared_sessions: Vec<String>,
|
||||
requests: std::collections::HashMap<String, String>,
|
||||
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<String> {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 =
|
||||
|
||||
@@ -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(_)
|
||||
|
||||
@@ -544,7 +544,7 @@ impl PageScriptHost {
|
||||
&mut self,
|
||||
) -> Option<crate::network::interception_output::ResourceInterceptionContext> {
|
||||
Some(
|
||||
crate::network::interception_output::ResourceInterceptionContext {
|
||||
crate::network::interception_output::ResourceInterceptionContext::Document {
|
||||
source_document: self.root_document_lifecycle_identity()?,
|
||||
output: self.native_interception_output()?,
|
||||
},
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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<PendingSubresourceFetchInfo>,
|
||||
running_subresource_fetches: HashMap<u64, RunningSubresourceFetchState>,
|
||||
streaming_subresource_fetches: HashMap<u64, StreamingSubresourceFetchState>,
|
||||
in_flight_worker_subresource_fetches: HashMap<u64, InFlightWorkerSubresourceFetchState>,
|
||||
#[cfg(test)]
|
||||
pending_subresource_continue_events: Vec<PendingSubresourceContinueEvent>,
|
||||
pub(crate) pending_network_body_sources:
|
||||
|
||||
@@ -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<v8::Context>,
|
||||
worker_id: DedicatedWorkerId,
|
||||
fetch_id: u32,
|
||||
load: ResourceLoadLease,
|
||||
credentials_mode: moli_fetch::RequestCredentialsMode,
|
||||
request_mode: moli_fetch::RequestMode,
|
||||
network_partition_key: Option<String>,
|
||||
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<v8::Context>,
|
||||
worker_id: DedicatedWorkerId,
|
||||
xhr_id: u32,
|
||||
load: ResourceLoadLease,
|
||||
credentials_mode: moli_fetch::RequestCredentialsMode,
|
||||
network_partition_key: Option<String>,
|
||||
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<v8::Context>,
|
||||
worker_id: DedicatedWorkerId,
|
||||
report_id: u32,
|
||||
load: ResourceLoadLease,
|
||||
credentials_mode: moli_fetch::RequestCredentialsMode,
|
||||
request_mode: moli_fetch::RequestMode,
|
||||
network_partition_key: Option<String>,
|
||||
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<v8::Context>,
|
||||
instance_id: SharedWorkerInstanceId,
|
||||
fetch_id: u32,
|
||||
load: ResourceLoadLease,
|
||||
credentials_mode: moli_fetch::RequestCredentialsMode,
|
||||
request_mode: moli_fetch::RequestMode,
|
||||
network_partition_key: Option<String>,
|
||||
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<v8::Context>,
|
||||
instance_id: SharedWorkerInstanceId,
|
||||
xhr_id: u32,
|
||||
load: ResourceLoadLease,
|
||||
credentials_mode: moli_fetch::RequestCredentialsMode,
|
||||
network_partition_key: Option<String>,
|
||||
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<v8::Context>,
|
||||
instance_id: SharedWorkerInstanceId,
|
||||
report_id: u32,
|
||||
load: ResourceLoadLease,
|
||||
credentials_mode: moli_fetch::RequestCredentialsMode,
|
||||
request_mode: moli_fetch::RequestMode,
|
||||
network_partition_key: Option<String>,
|
||||
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<Item = &PendingSubresourceFetchState> {
|
||||
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::<Vec<_>>();
|
||||
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) {
|
||||
|
||||
@@ -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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
response_body: RendererSyntheticResponseBody,
|
||||
) -> bool {
|
||||
self.browser_context_runtime
|
||||
.fulfill_shared_worker_xhr_response(
|
||||
instance_id,
|
||||
request,
|
||||
response_code,
|
||||
response_headers,
|
||||
response_body,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<Box<crate::protocol_types::NavigationResponse>>,
|
||||
script_kind: WorkerScriptKind,
|
||||
secure_context: bool,
|
||||
response_referrer_policy: Option<String>,
|
||||
@@ -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<crate::network::interception_output::ResourceInterceptionContext> {
|
||||
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<crate::network::interception_output::ResourceInterceptionContext> {
|
||||
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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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"
|
||||
);
|
||||
}
|
||||
|
||||
@@ -41,6 +41,7 @@ struct WorkerResourceLoaderAuthority {
|
||||
owner: WorkerResourceOwner,
|
||||
state: Mutex<WorkerResourceLoaderState>,
|
||||
loads: ResourceLoadRegistry,
|
||||
interception: Mutex<Option<crate::network::interception_output::ResourceInterceptionContext>>,
|
||||
}
|
||||
|
||||
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<crate::network::interception_output::ResourceInterceptionContext>,
|
||||
) {
|
||||
*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
|
||||
}
|
||||
|
||||
@@ -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<Arc<moli_fetch::RedirectInfo>>,
|
||||
@@ -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()
|
||||
}
|
||||
|
||||
@@ -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<WorkerInterceptionOutput>),
|
||||
}
|
||||
|
||||
/// Native network facts normally join the Document's networking task source.
|
||||
@@ -27,6 +34,7 @@ struct InterceptionOutputInner {
|
||||
journal: RendererTurnOutputJournal,
|
||||
completion: RendererResourceCompletionSender,
|
||||
state: Mutex<InterceptionOutputState>,
|
||||
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.
|
||||
|
||||
@@ -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<PendingSubresourceFetchInfo>,
|
||||
pause: ResourceInterceptionPause,
|
||||
},
|
||||
Continue {
|
||||
event: Box<PendingSubresourceContinueEvent>,
|
||||
pause: Option<ResourceInterceptionPause>,
|
||||
},
|
||||
Network(Box<ScriptNetworkOutputItem>),
|
||||
}
|
||||
|
||||
pub(crate) struct WorkerInterceptionOutput {
|
||||
control: Option<ResourceInterceptionContext>,
|
||||
publish: Arc<dyn Fn(ResourceInterceptionEvent) -> 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<Self>,
|
||||
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<ResourceInterceptionPause>,
|
||||
) -> 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 {}
|
||||
@@ -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();
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<FetchCancelHandle>,
|
||||
preflight_request_headers: Vec<(String, String)>,
|
||||
cancel: Option<FetchCancelHandle>,
|
||||
headers: Vec<(String, String)>,
|
||||
) -> Result<NetworkFetchResult<StreamingRawResponse>, 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
|
||||
}
|
||||
|
||||
@@ -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<v8::Local<'s, v8::Object>>,
|
||||
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<u8>) -> 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<Vec<u8>> {
|
||||
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();
|
||||
|
||||
@@ -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<service_worker::WorkerServiceWorkerFetch>,
|
||||
response_filter: Option<crate::types::AsyncSubresourceFetchResponseFilter>,
|
||||
request: Request,
|
||||
info: PendingSubresourceFetchInfo,
|
||||
load: ResourceLoadLease,
|
||||
cancel: FetchCancelHandle,
|
||||
source_document: RendererDocumentLifecycleIdentity,
|
||||
output: InterceptionOutput,
|
||||
interception: crate::network::interception_output::ResourceInterceptionContext,
|
||||
connect_policy: Option<DocumentConnectPolicySnapshot>,
|
||||
csp_violations: Vec<crate::content_security_policy::ContentSecurityPolicyUrlViolation>,
|
||||
preflight_headers: Vec<(String, String)>,
|
||||
initial_decision: Option<oneshot::Receiver<ResourceInterceptionDecision>>,
|
||||
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<Vec<(String, String)>>,
|
||||
) -> Result<Option<BufferedXhrResponse>, 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<ControlledXhrStream>,
|
||||
mut stream: Option<ControlledResourceStream>,
|
||||
) -> 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<T>(&self, result: Result<T, String>) -> Result<T, String> {
|
||||
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<ResourceInterceptionDecision>,
|
||||
phase: InterceptionPhase,
|
||||
) -> Result<ResourceInterceptionDecision, String> {
|
||||
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<crate::types::NavigationRedirect>) {
|
||||
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<BufferedXhrResponse>, Option<Vec<(String, String)>>), 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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<WorkerFetchEvent>,
|
||||
fetch_id: u32,
|
||||
interception: ResourceInterceptionContext,
|
||||
mode: RequestMode,
|
||||
credentials: RequestCredentialsMode,
|
||||
policy: SubresourcePolicyContext,
|
||||
pub(super) body_source_id: Option<NetworkBodySourceId>,
|
||||
response: Option<
|
||||
Box<(
|
||||
PendingSubresourceFetchInfo,
|
||||
ResponseHead,
|
||||
ResourceInterceptionBody,
|
||||
)>,
|
||||
>,
|
||||
delivered: usize,
|
||||
}
|
||||
|
||||
impl ControlledFetchStream {
|
||||
pub(super) fn policy_violations(
|
||||
&self,
|
||||
violations: Vec<crate::content_security_policy::ContentSecurityPolicyUrlViolation>,
|
||||
) {
|
||||
if !violations.is_empty() {
|
||||
let _ = self
|
||||
.completion
|
||||
.send(WorkerFetchEvent::PolicyViolations(violations));
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn new(
|
||||
completion: mpsc::UnboundedSender<WorkerFetchEvent>,
|
||||
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<Vec<(String, String)>>,
|
||||
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<u8>) -> 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<WorkerFetchEvent>,
|
||||
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())
|
||||
}
|
||||
@@ -28,6 +28,8 @@ pub(crate) struct XhrLoadResult {
|
||||
pub(crate) result: Result<Response, String>,
|
||||
pub(crate) info: PendingSubresourceFetchInfo,
|
||||
pub(crate) network_record: SubresourceNetworkRecord,
|
||||
pub(crate) csp_violations:
|
||||
Vec<crate::content_security_policy::ContentSecurityPolicyUrlViolation>,
|
||||
}
|
||||
|
||||
impl XhrLoadResult {
|
||||
@@ -95,6 +97,7 @@ impl XhrLoadResult {
|
||||
info,
|
||||
result: result.map(|delivered| delivered.response),
|
||||
network_record,
|
||||
csp_violations: Vec::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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<ServiceWorkerRuntimeService>,
|
||||
client_id: Option<ServiceWorkerClientId>,
|
||||
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<Option<Response>, 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()))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<NetworkBodySourceId>,
|
||||
}
|
||||
|
||||
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<crate::content_security_policy::ContentSecurityPolicyUrlViolation>,
|
||||
) {
|
||||
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<NetworkBodySourceId> {
|
||||
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<Vec<(String, String)>>,
|
||||
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<u8>) -> Result<(), String> {
|
||||
match self {
|
||||
Self::Document(stream) => stream.chunk(bytes),
|
||||
Self::WorkerFetch(stream) => stream.chunk(bytes),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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, '_>,
|
||||
|
||||
@@ -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<SubresourceResponseTransition, String> {
|
||||
// Error mode rejects redirect statuses without consulting Location.
|
||||
if request.redirect_mode() == RequestRedirectMode::Error {
|
||||
if matches!(head.status, 301 | 302 | 303 | 307 | 308) {
|
||||
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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");
|
||||
|
||||
|
||||
@@ -162,6 +162,7 @@ impl RendererProducerRegistrar {
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct RendererWorkerContextRuntime {
|
||||
debugger_enabled: bool,
|
||||
shared_worker_pause_on_start: Arc<AtomicBool>,
|
||||
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<HashMap<u64, DedicatedWorkerDevToolsTarget>>,
|
||||
dedicated_worker_pause_on_start_for_devtools: AtomicBool,
|
||||
shared_worker_pause_on_start_for_devtools: Arc<AtomicBool>,
|
||||
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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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,
|
||||
|
||||
@@ -597,6 +597,7 @@ impl RendererPendingWindowOpenEvent {
|
||||
}
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct RendererSharedWorkerTargetInfo {
|
||||
pub interception_policy: Option<crate::network::ResourceInterceptionPolicy>,
|
||||
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 {
|
||||
|
||||
+13
-5
@@ -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(
|
||||
|
||||
@@ -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(),
|
||||
))
|
||||
}
|
||||
|
||||
@@ -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(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<Self> {
|
||||
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<RefCell<PageScriptHost>>,
|
||||
@@ -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<Self> {
|
||||
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<Self> {
|
||||
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<bytes::Bytes>,
|
||||
request_handle: Option<SubresourceNetworkRequestHandle>,
|
||||
) -> 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",
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u16>,
|
||||
response_headers: Option<Vec<(String, Vec<u8>)>>,
|
||||
) -> 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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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<u8>)>,
|
||||
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,
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -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();
|
||||
|
||||
-175
@@ -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![(
|
||||
|
||||
+1
-3
@@ -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 {
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user