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 target-scoped page policy explicitly

ldm07ee196a86850
diff --git a/moli-protocol/src/conn/browser_context/emulation_owner.rs b/moli-protocol/src/conn/browser_context/emulation_owner.rs
index 057ab7f67..40d69ab04 100644
--- a/moli-protocol/src/conn/browser_context/emulation_owner.rs
+++ b/moli-protocol/src/conn/browser_context/emulation_owner.rs
@@ -127,7 +127,16 @@ impl CdpConnection {
session_id: Option<&str>,
f: impl FnOnce(Option<TargetEmulationSessionStateMut<'_>>),
) -> bool {
- self.with_target_session_owner_mut(session_id, |owner| {
+ self.mutate_emulation_session_state_for_route(session_id, None, f)
+ }
+
+ pub(crate) fn mutate_emulation_session_state_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ f: impl FnOnce(Option<TargetEmulationSessionStateMut<'_>>),
+ ) -> bool {
+ self.with_target_session_owner_mut_for_route(session_id, owner_route, |owner| {
owner.mutate_emulation_session_state(f)
})
.unwrap_or(false)
@@ -153,24 +162,26 @@ impl CdpConnection {
.set_devtools_timezone_override(timezone_override)
}
- pub(crate) fn set_base_locale_override_for_session_owner(
+ pub(crate) fn set_base_locale_override_for_route(
&mut self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
locale_override: Option<String>,
) -> bool {
let fallback_identity = self.base_browser_identity.clone();
- self.target_session_owner_mut(session_id)
+ self.target_session_owner_mut_for_route(session_id, owner_route)
.is_some_and(|mut owner| {
owner.set_base_locale_override(locale_override, &fallback_identity)
})
}
- pub(crate) fn set_base_timezone_override_for_session_owner(
+ pub(crate) fn set_base_timezone_override_for_route(
&mut self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
timezone_override: Option<String>,
) -> bool {
- self.target_session_owner_mut(session_id)
+ self.target_session_owner_mut_for_route(session_id, owner_route)
.is_some_and(|mut owner| owner.set_base_timezone_override(timezone_override))
}
diff --git a/moli-protocol/src/conn/browser_context/network_owner.rs b/moli-protocol/src/conn/browser_context/network_owner.rs
index bd1c70f8b..84c198258 100644
--- a/moli-protocol/src/conn/browser_context/network_owner.rs
+++ b/moli-protocol/src/conn/browser_context/network_owner.rs
@@ -687,39 +687,48 @@ impl CdpConnection {
pub(crate) fn enable_network_listener_for_session_owner(
&mut self,
session_id: Option<&str>,
+ ) -> bool {
+ self.set_network_listener_enabled_for_route(session_id, None, true)
+ }
+
+ fn set_network_listener_enabled_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ enabled: bool,
) -> bool {
if let Some(session_id) = session_id
&& let Some(target) = self.service_worker_target_for_session_mut(Some(session_id))
{
- return target.set_network_enabled(session_id, true);
+ return target.set_network_enabled(session_id, enabled);
}
if let Some(session_id) = session_id
&& let Some(target) = self.dedicated_worker_target_for_session_mut(Some(session_id))
{
- return target.set_network_enabled(session_id, true);
+ return target.set_network_enabled(session_id, enabled);
}
- self.with_target_session_owner_mut(session_id, |owner| owner.enable_listener(session_id))
- .unwrap_or(false)
+ self.with_target_session_owner_mut_for_route(session_id, owner_route, |owner| {
+ if enabled {
+ owner.enable_listener(session_id)
+ } else {
+ owner.disable_listener(session_id)
+ }
+ })
+ .unwrap_or(false)
}
pub fn enable_network_listener_for_target(&mut self, target_id: &str) -> bool {
let Some(route) = self.target_session_route_for_target_id(target_id) else {
return false;
};
- let mut route_scope = self.scoped_none_session_owner_route_override(route);
- route_scope
- .conn_mut()
- .enable_network_listener_for_session_owner(None)
+ self.set_network_listener_enabled_for_route(None, Some(&route), true)
}
pub fn disable_network_listener_for_target(&mut self, target_id: &str) -> bool {
let Some(route) = self.target_session_route_for_target_id(target_id) else {
return false;
};
- let mut route_scope = self.scoped_none_session_owner_route_override(route);
- route_scope
- .conn_mut()
- .disable_network_listener_for_session_owner(None)
+ self.set_network_listener_enabled_for_route(None, Some(&route), false)
}
pub(crate) fn set_global_cache_disabled(&mut self, cache_disabled: bool) {
@@ -750,18 +759,7 @@ impl CdpConnection {
&mut self,
session_id: Option<&str>,
) -> bool {
- if let Some(session_id) = session_id
- && let Some(target) = self.service_worker_target_for_session_mut(Some(session_id))
- {
- return target.set_network_enabled(session_id, false);
- }
- if let Some(session_id) = session_id
- && let Some(target) = self.dedicated_worker_target_for_session_mut(Some(session_id))
- {
- return target.set_network_enabled(session_id, false);
- }
- self.with_target_session_owner_mut(session_id, |owner| owner.disable_listener(session_id))
- .unwrap_or(false)
+ self.set_network_listener_enabled_for_route(session_id, None, false)
}
pub(crate) fn start_set_cache_disabled_for_session_owner(
@@ -826,12 +824,13 @@ impl CdpConnection {
owner.start_set_extra_http_headers(extra_headers)
}
- pub(crate) fn start_set_target_extra_http_headers_for_session_owner(
+ pub(crate) fn start_set_target_extra_http_headers_for_route(
&mut self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
extra_headers: Vec<(String, String)>,
) -> Result<Option<PendingPageCommand>, String> {
- let Some(owner) = self.target_session_owner_mut(session_id) else {
+ let Some(owner) = self.target_session_owner_mut_for_route(session_id, owner_route) else {
return Err("BrowserContextNotLoaded".to_owned());
};
owner.start_set_target_extra_http_headers(extra_headers)
@@ -857,9 +856,10 @@ impl CdpConnection {
owner.start_replay_effective_network_request_policy()
}
- pub(crate) fn start_set_base_user_agent_override_for_session_owner(
+ pub(crate) fn start_set_base_user_agent_override_for_route(
&mut self,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
user_agent: Option<String>,
) -> Result<Option<PendingPageCommand>, String> {
let browser_identity = user_agent.as_ref().map(|user_agent| {
@@ -868,20 +868,22 @@ impl CdpConnection {
self.base_browser_identity.accept_language(),
)
});
- if let Some(result) =
- self.start_set_non_page_browser_identity_override(session_id, browser_identity)
+ if owner_route.is_none()
+ && let Some(result) =
+ self.start_set_non_page_browser_identity_override(session_id, browser_identity)
{
return result;
}
let fallback_identity = self.base_browser_identity.clone();
- let Some(mut owner) = self.target_session_owner_mut(session_id) else {
+ let Some(mut owner) = self.target_session_owner_mut_for_route(session_id, owner_route)
+ else {
return Err("BrowserContextNotLoaded".to_owned());
};
if !owner.set_base_user_agent_override(user_agent, &fallback_identity) {
return Err("BrowserContextNotLoaded".to_owned());
}
- self.start_rebuild_resource_runtime_for_session_owner(session_id)
+ self.start_rebuild_resource_runtime_for_route(session_id, owner_route)
}
fn start_set_non_page_browser_identity_override(
@@ -981,7 +983,28 @@ impl CdpConnection {
upload_throughput: f64,
connection_type: Option<String>,
) -> Result<Option<PendingPageCommand>, String> {
- let Some(owner) = self.target_session_owner_mut(session_id) else {
+ self.start_set_emulated_network_conditions_for_route(
+ session_id,
+ None,
+ offline,
+ latency,
+ download_throughput,
+ upload_throughput,
+ connection_type,
+ )
+ }
+
+ pub(crate) fn start_set_emulated_network_conditions_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ offline: bool,
+ latency: f64,
+ download_throughput: f64,
+ upload_throughput: f64,
+ connection_type: Option<String>,
+ ) -> Result<Option<PendingPageCommand>, String> {
+ let Some(owner) = self.target_session_owner_mut_for_route(session_id, owner_route) else {
return Err("BrowserContextNotLoaded".to_owned());
};
owner.start_set_emulated_network_conditions(
diff --git a/moli-protocol/src/conn/browser_context/page_owner.rs b/moli-protocol/src/conn/browser_context/page_owner.rs
index 0d870d163..2c1153637 100644
--- a/moli-protocol/src/conn/browser_context/page_owner.rs
+++ b/moli-protocol/src/conn/browser_context/page_owner.rs
@@ -778,7 +778,16 @@ impl CdpConnection {
session_id: Option<&str>,
enabled: bool,
) -> bool {
- self.with_target_session_owner_mut(session_id, |owner| {
+ self.set_page_file_chooser_opened_event_enabled_for_route(session_id, None, enabled)
+ }
+
+ fn set_page_file_chooser_opened_event_enabled_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ enabled: bool,
+ ) -> bool {
+ self.with_target_session_owner_mut_for_route(session_id, owner_route, |owner| {
owner.set_page_file_chooser_opened_event_enabled(enabled)
})
.unwrap_or(false)
@@ -804,20 +813,14 @@ impl CdpConnection {
let Some(route) = self.target_session_route_for_target_id(target_id) else {
return false;
};
- let mut route_scope = self.scoped_none_session_owner_route_override(route);
- route_scope
- .conn_mut()
- .set_page_file_chooser_opened_event_enabled_for_session_owner(None, true)
+ self.set_page_file_chooser_opened_event_enabled_for_route(None, Some(&route), true)
}
pub fn disable_file_dialog_opened_listener_for_target(&mut self, target_id: &str) -> bool {
let Some(route) = self.target_session_route_for_target_id(target_id) else {
return false;
};
- let mut route_scope = self.scoped_none_session_owner_route_override(route);
- route_scope
- .conn_mut()
- .set_page_file_chooser_opened_event_enabled_for_session_owner(None, false)
+ self.set_page_file_chooser_opened_event_enabled_for_route(None, Some(&route), false)
}
pub(crate) fn set_page_lifecycle_events_enabled_for_session_owner(
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 446e46fbc..4a989ae03 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -1319,7 +1319,15 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> TargetNavigationLoadInputs {
- let mut inputs = match self.target_session_owner_ref(session_id) {
+ self.navigation_load_inputs_for_route(session_id, None)
+ }
+
+ pub(crate) fn navigation_load_inputs_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> TargetNavigationLoadInputs {
+ let mut inputs = match self.target_session_owner_ref_for_route(session_id, owner_route) {
Some(TargetSessionOwnerRef::NoLoadedBrowserContext) | None => self
.browser_context
.as_ref()
@@ -1733,7 +1741,15 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Option<&DevToolsSessionState> {
- self.target_session_owner_ref(session_id)?
+ self.target_devtools_session_state_for_route(session_id, None)
+ }
+
+ pub(crate) fn target_devtools_session_state_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Option<&DevToolsSessionState> {
+ self.target_session_owner_ref_for_route(session_id, owner_route)?
.devtools_session_state()
}
@@ -1768,7 +1784,15 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Option<String> {
- self.target_session_owner_ref(session_id)
+ self.target_renderer_runtime_inspector_session_id_for_route(session_id, None)
+ }
+
+ pub(crate) fn target_renderer_runtime_inspector_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)
.and_then(|owner| owner.renderer_runtime_inspector_session_id())
}
@@ -1829,7 +1853,16 @@ impl CdpConnection {
session_id: Option<&str>,
f: impl FnOnce(&mut TargetOwnerState) -> R,
) -> Option<R> {
- self.target_session_owner_mut(session_id)?
+ self.with_target_owner_state_for_route_mut(session_id, None, f)
+ }
+
+ pub(crate) fn with_target_owner_state_for_route_mut<R>(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ f: impl FnOnce(&mut TargetOwnerState) -> R,
+ ) -> Option<R> {
+ self.target_session_owner_mut_for_route(session_id, owner_route)?
.mutate_target_owner_state(|owner_state| owner_state.map(f))
}
@@ -2246,9 +2279,17 @@ impl CdpConnection {
pub(crate) fn page_event_session_ids_for_session_owner(
&self,
session_id: Option<&str>,
+ ) -> Vec<Option<String>> {
+ self.page_event_session_ids_for_route(session_id, None)
+ }
+
+ pub(crate) fn page_event_session_ids_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Vec<Option<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![session_id.map(str::to_owned)];
};
@@ -2354,7 +2395,16 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Option<String> {
- self.target_session_owner_ref(session_id)?.target_url()
+ self.runtime_session_owner_target_url_for_route(session_id, None)
+ }
+
+ pub(crate) fn runtime_session_owner_target_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)?
+ .target_url()
}
pub(crate) fn runtime_session_owner_record_initial_empty_document_url(
@@ -2395,7 +2445,15 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
) -> Option<(String, String, String, String)> {
- self.target_session_owner_ref(session_id)?
+ self.target_session_owner_frame_tree_identity_for_route(session_id, None)
+ }
+
+ pub(crate) fn target_session_owner_frame_tree_identity_for_route(
+ &self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ ) -> Option<(String, String, String, String)> {
+ self.target_session_owner_ref_for_route(session_id, owner_route)?
.frame_tree_identity()
}
@@ -2577,6 +2635,16 @@ impl CdpConnection {
) -> Option<R> {
self.target_session_owner_mut(session_id).map(f)
}
+
+ pub(super) fn with_target_session_owner_mut_for_route<R>(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ f: impl FnOnce(TargetSessionOwnerMut<'_>) -> R,
+ ) -> Option<R> {
+ self.target_session_owner_mut_for_route(session_id, owner_route)
+ .map(f)
+ }
}
#[cfg(test)]
diff --git a/moli-protocol/src/conn/resource_runtime_support.rs b/moli-protocol/src/conn/resource_runtime_support.rs
index 2799ef642..e07c3147d 100644
--- a/moli-protocol/src/conn/resource_runtime_support.rs
+++ b/moli-protocol/src/conn/resource_runtime_support.rs
@@ -227,7 +227,15 @@ impl CdpConnection {
&mut self,
session_id: Option<&str>,
) -> Result<Option<PendingPageCommand>, String> {
- let load_inputs = self.navigation_load_inputs_for_session_owner(session_id);
+ self.start_rebuild_resource_runtime_for_route(session_id, None)
+ }
+
+ pub(crate) fn start_rebuild_resource_runtime_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&super::CdpSessionRoute>,
+ ) -> Result<Option<PendingPageCommand>, String> {
+ let load_inputs = self.navigation_load_inputs_for_route(session_id, owner_route);
let navigator_identity = load_inputs
.navigator_identity_override
.clone()
@@ -241,7 +249,7 @@ impl CdpConnection {
storage.into_navigation_storage(),
)
.map_err(|error| format!("failed to rebuild resource runtime: {error}"))?;
- let Some(page) = self.resource_runtime_apply_page_for_session_owner(session_id) else {
+ let Some(page) = self.resource_runtime_apply_page_for_route(session_id, owner_route) else {
return Ok(None);
};
page.start_replace_browser_resource_runtime_with_navigator_identity(
diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rs
index 94c9f61f3..0ab482900 100644
--- a/moli-protocol/src/conn/runtime_eval.rs
+++ b/moli-protocol/src/conn/runtime_eval.rs
@@ -1991,6 +1991,20 @@ impl CdpConnection {
self.register_runtime_remote_object_ids_for_session_owner(session_id, object_ids);
}
+ pub(crate) fn register_runtime_remote_object_ids_from_value_for_route(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ value: &Value,
+ ) {
+ let object_ids = runtime_remote_object_ids_in_value(value);
+ let _ = self.with_target_devtools_session_state_for_route_mut(
+ session_id,
+ owner_route,
+ |state| state.register_runtime_remote_object_ids(object_ids),
+ );
+ }
+
pub(crate) fn register_runtime_remote_object_ids_from_value_for_session_owner_with_group(
&mut self,
session_id: Option<&str>,
@@ -2005,6 +2019,21 @@ impl CdpConnection {
);
}
+ pub(crate) fn register_runtime_remote_object_ids_from_value_for_route_with_group(
+ &mut self,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+ value: &Value,
+ object_group: &str,
+ ) {
+ let object_ids = runtime_remote_object_ids_in_value(value);
+ let _ = self.with_target_devtools_session_state_for_route_mut(
+ session_id,
+ owner_route,
+ |state| state.register_runtime_remote_object_ids_with_group(object_ids, object_group),
+ );
+ }
+
pub(crate) fn runtime_remote_object_group_for_session_owner(
&self,
session_id: Option<&str>,
diff --git a/moli-protocol/src/conn/target/activation.rs b/moli-protocol/src/conn/target/activation.rs
index 5dd93d1b4..84e48ad4b 100644
--- a/moli-protocol/src/conn/target/activation.rs
+++ b/moli-protocol/src/conn/target/activation.rs
@@ -146,12 +146,10 @@ impl CdpConnection {
let Some(route) = self.target_session_route_for_target_id(target_id) else {
return Vec::new();
};
- let mut route_scope = self.scoped_none_session_owner_route_override(route);
- let conn = route_scope.conn_mut();
- conn.page_event_session_ids_for_session_owner(None)
+ self.page_event_session_ids_for_route(None, Some(&route))
.into_iter()
.filter(|session_id| {
- conn.target_page_session_state_for_session(session_id.as_deref())
+ self.target_page_session_state_for_route(session_id.as_deref(), Some(&route))
.is_some_and(|state| state.page_screencast.is_active())
})
.collect()
diff --git a/moli-protocol/src/domains/dom.rs b/moli-protocol/src/domains/dom.rs
index 0f4854259..8142e9a2d 100644
--- a/moli-protocol/src/domains/dom.rs
+++ b/moli-protocol/src/domains/dom.rs
@@ -176,7 +176,15 @@ pub(crate) fn dom_agent_includes_whitespace_for_session(
conn: &CdpConnection,
session_id: Option<&str>,
) -> bool {
- conn.target_devtools_session_state_for_session(session_id)
+ dom_agent_includes_whitespace_for_route(conn, session_id, None)
+}
+
+pub(crate) fn dom_agent_includes_whitespace_for_route(
+ conn: &CdpConnection,
+ session_id: Option<&str>,
+ owner_route: Option<&crate::conn::CdpSessionRoute>,
+) -> bool {
+ conn.target_devtools_session_state_for_route(session_id, owner_route)
.is_some_and(|state| {
state.dom_session_state.enabled && state.dom_session_state.include_whitespace
})
diff --git a/moli-protocol/src/domains/dom/child_frame.rs b/moli-protocol/src/domains/dom/child_frame.rs
index 59e62bf30..7cb0c0c69 100644
--- a/moli-protocol/src/domains/dom/child_frame.rs
+++ b/moli-protocol/src/domains/dom/child_frame.rs
@@ -1,8 +1,7 @@
use serde_json::json;
use super::{
- dom_agent_includes_whitespace_for_session, frontend_binding, loaded_page_mut_for_session,
- node_snapshot_to_cdp,
+ dom_agent_includes_whitespace_for_route, frontend_binding, node_snapshot_to_cdp,
resolve::{
PendingDomCommandStartError, attributes_result_from_renderer_resolution,
devtools_dom_geometry_result_from_renderer, property_result_from_renderer_resolution,
@@ -10,7 +9,7 @@ use super::{
text_result_from_renderer_resolution,
},
};
-use crate::conn::CdpConnection;
+use crate::conn::{CdpConnection, CdpSessionRoute};
use crate::devtools_runtime::{
DevToolsCommand, DevToolsCommandResult, DevToolsDescribeNodeCommand,
DevToolsDescribeNodeResult, DevToolsDomGeometryCommand, DevToolsDomGeometryResult,
@@ -24,6 +23,15 @@ use moli_core::page::{
RendererDocumentNodeReference,
};
+fn loaded_page_mut_for_route<'a>(
+ conn: &'a mut CdpConnection,
+ session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
+) -> Option<&'a mut Page> {
+ conn.loaded_page_mut_for_protocol_access_for_route(session_id, Some(owner_route))
+ .ok()
+}
+
pub(super) async fn execute_devtools_dom_command(
conn: &mut CdpConnection,
frame_id: &str,
@@ -99,41 +107,35 @@ async fn query_selector_command(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- query_selector_command_in_session(
- route_scope.conn_mut(),
- None,
- frame_id,
- root,
- selector,
- multiple,
- )
- .await
+ query_selector_command_in_session(conn, None, &route, frame_id, root, selector, multiple).await
}
async fn query_selector_command_in_session(
conn: &mut CdpConnection,
session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
frame_id: &str,
root: Option<DevToolsDomNodeReference>,
selector: &str,
multiple: bool,
) -> Result<DevToolsQuerySelectorResult, PendingDomCommandStartError> {
let renderer_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let include_whitespace = dom_agent_includes_whitespace_for_session(conn, session_id);
+ conn.target_renderer_runtime_inspector_session_id_for_route(session_id, Some(owner_route));
+ let include_whitespace =
+ dom_agent_includes_whitespace_for_route(conn, session_id, Some(owner_route));
let root_backend_node_id = match root {
Some(reference) => {
- let reference = resolve_frontend_node_reference(conn, session_id, reference).await?;
+ let reference =
+ resolve_frontend_node_reference(conn, session_id, owner_route, reference).await?;
required_child_frame_backend_node_id(&reference)?
}
None => {
- child_frame_document_root_node_reference(conn, session_id, frame_id)
+ child_frame_document_root_node_reference(conn, session_id, owner_route, frame_id)
.await?
.backend_node_id
}
};
- let page = loaded_page_mut_for_session(conn, session_id)
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
.start_child_frame_document_query_selector_for_backend_node_id(
@@ -158,14 +160,15 @@ async fn query_selector_command_in_session(
async fn resolve_frontend_node_reference(
conn: &mut CdpConnection,
session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
reference: DevToolsDomNodeReference,
) -> Result<DevToolsDomNodeReference, PendingDomCommandStartError> {
let DevToolsDomNodeReference::FrontendNodeId(frontend_node_id) = reference else {
return Ok(reference);
};
let renderer_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let page = loaded_page_mut_for_session(conn, session_id)
+ conn.target_renderer_runtime_inspector_session_id_for_route(session_id, Some(owner_route));
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
.start_document_frontend_node_binding(renderer_inspector_session_id, frontend_node_id)
@@ -174,7 +177,7 @@ async fn resolve_frontend_node_reference(
.wait()
.await
.map_err(PendingDomCommandStartError::renderer_error)?;
- let page = loaded_page_mut_for_session(conn, session_id)
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
frontend_binding::finish_reference(page, completion).map_err(|message| {
PendingDomCommandStartError {
@@ -187,11 +190,12 @@ async fn resolve_frontend_node_reference(
async fn child_frame_document_root_node_reference(
conn: &mut CdpConnection,
session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
frame_id: &str,
) -> Result<RendererDocumentNodeReference, PendingDomCommandStartError> {
let renderer_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let page = loaded_page_mut_for_session(conn, session_id)
+ conn.target_renderer_runtime_inspector_session_id_for_route(session_id, Some(owner_route));
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
.start_child_frame_document_root_node_reference(frame_id, renderer_inspector_session_id)
@@ -200,7 +204,7 @@ async fn child_frame_document_root_node_reference(
.wait()
.await
.map_err(PendingDomCommandStartError::renderer_error)?;
- let page = loaded_page_mut_for_session(conn, session_id)
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
page.finish_document_node_reference(completion)
.map_err(PendingDomCommandStartError::renderer_error)?
@@ -215,10 +219,8 @@ async fn attributes_command(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- let conn = route_scope.conn_mut();
- let reference = resolve_frontend_node_reference(conn, None, reference).await?;
- let page = loaded_page_mut_for_session(conn, None)
+ let reference = resolve_frontend_node_reference(conn, None, &route, reference).await?;
+ let page = loaded_page_mut_for_route(conn, None, &route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = start_document_node_attributes_for_reference(page, reference)?;
let completion = pending
@@ -247,10 +249,8 @@ async fn text_command(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- let conn = route_scope.conn_mut();
- let reference = resolve_frontend_node_reference(conn, None, reference).await?;
- let page = loaded_page_mut_for_session(conn, None)
+ let reference = resolve_frontend_node_reference(conn, None, &route, reference).await?;
+ let page = loaded_page_mut_for_route(conn, None, &route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = start_document_node_text_for_reference(page, reference)?;
let completion = pending
@@ -280,10 +280,8 @@ async fn property_command(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- let conn = route_scope.conn_mut();
- let reference = resolve_frontend_node_reference(conn, None, reference).await?;
- let page = loaded_page_mut_for_session(conn, None)
+ let reference = resolve_frontend_node_reference(conn, None, &route, reference).await?;
+ let page = loaded_page_mut_for_route(conn, None, &route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = start_document_node_property_for_reference(page, reference, name)?;
let completion = pending
@@ -315,10 +313,10 @@ async fn outer_html_command(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
outer_html_command_in_session(
- route_scope.conn_mut(),
+ conn,
session_id,
+ &route,
frame_id,
reference,
include_shadow_dom,
@@ -329,25 +327,26 @@ async fn outer_html_command(
async fn outer_html_command_in_session(
conn: &mut CdpConnection,
session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
frame_id: &str,
reference: Option<DevToolsDomNodeReference>,
include_shadow_dom: bool,
) -> Result<String, PendingDomCommandStartError> {
let reference = match reference {
Some(reference) => {
- Some(resolve_frontend_node_reference(conn, session_id, reference).await?)
+ Some(resolve_frontend_node_reference(conn, session_id, owner_route, reference).await?)
}
None => None,
};
let backend_node_id = match reference {
Some(reference) => required_child_frame_backend_node_id(&reference)?,
None => {
- child_frame_document_root_node_reference(conn, session_id, frame_id)
+ child_frame_document_root_node_reference(conn, session_id, owner_route, frame_id)
.await?
.backend_node_id
}
};
- let page = loaded_page_mut_for_session(conn, session_id)
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
.start_outer_html_for_backend_node_id(backend_node_id, include_shadow_dom)
@@ -369,21 +368,22 @@ async fn resolve_node_command(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- resolve_node_command_in_session(route_scope.conn_mut(), None, command).await
+ resolve_node_command_in_session(conn, None, &route, command).await
}
async fn resolve_node_command_in_session(
conn: &mut CdpConnection,
session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
command: DevToolsResolveNodeCommand,
) -> Result<DevToolsResolveNodeResult, PendingDomCommandStartError> {
- let reference = resolve_frontend_node_reference(conn, session_id, command.reference).await?;
+ let reference =
+ resolve_frontend_node_reference(conn, session_id, owner_route, command.reference).await?;
let object_group = command.object_group;
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, Some(owner_route));
let remote_object = {
- let page = loaded_page_mut_for_session(conn, session_id)
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let backend_node_id = required_child_frame_backend_node_id(&reference)?;
let pending = page
@@ -422,13 +422,18 @@ async fn resolve_node_command_in_session(
}
let result = json!({ "object": remote_object.clone() });
if let Some(object_group) = object_group.as_deref() {
- conn.register_runtime_remote_object_ids_from_value_for_session_owner_with_group(
+ conn.register_runtime_remote_object_ids_from_value_for_route_with_group(
session_id,
+ Some(owner_route),
&result,
object_group,
);
} else {
- conn.register_runtime_remote_object_ids_from_value_for_session_owner(session_id, &result);
+ conn.register_runtime_remote_object_ids_from_value_for_route(
+ session_id,
+ Some(owner_route),
+ &result,
+ );
}
Ok(DevToolsResolveNodeResult {
object: remote_object,
@@ -473,29 +478,24 @@ async fn node_snapshot_for_reference(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- node_snapshot_for_reference_in_session(
- route_scope.conn_mut(),
- session_id,
- reference,
- depth,
- pierce,
- )
- .await
+ node_snapshot_for_reference_in_session(conn, session_id, &route, reference, depth, pierce).await
}
async fn node_snapshot_for_reference_in_session(
conn: &mut CdpConnection,
session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
reference: DevToolsDomNodeReference,
depth: i32,
pierce: bool,
) -> Result<moli_core::page::DocumentNodeSnapshot, PendingDomCommandStartError> {
- let reference = resolve_frontend_node_reference(conn, session_id, reference).await?;
+ let reference =
+ resolve_frontend_node_reference(conn, session_id, owner_route, reference).await?;
let renderer_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let include_whitespace = dom_agent_includes_whitespace_for_session(conn, session_id);
- let page = loaded_page_mut_for_session(conn, session_id)
+ conn.target_renderer_runtime_inspector_session_id_for_route(session_id, Some(owner_route));
+ let include_whitespace =
+ dom_agent_includes_whitespace_for_route(conn, session_id, Some(owner_route));
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let backend_node_id = required_child_frame_backend_node_id(&reference)?;
let pending = page
@@ -527,15 +527,15 @@ async fn child_frame_root_node_snapshot(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- let conn = route_scope.conn_mut();
- let backend_node_id = child_frame_document_root_node_reference(conn, session_id, frame_id)
- .await?
- .backend_node_id;
+ let backend_node_id =
+ child_frame_document_root_node_reference(conn, session_id, &route, frame_id)
+ .await?
+ .backend_node_id;
let renderer_inspector_session_id =
- conn.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let include_whitespace = dom_agent_includes_whitespace_for_session(conn, session_id);
- let page = loaded_page_mut_for_session(conn, session_id)
+ conn.target_renderer_runtime_inspector_session_id_for_route(session_id, Some(&route));
+ let include_whitespace =
+ dom_agent_includes_whitespace_for_route(conn, session_id, Some(&route));
+ let page = loaded_page_mut_for_route(conn, session_id, &route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
.start_document_node_snapshot_for_backend_node_id_in_inspector_session(
@@ -600,17 +600,18 @@ async fn document_geometry_for_reference(
let route = conn
.target_session_route_for_child_frame_id(frame_id)
.ok_or_else(PendingDomCommandStartError::no_such_target)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- document_geometry_for_reference_in_session(route_scope.conn_mut(), None, reference).await
+ document_geometry_for_reference_in_session(conn, None, &route, reference).await
}
async fn document_geometry_for_reference_in_session(
conn: &mut CdpConnection,
session_id: Option<&str>,
+ owner_route: &CdpSessionRoute,
reference: DevToolsDomNodeReference,
) -> Result<RendererDocumentNodeGeometry, PendingDomCommandStartError> {
- let reference = resolve_frontend_node_reference(conn, session_id, reference).await?;
- let page = loaded_page_mut_for_session(conn, session_id)
+ let reference =
+ resolve_frontend_node_reference(conn, session_id, owner_route, reference).await?;
+ let page = loaded_page_mut_for_route(conn, session_id, owner_route)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let backend_node_id = required_child_frame_backend_node_id(&reference)?;
let pending = page
diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rs
index 52cc69432..c81bb3d6c 100644
--- a/moli-protocol/src/domains/emulation.rs
+++ b/moli-protocol/src/domains/emulation.rs
@@ -857,7 +857,7 @@ fn start_device_metrics_override_command(
screen_width: Some(screen_width),
screen_height: Some(screen_height),
};
- match start_devtools_set_viewport_command(conn, cmd.id, command) {
+ match start_devtools_set_viewport_command(conn, cmd.id, command, None) {
Ok(Some(pending)) => EmulationCommandTaskStep::Pending(pending),
Ok(None) => EmulationCommandTaskStep::Complete(CommandOutputPlan::success()),
Err(error) => {
@@ -937,18 +937,21 @@ fn start_devtools_set_viewport_command(
conn: &mut CdpConnection,
command_id: Option<u64>,
command: DevToolsSetViewportCommand,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<Option<PendingEmulationCommandDispatch>, DevToolsError> {
let session_id = command.context.session_id.as_ref().map(|id| id.as_str());
if conn.browser_context.is_none()
- && conn.target_owner_identity_for_session(session_id).is_none()
+ && conn
+ .target_owner_identity_for_route(session_id, owner_route)
+ .is_none()
{
return Ok(None);
}
- let metrics = set_viewport_metrics_from_command(conn, session_id, &command)?;
+ let metrics = set_viewport_metrics_from_command(conn, session_id, owner_route, &command)?;
let had_existing_device_metrics = conn
- .target_session_owner_emulated_device_metrics(session_id)
+ .target_session_owner_emulated_device_metrics_for_route(session_id, owner_route)
.is_some();
- if !conn.mutate_emulation_session_state_for_session_owner(session_id, |state| {
+ if !conn.mutate_emulation_session_state_for_route(session_id, owner_route, |state| {
if let Some(state) = state {
*state.emulated_device_metrics = Some(metrics.clone());
}
@@ -958,9 +961,13 @@ fn start_devtools_set_viewport_command(
"BrowserContextNotLoaded",
));
}
- let owner_scope = CommandOwnerScope::capture(conn, session_id);
+ let owner_scope =
+ CommandOwnerScope::from_session_and_owner_route(session_id, owner_route.cloned());
let runtime_call_id = conn.next_internal_runtime_command_id();
- let Some(page) = loaded_page_mut_for_target_configuration(conn, session_id) else {
+ let Some(page) = conn
+ .loaded_page_mut_for_target_configuration_for_route(session_id, owner_route)
+ .ok()
+ else {
return Ok(None);
};
let session_id = session_id.map(str::to_owned);
@@ -998,9 +1005,11 @@ fn start_devtools_set_viewport_command(
fn set_viewport_metrics_from_command(
conn: &CdpConnection,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
command: &DevToolsSetViewportCommand,
) -> Result<EmulatedDeviceMetrics, DevToolsError> {
- let current_metrics = conn.target_session_owner_emulated_device_metrics(session_id);
+ let current_metrics =
+ conn.target_session_owner_emulated_device_metrics_for_route(session_id, owner_route);
set_viewport_metrics_from_current(current_metrics.as_ref(), command)
}
@@ -1132,14 +1141,7 @@ async fn execute_devtools_set_extra_headers_for_targets(
target_id,
"ChildFrameContextNotSupportedForSetExtraHeaders",
)?;
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_extra_headers_for_current_route(
- route_scope.conn_mut(),
- &route,
- command.headers.clone(),
- )
- };
+ let result = start_extra_headers_for_current_route(conn, &route, command.headers.clone());
pending.extend(result?);
}
complete_emulation_page_updates(conn, devtools_command_session_id(&command.context), pending)
@@ -1201,16 +1203,13 @@ async fn execute_devtools_set_geolocation_override_for_targets(
target_id,
"ChildFrameContextNotSupportedForGeolocationOverride",
)?;
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_geolocation_override_for_current_route(
- route_scope.conn_mut(),
- &route,
- command
- .override_state
- .map(emulated_geolocation_override_state),
- )
- };
+ let result = start_geolocation_override_for_current_route(
+ conn,
+ &route,
+ command
+ .override_state
+ .map(emulated_geolocation_override_state),
+ );
pending.extend(result?);
}
complete_emulation_page_updates(conn, devtools_command_session_id(&command.context), pending)
@@ -1247,10 +1246,7 @@ async fn execute_geolocation_surface_updates_for_routes(
let mut pending = Vec::new();
for route in routes {
let target = pending_emulation_target_for_route(conn, &route)?;
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- start_surface_override_for_route(route_scope.conn_mut(), target)
- };
+ let result = start_surface_override_for_route(conn, target, &route);
pending.extend(
result.map_err(|error| DevToolsError::new(DevToolsErrorKind::Internal, error))?,
);
@@ -1263,7 +1259,7 @@ fn start_geolocation_override_for_current_route(
route: &CdpSessionRoute,
override_state: Option<EmulatedGeolocationOverrideState>,
) -> Result<Vec<PendingEmulationPageCommand>, DevToolsError> {
- if !conn.mutate_emulation_session_state_for_session_owner(None, |state| {
+ if !conn.mutate_emulation_session_state_for_route(None, Some(route), |state| {
if let Some(state) = state {
*state.geolocation_override = override_state;
}
@@ -1273,7 +1269,7 @@ fn start_geolocation_override_for_current_route(
));
}
let target = pending_emulation_target_for_route(conn, route)?;
- start_surface_override_for_route(conn, target)
+ start_surface_override_for_route(conn, target, route)
.map_err(|error| DevToolsError::new(DevToolsErrorKind::Internal, error))
}
@@ -1302,14 +1298,8 @@ async fn execute_devtools_set_network_conditions_for_targets(
target_id,
"ChildFrameContextNotSupportedForNetworkConditions",
)?;
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_network_conditions_for_current_route(
- route_scope.conn_mut(),
- &route,
- command.network_conditions,
- )
- };
+ let result =
+ start_network_conditions_for_current_route(conn, &route, command.network_conditions);
pending.extend(result?);
}
complete_emulation_page_updates(conn, devtools_command_session_id(&command.context), pending)
@@ -1344,10 +1334,7 @@ async fn execute_network_conditions_updates_for_routes(
) -> Result<DevToolsCommandResult, DevToolsError> {
let mut pending = Vec::new();
for route in routes {
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_network_conditions_update_for_current_route(route_scope.conn_mut(), &route)
- };
+ let result = start_network_conditions_update_for_current_route(conn, &route);
pending.extend(result?);
}
complete_emulation_page_updates(conn, session_id, pending).await
@@ -1358,7 +1345,7 @@ fn start_network_conditions_for_current_route(
route: &CdpSessionRoute,
network_conditions: Option<DevToolsNetworkConditions>,
) -> Result<Vec<PendingEmulationPageCommand>, DevToolsError> {
- if !conn.mutate_emulation_session_state_for_session_owner(None, |state| {
+ if !conn.mutate_emulation_session_state_for_route(None, Some(route), |state| {
if let Some(state) = state {
*state.network_conditions = network_conditions.map(emulated_network_conditions);
}
@@ -1391,8 +1378,9 @@ fn start_network_conditions_update_for_current_route(
PendingEmulationPageTarget::SessionOwner { .. } => false,
};
let network_update = conn
- .start_set_emulated_network_conditions_for_session_owner(
+ .start_set_emulated_network_conditions_for_route(
None,
+ Some(route),
effective_offline,
0.0,
-1.0,
@@ -1410,7 +1398,7 @@ fn start_network_conditions_update_for_current_route(
});
}
pending.extend(
- start_surface_override_for_route(conn, target)
+ start_surface_override_for_route(conn, target, route)
.map_err(|error| DevToolsError::new(DevToolsErrorKind::Internal, error))?,
);
Ok(pending)
@@ -1423,7 +1411,7 @@ fn start_extra_headers_for_current_route(
) -> Result<Vec<PendingEmulationPageCommand>, DevToolsError> {
let target = pending_emulation_target_for_route(conn, route)?;
let pending = conn
- .start_set_target_extra_http_headers_for_session_owner(None, headers)
+ .start_set_target_extra_http_headers_for_route(None, Some(route), headers)
.map_err(devtools_emulation_owner_error)?;
Ok(pending
.map(|pending| {
@@ -1581,14 +1569,8 @@ async fn execute_devtools_set_user_agent_override_for_targets(
target_id,
"ChildFrameContextNotSupportedForUserAgentOverride",
)?;
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_user_agent_override_for_current_route(
- route_scope.conn_mut(),
- &route,
- command.user_agent.clone(),
- )
- };
+ let result =
+ start_user_agent_override_for_current_route(conn, &route, command.user_agent.clone());
if let Some(pending_command) = result? {
pending.push(pending_command);
}
@@ -1638,10 +1620,7 @@ async fn execute_user_agent_loader_updates_for_routes(
) -> Result<DevToolsCommandResult, DevToolsError> {
let mut pending = Vec::new();
for route in routes {
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_user_agent_loader_update_for_current_route(route_scope.conn_mut(), &route)
- };
+ let result = start_user_agent_loader_update_for_current_route(conn, &route);
if let Some(pending_command) = result? {
pending.push(pending_command);
}
@@ -1676,7 +1655,7 @@ fn start_user_agent_override_for_current_route(
) -> Result<Option<PendingEmulationPageCommand>, DevToolsError> {
let target = pending_emulation_target_for_route(conn, route)?;
let pending = conn
- .start_set_base_user_agent_override_for_session_owner(None, user_agent)
+ .start_set_base_user_agent_override_for_route(None, Some(route), user_agent)
.map_err(devtools_emulation_owner_error)?;
if let Some(pending) = pending {
return Ok(Some(PendingEmulationPageCommand {
@@ -1694,11 +1673,14 @@ fn start_user_agent_loader_update_for_current_route(
route: &CdpSessionRoute,
) -> Result<Option<PendingEmulationPageCommand>, DevToolsError> {
let target = pending_emulation_target_for_route(conn, route)?;
- let load_inputs = conn.navigation_load_inputs_for_session_owner(None);
+ let load_inputs = conn.navigation_load_inputs_for_route(None, Some(route));
let resource_runtime = conn
.build_registered_browser_resource_runtime_for_navigation_load_inputs(&load_inputs)
.map_err(|error| DevToolsError::new(DevToolsErrorKind::Internal, error))?;
- let Some(page) = loaded_page_mut_for_target_configuration(conn, None) else {
+ let Some(page) = conn
+ .loaded_page_mut_for_target_configuration_for_route(None, Some(route))
+ .ok()
+ else {
return Ok(None);
};
let pending = page
@@ -1739,14 +1721,7 @@ async fn execute_devtools_set_locale_override_for_targets(
target_id,
"ChildFrameContextNotSupportedForLocaleOverride",
)?;
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_locale_override_for_current_route(
- route_scope.conn_mut(),
- &route,
- command.locale.clone(),
- )
- };
+ let result = start_locale_override_for_current_route(conn, &route, command.locale.clone());
pending.extend(result?);
}
complete_emulation_page_updates(conn, devtools_command_session_id(&command.context), pending)
@@ -1777,10 +1752,7 @@ async fn execute_locale_updates_for_routes(
) -> Result<DevToolsCommandResult, DevToolsError> {
let mut pending = Vec::new();
for route in routes {
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_locale_update_for_current_route(route_scope.conn_mut(), &route)
- };
+ let result = start_locale_update_for_current_route(conn, &route);
pending.extend(result?);
}
complete_emulation_page_updates(conn, session_id, pending).await
@@ -1791,7 +1763,7 @@ fn start_locale_override_for_current_route(
route: &CdpSessionRoute,
locale: Option<String>,
) -> Result<Vec<PendingEmulationPageCommand>, DevToolsError> {
- if !conn.set_base_locale_override_for_session_owner(None, locale) {
+ if !conn.set_base_locale_override_for_route(None, Some(route), locale) {
return Err(devtools_emulation_owner_error(
"BrowserContextNotLoaded".to_owned(),
));
@@ -1808,10 +1780,13 @@ fn start_locale_update_for_current_route(
pending.push(identity_update);
}
let target = pending_emulation_target_for_route(conn, route)?;
- let Some(locale_override) = locale_override_for_session(conn, None) else {
+ let Some(locale_override) = locale_override_for_route(conn, None, Some(route)) else {
return Ok(pending);
};
- let Some(page) = loaded_page_mut_for_target_configuration(conn, None) else {
+ let Some(page) = conn
+ .loaded_page_mut_for_target_configuration_for_route(None, Some(route))
+ .ok()
+ else {
return Ok(pending);
};
pending.extend(
@@ -1848,14 +1823,8 @@ async fn execute_devtools_set_timezone_override_for_targets(
target_id,
"ChildFrameContextNotSupportedForTimezoneOverride",
)?;
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_timezone_override_for_current_route(
- route_scope.conn_mut(),
- &route,
- command.timezone.clone(),
- )
- };
+ let result =
+ start_timezone_override_for_current_route(conn, &route, command.timezone.clone());
if let Some(pending_command) = result? {
pending.push(pending_command);
}
@@ -1887,10 +1856,7 @@ async fn execute_timezone_updates_for_routes(
) -> Result<DevToolsCommandResult, DevToolsError> {
let mut pending = Vec::new();
for route in routes {
- let result = {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route.clone());
- start_timezone_update_for_current_route(route_scope.conn_mut(), &route)
- };
+ let result = start_timezone_update_for_current_route(conn, &route);
if let Some(pending_command) = result? {
pending.push(pending_command);
}
@@ -1903,7 +1869,7 @@ fn start_timezone_override_for_current_route(
route: &CdpSessionRoute,
timezone: Option<String>,
) -> Result<Option<PendingEmulationPageCommand>, DevToolsError> {
- if !conn.set_base_timezone_override_for_session_owner(None, timezone) {
+ if !conn.set_base_timezone_override_for_route(None, Some(route), timezone) {
return Err(devtools_emulation_owner_error(
"BrowserContextNotLoaded".to_owned(),
));
@@ -1916,8 +1882,11 @@ fn start_timezone_update_for_current_route(
route: &CdpSessionRoute,
) -> Result<Option<PendingEmulationPageCommand>, DevToolsError> {
let target = pending_emulation_target_for_route(conn, route)?;
- let load_inputs = conn.navigation_load_inputs_for_session_owner(None);
- let Some(page) = loaded_page_mut_for_target_configuration(conn, None) else {
+ let load_inputs = conn.navigation_load_inputs_for_route(None, Some(route));
+ let Some(page) = conn
+ .loaded_page_mut_for_target_configuration_for_route(None, Some(route))
+ .ok()
+ else {
return Ok(None);
};
let pending = page
@@ -2068,19 +2037,18 @@ async fn execute_devtools_set_viewport_command_async(
"NoSuchTarget",
));
};
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
let mut command = command;
command.context.session_id = None;
- return match start_devtools_set_viewport_command(route_scope.conn_mut(), None, command) {
+ return match start_devtools_set_viewport_command(conn, None, command, Some(&route)) {
Ok(Some(pending)) => {
let completed = pending.wait().await;
- complete_pending_devtools_emulation_command(route_scope.conn_mut(), completed)
+ complete_pending_devtools_emulation_command(conn, completed)
}
Ok(None) => Ok(DevToolsCommandResult::Empty),
Err(error) => Err(error),
};
}
- match start_devtools_set_viewport_command(conn, None, command) {
+ match start_devtools_set_viewport_command(conn, None, command, None) {
Ok(Some(pending)) => {
let completed = pending.wait().await;
complete_pending_devtools_emulation_command(conn, completed)
@@ -2100,26 +2068,23 @@ async fn execute_devtools_set_window_state_command_async(
target_id,
"ChildFrameContextNotSupportedForSetWindowState",
)?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
let mut command = command;
command.context.session_id = None;
- return execute_devtools_set_window_state_for_current_route(
- route_scope.conn_mut(),
- command,
- )
- .await;
+ return execute_devtools_set_window_state_for_current_route(conn, command, Some(&route))
+ .await;
}
- execute_devtools_set_window_state_for_current_route(conn, command).await
+ execute_devtools_set_window_state_for_current_route(conn, command, None).await
}
async fn execute_devtools_set_window_state_for_current_route(
conn: &mut CdpConnection,
command: crate::devtools_runtime::DevToolsSetWindowStateCommand,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<DevToolsCommandResult, DevToolsError> {
let session_id = command.context.session_id.as_ref().map(|id| id.as_str());
let state = target_window_surface_state_from_devtools(command.state);
if conn
- .with_target_owner_state_for_session_mut(session_id, |owner_state| {
+ .with_target_owner_state_for_route_mut(session_id, owner_route, |owner_state| {
owner_state.set_window_surface_state(state);
})
.is_none()
@@ -2129,8 +2094,9 @@ async fn execute_devtools_set_window_state_for_current_route(
"BrowserContextNotLoaded",
));
}
- let pending = start_session_surface_override_page_command(conn, session_id)
- .map_err(devtools_emulation_owner_error)?;
+ let pending =
+ start_session_surface_override_page_command_for_route(conn, session_id, owner_route)
+ .map_err(devtools_emulation_owner_error)?;
complete_emulation_page_updates(conn, devtools_command_session_id(&command.context), pending)
.await
}
@@ -2142,9 +2108,6 @@ async fn execute_devtools_set_client_window_state_command_async(
let route = conn
.target_session_route_for_target_id(command.client_window.as_str())
.ok_or_else(|| DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "NoSuchTarget"))?;
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- let conn = route_scope.conn_mut();
-
let mut window_state_context = command.context.clone();
window_state_context.session_id = None;
window_state_context.target_id = Some(command.client_window.clone());
@@ -2154,12 +2117,13 @@ async fn execute_devtools_set_client_window_state_command_async(
context: window_state_context,
state: command.state,
},
+ Some(&route),
)
.await;
match result {
Ok(_) => {
- let _ = conn.with_target_owner_state_for_session_mut(None, |owner_state| {
+ let _ = conn.with_target_owner_state_for_route_mut(None, Some(&route), |owner_state| {
owner_state.set_window_surface_geometry(
command.width,
command.height,
@@ -2797,10 +2761,18 @@ fn start_geolocation_surface_override_page_commands(
fn start_session_surface_override_page_command(
conn: &mut CdpConnection,
session_id: Option<&str>,
+) -> Result<Vec<PendingEmulationPageCommand>, String> {
+ start_session_surface_override_page_command_for_route(conn, session_id, None)
+}
+
+fn start_session_surface_override_page_command_for_route(
+ conn: &mut CdpConnection,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<Vec<PendingEmulationPageCommand>, String> {
let script = {
let Some((browser_context_id, target_id)) =
- conn.target_owner_identity_for_session(session_id)
+ conn.target_owner_identity_for_route(session_id, owner_route)
else {
return Err("BrowserContextNotLoaded".to_owned());
};
@@ -2818,9 +2790,13 @@ fn start_session_surface_override_page_command(
let Some(script) = script else {
return Ok(Vec::new());
};
- let owner_scope = CommandOwnerScope::capture(conn, session_id);
+ let owner_scope =
+ CommandOwnerScope::from_session_and_owner_route(session_id, owner_route.cloned());
let runtime_call_id = conn.next_internal_runtime_command_id();
- let Some(page) = loaded_page_mut_for_target_configuration(conn, session_id) else {
+ let Some(page) = conn
+ .loaded_page_mut_for_target_configuration_for_route(session_id, owner_route)
+ .ok()
+ else {
return Ok(Vec::new());
};
start_surface_override_page_command(
@@ -2835,6 +2811,7 @@ fn start_session_surface_override_page_command(
fn start_surface_override_for_route(
conn: &mut CdpConnection,
target: PendingEmulationPageTarget,
+ route: &CdpSessionRoute,
) -> Result<Vec<PendingEmulationPageCommand>, String> {
let script = match &target {
PendingEmulationPageTarget::BrowserContextTarget {
@@ -2851,14 +2828,21 @@ fn start_surface_override_for_route(
}
}
PendingEmulationPageTarget::SessionOwner { owner_scope } => {
- return start_session_surface_override_page_command(conn, owner_scope.session_id());
+ return start_session_surface_override_page_command_for_route(
+ conn,
+ owner_scope.session_id(),
+ owner_scope.session_owner_route(),
+ );
}
};
let Some(script) = script else {
return Ok(Vec::new());
};
let runtime_call_id = conn.next_internal_runtime_command_id();
- let Some(page) = loaded_page_mut_for_target_configuration(conn, None) else {
+ let Some(page) = conn
+ .loaded_page_mut_for_target_configuration_for_route(None, Some(route))
+ .ok()
+ else {
return Ok(Vec::new());
};
start_surface_override_page_command(target, page, script, runtime_call_id)
@@ -2901,7 +2885,16 @@ fn locale_override_for_session(
conn: &CdpConnection,
session_id: Option<&str>,
) -> Option<Option<String>> {
- let (browser_context_id, target_id) = conn.target_owner_identity_for_session(session_id)?;
+ locale_override_for_route(conn, session_id, None)
+}
+
+fn locale_override_for_route(
+ conn: &CdpConnection,
+ session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
+) -> Option<Option<String>> {
+ let (browser_context_id, target_id) =
+ conn.target_owner_identity_for_route(session_id, owner_route)?;
let browser_context = conn.browser_context_by_id(&browser_context_id)?;
if let Some(target_id) = target_id
&& browser_context.background_target(&target_id).is_some()
diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rs
index affdbbbba..c97ab405a 100644
--- a/moli-protocol/src/domains/page.rs
+++ b/moli-protocol/src/domains/page.rs
@@ -2133,7 +2133,7 @@ fn complete_devtools_handle_javascript_dialog_command(
conn: &mut CdpConnection,
command: DevToolsHandleJavaScriptDialogCommand,
) -> CommandOutputPlan {
- match finish_devtools_handle_javascript_dialog_command(conn, command) {
+ match finish_devtools_handle_javascript_dialog_command(conn, command, None) {
Ok(closed_event) => {
let mut plan = CommandOutputPlan::default();
plan.push_background_event(closed_event);
@@ -2147,11 +2147,12 @@ fn complete_devtools_handle_javascript_dialog_command(
fn finish_devtools_get_javascript_dialog_command(
conn: &CdpConnection,
command: DevToolsGetJavaScriptDialogCommand,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<DevToolsJavaScriptDialogResult, DevToolsError> {
let session_id = command.context.session_id.as_ref().map(|id| id.as_str());
- let current_page_owner = conn.target_page_residence_identity_for_session(session_id);
+ let current_page_owner = conn.target_page_residence_identity_for_route(session_id, owner_route);
let Some(dialog) = conn
- .target_page_session_state_for_session(session_id)
+ .target_page_session_state_for_route(session_id, owner_route)
.and_then(|page_state| page_state.javascript_dialog_state.peek_next())
.filter(|dialog| current_page_owner.as_ref() == Some(dialog.page_owner()))
else {
@@ -2170,11 +2171,12 @@ fn finish_devtools_get_javascript_dialog_command(
fn finish_devtools_set_javascript_dialog_prompt_text_command(
conn: &mut CdpConnection,
command: DevToolsSetJavaScriptDialogPromptTextCommand,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<DevToolsCommandResult, DevToolsError> {
let session_id = command.context.session_id.as_ref().map(|id| id.as_str());
- let current_page_owner = conn.target_page_residence_identity_for_session(session_id);
+ let current_page_owner = conn.target_page_residence_identity_for_route(session_id, owner_route);
let Some(result) =
- conn.with_target_devtools_session_state_for_session_mut(session_id, |state| {
+ conn.with_target_devtools_session_state_for_route_mut(session_id, owner_route, |state| {
let dialog_state = &mut state.page_session_state.javascript_dialog_state;
let Some(dialog) = dialog_state
.peek_next()
@@ -2211,12 +2213,13 @@ fn finish_devtools_set_javascript_dialog_prompt_text_command(
fn finish_devtools_handle_javascript_dialog_command(
conn: &mut CdpConnection,
command: DevToolsHandleJavaScriptDialogCommand,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<BackgroundProtocolEvent, DevToolsError> {
let session_id = command.context.session_id.as_ref().map(|id| id.as_str());
let command_prompt_text = command.prompt_text;
- let current_page_owner = conn.target_page_residence_identity_for_session(session_id);
+ let current_page_owner = conn.target_page_residence_identity_for_route(session_id, owner_route);
let Some(dialog) = conn
- .with_target_devtools_session_state_for_session_mut(session_id, |state| {
+ .with_target_devtools_session_state_for_route_mut(session_id, owner_route, |state| {
let dialog_state = &mut state.page_session_state.javascript_dialog_state;
if dialog_state
.peek_next()
@@ -5845,23 +5848,24 @@ async fn execute_devtools_get_layout_metrics_command(
if route.is_some() {
command.context.session_id = None;
}
- let result = if let Some(route) = route {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- execute_devtools_get_layout_metrics_for_current_owner(route_scope.conn_mut(), command).await
- } else {
- execute_devtools_get_layout_metrics_for_current_owner(conn, command).await
- };
+ let result =
+ execute_devtools_get_layout_metrics_for_current_owner(conn, command, route.as_ref()).await;
result.map(DevToolsCommandResult::LayoutMetrics)
}
async fn execute_devtools_get_layout_metrics_for_current_owner(
conn: &mut CdpConnection,
command: DevToolsGetLayoutMetricsCommand,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<DevToolsLayoutMetricsResult, DevToolsError> {
let session_id = command.context.session_id.as_ref().map(|id| id.as_str());
- let fallback = layout_metrics_result_from_surface(current_viewport_surface(conn, session_id));
+ let fallback = layout_metrics_result_from_surface(current_viewport_surface_for_route(
+ conn,
+ session_id,
+ owner_route,
+ ));
let Some(page) = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -5874,7 +5878,7 @@ async fn execute_devtools_get_layout_metrics_for_current_owner(
devtools_layout_metrics_error(format!("Failed to produce layout metrics: {error}"))
})?;
let Some(page) = conn
- .runtime_session_owner_slot_mut(session_id)
+ .runtime_session_owner_slot_mut_for_route(session_id, owner_route)
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -6227,30 +6231,27 @@ async fn execute_devtools_get_frame_tree_command_for_current_owner_async(
command: DevToolsGetFrameTreeCommand,
route: Option<CdpSessionRoute>,
) -> Result<Value, DevToolsError> {
- if let Some(route) = route {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- devtools_frame_tree_for_current_owner_async(route_scope.conn_mut(), command).await
- } else {
- devtools_frame_tree_for_current_owner_async(conn, command).await
- }
+ devtools_frame_tree_for_current_owner_async(conn, command, route.as_ref()).await
}
async fn devtools_frame_tree_for_current_owner_async(
conn: &mut CdpConnection,
command: DevToolsGetFrameTreeCommand,
+ owner_route: Option<&CdpSessionRoute>,
) -> Result<Value, DevToolsError> {
let command_session_id = command.context.session_id.as_ref().map(|id| id.as_str());
if command_session_id.is_none() && conn.browser_context.is_none() {
return Err(devtools_frame_tree_error("BrowserContextNotLoaded"));
}
let (target_id, target_url, target_security_origin, target_secure_context_type) = conn
- .target_session_owner_frame_tree_identity(command_session_id)
+ .target_session_owner_frame_tree_identity_for_route(command_session_id, owner_route)
.ok_or_else(|| devtools_frame_tree_error("TargetNotLoaded"))?;
let target_unreachable_url =
- network_error_page_unreachable_url(conn, command_session_id, &target_url);
- let target_loader_id = frame_tree_loader_id_for_current_owner(conn, command_session_id);
+ network_error_page_unreachable_url(conn, command_session_id, owner_route, &target_url);
+ let target_loader_id =
+ frame_tree_loader_id_for_current_owner(conn, command_session_id, owner_route);
if conn
- .ensure_document_accessible_for_session_owner(command_session_id)
+ .ensure_document_accessible_for_route(command_session_id, owner_route)
.is_err()
{
return Ok(frame_tree_payload(
@@ -6265,7 +6266,7 @@ async fn devtools_frame_tree_for_current_owner_async(
));
}
let Some(page) = conn
- .runtime_session_owner_slot_mut(command_session_id)
+ .runtime_session_owner_slot_mut_for_route(command_session_id, owner_route)
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -6288,7 +6289,7 @@ async fn devtools_frame_tree_for_current_owner_async(
devtools_frame_tree_error(format!("Failed to snapshot child frame tree: {error}"))
})?;
if conn
- .ensure_document_accessible_for_session_owner(command_session_id)
+ .ensure_document_accessible_for_route(command_session_id, owner_route)
.is_err()
{
return Ok(frame_tree_payload(
@@ -6303,7 +6304,7 @@ async fn devtools_frame_tree_for_current_owner_async(
));
}
let Some(page) = conn
- .runtime_session_owner_slot_mut(command_session_id)
+ .runtime_session_owner_slot_mut_for_route(command_session_id, owner_route)
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
@@ -6342,10 +6343,11 @@ fn default_document_mime_type() -> String {
fn network_error_page_unreachable_url(
conn: &CdpConnection,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
document_url: &str,
) -> Option<String> {
(document_url == NETWORK_ERROR_PAGE_URL)
- .then(|| conn.runtime_session_owner_target_url(session_id))
+ .then(|| conn.runtime_session_owner_target_url_for_route(session_id, owner_route))
.flatten()
}
@@ -6367,8 +6369,9 @@ fn devtools_frame_tree_error(message: impl Into<String>) -> DevToolsError {
fn frame_tree_loader_id_for_current_owner(
conn: &CdpConnection,
session_id: Option<&str>,
+ owner_route: Option<&CdpSessionRoute>,
) -> String {
- conn.target_session_owner_frame_tree_loader_id(session_id)
+ conn.target_session_owner_frame_tree_loader_id_for_route(session_id, owner_route)
.unwrap_or_default()
}
@@ -6401,12 +6404,7 @@ fn execute_devtools_get_javascript_dialog_command(
if route.is_some() {
command.context.session_id = None;
}
- let result = if let Some(route) = route {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- finish_devtools_get_javascript_dialog_command(route_scope.conn_mut(), command)
- } else {
- finish_devtools_get_javascript_dialog_command(conn, command)
- };
+ let result = finish_devtools_get_javascript_dialog_command(conn, command, route.as_ref());
result.map(DevToolsCommandResult::JavaScriptDialog)
}
@@ -6423,12 +6421,7 @@ fn execute_devtools_set_javascript_dialog_prompt_text_command(
if route.is_some() {
command.context.session_id = None;
}
- if let Some(route) = route {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- finish_devtools_set_javascript_dialog_prompt_text_command(route_scope.conn_mut(), command)
- } else {
- finish_devtools_set_javascript_dialog_prompt_text_command(conn, command)
- }
+ finish_devtools_set_javascript_dialog_prompt_text_command(conn, command, route.as_ref())
}
fn execute_devtools_handle_javascript_dialog_command(
@@ -6450,12 +6443,7 @@ fn execute_devtools_handle_javascript_dialog_command(
if route.is_some() {
command.context.session_id = None;
}
- let result = if let Some(route) = route {
- let mut route_scope = conn.scoped_none_session_owner_route_override(route);
- finish_devtools_handle_javascript_dialog_command(route_scope.conn_mut(), command)
- } else {
- finish_devtools_handle_javascript_dialog_command(conn, command)
- };
+ let result = finish_devtools_handle_javascript_dialog_command(conn, command, route.as_ref());
match result {
Ok(event) => (Ok(DevToolsCommandResult::Empty), vec![event]),
Err(error) => (Err(error), Vec::new()),
@@ -6679,7 +6667,7 @@ fn start_devtools_page_command(
start_devtools_get_layout_metrics_command(conn, command_id, command)
}
DevToolsCommand::GetJavaScriptDialog(command) => PageCommandTaskStep::Complete(
- match finish_devtools_get_javascript_dialog_command(conn, command) {
+ match finish_devtools_get_javascript_dialog_command(conn, command, None) {
Ok(result) => CommandOutputPlan::from_devtools_result(
DevToolsCommandResult::JavaScriptDialog(result),
),
@@ -6687,7 +6675,7 @@ fn start_devtools_page_command(
},
),
DevToolsCommand::SetJavaScriptDialogPromptText(command) => PageCommandTaskStep::Complete(
- match finish_devtools_set_javascript_dialog_prompt_text_command(conn, command) {
+ match finish_devtools_set_javascript_dialog_prompt_text_command(conn, command, None) {
Ok(result) => CommandOutputPlan::from_devtools_result(result),
Err(error) => CommandOutputPlan::from_devtools_error(error),
},
@@ -6895,8 +6883,8 @@ fn start_devtools_get_frame_tree_command(
}
};
let target_unreachable_url =
- network_error_page_unreachable_url(conn, command_session_id, &target_url);
- let target_loader_id = frame_tree_loader_id_for_current_owner(conn, command_session_id);
+ network_error_page_unreachable_url(conn, command_session_id, None, &target_url);
+ let target_loader_id = frame_tree_loader_id_for_current_owner(conn, command_session_id, None);
if conn
.ensure_document_accessible_for_session_owner(command_session_id)
.is_err()