Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

refactor(cdp): route deferred page effects explicitly

ldm0439148c73e0f
diff --git a/moli-protocol/src/conn/bidi_channel_work.rs b/moli-protocol/src/conn/bidi_channel_work.rs
index 8b2d1b70e..53952d9ee 100644
--- a/moli-protocol/src/conn/bidi_channel_work.rs
+++ b/moli-protocol/src/conn/bidi_channel_work.rs
@@ -25,9 +25,19 @@ impl BidiChannelPageOwner {
/// route, while `attachment` freezes the target Page residence and exact
/// protocol session.
pub(crate) fn capture(conn: &CdpConnection, session_id: Option<&str>) -> Option<Self> {
+ Self::capture_for_owner(conn, CommandOwnerScope::capture(conn, session_id))
+ }
+
+ pub(crate) fn capture_for_owner(
+ conn: &CdpConnection,
+ owner_scope: CommandOwnerScope,
+ ) -> Option<Self> {
Some(Self {
- owner_scope: CommandOwnerScope::capture(conn, session_id),
- attachment: conn.target_page_protocol_attachment_identity_for_session(session_id)?,
+ attachment: conn.target_page_protocol_attachment_identity_for_route(
+ owner_scope.session_id(),
+ owner_scope.session_owner_route(),
+ )?,
+ owner_scope,
})
}
@@ -39,6 +49,10 @@ impl BidiChannelPageOwner {
self.attachment.page_owner().target_id()
}
+ pub(crate) fn command_owner(&self) -> &CommandOwnerScope {
+ &self.owner_scope
+ }
+
pub(crate) fn enter<'a>(
&self,
conn: &'a mut CdpConnection,
@@ -46,11 +60,10 @@ impl BidiChannelPageOwner {
self.owner_scope.enter(conn)
}
- /// Checks the captured Page attachment under its owner route.
+ /// Checks the captured Page attachment directly.
///
- /// Callers handling an implicit session must first enter this binding with
- /// `enter`; otherwise a surrounding command's route could answer the
- /// currentness query for the wrong Page.
+ /// The attachment contains its exact context, target, and Page residence,
+ /// so this check does not depend on the connection's ambient route.
pub(crate) fn is_current(&self, conn: &CdpConnection) -> bool {
conn.target_page_protocol_attachment_identity_is_current(&self.attachment)
}
diff --git a/moli-protocol/src/conn/browser_context/fetch_owner.rs b/moli-protocol/src/conn/browser_context/fetch_owner.rs
index 644b86579..6bb03a003 100644
--- a/moli-protocol/src/conn/browser_context/fetch_owner.rs
+++ b/moli-protocol/src/conn/browser_context/fetch_owner.rs
@@ -233,7 +233,15 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Option<TargetFetchSubresourceInterceptionSnapshot> {
- self.target_session_owner_aggregate_fetch_config(session_id)
+ self.target_fetch_subresource_interception_snapshot_for_route(session_id, None)
+ }
+
+ pub(crate) fn target_fetch_subresource_interception_snapshot_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Option<TargetFetchSubresourceInterceptionSnapshot> {
+ self.target_session_owner_aggregate_fetch_config_for_route(session_id, owner_route)
.map(|config| config.subresource_interception_snapshot())
}
@@ -821,9 +829,18 @@ impl CdpConnection {
&mut self,
session_id: Option<&str>,
internal_id: u64,
+ ) -> Option<String> {
+ self.in_flight_subresource_fetch_request_id_for_route(session_id, None, internal_id)
+ }
+
+ pub(crate) fn in_flight_subresource_fetch_request_id_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ internal_id: u64,
) -> Option<String> {
let (request_id, page_owner) = self
- .target_session_owner_mut(session_id)?
+ .target_session_owner_mut_for_route(session_id, owner_route)?
.in_flight_subresource_fetch_request_identity(internal_id)?;
self.target_page_residence_identity_is_current_for_session(session_id, &page_owner)
.then_some(request_id)
@@ -1139,11 +1156,12 @@ impl CdpConnection {
Ok(Some((pending, page_command)))
}
- pub(crate) fn take_pending_fetch_state_for_session_owner(
+ pub(crate) fn take_pending_fetch_state_for_route(
&mut self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Option<SessionOwnerPendingFetchState> {
- self.target_session_owner_mut(session_id)?
+ self.target_session_owner_mut_for_route(session_id, owner_route)?
.drain_fetch_pending_state()
}
}
diff --git a/moli-protocol/src/conn/browser_context/network_owner.rs b/moli-protocol/src/conn/browser_context/network_owner.rs
index 84c198258..07dba498a 100644
--- a/moli-protocol/src/conn/browser_context/network_owner.rs
+++ b/moli-protocol/src/conn/browser_context/network_owner.rs
@@ -530,9 +530,24 @@ impl CdpConnection {
session_id: Option<&str>,
data_type: DevToolsNetworkDataType,
encoded_data_size: usize,
+ ) -> Vec<String> {
+ self.network_data_collector_ids_for_route_body(
+ session_id,
+ None,
+ data_type,
+ encoded_data_size,
+ )
+ }
+
+ pub(crate) fn network_data_collector_ids_for_route_body(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ data_type: DevToolsNetworkDataType,
+ encoded_data_size: usize,
) -> Vec<String> {
let Some((browser_context_id, target_id)) =
- self.target_owner_identity_for_session(session_id)
+ self.target_owner_identity_for_route(session_id, owner_route)
else {
return Vec::new();
};
@@ -611,11 +626,28 @@ impl CdpConnection {
trigger_session_id: Option<&str>,
primary_session_id: Option<&str>,
preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
+ ) -> Option<TargetNetworkBacklogPreparedDelivery> {
+ self.network_backlog_prepared_delivery_for_route(
+ session_id,
+ None,
+ trigger_session_id,
+ primary_session_id,
+ preferred_request_id,
+ )
+ }
+
+ pub(crate) fn network_backlog_prepared_delivery_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ trigger_session_id: Option<&str>,
+ primary_session_id: Option<&str>,
+ preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
) -> Option<TargetNetworkBacklogPreparedDelivery> {
let mut network_request_id_allocator =
std::mem::take(&mut self.network_request_id_allocator);
let result = self
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)
.ok()
.map(|runtime_slot| {
runtime_slot.network_backlog_prepared_delivery(
@@ -649,9 +681,10 @@ impl CdpConnection {
result
}
- pub(crate) fn pending_network_backlog_delivery_snapshot_for_session_owner(
+ pub(crate) fn pending_network_backlog_delivery_snapshot_for_route(
&mut self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
trigger_session_id: Option<&str>,
primary_session_id: Option<&str>,
preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
@@ -659,7 +692,7 @@ impl CdpConnection {
let mut network_request_id_allocator =
std::mem::take(&mut self.network_request_id_allocator);
let result = self
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)
.ok()
.and_then(|runtime_slot| {
runtime_slot.pending_network_backlog_delivery_snapshot(
@@ -677,10 +710,20 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Vec<Option<String>> {
- let Ok(runtime_slot) = self.runtime_session_owner_slot(session_id) else {
+ self.network_event_session_ids_for_route(session_id, None)
+ }
+
+ pub(crate) fn network_event_session_ids_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Vec<Option<String>> {
+ let Ok(runtime_slot) = self.runtime_session_owner_slot_for_route(session_id, owner_route)
+ else {
return vec![session_id.map(str::to_owned)];
};
- let primary_session_id = self.runtime_session_owner_primary_session_id(session_id);
+ let primary_session_id =
+ self.runtime_session_owner_primary_session_id_for_route(session_id, owner_route);
runtime_slot.network_event_session_ids(session_id, primary_session_id.as_deref())
}
diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rs
index 4cf72fcec..86cc70bf8 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -1451,11 +1451,13 @@ impl CdpConnection {
.await
}
- pub(crate) fn initial_document_page_owner_for_session(
+ pub(crate) fn initial_document_page_owner_for_route(
&self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Option<InitialDocumentPageOwner> {
- let (browser_context_id, target_id) = self.target_owner_identity_for_session(session_id)?;
+ let (browser_context_id, target_id) =
+ self.target_owner_identity_for_route(session_id, owner_route)?;
Some(InitialDocumentPageOwner {
browser_context_id,
target_id: target_id?,
@@ -1522,11 +1524,12 @@ impl CdpConnection {
.clear_pending_navigation_history_update()
}
- pub(crate) async fn mark_target_crashed_for_session_owner_async(
+ pub(crate) async fn mark_target_crashed_for_route_async(
&mut self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Option<()> {
- self.target_session_owner_mut(session_id)?
+ self.target_session_owner_mut_for_route(session_id, owner_route)?
.mark_target_crashed_async()
.await
}
@@ -1743,7 +1746,15 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Option<TargetFetchConfig> {
- self.target_session_owner_ref(session_id)?
+ self.target_session_owner_aggregate_fetch_config_for_route(session_id, None)
+ }
+
+ pub(crate) fn target_session_owner_aggregate_fetch_config_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Option<TargetFetchConfig> {
+ self.target_session_owner_ref_for_route(session_id, owner_route)?
.aggregate_fetch_config()
}
@@ -1842,26 +1853,39 @@ impl CdpConnection {
pub(crate) fn target_owner_has_bidi_channel_preload_script_for_session(
&self,
session_id: Option<&str>,
+ ) -> bool {
+ let none_session_owner_route = self.none_session_owner_route_override();
+ self.target_owner_has_bidi_channel_preload_script_for_route(
+ session_id,
+ none_session_owner_route.as_ref(),
+ )
+ }
+
+ pub(crate) fn target_owner_has_bidi_channel_preload_script_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> bool {
let target_owner_has_script = self
- .target_owner_state_for_session(session_id)
+ .target_owner_state_for_route(session_id, owner_route)
.is_some_and(TargetOwnerState::has_bidi_channel_preload_script);
if target_owner_has_script {
return true;
}
- self.target_owner_identity_for_session(session_id)
+ self.target_owner_identity_for_route(session_id, owner_route)
.and_then(|(browser_context_id, _)| self.browser_context_by_id(&browser_context_id))
.is_some_and(|browser_context| {
browser_context.has_default_bidi_channel_preload_script()
})
}
- pub(crate) fn target_owner_bidi_channel_preload_handoffs_for_session(
+ pub(crate) fn target_owner_bidi_channel_preload_handoffs_for_route(
&self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Vec<BidiPreloadChannelHandoff> {
let mut handoffs = Vec::new();
- if let Some(owner_state) = self.target_owner_state_for_session(session_id) {
+ if let Some(owner_state) = self.target_owner_state_for_route(session_id, owner_route) {
handoffs.extend(
owner_state
.document_start_scripts
@@ -1870,7 +1894,7 @@ impl CdpConnection {
);
}
if let Some(browser_context) = self
- .target_owner_identity_for_session(session_id)
+ .target_owner_identity_for_route(session_id, owner_route)
.and_then(|(browser_context_id, _)| self.browser_context_by_id(&browser_context_id))
{
handoffs.extend(
@@ -1987,16 +2011,28 @@ impl CdpConnection {
pub(crate) fn pending_target_page_residence_identity_for_session(
&self,
session_id: Option<&str>,
+ ) -> Option<TargetPageResidenceIdentity> {
+ let none_session_owner_route = self.none_session_owner_route_override();
+ self.pending_target_page_residence_identity_for_route(
+ session_id,
+ none_session_owner_route.as_ref(),
+ )
+ }
+
+ pub(crate) fn pending_target_page_residence_identity_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Option<TargetPageResidenceIdentity> {
let (browser_context_id, routed_target_id) =
- self.target_owner_identity_for_session(session_id)?;
+ self.target_owner_identity_for_route(session_id, owner_route)?;
let target_id = routed_target_id.or_else(|| {
self.browser_context_by_id(&browser_context_id)
.and_then(|browser_context| browser_context.active_target_id())
.map(str::to_owned)
});
let page_attachment_id = self
- .runtime_session_owner_slot(session_id)
+ .runtime_session_owner_slot_for_route(session_id, owner_route)
.ok()?
.pending_page_attachment_id()?;
Some(TargetPageResidenceIdentity::new(
@@ -2303,7 +2339,7 @@ impl CdpConnection {
owner_route: Option<&CdpSessionRoute>,
) -> Result<&mut TargetRuntimeSlot, String> {
let renderer_inspector_session_id =
- self.target_renderer_runtime_inspector_session_id_for_session(session_id);
+ self.target_renderer_runtime_inspector_session_id_for_route(session_id, owner_route);
let slot = self
.target_session_owner_mut_for_route(session_id, owner_route)
.and_then(TargetSessionOwnerMut::into_runtime_slot_mut)
@@ -2336,7 +2372,15 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Option<String> {
- self.target_session_owner_ref(session_id)?
+ self.runtime_session_owner_primary_session_id_for_route(session_id, None)
+ }
+
+ pub(crate) fn runtime_session_owner_primary_session_id_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Option<String> {
+ self.target_session_owner_ref_for_route(session_id, owner_route)?
.primary_session_id()
}
@@ -2487,6 +2531,15 @@ impl CdpConnection {
.initial_empty_document_url_if_current()
}
+ pub(crate) fn runtime_session_owner_record_initial_empty_document_url_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Option<String> {
+ self.target_session_owner_ref_for_route(session_id, owner_route)?
+ .initial_empty_document_url_if_current()
+ }
+
pub(crate) fn runtime_session_owner_initial_empty_document_storage_key(
&self,
session_id: Option<&str>,
@@ -2495,11 +2548,21 @@ impl CdpConnection {
.initial_empty_document_storage_key_if_current()
}
- pub(crate) fn runtime_session_owner_record_is_on_initial_empty_document(
+ pub(crate) fn runtime_session_owner_initial_empty_document_storage_key_for_route(
&self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Option<moli_storage_key::MoliStorageKey> {
+ self.target_session_owner_ref_for_route(session_id, owner_route)?
+ .initial_empty_document_storage_key_if_current()
+ }
+
+ pub(crate) fn runtime_session_owner_record_is_on_initial_empty_document_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Option<bool> {
- self.target_session_owner_ref(session_id)?
+ self.target_session_owner_ref_for_route(session_id, owner_route)?
.is_on_initial_empty_document()
}
diff --git a/moli-protocol/src/conn/command_owner_scope.rs b/moli-protocol/src/conn/command_owner_scope.rs
index a0aaa1df0..65635223f 100644
--- a/moli-protocol/src/conn/command_owner_scope.rs
+++ b/moli-protocol/src/conn/command_owner_scope.rs
@@ -1,4 +1,7 @@
-use super::{CdpConnection, CdpSessionRoute, NoneSessionOwnerRouteOverrideScope};
+use super::{
+ CdpConnection, CdpSessionRoute, NoneSessionOwnerRouteOverrideScope,
+ TargetPageProtocolAttachmentIdentity,
+};
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct CommandOwnerScope {
@@ -49,6 +52,24 @@ impl CommandOwnerScope {
}
}
+ pub(crate) fn for_page_attachment(attachment: &TargetPageProtocolAttachmentIdentity) -> Self {
+ if let Some(session_id) = attachment.session_id() {
+ return Self::for_session(session_id);
+ }
+ let page = attachment.page_owner();
+ let route = match page.target_id() {
+ Some(target_id) => CdpSessionRoute::PageTarget {
+ browser_context_id: page.browser_context_id().to_owned(),
+ target_id: target_id.to_owned(),
+ is_attached_session: false,
+ },
+ None => CdpSessionRoute::BrowserContext {
+ browser_context_id: page.browser_context_id().to_owned(),
+ },
+ };
+ Self::for_implicit_route(Some(route))
+ }
+
pub(crate) fn session_id(&self) -> Option<&str> {
match &self.identity {
CommandOwnerIdentity::Session(session_id) => Some(session_id),
diff --git a/moli-protocol/src/conn/devtools_command.rs b/moli-protocol/src/conn/devtools_command.rs
index 16e4bd324..688ebe9f5 100644
--- a/moli-protocol/src/conn/devtools_command.rs
+++ b/moli-protocol/src/conn/devtools_command.rs
@@ -392,13 +392,10 @@ impl CdpConnection {
.is_some_and(|browser_context| {
browser_context.has_default_bidi_channel_preload_script()
});
- let mut route_scope = self.scoped_none_session_owner_route_override(route);
+ let command_owner = CommandOwnerScope::for_implicit_route(Some(route.clone()));
let mut initial_runtime_execution_context_ids = Vec::new();
let mut renderer_output_predecessor = None;
- let pending = match route_scope
- .conn_mut()
- .start_initial_document_page_ensure_for_session_owner(None)
- {
+ let pending = match self.start_initial_document_page_ensure_for_owner(&command_owner) {
Ok(pending) => pending,
Err(error) => {
tracing::debug!(
@@ -412,8 +409,7 @@ impl CdpConnection {
if let Some(pending) = pending {
match pending.wait().await {
Ok(completed) => {
- match route_scope
- .conn_mut()
+ match self
.complete_initial_document_page_build_for_owner_with_creation_diagnostics(
completed,
)
@@ -444,9 +440,7 @@ impl CdpConnection {
}
}
Err(error) => {
- let error = route_scope
- .conn_mut()
- .reset_failed_initial_document_page_build_for_owner(error);
+ let error = self.reset_failed_initial_document_page_build_for_owner(error);
tracing::debug!(
?error,
target_id = %target_id.as_str(),
@@ -458,18 +452,18 @@ impl CdpConnection {
}
let mut listener_events = Vec::new();
if has_default_bidi_channel_preload_script
- || route_scope
- .conn_mut()
- .target_owner_has_bidi_channel_preload_script_for_session(None)
+ || self.target_owner_has_bidi_channel_preload_script_for_route(
+ command_owner.session_id(),
+ command_owner.session_owner_route(),
+ )
{
let mut execution_context_ids = initial_runtime_execution_context_ids;
// Target lifecycle creation can materialize initial about:blank without Runtime.enable;
// in that path the renderer has an initial default context id but no Runtime
// frontend-created inspector batch.
if execution_context_ids.is_empty()
- && let Ok(Some(default_context_id)) = route_scope
- .conn_mut()
- .runtime_default_or_initial_execution_context_id_for_session_owner_async(None)
+ && let Ok(Some(default_context_id)) = self
+ .runtime_default_or_initial_execution_context_id_for_owner_async(&command_owner)
.await
{
execution_context_ids.push(default_context_id);
@@ -477,8 +471,8 @@ impl CdpConnection {
for execution_context_id in execution_context_ids {
Box::pin(
crate::domains::runtime::start_bidi_preload_channel_listeners_for_execution_context_background_events_async(
- route_scope.conn_mut(),
- None,
+ self,
+ &command_owner,
execution_context_id,
&mut listener_events,
),
diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rs
index c0fa9e6d2..4458a9f4a 100644
--- a/moli-protocol/src/conn/fetch_support.rs
+++ b/moli-protocol/src/conn/fetch_support.rs
@@ -5,7 +5,7 @@ use url::Url;
use super::body_spool::ensure_materialize_limit;
use super::{
- CapturedBody, CapturedBodyWriter, CdpConnection, DocumentNavigationToken,
+ CapturedBody, CapturedBodyWriter, CdpConnection, CdpSessionRoute, DocumentNavigationToken,
NavigationDispatchState, NavigationLoadOutcome, PausedResponsePreparedDocument,
};
use crate::devtools_runtime::{DevToolsNetworkInterceptId, DevToolsNetworkResourceType};
@@ -2111,9 +2111,25 @@ impl CdpConnection {
session_id: Option<&str>,
internal_id: u64,
error_text: String,
+ ) -> Result<Option<moli_core::RendererOutputFence>, String> {
+ self.fail_pending_subresource_auth_for_route_async(
+ session_id,
+ None,
+ internal_id,
+ error_text,
+ )
+ .await
+ }
+
+ pub(crate) async fn fail_pending_subresource_auth_for_route_async(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ internal_id: u64,
+ error_text: String,
) -> Result<Option<moli_core::RendererOutputFence>, String> {
let page = self
- .runtime_session_owner_slot_mut(session_id)?
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)?
.loaded_page_mut()
.ok_or_else(|| "NoDocumentLoaded".to_owned())?;
page.fail_pending_subresource_auth_async(internal_id, error_text)
@@ -2135,9 +2151,25 @@ impl CdpConnection {
session_id: Option<&str>,
internal_id: u64,
error_text: String,
+ ) -> Result<Option<moli_core::RendererOutputFence>, String> {
+ self.fail_pending_subresource_fetch_for_route_async(
+ session_id,
+ None,
+ internal_id,
+ error_text,
+ )
+ .await
+ }
+
+ pub(crate) async fn fail_pending_subresource_fetch_for_route_async(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ internal_id: u64,
+ error_text: String,
) -> Result<Option<moli_core::RendererOutputFence>, String> {
let page = self
- .runtime_session_owner_slot_mut(session_id)?
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)?
.loaded_page_mut()
.ok_or_else(|| "NoDocumentLoaded".to_owned())?;
page.fail_pending_subresource_fetch_async(internal_id, error_text)
@@ -2237,9 +2269,25 @@ impl CdpConnection {
session_id: Option<&str>,
internal_id: u64,
error_text: String,
+ ) -> Result<Option<moli_core::RendererOutputFence>, String> {
+ self.fail_pending_subresource_response_for_route_async(
+ session_id,
+ None,
+ internal_id,
+ error_text,
+ )
+ .await
+ }
+
+ pub(crate) async fn fail_pending_subresource_response_for_route_async(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ internal_id: u64,
+ error_text: String,
) -> Result<Option<moli_core::RendererOutputFence>, String> {
let page = self
- .runtime_session_owner_slot_mut(session_id)?
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)?
.loaded_page_mut()
.ok_or_else(|| "NoDocumentLoaded".to_owned())?;
page.fail_pending_subresource_response_async(internal_id, error_text)
diff --git a/moli-protocol/src/conn/protocol_output.rs b/moli-protocol/src/conn/protocol_output.rs
index 5702014e8..3a8a9e175 100644
--- a/moli-protocol/src/conn/protocol_output.rs
+++ b/moli-protocol/src/conn/protocol_output.rs
@@ -183,20 +183,18 @@ impl CdpConnection {
}
ReadyProtocolSchedulerWork::TopLevelLocationNavigationOwnerAction(action) => {
let (owner_scope, page_owner, navigation) = action.into_parts();
- let session_id = owner_scope.session_id().map(str::to_owned);
- let mut route_scope = owner_scope.enter(self);
let mut protocol_events = Vec::new();
crate::domains::page::navigate_page_owned_top_level_location_background_events_async(
- route_scope.conn_mut(),
+ self,
&mut protocol_events,
- session_id.as_deref(),
+ &owner_scope,
&page_owner,
navigation,
)
.await;
CdpTurnOutcome::new_with_protocol_events(
protocol_events,
- route_scope.conn_mut().take_scheduler_events(),
+ self.take_scheduler_events(),
)
}
ReadyProtocolSchedulerWork::PopupTargetNavigationOwnerAction(action) => {
diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rs
index 5c64de354..31bbd3d65 100644
--- a/moli-protocol/src/conn/runtime_eval.rs
+++ b/moli-protocol/src/conn/runtime_eval.rs
@@ -2309,6 +2309,30 @@ impl CdpConnection {
});
}
+ pub(crate) fn register_runtime_remote_object_ids_for_owner_with_realm(
+ &mut self,
+ owner: &CommandOwnerScope,
+ object_ids: Vec<String>,
+ realm_id: &str,
+ ) {
+ if owner.session_id().is_some() {
+ self.register_runtime_remote_object_ids_for_session_owner_with_realm(
+ owner.session_id(),
+ object_ids,
+ realm_id,
+ );
+ return;
+ }
+ if object_ids.is_empty() {
+ return;
+ }
+ let _ = self.with_target_devtools_session_state_for_route_mut(
+ owner.session_id(),
+ owner.session_owner_route(),
+ |state| state.register_runtime_remote_object_ids_with_realm(object_ids, realm_id),
+ );
+ }
+
pub(crate) fn register_runtime_remote_object_alias_for_session_owner_with_realm(
&mut self,
session_id: Option<&str>,
@@ -3318,9 +3342,7 @@ impl CdpConnection {
return BidiChannelListenerRoute::NotListener;
};
let owner = residence.owner().clone();
- let mut route_scope = owner.enter(self);
- let conn = route_scope.conn_mut();
- if !owner.is_current(conn) {
+ if !owner.is_current(self) {
tracing::debug!(
command_id = response.command_id,
session_id = owner.session_id(),
@@ -3336,7 +3358,7 @@ impl CdpConnection {
channel = %listener.properties().channel,
"BiDi channel listener stopped after inspector error"
);
- conn.publish_bidi_channel_object_group_release(
+ self.publish_bidi_channel_object_group_release(
owner,
listener.channel_object_group().to_owned(),
);
@@ -3349,7 +3371,7 @@ impl CdpConnection {
channel = %listener.properties().channel,
"BiDi channel listener stopped after JavaScript exception"
);
- conn.publish_bidi_channel_object_group_release(
+ self.publish_bidi_channel_object_group_release(
owner,
listener.channel_object_group().to_owned(),
);
@@ -3364,8 +3386,8 @@ impl CdpConnection {
Some(realm_id.clone()),
);
if let Some(remote_object_id) = data.handle.as_ref().or(data.shared_id.as_ref()) {
- conn.register_runtime_remote_object_ids_for_session_owner_with_realm(
- response.session_id(),
+ self.register_runtime_remote_object_ids_for_owner_with_realm(
+ owner.command_owner(),
vec![remote_object_id.as_str().to_owned()],
realm_id.as_str(),
);
@@ -3382,7 +3404,7 @@ impl CdpConnection {
data,
}),
);
- conn.publish_bidi_channel_listener_start(residence);
+ self.publish_bidi_channel_listener_start(residence);
BidiChannelListenerRoute::Event(event)
}
@@ -5490,6 +5512,22 @@ impl CdpConnection {
.map_err(|error| format!("runtime default execution context lookup failed: {error}"))
}
+ pub(crate) async fn runtime_default_or_initial_execution_context_id_for_owner_async(
+ &mut self,
+ owner: &CommandOwnerScope,
+ ) -> Result<Option<i64>, String> {
+ let page = self
+ .runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )?
+ .loaded_page_mut()
+ .ok_or_else(|| "NoDocumentLoaded".to_owned())?;
+ page.default_or_initial_execution_context_id_async()
+ .await
+ .map_err(|error| format!("runtime default execution context lookup failed: {error}"))
+ }
+
pub(crate) async fn runtime_ensure_isolated_world_for_session_owner_async(
&mut self,
session_id: Option<&str>,
diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rs
index 2a9606ab6..9fa84562f 100644
--- a/moli-protocol/src/conn/runtime_load.rs
+++ b/moli-protocol/src/conn/runtime_load.rs
@@ -1774,14 +1774,24 @@ impl CdpConnection {
&mut self,
session_id: Option<&str>,
) -> Result<Option<PendingInitialDocumentPageBuild>, String> {
- let runtime_slot = match self.runtime_session_owner_slot(session_id) {
+ let owner = CommandOwnerScope::capture(self, session_id);
+ self.start_initial_document_page_ensure_for_owner(&owner)
+ }
+
+ pub(crate) fn start_initial_document_page_ensure_for_owner(
+ &mut self,
+ owner: &CommandOwnerScope,
+ ) -> Result<Option<PendingInitialDocumentPageBuild>, String> {
+ let runtime_slot = match self
+ .runtime_session_owner_slot_for_route(owner.session_id(), owner.session_owner_route())
+ {
Ok(slot) => slot,
Err(_) => return Ok(None),
};
if runtime_slot.has_loaded_page() {
return Ok(None);
}
- if !self.runtime_session_owner_target_is_initial_about_blank(session_id) {
+ if !self.runtime_session_owner_target_is_initial_about_blank_for_owner(owner) {
return Ok(None);
}
// Session attachment is a target operation, not a Document command.
@@ -1792,27 +1802,44 @@ impl CdpConnection {
// it, while rejecting the ensure would incorrectly reject attachment.
// Treat this as an already-satisfied ensure and let the exact
// target-owned navigation install the replacement Document.
- if self.has_pending_document_navigation_for_session_owner(session_id) {
+ if self.has_pending_document_navigation_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ ) {
return Ok(None);
}
- self.start_initial_empty_document_page_build_for_session_owner(session_id)
+ self.start_initial_empty_document_page_build_for_owner(owner)
}
pub(crate) fn runtime_session_owner_target_is_initial_about_blank(
&self,
session_id: Option<&str>,
) -> bool {
- if let Some(is_on_initial_empty_document) =
- self.runtime_session_owner_record_is_on_initial_empty_document(session_id)
+ let owner = CommandOwnerScope::capture(self, session_id);
+ self.runtime_session_owner_target_is_initial_about_blank_for_owner(&owner)
+ }
+
+ fn runtime_session_owner_target_is_initial_about_blank_for_owner(
+ &self,
+ owner: &CommandOwnerScope,
+ ) -> bool {
+ if let Some(is_on_initial_empty_document) = self
+ .runtime_session_owner_record_is_on_initial_empty_document_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
{
return is_on_initial_empty_document;
}
- self.runtime_session_owner_target_url(session_id)
- .as_deref()
- .and_then(|raw_url| Url::parse(raw_url).ok())
- .as_ref()
- .is_some_and(moli_url::is_about_blank)
+ self.runtime_session_owner_target_url_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
+ .as_deref()
+ .and_then(|raw_url| Url::parse(raw_url).ok())
+ .as_ref()
+ .is_some_and(moli_url::is_about_blank)
}
/// Returns whether the materialized initial `about:blank` still needs to
@@ -1870,11 +1897,13 @@ impl CdpConnection {
target_url != initial_url
}
- fn start_initial_empty_document_page_build_for_session_owner(
+ fn start_initial_empty_document_page_build_for_owner(
&mut self,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
) -> Result<Option<PendingInitialDocumentPageBuild>, String> {
- let runtime_slot = match self.runtime_session_owner_slot(session_id) {
+ let runtime_slot = match self
+ .runtime_session_owner_slot_for_route(owner.session_id(), owner.session_owner_route())
+ {
Ok(slot) => slot,
Err(_) => return Ok(None),
};
@@ -1890,38 +1919,53 @@ impl CdpConnection {
}));
}
- let owner = self
- .initial_document_page_owner_for_session(session_id)
+ let page_owner = self
+ .initial_document_page_owner_for_route(owner.session_id(), owner.session_owner_route())
.ok_or_else(|| "TargetNotLoaded".to_owned())?;
- let load_inputs = self.navigation_load_inputs_for_session_owner(session_id);
+ let load_inputs =
+ self.navigation_load_inputs_for_route(owner.session_id(), owner.session_owner_route());
let requested_url = self
- .runtime_session_owner_initial_empty_document_url(session_id)
+ .runtime_session_owner_initial_empty_document_url_for_owner(owner)
.unwrap_or_else(|| Url::parse("about:blank").expect("about:blank should be valid"));
let (fetch_subresource_interception_enabled, fetch_subresource_interception_resource_type) =
load_inputs.fetch_subresource_interception;
let mut engine = self.background_navigation_engine_for_load_inputs(&load_inputs);
let page_storage = load_inputs.page_storage_handles();
- let top_level_storage_key =
- self.runtime_session_owner_initial_empty_document_storage_key(session_id);
- self.runtime_session_owner_slot_mut(session_id)?
- .start_initial_document_page_build();
+ let top_level_storage_key = self
+ .runtime_session_owner_initial_empty_document_storage_key_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ );
+ self.runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )?
+ .start_initial_document_page_build();
let page_reservation = engine.reserve_page_for_creation();
let renderer_page = RendererPageResidenceIdentity::from_parts(
page_reservation.local_host_id(),
page_reservation.page_id(),
);
if !self
- .runtime_session_owner_slot_mut(session_id)?
+ .runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )?
.bind_initial_document_page_build_renderer_page(renderer_page)
{
let message =
"initial document Page reservation no longer matches its target build".to_owned();
- let _ = self.runtime_session_owner_slot_mut(session_id).map(|slot| {
- slot.fail_initial_document_page_build(message.clone());
- slot.mark_loaded_page_absent(
- TargetPageAbsenceReason::InitialDocumentPageBuildPending,
- );
- });
+ let _ = self
+ .runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
+ .map(|slot| {
+ slot.fail_initial_document_page_build(message.clone());
+ slot.mark_loaded_page_absent(
+ TargetPageAbsenceReason::InitialDocumentPageBuildPending,
+ );
+ });
return Err(message);
}
// The renderer command below can open the Page output stream and
@@ -1929,10 +1973,13 @@ impl CdpConnection {
// control. Bind the reserved Page to its target before enqueueing that
// command; binding after `start_*` would leave a real cross-thread race
// where the concrete FIFO receives its first publication ownerless.
- let page_owner = self
- .pending_target_page_residence_identity_for_session(session_id)
+ let renderer_page_owner = self
+ .pending_target_page_residence_identity_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
.ok_or_else(|| "initial document Page reservation lost its target owner".to_owned())?;
- self.bind_renderer_page_output_owner(renderer_page, page_owner);
+ self.bind_renderer_page_output_owner(renderer_page, renderer_page_owner);
let pending = engine
.start_build_html_page_from_response_with_storage_and_inspector_session_restores(
page_reservation,
@@ -1968,17 +2015,22 @@ impl CdpConnection {
)
.map_err(|error| {
let message = format!("failed to start initial document page build: {error}");
- let _ = self.runtime_session_owner_slot_mut(session_id).map(|slot| {
- slot.fail_initial_document_page_build(message.clone());
- slot.mark_loaded_page_absent(
- TargetPageAbsenceReason::InitialDocumentPageBuildPending,
- );
- });
+ let _ = self
+ .runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
+ .map(|slot| {
+ slot.fail_initial_document_page_build(message.clone());
+ slot.mark_loaded_page_absent(
+ TargetPageAbsenceReason::InitialDocumentPageBuildPending,
+ );
+ });
message
})?;
Ok(Some(PendingInitialDocumentPageBuild {
kind: PendingInitialDocumentPageBuildKind::Build {
- owner,
+ owner: page_owner,
load_inputs: Box::new(load_inputs),
override_mode: NavigationLoadInputOverrideMode::FreshlyBuiltPage,
engine: Box::new(Some(engine)),
@@ -2028,19 +2080,25 @@ impl CdpConnection {
failed.into_message()
}
- fn runtime_session_owner_initial_empty_document_url(
+ fn runtime_session_owner_initial_empty_document_url_for_owner(
&self,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
) -> Option<Url> {
- if let Some(raw_url) =
- self.runtime_session_owner_record_initial_empty_document_url(session_id)
+ if let Some(raw_url) = self
+ .runtime_session_owner_record_initial_empty_document_url_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
{
return Url::parse(&raw_url).ok().filter(moli_url::is_about_blank);
}
- self.runtime_session_owner_target_url(session_id)
- .as_deref()
- .and_then(|raw_url| Url::parse(raw_url).ok())
- .filter(moli_url::is_about_blank)
+ self.runtime_session_owner_target_url_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
+ .as_deref()
+ .and_then(|raw_url| Url::parse(raw_url).ok())
+ .filter(moli_url::is_about_blank)
}
fn complete_initial_document_page_build_for_page_owner(
diff --git a/moli-protocol/src/domains/activity/contextual_projection.rs b/moli-protocol/src/domains/activity/contextual_projection.rs
index dc8325159..52031299a 100644
--- a/moli-protocol/src/domains/activity/contextual_projection.rs
+++ b/moli-protocol/src/domains/activity/contextual_projection.rs
@@ -1,13 +1,10 @@
use url::Url;
-use crate::conn::{BackgroundProtocolEvent, CdpConnection, CommandDispatchContext};
+use crate::conn::{BackgroundProtocolEvent, CommandDispatchContext};
use crate::domains::network::{
MainDocumentProgressBackgroundEventBarrier, MainDocumentProgressGate,
};
-use super::output_payloads::ProtocolOutputPayloads;
-use super::output_slot::ProtocolOutputSlot;
-
/// Exact protocol projection context for one already-frozen output batch.
///
/// The context selects only how a frozen fact is projected for a session or
@@ -22,59 +19,6 @@ pub(in crate::domains) struct ProtocolOutputProjectionContext<'a> {
pub(in crate::domains) subresource_network_request_id: Option<&'a str>,
}
-/// Ordered contextual projection of protocol-local facts.
-///
-/// A plan is a static sequence from the same closed output enum used by
-/// renderer publications, not a second trait-object registry. It is limited to
-/// context-derived facts and never reads renderer readiness.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(super) struct ProtocolOutputProjectionPlan {
- pub(super) steps: &'static [ProtocolOutputSlot],
-}
-
-pub(super) const POST_SUBRESOURCE_FETCH_PROJECTION_STEPS: &[ProtocolOutputSlot] = &[
- ProtocolOutputSlot::NetworkBacklog,
- ProtocolOutputSlot::SubresourceFetchInterception,
-];
-
-pub(super) const POST_SUBRESOURCE_NETWORK_PROJECTION_STEPS: &[ProtocolOutputSlot] =
- &[ProtocolOutputSlot::NetworkBacklog];
-
-impl ProtocolOutputProjectionPlan {
- pub(super) async fn project_into_protocol_events_async(
- self,
- conn: &mut CdpConnection,
- mut context: ProtocolOutputProjectionContext<'_>,
- ) {
- let mut prepared_payloads = self
- .steps
- .contains(&ProtocolOutputSlot::NetworkBacklog)
- .then(|| {
- ProtocolOutputPayloads::from_slot(
- crate::domains::network::NetworkPreparedOutputSlot::from_outputs(
- crate::domains::network::network_backlog_prepared_outputs(
- conn,
- context.session_id,
- context.subresource_network_request_id.map(
- crate::domains::network::NetworkBacklogPreferredRequestId::contextual_subresource,
- ),
- ),
- ),
- )
- });
- for projection in self.steps.iter().copied() {
- projection
- .project_async(conn, &mut context, prepared_payloads.as_mut())
- .await;
- }
- }
-
- #[cfg(test)]
- pub(super) fn has_contextual_projection_payloads(&self) -> bool {
- self.steps.contains(&ProtocolOutputSlot::NetworkBacklog)
- }
-}
-
impl<'a> ProtocolOutputProjectionContext<'a> {
pub(in crate::domains) fn new(
session_id: Option<&'a str>,
@@ -89,18 +33,6 @@ impl<'a> ProtocolOutputProjectionContext<'a> {
subresource_network_request_id: None,
}
}
-
- pub(super) fn with_subresource_filter(
- mut self,
- frame_id: &'a str,
- document_url: &'a Url,
- network_request_id: Option<&'a str>,
- ) -> Self {
- self.subresource_frame_id = Some(frame_id);
- self.subresource_document_url = Some(document_url);
- self.subresource_network_request_id = network_request_id;
- self
- }
}
/// Projection guard for main-document background events captured before the
@@ -128,31 +60,10 @@ mod tests {
use crate::conn::CommandDispatchContext;
- use super::super::output_slot::ProtocolOutputSlot;
- use super::{
- POST_SUBRESOURCE_FETCH_PROJECTION_STEPS, POST_SUBRESOURCE_NETWORK_PROJECTION_STEPS,
- ProtocolOutputProjectionContext, ProtocolOutputProjectionPlan,
- };
+ use super::ProtocolOutputProjectionContext;
#[test]
fn plans_use_closed_projection_families_with_exact_context() {
- assert_eq!(
- POST_SUBRESOURCE_FETCH_PROJECTION_STEPS,
- &[
- ProtocolOutputSlot::NetworkBacklog,
- ProtocolOutputSlot::SubresourceFetchInterception,
- ]
- );
- assert_eq!(
- POST_SUBRESOURCE_NETWORK_PROJECTION_STEPS,
- &[ProtocolOutputSlot::NetworkBacklog]
- );
- assert!(
- (ProtocolOutputProjectionPlan {
- steps: POST_SUBRESOURCE_NETWORK_PROJECTION_STEPS
- })
- .has_contextual_projection_payloads()
- );
let document_url = Url::parse("https://example.test/page").unwrap();
let mut command = CommandDispatchContext::default();
let context = ProtocolOutputProjectionContext {
diff --git a/moli-protocol/src/domains/activity/main_document.rs b/moli-protocol/src/domains/activity/main_document.rs
index b8be4bcf1..08e410fae 100644
--- a/moli-protocol/src/domains/activity/main_document.rs
+++ b/moli-protocol/src/domains/activity/main_document.rs
@@ -50,7 +50,6 @@ pub(crate) struct MainDocumentDownloadNavigationActivity {
struct DeferredMainDocumentLoadCompletionState {
navigation_activity: MainDocumentNavigationActivity,
- owner_scope: CommandOwnerScope,
renderer_document_binding: Option<CommittedRendererDocumentBinding>,
pending_download: Option<RendererPendingDownloadActivation>,
}
@@ -255,11 +254,9 @@ impl MainDocumentNavigationActivity {
elapsed_ms = timing_started.elapsed().as_millis(),
);
}
- let owner_scope = CommandOwnerScope::capture(conn, self.state.owner.session_id());
conn.enqueue_deferred_main_document_load_completion(
DeferredMainDocumentLoadCompletionAdmission::new(self, pending_download)
- .with_renderer_document_binding(renderer_document_binding)
- .with_owner_scope(owner_scope),
+ .with_renderer_document_binding(renderer_document_binding),
);
}
@@ -624,7 +621,7 @@ impl MainDocumentNavigationActivity {
network::emit_pending_network_backlog_activity_background_events(
conn,
out,
- network::NetworkBacklogProjectionContext::new(self.state.owner.session_id()),
+ network::NetworkBacklogProjectionContext::for_owner(&self.state.owner),
);
if timing_enabled {
tracing::info!(
@@ -643,11 +640,9 @@ impl DeferredMainDocumentLoadCompletionAdmission {
navigation_activity: MainDocumentNavigationActivity,
pending_download: Option<RendererPendingDownloadActivation>,
) -> Self {
- let owner_scope = navigation_activity.state.owner.clone();
Self {
state: DeferredMainDocumentLoadCompletionState {
navigation_activity,
- owner_scope,
renderer_document_binding: None,
pending_download,
},
@@ -662,17 +657,12 @@ impl DeferredMainDocumentLoadCompletionAdmission {
self
}
- fn with_owner_scope(mut self, owner_scope: CommandOwnerScope) -> Self {
- self.state.owner_scope = owner_scope;
- self
- }
-
pub(crate) fn owner_scope(&self) -> &CommandOwnerScope {
- &self.state.owner_scope
+ &self.state.navigation_activity.state.owner
}
pub(crate) fn session_id(&self) -> Option<&str> {
- self.state.owner_scope.session_id()
+ self.owner_scope().session_id()
}
pub(crate) fn is_still_current_for_scheduler(&self, conn: &CdpConnection) -> bool {
@@ -710,7 +700,7 @@ impl DeferredMainDocumentLoadCompletionAdmission {
impl DeferredMainDocumentLoadCompletionActivity {
pub(crate) fn owner_scope(&self) -> &CommandOwnerScope {
- &self.state.owner_scope
+ &self.state.navigation_activity.state.owner
}
pub(crate) fn renderer_document_identity(&self) -> Option<RendererDocumentLifecycleIdentity> {
@@ -718,7 +708,7 @@ impl DeferredMainDocumentLoadCompletionActivity {
}
pub(crate) fn session_id(&self) -> Option<&str> {
- self.state.owner_scope.session_id()
+ self.owner_scope().session_id()
}
pub(crate) fn target_id(&self) -> &str {
@@ -819,11 +809,11 @@ impl PendingDeferredMainDocumentLoadCompletionActivity {
impl CompletedDeferredMainDocumentLoadCompletionActivity {
pub(crate) fn owner_scope(&self) -> &CommandOwnerScope {
- &self.state.owner_scope
+ &self.state.navigation_activity.state.owner
}
pub(crate) fn session_id(&self) -> Option<&str> {
- self.state.owner_scope.session_id()
+ self.owner_scope().session_id()
}
pub(crate) fn observation_id(&self) -> DeferredMainDocumentLoadObservationId {
@@ -1075,7 +1065,6 @@ mod tests {
}
fn deferred_load_admission_for_test(
- conn: &CdpConnection,
binding: CommittedRendererDocumentBinding,
) -> DeferredMainDocumentLoadCompletionAdmission {
let navigation_activity = MainDocumentNavigationActivity::new(
@@ -1086,7 +1075,6 @@ mod tests {
);
DeferredMainDocumentLoadCompletionAdmission::new(navigation_activity, None)
.with_renderer_document_binding(Some(binding))
- .with_owner_scope(CommandOwnerScope::capture(conn, Some("SID-nav")))
}
fn take_deferred_load_work_for_test(conn: &mut CdpConnection) -> ProtocolSchedulerWork {
@@ -1518,7 +1506,7 @@ mod tests {
#[tokio::test]
async fn deferred_load_terminal_before_adapter_wait_is_not_lost() {
let (mut conn, binding, started) = connection_with_dcl_only_renderer_lifecycle();
- let admission = deferred_load_admission_for_test(&conn, binding);
+ let admission = deferred_load_admission_for_test(binding);
conn.enqueue_deferred_main_document_load_completion(admission);
let work = take_deferred_load_work_for_test(&mut conn);
@@ -1539,8 +1527,8 @@ mod tests {
#[test]
fn same_owner_load_admissions_publish_distinct_ordered_work() {
let (mut conn, binding, _) = connection_with_dcl_only_renderer_lifecycle();
- let first = deferred_load_admission_for_test(&conn, binding.clone());
- let second = deferred_load_admission_for_test(&conn, binding);
+ let first = deferred_load_admission_for_test(binding.clone());
+ let second = deferred_load_admission_for_test(binding);
conn.enqueue_deferred_main_document_load_completion(first);
conn.enqueue_deferred_main_document_load_completion(second);
@@ -1571,7 +1559,7 @@ mod tests {
#[tokio::test]
async fn deferred_load_work_remains_resident_without_republication_until_terminal() {
let (mut conn, binding, started) = connection_with_dcl_only_renderer_lifecycle();
- let admission = deferred_load_admission_for_test(&conn, binding);
+ let admission = deferred_load_admission_for_test(binding);
conn.enqueue_deferred_main_document_load_completion(admission);
let work = take_deferred_load_work_for_test(&mut conn);
assert!(
@@ -1661,7 +1649,7 @@ mod tests {
#[tokio::test]
async fn superseded_deferred_load_completion_is_consumed_through_its_observer() {
let (mut conn, binding, _) = connection_with_dcl_only_renderer_lifecycle();
- let old_completion = deferred_load_admission_for_test(&conn, binding);
+ let old_completion = deferred_load_admission_for_test(binding);
conn.enqueue_deferred_main_document_load_completion(old_completion);
let work = take_deferred_load_work_for_test(&mut conn);
diff --git a/moli-protocol/src/domains/activity/mod.rs b/moli-protocol/src/domains/activity/mod.rs
index f57177579..f1bad07f1 100644
--- a/moli-protocol/src/domains/activity/mod.rs
+++ b/moli-protocol/src/domains/activity/mod.rs
@@ -41,6 +41,9 @@ pub(in crate::domains) use subresource::{
};
pub(crate) use subresource::{
flush_post_subresource_auth_activity_background_events_async,
+ flush_post_subresource_auth_activity_for_owner_background_events_async,
flush_post_subresource_fetch_request_activity_background_events_async,
+ flush_post_subresource_fetch_request_activity_for_owner_background_events_async,
flush_post_subresource_response_activity_background_events_async,
+ flush_post_subresource_response_activity_for_owner_background_events_async,
};
diff --git a/moli-protocol/src/domains/activity/subresource.rs b/moli-protocol/src/domains/activity/subresource.rs
index 7d258b3d4..ed309c235 100644
--- a/moli-protocol/src/domains/activity/subresource.rs
+++ b/moli-protocol/src/domains/activity/subresource.rs
@@ -1,12 +1,10 @@
-use url::Url;
-
use crate::conn::{
- BackgroundProtocolEvent, CdpConnection, ClaimedSubresourceContinueRequest, FetchAuthChallenge,
- FetchRequestStage, PendingSubresourceFetchAuthRequest, PendingSubresourceFetchAuthStage,
- PendingSubresourceFetchAuthStageChain, PendingSubresourceFetchOwnerKind,
- PendingSubresourceFetchRequest, PendingSubresourceFetchResponseRequest,
- PendingSubresourceFetchResponseStage, PendingSubresourceFetchResponseStageChain,
- TargetPageResidenceIdentity,
+ BackgroundProtocolEvent, CdpConnection, ClaimedSubresourceContinueRequest, CommandOwnerScope,
+ FetchAuthChallenge, FetchRequestStage, PendingSubresourceFetchAuthRequest,
+ PendingSubresourceFetchAuthStage, PendingSubresourceFetchAuthStageChain,
+ PendingSubresourceFetchOwnerKind, PendingSubresourceFetchRequest,
+ PendingSubresourceFetchResponseRequest, PendingSubresourceFetchResponseStage,
+ PendingSubresourceFetchResponseStageChain, TargetPageResidenceIdentity,
};
use crate::devtools_runtime::DevToolsNetworkInterceptId;
use crate::domains::fetch;
@@ -15,12 +13,12 @@ use moli_core::page::{
SubresourceNetworkRequestHandle,
};
-use super::contextual_projection::{
- MainDocumentBodyCompleteProjection, POST_SUBRESOURCE_FETCH_PROJECTION_STEPS,
- POST_SUBRESOURCE_NETWORK_PROJECTION_STEPS, ProtocolOutputProjectionContext,
- ProtocolOutputProjectionPlan,
+use super::contextual_projection::MainDocumentBodyCompleteProjection;
+use crate::domains::network::{
+ MainDocumentProgressGate, NetworkBacklogPreferredRequestId, NetworkBacklogProjectionContext,
+ emit_pending_network_backlog_activity_background_events,
+ network_backlog_prepared_outputs_for_owner,
};
-use crate::domains::network::MainDocumentProgressGate;
#[derive(Debug)]
pub(crate) struct PreparedSubresourceContinueAction {
@@ -505,29 +503,34 @@ pub(crate) async fn flush_post_subresource_fetch_request_activity_background_eve
out: &mut Vec<BackgroundProtocolEvent>,
session_id: Option<&str>,
pending: &PendingSubresourceFetchRequest,
+) {
+ let owner = CommandOwnerScope::capture(conn, session_id);
+ flush_post_subresource_fetch_request_activity_for_owner_background_events_async(
+ conn, out, &owner, pending,
+ )
+ .await;
+}
+
+pub(crate) async fn flush_post_subresource_fetch_request_activity_for_owner_background_events_async(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ owner: &CommandOwnerScope,
+ pending: &PendingSubresourceFetchRequest,
) {
record_subresource_network_request_handle(
conn,
- session_id,
+ owner,
&pending.network_request_id,
pending.network_request_handle,
);
- let mut command_context = crate::conn::CommandDispatchContext::default();
- ProtocolOutputProjectionPlan {
- steps: POST_SUBRESOURCE_FETCH_PROJECTION_STEPS,
- }
- .project_into_protocol_events_async(
+ project_network_backlog_for_owner(
conn,
- ProtocolOutputProjectionContext::new(session_id, &mut command_context)
- .with_subresource_filter(
- &pending.frame_id,
- &pending.document_url,
- Some(&pending.network_request_id),
- ),
- )
- .await;
- out.extend(command_context.take_protocol_events());
- clear_fetch_pause_network_announcement(conn, session_id, &pending.network_request_id);
+ out,
+ owner,
+ &pending.frame_id,
+ Some(&pending.network_request_id),
+ );
+ clear_fetch_pause_network_announcement(conn, owner, &pending.network_request_id);
}
pub(crate) async fn flush_post_subresource_response_activity_background_events_async(
@@ -535,19 +538,31 @@ pub(crate) async fn flush_post_subresource_response_activity_background_events_a
out: &mut Vec<BackgroundProtocolEvent>,
session_id: Option<&str>,
pending: &PendingSubresourceFetchResponseRequest,
+) {
+ let owner = CommandOwnerScope::capture(conn, session_id);
+ flush_post_subresource_response_activity_for_owner_background_events_async(
+ conn, out, &owner, pending,
+ )
+ .await;
+}
+
+pub(crate) async fn flush_post_subresource_response_activity_for_owner_background_events_async(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ owner: &CommandOwnerScope,
+ pending: &PendingSubresourceFetchResponseRequest,
) {
record_subresource_network_request_handle(
conn,
- session_id,
+ owner,
&pending.network_request_id,
pending.network_request_handle,
);
flush_post_subresource_network_activity_background_events_async(
conn,
out,
- session_id,
+ owner,
&pending.frame_id,
- &pending.document_url,
&pending.network_request_id,
)
.await;
@@ -558,19 +573,31 @@ pub(crate) async fn flush_post_subresource_auth_activity_background_events_async
out: &mut Vec<BackgroundProtocolEvent>,
session_id: Option<&str>,
pending: &PendingSubresourceFetchAuthRequest,
+) {
+ let owner = CommandOwnerScope::capture(conn, session_id);
+ flush_post_subresource_auth_activity_for_owner_background_events_async(
+ conn, out, &owner, pending,
+ )
+ .await;
+}
+
+pub(crate) async fn flush_post_subresource_auth_activity_for_owner_background_events_async(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ owner: &CommandOwnerScope,
+ pending: &PendingSubresourceFetchAuthRequest,
) {
record_subresource_network_request_handle(
conn,
- session_id,
+ owner,
&pending.network_request_id,
pending.network_request_handle,
);
flush_post_subresource_network_activity_background_events_async(
conn,
out,
- session_id,
+ owner,
&pending.frame_id,
- &pending.document_url,
&pending.network_request_id,
)
.await;
@@ -579,46 +606,63 @@ pub(crate) async fn flush_post_subresource_auth_activity_background_events_async
async fn flush_post_subresource_network_activity_background_events_async(
conn: &mut CdpConnection,
out: &mut Vec<BackgroundProtocolEvent>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: &str,
- document_url: &Url,
network_request_id: &str,
) {
- conn.ingest_runtime_session_owner_output_updates(session_id);
- let mut command_context = crate::conn::CommandDispatchContext::default();
- ProtocolOutputProjectionPlan {
- steps: POST_SUBRESOURCE_NETWORK_PROJECTION_STEPS,
- }
- .project_into_protocol_events_async(
+ conn.ingest_runtime_session_owner_output_updates_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ );
+ project_network_backlog_for_owner(conn, out, owner, frame_id, Some(network_request_id));
+ clear_fetch_pause_network_announcement(conn, owner, network_request_id);
+}
+
+fn project_network_backlog_for_owner(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ owner: &CommandOwnerScope,
+ frame_id: &str,
+ network_request_id: Option<&str>,
+) {
+ let preferred_request_id =
+ network_request_id.map(NetworkBacklogPreferredRequestId::contextual_subresource);
+ let mut prepared =
+ network_backlog_prepared_outputs_for_owner(conn, owner, preferred_request_id);
+ emit_pending_network_backlog_activity_background_events(
conn,
- ProtocolOutputProjectionContext::new(session_id, &mut command_context)
- .with_subresource_filter(frame_id, document_url, Some(network_request_id)),
- )
- .await;
- out.extend(command_context.take_protocol_events());
- clear_fetch_pause_network_announcement(conn, session_id, network_request_id);
+ out,
+ NetworkBacklogProjectionContext::for_owner(owner)
+ .with_frame_id(Some(frame_id))
+ .with_contextual_subresource_request_id(network_request_id)
+ .with_prepared_outputs(Some(&mut prepared)),
+ );
}
fn clear_fetch_pause_network_announcement(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
request_id: &str,
) {
- if let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) {
+ if let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ {
runtime_slot.clear_fetch_pause_announced_request_id(request_id);
}
}
fn record_subresource_network_request_handle(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
request_id: &str,
request_handle: Option<SubresourceNetworkRequestHandle>,
) {
let Some(request_handle) = request_handle else {
return;
};
- if let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) {
+ if let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ {
runtime_slot.record_subresource_request_id_for_handle_if_absent(
request_handle,
request_id.to_owned(),
diff --git a/moli-protocol/src/domains/network.rs b/moli-protocol/src/domains/network.rs
index 690ba9d26..b850365f2 100644
--- a/moli-protocol/src/domains/network.rs
+++ b/moli-protocol/src/domains/network.rs
@@ -54,7 +54,7 @@ use super::command_output::CommandOutputPlan;
pub(crate) use activity::NetworkPreparedOutputSlot;
pub(crate) use activity::NetworkPreparedOutputs;
pub(in crate::domains) use activity::{
- network_backlog_prepared_outputs, project_network_backlog_async,
+ network_backlog_prepared_outputs_for_owner, project_network_backlog_async,
project_pending_subresource_continue_async, project_renderer_network_live_async,
project_subresource_fetch_interception_async,
};
diff --git a/moli-protocol/src/domains/network/activity.rs b/moli-protocol/src/domains/network/activity.rs
index 364b5a9f0..cf6c96609 100644
--- a/moli-protocol/src/domains/network/activity.rs
+++ b/moli-protocol/src/domains/network/activity.rs
@@ -1,4 +1,4 @@
-use crate::conn::CdpConnection;
+use crate::conn::{CdpConnection, CommandOwnerScope};
use crate::domains::activity::{
PreparedSubresourceContinueAction, ProtocolOutputPayloads, ProtocolOutputProjectionContext,
ProtocolOutputSink, ProtocolOutputSlot,
@@ -55,13 +55,13 @@ impl NetworkPreparedOutputs {
}
pub(crate) fn backlog_projection_context<'a>(
- session_id: Option<&'a str>,
+ owner: &CommandOwnerScope,
frame_id: Option<&'a str>,
base_timestamp: Option<f64>,
contextual_subresource_request_id: Option<&'a str>,
prepared_outputs: Option<&'a mut Self>,
) -> NetworkBacklogProjectionContext<'a> {
- NetworkBacklogProjectionContext::new(session_id)
+ NetworkBacklogProjectionContext::for_owner(owner)
.with_frame_id(frame_id)
.with_base_timestamp(base_timestamp)
.with_contextual_subresource_request_id(contextual_subresource_request_id)
@@ -288,13 +288,13 @@ impl NetworkPreparedOutputSlot {
pub(crate) fn backlog_projection_context<'a>(
&'a mut self,
- session_id: Option<&'a str>,
+ owner: &CommandOwnerScope,
frame_id: Option<&'a str>,
base_timestamp: Option<f64>,
contextual_subresource_request_id: Option<&'a str>,
) -> NetworkBacklogProjectionContext<'a> {
NetworkPreparedOutputs::backlog_projection_context(
- session_id,
+ owner,
frame_id,
base_timestamp,
contextual_subresource_request_id,
@@ -320,7 +320,7 @@ impl NetworkPreparedOutputSlot {
&mut self,
conn: &mut CdpConnection,
out: &mut Vec<crate::conn::BackgroundProtocolEvent>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: Option<&str>,
base_timestamp: Option<f64>,
contextual_subresource_request_id: Option<&str>,
@@ -329,7 +329,7 @@ impl NetworkPreparedOutputSlot {
conn,
out,
self.backlog_projection_context(
- session_id,
+ owner,
frame_id,
base_timestamp,
contextual_subresource_request_id,
@@ -390,10 +390,11 @@ impl NetworkOutputProjectionStep {
}
NetworkOutputProjectionStep::NetworkBacklog => {
if let Some(slot) = prepared_outputs.and_then(ProtocolOutputPayloads::network_mut) {
+ let owner = CommandOwnerScope::capture(conn, context.session_id);
slot.emit_backlog_activity_background_events(
conn,
context.command.protocol_events_mut(),
- context.session_id,
+ &owner,
context.subresource_frame_id,
context.subresource_timestamp,
context.subresource_network_request_id,
@@ -485,9 +486,39 @@ pub(in crate::domains) fn network_backlog_prepared_outputs(
outputs
}
+pub(in crate::domains) fn network_backlog_prepared_outputs_for_owner(
+ conn: &mut CdpConnection,
+ owner: &crate::conn::CommandOwnerScope,
+ preferred_request_id: Option<super::NetworkBacklogPreferredRequestId<'_>>,
+) -> NetworkPreparedOutputs {
+ let mut outputs = NetworkPreparedOutputs::default();
+ let session_id = owner.session_id();
+ let primary_session_id = conn.runtime_session_owner_primary_session_id_for_route(
+ session_id,
+ owner.session_owner_route(),
+ );
+ if let Some(backlog) = conn.network_backlog_prepared_delivery_for_route(
+ session_id,
+ owner.session_owner_route(),
+ session_id,
+ primary_session_id.as_deref(),
+ preferred_request_id,
+ ) {
+ outputs.extend(NetworkPreparedOutputs {
+ pending_subresource_continue_actions: Vec::new(),
+ renderer_live: TargetNetworkBacklogPreparedDelivery::default(),
+ backlog,
+ subresource_fetch_pauses: Vec::new(),
+ });
+ }
+ outputs
+}
+
#[cfg(test)]
mod tests {
- use crate::conn::{CommandDispatchContext, PendingSubresourceFetchOwnerKind};
+ use crate::conn::{
+ CommandDispatchContext, CommandOwnerScope, PendingSubresourceFetchOwnerKind,
+ };
use axum::{
Router,
extract::ws::{Message, WebSocketUpgrade},
@@ -557,15 +588,16 @@ mod tests {
#[test]
fn network_prepared_outputs_build_backlog_projection_context() {
let mut prepared = NetworkPreparedOutputs::default();
+ let owner = CommandOwnerScope::for_session("SID-1");
let context = NetworkPreparedOutputs::backlog_projection_context(
- Some("SID-1"),
+ &owner,
Some("FRAME-1"),
Some(11.0),
Some("REQ-1"),
Some(&mut prepared),
);
- assert_eq!(context.session_id, Some("SID-1"));
+ assert_eq!(context.session_id(), Some("SID-1"));
assert_eq!(context.frame_id, Some("FRAME-1"));
assert_eq!(context.base_timestamp, Some(11.0));
assert!(
diff --git a/moli-protocol/src/domains/network/backlog.rs b/moli-protocol/src/domains/network/backlog.rs
index e36f083a6..e842a0b0d 100644
--- a/moli-protocol/src/domains/network/backlog.rs
+++ b/moli-protocol/src/domains/network/backlog.rs
@@ -1,7 +1,8 @@
use moli_core::page::{SubresourceBodyFinishedResult, SubresourceResponseBody};
use crate::conn::{
- BackgroundProtocolEvent, CdpConnection, FetchRequestStage, monotonic_timestamp_seconds,
+ BackgroundProtocolEvent, CdpConnection, CommandOwnerScope, FetchRequestStage,
+ monotonic_timestamp_seconds,
};
use crate::devtools_runtime::{DevToolsNetworkInterceptId, DevToolsNetworkResourceType};
use crate::domains::network::{NetworkBacklogPreferredRequestId, NetworkPreparedOutputs};
@@ -25,7 +26,7 @@ use super::output_queue::{
};
pub(crate) struct NetworkBacklogProjectionContext<'a> {
- pub(in crate::domains::network) session_id: Option<&'a str>,
+ owner: CommandOwnerScope,
pub(in crate::domains::network) frame_id: Option<&'a str>,
pub(in crate::domains::network) base_timestamp: Option<f64>,
pub(in crate::domains::network) preferred_request_id:
@@ -34,9 +35,9 @@ pub(crate) struct NetworkBacklogProjectionContext<'a> {
}
impl<'a> NetworkBacklogProjectionContext<'a> {
- pub(crate) fn new(session_id: Option<&'a str>) -> Self {
+ pub(crate) fn for_owner(owner: &CommandOwnerScope) -> Self {
Self {
- session_id,
+ owner: owner.clone(),
frame_id: None,
base_timestamp: None,
preferred_request_id: None,
@@ -44,6 +45,11 @@ impl<'a> NetworkBacklogProjectionContext<'a> {
}
}
+ #[cfg(test)]
+ pub(in crate::domains::network) fn session_id(&self) -> Option<&str> {
+ self.owner.session_id()
+ }
+
pub(crate) fn with_frame_id(mut self, frame_id: Option<&'a str>) -> Self {
self.frame_id = frame_id;
self
@@ -77,7 +83,7 @@ fn emit_subresource_network_delivery_record(
out: &mut Vec<BackgroundProtocolEvent>,
delivery_output: &TargetSubresourceNetworkDeliveryOutput,
event_session_ids: &[Option<String>],
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: &str,
base_timestamp: f64,
) -> bool {
@@ -88,7 +94,7 @@ fn emit_subresource_network_delivery_record(
out,
output,
event_session_ids,
- session_id,
+ owner,
frame_id,
base_timestamp,
)
@@ -99,7 +105,7 @@ fn emit_subresource_network_delivery_record(
out,
output,
event_session_ids,
- session_id,
+ owner,
frame_id,
base_timestamp,
)
@@ -118,7 +124,7 @@ fn emit_subresource_network_delivery_record(
out,
output,
event_session_ids,
- session_id,
+ owner,
frame_id,
base_timestamp,
)
@@ -140,7 +146,7 @@ fn emit_subresource_network_delivery_record(
out,
output,
event_session_ids,
- session_id,
+ owner,
frame_id,
base_timestamp,
)
@@ -198,7 +204,7 @@ fn emit_complete_subresource_network_delivery_record(
out: &mut Vec<BackgroundProtocolEvent>,
delivery_output: &TargetSubresourceCompleteNetworkDeliveryOutput,
event_session_ids: &[Option<String>],
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: &str,
base_timestamp: f64,
) -> bool {
@@ -213,7 +219,9 @@ fn emit_complete_subresource_network_delivery_record(
let record_document_url = output.document_url();
let timestamp = base_timestamp + ((output.index() + 1) as f64 * 0.000_001);
let resource_type = output.resource_type().into();
- let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) else {
+ let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ else {
return false;
};
let request_was_announced_by_fetch_pause =
@@ -222,10 +230,10 @@ fn emit_complete_subresource_network_delivery_record(
return false;
}
if output.resource_type() != moli_core::page::SubresourceResourceType::WebSocket {
- record_subresource_pending_response_body(conn, session_id, request_id, event_session_ids);
+ record_subresource_pending_response_body(conn, owner, request_id, event_session_ids);
record_subresource_request_body(
conn,
- session_id,
+ owner,
request_id,
output.request_body_bytes(),
event_session_ids,
@@ -320,7 +328,7 @@ fn emit_complete_subresource_network_delivery_record(
for event_session_id in event_session_ids {
let blocked_intercepts = matching_subresource_network_intercepts(
conn,
- session_id,
+ owner,
FetchRequestStage::Response,
resource_type,
final_url,
@@ -349,7 +357,7 @@ fn emit_complete_subresource_network_delivery_record(
if let Some(response_body) = output.response_body() {
record_subresource_response_body_source(
conn,
- session_id,
+ owner,
response_body,
request_id,
event_session_ids,
@@ -372,7 +380,7 @@ fn emit_complete_subresource_network_delivery_record(
if output.resource_type() != moli_core::page::SubresourceResourceType::WebSocket {
record_subresource_failed_response_body(
conn,
- session_id,
+ owner,
error_text.clone(),
request_id,
event_session_ids,
@@ -400,7 +408,7 @@ fn emit_staged_subresource_request_started(
out: &mut Vec<BackgroundProtocolEvent>,
delivery_output: &TargetSubresourceRequestNetworkDeliveryOutput,
event_session_ids: &[Option<String>],
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: &str,
base_timestamp: f64,
) -> bool {
@@ -415,13 +423,13 @@ fn emit_staged_subresource_request_started(
let timestamp = base_timestamp + ((output.index() + 1) as f64 * 0.000_001);
let resource_type = output.resource_type().into();
let request_was_announced_by_fetch_pause = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
.is_ok_and(|runtime_slot| runtime_slot.take_fetch_pause_announced_request_id(request_id));
if output.resource_type() != moli_core::page::SubresourceResourceType::WebSocket {
- record_subresource_pending_response_body(conn, session_id, request_id, event_session_ids);
+ record_subresource_pending_response_body(conn, owner, request_id, event_session_ids);
record_subresource_request_body(
conn,
- session_id,
+ owner,
request_id,
output.request_body_bytes(),
event_session_ids,
@@ -481,7 +489,7 @@ fn emit_staged_subresource_response_started(
out: &mut Vec<BackgroundProtocolEvent>,
delivery_output: &TargetSubresourceResponseNetworkDeliveryOutput,
event_session_ids: &[Option<String>],
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: &str,
base_timestamp: f64,
) -> bool {
@@ -536,15 +544,16 @@ fn emit_staged_subresource_response_started(
for event_session_id in event_session_ids {
let blocked_intercepts = matching_subresource_network_intercepts(
conn,
- session_id,
+ owner,
FetchRequestStage::Response,
resource_type,
output.final_url(),
);
let fetch_request_id = (!blocked_intercepts.is_empty())
.then(|| {
- conn.in_flight_subresource_fetch_request_id_for_session_owner(
- session_id,
+ conn.in_flight_subresource_fetch_request_id_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
output.handle().get(),
)
})
@@ -575,14 +584,17 @@ fn emit_staged_subresource_response_started(
fn matching_subresource_network_intercepts(
conn: &CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
request_stage: FetchRequestStage,
resource_type: DevToolsNetworkResourceType,
url: &url::Url,
) -> Vec<DevToolsNetworkInterceptId> {
- conn.target_fetch_subresource_interception_snapshot_for_session_owner(session_id)
- .map(|snapshot| snapshot.matching_network_intercepts(request_stage, resource_type, url))
- .unwrap_or_default()
+ conn.target_fetch_subresource_interception_snapshot_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
+ .map(|snapshot| snapshot.matching_network_intercepts(request_stage, resource_type, url))
+ .unwrap_or_default()
}
fn emit_staged_subresource_body_finished(
@@ -590,7 +602,7 @@ fn emit_staged_subresource_body_finished(
out: &mut Vec<BackgroundProtocolEvent>,
delivery_output: &TargetSubresourceBodyNetworkDeliveryOutput,
event_session_ids: &[Option<String>],
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: &str,
base_timestamp: f64,
) -> bool {
@@ -610,7 +622,7 @@ fn emit_staged_subresource_body_finished(
let response_body_len = response_body.len();
record_subresource_response_body_source(
conn,
- session_id,
+ owner,
response_body,
request_id,
event_session_ids,
@@ -644,7 +656,7 @@ fn emit_staged_subresource_body_finished(
SubresourceBodyFinishedResult::Failed(error_text) => {
record_subresource_failed_response_body(
conn,
- session_id,
+ owner,
error_text.clone(),
request_id,
event_session_ids,
@@ -668,7 +680,7 @@ fn emit_staged_subresource_body_finished(
} => {
record_subresource_response_body_source(
conn,
- session_id,
+ owner,
partial_body,
request_id,
event_session_ids,
@@ -696,20 +708,24 @@ pub(crate) fn emit_pending_network_backlog_activity_background_events(
context: NetworkBacklogProjectionContext<'_>,
) {
let NetworkBacklogProjectionContext {
- session_id,
+ owner,
frame_id,
base_timestamp,
preferred_request_id,
prepared_outputs,
} = context;
- let primary_session_id = conn.runtime_session_owner_primary_session_id(session_id);
+ let primary_session_id = conn.runtime_session_owner_primary_session_id_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ );
let Some((frame_id, snapshot)) = (|| {
- let frame_id = frame_id
- .map(str::to_owned)
- .or_else(|| conn.target_owner_identity_for_session(session_id)?.1)?;
+ let frame_id = frame_id.map(str::to_owned).or_else(|| {
+ conn.target_owner_identity_for_route(owner.session_id(), owner.session_owner_route())?
+ .1
+ })?;
let snapshot = pending_network_backlog_delivery_snapshot(
conn,
- session_id,
+ &owner,
primary_session_id.as_deref(),
preferred_request_id,
prepared_outputs,
@@ -721,7 +737,7 @@ pub(crate) fn emit_pending_network_backlog_activity_background_events(
emit_network_delivery_snapshot(
conn,
out,
- session_id,
+ &owner,
&frame_id,
base_timestamp.unwrap_or_else(monotonic_timestamp_seconds),
snapshot,
@@ -741,10 +757,16 @@ pub(crate) fn emit_prepared_renderer_network_live_background_events(
session_id: Option<&str>,
prepared: &mut TargetNetworkBacklogPreparedDelivery,
) {
+ let owner = session_id
+ .map(CommandOwnerScope::for_session)
+ .unwrap_or_else(|| CommandOwnerScope::for_implicit_route(None));
+ let session_id = owner.session_id();
let Some((frame_id, snapshot)) = (|| {
- let frame_id = conn.target_owner_identity_for_session(session_id)?.1?;
+ let frame_id = conn
+ .target_owner_identity_for_route(session_id, owner.session_owner_route())?
+ .1?;
let snapshot = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(session_id, owner.session_owner_route())
.ok()?
.pending_network_backlog_delivery_snapshot_from_backlog(prepared)?;
Some((frame_id, snapshot))
@@ -754,7 +776,7 @@ pub(crate) fn emit_prepared_renderer_network_live_background_events(
emit_network_delivery_snapshot(
conn,
out,
- session_id,
+ &owner,
&frame_id,
monotonic_timestamp_seconds(),
snapshot,
@@ -764,7 +786,7 @@ pub(crate) fn emit_prepared_renderer_network_live_background_events(
fn emit_network_delivery_snapshot(
conn: &mut CdpConnection,
out: &mut Vec<BackgroundProtocolEvent>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
frame_id: &str,
base_timestamp: f64,
snapshot: PendingNetworkBacklogDeliverySnapshot,
@@ -777,7 +799,7 @@ fn emit_network_delivery_snapshot(
out,
output,
event_session_ids,
- session_id,
+ owner,
frame_id,
base_timestamp,
);
@@ -792,25 +814,31 @@ fn emit_network_delivery_snapshot(
}
}
}
- mark_network_backlog_delivery_snapshot_emitted(conn, session_id, &snapshot);
+ mark_network_backlog_delivery_snapshot_emitted(conn, owner, &snapshot);
}
fn pending_network_backlog_delivery_snapshot(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
primary_session_id: Option<&str>,
preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
prepared_network_outputs: Option<&mut NetworkPreparedOutputs>,
) -> Option<PendingNetworkBacklogDeliverySnapshot> {
if let Some(prepared_network_outputs) = prepared_network_outputs {
- let runtime_slot = conn.runtime_session_owner_slot_mut(session_id).ok()?;
+ let runtime_slot = conn
+ .runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
+ .ok()?;
return runtime_slot.pending_network_backlog_delivery_snapshot_from_backlog(
prepared_network_outputs.backlog_mut(),
);
}
- conn.pending_network_backlog_delivery_snapshot_for_session_owner(
- session_id,
- session_id,
+ conn.pending_network_backlog_delivery_snapshot_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ owner.session_id(),
primary_session_id,
preferred_request_id,
)
@@ -818,10 +846,12 @@ fn pending_network_backlog_delivery_snapshot(
fn mark_network_backlog_delivery_snapshot_emitted(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
snapshot: &PendingNetworkBacklogDeliverySnapshot,
) {
- let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) else {
+ let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ else {
return;
};
runtime_slot.mark_network_backlog_delivery_snapshot_emitted(snapshot);
@@ -829,15 +859,16 @@ fn mark_network_backlog_delivery_snapshot_emitted(
fn record_subresource_response_body_source(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
response_body: &SubresourceResponseBody,
request_id: &str,
session_ids: &[Option<String>],
) {
let captured_body = crate::conn::CapturedBody::from_subresource_response_body(response_body);
let data_type = crate::devtools_runtime::DevToolsNetworkDataType::Response;
- let collector_ids = conn.network_data_collector_ids_for_session_owner_body(
- session_id,
+ let collector_ids = conn.network_data_collector_ids_for_route_body(
+ owner.session_id(),
+ owner.session_owner_route(),
data_type,
captured_body.len(),
);
@@ -849,7 +880,9 @@ fn record_subresource_response_body_source(
collector_ids.iter().cloned(),
collection_was_gated,
);
- let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) else {
+ let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ else {
return;
};
runtime_slot.record_captured_response_body_source_with_collector_scope(
@@ -863,7 +896,7 @@ fn record_subresource_response_body_source(
fn record_subresource_request_body(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
request_id: &str,
request_body: Option<&[u8]>,
session_ids: &[Option<String>],
@@ -872,8 +905,9 @@ fn record_subresource_request_body(
return;
};
let data_type = crate::devtools_runtime::DevToolsNetworkDataType::Request;
- let collector_ids = conn.network_data_collector_ids_for_session_owner_body(
- session_id,
+ let collector_ids = conn.network_data_collector_ids_for_route_body(
+ owner.session_id(),
+ owner.session_owner_route(),
data_type,
request_body.len(),
);
@@ -885,7 +919,9 @@ fn record_subresource_request_body(
collector_ids.iter().cloned(),
collection_was_gated,
);
- let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) else {
+ let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ else {
return;
};
runtime_slot.record_captured_request_body_with_collector_scope(
@@ -899,19 +935,22 @@ fn record_subresource_request_body(
fn record_subresource_pending_response_body(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
request_id: &str,
session_ids: &[Option<String>],
) {
- let collector_ids = conn.network_data_collector_ids_for_session_owner_body(
- session_id,
+ let collector_ids = conn.network_data_collector_ids_for_route_body(
+ owner.session_id(),
+ owner.session_owner_route(),
crate::devtools_runtime::DevToolsNetworkDataType::Response,
0,
);
let collection_was_gated = conn.network_data_collection_is_gated_for_body(
crate::devtools_runtime::DevToolsNetworkDataType::Response,
);
- let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) else {
+ let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ else {
return;
};
runtime_slot.record_pending_response_body_with_collector_scope(
@@ -924,20 +963,23 @@ fn record_subresource_pending_response_body(
fn record_subresource_failed_response_body(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
error_text: String,
request_id: &str,
session_ids: &[Option<String>],
) {
- let collector_ids = conn.network_data_collector_ids_for_session_owner_body(
- session_id,
+ let collector_ids = conn.network_data_collector_ids_for_route_body(
+ owner.session_id(),
+ owner.session_owner_route(),
crate::devtools_runtime::DevToolsNetworkDataType::Response,
0,
);
let collection_was_gated = conn.network_data_collection_is_gated_for_body(
crate::devtools_runtime::DevToolsNetworkDataType::Response,
);
- let Ok(runtime_slot) = conn.runtime_session_owner_slot_mut(session_id) else {
+ let Ok(runtime_slot) = conn
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
+ else {
return;
};
runtime_slot.record_failed_response_body_with_collector_scope(
@@ -1047,7 +1089,7 @@ mod tests {
use url::Url;
use crate::{
- conn::CdpConnection,
+ conn::{CdpConnection, CommandOwnerScope},
devtools_runtime::{AutomationEvent, DevToolsNetworkResourceType},
domains::network::{
NetworkPreparedOutputs, PendingSubresourceNetworkActivity,
@@ -1093,7 +1135,8 @@ mod tests {
let mut events = Vec::new();
let mut conn = CdpConnection::new();
conn.install_default_browser_target();
- emit_network_delivery_snapshot(&mut conn, &mut events, None, "FRAME-1", 1.0, snapshot);
+ let owner = crate::conn::CommandOwnerScope::for_implicit_route(None);
+ emit_network_delivery_snapshot(&mut conn, &mut events, &owner, "FRAME-1", 1.0, snapshot);
events
.into_iter()
.find(|event| event.protocol_method() == Some("Network.loadingFinished"))
@@ -1124,12 +1167,13 @@ mod tests {
#[test]
fn backlog_projection_context_wraps_contextual_subresource_preferred_request_id() {
- let context = NetworkBacklogProjectionContext::new(Some("SID-1"))
+ let owner = CommandOwnerScope::for_session("SID-1");
+ let context = NetworkBacklogProjectionContext::for_owner(&owner)
.with_frame_id(Some("FRAME-1"))
.with_base_timestamp(Some(12.5))
.with_contextual_subresource_request_id(Some("REQ-prepared"));
- assert_eq!(context.session_id, Some("SID-1"));
+ assert_eq!(context.session_id(), Some("SID-1"));
assert_eq!(context.frame_id, Some("FRAME-1"));
assert_eq!(context.base_timestamp, Some(12.5));
assert_eq!(
@@ -1144,7 +1188,8 @@ mod tests {
#[test]
fn backlog_projection_context_carries_captured_outputs_slot() {
let mut prepared_outputs = NetworkPreparedOutputs::default();
- let context = NetworkBacklogProjectionContext::new(Some("SID-1"))
+ let owner = CommandOwnerScope::for_session("SID-1");
+ let context = NetworkBacklogProjectionContext::for_owner(&owner)
.with_prepared_outputs(Some(&mut prepared_outputs));
assert!(
diff --git a/moli-protocol/src/domains/network/tests/response_body.rs b/moli-protocol/src/domains/network/tests/response_body.rs
index 0f6f5d51d..5cabf3132 100644
--- a/moli-protocol/src/domains/network/tests/response_body.rs
+++ b/moli-protocol/src/domains/network/tests/response_body.rs
@@ -384,10 +384,11 @@ async fn get_response_body_returns_partial_body_after_staged_loading_failed() {
*prepared_outputs.backlog_mut() = backlog;
let mut emitted_events = Vec::new();
+ let owner = crate::conn::CommandOwnerScope::for_session("SID-1");
emit_pending_network_backlog_activity_background_events(
&mut ctx.conn,
&mut emitted_events,
- NetworkBacklogProjectionContext::new(Some("SID-1"))
+ NetworkBacklogProjectionContext::for_owner(&owner)
.with_base_timestamp(Some(100.0))
.with_prepared_outputs(Some(&mut prepared_outputs)),
);
diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rs
index b9bcba034..b92966ee6 100644
--- a/moli-protocol/src/domains/page.rs
+++ b/moli-protocol/src/domains/page.rs
@@ -2329,10 +2329,11 @@ pub(in crate::domains) async fn emit_top_level_history_traversal_activity_backgr
pub(crate) async fn navigate_page_owned_top_level_location_background_events_async(
conn: &mut CdpConnection,
out: &mut Vec<BackgroundProtocolEvent>,
- session_id: Option<&str>,
+ command_owner: &CommandOwnerScope,
owner: &crate::conn::TargetPageResidenceIdentity,
navigation: RendererDocumentSourcedTopLevelLocationNavigation,
) {
+ let session_id = command_owner.session_id();
let source_document = navigation.source_document();
if !conn.target_page_residence_identity_is_current_for_session(session_id, owner) {
tracing::debug!(
@@ -2346,10 +2347,10 @@ pub(crate) async fn navigate_page_owned_top_level_location_background_events_asy
);
return;
}
- navigate_session_owner_from_renderer_request_background_events_async(
+ navigate_command_owner_from_renderer_request_background_events_async(
conn,
out,
- session_id,
+ command_owner.clone(),
navigation.url(),
navigation.request_method(),
navigation.request_body(),
@@ -2365,10 +2366,20 @@ pub(crate) async fn navigate_session_owner_from_renderer_background_events_async
session_id: Option<&str>,
url: &str,
) {
- navigate_session_owner_from_renderer_request_background_events_async(
+ let owner = CommandOwnerScope::capture(conn, session_id);
+ navigate_command_owner_from_renderer_background_events_async(conn, out, &owner, url).await;
+}
+
+pub(crate) async fn navigate_command_owner_from_renderer_background_events_async(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ owner: &CommandOwnerScope,
+ url: &str,
+) {
+ navigate_command_owner_from_renderer_request_background_events_async(
conn,
out,
- session_id,
+ owner.clone(),
url,
"GET",
None,
@@ -2378,17 +2389,16 @@ pub(crate) async fn navigate_session_owner_from_renderer_background_events_async
.await;
}
-async fn navigate_session_owner_from_renderer_request_background_events_async(
+async fn navigate_command_owner_from_renderer_request_background_events_async(
conn: &mut CdpConnection,
out: &mut Vec<BackgroundProtocolEvent>,
- session_id: Option<&str>,
+ owner: CommandOwnerScope,
url: &str,
request_method: &str,
request_body: Option<&[u8]>,
request_headers: &[(String, String)],
browser_navigation_kind: moli_fetch::BrowserNavigationRequestKind,
) {
- let owner = CommandOwnerScope::capture(conn, session_id);
let start = navigation::start_session_owner_navigation_from_renderer(
conn,
&owner,
@@ -7475,16 +7485,6 @@ pub(crate) async fn complete_pending_page_command(
conn: &mut CdpConnection,
completed: CompletedPageCommandDispatch,
command_context: &mut CommandDispatchContext,
-) -> PageCommandTaskStep {
- let owner_scope = completed.owner_scope.clone();
- let mut route_scope = owner_scope.enter(conn);
- complete_pending_page_command_inner(route_scope.conn_mut(), completed, command_context).await
-}
-
-async fn complete_pending_page_command_inner(
- conn: &mut CdpConnection,
- completed: CompletedPageCommandDispatch,
- command_context: &mut CommandDispatchContext,
) -> PageCommandTaskStep {
let command_id = completed.command_id;
let owner_scope = completed.owner_scope.clone();
@@ -7611,7 +7611,7 @@ async fn complete_pending_page_command_inner(
return preload::complete_pending_add_script_to_evaluate_on_new_document_command(
conn,
command_id,
- session_id.as_deref(),
+ &owner_scope,
completed,
command_context,
)
@@ -7989,7 +7989,7 @@ async fn complete_pending_page_command_inner(
return preload::complete_pending_create_isolated_world_command(
conn,
command_id,
- session_id.as_deref(),
+ &owner_scope,
*completed,
command_context,
)
@@ -8027,7 +8027,7 @@ async fn complete_pending_page_command_inner(
return termination::complete_stop_loading_command_dispatch(
conn,
command_id,
- session_id.as_deref(),
+ &owner_scope,
)
.await;
}
@@ -8035,7 +8035,7 @@ async fn complete_pending_page_command_inner(
return termination::complete_crash_command_dispatch(
conn,
command_id,
- session_id.as_deref(),
+ &owner_scope,
command_context,
)
.await;
@@ -8044,7 +8044,7 @@ async fn complete_pending_page_command_inner(
return termination::complete_close_command_dispatch(
conn,
command_id,
- session_id.as_deref(),
+ &owner_scope,
command_context,
)
.await;
diff --git a/moli-protocol/src/domains/page/app_manifest.rs b/moli-protocol/src/domains/page/app_manifest.rs
index 86b6a676c..86e6372e9 100644
--- a/moli-protocol/src/domains/page/app_manifest.rs
+++ b/moli-protocol/src/domains/page/app_manifest.rs
@@ -230,7 +230,7 @@ pub(super) fn complete_get_app_manifest_command(
emit_pending_network_backlog_activity_background_events(
conn,
&mut ordered_events,
- NetworkBacklogProjectionContext::new(session_id),
+ NetworkBacklogProjectionContext::for_owner(owner),
);
let mut plan = CommandOutputPlan::default();
plan.extend_background_events(ordered_events);
diff --git a/moli-protocol/src/domains/page/navigation_commit.rs b/moli-protocol/src/domains/page/navigation_commit.rs
index 98903553f..3848e54ad 100644
--- a/moli-protocol/src/domains/page/navigation_commit.rs
+++ b/moli-protocol/src/domains/page/navigation_commit.rs
@@ -536,7 +536,7 @@ async fn restore_and_commit_loaded_navigation_page_async(
Box::pin(
crate::domains::runtime::start_bidi_preload_channel_listeners_for_execution_context_background_events_async(
conn,
- state.owner.session_id(),
+ &state.owner,
execution_context_id,
&mut preload_channel_listener_events,
),
diff --git a/moli-protocol/src/domains/page/preload.rs b/moli-protocol/src/domains/page/preload.rs
index a94c3f1bf..8e0686083 100644
--- a/moli-protocol/src/domains/page/preload.rs
+++ b/moli-protocol/src/domains/page/preload.rs
@@ -12,7 +12,7 @@ use serde_json::json;
use crate::conn::{
BackgroundProtocolEvent, BrowserContext, CdpConnection, CdpSessionRoute, Cmd,
- CommandDispatchContext, DocumentStartScript,
+ CommandDispatchContext, CommandOwnerScope, DocumentStartScript,
};
use crate::domains::command_output::CommandOutputPlan;
use crate::domains::runtime::bidi_preload_function_declaration_source;
@@ -124,14 +124,20 @@ impl PendingAddScriptToEvaluateOnNewDocumentCommand {
}
}
-async fn append_loaded_page_document_start_script_for_session_async(
+async fn append_loaded_page_document_start_script_for_owner_async(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
script: &DocumentStartScript,
) -> Result<(), String> {
- let renderer_runtime_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let slot = conn.runtime_session_owner_slot_mut(session_id)?;
+ let renderer_runtime_inspector_session_id = conn
+ .target_renderer_runtime_inspector_session_id_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ );
+ let slot = conn.runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )?;
if let Some(page) = slot.loaded_page_mut() {
page.add_document_start_script_runtime_activity_async(
renderer_runtime_inspector_session_id.as_deref(),
@@ -144,12 +150,15 @@ async fn append_loaded_page_document_start_script_for_session_async(
Ok(())
}
-async fn remove_loaded_page_document_start_script_for_session_async(
+async fn remove_loaded_page_document_start_script_for_owner_async(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
registry_key: &str,
) -> Result<(), String> {
- let slot = conn.runtime_session_owner_slot_mut(session_id)?;
+ let slot = conn.runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )?;
if let Some(page) = slot.loaded_page_mut() {
page.remove_document_start_script_by_registry_key_async(registry_key)
.await
@@ -390,13 +399,14 @@ async fn execute_devtools_single_route_preload_command_async(
Ok(resolved) => resolved,
Err(error) => return (Err(error), Vec::new(), None),
};
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
+ let owner = CommandOwnerScope::for_implicit_route(Some(route));
let mut events = Vec::new();
let mut command_context = CommandDispatchContext::default();
let result = match command {
DevToolsCommand::AddPreloadScript(command) => {
execute_devtools_single_route_add_preload_script_command(
- route_scope.conn_mut(),
+ conn,
+ &owner,
command,
result_kind,
&mut events,
@@ -405,11 +415,8 @@ async fn execute_devtools_single_route_preload_command_async(
.await
}
DevToolsCommand::RemovePreloadScript(command) => {
- match execute_devtools_single_route_remove_preload_script_command(
- route_scope.conn_mut(),
- command,
- )
- .await
+ match execute_devtools_single_route_remove_preload_script_command(conn, &owner, command)
+ .await
{
Ok(()) => Ok(DevToolsCommandResult::Empty),
Err(error) => Err(error),
@@ -473,14 +480,10 @@ async fn execute_devtools_browser_context_add_preload_script_command(
target_id: active_target_id,
is_attached_session: false,
};
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- append_loaded_page_document_start_script_for_session_async(
- route_scope.conn_mut(),
- None,
- &renderer_script,
- )
- .await
- .map_err(|message| devtools_preload_owner_error(&message))?;
+ let owner = CommandOwnerScope::for_implicit_route(Some(route));
+ append_loaded_page_document_start_script_for_owner_async(conn, &owner, &renderer_script)
+ .await
+ .map_err(|message| devtools_preload_owner_error(&message))?;
}
Ok(DevToolsCommandResult::AddPreloadScript(
DevToolsAddPreloadScriptResult {
@@ -491,21 +494,25 @@ async fn execute_devtools_browser_context_add_preload_script_command(
async fn execute_devtools_single_route_add_preload_script_command(
conn: &mut CdpConnection,
+ owner: &CommandOwnerScope,
command: DevToolsAddPreloadScriptCommand,
result_kind: DevToolsPreloadResultKind,
events: &mut Vec<BackgroundProtocolEvent>,
command_context: &mut CommandDispatchContext,
) -> Result<DevToolsCommandResult, DevToolsError> {
let identifier = if is_bidi_default_preload_command(&command) {
- execute_devtools_default_add_preload_script_command(conn, command).await?
+ execute_devtools_default_add_preload_script_command(conn, owner, command).await?
} else {
- if conn.target_owner_identity_for_session(None).is_none() {
+ if conn
+ .target_owner_identity_for_route(owner.session_id(), owner.session_owner_route())
+ .is_none()
+ {
return Err(preload_missing_owner_error(conn));
}
let mut side_effects = CommandOutputPlan::default();
let identifier = add_script_to_evaluate_on_new_document_direct_async(
conn,
- None,
+ owner,
command,
&mut side_effects,
command_context,
@@ -519,10 +526,20 @@ async fn execute_devtools_single_route_add_preload_script_command(
async fn execute_devtools_default_add_preload_script_command(
conn: &mut CdpConnection,
+ owner: &CommandOwnerScope,
command: DevToolsAddPreloadScriptCommand,
) -> Result<String, DevToolsError> {
let script = document_start_script_from_add_preload_command(&command)?;
- let Some(browser_context) = conn.browser_context.as_mut() else {
+ let Some(browser_context_id) = conn
+ .target_owner_identity_for_route(owner.session_id(), owner.session_owner_route())
+ .map(|(browser_context_id, _)| browser_context_id)
+ else {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "BrowserContextNotLoaded",
+ ));
+ };
+ let Some(browser_context) = conn.browser_context_by_id_mut(&browser_context_id) else {
return Err(DevToolsError::new(
DevToolsErrorKind::NoSuchTarget,
"BrowserContextNotLoaded",
@@ -532,19 +549,22 @@ async fn execute_devtools_default_add_preload_script_command(
let script = script.with_registry_key(
BrowserContext::default_document_start_script_registry_key(&identifier),
);
- append_default_document_start_script_direct_async(conn, None, identifier, &script).await
+ append_default_document_start_script_direct_async(conn, owner, identifier, &script).await
}
async fn append_default_document_start_script_direct_async(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
identifier: String,
script: &DocumentStartScript,
) -> Result<String, DevToolsError> {
- let renderer_runtime_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
+ let renderer_runtime_inspector_session_id = conn
+ .target_renderer_runtime_inspector_session_id_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ );
let Some(page) = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -562,7 +582,7 @@ async fn append_default_document_start_script_direct_async(
.await
.map_err(|error| devtools_preload_internal_error(error.to_string()))?;
let Some(page) = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -575,22 +595,28 @@ async fn append_default_document_start_script_direct_async(
async fn execute_devtools_single_route_remove_preload_script_command(
conn: &mut CdpConnection,
+ owner: &CommandOwnerScope,
command: DevToolsRemovePreloadScriptCommand,
) -> Result<(), DevToolsError> {
let protocol = command.context.protocol;
let script_id = command.script_id.into_string();
- let owner_identity = conn.target_owner_identity_for_session(None);
+ let owner_identity =
+ conn.target_owner_identity_for_route(owner.session_id(), owner.session_owner_route());
let target_registry_key = owner_identity.as_ref().map(|(_, target_id)| {
BrowserContext::target_document_start_script_registry_key(target_id.as_deref(), &script_id)
});
- let remove_result = conn.with_target_owner_state_for_session_mut(None, |owner_state| {
- remove_stored_document_start_script_registry_key(
- owner_state,
- None,
- &script_id,
- target_registry_key.clone(),
- )
- });
+ let remove_result = conn.with_target_owner_state_for_route_mut(
+ owner.session_id(),
+ owner.session_owner_route(),
+ |owner_state| {
+ remove_stored_document_start_script_registry_key(
+ owner_state,
+ None,
+ &script_id,
+ target_registry_key.clone(),
+ )
+ },
+ );
let Some((mut removed, mut registry_key)) = remove_result else {
return Err(preload_missing_owner_error(conn));
};
@@ -610,19 +636,19 @@ async fn execute_devtools_single_route_remove_preload_script_command(
"NoSuchScript",
));
}
- remove_document_start_script_direct_async(conn, None, registry_key).await
+ remove_document_start_script_direct_async(conn, owner, registry_key).await
}
async fn remove_document_start_script_direct_async(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
registry_key: Option<String>,
) -> Result<(), DevToolsError> {
let Some(registry_key) = registry_key else {
return Ok(());
};
let Some(page) = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -636,7 +662,7 @@ async fn remove_document_start_script_direct_async(
.await
.map_err(|error| devtools_preload_internal_error(error.to_string()))?;
let Some(page) = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -684,14 +710,10 @@ async fn execute_devtools_bidi_browser_context_remove_preload_script_command(
target_id: active_target_id,
is_attached_session: false,
};
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- remove_loaded_page_document_start_script_for_session_async(
- route_scope.conn_mut(),
- None,
- registry_key,
- )
- .await
- .map_err(|message| devtools_preload_owner_error(&message))?;
+ let owner = CommandOwnerScope::for_implicit_route(Some(route));
+ remove_loaded_page_document_start_script_for_owner_async(conn, &owner, registry_key)
+ .await
+ .map_err(|message| devtools_preload_owner_error(&message))?;
}
Ok(DevToolsCommandResult::Empty)
}
@@ -974,10 +996,8 @@ fn find_preload_script_route(conn: &mut CdpConnection, script_id: &str) -> Optio
let Some(route) = conn.target_session_route_for_target_id(&target_id) else {
continue;
};
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- let scoped_conn = route_scope.conn_mut();
- let has_script = scoped_conn
- .target_owner_state_for_session(None)
+ let has_script = conn
+ .target_owner_state_for_route(None, Some(&route))
.is_some_and(|owner_state| {
owner_state
.document_start_scripts
@@ -986,9 +1006,7 @@ fn find_preload_script_route(conn: &mut CdpConnection, script_id: &str) -> Optio
})
|| route
.browser_context_id()
- .and_then(|browser_context_id| {
- scoped_conn.browser_context_by_id(browser_context_id)
- })
+ .and_then(|browser_context_id| conn.browser_context_by_id(browser_context_id))
.is_some_and(|browser_context| {
browser_context.has_default_document_start_script(script_id)
});
@@ -1228,12 +1246,8 @@ pub(super) fn try_start_create_isolated_world_command(
return PageCommandTaskStep::Complete(CommandOutputPlan::error(-32000, "NoDocumentLoaded"));
}
- start_create_isolated_world_initial_navigation_or_renderer_phase(
- conn,
- cmd.id,
- cmd.session_id,
- task,
- )
+ let owner = CommandOwnerScope::capture(conn, cmd.session_id);
+ start_create_isolated_world_initial_navigation_or_renderer_phase(conn, cmd.id, owner, task)
}
fn prepare_create_isolated_world_task(
@@ -1280,18 +1294,15 @@ fn pending_create_isolated_world_command_for_session(
fn start_create_isolated_world_initial_navigation_or_renderer_phase(
conn: &mut CdpConnection,
command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: CommandOwnerScope,
mut task: CreateIsolatedWorldCommandTask,
) -> PageCommandTaskStep {
let should_start_target_url_navigation =
- conn.runtime_session_owner_can_start_initial_document_navigation(session_id);
+ conn.runtime_session_owner_can_start_initial_document_navigation(owner.session_id());
if !should_start_target_url_navigation {
- return start_create_isolated_world_frame_or_world_phase(
- conn, command_id, session_id, task,
- );
+ return start_create_isolated_world_frame_or_world_phase(conn, command_id, owner, task);
}
- let owner = crate::conn::CommandOwnerScope::capture(conn, session_id);
let start = match super::navigation::start_initial_document_navigation_for_session_owner(
conn,
None,
@@ -1309,7 +1320,7 @@ fn start_create_isolated_world_initial_navigation_or_renderer_phase(
) {
return PageCommandTaskStep::Complete(plan);
}
- start_create_isolated_world_frame_or_world_phase(conn, command_id, session_id, task)
+ start_create_isolated_world_frame_or_world_phase(conn, command_id, owner, task)
}
super::navigation::NavigateCommandStart::CompletePlan(plan) => {
PageCommandTaskStep::Complete(plan)
@@ -1350,22 +1361,23 @@ fn start_create_isolated_world_initial_navigation_or_renderer_phase(
fn start_create_isolated_world_frame_or_world_phase(
conn: &mut CdpConnection,
command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: CommandOwnerScope,
mut task: CreateIsolatedWorldCommandTask,
) -> PageCommandTaskStep {
- let owner = crate::conn::CommandOwnerScope::capture(conn, session_id);
task.phase = CreateIsolatedWorldPhase::RuntimeActivity;
let frame_id = (task.params.frame_id != task.target_id).then(|| task.params.frame_id.clone());
let world_name = task.params.world_name.clone();
let grant_universal_access = task.params.grant_universal_access;
- let renderer_runtime_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let page = match loaded_page_mut_for_create_isolated_world_renderer_command(
- conn, session_id, &mut task,
- ) {
- Ok(page) => page,
- Err(plan) => return PageCommandTaskStep::Complete(plan),
- };
+ let renderer_runtime_inspector_session_id = conn
+ .target_renderer_runtime_inspector_session_id_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ );
+ let page =
+ match loaded_page_mut_for_create_isolated_world_renderer_command(conn, &owner, &mut task) {
+ Ok(page) => page,
+ Err(plan) => return PageCommandTaskStep::Complete(plan),
+ };
match page.start_create_isolated_world_runtime_activity_capturing_runtime_inspector_messages(
renderer_runtime_inspector_session_id.as_deref(),
frame_id.as_deref(),
@@ -1386,11 +1398,11 @@ fn start_create_isolated_world_frame_or_world_phase(
fn loaded_page_mut_for_create_isolated_world_renderer_command<'a>(
conn: &'a mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
task: &mut CreateIsolatedWorldCommandTask,
) -> Result<&'a mut moli_core::page::Page, CommandOutputPlan> {
let slot = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(owner.session_id(), owner.session_owner_route())
.map_err(|error| CommandOutputPlan::error(-32000, error))?;
task.pending_renderer_agent_attachment_id = Some(
slot.current_renderer_attachment()
@@ -1403,13 +1415,13 @@ fn loaded_page_mut_for_create_isolated_world_renderer_command<'a>(
fn create_isolated_world_renderer_completion_is_stale(
conn: &CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
task: &CreateIsolatedWorldCommandTask,
) -> bool {
let Some(expected_attachment_id) = task.pending_renderer_agent_attachment_id else {
return false;
};
- conn.runtime_session_owner_slot(session_id)
+ conn.runtime_session_owner_slot_for_route(owner.session_id(), owner.session_owner_route())
.map(|slot| {
slot.current_renderer_attachment()
.map(|attachment| attachment.id())
@@ -1422,11 +1434,11 @@ fn create_isolated_world_renderer_completion_is_stale(
fn restart_create_isolated_world_after_stale_renderer_completion(
conn: &mut CdpConnection,
command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: CommandOwnerScope,
mut task: CreateIsolatedWorldCommandTask,
) -> PageCommandTaskStep {
task.pending_renderer_agent_attachment_id = None;
- start_create_isolated_world_frame_or_world_phase(conn, command_id, session_id, task)
+ start_create_isolated_world_frame_or_world_phase(conn, command_id, owner, task)
}
fn record_document_start_script(
@@ -1537,7 +1549,7 @@ fn target_document_start_script_registry_key_for_owner(
pub(super) async fn complete_pending_create_isolated_world_command(
conn: &mut CdpConnection,
command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
mut completed: CompletedCreateIsolatedWorldCommand,
command_context: &mut CommandDispatchContext,
) -> PageCommandTaskStep {
@@ -1574,17 +1586,16 @@ pub(super) async fn complete_pending_create_isolated_world_command(
start_create_isolated_world_frame_or_world_phase(
conn,
command_id,
- session_id,
+ owner.clone(),
completed.task,
)
}
CreateIsolatedWorldPhase::RuntimeActivity => {
- if create_isolated_world_renderer_completion_is_stale(conn, session_id, &completed.task)
- {
+ if create_isolated_world_renderer_completion_is_stale(conn, owner, &completed.task) {
return restart_create_isolated_world_after_stale_renderer_completion(
conn,
command_id,
- session_id,
+ owner.clone(),
completed.task,
);
}
@@ -1616,7 +1627,10 @@ pub(super) async fn complete_pending_create_isolated_world_command(
};
let completed_world = {
let Some(page) = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(
+ owner.session_id(),
+ owner.session_owner_route(),
+ )
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -1637,13 +1651,8 @@ pub(super) async fn complete_pending_create_isolated_world_command(
}
};
command_context.consume_renderer_command_turn_output(output);
- complete_create_isolated_world_task(
- conn,
- session_id,
- completed.task,
- execution_context_id,
- )
- .await
+ complete_create_isolated_world_task(conn, owner, completed.task, execution_context_id)
+ .await
}
}
}
@@ -1669,7 +1678,7 @@ fn append_page_command_step_output(
async fn complete_create_isolated_world_task(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
task: CreateIsolatedWorldCommandTask,
execution_context_id: i64,
) -> PageCommandTaskStep {
@@ -1685,7 +1694,7 @@ async fn complete_create_isolated_world_task(
Box::pin(
crate::domains::runtime::start_bidi_preload_channel_listeners_for_execution_context_background_events_async(
conn,
- session_id,
+ owner,
execution_context_id,
&mut preload_channel_listener_events,
),
@@ -1700,14 +1709,14 @@ async fn complete_create_isolated_world_task(
pub(super) async fn complete_pending_add_script_to_evaluate_on_new_document_command(
conn: &mut CdpConnection,
_command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
completed: CompletedAddScriptToEvaluateOnNewDocumentCommand,
command_context: &mut CommandDispatchContext,
) -> PageCommandTaskStep {
let mut plan = CommandOutputPlan::default();
match add_script_to_evaluate_on_new_document_direct_async(
conn,
- session_id,
+ owner,
completed.command,
&mut plan,
command_context,
@@ -1727,28 +1736,32 @@ pub(super) async fn complete_pending_add_script_to_evaluate_on_new_document_comm
async fn add_script_to_evaluate_on_new_document_direct_async(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
command: DevToolsAddPreloadScriptCommand,
side_effects: &mut CommandOutputPlan,
command_context: &mut CommandDispatchContext,
) -> Result<String, DevToolsError> {
let script = document_start_script_from_add_preload_command(&command)?;
+ let session_id = owner.session_id();
+ let owner_route = owner.session_owner_route();
let renderer_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
+ conn.target_renderer_runtime_inspector_session_id_for_route(session_id, owner_route);
let script_owner_session = (command.context.protocol == DevToolsProtocol::Cdp).then(|| {
DevToolsSessionKey::from_wire_session_id(renderer_inspector_session_id.as_deref())
});
let target_id = conn
- .target_owner_identity_for_session(session_id)
+ .target_owner_identity_for_route(session_id, owner_route)
.and_then(|(_, target_id)| target_id);
- let Some(recorded) = conn.with_target_owner_state_for_session_mut(session_id, |owner_state| {
- record_document_start_script(
- owner_state,
- target_id.as_deref(),
- script_owner_session.as_ref(),
- &script,
- )
- }) else {
+ let Some(recorded) =
+ conn.with_target_owner_state_for_route_mut(session_id, owner_route, |owner_state| {
+ record_document_start_script(
+ owner_state,
+ target_id.as_deref(),
+ script_owner_session.as_ref(),
+ &script,
+ )
+ })
+ else {
return Err(preload_missing_owner_error(conn));
};
let identifier = recorded.identifier.clone();
@@ -1758,7 +1771,7 @@ async fn add_script_to_evaluate_on_new_document_direct_async(
}
let pending_run_immediately = {
let renderer_runtime_inspector_session_id = renderer_inspector_session_id;
- let slot = match conn.runtime_session_owner_slot_mut(session_id) {
+ let slot = match conn.runtime_session_owner_slot_mut_for_route(session_id, owner_route) {
Ok(slot) => slot,
Err(error) => return Err(devtools_preload_internal_error(error)),
};
@@ -1786,7 +1799,7 @@ async fn add_script_to_evaluate_on_new_document_direct_async(
.map_err(|error| devtools_preload_internal_error(error.to_string()))?;
let (result, output) = {
let slot = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)
.map_err(devtools_preload_internal_error)?;
let page = slot.loaded_page_mut().ok_or_else(|| {
devtools_preload_internal_error("NoDocumentLoaded".to_owned())
@@ -1806,7 +1819,7 @@ async fn add_script_to_evaluate_on_new_document_direct_async(
Box::pin(
crate::domains::runtime::start_bidi_preload_channel_listeners_for_execution_context_background_events_async(
conn,
- session_id,
+ owner,
execution_context_id,
&mut preload_channel_listener_events,
),
diff --git a/moli-protocol/src/domains/page/termination.rs b/moli-protocol/src/domains/page/termination.rs
index 20ab7ef39..8f2cb24ca 100644
--- a/moli-protocol/src/domains/page/termination.rs
+++ b/moli-protocol/src/domains/page/termination.rs
@@ -118,7 +118,22 @@ pub(crate) fn take_pending_fetch_state(
Vec<(String, crate::conn::PendingSubresourceFetchAuthRequest)>,
Vec<(String, crate::conn::PendingSubresourceFetchResponseRequest)>,
) {
- conn.take_pending_fetch_state_for_session_owner(session_id)
+ let owner = CommandOwnerScope::capture(conn, session_id);
+ take_pending_fetch_state_for_owner(conn, &owner)
+}
+
+fn take_pending_fetch_state_for_owner(
+ conn: &mut CdpConnection,
+ owner: &CommandOwnerScope,
+) -> (
+ Vec<PendingFetchNavigation>,
+ Vec<crate::conn::PendingFetchAuthNavigation>,
+ Vec<crate::conn::PausedDocumentTransfer>,
+ Vec<(String, PendingSubresourceFetchRequest)>,
+ Vec<(String, crate::conn::PendingSubresourceFetchAuthRequest)>,
+ Vec<(String, crate::conn::PendingSubresourceFetchResponseRequest)>,
+) {
+ conn.take_pending_fetch_state_for_route(owner.session_id(), owner.session_owner_route())
.unwrap_or_else(|| {
(
Vec::new(),
@@ -147,6 +162,40 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
crate::conn::PendingSubresourceFetchResponseRequest,
)>,
) -> Option<RendererOutputFence> {
+ let owner = CommandOwnerScope::capture(conn, session_id);
+ fail_pending_fetch_state_for_owner_background_events_async(
+ conn,
+ out,
+ &owner,
+ navigation_error_text,
+ subresource_error_text,
+ pending_navigations,
+ pending_auth_navigations,
+ pending_response_navigations,
+ pending_subresource_fetches,
+ pending_subresource_auths,
+ pending_subresource_responses,
+ )
+ .await
+}
+
+async fn fail_pending_fetch_state_for_owner_background_events_async(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ owner: &CommandOwnerScope,
+ navigation_error_text: &str,
+ subresource_error_text: &str,
+ pending_navigations: Vec<PendingFetchNavigation>,
+ pending_auth_navigations: Vec<crate::conn::PendingFetchAuthNavigation>,
+ pending_response_navigations: Vec<crate::conn::PausedDocumentTransfer>,
+ pending_subresource_fetches: Vec<(String, PendingSubresourceFetchRequest)>,
+ pending_subresource_auths: Vec<(String, crate::conn::PendingSubresourceFetchAuthRequest)>,
+ pending_subresource_responses: Vec<(
+ String,
+ crate::conn::PendingSubresourceFetchResponseRequest,
+ )>,
+) -> Option<RendererOutputFence> {
+ let session_id = owner.session_id();
// A protocol navigation waiter may expose an operation-specific failure,
// while Network.loadingFailed must retain the underlying net error. For
// Page.stopLoading Chromium reports ERR_ABORTED/canceled=true even though
@@ -206,8 +255,9 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
continue;
}
match conn
- .fail_pending_subresource_fetch_for_session_owner_async(
+ .fail_pending_subresource_fetch_for_route_async(
session_id,
+ owner.session_owner_route(),
pending.internal_id,
subresource_error_text.to_owned(),
)
@@ -215,10 +265,13 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
{
Ok(predecessor) => {
merge_renderer_output_predecessor(&mut renderer_output_predecessor, predecessor);
- activity::flush_post_subresource_fetch_request_activity_background_events_async(
- conn, out, session_id, &pending,
+ activity::flush_post_subresource_fetch_request_activity_for_owner_background_events_async(
+ conn,
+ out,
+ owner,
+ &pending,
)
- .await
+ .await;
}
Err(message) if message == "NoDocumentLoaded" => {}
Err(_) => {}
@@ -231,8 +284,9 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
continue;
}
match conn
- .fail_pending_subresource_auth_for_session_owner_async(
+ .fail_pending_subresource_auth_for_route_async(
session_id,
+ owner.session_owner_route(),
pending.internal_id,
subresource_error_text.to_owned(),
)
@@ -240,10 +294,10 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
{
Ok(predecessor) => {
merge_renderer_output_predecessor(&mut renderer_output_predecessor, predecessor);
- activity::flush_post_subresource_auth_activity_background_events_async(
- conn, out, session_id, &pending,
+ activity::flush_post_subresource_auth_activity_for_owner_background_events_async(
+ conn, out, owner, &pending,
)
- .await
+ .await;
}
Err(message) if message == "NoDocumentLoaded" => {}
Err(_) => {}
@@ -256,8 +310,9 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
continue;
}
match conn
- .fail_pending_subresource_response_for_session_owner_async(
+ .fail_pending_subresource_response_for_route_async(
session_id,
+ owner.session_owner_route(),
pending.internal_id,
subresource_error_text.to_owned(),
)
@@ -265,10 +320,13 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
{
Ok(predecessor) => {
merge_renderer_output_predecessor(&mut renderer_output_predecessor, predecessor);
- activity::flush_post_subresource_response_activity_background_events_async(
- conn, out, session_id, &pending,
+ activity::flush_post_subresource_response_activity_for_owner_background_events_async(
+ conn,
+ out,
+ owner,
+ &pending,
)
- .await
+ .await;
}
Err(message) if message == "NoDocumentLoaded" => {}
Err(_) => {}
@@ -288,16 +346,17 @@ pub(crate) async fn fail_pending_fetch_state_background_events_async(
fn fail_crashed_subresource_fetches_background_events(
conn: &CdpConnection,
out: &mut Vec<BackgroundProtocolEvent>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
error_text: &str,
pending_subresource_fetches: Vec<(String, PendingSubresourceFetchRequest)>,
pending_subresource_auths: Vec<(String, PendingSubresourceFetchAuthRequest)>,
pending_subresource_responses: Vec<(String, PendingSubresourceFetchResponseRequest)>,
) {
let loader_id = conn
- .current_document_loader_id_for_session_owner(session_id)
+ .current_document_loader_id_for_route(owner.session_id(), owner.session_owner_route())
.unwrap_or_else(|| DEFAULT_LOADER_ID.to_owned());
- let event_session_ids = conn.network_event_session_ids_for_session_owner(session_id);
+ let event_session_ids =
+ conn.network_event_session_ids_for_route(owner.session_id(), owner.session_owner_route());
let timestamp = monotonic_timestamp_seconds();
let mut emit_failure =
@@ -358,21 +417,12 @@ pub(super) fn try_start_stop_loading_command_dispatch(
pub(super) async fn complete_stop_loading_command_dispatch(
conn: &mut CdpConnection,
_command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
) -> PageCommandTaskStep {
let mut out = Vec::new();
- let restore_browser_context_id = conn.browser_context.as_ref().map(|bc| bc.id.clone());
- if let Some(session_id) = session_id
- && !conn
- .activate_browser_context_for_session_async(session_id)
- .await
- {
- return PageCommandTaskStep::Complete(CommandOutputPlan::error_without_session(
- -32001,
- "Unknown sessionId",
- ));
- }
- if let Ok(slot) = conn.runtime_session_owner_slot_mut(session_id)
+ let session_id = owner.session_id();
+ if let Ok(slot) =
+ conn.runtime_session_owner_slot_mut_for_route(session_id, owner.session_owner_route())
&& let Some(page) = slot.loaded_page_mut()
&& let Err(error) = page.stop_document_lifecycle_async().await
{
@@ -385,12 +435,12 @@ pub(super) async fn complete_stop_loading_command_dispatch(
pending_subresource_fetches,
pending_subresource_auths,
pending_subresource_responses,
- ) = take_pending_fetch_state(conn, session_id);
+ ) = take_pending_fetch_state_for_owner(conn, owner);
- let renderer_output_predecessor = fail_pending_fetch_state_background_events_async(
+ let renderer_output_predecessor = fail_pending_fetch_state_for_owner_background_events_async(
conn,
&mut out,
- session_id,
+ owner,
"Navigation stopped",
moli_fetch::NET_ERR_ABORTED_ERROR_TEXT,
pending_navigations,
@@ -401,7 +451,6 @@ pub(super) async fn complete_stop_loading_command_dispatch(
pending_subresource_responses,
)
.await;
- restore_stop_loading_browser_context_async(conn, restore_browser_context_id.as_deref()).await;
let mut plan = CommandOutputPlan::success();
for event in out {
plan.push_background_event(event);
@@ -412,23 +461,6 @@ pub(super) async fn complete_stop_loading_command_dispatch(
PageCommandTaskStep::Complete(plan)
}
-async fn restore_stop_loading_browser_context_async(
- conn: &mut CdpConnection,
- browser_context_id: Option<&str>,
-) {
- if let Some(browser_context_id) = browser_context_id
- && conn.has_browser_context_id(browser_context_id)
- && conn
- .browser_context
- .as_ref()
- .is_none_or(|bc| bc.id != browser_context_id)
- {
- let _ = conn
- .activate_browser_context_by_id_async(browser_context_id)
- .await;
- }
-}
-
pub(super) fn try_start_crash_command_dispatch(
conn: &CdpConnection,
cmd: &Cmd<'_>,
@@ -452,11 +484,14 @@ pub(super) fn try_start_crash_command_dispatch(
pub(super) async fn complete_crash_command_dispatch(
conn: &mut CdpConnection,
_command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
command_context: &mut crate::conn::CommandDispatchContext,
) -> PageCommandTaskStep {
let mut out = Vec::new();
- let Some((_, target_id)) = conn.target_owner_identity_for_session(session_id) else {
+ let session_id = owner.session_id();
+ let Some((_, target_id)) =
+ conn.target_owner_identity_for_route(session_id, owner.session_owner_route())
+ else {
return PageCommandTaskStep::Complete(CommandOutputPlan::error_without_session(
-31998,
super::missing_page_target_error_message(conn, session_id),
@@ -469,8 +504,6 @@ pub(super) async fn complete_crash_command_dispatch(
));
};
- let primary_session_id = conn.runtime_session_owner_primary_session_id(session_id);
- let fail_session_id = session_id.or(primary_session_id.as_deref());
let (
pending_navigations,
pending_auth_navigations,
@@ -478,13 +511,16 @@ pub(super) async fn complete_crash_command_dispatch(
pending_subresource_fetches,
pending_subresource_auths,
pending_subresource_responses,
- ) = take_pending_fetch_state(conn, session_id);
+ ) = take_pending_fetch_state_for_owner(conn, owner);
// Chromium handles Page.crash directly at the renderer IO-agent boundary;
// it never enters a V8InspectorSession or the ordinary target IO task FIFO.
// Seal both DevTools receivers and interrupt active V8 synchronously so
// target retirement cannot wait behind earlier JavaScript or IO work.
- if let Ok(page) = conn.loaded_page_mut_for_interruptible_protocol_access(session_id) {
+ if let Ok(page) = conn.loaded_page_mut_for_interruptible_protocol_access_for_route(
+ session_id,
+ owner.session_owner_route(),
+ ) {
page.crash_devtools_target_from_io();
}
@@ -493,22 +529,30 @@ pub(super) async fn complete_crash_command_dispatch(
// Page; otherwise a late completion from (for example) the primary
// session can wait forever on a response sender owned by the retired
// renderer while the crash was issued by an auxiliary session.
- let target_inspector_session_ids = conn.page_event_session_ids_for_session_owner(session_id);
+ let target_inspector_session_ids =
+ conn.page_event_session_ids_for_route(session_id, owner.session_owner_route());
let mut pending_await_events = Vec::new();
for inspector_session_id in &target_inspector_session_ids {
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- &mut pending_await_events,
- command_context.protocol_events_mut(),
- inspector_session_id.as_deref(),
- "Page crashed",
- );
+ let inspector_owner = inspector_session_id
+ .as_deref()
+ .map(CommandOwnerScope::for_session)
+ .unwrap_or_else(|| owner.clone());
+ let mut route_scope = inspector_owner.enter(conn);
+ route_scope
+ .conn_mut()
+ .fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ &mut pending_await_events,
+ command_context.protocol_events_mut(),
+ inspector_session_id.as_deref(),
+ "Page crashed",
+ );
}
out.extend(pending_await_events);
- let renderer_output_predecessor = fail_pending_fetch_state_background_events_async(
+ let renderer_output_predecessor = fail_pending_fetch_state_for_owner_background_events_async(
conn,
&mut out,
- fail_session_id,
+ owner,
"Page crashed",
"Page crashed",
pending_navigations,
@@ -522,7 +566,7 @@ pub(super) async fn complete_crash_command_dispatch(
fail_crashed_subresource_fetches_background_events(
conn,
&mut out,
- fail_session_id,
+ owner,
"Page crashed",
pending_subresource_fetches,
pending_subresource_auths,
@@ -532,21 +576,25 @@ pub(super) async fn complete_crash_command_dispatch(
command_context.set_renderer_output_predecessor(predecessor);
}
- out.extend(
- mark_page_target_crashed_background_events_async(conn, session_id, &target_id).await,
- );
+ out.extend(mark_page_target_crashed_background_events_async(conn, owner, &target_id).await);
complete_success_with_background_events(out)
}
async fn mark_page_target_crashed_background_events_async(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
target_id: &str,
) -> Vec<BackgroundProtocolEvent> {
- let inspector_session_ids = conn.page_event_session_ids_for_session_owner(session_id);
+ let inspector_session_ids =
+ conn.page_event_session_ids_for_route(owner.session_id(), owner.session_owner_route());
for inspector_session_id in &inspector_session_ids {
- let _ = conn.with_target_devtools_session_state_for_session_mut(
- inspector_session_id.as_deref(),
+ let inspector_owner = inspector_session_id
+ .as_deref()
+ .map(CommandOwnerScope::for_session)
+ .unwrap_or_else(|| owner.clone());
+ let _ = conn.with_target_devtools_session_state_for_route_mut(
+ inspector_owner.session_id(),
+ inspector_owner.session_owner_route(),
|state| {
state
.runtime_session_state
@@ -555,7 +603,7 @@ async fn mark_page_target_crashed_background_events_async(
);
}
let _ = conn
- .mark_target_crashed_for_session_owner_async(session_id)
+ .mark_target_crashed_for_route_async(owner.session_id(), owner.session_owner_route())
.await;
let mut out = inspector_session_ids
.into_iter()
@@ -581,11 +629,14 @@ pub(super) fn try_start_close_command_dispatch(
pub(super) async fn complete_close_command_dispatch(
conn: &mut CdpConnection,
_command_id: Option<u64>,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
command_context: &mut crate::conn::CommandDispatchContext,
) -> PageCommandTaskStep {
let mut out = Vec::new();
- let Some((_, target_id)) = conn.target_owner_identity_for_session(session_id) else {
+ let session_id = owner.session_id();
+ let Some((_, target_id)) =
+ conn.target_owner_identity_for_route(session_id, owner.session_owner_route())
+ else {
return PageCommandTaskStep::Complete(CommandOutputPlan::error_without_session(
-31998,
super::missing_page_target_error_message(conn, session_id),
@@ -598,8 +649,6 @@ pub(super) async fn complete_close_command_dispatch(
));
};
let target_id = target_id.expect("validated Page target identity");
- let primary_session_id = conn.runtime_session_owner_primary_session_id(session_id);
- let fail_session_id = session_id.or(primary_session_id.as_deref());
let (
pending_navigations,
@@ -608,21 +657,26 @@ pub(super) async fn complete_close_command_dispatch(
pending_subresource_fetches,
pending_subresource_auths,
pending_subresource_responses,
- ) = take_pending_fetch_state(conn, session_id);
+ ) = take_pending_fetch_state_for_owner(conn, owner);
let mut pending_await_events = Vec::new();
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- &mut pending_await_events,
- command_context.protocol_events_mut(),
- session_id,
- "Page closed",
- );
+ {
+ let mut route_scope = owner.enter(conn);
+ route_scope
+ .conn_mut()
+ .fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ &mut pending_await_events,
+ command_context.protocol_events_mut(),
+ session_id,
+ "Page closed",
+ );
+ }
out.extend(pending_await_events);
- let renderer_output_predecessor = fail_pending_fetch_state_background_events_async(
+ let renderer_output_predecessor = fail_pending_fetch_state_for_owner_background_events_async(
conn,
&mut out,
- fail_session_id,
+ owner,
"Page closed",
"Page closed",
pending_navigations,
@@ -643,7 +697,7 @@ pub(super) async fn complete_close_command_dispatch(
// fence first admits every renderer record produced above, then the
// scheduler sends the Page.close response and runs this teardown action.
conn.publish_page_target_termination_owner_action(PageTargetTerminationOwnerAction::new(
- CommandOwnerScope::capture(conn, session_id),
+ owner.clone(),
target_id,
PageTargetTerminationKind::PageClose,
));
diff --git a/moli-protocol/src/domains/runtime/activity.rs b/moli-protocol/src/domains/runtime/activity.rs
index f7a069a02..93d90b652 100644
--- a/moli-protocol/src/domains/runtime/activity.rs
+++ b/moli-protocol/src/domains/runtime/activity.rs
@@ -102,6 +102,15 @@ impl RuntimeInspectorMessageAuthority {
}
}
}
+
+ fn command_owner(&self) -> Option<crate::conn::CommandOwnerScope> {
+ match self {
+ Self::CurrentPage(attachment) => Some(
+ crate::conn::CommandOwnerScope::for_page_attachment(attachment),
+ ),
+ Self::AuthorizedRetiredTerminal { .. } => None,
+ }
+ }
}
#[derive(Clone, Debug, PartialEq)]
@@ -194,6 +203,7 @@ impl RuntimeOutputProjectionStep {
if !batch.authority.permits_projection(conn) {
continue;
}
+ let owner = batch.authority.command_owner();
let session_id = batch.authority.session_id().map(str::to_owned);
push_runtime_inspector_messages_for_session(
conn,
@@ -202,10 +212,13 @@ impl RuntimeOutputProjectionStep {
session_id.as_deref(),
);
for execution_context_id in batch.created_execution_context_ids {
+ let Some(owner) = owner.as_ref() else {
+ continue;
+ };
Box::pin(
super::start_bidi_preload_channel_listeners_for_execution_context_background_events_async(
conn,
- session_id.as_deref(),
+ owner,
execution_context_id,
context.command.protocol_events_mut(),
),
diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rs
index 816c30625..821810fba 100644
--- a/moli-protocol/src/domains/runtime/dispatcher.rs
+++ b/moli-protocol/src/domains/runtime/dispatcher.rs
@@ -4141,23 +4141,31 @@ fn bidi_channel_properties_from_local_value(
pub(crate) async fn start_bidi_preload_channel_listeners_for_execution_context_background_events_async(
conn: &mut CdpConnection,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
execution_context_id: i64,
out: &mut Vec<BackgroundProtocolEvent>,
) {
- let handoff_owners = conn.target_owner_bidi_channel_preload_handoffs_for_session(session_id);
+ let session_id = owner.session_id();
+ let handoff_owners = conn.target_owner_bidi_channel_preload_handoffs_for_route(
+ session_id,
+ owner.session_owner_route(),
+ );
if handoff_owners.is_empty() {
return;
}
let target_id = conn
- .target_owner_identity_for_session(session_id)
+ .target_owner_identity_for_route(session_id, owner.session_owner_route())
.and_then(|(_, target_id)| target_id)
.map(DevToolsTargetId::from);
- let route = conn.session_route(session_id).or_else(|| {
- target_id
- .as_ref()
- .and_then(|target_id| conn.target_session_route_for_target_id(target_id.as_str()))
- });
+ let route = owner
+ .session_owner_route()
+ .cloned()
+ .or_else(|| conn.session_route(session_id))
+ .or_else(|| {
+ target_id
+ .as_ref()
+ .and_then(|target_id| conn.target_session_route_for_target_id(target_id.as_str()))
+ });
let Some(route) = route else {
return;
};
@@ -4166,8 +4174,7 @@ pub(crate) async fn start_bidi_preload_channel_listeners_for_execution_context_b
execution_context_id: Some(execution_context_id),
window_context_id: target_id,
};
- let Some(listener_owner) =
- bidi_channel_page_owner_for_runtime_target(conn, &target, session_id)
+ let Some(listener_owner) = bidi_channel_page_owner_for_runtime_target(conn, &target, owner)
else {
return;
};
@@ -4349,12 +4356,15 @@ async fn release_bidi_channel_object_group_for_target_best_effort_async(
}
fn bidi_channel_page_owner_for_runtime_target(
- conn: &mut CdpConnection,
+ conn: &CdpConnection,
target: &DevToolsRuntimeTarget,
- session_id: Option<&str>,
+ owner: &CommandOwnerScope,
) -> Option<BidiChannelPageOwner> {
- let mut route_scope = conn.scoped_none_session_owner_route_override(target.route.clone());
- BidiChannelPageOwner::capture(route_scope.conn_mut(), session_id)
+ let exact_owner = owner
+ .session_id()
+ .map(CommandOwnerScope::for_session)
+ .unwrap_or_else(|| CommandOwnerScope::for_implicit_route(Some(target.route.clone())));
+ BidiChannelPageOwner::capture_for_owner(conn, exact_owner)
}
async fn create_bidi_channel_proxy_and_start_listener_async(
@@ -4370,8 +4380,12 @@ async fn create_bidi_channel_proxy_and_start_listener_async(
let listener_realm_id = realm_id
.cloned()
.ok_or_else(|| "NoSuchBidiChannelRealm".to_owned())?;
- let listener_owner = bidi_channel_page_owner_for_runtime_target(conn, target, None)
- .ok_or_else(|| "NoSuchBidiChannelTarget".to_owned())?;
+ let listener_owner = bidi_channel_page_owner_for_runtime_target(
+ conn,
+ target,
+ &CommandOwnerScope::for_implicit_route(Some(target.route.clone())),
+ )
+ .ok_or_else(|| "NoSuchBidiChannelTarget".to_owned())?;
let channel_object_group = conn.next_bidi_channel_object_group();
let proxy_handle = match create_bidi_channel_proxy_async(
conn,
diff --git a/moli-protocol/src/domains/target.rs b/moli-protocol/src/domains/target.rs
index 6474bd9b5..bbeafe9e8 100644
--- a/moli-protocol/src/domains/target.rs
+++ b/moli-protocol/src/domains/target.rs
@@ -323,7 +323,6 @@ enum PendingTargetCommandKind {
CreateTarget {
response_plan: CommandOutputPlan,
creation_commit: creation::TargetCreationCommit,
- initial_document_route: Option<crate::conn::CdpSessionRoute>,
initial_document: Option<Box<crate::conn::PendingInitialDocumentPageBuild>>,
},
DetachFromTarget {
@@ -364,7 +363,6 @@ enum CompletedTargetCommandKind {
CreateTarget {
response_plan: CommandOutputPlan,
creation_commit: creation::TargetCreationCommit,
- initial_document_route: Option<crate::conn::CdpSessionRoute>,
initial_document: Option<
Result<
Box<crate::conn::CompletedInitialDocumentPageBuild>,
@@ -418,12 +416,10 @@ impl PendingTargetCommandDispatch {
PendingTargetCommandKind::CreateTarget {
response_plan,
creation_commit,
- initial_document_route,
initial_document,
} => CompletedTargetCommandKind::CreateTarget {
response_plan,
creation_commit,
- initial_document_route,
initial_document: match initial_document {
Some(pending) => Some(pending.wait().await.map(Box::new)),
None => None,
@@ -809,7 +805,6 @@ pub(crate) async fn complete_pending_target_command(
CompletedTargetCommandKind::CreateTarget {
response_plan,
creation_commit,
- initial_document_route,
initial_document,
} => {
let activation_events = if let Some(activation) = creation_commit.activation() {
@@ -822,20 +817,11 @@ pub(crate) async fn complete_pending_target_command(
match initial_document {
Some(Ok(completed_initial_document)) => {
let completed_initial_document = *completed_initial_document;
- let result = if let Some(route) = initial_document_route {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- route_scope
- .conn_mut()
- .complete_initial_document_page_build_for_owner_with_creation_diagnostics(
- completed_initial_document,
- )
- .await
- } else {
- conn.complete_initial_document_page_build_for_owner_with_creation_diagnostics(
+ let result = conn
+ .complete_initial_document_page_build_for_owner_with_creation_diagnostics(
completed_initial_document,
)
- .await
- };
+ .await;
match result {
Ok(diagnostics) => {
if let Some(predecessor) = diagnostics.renderer_output_predecessor {
diff --git a/moli-protocol/src/domains/target/auto_attach.rs b/moli-protocol/src/domains/target/auto_attach.rs
index 1bb6967d0..287ae65cd 100644
--- a/moli-protocol/src/domains/target/auto_attach.rs
+++ b/moli-protocol/src/domains/target/auto_attach.rs
@@ -1290,21 +1290,16 @@ async fn ensure_initial_document_for_attached_page_targets_async(
let Some(route) = conn.target_session_route_for_target_id(target_id) else {
continue;
};
- let pending = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- match route_scope
- .conn_mut()
- .start_initial_document_page_ensure_for_session_owner(None)
- {
- Ok(pending) => pending,
- Err(message) => {
- warn_target_protocol_side_effect_failure(
- target_id,
- "start_initial_document_page_ensure",
- &message,
- );
- continue;
- }
+ let owner = crate::conn::CommandOwnerScope::for_implicit_route(Some(route));
+ let pending = match conn.start_initial_document_page_ensure_for_owner(&owner) {
+ Ok(pending) => pending,
+ Err(message) => {
+ warn_target_protocol_side_effect_failure(
+ target_id,
+ "start_initial_document_page_ensure",
+ &message,
+ );
+ continue;
}
};
let Some(pending) = pending else {
diff --git a/moli-protocol/src/domains/target/creation.rs b/moli-protocol/src/domains/target/creation.rs
index 3e10d58fd..0185c3138 100644
--- a/moli-protocol/src/domains/target/creation.rs
+++ b/moli-protocol/src/domains/target/creation.rs
@@ -231,11 +231,9 @@ fn start_devtools_create_target_command_with_result_host(
};
let initial_document_route =
conn.target_session_route_for_target_id(created_target_id.as_str());
- let pending_initial_document = if let Some(route) = initial_document_route.clone() {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- route_scope
- .conn_mut()
- .start_initial_document_page_ensure_for_session_owner(None)
+ let pending_initial_document = if let Some(route) = initial_document_route {
+ let owner = crate::conn::CommandOwnerScope::for_implicit_route(Some(route));
+ conn.start_initial_document_page_ensure_for_owner(&owner)
} else {
Ok(None)
};
@@ -247,7 +245,6 @@ fn start_devtools_create_target_command_with_result_host(
kind: Box::new(PendingTargetCommandKind::CreateTarget {
response_plan: plan,
creation_commit,
- initial_document_route,
initial_document: Some(Box::new(initial_document)),
}),
})
diff --git a/moli-protocol/src/domains/target/popup.rs b/moli-protocol/src/domains/target/popup.rs
index dcb2da0fc..098e053a5 100644
--- a/moli-protocol/src/domains/target/popup.rs
+++ b/moli-protocol/src/domains/target/popup.rs
@@ -1,6 +1,6 @@
use crate::conn::{
- PopupTargetActivationAction, PopupTargetNavigationKind, PopupTargetNavigationOwnerAction,
- PreparedTargetAttach,
+ CommandOwnerScope, PopupTargetActivationAction, PopupTargetNavigationKind,
+ PopupTargetNavigationOwnerAction, PreparedTargetAttach,
};
use super::creation::{
@@ -313,12 +313,9 @@ async fn ensure_popup_initial_document_page_async(
let Some(route) = conn.target_session_route_for_target_id(target_id) else {
return false;
};
+ let owner = CommandOwnerScope::for_implicit_route(Some(route));
{
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- let pending = match route_scope
- .conn_mut()
- .start_initial_document_page_ensure_for_session_owner(None)
- {
+ let pending = match conn.start_initial_document_page_ensure_for_owner(&owner) {
Ok(pending) => pending,
Err(message) => {
tracing::debug!(
@@ -333,9 +330,7 @@ async fn ensure_popup_initial_document_page_async(
let completed = match pending.wait().await {
Ok(completed) => completed,
Err(failed) => {
- let message = route_scope
- .conn_mut()
- .reset_failed_initial_document_page_build_for_owner(failed);
+ let message = conn.reset_failed_initial_document_page_build_for_owner(failed);
tracing::debug!(
target_id,
?message,
@@ -344,8 +339,7 @@ async fn ensure_popup_initial_document_page_async(
return false;
}
};
- if let Err(message) = route_scope
- .conn_mut()
+ if let Err(message) = conn
.complete_initial_document_page_build_for_owner(completed)
.await
{
@@ -408,48 +402,30 @@ pub(super) async fn start_target_url_navigation_if_allowed_background_events_asy
let Some(route) = conn.target_session_route_for_target_id(target_id) else {
return;
};
- let started_target_url_navigation = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- start_initial_document_target_url_navigation_if_needed_background_events_async(
- route_scope.conn_mut(),
- out,
- None,
- )
- .await
+ let Some(browser_context_id) = route.browser_context_id().map(str::to_owned) else {
+ return;
};
- if started_target_url_navigation
- && let Some(browser_context_id) = conn
- .target_session_route_for_target_id(target_id)
- .and_then(|route| route.browser_context_id().map(str::to_owned))
- {
- emit_target_info_changed_for_target_background_event(
- conn,
- out,
- &browser_context_id,
- target_id,
- );
- }
-}
-
-pub(crate) async fn start_initial_document_target_url_navigation_if_needed_background_events_async(
- conn: &mut CdpConnection,
- out: &mut Vec<BackgroundProtocolEvent>,
- session_id: Option<&str>,
-) -> bool {
- if !conn.runtime_session_owner_can_start_initial_document_navigation(session_id) {
- return false;
+ let Some(browser_context) = conn.browser_context_by_id(&browser_context_id) else {
+ return;
+ };
+ if !browser_context.target_needs_initial_document_navigation(target_id) {
+ return;
}
- let Some(target_url) = conn.runtime_session_owner_target_url(session_id) else {
- return false;
+ let Some(target_url) = browser_context
+ .devtools_target_info(target_id)
+ .map(|target_info| target_info.url)
+ else {
+ return;
};
- crate::domains::page::navigate_session_owner_from_renderer_background_events_async(
+ let owner_scope = CommandOwnerScope::for_implicit_route(Some(route));
+ crate::domains::page::navigate_command_owner_from_renderer_background_events_async(
conn,
out,
- session_id,
+ &owner_scope,
&target_url,
)
.await;
- true
+ emit_target_info_changed_for_target_background_event(conn, out, &browser_context_id, target_id);
}
pub(crate) fn schedule_initial_document_target_url_navigation_after_debugger_resume(
@@ -526,14 +502,15 @@ pub(crate) async fn complete_popup_target_navigation_owner_action_async(
action: PopupTargetNavigationOwnerAction,
) -> crate::conn::CdpTurnOutcome {
let (owner_scope, browser_context_id, target_id, url, kind) = action.into_parts();
- let mut route_scope = owner_scope.enter(conn);
- let conn = route_scope.conn_mut();
- let target_is_current = conn.target_owner_identity_for_session(None).is_some_and(
- |(current_browser_context_id, current_target_id)| {
+ let target_is_current = conn
+ .target_owner_identity_for_route(
+ owner_scope.session_id(),
+ owner_scope.session_owner_route(),
+ )
+ .is_some_and(|(current_browser_context_id, current_target_id)| {
current_browser_context_id == browser_context_id
&& current_target_id.as_deref() == Some(target_id.as_str())
- },
- );
+ });
if !target_is_current || !popup_target_has_loaded_page(conn, &browser_context_id, &target_id) {
tracing::debug!(
browser_context_id,
@@ -556,7 +533,13 @@ pub(crate) async fn complete_popup_target_navigation_owner_action_async(
// runs. Another inspector session can attach after this action is
// scheduled; that new session must be able to pause the initial
// document before any target-URL request starts.
- if !conn.runtime_session_owner_can_start_initial_document_navigation(None) {
+ if conn.target_has_waiting_for_debugger_session(&target_id)
+ || !conn
+ .browser_context_by_id(&browser_context_id)
+ .is_some_and(|browser_context| {
+ browser_context.target_needs_initial_document_navigation(&target_id)
+ })
+ {
return crate::conn::CdpTurnOutcome::new_with_protocol_events(
Vec::new(),
conn.take_scheduler_events(),
@@ -565,10 +548,10 @@ pub(crate) async fn complete_popup_target_navigation_owner_action_async(
}
PopupTargetNavigationKind::NamedTargetReuse => {}
}
- crate::domains::page::navigate_session_owner_from_renderer_background_events_async(
+ crate::domains::page::navigate_command_owner_from_renderer_background_events_async(
conn,
&mut protocol_events,
- None,
+ &owner_scope,
&url,
)
.await;