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): organize target lifecycle by ownership

ldm0d396802e7b5f
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index bd04ca427..917d8dce2 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -72,7 +72,6 @@ pub(crate) use bidi_channel_work::{
BidiChannelPageOwner,
};
pub(crate) use body_spool::{CapturedBody, CapturedBodyWriter};
-pub(crate) use browser_context::{CdpSessionRoute, TargetHandlerAccessMode};
pub(crate) use browser_context::{
PageLifecycleEventsEnableResult, SessionOwnerInspectorEnableResult,
SessionOwnerRuntimeFrontendEnableResult, TargetEmulationSessionStateMut,
@@ -118,6 +117,7 @@ pub use moli_protocol_cdp::{
CdpRendererCommandAccess, CdpRendererCommandPolicy, CdpRendererCommandReplacement,
CdpRendererCommandReplayDispatch, CdpRequest, ParsedCdpCommand,
};
+pub(crate) use target::{CdpSessionRoute, TargetActivationTransition, TargetHandlerAccessMode};
#[derive(Clone, Debug)]
pub enum CdpTargetHostLifecycleDelta {
@@ -127,25 +127,6 @@ pub enum CdpTargetHostLifecycleDelta {
Destroyed { target_id: String },
}
-/// Successful target selection and the Page events caused by its surface move.
-///
-/// The events stay attached to the completion so every activation entry point
-/// must preserve their position relative to its own response or owner action.
-#[derive(Debug)]
-pub(crate) struct CompletedTargetActivation {
- protocol_events: Vec<BackgroundProtocolEvent>,
-}
-
-impl CompletedTargetActivation {
- fn new(protocol_events: Vec<BackgroundProtocolEvent>) -> Self {
- Self { protocol_events }
- }
-
- pub(crate) fn into_protocol_events(self) -> Vec<BackgroundProtocolEvent> {
- self.protocol_events
- }
-}
-
#[derive(Clone)]
pub struct CdpTargetHostLifecycleObserver {
callback: Arc<dyn Fn(CdpTargetHostLifecycleDelta) + Send + Sync>,
@@ -599,8 +580,7 @@ pub(crate) use state::{
};
pub(crate) use target::{
PreparedTargetAttach, PreparedTargetHostClosure, PreparedTargetHostDelta,
- TargetAttachRollbackPlan, TargetAttachSessionCommit, TargetAutoAttachedSessionDetachPlan,
- TargetBindingCleanupAction, TargetBindingCleanupPlan, TargetClosureCleanupPlan,
+ TargetAttachSessionCommit, TargetBindingCleanupAction, TargetClosureCleanupPlan,
TargetSessionDetachCleanupPlan,
};
use target::{
@@ -2613,141 +2593,6 @@ impl CdpConnection {
.expect("page owner must retain its exact BrowserContext engine");
}
- pub(crate) fn handoff_navigation_engine_for_target_activation(&mut self, target_id: &str) {
- let Some(browser_context) = self.browser_context.as_ref() else {
- return;
- };
- let browser_context_id = browser_context.id.clone();
- let renderer_runtime = browser_context.renderer_runtime_owner_access();
- let navigation_runtime_config = self.engine.runtime_config();
- let promoted_key = (browser_context_id.clone(), target_id.to_owned());
- let promoted_engine = self
- .retained_background_navigation_engines
- .remove(&promoted_key);
-
- let active_target_id = browser_context.active_target_id().map(str::to_owned);
- let active_has_loaded_page = browser_context.has_loaded_page();
- if let Some(active_target_id) = active_target_id
- && active_has_loaded_page
- {
- let next_engine = promoted_engine.unwrap_or_else(|| {
- NavigationEngine::new_with_runtime_config_and_browser_context_access(
- navigation_runtime_config,
- renderer_runtime.clone(),
- )
- .expect("active BrowserContext owner must be live")
- });
- self.apply_scheduler_senders_to_navigation_engine(&next_engine);
- let active_engine = self.engine.replace(next_engine);
- self.retain_background_navigation_engine(
- browser_context_id,
- active_target_id,
- active_engine,
- )
- .expect("demoted active engine must retain its exact BrowserContext owner");
- } else if let Some(promoted_engine) = promoted_engine {
- self.replace_navigation_engine(promoted_engine);
- }
- }
-
- pub(crate) fn handoff_navigation_engine_for_active_target_demotion(&mut self) {
- let Some(browser_context) = self.browser_context.as_ref() else {
- return;
- };
- let Some(active_target_id) = browser_context.active_target_id().map(str::to_owned) else {
- return;
- };
- if !browser_context.has_loaded_page() {
- return;
- }
-
- let browser_context_id = browser_context.id.clone();
- let renderer_runtime = browser_context.renderer_runtime_owner_access();
- let next_engine = NavigationEngine::new_with_runtime_config_and_browser_context_access(
- self.engine.runtime_config(),
- renderer_runtime,
- )
- .expect("active BrowserContext owner must be live");
- self.apply_scheduler_senders_to_navigation_engine(&next_engine);
- let active_engine = self.engine.replace(next_engine);
- self.retain_background_navigation_engine(
- browser_context_id,
- active_target_id,
- active_engine,
- )
- .expect("demoted active engine must retain its exact BrowserContext owner");
- }
-
- pub(crate) async fn promote_background_target_to_active_for_connection_async(
- &mut self,
- target_id: &str,
- ) -> Result<Option<CompletedTargetActivation>, String> {
- let previous_active_target_id = self
- .browser_context
- .as_ref()
- .and_then(BrowserContext::active_target_id_owned);
- let hidden_screencast_sessions = previous_active_target_id
- .as_deref()
- .filter(|active_target_id| *active_target_id != target_id)
- .map(|active_target_id| self.page_screencast_session_ids_for_target(active_target_id))
- .unwrap_or_default();
- self.handoff_navigation_engine_for_target_activation(target_id);
- let Some(browser_context) = self.browser_context.as_mut() else {
- return Err("BrowserContextNotLoaded".to_owned());
- };
- let promoted = browser_context
- .promote_background_target_to_active_slot_async(target_id)
- .await?;
- if !promoted {
- return Ok(None);
- }
- self.refresh_active_browser_context_loader_async().await;
- self.notify_target_host_activated(target_id);
-
- let target_changed = previous_active_target_id.as_deref() != Some(target_id);
- let mut protocol_events = Vec::new();
- if target_changed {
- // Chromium's PageHandler reports RenderWidgetHost visibility only
- // while that attachment has an active screencast. Hide the old
- // surface before exposing the promoted one.
- protocol_events.extend(hidden_screencast_sessions.into_iter().map(|session_id| {
- BackgroundProtocolEvent::page_screencast_visibility_changed(
- session_id.as_deref(),
- false,
- )
- }));
- protocol_events.extend(
- self.page_screencast_session_ids_for_target(target_id)
- .into_iter()
- .map(|session_id| {
- BackgroundProtocolEvent::page_screencast_visibility_changed(
- session_id.as_deref(),
- true,
- )
- }),
- );
- }
- Ok(Some(CompletedTargetActivation::new(protocol_events)))
- }
-
- pub(crate) fn page_screencast_session_ids_for_target(
- &mut self,
- target_id: &str,
- ) -> Vec<Option<String>> {
- 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)
- .into_iter()
- .filter(|session_id| {
- conn.target_page_session_state_for_session(session_id.as_deref())
- .is_some_and(|state| state.page_screencast.is_active())
- })
- .collect()
- }
-
pub(crate) fn enqueue_deferred_main_document_load_completion(
&mut self,
admission: crate::domains::activity::DeferredMainDocumentLoadCompletionAdmission,
diff --git a/moli-protocol/src/conn/browser_context/mod.rs b/moli-protocol/src/conn/browser_context/mod.rs
index 1ae7a6c7b..ab16516f7 100644
--- a/moli-protocol/src/conn/browser_context/mod.rs
+++ b/moli-protocol/src/conn/browser_context/mod.rs
@@ -1,4 +1,4 @@
-use crate::conn::{BrowserContext, CdpConnection, ParkedPageSessionState, TargetPageSessionState};
+use crate::conn::{BrowserContext, CdpConnection, CdpSessionRoute, TargetPageSessionState};
use crate::domains::audits::SessionOwnerAuditsEnableResult;
use crate::domains::log::{SessionOwnerLogControlResult, SessionOwnerLogEnableResult};
use serde_json::Value;
@@ -18,5 +18,4 @@ pub(crate) use page_owner::PageLifecycleEventsEnableResult;
pub(crate) use runtime_owner::{
SessionOwnerInspectorEnableResult, SessionOwnerRuntimeFrontendEnableResult,
};
-pub(crate) use session_owner::{CdpSessionRoute, TargetHandlerAccessMode};
pub(crate) use target_session_owner::TargetNavigationLoadInputs;
diff --git a/moli-protocol/src/conn/browser_context/network_owner.rs b/moli-protocol/src/conn/browser_context/network_owner.rs
index e283c7a8c..480b4d9d7 100644
--- a/moli-protocol/src/conn/browser_context/network_owner.rs
+++ b/moli-protocol/src/conn/browser_context/network_owner.rs
@@ -1,6 +1,6 @@
-use super::session_owner::CdpSessionRoute;
use super::target_session_owner::{TargetSessionOwnerMut, TargetSessionStateMut};
use super::*;
+use crate::conn::CdpSessionRoute;
use crate::conn::{CapturedBody, TargetRuntimeSlot};
use crate::devtools_runtime::DevToolsNetworkDataType;
use crate::domains::network::{
@@ -1064,7 +1064,7 @@ fn clear_parked_network_observation_artifacts_if_unobserved(
#[cfg(test)]
mod tests {
use super::*;
- use crate::conn::BackgroundTarget;
+ use crate::conn::{BackgroundTarget, ParkedPageSessionState};
fn active_session_state_mut(browser_context: &mut BrowserContext) -> TargetSessionStateMut<'_> {
TargetSessionStateMut::Active {
diff --git a/moli-protocol/src/conn/browser_context/page_owner.rs b/moli-protocol/src/conn/browser_context/page_owner.rs
index 63dc7c603..abb9fd1b6 100644
--- a/moli-protocol/src/conn/browser_context/page_owner.rs
+++ b/moli-protocol/src/conn/browser_context/page_owner.rs
@@ -1006,6 +1006,7 @@ fn runtime_observable_console_payloads(
#[cfg(test)]
mod tests {
use super::*;
+ use crate::conn::ParkedPageSessionState;
fn active_session_state_mut(browser_context: &mut BrowserContext) -> TargetSessionStateMut<'_> {
TargetSessionStateMut::Active {
diff --git a/moli-protocol/src/conn/browser_context/session_owner.rs b/moli-protocol/src/conn/browser_context/session_owner.rs
index b16c24c9e..fc9c3d34d 100644
--- a/moli-protocol/src/conn/browser_context/session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/session_owner.rs
@@ -1,1844 +1,19 @@
-use super::*;
-use crate::conn::{ServiceWorkerTargetState, SharedWorkerTargetState};
-use crate::devtools_runtime::DevToolsTargetInfo;
+use crate::conn::{BrowserContext, CdpConnection, CdpSessionRoute, ParkedPageSessionState};
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) enum TargetHandlerAccessMode {
- Browser,
- Regular,
- AutoAttachOnly,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum CdpSessionRoute {
- Browser,
- TabTarget {
- browser_context_id: String,
- tab_target_id: String,
- },
- ActiveTarget {
- browser_context_id: String,
- target_id: Option<String>,
- },
- AuxiliaryTarget {
- browser_context_id: String,
- target_id: String,
- },
- BackgroundTarget {
- browser_context_id: String,
- target_id: String,
- },
- SharedWorkerTarget {
- browser_context_id: String,
- target_id: String,
- },
- DedicatedWorkerTarget {
- browser_context_id: String,
- target_id: String,
- },
- ServiceWorkerTarget {
- browser_context_id: String,
- target_id: String,
- },
-}
-
-impl CdpSessionRoute {
- pub(crate) fn browser_context_id(&self) -> Option<&str> {
- match self {
- Self::Browser => None,
- Self::TabTarget {
- browser_context_id, ..
- }
- | Self::ActiveTarget {
- browser_context_id, ..
- }
- | Self::AuxiliaryTarget {
- browser_context_id, ..
- }
- | Self::BackgroundTarget {
- browser_context_id, ..
- }
- | Self::SharedWorkerTarget {
- browser_context_id, ..
- }
- | Self::DedicatedWorkerTarget {
- browser_context_id, ..
- }
- | Self::ServiceWorkerTarget {
- browser_context_id, ..
- } => Some(browser_context_id),
- }
- }
-
- /// Whether Chromium installs a handler for this CDP domain on the routed
- /// DevToolsAgentHost.
- ///
- /// Page and worker capability checks remain in their domain handlers for
- /// now. Browser and Tab hosts are browser-only sessions in Chromium; they
- /// must not fall through to whichever Page happens to be active.
- pub(crate) fn supports_cdp_domain(&self, domain: &str) -> bool {
- match self {
- Self::Browser => matches!(
- domain,
- "Browser"
- | "Fetch"
- | "IO"
- | "Security"
- | "Storage"
- | "SystemInfo"
- | "Target"
- | "Tracing"
- ),
- Self::TabTarget { .. } => matches!(domain, "IO" | "Target" | "Tracing"),
- Self::ActiveTarget { .. }
- | Self::AuxiliaryTarget { .. }
- | Self::BackgroundTarget { .. }
- | Self::SharedWorkerTarget { .. }
- | Self::DedicatedWorkerTarget { .. }
- | Self::ServiceWorkerTarget { .. } => true,
- }
- }
-
- pub(crate) fn target_handler_access_mode(&self) -> TargetHandlerAccessMode {
- match self {
- Self::Browser => TargetHandlerAccessMode::Browser,
- Self::TabTarget { .. }
- | Self::ActiveTarget { .. }
- | Self::AuxiliaryTarget { .. }
- | Self::BackgroundTarget { .. } => TargetHandlerAccessMode::Regular,
- Self::SharedWorkerTarget { .. }
- | Self::DedicatedWorkerTarget { .. }
- | Self::ServiceWorkerTarget { .. } => TargetHandlerAccessMode::AutoAttachOnly,
- }
- }
-}
-
-pub(super) enum TargetSessionOwner {
- ActiveTarget {
- browser_context_id: String,
- is_auxiliary_target_session: bool,
- },
- BackgroundTarget {
- browser_context_id: String,
- target_id: String,
- is_auxiliary_target_session: bool,
- },
- NoLoadedBrowserContext,
-}
-
-impl CdpConnection {
- pub(crate) fn target_handler_access_mode(
- &self,
- session_id: Option<&str>,
- ) -> TargetHandlerAccessMode {
- let Some(session_id) = session_id else {
- return TargetHandlerAccessMode::Browser;
- };
- self.session_route(Some(session_id))
- .map(|route| route.target_handler_access_mode())
- .unwrap_or(TargetHandlerAccessMode::Regular)
- }
-
- pub(crate) fn target_handler_may_get_target_info(
- &self,
- session_id: Option<&str>,
- target_id: Option<&str>,
- ) -> bool {
- if self.target_handler_access_mode(session_id) != TargetHandlerAccessMode::AutoAttachOnly {
- return true;
- }
- let Some(session_id) = session_id else {
- return false;
- };
- let owner_target_id = self.non_browser_target_id_for_session(Some(session_id));
- let Some(target_id) = target_id.or(owner_target_id.as_deref()) else {
- return false;
- };
- owner_target_id.as_deref() == Some(target_id)
- }
-
- pub(crate) fn target_handler_may_close_target(
- &self,
- session_id: Option<&str>,
- target_id: &str,
- ) -> bool {
- if self.target_handler_access_mode(session_id) != TargetHandlerAccessMode::AutoAttachOnly {
- return true;
- }
- let Some(session_id) = session_id else {
- return false;
- };
- self.non_browser_target_id_for_session(Some(session_id))
- .as_deref()
- == Some(target_id)
- || self
- .target_control
- .auto_attached_target_ids_for_owner(Some(session_id))
- .iter()
- .any(|attached_target_id| attached_target_id == target_id)
- }
-
- pub(crate) fn session_route(&self, session_id: Option<&str>) -> Option<CdpSessionRoute> {
- let session_id = session_id?;
- if self.browser_session_ids.contains(session_id) {
- return Some(CdpSessionRoute::Browser);
- }
- if let Some(tab_target_id) = self.tab_target_id_for_session_id(session_id)
- && let Some(browser_context_id) =
- self.browser_context_id_for_tab_target_id(tab_target_id)
- {
- return Some(CdpSessionRoute::TabTarget {
- browser_context_id,
- tab_target_id: tab_target_id.to_owned(),
- });
- }
- self.browser_contexts()
- .find_map(|bc| browser_context_session_route(bc, session_id))
- }
-
- pub(crate) fn target_session_route_for_target_id(
- &self,
- target_id: &str,
- ) -> Option<CdpSessionRoute> {
- if self
- .primary_page_target_id_for_tab_target_id(target_id)
- .is_some()
- && let Some(browser_context_id) = self.browser_context_id_for_tab_target_id(target_id)
- {
- return Some(CdpSessionRoute::TabTarget {
- browser_context_id,
- tab_target_id: target_id.to_owned(),
- });
- }
- self.browser_contexts().find_map(|browser_context| {
- if browser_context.active_target_id() == Some(target_id) {
- return Some(CdpSessionRoute::ActiveTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: None,
- });
- }
- if browser_context.background_target(target_id).is_some() {
- return Some(CdpSessionRoute::BackgroundTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- });
- }
- if browser_context.has_shared_worker_target(target_id) {
- return Some(CdpSessionRoute::SharedWorkerTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- });
- }
- if browser_context.has_dedicated_worker_target(target_id) {
- return Some(CdpSessionRoute::DedicatedWorkerTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- });
- }
- browser_context
- .has_service_worker_target(target_id)
- .then(|| CdpSessionRoute::ServiceWorkerTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- })
- })
- }
-
- /// Returns the DevToolsAgentHost owned by a non-browser session.
- ///
- /// Chromium's Target domain uses its handler's `owner_target_id` when
- /// `Target.getTargetInfo` omits `targetId`. A tab session therefore owns
- /// the stable Tab target, while a page or worker session owns its exact
- /// execution target.
- pub(crate) fn non_browser_target_id_for_session(
- &self,
- session_id: Option<&str>,
- ) -> Option<String> {
- match self.session_route(session_id)? {
- CdpSessionRoute::TabTarget {
- tab_target_id: target_id,
- ..
- }
- | CdpSessionRoute::AuxiliaryTarget { target_id, .. }
- | CdpSessionRoute::BackgroundTarget { target_id, .. }
- | CdpSessionRoute::SharedWorkerTarget { target_id, .. }
- | CdpSessionRoute::DedicatedWorkerTarget { target_id, .. }
- | CdpSessionRoute::ServiceWorkerTarget { target_id, .. }
- | CdpSessionRoute::ActiveTarget {
- target_id: Some(target_id),
- ..
- } => Some(target_id),
- CdpSessionRoute::ActiveTarget {
- browser_context_id,
- target_id: None,
- } => self
- .browser_context_by_id(&browser_context_id)
- .and_then(|browser_context| browser_context.active_target_id())
- .map(str::to_owned),
- CdpSessionRoute::Browser => None,
- }
- }
-
- pub fn worker_target_id_for_session(&self, session_id: Option<&str>) -> Option<String> {
- match self.session_route(session_id)? {
- CdpSessionRoute::SharedWorkerTarget { target_id, .. }
- | CdpSessionRoute::DedicatedWorkerTarget { target_id, .. }
- | CdpSessionRoute::ServiceWorkerTarget { target_id, .. } => Some(target_id),
- _ => None,
- }
- }
-
- pub(crate) fn target_session_route_for_child_frame_id(
- &self,
- frame_id: &str,
- ) -> Option<CdpSessionRoute> {
- self.browser_contexts().find_map(|browser_context| {
- if browser_context
- .active_target
- .owner_state
- .has_attached_child_frame_id(frame_id)
- {
- return Some(CdpSessionRoute::ActiveTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: None,
- });
- }
- browser_context
- .background_targets
- .iter()
- .find_map(|target| {
- browser_context
- .parked_target_owner_state(target.target_id())
- .is_some_and(|owner_state| {
- owner_state.has_attached_child_frame_id(frame_id)
- })
- .then(|| CdpSessionRoute::BackgroundTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target.target_id().to_owned(),
- })
- })
- })
- }
-
- pub(crate) fn has_attached_child_frame_id(&self, frame_id: &str) -> bool {
- self.browser_contexts()
- .any(|browser_context| browser_context.has_attached_child_frame_id(frame_id))
- }
-
- #[cfg(test)]
- pub(crate) fn has_background_target_session(&self, session_id: Option<&str>) -> bool {
- self.background_target_route(session_id).is_some()
- }
-
- #[cfg(test)]
- pub(crate) fn background_target_id_for_session(
- &self,
- session_id: Option<&str>,
- ) -> Option<String> {
- self.background_target_route(session_id)
- .map(|(_, target_id)| target_id)
- }
-
- fn background_target_route(&self, session_id: Option<&str>) -> Option<(String, String)> {
- match self.session_route(session_id)? {
- CdpSessionRoute::BackgroundTarget {
- browser_context_id,
- target_id,
- } => Some((browser_context_id, target_id)),
- CdpSessionRoute::AuxiliaryTarget {
- browser_context_id,
- target_id,
- } => self
- .browser_context_by_id(&browser_context_id)?
- .background_target(&target_id)
- .is_some()
- .then_some((browser_context_id, target_id)),
- CdpSessionRoute::Browser
- | CdpSessionRoute::TabTarget { .. }
- | CdpSessionRoute::ActiveTarget { .. }
- | CdpSessionRoute::SharedWorkerTarget { .. }
- | CdpSessionRoute::DedicatedWorkerTarget { .. }
- | CdpSessionRoute::ServiceWorkerTarget { .. } => None,
- }
- }
-
- pub(crate) fn is_browser_session_id(&self, session_id: Option<&str>) -> bool {
- let Some(session_id) = session_id else {
- return false;
- };
- self.browser_session_ids.contains(session_id)
- }
-
- #[cfg(test)]
- pub(crate) fn register_browser_session(&mut self, session_id: String) {
- self.browser_session_ids.insert(session_id);
- }
-
- pub(crate) fn remove_browser_session(&mut self, session_id: &str) -> bool {
- self.browser_session_ids.remove(session_id)
- }
-
- fn clear_browser_session_owner_state(&mut self, session_id: &str) -> bool {
- if !self.remove_browser_session(session_id) {
- return false;
- }
- self.download_behavior
- .set_browser_events_enabled_for_session(Some(session_id), false);
- self.cancel_tracing_for_session_owner(Some(session_id));
- self.clear_auto_attach_owner(Some(session_id));
- self.clear_target_discovery_for_owner(Some(session_id));
- self.set_service_worker_pause_on_start_owner(Some(session_id), false);
- self.set_dedicated_worker_pause_on_start_owner(Some(session_id), false);
- true
- }
-
- pub(crate) fn detach_browser_session_owner_without_event(
- &mut self,
- session_id: &str,
- ) -> Option<crate::conn::target::TargetEventPlan> {
- if !self.clear_browser_session_owner_state(session_id) {
- return None;
- }
- let rollback_plan = self.rollback_attached_session_without_event(session_id);
- Some(rollback_plan)
- }
-
- pub(crate) fn detach_browser_session_owner_event_plan(
- &mut self,
- session_id: &str,
- ) -> Option<crate::conn::target::TargetEventPlan> {
- let owner_session_id = self
- .target_control
- .attached_session_owner_session_id(session_id)
- .map(str::to_owned);
- if !self.clear_browser_session_owner_state(session_id) {
- return None;
- }
- let plan = self.target_control.detach_attached_session_event_plan(
- session_id,
- None,
- owner_session_id.as_deref(),
- );
- self.clear_detached_target_session_owner_state(session_id);
- plan
- }
-
- pub(crate) fn release_root_target_frontend_owner_without_event(&mut self) {
- self.download_behavior
- .set_browser_events_enabled_for_session(None, false);
- self.cancel_tracing_for_session_owner(None);
- self.clear_auto_attach_owner(None);
- self.clear_target_discovery_for_owner(None);
- self.target_control.remove_owner(None);
- }
-
- pub(crate) fn release_primary_target_session_binding_without_event(
- &mut self,
- session_id: &str,
- ) -> bool {
- let released = self
- .browser_context
- .as_mut()
- .is_some_and(|browser_context| {
- browser_context
- .release_primary_session_binding_preserving_frontend_state(session_id)
- });
- if released {
- self.rollback_attached_session_without_event(session_id);
- }
- released
- }
-
- fn sync_auto_attach_flags_from_owners(&mut self) {
- self.auto_attach = !self.auto_attach_owner_sessions.is_empty();
- self.auto_attach_wait_for_debugger_on_start = self
- .auto_attach_owner_sessions
- .values()
- .any(|policy| policy.wait_for_debugger_on_start);
- }
-
- pub(crate) fn has_auto_attach_owner(&self, session_id: Option<&str>) -> bool {
- self.auto_attach_owner_sessions
- .contains_key(&session_id.map(str::to_owned))
- }
-
- pub(crate) fn auto_attach_owner_count(&self) -> usize {
- self.auto_attach_owner_sessions.len()
- }
-
- pub(crate) fn auto_attach_owner_sessions_for_target_type(
- &self,
- target_type: &str,
- ) -> Vec<Option<String>> {
- if self.auto_attach_owner_sessions.is_empty() && self.auto_attach {
- return super::super::CdpTargetFilter::default_auto_attach()
- .matches(target_type)
- .then_some(None)
- .into_iter()
- .collect();
- }
- self.auto_attach_owner_sessions
- .iter()
- .filter(|(_, policy)| policy.target_filter.matches(target_type))
- .map(|(session_id, _)| session_id.clone())
- .collect::<Vec<_>>()
- }
-
- pub(crate) fn auto_attach_owner_allows_target_type(
- &self,
- session_id: Option<&str>,
- target_type: &str,
- ) -> bool {
- self.auto_attach_owner_sessions
- .get(&session_id.map(str::to_owned))
- .is_some_and(|policy| policy.target_filter.matches(target_type))
- || (self.auto_attach_owner_sessions.is_empty()
- && self.auto_attach
- && super::super::CdpTargetFilter::default_auto_attach().matches(target_type))
- }
-
- pub(crate) fn auto_attach_owner_waits_for_debugger_on_start(
- &self,
- session_id: Option<&str>,
- ) -> bool {
- if self.auto_attach_owner_sessions.is_empty() && self.auto_attach {
- return self.auto_attach_wait_for_debugger_on_start;
- }
- self.auto_attach_owner_sessions
- .get(&session_id.map(str::to_owned))
- .is_some_and(|policy| policy.wait_for_debugger_on_start)
- }
-
- pub(crate) fn set_auto_attach_owner(
- &mut self,
- session_id: Option<&str>,
- enabled: bool,
- wait_for_debugger_on_start: bool,
- target_filter: super::super::CdpTargetFilter,
- ) {
- self.clear_service_worker_auto_attach_related_owner(session_id);
- let key = session_id.map(str::to_owned);
- if enabled {
- self.target_control.ensure_owner(session_id);
- self.auto_attach_owner_sessions.insert(
- key,
- super::super::AutoAttachOwnerPolicy {
- wait_for_debugger_on_start,
- target_filter,
- },
- );
- } else {
- self.auto_attach_owner_sessions.remove(&key);
- }
- self.sync_auto_attach_flags_from_owners();
- }
-
- pub(crate) fn clear_auto_attach_owner(&mut self, session_id: Option<&str>) {
- self.clear_service_worker_auto_attach_related_owner(session_id);
- let key = session_id.map(str::to_owned);
- self.auto_attach_owner_sessions.remove(&key);
- self.sync_auto_attach_flags_from_owners();
- }
-
- #[cfg(test)]
- pub(crate) fn register_auto_attached_session(
- &mut self,
- session_id: String,
- owner_session_id: Option<&str>,
- ) {
- let target_id = self.non_browser_target_id_for_session(Some(&session_id));
- self.register_auto_attached_session_for_target(
- session_id,
- owner_session_id,
- target_id.as_deref(),
- );
- }
-
- #[cfg(test)]
- pub(crate) fn register_auto_attached_session_for_target(
- &mut self,
- session_id: String,
- owner_session_id: Option<&str>,
- target_id: Option<&str>,
- ) {
- let route = self.session_route(Some(&session_id));
- self.target_control.commit_auto_attached_session_for_target(
- session_id,
- owner_session_id,
- target_id,
- route,
- false,
- );
- }
-
- pub(crate) fn commit_prepared_attach_event_plan(
- &mut self,
- prepared: crate::conn::PreparedTargetAttach,
- ) -> crate::conn::target::TargetEventPlan {
- self.commit_prepared_attach_event_plan_with_attached_state_delta(prepared, true)
- }
-
- pub(crate) fn commit_prepared_dedicated_worker_attach_event_plan(
- &mut self,
- prepared: crate::conn::PreparedTargetAttach,
- ) -> crate::conn::target::TargetEventPlan {
- self.commit_prepared_attach_event_plan_with_attached_state_delta(prepared, false)
- }
-
- fn commit_prepared_attach_event_plan_with_attached_state_delta(
- &mut self,
- prepared: crate::conn::PreparedTargetAttach,
- emit_attached_state_delta: bool,
- ) -> crate::conn::target::TargetEventPlan {
- let (target_id, target_info, sessions) = prepared.into_parts();
- let should_emit_attached_state_delta = emit_attached_state_delta && !sessions.is_empty();
- let attached_state_delta_plan = should_emit_attached_state_delta
- .then(|| self.exact_target_info_changed_event_plan_for_target_delta(&target_id));
- let mut plan = crate::conn::target::TargetEventPlan::default();
- for session in sessions {
- let (session_id, owner_session_id, route, auto_attached, waiting_for_debugger) =
- session.into_parts();
- if auto_attached {
- self.target_control
- .ensure_owner(owner_session_id.as_deref());
- }
- plan.extend(self.target_control.commit_attached_session_event(
- session_id,
- owner_session_id.as_deref(),
- &target_id,
- route,
- auto_attached,
- waiting_for_debugger,
- target_info.clone(),
- ));
- }
- if let Some(attached_state_delta_plan) = attached_state_delta_plan {
- plan.extend(attached_state_delta_plan);
- }
- plan
- }
-
- pub(crate) fn prepare_auto_attach_session_commit(
- &self,
- session_id: impl Into<String>,
- owner_session_id: Option<String>,
- waiting_for_debugger: bool,
- ) -> crate::conn::TargetAttachSessionCommit {
- let session_id = session_id.into();
- let route = self.session_route(Some(&session_id));
- crate::conn::TargetAttachSessionCommit::auto_attached(
- session_id,
- owner_session_id,
- waiting_for_debugger,
- )
- .with_route(route)
- }
-
- pub(crate) fn prepare_direct_attach_session_commit(
- &self,
- session_id: impl Into<String>,
- owner_session_id: Option<String>,
- waiting_for_debugger: bool,
- ) -> crate::conn::TargetAttachSessionCommit {
- let session_id = session_id.into();
- let route = self.session_route(Some(&session_id));
- crate::conn::TargetAttachSessionCommit::direct(
- session_id,
- owner_session_id,
- waiting_for_debugger,
- )
- .with_route(route)
- }
-
- pub(crate) fn attach_tab_target_session_event_plan(
- &mut self,
- session_id: String,
- owner_session_id: Option<&str>,
- tab_target_id: &str,
- auxiliary: bool,
- ) -> Result<crate::conn::target::TargetEventPlan, &'static str> {
- if !self.assign_session_to_tab_target(tab_target_id, session_id.clone(), auxiliary) {
- return Err("UnknownTargetId");
- }
- let prepared_session = self.prepare_direct_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- false,
- );
- let Some(target_info) = self.tab_target_info(tab_target_id) else {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("UnknownTargetId");
- };
- if prepared_session.route().is_none() {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("InvalidSessionId");
- }
- Ok(
- self.commit_prepared_attach_event_plan(crate::conn::PreparedTargetAttach::new(
- tab_target_id,
- target_info,
- [prepared_session],
- )),
- )
- }
-
- pub(crate) fn attach_shared_worker_target_session_event_plan(
- &mut self,
- session_id: String,
- owner_session_id: Option<&str>,
- target_id: &str,
- ) -> Result<crate::conn::target::TargetEventPlan, &'static str> {
- let session_id_for_binding = session_id.clone();
- let target_info = {
- let Some(bc) = self.browser_context.as_mut() else {
- return Err("BrowserContextNotLoaded");
- };
- if !bc.assign_session_to_shared_worker_target(target_id, session_id_for_binding) {
- return Err("UnknownTargetId");
- }
- bc.devtools_target_info(target_id)
- };
- let prepared_session = self.prepare_direct_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- false,
- );
- let Some(target_info) = target_info else {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("UnknownTargetId");
- };
- if prepared_session.route().is_none() {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("InvalidSessionId");
- }
- Ok(
- self.commit_prepared_attach_event_plan(crate::conn::PreparedTargetAttach::new(
- target_id,
- target_info,
- [prepared_session],
- )),
- )
- }
-
- pub(crate) fn attach_service_worker_target_session_event_plan(
- &mut self,
- session_id: String,
- owner_session_id: Option<&str>,
- target_id: &str,
- ) -> Result<crate::conn::target::TargetEventPlan, &'static str> {
- let session_id_for_binding = session_id.clone();
- let target_info = {
- let Some(bc) = self.browser_context.as_mut() else {
- return Err("BrowserContextNotLoaded");
- };
- if !bc.assign_session_to_service_worker_target(target_id, session_id_for_binding) {
- return Err("UnknownTargetId");
- }
- bc.devtools_target_info(target_id)
- };
- let prepared_session = self.prepare_direct_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- false,
- );
- let Some(target_info) = target_info else {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("UnknownTargetId");
- };
- if prepared_session.route().is_none() {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("InvalidSessionId");
- }
- Ok(
- self.commit_prepared_attach_event_plan(crate::conn::PreparedTargetAttach::new(
- target_id,
- target_info,
- [prepared_session],
- )),
- )
- }
-
- pub(crate) fn attach_dedicated_worker_target_session_event_plan(
- &mut self,
- session_id: String,
- owner_session_id: Option<&str>,
- target_id: &str,
- ) -> Result<crate::conn::target::TargetEventPlan, &'static str> {
- let session_id_for_binding = session_id.clone();
- let target_info = {
- let Some(bc) = self.browser_context.as_mut() else {
- return Err("BrowserContextNotLoaded");
- };
- if !bc.assign_session_to_dedicated_worker_target(target_id, session_id_for_binding) {
- return Err("UnknownTargetId");
- }
- bc.devtools_target_info(target_id)
- };
- let prepared_session = self.prepare_direct_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- false,
- );
- let Some(target_info) = target_info else {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("UnknownTargetId");
- };
- if prepared_session.route().is_none() {
- self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
- return Err("InvalidSessionId");
- }
- Ok(self.commit_prepared_dedicated_worker_attach_event_plan(
- crate::conn::PreparedTargetAttach::new(target_id, target_info, [prepared_session]),
- ))
- }
-
- pub(crate) fn prepare_auto_attached_tab_session_binding(
- &mut self,
- tab_target_id: &str,
- session_id: String,
- owner_session_id: Option<&str>,
- ) -> bool {
- self.assign_session_to_tab_target(tab_target_id, session_id, owner_session_id.is_some())
- }
-
- pub(crate) fn prepare_auto_attached_page_session_binding(
- &mut self,
- target_id: &str,
- session_id: String,
- ) -> bool {
- self.browser_context
- .as_mut()
- .is_some_and(|bc| bc.assign_auto_attached_session_to_target(target_id, session_id))
- }
-
- pub(crate) fn prepare_auto_attached_page_session_binding_in_browser_context(
- &mut self,
- browser_context_id: &str,
- target_id: &str,
- session_id: String,
- ) -> bool {
- self.browser_context_by_id_mut(browser_context_id)
- .is_some_and(|bc| bc.assign_auto_attached_session_to_target(target_id, session_id))
- }
-
- pub(crate) fn prepare_auto_attached_shared_worker_session_binding(
- &mut self,
- target_id: &str,
- session_id: String,
- ) -> bool {
- self.browser_context
- .as_mut()
- .is_some_and(|bc| bc.assign_session_to_shared_worker_target(target_id, session_id))
- }
-
- pub(crate) fn prepare_auto_attached_dedicated_worker_session_binding(
- &mut self,
- target_id: &str,
- session_id: String,
- ) -> bool {
- self.browser_context
- .as_mut()
- .is_some_and(|bc| bc.assign_session_to_dedicated_worker_target(target_id, session_id))
- }
-
- pub(crate) fn prepare_auto_attached_service_worker_session_binding(
- &mut self,
- target_id: &str,
- session_id: String,
- ) -> bool {
- self.browser_context
- .as_mut()
- .is_some_and(|bc| bc.assign_session_to_service_worker_target(target_id, session_id))
- }
-
- pub(crate) fn prepare_auto_attached_shared_worker_session_binding_info_in_browser_context(
- &mut self,
- browser_context_id: &str,
- target_id: &str,
- session_id: String,
- ) -> Option<DevToolsTargetInfo> {
- let bc = self.browser_context_by_id_mut(browser_context_id)?;
- if !bc.assign_session_to_shared_worker_target(target_id, session_id) {
- return None;
- }
- bc.devtools_target_info(target_id)
- }
-
- pub(crate) fn prepare_auto_attached_dedicated_worker_session_binding_info_in_browser_context(
- &mut self,
- browser_context_id: &str,
- target_id: &str,
- session_id: String,
- ) -> Option<DevToolsTargetInfo> {
- let bc = self.browser_context_by_id_mut(browser_context_id)?;
- if !bc.assign_session_to_dedicated_worker_target(target_id, session_id) {
- return None;
- }
- bc.devtools_target_info(target_id)
- }
-
- pub(crate) fn prepare_auto_attached_service_worker_session_binding_info_in_browser_context(
- &mut self,
- browser_context_id: &str,
- target_id: &str,
- session_id: String,
- ) -> Option<DevToolsTargetInfo> {
- let bc = self.browser_context_by_id_mut(browser_context_id)?;
- if !bc.assign_session_to_service_worker_target(target_id, session_id) {
- return None;
- }
- bc.devtools_target_info(target_id)
- }
-
- pub(crate) fn prepare_auto_attached_service_worker_session_binding_info(
- &mut self,
- target_id: &str,
- session_id: String,
- ) -> Option<DevToolsTargetInfo> {
- let bc = self.browser_context.as_mut()?;
- if !bc.assign_session_to_service_worker_target(target_id, session_id) {
- return None;
- }
- bc.devtools_target_info(target_id)
- }
-
- pub(crate) fn commit_browser_attached_session_event_plan(
- &mut self,
- session_id: String,
- owner_session_id: Option<&str>,
- target_id: &str,
- target_info: DevToolsTargetInfo,
- ) -> crate::conn::target::TargetEventPlan {
- self.browser_session_ids.insert(session_id.clone());
- self.target_control.commit_attached_session_event(
- session_id,
- owner_session_id,
- target_id,
- Some(CdpSessionRoute::Browser),
- false,
- false,
- target_info,
- )
- }
-
- pub(crate) fn rollback_attached_session_without_event(
- &mut self,
- session_id: &str,
- ) -> crate::conn::target::TargetEventPlan {
- let plan = self
- .target_control
- .rollback_attached_session_without_event(session_id);
- for session_id in plan.rolled_back_session_ids() {
- self.clear_detached_target_session_owner_state(session_id);
- }
- plan
- }
-
- pub(crate) fn detach_known_session_event_plan(
- &mut self,
- target_id: &str,
- session_id: &str,
- reason: Option<&str>,
- parent_session_id: Option<&str>,
- ) -> crate::conn::target::TargetEventPlan {
- self.detach_known_session_event_plan_with_attached_state_delta(
- target_id,
- session_id,
- reason,
- parent_session_id,
- true,
- )
- }
-
- fn detach_known_session_event_plan_with_attached_state_delta(
- &mut self,
- target_id: &str,
- session_id: &str,
- reason: Option<&str>,
- parent_session_id: Option<&str>,
- emit_attached_state_delta: bool,
- ) -> crate::conn::target::TargetEventPlan {
- let attached_state_delta_plan = emit_attached_state_delta
- .then(|| self.exact_target_info_changed_event_plan_for_target_delta(target_id));
- let mut plan = self.target_control.detach_known_session_event_plan(
- target_id,
- session_id,
- reason,
- parent_session_id,
- );
- self.clear_detached_target_session_owner_state(session_id);
- if let Some(attached_state_delta_plan) = attached_state_delta_plan {
- plan.extend(attached_state_delta_plan);
- }
- plan
- }
-
- pub(crate) fn detach_target_closure_cleanup_event_plan(
- &mut self,
- cleanup_plan: crate::conn::TargetClosureCleanupPlan,
- parent_session_id: Option<&str>,
- ) -> crate::conn::target::TargetEventPlan {
- let plan = self
- .target_control
- .detach_target_closure_cleanup_event_plan(cleanup_plan, parent_session_id);
- for session in plan.detached_sessions() {
- self.clear_detached_target_session_owner_state(session.session_id());
- }
- plan
- }
-
- pub(crate) async fn rollback_prepared_attach_session_without_event_async(
- &mut self,
- prepared: &crate::conn::TargetAttachSessionCommit,
- ) -> crate::conn::target::TargetEventPlan {
- self.rollback_attached_session_with_cleanup_without_event_async(
- crate::conn::TargetAttachRollbackPlan::from_prepared_attach_session(prepared),
- )
- .await
- }
-
- pub(crate) fn rollback_prepared_attach_session_sync_without_event(
- &mut self,
- prepared: &crate::conn::TargetAttachSessionCommit,
- ) -> crate::conn::target::TargetEventPlan {
- self.rollback_attached_session_with_cleanup_without_event_sync(
- crate::conn::TargetAttachRollbackPlan::from_prepared_attach_session(prepared),
- )
- }
-
- fn rollback_attached_session_with_cleanup_without_event_sync(
- &mut self,
- rollback_plan: crate::conn::TargetAttachRollbackPlan,
- ) -> crate::conn::target::TargetEventPlan {
- if let Some(cleanup_plan) = rollback_plan.cleanup_plan() {
- if matches!(
- cleanup_plan.action(),
- crate::conn::TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached
- ) {
- debug_assert!(
- false,
- "active target rollback requires async binding cleanup"
- );
- } else {
- self.execute_target_binding_cleanup_without_event_sync(cleanup_plan);
- }
- }
- self.rollback_attached_session_without_event(rollback_plan.session_id())
- }
-
- fn execute_target_binding_cleanup_without_event_sync(
- &mut self,
- cleanup_plan: &crate::conn::TargetBindingCleanupPlan,
- ) {
- match cleanup_plan.action() {
- crate::conn::TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached {
- ..
- } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.clear_background_target_primary_auto_attached_session(
- cleanup_plan.session_id(),
- );
- }
- }
- crate::conn::TargetBindingCleanupAction::AuxiliaryTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.remove_auxiliary_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::TabTarget { .. } => {
- self.remove_tab_session(cleanup_plan.session_id());
- }
- crate::conn::TargetBindingCleanupAction::SharedWorkerTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.detach_shared_worker_target_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::DedicatedWorkerTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.detach_dedicated_worker_target_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::ServiceWorkerTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.detach_service_worker_target_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::None
- | crate::conn::TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached => {}
- }
- }
-
- async fn rollback_attached_session_with_cleanup_without_event_async(
- &mut self,
- rollback_plan: crate::conn::TargetAttachRollbackPlan,
- ) -> crate::conn::target::TargetEventPlan {
- let Some(browser_context_id) = rollback_plan.browser_context_id().map(str::to_owned) else {
- return self.rollback_attached_session_without_event(rollback_plan.session_id());
- };
- if !self
- .activate_browser_context_by_id_async(&browser_context_id)
- .await
- {
- return self.rollback_attached_session_without_event(rollback_plan.session_id());
- }
-
- if let Some(cleanup_plan) = rollback_plan.cleanup_plan() {
- self.execute_target_binding_cleanup_without_event_async(cleanup_plan)
- .await;
- }
- self.rollback_attached_session_without_event(rollback_plan.session_id())
- }
-
- pub(crate) fn auto_attached_session_detach_plan(
- &self,
- session_id: &str,
- ) -> crate::conn::TargetAutoAttachedSessionDetachPlan {
- crate::conn::TargetAutoAttachedSessionDetachPlan::from_session_route(
- session_id,
- self.session_route(Some(session_id)),
- )
- }
-
- pub(crate) fn rollback_auto_attached_session_detach_plan_without_event(
- &mut self,
- detach_plan: &crate::conn::TargetAutoAttachedSessionDetachPlan,
- ) -> crate::conn::target::TargetEventPlan {
- self.rollback_attached_session_without_event(detach_plan.session_id())
- }
-
- pub(crate) async fn execute_target_binding_cleanup_without_event_async(
- &mut self,
- cleanup_plan: &crate::conn::TargetBindingCleanupPlan,
- ) {
- match cleanup_plan.action() {
- crate::conn::TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc
- .clear_active_target_primary_auto_attached_session_async()
- .await;
- }
- }
- crate::conn::TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached {
- ..
- } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.clear_background_target_primary_auto_attached_session(
- cleanup_plan.session_id(),
- );
- }
- }
- crate::conn::TargetBindingCleanupAction::AuxiliaryTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.remove_auxiliary_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::TabTarget { .. } => {
- self.remove_tab_session(cleanup_plan.session_id());
- }
- crate::conn::TargetBindingCleanupAction::SharedWorkerTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.detach_shared_worker_target_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::DedicatedWorkerTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.detach_dedicated_worker_target_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::ServiceWorkerTarget { .. } => {
- if let Some(bc) = self.browser_context.as_mut() {
- let _ = bc.detach_service_worker_target_session(cleanup_plan.session_id());
- }
- }
- crate::conn::TargetBindingCleanupAction::None => {}
- }
- }
-
- pub(crate) async fn execute_target_binding_cleanup_for_session_without_event_async(
- &mut self,
- session_id: &str,
- ) -> bool {
- let Some(route) = self.session_route(Some(session_id)) else {
- return false;
- };
- self.cancel_tracing_for_session_owner_async(Some(session_id))
- .await;
- let cleanup_plan = crate::conn::TargetBindingCleanupPlan::from_route(session_id, &route);
- self.execute_target_binding_cleanup_without_event_async(&cleanup_plan)
- .await;
- true
- }
-
- pub(crate) async fn detach_session_with_binding_cleanup_event_plan_async(
- &mut self,
- cleanup_plan: crate::conn::TargetSessionDetachCleanupPlan,
- ) -> crate::conn::target::TargetEventPlan {
- let session_id = cleanup_plan.session_id().to_owned();
- let target_id = cleanup_plan.target_id().to_owned();
- let reason = cleanup_plan.reason().map(str::to_owned);
- let parent_session_id = cleanup_plan
- .parent_session_id()
- .or_else(|| {
- self.target_control
- .attached_session_owner_session_id(&session_id)
- })
- .map(str::to_owned);
- let _ = self
- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
- .await;
- self.detach_known_session_event_plan(
- &target_id,
- &session_id,
- reason.as_deref(),
- parent_session_id.as_deref(),
- )
- }
-
- pub(crate) async fn detach_dedicated_worker_session_with_binding_cleanup_event_plan_async(
- &mut self,
- cleanup_plan: crate::conn::TargetSessionDetachCleanupPlan,
- ) -> crate::conn::target::TargetEventPlan {
- let session_id = cleanup_plan.session_id().to_owned();
- let target_id = cleanup_plan.target_id().to_owned();
- let reason = cleanup_plan.reason().map(str::to_owned);
- let parent_session_id = cleanup_plan
- .parent_session_id()
- .or_else(|| {
- self.target_control
- .attached_session_owner_session_id(&session_id)
- })
- .map(str::to_owned);
- let _ = self
- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
- .await;
- self.detach_known_session_event_plan_with_attached_state_delta(
- &target_id,
- &session_id,
- reason.as_deref(),
- parent_session_id.as_deref(),
- false,
- )
- }
-
- pub(crate) fn detach_dedicated_worker_session_after_target_removal_event_plan(
- &mut self,
- cleanup_plan: crate::conn::TargetSessionDetachCleanupPlan,
- ) -> crate::conn::target::TargetEventPlan {
- let parent_session_id = cleanup_plan
- .parent_session_id()
- .or_else(|| {
- self.target_control
- .attached_session_owner_session_id(cleanup_plan.session_id())
- })
- .map(str::to_owned);
- self.detach_known_session_event_plan_with_attached_state_delta(
- cleanup_plan.target_id(),
- cleanup_plan.session_id(),
- cleanup_plan.reason(),
- parent_session_id.as_deref(),
- false,
- )
- }
-
- pub(crate) async fn detach_target_sessions_with_binding_cleanup_event_plan_async(
- &mut self,
- cleanup_plan: crate::conn::TargetClosureCleanupPlan,
- parent_session_id: Option<&str>,
- ) -> crate::conn::target::TargetEventPlan {
- let target_id = cleanup_plan.target_id().to_owned();
- let reason = cleanup_plan.reason().map(str::to_owned);
- let session_ids = cleanup_plan
- .session_ids()
- .map(str::to_owned)
- .collect::<Vec<_>>();
- let mut plan = crate::conn::target::TargetEventPlan::default();
- for session_id in session_ids {
- if self
- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
- .await
- {
- plan.extend(self.detach_known_session_event_plan(
- &target_id,
- &session_id,
- reason.as_deref(),
- parent_session_id,
- ));
- }
- }
- plan
- }
-
- pub(crate) async fn detach_active_target_session_binding_event_plan_async(
- &mut self,
- cleanup_plan: crate::conn::TargetSessionDetachCleanupPlan,
- ) -> Result<crate::conn::target::TargetEventPlan, String> {
- let session_id = cleanup_plan.session_id().to_owned();
- let target_id = cleanup_plan.target_id().to_owned();
- let reason = cleanup_plan.reason().map(str::to_owned);
- let parent_session_id = cleanup_plan.parent_session_id().map(str::to_owned);
- self.clear_active_target_session_binding_for_detach_async()
- .await?;
- Ok(self.detach_known_session_event_plan(
- &target_id,
- &session_id,
- reason.as_deref(),
- parent_session_id.as_deref(),
- ))
- }
-
- pub(crate) async fn detach_background_target_session_binding_event_plan_async(
- &mut self,
- cleanup_plan: crate::conn::TargetSessionDetachCleanupPlan,
- ) -> Result<Option<crate::conn::target::TargetEventPlan>, String> {
- let session_id = cleanup_plan.session_id().to_owned();
- let target_id = cleanup_plan.target_id().to_owned();
- let reason = cleanup_plan.reason().map(str::to_owned);
- let parent_session_id = cleanup_plan.parent_session_id().map(str::to_owned);
- let Some(detached_target_id) = self
- .clear_background_target_session_binding_for_detach_async(&session_id)
- .await?
- else {
- return Ok(None);
- };
- debug_assert_eq!(detached_target_id, target_id);
- Ok(Some(self.detach_known_session_event_plan(
- &target_id,
- &session_id,
- reason.as_deref(),
- parent_session_id.as_deref(),
- )))
- }
-
- pub(crate) fn background_target_session_detach_cleanup_plans(
- &self,
- reason: Option<&str>,
- parent_session_id: Option<&str>,
- ) -> Vec<crate::conn::TargetSessionDetachCleanupPlan> {
- self.browser_context
- .as_ref()
- .map(|bc| {
- bc.background_targets
- .iter()
- .filter_map(|target| {
- Some(crate::conn::TargetSessionDetachCleanupPlan::new(
- target.target_id().to_owned(),
- target.session_id()?.to_owned(),
- reason,
- parent_session_id,
- ))
- })
- .collect()
- })
- .unwrap_or_default()
- }
-
- pub(crate) async fn clear_active_target_session_binding_for_detach_async(
- &mut self,
- ) -> Result<(), String> {
- let Some(bc) = self.browser_context.as_mut() else {
- return Ok(());
- };
- bc.clear_active_target_session_binding_and_scoped_state_async()
- .await
- }
-
- pub(crate) async fn clear_background_target_session_binding_for_detach_async(
- &mut self,
- session_id: &str,
- ) -> Result<Option<String>, String> {
- let Some(bc) = self.browser_context.as_mut() else {
- return Ok(None);
- };
- bc.clear_background_target_session_binding_and_scoped_state_async(session_id)
- .await
- }
-
- pub(crate) async fn detach_all_shared_worker_target_sessions_event_plan_async(
- &mut self,
- reason: Option<&str>,
- parent_session_id: Option<&str>,
- ) -> crate::conn::target::TargetEventPlan {
- let target_ids = self
- .browser_context
- .as_ref()
- .map(|bc| {
- bc.shared_worker_targets
- .values()
- .filter(|target| target.has_session())
- .map(|target| target.target_id.clone())
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- let mut plan = crate::conn::target::TargetEventPlan::default();
- for target_id in target_ids {
- let session_ids = self
- .browser_context
- .as_ref()
- .and_then(|bc| bc.shared_worker_target(&target_id))
- .map(|target| target.session_ids())
- .unwrap_or_default();
- for session_id in session_ids {
- if self
- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
- .await
- {
- plan.extend(self.detach_known_session_event_plan(
- &target_id,
- &session_id,
- reason,
- parent_session_id,
- ));
- }
- }
- }
- plan
- }
-
- pub(crate) async fn detach_all_service_worker_target_sessions_event_plan_async(
- &mut self,
- reason: Option<&str>,
- parent_session_id: Option<&str>,
- ) -> crate::conn::target::TargetEventPlan {
- let target_ids = self
- .browser_context
- .as_ref()
- .map(|bc| {
- bc.service_worker_targets
- .values()
- .filter(|target| target.has_session())
- .map(|target| target.target_id.clone())
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- let mut plan = crate::conn::target::TargetEventPlan::default();
- for target_id in target_ids {
- let session_ids = self
- .browser_context
- .as_ref()
- .and_then(|bc| bc.service_worker_target(&target_id))
- .map(|target| target.session_ids())
- .unwrap_or_default();
- for session_id in session_ids {
- if self
- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
- .await
- {
- plan.extend(self.detach_known_session_event_plan(
- &target_id,
- &session_id,
- reason,
- parent_session_id,
- ));
- }
- }
- }
- plan
- }
-
- pub(crate) async fn detach_all_dedicated_worker_target_sessions_event_plan_async(
- &mut self,
- reason: Option<&str>,
- parent_session_id: Option<&str>,
- ) -> crate::conn::target::TargetEventPlan {
- let target_ids = self
- .browser_context
- .as_ref()
- .map(|bc| {
- bc.dedicated_worker_targets
- .values()
- .filter(|target| target.has_session())
- .map(|target| target.target_id.clone())
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- let mut plan = crate::conn::target::TargetEventPlan::default();
- for target_id in target_ids {
- let session_ids = self
- .browser_context
- .as_ref()
- .and_then(|bc| bc.dedicated_worker_target(&target_id))
- .map(|target| target.session_ids())
- .unwrap_or_default();
- for session_id in session_ids {
- if self
- .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
- .await
- {
- plan.extend(self.detach_known_session_event_plan(
- &target_id,
- &session_id,
- reason,
- parent_session_id,
- ));
- }
- }
- }
- plan
- }
-
- fn clear_detached_target_session_owner_state(&mut self, session_id: &str) {
- self.download_behavior
- .set_browser_events_enabled_for_session(Some(session_id), false);
- self.cancel_tracing_for_session_owner(Some(session_id));
- self.clear_auto_attach_owner(Some(session_id));
- self.set_service_worker_pause_on_start_owner(Some(session_id), false);
- self.target_control.remove_owner(Some(session_id));
- }
-
- pub(crate) fn attached_sessions_for_target(&self, target_id: &str) -> Vec<String> {
- self.target_control.attached_sessions_for_target(target_id)
- }
-
- pub(crate) fn target_has_waiting_for_debugger_session(&self, target_id: &str) -> bool {
- self.target_control
- .target_has_waiting_for_debugger_session(target_id)
- }
-
- pub(crate) fn auto_attached_sessions_for_owner(
- &self,
- owner_session_id: Option<&str>,
- ) -> Vec<String> {
- self.target_control
- .auto_attached_sessions_for_owner(owner_session_id)
- }
-
- pub(crate) fn attached_session_cascade_for_owner(
- &self,
- owner_session_id: Option<&str>,
- ) -> Vec<String> {
- self.target_control
- .attached_session_cascade_for_owner(owner_session_id)
- }
-
- pub(crate) fn attached_session_cascade_for_root_frontend(&self) -> Vec<String> {
- self.target_control
- .attached_session_cascade_for_root_frontend()
- }
-
- pub(crate) fn auto_attached_session_cascade_for_owner(
- &self,
- owner_session_id: Option<&str>,
- ) -> Vec<String> {
- self.target_control
- .auto_attached_session_cascade_for_owner(owner_session_id)
- }
-
- pub(crate) fn set_service_worker_auto_attach_related_owner(
- &mut self,
- owner_session_id: Option<&str>,
- browser_context_id: &str,
- registration_id: u64,
- base_version_id: u64,
- script_url: String,
- scope_url: String,
- allow_service_worker_targets: bool,
- wait_for_debugger_on_start: bool,
- ) {
- let owner_key = owner_session_id.map(str::to_owned);
- self.service_worker_auto_attach_related_owners
- .retain(|owner| {
- !(owner.owner_session_id == owner_key
- && owner.browser_context_id == browser_context_id
- && owner.registration_id == registration_id
- && owner.script_url == script_url
- && owner.scope_url == scope_url)
- });
- self.service_worker_auto_attach_related_owners.push(
- super::super::ServiceWorkerAutoAttachRelatedOwner {
- owner_session_id: owner_key,
- browser_context_id: browser_context_id.to_owned(),
- registration_id,
- base_version_id,
- script_url,
- scope_url,
- allow_service_worker_targets,
- wait_for_debugger_on_start,
- },
- );
- self.sync_service_worker_related_pause_on_start_for_devtools();
- }
-
- pub(crate) fn replace_service_worker_auto_attach_related_owner(
- &mut self,
- owner_session_id: Option<&str>,
- browser_context_id: &str,
- registration_id: u64,
- base_version_id: u64,
- script_url: String,
- scope_url: String,
- allow_service_worker_targets: bool,
- wait_for_debugger_on_start: bool,
- ) {
- self.clear_auto_attach_owner(owner_session_id);
- self.set_service_worker_auto_attach_related_owner(
- owner_session_id,
- browser_context_id,
- registration_id,
- base_version_id,
- script_url,
- scope_url,
- allow_service_worker_targets,
- wait_for_debugger_on_start,
- );
- }
-
- pub(crate) fn clear_service_worker_auto_attach_related_owner(
- &mut self,
- owner_session_id: Option<&str>,
- ) {
- let owner_key = owner_session_id.map(str::to_owned);
- self.service_worker_auto_attach_related_owners
- .retain(|owner| owner.owner_session_id != owner_key);
- self.sync_service_worker_related_pause_on_start_for_devtools();
- }
-
- pub(crate) fn service_worker_auto_attach_related_owner_sessions_for_target(
- &self,
- browser_context_id: &str,
- registration_id: u64,
- version_id: u64,
- script_url: &str,
- scope_url: &str,
- ) -> Vec<super::super::ServiceWorkerAutoAttachRelatedOwnerSession> {
- let mut owners = Vec::new();
- for owner in &self.service_worker_auto_attach_related_owners {
- if !owner.allow_service_worker_targets
- || owner.browser_context_id != browser_context_id
- || owner.registration_id != registration_id
- || version_id <= owner.base_version_id
- || owner.script_url != script_url
- || owner.scope_url != scope_url
- {
- continue;
- }
- if !owners.iter().any(
- |existing: &super::super::ServiceWorkerAutoAttachRelatedOwnerSession| {
- existing.owner_session_id == owner.owner_session_id
- },
- ) {
- owners.push(super::super::ServiceWorkerAutoAttachRelatedOwnerSession {
- owner_session_id: owner.owner_session_id.clone(),
- wait_for_debugger_on_start: owner.wait_for_debugger_on_start,
- });
- }
- }
- owners
- }
-
- fn sync_service_worker_related_pause_on_start_for_devtools(&self) {
- for browser_context in self.browser_contexts() {
- let policies = self
- .service_worker_auto_attach_related_owners
- .iter()
- .filter(|owner| {
- owner.browser_context_id == browser_context.id
- && owner.allow_service_worker_targets
- && owner.wait_for_debugger_on_start
- })
- .map(|owner| {
- (
- owner.registration_id,
- owner.base_version_id,
- owner.script_url.clone(),
- owner.scope_url.clone(),
- )
- })
- .collect::<Vec<_>>();
- browser_context
- .renderer_runtime()
- .set_service_worker_related_pause_on_start_policies_for_devtools(policies);
- }
- }
-
- pub(crate) fn set_service_worker_pause_on_start_owner(
- &mut self,
- session_id: Option<&str>,
- enabled: bool,
- ) -> bool {
- let key = session_id.map(str::to_owned);
- if enabled {
- self.service_worker_pause_on_start_owner_sessions
- .insert(key);
- } else {
- self.service_worker_pause_on_start_owner_sessions
- .remove(&key);
- }
- let pause = self.service_worker_pause_on_start_for_devtools();
- let runtimes = self
- .browser_contexts()
- .map(BrowserContext::renderer_runtime)
- .collect::<Vec<_>>();
- for runtime in runtimes {
- runtime.set_service_worker_pause_on_start_for_devtools(pause);
- }
- pause
- }
-
- pub(crate) fn service_worker_pause_on_start_for_devtools(&self) -> bool {
- !self.service_worker_pause_on_start_owner_sessions.is_empty()
- }
-
- pub(crate) fn set_dedicated_worker_pause_on_start_owner(
- &mut self,
- session_id: Option<&str>,
- enabled: bool,
- ) -> bool {
- let key = session_id.map(str::to_owned);
- if enabled {
- self.dedicated_worker_pause_on_start_owner_sessions
- .insert(key);
- } else {
- self.dedicated_worker_pause_on_start_owner_sessions
- .remove(&key);
- }
- self.dedicated_worker_pause_on_start_for_devtools()
- }
-
- pub(crate) fn dedicated_worker_pause_on_start_for_devtools(&self) -> bool {
- !self
- .dedicated_worker_pause_on_start_owner_sessions
- .is_empty()
- }
-
- #[cfg(test)]
- pub(crate) fn service_worker_pause_on_start_owner_count(&self) -> usize {
- self.service_worker_pause_on_start_owner_sessions.len()
- }
-
- pub(crate) fn shared_worker_target_for_session(
- &self,
- session_id: Option<&str>,
- ) -> Option<&SharedWorkerTargetState> {
- let session_id = session_id?;
- match self.session_route(Some(session_id))? {
- CdpSessionRoute::SharedWorkerTarget {
- browser_context_id,
- target_id,
- } => self
- .browser_context_by_id(&browser_context_id)?
- .shared_worker_target(&target_id),
- CdpSessionRoute::DedicatedWorkerTarget {
- browser_context_id,
- target_id,
- } => self
- .browser_context_by_id(&browser_context_id)?
- .dedicated_worker_target(&target_id)
- .map(|target| &target.inner),
- _ => None,
- }
- }
-
- /// Captures the exact renderer worker and protocol attachment addressed by
- /// `session_id`.
- ///
- /// The attachment scope lives with the SharedWorker target's per-session
- /// state. Holding this weak identity across a publication-capture boundary does
- /// not keep a normally detached session alive and cannot be rebound by a
- /// later current-session lookup.
- pub(crate) fn shared_worker_protocol_attachment_identity_for_session(
- &self,
- session_id: Option<&str>,
- ) -> Option<crate::conn::TargetSharedWorkerProtocolAttachmentIdentity> {
- let session_id = session_id?;
- let CdpSessionRoute::SharedWorkerTarget {
- browser_context_id,
- target_id,
- } = self.session_route(Some(session_id))?
- else {
- return None;
- };
- self.browser_context_by_id(&browser_context_id)?
- .shared_worker_target(&target_id)?
- .protocol_attachment_identity(&browser_context_id, session_id)
- }
-
- pub(crate) fn shared_worker_target_for_session_mut(
- &mut self,
- session_id: Option<&str>,
- ) -> Option<&mut SharedWorkerTargetState> {
- let session_id = session_id?;
- match self.session_route(Some(session_id))? {
- CdpSessionRoute::SharedWorkerTarget {
- browser_context_id,
- target_id,
- } => self
- .browser_context_by_id_mut(&browser_context_id)?
- .shared_worker_target_mut(&target_id),
- CdpSessionRoute::DedicatedWorkerTarget {
- browser_context_id,
- target_id,
- } => self
- .browser_context_by_id_mut(&browser_context_id)?
- .dedicated_worker_target_mut(&target_id)
- .map(|target| &mut target.inner),
- _ => None,
- }
- }
-
- pub(crate) fn dedicated_worker_target_for_session(
- &self,
- session_id: Option<&str>,
- ) -> Option<&crate::conn::DedicatedWorkerTargetState> {
- let session_id = session_id?;
- let CdpSessionRoute::DedicatedWorkerTarget {
- browser_context_id,
- target_id,
- } = self.session_route(Some(session_id))?
- else {
- return None;
- };
- self.browser_context_by_id(&browser_context_id)?
- .dedicated_worker_target(&target_id)
- }
-
- pub(crate) fn dedicated_worker_target_for_session_mut(
- &mut self,
- session_id: Option<&str>,
- ) -> Option<&mut crate::conn::DedicatedWorkerTargetState> {
- let session_id = session_id?;
- let CdpSessionRoute::DedicatedWorkerTarget {
- browser_context_id,
- target_id,
- } = self.session_route(Some(session_id))?
- else {
- return None;
- };
- self.browser_context_by_id_mut(&browser_context_id)?
- .dedicated_worker_target_mut(&target_id)
- }
-
- pub(crate) fn service_worker_target_for_session(
- &self,
- session_id: Option<&str>,
- ) -> Option<&ServiceWorkerTargetState> {
- let session_id = session_id?;
- let CdpSessionRoute::ServiceWorkerTarget {
- browser_context_id,
- target_id,
- } = self.session_route(Some(session_id))?
- else {
- return None;
- };
- self.browser_context_by_id(&browser_context_id)?
- .service_worker_target(&target_id)
- }
-
- pub(crate) fn service_worker_target_for_session_mut(
- &mut self,
- session_id: Option<&str>,
- ) -> Option<&mut ServiceWorkerTargetState> {
- let session_id = session_id?;
- let CdpSessionRoute::ServiceWorkerTarget {
- browser_context_id,
- target_id,
- } = self.session_route(Some(session_id))?
- else {
- return None;
- };
- self.browser_context_by_id_mut(&browser_context_id)?
- .service_worker_target_mut(&target_id)
- }
+pub(super) enum TargetSessionOwner {
+ ActiveTarget {
+ browser_context_id: String,
+ is_auxiliary_target_session: bool,
+ },
+ BackgroundTarget {
+ browser_context_id: String,
+ target_id: String,
+ is_auxiliary_target_session: bool,
+ },
+ NoLoadedBrowserContext,
+}
+impl CdpConnection {
pub(crate) fn with_background_target_session<R>(
&mut self,
session_id: Option<&str>,
@@ -1937,55 +112,3 @@ impl CdpConnection {
}
}
}
-
-fn browser_context_session_route(
- browser_context: &BrowserContext,
- session_id: &str,
-) -> Option<CdpSessionRoute> {
- if browser_context.active_session_id() == Some(session_id) {
- return Some(CdpSessionRoute::ActiveTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: browser_context.active_target_id().map(str::to_owned),
- });
- }
-
- if let Some(target_id) = browser_context.auxiliary_target_id_for_session(session_id) {
- return Some(CdpSessionRoute::AuxiliaryTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- });
- }
-
- browser_context
- .background_targets
- .iter()
- .find(|target| target.is_session(session_id))
- .map(|target| CdpSessionRoute::BackgroundTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target.target_id().to_owned(),
- })
- .or_else(|| {
- browser_context
- .shared_worker_target_id_for_session(session_id)
- .map(|target_id| CdpSessionRoute::SharedWorkerTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- })
- .or_else(|| {
- browser_context
- .dedicated_worker_target_id_for_session(session_id)
- .map(|target_id| CdpSessionRoute::DedicatedWorkerTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- })
- .or_else(|| {
- browser_context
- .service_worker_target_id_for_session(session_id)
- .map(|target_id| CdpSessionRoute::ServiceWorkerTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: target_id.to_owned(),
- })
- })
- })
- })
-}
diff --git a/moli-protocol/src/conn/target/activation.rs b/moli-protocol/src/conn/target/activation.rs
new file mode 100644
index 000000000..c79e2bae6
--- /dev/null
+++ b/moli-protocol/src/conn/target/activation.rs
@@ -0,0 +1,227 @@
+use moli_core::runtime::NavigationEngine;
+
+use crate::conn::{BackgroundProtocolEvent, BrowserContext, CdpConnection};
+
+/// The stable Target identities on both sides of one foreground selection.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct TargetActivationTransition {
+ promoted_target_id: String,
+ previous_active_target_id: Option<String>,
+}
+
+impl TargetActivationTransition {
+ pub(crate) fn new(
+ promoted_target_id: impl Into<String>,
+ previous_active_target_id: Option<String>,
+ ) -> Self {
+ Self {
+ promoted_target_id: promoted_target_id.into(),
+ previous_active_target_id,
+ }
+ }
+
+ fn promoted_target_id(&self) -> &str {
+ &self.promoted_target_id
+ }
+
+ fn previous_active_target_id(&self) -> Option<&str> {
+ self.previous_active_target_id.as_deref()
+ }
+
+ fn demoted_target_id(&self) -> Option<&str> {
+ self.previous_active_target_id()
+ .filter(|target_id| *target_id != self.promoted_target_id())
+ }
+
+ fn changed_active_target(&self) -> bool {
+ self.previous_active_target_id() != Some(self.promoted_target_id())
+ }
+}
+
+/// Successful target selection and the Page events caused by its surface move.
+///
+/// The events stay attached to the completion so every activation entry point
+/// must preserve their position relative to its own response or owner action.
+#[derive(Debug)]
+pub(crate) struct CompletedTargetActivation {
+ protocol_events: Vec<BackgroundProtocolEvent>,
+}
+
+impl CompletedTargetActivation {
+ fn new(protocol_events: Vec<BackgroundProtocolEvent>) -> Self {
+ Self { protocol_events }
+ }
+
+ pub(crate) fn into_protocol_events(self) -> Vec<BackgroundProtocolEvent> {
+ self.protocol_events
+ }
+}
+
+impl CdpConnection {
+ /// Completes the renderer-surface half of a foreground transition that was
+ /// staged synchronously while creating a new target.
+ pub(crate) async fn complete_staged_target_activation_async(
+ &mut self,
+ transition: &TargetActivationTransition,
+ ) -> CompletedTargetActivation {
+ let Some(demoted_target_id) = transition.demoted_target_id() else {
+ return CompletedTargetActivation::new(Vec::new());
+ };
+ let protocol_events = self
+ .page_screencast_session_ids_for_target(demoted_target_id)
+ .into_iter()
+ .map(|session_id| {
+ BackgroundProtocolEvent::page_screencast_visibility_changed(
+ session_id.as_deref(),
+ false,
+ )
+ })
+ .collect();
+ if let Err(error) = self
+ .apply_parked_target_surface_overrides_async(demoted_target_id)
+ .await
+ {
+ tracing::warn!(
+ target_id = demoted_target_id,
+ promoted_target_id = transition.promoted_target_id(),
+ %error,
+ "failed to update Page visibility after target activation"
+ );
+ }
+ CompletedTargetActivation::new(protocol_events)
+ }
+
+ pub(crate) fn handoff_navigation_engine_for_target_activation(&mut self, target_id: &str) {
+ let Some(browser_context) = self.browser_context.as_ref() else {
+ return;
+ };
+ let browser_context_id = browser_context.id.clone();
+ let renderer_runtime = browser_context.renderer_runtime_owner_access();
+ let navigation_runtime_config = self.engine.runtime_config();
+ let promoted_key = (browser_context_id.clone(), target_id.to_owned());
+ let promoted_engine = self
+ .retained_background_navigation_engines
+ .remove(&promoted_key);
+
+ let active_target_id = browser_context.active_target_id().map(str::to_owned);
+ let active_has_loaded_page = browser_context.has_loaded_page();
+ if let Some(active_target_id) = active_target_id
+ && active_has_loaded_page
+ {
+ let next_engine = promoted_engine.unwrap_or_else(|| {
+ NavigationEngine::new_with_runtime_config_and_browser_context_access(
+ navigation_runtime_config,
+ renderer_runtime.clone(),
+ )
+ .expect("active BrowserContext owner must be live")
+ });
+ self.apply_scheduler_senders_to_navigation_engine(&next_engine);
+ let active_engine = self.engine.replace(next_engine);
+ self.retain_background_navigation_engine(
+ browser_context_id,
+ active_target_id,
+ active_engine,
+ )
+ .expect("demoted active engine must retain its exact BrowserContext owner");
+ } else if let Some(promoted_engine) = promoted_engine {
+ self.replace_navigation_engine(promoted_engine);
+ }
+ }
+
+ pub(crate) fn handoff_navigation_engine_for_active_target_demotion(&mut self) {
+ let Some(browser_context) = self.browser_context.as_ref() else {
+ return;
+ };
+ let Some(active_target_id) = browser_context.active_target_id().map(str::to_owned) else {
+ return;
+ };
+ if !browser_context.has_loaded_page() {
+ return;
+ }
+
+ let browser_context_id = browser_context.id.clone();
+ let renderer_runtime = browser_context.renderer_runtime_owner_access();
+ let next_engine = NavigationEngine::new_with_runtime_config_and_browser_context_access(
+ self.engine.runtime_config(),
+ renderer_runtime,
+ )
+ .expect("active BrowserContext owner must be live");
+ self.apply_scheduler_senders_to_navigation_engine(&next_engine);
+ let active_engine = self.engine.replace(next_engine);
+ self.retain_background_navigation_engine(
+ browser_context_id,
+ active_target_id,
+ active_engine,
+ )
+ .expect("demoted active engine must retain its exact BrowserContext owner");
+ }
+
+ pub(crate) async fn promote_background_target_to_active_for_connection_async(
+ &mut self,
+ target_id: &str,
+ ) -> Result<Option<CompletedTargetActivation>, String> {
+ let previous_active_target_id = self
+ .browser_context
+ .as_ref()
+ .and_then(BrowserContext::active_target_id_owned);
+ let transition = TargetActivationTransition::new(target_id, previous_active_target_id);
+ let hidden_screencast_sessions = transition
+ .demoted_target_id()
+ .map(|active_target_id| self.page_screencast_session_ids_for_target(active_target_id))
+ .unwrap_or_default();
+ self.handoff_navigation_engine_for_target_activation(target_id);
+ let Some(browser_context) = self.browser_context.as_mut() else {
+ return Err("BrowserContextNotLoaded".to_owned());
+ };
+ let promoted = browser_context
+ .promote_background_target_to_active_slot_async(target_id)
+ .await?;
+ if !promoted {
+ return Ok(None);
+ }
+ self.refresh_active_browser_context_loader_async().await;
+ self.notify_target_host_activated(target_id);
+
+ let mut protocol_events = Vec::new();
+ if transition.changed_active_target() {
+ // Chromium's PageHandler reports RenderWidgetHost visibility only
+ // while that attachment has an active screencast. Hide the old
+ // surface before exposing the promoted one.
+ protocol_events.extend(hidden_screencast_sessions.into_iter().map(|session_id| {
+ BackgroundProtocolEvent::page_screencast_visibility_changed(
+ session_id.as_deref(),
+ false,
+ )
+ }));
+ protocol_events.extend(
+ self.page_screencast_session_ids_for_target(target_id)
+ .into_iter()
+ .map(|session_id| {
+ BackgroundProtocolEvent::page_screencast_visibility_changed(
+ session_id.as_deref(),
+ true,
+ )
+ }),
+ );
+ }
+ Ok(Some(CompletedTargetActivation::new(protocol_events)))
+ }
+
+ pub(crate) fn page_screencast_session_ids_for_target(
+ &mut self,
+ target_id: &str,
+ ) -> Vec<Option<String>> {
+ 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)
+ .into_iter()
+ .filter(|session_id| {
+ conn.target_page_session_state_for_session(session_id.as_deref())
+ .is_some_and(|state| state.page_screencast.is_active())
+ })
+ .collect()
+ }
+}
diff --git a/moli-protocol/src/conn/target/auto_attach_owner.rs b/moli-protocol/src/conn/target/auto_attach_owner.rs
new file mode 100644
index 000000000..21dd16624
--- /dev/null
+++ b/moli-protocol/src/conn/target/auto_attach_owner.rs
@@ -0,0 +1,94 @@
+use crate::conn::{AutoAttachOwnerPolicy, CdpConnection, CdpTargetFilter};
+
+impl CdpConnection {
+ fn sync_auto_attach_flags_from_owners(&mut self) {
+ self.auto_attach = !self.auto_attach_owner_sessions.is_empty();
+ self.auto_attach_wait_for_debugger_on_start = self
+ .auto_attach_owner_sessions
+ .values()
+ .any(|policy| policy.wait_for_debugger_on_start);
+ }
+
+ pub(crate) fn has_auto_attach_owner(&self, session_id: Option<&str>) -> bool {
+ self.auto_attach_owner_sessions
+ .contains_key(&session_id.map(str::to_owned))
+ }
+
+ pub(crate) fn auto_attach_owner_count(&self) -> usize {
+ self.auto_attach_owner_sessions.len()
+ }
+
+ pub(crate) fn auto_attach_owner_sessions_for_target_type(
+ &self,
+ target_type: &str,
+ ) -> Vec<Option<String>> {
+ if self.auto_attach_owner_sessions.is_empty() && self.auto_attach {
+ return CdpTargetFilter::default_auto_attach()
+ .matches(target_type)
+ .then_some(None)
+ .into_iter()
+ .collect();
+ }
+ self.auto_attach_owner_sessions
+ .iter()
+ .filter(|(_, policy)| policy.target_filter.matches(target_type))
+ .map(|(session_id, _)| session_id.clone())
+ .collect::<Vec<_>>()
+ }
+
+ pub(crate) fn auto_attach_owner_allows_target_type(
+ &self,
+ session_id: Option<&str>,
+ target_type: &str,
+ ) -> bool {
+ self.auto_attach_owner_sessions
+ .get(&session_id.map(str::to_owned))
+ .is_some_and(|policy| policy.target_filter.matches(target_type))
+ || (self.auto_attach_owner_sessions.is_empty()
+ && self.auto_attach
+ && CdpTargetFilter::default_auto_attach().matches(target_type))
+ }
+
+ pub(crate) fn auto_attach_owner_waits_for_debugger_on_start(
+ &self,
+ session_id: Option<&str>,
+ ) -> bool {
+ if self.auto_attach_owner_sessions.is_empty() && self.auto_attach {
+ return self.auto_attach_wait_for_debugger_on_start;
+ }
+ self.auto_attach_owner_sessions
+ .get(&session_id.map(str::to_owned))
+ .is_some_and(|policy| policy.wait_for_debugger_on_start)
+ }
+
+ pub(crate) fn set_auto_attach_owner(
+ &mut self,
+ session_id: Option<&str>,
+ enabled: bool,
+ wait_for_debugger_on_start: bool,
+ target_filter: CdpTargetFilter,
+ ) {
+ self.clear_service_worker_auto_attach_related_owner(session_id);
+ let key = session_id.map(str::to_owned);
+ if enabled {
+ self.target_control.ensure_owner(session_id);
+ self.auto_attach_owner_sessions.insert(
+ key,
+ AutoAttachOwnerPolicy {
+ wait_for_debugger_on_start,
+ target_filter,
+ },
+ );
+ } else {
+ self.auto_attach_owner_sessions.remove(&key);
+ }
+ self.sync_auto_attach_flags_from_owners();
+ }
+
+ pub(crate) fn clear_auto_attach_owner(&mut self, session_id: Option<&str>) {
+ self.clear_service_worker_auto_attach_related_owner(session_id);
+ let key = session_id.map(str::to_owned);
+ self.auto_attach_owner_sessions.remove(&key);
+ self.sync_auto_attach_flags_from_owners();
+ }
+}
diff --git a/moli-protocol/src/conn/target/mod.rs b/moli-protocol/src/conn/target/mod.rs
index 19691f268..e1c04bd8a 100644
--- a/moli-protocol/src/conn/target/mod.rs
+++ b/moli-protocol/src/conn/target/mod.rs
@@ -1,15 +1,23 @@
+mod activation;
+mod auto_attach_owner;
mod control;
mod graph;
mod host;
mod observer;
mod projection;
mod registry;
+mod route;
mod session;
+mod session_binding;
mod transaction;
+mod worker_auto_attach;
+mod worker_session;
+pub(crate) use activation::TargetActivationTransition;
pub(crate) use control::TargetControlPlane;
pub(crate) use observer::{TargetHandlerStore, target_destroyed_automation_events};
pub(crate) use registry::{TargetClosurePlan, TargetHostDelta, TargetRegistry};
+pub(crate) use route::{CdpSessionRoute, TargetHandlerAccessMode};
pub(crate) use session::{
CommittedAttachSession, DetachedTargetSession, PreparedAttachSession, TargetSessionRegistry,
};
diff --git a/moli-protocol/src/conn/target/route.rs b/moli-protocol/src/conn/target/route.rs
new file mode 100644
index 000000000..6b076d464
--- /dev/null
+++ b/moli-protocol/src/conn/target/route.rs
@@ -0,0 +1,402 @@
+use crate::conn::{BrowserContext, CdpConnection};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum TargetHandlerAccessMode {
+ Browser,
+ Regular,
+ AutoAttachOnly,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum CdpSessionRoute {
+ Browser,
+ TabTarget {
+ browser_context_id: String,
+ tab_target_id: String,
+ },
+ ActiveTarget {
+ browser_context_id: String,
+ target_id: Option<String>,
+ },
+ AuxiliaryTarget {
+ browser_context_id: String,
+ target_id: String,
+ },
+ BackgroundTarget {
+ browser_context_id: String,
+ target_id: String,
+ },
+ SharedWorkerTarget {
+ browser_context_id: String,
+ target_id: String,
+ },
+ DedicatedWorkerTarget {
+ browser_context_id: String,
+ target_id: String,
+ },
+ ServiceWorkerTarget {
+ browser_context_id: String,
+ target_id: String,
+ },
+}
+
+impl CdpSessionRoute {
+ pub(crate) fn browser_context_id(&self) -> Option<&str> {
+ match self {
+ Self::Browser => None,
+ Self::TabTarget {
+ browser_context_id, ..
+ }
+ | Self::ActiveTarget {
+ browser_context_id, ..
+ }
+ | Self::AuxiliaryTarget {
+ browser_context_id, ..
+ }
+ | Self::BackgroundTarget {
+ browser_context_id, ..
+ }
+ | Self::SharedWorkerTarget {
+ browser_context_id, ..
+ }
+ | Self::DedicatedWorkerTarget {
+ browser_context_id, ..
+ }
+ | Self::ServiceWorkerTarget {
+ browser_context_id, ..
+ } => Some(browser_context_id),
+ }
+ }
+
+ /// Whether Chromium installs a handler for this CDP domain on the routed
+ /// DevToolsAgentHost.
+ ///
+ /// Page and worker capability checks remain in their domain handlers for
+ /// now. Browser and Tab hosts are browser-only sessions in Chromium; they
+ /// must not fall through to whichever Page happens to be active.
+ pub(crate) fn supports_cdp_domain(&self, domain: &str) -> bool {
+ match self {
+ Self::Browser => matches!(
+ domain,
+ "Browser"
+ | "Fetch"
+ | "IO"
+ | "Security"
+ | "Storage"
+ | "SystemInfo"
+ | "Target"
+ | "Tracing"
+ ),
+ Self::TabTarget { .. } => matches!(domain, "IO" | "Target" | "Tracing"),
+ Self::ActiveTarget { .. }
+ | Self::AuxiliaryTarget { .. }
+ | Self::BackgroundTarget { .. }
+ | Self::SharedWorkerTarget { .. }
+ | Self::DedicatedWorkerTarget { .. }
+ | Self::ServiceWorkerTarget { .. } => true,
+ }
+ }
+
+ pub(crate) fn target_handler_access_mode(&self) -> TargetHandlerAccessMode {
+ match self {
+ Self::Browser => TargetHandlerAccessMode::Browser,
+ Self::TabTarget { .. }
+ | Self::ActiveTarget { .. }
+ | Self::AuxiliaryTarget { .. }
+ | Self::BackgroundTarget { .. } => TargetHandlerAccessMode::Regular,
+ Self::SharedWorkerTarget { .. }
+ | Self::DedicatedWorkerTarget { .. }
+ | Self::ServiceWorkerTarget { .. } => TargetHandlerAccessMode::AutoAttachOnly,
+ }
+ }
+}
+impl CdpConnection {
+ pub(crate) fn target_handler_access_mode(
+ &self,
+ session_id: Option<&str>,
+ ) -> TargetHandlerAccessMode {
+ let Some(session_id) = session_id else {
+ return TargetHandlerAccessMode::Browser;
+ };
+ self.session_route(Some(session_id))
+ .map(|route| route.target_handler_access_mode())
+ .unwrap_or(TargetHandlerAccessMode::Regular)
+ }
+
+ pub(crate) fn target_handler_may_get_target_info(
+ &self,
+ session_id: Option<&str>,
+ target_id: Option<&str>,
+ ) -> bool {
+ if self.target_handler_access_mode(session_id) != TargetHandlerAccessMode::AutoAttachOnly {
+ return true;
+ }
+ let Some(session_id) = session_id else {
+ return false;
+ };
+ let owner_target_id = self.non_browser_target_id_for_session(Some(session_id));
+ let Some(target_id) = target_id.or(owner_target_id.as_deref()) else {
+ return false;
+ };
+ owner_target_id.as_deref() == Some(target_id)
+ }
+
+ pub(crate) fn target_handler_may_close_target(
+ &self,
+ session_id: Option<&str>,
+ target_id: &str,
+ ) -> bool {
+ if self.target_handler_access_mode(session_id) != TargetHandlerAccessMode::AutoAttachOnly {
+ return true;
+ }
+ let Some(session_id) = session_id else {
+ return false;
+ };
+ self.non_browser_target_id_for_session(Some(session_id))
+ .as_deref()
+ == Some(target_id)
+ || self
+ .target_control
+ .auto_attached_target_ids_for_owner(Some(session_id))
+ .iter()
+ .any(|attached_target_id| attached_target_id == target_id)
+ }
+
+ pub(crate) fn session_route(&self, session_id: Option<&str>) -> Option<CdpSessionRoute> {
+ let session_id = session_id?;
+ if self.browser_session_ids.contains(session_id) {
+ return Some(CdpSessionRoute::Browser);
+ }
+ if let Some(tab_target_id) = self.tab_target_id_for_session_id(session_id)
+ && let Some(browser_context_id) =
+ self.browser_context_id_for_tab_target_id(tab_target_id)
+ {
+ return Some(CdpSessionRoute::TabTarget {
+ browser_context_id,
+ tab_target_id: tab_target_id.to_owned(),
+ });
+ }
+ self.browser_contexts()
+ .find_map(|bc| browser_context_session_route(bc, session_id))
+ }
+
+ pub(crate) fn target_session_route_for_target_id(
+ &self,
+ target_id: &str,
+ ) -> Option<CdpSessionRoute> {
+ if self
+ .primary_page_target_id_for_tab_target_id(target_id)
+ .is_some()
+ && let Some(browser_context_id) = self.browser_context_id_for_tab_target_id(target_id)
+ {
+ return Some(CdpSessionRoute::TabTarget {
+ browser_context_id,
+ tab_target_id: target_id.to_owned(),
+ });
+ }
+ self.browser_contexts().find_map(|browser_context| {
+ if browser_context.active_target_id() == Some(target_id) {
+ return Some(CdpSessionRoute::ActiveTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: None,
+ });
+ }
+ if browser_context.background_target(target_id).is_some() {
+ return Some(CdpSessionRoute::BackgroundTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ });
+ }
+ if browser_context.has_shared_worker_target(target_id) {
+ return Some(CdpSessionRoute::SharedWorkerTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ });
+ }
+ if browser_context.has_dedicated_worker_target(target_id) {
+ return Some(CdpSessionRoute::DedicatedWorkerTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ });
+ }
+ browser_context
+ .has_service_worker_target(target_id)
+ .then(|| CdpSessionRoute::ServiceWorkerTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ })
+ })
+ }
+
+ /// Returns the DevToolsAgentHost owned by a non-browser session.
+ ///
+ /// Chromium's Target domain uses its handler's `owner_target_id` when
+ /// `Target.getTargetInfo` omits `targetId`. A tab session therefore owns
+ /// the stable Tab target, while a page or worker session owns its exact
+ /// execution target.
+ pub(crate) fn non_browser_target_id_for_session(
+ &self,
+ session_id: Option<&str>,
+ ) -> Option<String> {
+ match self.session_route(session_id)? {
+ CdpSessionRoute::TabTarget {
+ tab_target_id: target_id,
+ ..
+ }
+ | CdpSessionRoute::AuxiliaryTarget { target_id, .. }
+ | CdpSessionRoute::BackgroundTarget { target_id, .. }
+ | CdpSessionRoute::SharedWorkerTarget { target_id, .. }
+ | CdpSessionRoute::DedicatedWorkerTarget { target_id, .. }
+ | CdpSessionRoute::ServiceWorkerTarget { target_id, .. }
+ | CdpSessionRoute::ActiveTarget {
+ target_id: Some(target_id),
+ ..
+ } => Some(target_id),
+ CdpSessionRoute::ActiveTarget {
+ browser_context_id,
+ target_id: None,
+ } => self
+ .browser_context_by_id(&browser_context_id)
+ .and_then(|browser_context| browser_context.active_target_id())
+ .map(str::to_owned),
+ CdpSessionRoute::Browser => None,
+ }
+ }
+
+ pub fn worker_target_id_for_session(&self, session_id: Option<&str>) -> Option<String> {
+ match self.session_route(session_id)? {
+ CdpSessionRoute::SharedWorkerTarget { target_id, .. }
+ | CdpSessionRoute::DedicatedWorkerTarget { target_id, .. }
+ | CdpSessionRoute::ServiceWorkerTarget { target_id, .. } => Some(target_id),
+ _ => None,
+ }
+ }
+
+ pub(crate) fn target_session_route_for_child_frame_id(
+ &self,
+ frame_id: &str,
+ ) -> Option<CdpSessionRoute> {
+ self.browser_contexts().find_map(|browser_context| {
+ if browser_context
+ .active_target
+ .owner_state
+ .has_attached_child_frame_id(frame_id)
+ {
+ return Some(CdpSessionRoute::ActiveTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: None,
+ });
+ }
+ browser_context
+ .background_targets
+ .iter()
+ .find_map(|target| {
+ browser_context
+ .parked_target_owner_state(target.target_id())
+ .is_some_and(|owner_state| {
+ owner_state.has_attached_child_frame_id(frame_id)
+ })
+ .then(|| CdpSessionRoute::BackgroundTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target.target_id().to_owned(),
+ })
+ })
+ })
+ }
+
+ pub(crate) fn has_attached_child_frame_id(&self, frame_id: &str) -> bool {
+ self.browser_contexts()
+ .any(|browser_context| browser_context.has_attached_child_frame_id(frame_id))
+ }
+
+ #[cfg(test)]
+ pub(crate) fn has_background_target_session(&self, session_id: Option<&str>) -> bool {
+ self.background_target_route(session_id).is_some()
+ }
+
+ #[cfg(test)]
+ pub(crate) fn background_target_id_for_session(
+ &self,
+ session_id: Option<&str>,
+ ) -> Option<String> {
+ self.background_target_route(session_id)
+ .map(|(_, target_id)| target_id)
+ }
+
+ pub(crate) fn background_target_route(
+ &self,
+ session_id: Option<&str>,
+ ) -> Option<(String, String)> {
+ match self.session_route(session_id)? {
+ CdpSessionRoute::BackgroundTarget {
+ browser_context_id,
+ target_id,
+ } => Some((browser_context_id, target_id)),
+ CdpSessionRoute::AuxiliaryTarget {
+ browser_context_id,
+ target_id,
+ } => self
+ .browser_context_by_id(&browser_context_id)?
+ .background_target(&target_id)
+ .is_some()
+ .then_some((browser_context_id, target_id)),
+ CdpSessionRoute::Browser
+ | CdpSessionRoute::TabTarget { .. }
+ | CdpSessionRoute::ActiveTarget { .. }
+ | CdpSessionRoute::SharedWorkerTarget { .. }
+ | CdpSessionRoute::DedicatedWorkerTarget { .. }
+ | CdpSessionRoute::ServiceWorkerTarget { .. } => None,
+ }
+ }
+}
+fn browser_context_session_route(
+ browser_context: &BrowserContext,
+ session_id: &str,
+) -> Option<CdpSessionRoute> {
+ if browser_context.active_session_id() == Some(session_id) {
+ return Some(CdpSessionRoute::ActiveTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: browser_context.active_target_id().map(str::to_owned),
+ });
+ }
+
+ if let Some(target_id) = browser_context.auxiliary_target_id_for_session(session_id) {
+ return Some(CdpSessionRoute::AuxiliaryTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ });
+ }
+
+ browser_context
+ .background_targets
+ .iter()
+ .find(|target| target.is_session(session_id))
+ .map(|target| CdpSessionRoute::BackgroundTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target.target_id().to_owned(),
+ })
+ .or_else(|| {
+ browser_context
+ .shared_worker_target_id_for_session(session_id)
+ .map(|target_id| CdpSessionRoute::SharedWorkerTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ })
+ .or_else(|| {
+ browser_context
+ .dedicated_worker_target_id_for_session(session_id)
+ .map(|target_id| CdpSessionRoute::DedicatedWorkerTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ })
+ .or_else(|| {
+ browser_context
+ .service_worker_target_id_for_session(session_id)
+ .map(|target_id| CdpSessionRoute::ServiceWorkerTarget {
+ browser_context_id: browser_context.id.clone(),
+ target_id: target_id.to_owned(),
+ })
+ })
+ })
+ })
+}
diff --git a/moli-protocol/src/conn/target/session_binding.rs b/moli-protocol/src/conn/target/session_binding.rs
new file mode 100644
index 000000000..4863962c5
--- /dev/null
+++ b/moli-protocol/src/conn/target/session_binding.rs
@@ -0,0 +1,1072 @@
+use crate::conn::CdpConnection;
+use crate::devtools_runtime::DevToolsTargetInfo;
+
+use super::{
+ CdpSessionRoute, PreparedTargetAttach, TargetAttachRollbackPlan, TargetAttachSessionCommit,
+ TargetAutoAttachedSessionDetachPlan, TargetBindingCleanupAction, TargetBindingCleanupPlan,
+ TargetClosureCleanupPlan, TargetEventPlan, TargetSessionDetachCleanupPlan,
+};
+
+impl CdpConnection {
+ pub(crate) fn is_browser_session_id(&self, session_id: Option<&str>) -> bool {
+ let Some(session_id) = session_id else {
+ return false;
+ };
+ self.browser_session_ids.contains(session_id)
+ }
+
+ #[cfg(test)]
+ pub(crate) fn register_browser_session(&mut self, session_id: String) {
+ self.browser_session_ids.insert(session_id);
+ }
+
+ pub(crate) fn remove_browser_session(&mut self, session_id: &str) -> bool {
+ self.browser_session_ids.remove(session_id)
+ }
+
+ fn clear_browser_session_owner_state(&mut self, session_id: &str) -> bool {
+ if !self.remove_browser_session(session_id) {
+ return false;
+ }
+ self.download_behavior
+ .set_browser_events_enabled_for_session(Some(session_id), false);
+ self.cancel_tracing_for_session_owner(Some(session_id));
+ self.clear_auto_attach_owner(Some(session_id));
+ self.clear_target_discovery_for_owner(Some(session_id));
+ self.set_service_worker_pause_on_start_owner(Some(session_id), false);
+ self.set_dedicated_worker_pause_on_start_owner(Some(session_id), false);
+ true
+ }
+
+ pub(crate) fn detach_browser_session_owner_without_event(
+ &mut self,
+ session_id: &str,
+ ) -> Option<TargetEventPlan> {
+ if !self.clear_browser_session_owner_state(session_id) {
+ return None;
+ }
+ let rollback_plan = self.rollback_attached_session_without_event(session_id);
+ Some(rollback_plan)
+ }
+
+ pub(crate) fn detach_browser_session_owner_event_plan(
+ &mut self,
+ session_id: &str,
+ ) -> Option<TargetEventPlan> {
+ let owner_session_id = self
+ .target_control
+ .attached_session_owner_session_id(session_id)
+ .map(str::to_owned);
+ if !self.clear_browser_session_owner_state(session_id) {
+ return None;
+ }
+ let plan = self.target_control.detach_attached_session_event_plan(
+ session_id,
+ None,
+ owner_session_id.as_deref(),
+ );
+ self.clear_detached_target_session_owner_state(session_id);
+ plan
+ }
+
+ pub(crate) fn release_root_target_frontend_owner_without_event(&mut self) {
+ self.download_behavior
+ .set_browser_events_enabled_for_session(None, false);
+ self.cancel_tracing_for_session_owner(None);
+ self.clear_auto_attach_owner(None);
+ self.clear_target_discovery_for_owner(None);
+ self.target_control.remove_owner(None);
+ }
+
+ pub(crate) fn release_primary_target_session_binding_without_event(
+ &mut self,
+ session_id: &str,
+ ) -> bool {
+ let released = self
+ .browser_context
+ .as_mut()
+ .is_some_and(|browser_context| {
+ browser_context
+ .release_primary_session_binding_preserving_frontend_state(session_id)
+ });
+ if released {
+ self.rollback_attached_session_without_event(session_id);
+ }
+ released
+ }
+
+ #[cfg(test)]
+ pub(crate) fn register_auto_attached_session(
+ &mut self,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ ) {
+ let target_id = self.non_browser_target_id_for_session(Some(&session_id));
+ self.register_auto_attached_session_for_target(
+ session_id,
+ owner_session_id,
+ target_id.as_deref(),
+ );
+ }
+
+ #[cfg(test)]
+ pub(crate) fn register_auto_attached_session_for_target(
+ &mut self,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ target_id: Option<&str>,
+ ) {
+ let route = self.session_route(Some(&session_id));
+ self.target_control.commit_auto_attached_session_for_target(
+ session_id,
+ owner_session_id,
+ target_id,
+ route,
+ false,
+ );
+ }
+
+ pub(crate) fn commit_prepared_attach_event_plan(
+ &mut self,
+ prepared: PreparedTargetAttach,
+ ) -> TargetEventPlan {
+ self.commit_prepared_attach_event_plan_with_attached_state_delta(prepared, true)
+ }
+
+ pub(crate) fn commit_prepared_dedicated_worker_attach_event_plan(
+ &mut self,
+ prepared: PreparedTargetAttach,
+ ) -> TargetEventPlan {
+ self.commit_prepared_attach_event_plan_with_attached_state_delta(prepared, false)
+ }
+
+ fn commit_prepared_attach_event_plan_with_attached_state_delta(
+ &mut self,
+ prepared: PreparedTargetAttach,
+ emit_attached_state_delta: bool,
+ ) -> TargetEventPlan {
+ let (target_id, target_info, sessions) = prepared.into_parts();
+ let should_emit_attached_state_delta = emit_attached_state_delta && !sessions.is_empty();
+ let attached_state_delta_plan = should_emit_attached_state_delta
+ .then(|| self.exact_target_info_changed_event_plan_for_target_delta(&target_id));
+ let mut plan = TargetEventPlan::default();
+ for session in sessions {
+ let (session_id, owner_session_id, route, auto_attached, waiting_for_debugger) =
+ session.into_parts();
+ if auto_attached {
+ self.target_control
+ .ensure_owner(owner_session_id.as_deref());
+ }
+ plan.extend(self.target_control.commit_attached_session_event(
+ session_id,
+ owner_session_id.as_deref(),
+ &target_id,
+ route,
+ auto_attached,
+ waiting_for_debugger,
+ target_info.clone(),
+ ));
+ }
+ if let Some(attached_state_delta_plan) = attached_state_delta_plan {
+ plan.extend(attached_state_delta_plan);
+ }
+ plan
+ }
+
+ pub(crate) fn prepare_auto_attach_session_commit(
+ &self,
+ session_id: impl Into<String>,
+ owner_session_id: Option<String>,
+ waiting_for_debugger: bool,
+ ) -> TargetAttachSessionCommit {
+ let session_id = session_id.into();
+ let route = self.session_route(Some(&session_id));
+ TargetAttachSessionCommit::auto_attached(session_id, owner_session_id, waiting_for_debugger)
+ .with_route(route)
+ }
+
+ pub(crate) fn prepare_direct_attach_session_commit(
+ &self,
+ session_id: impl Into<String>,
+ owner_session_id: Option<String>,
+ waiting_for_debugger: bool,
+ ) -> TargetAttachSessionCommit {
+ let session_id = session_id.into();
+ let route = self.session_route(Some(&session_id));
+ TargetAttachSessionCommit::direct(session_id, owner_session_id, waiting_for_debugger)
+ .with_route(route)
+ }
+
+ pub(crate) fn attach_tab_target_session_event_plan(
+ &mut self,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ tab_target_id: &str,
+ auxiliary: bool,
+ ) -> Result<TargetEventPlan, &'static str> {
+ if !self.assign_session_to_tab_target(tab_target_id, session_id.clone(), auxiliary) {
+ return Err("UnknownTargetId");
+ }
+ let prepared_session = self.prepare_direct_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ false,
+ );
+ let Some(target_info) = self.tab_target_info(tab_target_id) else {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("UnknownTargetId");
+ };
+ if prepared_session.route().is_none() {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("InvalidSessionId");
+ }
+ Ok(
+ self.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ tab_target_id,
+ target_info,
+ [prepared_session],
+ )),
+ )
+ }
+
+ pub(crate) fn attach_shared_worker_target_session_event_plan(
+ &mut self,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+ ) -> Result<TargetEventPlan, &'static str> {
+ let session_id_for_binding = session_id.clone();
+ let target_info = {
+ let Some(bc) = self.browser_context.as_mut() else {
+ return Err("BrowserContextNotLoaded");
+ };
+ if !bc.assign_session_to_shared_worker_target(target_id, session_id_for_binding) {
+ return Err("UnknownTargetId");
+ }
+ bc.devtools_target_info(target_id)
+ };
+ let prepared_session = self.prepare_direct_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ false,
+ );
+ let Some(target_info) = target_info else {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("UnknownTargetId");
+ };
+ if prepared_session.route().is_none() {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("InvalidSessionId");
+ }
+ Ok(
+ self.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ target_id,
+ target_info,
+ [prepared_session],
+ )),
+ )
+ }
+
+ pub(crate) fn attach_service_worker_target_session_event_plan(
+ &mut self,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+ ) -> Result<TargetEventPlan, &'static str> {
+ let session_id_for_binding = session_id.clone();
+ let target_info = {
+ let Some(bc) = self.browser_context.as_mut() else {
+ return Err("BrowserContextNotLoaded");
+ };
+ if !bc.assign_session_to_service_worker_target(target_id, session_id_for_binding) {
+ return Err("UnknownTargetId");
+ }
+ bc.devtools_target_info(target_id)
+ };
+ let prepared_session = self.prepare_direct_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ false,
+ );
+ let Some(target_info) = target_info else {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("UnknownTargetId");
+ };
+ if prepared_session.route().is_none() {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("InvalidSessionId");
+ }
+ Ok(
+ self.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ target_id,
+ target_info,
+ [prepared_session],
+ )),
+ )
+ }
+
+ pub(crate) fn attach_dedicated_worker_target_session_event_plan(
+ &mut self,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+ ) -> Result<TargetEventPlan, &'static str> {
+ let session_id_for_binding = session_id.clone();
+ let target_info = {
+ let Some(bc) = self.browser_context.as_mut() else {
+ return Err("BrowserContextNotLoaded");
+ };
+ if !bc.assign_session_to_dedicated_worker_target(target_id, session_id_for_binding) {
+ return Err("UnknownTargetId");
+ }
+ bc.devtools_target_info(target_id)
+ };
+ let prepared_session = self.prepare_direct_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ false,
+ );
+ let Some(target_info) = target_info else {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("UnknownTargetId");
+ };
+ if prepared_session.route().is_none() {
+ self.rollback_prepared_attach_session_sync_without_event(&prepared_session);
+ return Err("InvalidSessionId");
+ }
+ Ok(
+ self.commit_prepared_dedicated_worker_attach_event_plan(PreparedTargetAttach::new(
+ target_id,
+ target_info,
+ [prepared_session],
+ )),
+ )
+ }
+
+ pub(crate) fn prepare_auto_attached_tab_session_binding(
+ &mut self,
+ tab_target_id: &str,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ ) -> bool {
+ self.assign_session_to_tab_target(tab_target_id, session_id, owner_session_id.is_some())
+ }
+
+ pub(crate) fn prepare_auto_attached_page_session_binding(
+ &mut self,
+ target_id: &str,
+ session_id: String,
+ ) -> bool {
+ self.browser_context
+ .as_mut()
+ .is_some_and(|bc| bc.assign_auto_attached_session_to_target(target_id, session_id))
+ }
+
+ pub(crate) fn prepare_auto_attached_page_session_binding_in_browser_context(
+ &mut self,
+ browser_context_id: &str,
+ target_id: &str,
+ session_id: String,
+ ) -> bool {
+ self.browser_context_by_id_mut(browser_context_id)
+ .is_some_and(|bc| bc.assign_auto_attached_session_to_target(target_id, session_id))
+ }
+
+ pub(crate) fn prepare_auto_attached_shared_worker_session_binding(
+ &mut self,
+ target_id: &str,
+ session_id: String,
+ ) -> bool {
+ self.browser_context
+ .as_mut()
+ .is_some_and(|bc| bc.assign_session_to_shared_worker_target(target_id, session_id))
+ }
+
+ pub(crate) fn prepare_auto_attached_dedicated_worker_session_binding(
+ &mut self,
+ target_id: &str,
+ session_id: String,
+ ) -> bool {
+ self.browser_context
+ .as_mut()
+ .is_some_and(|bc| bc.assign_session_to_dedicated_worker_target(target_id, session_id))
+ }
+
+ pub(crate) fn prepare_auto_attached_service_worker_session_binding(
+ &mut self,
+ target_id: &str,
+ session_id: String,
+ ) -> bool {
+ self.browser_context
+ .as_mut()
+ .is_some_and(|bc| bc.assign_session_to_service_worker_target(target_id, session_id))
+ }
+
+ pub(crate) fn prepare_auto_attached_shared_worker_session_binding_info_in_browser_context(
+ &mut self,
+ browser_context_id: &str,
+ target_id: &str,
+ session_id: String,
+ ) -> Option<DevToolsTargetInfo> {
+ let bc = self.browser_context_by_id_mut(browser_context_id)?;
+ if !bc.assign_session_to_shared_worker_target(target_id, session_id) {
+ return None;
+ }
+ bc.devtools_target_info(target_id)
+ }
+
+ pub(crate) fn prepare_auto_attached_dedicated_worker_session_binding_info_in_browser_context(
+ &mut self,
+ browser_context_id: &str,
+ target_id: &str,
+ session_id: String,
+ ) -> Option<DevToolsTargetInfo> {
+ let bc = self.browser_context_by_id_mut(browser_context_id)?;
+ if !bc.assign_session_to_dedicated_worker_target(target_id, session_id) {
+ return None;
+ }
+ bc.devtools_target_info(target_id)
+ }
+
+ pub(crate) fn prepare_auto_attached_service_worker_session_binding_info_in_browser_context(
+ &mut self,
+ browser_context_id: &str,
+ target_id: &str,
+ session_id: String,
+ ) -> Option<DevToolsTargetInfo> {
+ let bc = self.browser_context_by_id_mut(browser_context_id)?;
+ if !bc.assign_session_to_service_worker_target(target_id, session_id) {
+ return None;
+ }
+ bc.devtools_target_info(target_id)
+ }
+
+ pub(crate) fn prepare_auto_attached_service_worker_session_binding_info(
+ &mut self,
+ target_id: &str,
+ session_id: String,
+ ) -> Option<DevToolsTargetInfo> {
+ let bc = self.browser_context.as_mut()?;
+ if !bc.assign_session_to_service_worker_target(target_id, session_id) {
+ return None;
+ }
+ bc.devtools_target_info(target_id)
+ }
+
+ pub(crate) fn commit_browser_attached_session_event_plan(
+ &mut self,
+ session_id: String,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+ target_info: DevToolsTargetInfo,
+ ) -> TargetEventPlan {
+ self.browser_session_ids.insert(session_id.clone());
+ self.target_control.commit_attached_session_event(
+ session_id,
+ owner_session_id,
+ target_id,
+ Some(CdpSessionRoute::Browser),
+ false,
+ false,
+ target_info,
+ )
+ }
+
+ pub(crate) fn rollback_attached_session_without_event(
+ &mut self,
+ session_id: &str,
+ ) -> TargetEventPlan {
+ let plan = self
+ .target_control
+ .rollback_attached_session_without_event(session_id);
+ for session_id in plan.rolled_back_session_ids() {
+ self.clear_detached_target_session_owner_state(session_id);
+ }
+ plan
+ }
+
+ pub(crate) fn detach_known_session_event_plan(
+ &mut self,
+ target_id: &str,
+ session_id: &str,
+ reason: Option<&str>,
+ parent_session_id: Option<&str>,
+ ) -> TargetEventPlan {
+ self.detach_known_session_event_plan_with_attached_state_delta(
+ target_id,
+ session_id,
+ reason,
+ parent_session_id,
+ true,
+ )
+ }
+
+ fn detach_known_session_event_plan_with_attached_state_delta(
+ &mut self,
+ target_id: &str,
+ session_id: &str,
+ reason: Option<&str>,
+ parent_session_id: Option<&str>,
+ emit_attached_state_delta: bool,
+ ) -> TargetEventPlan {
+ let attached_state_delta_plan = emit_attached_state_delta
+ .then(|| self.exact_target_info_changed_event_plan_for_target_delta(target_id));
+ let mut plan = self.target_control.detach_known_session_event_plan(
+ target_id,
+ session_id,
+ reason,
+ parent_session_id,
+ );
+ self.clear_detached_target_session_owner_state(session_id);
+ if let Some(attached_state_delta_plan) = attached_state_delta_plan {
+ plan.extend(attached_state_delta_plan);
+ }
+ plan
+ }
+
+ pub(crate) fn detach_target_closure_cleanup_event_plan(
+ &mut self,
+ cleanup_plan: TargetClosureCleanupPlan,
+ parent_session_id: Option<&str>,
+ ) -> TargetEventPlan {
+ let plan = self
+ .target_control
+ .detach_target_closure_cleanup_event_plan(cleanup_plan, parent_session_id);
+ for session in plan.detached_sessions() {
+ self.clear_detached_target_session_owner_state(session.session_id());
+ }
+ plan
+ }
+
+ pub(crate) async fn rollback_prepared_attach_session_without_event_async(
+ &mut self,
+ prepared: &TargetAttachSessionCommit,
+ ) -> TargetEventPlan {
+ self.rollback_attached_session_with_cleanup_without_event_async(
+ TargetAttachRollbackPlan::from_prepared_attach_session(prepared),
+ )
+ .await
+ }
+
+ pub(crate) fn rollback_prepared_attach_session_sync_without_event(
+ &mut self,
+ prepared: &TargetAttachSessionCommit,
+ ) -> TargetEventPlan {
+ self.rollback_attached_session_with_cleanup_without_event_sync(
+ TargetAttachRollbackPlan::from_prepared_attach_session(prepared),
+ )
+ }
+
+ fn rollback_attached_session_with_cleanup_without_event_sync(
+ &mut self,
+ rollback_plan: TargetAttachRollbackPlan,
+ ) -> TargetEventPlan {
+ if let Some(cleanup_plan) = rollback_plan.cleanup_plan() {
+ if matches!(
+ cleanup_plan.action(),
+ TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached
+ ) {
+ debug_assert!(
+ false,
+ "active target rollback requires async binding cleanup"
+ );
+ } else {
+ self.execute_target_binding_cleanup_without_event_sync(cleanup_plan);
+ }
+ }
+ self.rollback_attached_session_without_event(rollback_plan.session_id())
+ }
+
+ fn execute_target_binding_cleanup_without_event_sync(
+ &mut self,
+ cleanup_plan: &TargetBindingCleanupPlan,
+ ) {
+ match cleanup_plan.action() {
+ TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.clear_background_target_primary_auto_attached_session(
+ cleanup_plan.session_id(),
+ );
+ }
+ }
+ TargetBindingCleanupAction::AuxiliaryTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.remove_auxiliary_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::TabTarget { .. } => {
+ self.remove_tab_session(cleanup_plan.session_id());
+ }
+ TargetBindingCleanupAction::SharedWorkerTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.detach_shared_worker_target_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::DedicatedWorkerTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.detach_dedicated_worker_target_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::ServiceWorkerTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.detach_service_worker_target_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::None
+ | TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached => {}
+ }
+ }
+
+ async fn rollback_attached_session_with_cleanup_without_event_async(
+ &mut self,
+ rollback_plan: TargetAttachRollbackPlan,
+ ) -> TargetEventPlan {
+ let Some(browser_context_id) = rollback_plan.browser_context_id().map(str::to_owned) else {
+ return self.rollback_attached_session_without_event(rollback_plan.session_id());
+ };
+ if !self
+ .activate_browser_context_by_id_async(&browser_context_id)
+ .await
+ {
+ return self.rollback_attached_session_without_event(rollback_plan.session_id());
+ }
+
+ if let Some(cleanup_plan) = rollback_plan.cleanup_plan() {
+ self.execute_target_binding_cleanup_without_event_async(cleanup_plan)
+ .await;
+ }
+ self.rollback_attached_session_without_event(rollback_plan.session_id())
+ }
+
+ pub(crate) fn auto_attached_session_detach_plan(
+ &self,
+ session_id: &str,
+ ) -> TargetAutoAttachedSessionDetachPlan {
+ TargetAutoAttachedSessionDetachPlan::from_session_route(
+ session_id,
+ self.session_route(Some(session_id)),
+ )
+ }
+
+ pub(crate) fn rollback_auto_attached_session_detach_plan_without_event(
+ &mut self,
+ detach_plan: &TargetAutoAttachedSessionDetachPlan,
+ ) -> TargetEventPlan {
+ self.rollback_attached_session_without_event(detach_plan.session_id())
+ }
+
+ pub(crate) async fn execute_target_binding_cleanup_without_event_async(
+ &mut self,
+ cleanup_plan: &TargetBindingCleanupPlan,
+ ) {
+ match cleanup_plan.action() {
+ TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc
+ .clear_active_target_primary_auto_attached_session_async()
+ .await;
+ }
+ }
+ TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.clear_background_target_primary_auto_attached_session(
+ cleanup_plan.session_id(),
+ );
+ }
+ }
+ TargetBindingCleanupAction::AuxiliaryTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.remove_auxiliary_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::TabTarget { .. } => {
+ self.remove_tab_session(cleanup_plan.session_id());
+ }
+ TargetBindingCleanupAction::SharedWorkerTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.detach_shared_worker_target_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::DedicatedWorkerTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.detach_dedicated_worker_target_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::ServiceWorkerTarget { .. } => {
+ if let Some(bc) = self.browser_context.as_mut() {
+ let _ = bc.detach_service_worker_target_session(cleanup_plan.session_id());
+ }
+ }
+ TargetBindingCleanupAction::None => {}
+ }
+ }
+
+ pub(crate) async fn execute_target_binding_cleanup_for_session_without_event_async(
+ &mut self,
+ session_id: &str,
+ ) -> bool {
+ let Some(route) = self.session_route(Some(session_id)) else {
+ return false;
+ };
+ self.cancel_tracing_for_session_owner_async(Some(session_id))
+ .await;
+ let cleanup_plan = TargetBindingCleanupPlan::from_route(session_id, &route);
+ self.execute_target_binding_cleanup_without_event_async(&cleanup_plan)
+ .await;
+ true
+ }
+
+ pub(crate) async fn detach_session_with_binding_cleanup_event_plan_async(
+ &mut self,
+ cleanup_plan: TargetSessionDetachCleanupPlan,
+ ) -> TargetEventPlan {
+ let session_id = cleanup_plan.session_id().to_owned();
+ let target_id = cleanup_plan.target_id().to_owned();
+ let reason = cleanup_plan.reason().map(str::to_owned);
+ let parent_session_id = cleanup_plan
+ .parent_session_id()
+ .or_else(|| {
+ self.target_control
+ .attached_session_owner_session_id(&session_id)
+ })
+ .map(str::to_owned);
+ let _ = self
+ .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
+ .await;
+ self.detach_known_session_event_plan(
+ &target_id,
+ &session_id,
+ reason.as_deref(),
+ parent_session_id.as_deref(),
+ )
+ }
+
+ pub(crate) async fn detach_dedicated_worker_session_with_binding_cleanup_event_plan_async(
+ &mut self,
+ cleanup_plan: TargetSessionDetachCleanupPlan,
+ ) -> TargetEventPlan {
+ let session_id = cleanup_plan.session_id().to_owned();
+ let target_id = cleanup_plan.target_id().to_owned();
+ let reason = cleanup_plan.reason().map(str::to_owned);
+ let parent_session_id = cleanup_plan
+ .parent_session_id()
+ .or_else(|| {
+ self.target_control
+ .attached_session_owner_session_id(&session_id)
+ })
+ .map(str::to_owned);
+ let _ = self
+ .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
+ .await;
+ self.detach_known_session_event_plan_with_attached_state_delta(
+ &target_id,
+ &session_id,
+ reason.as_deref(),
+ parent_session_id.as_deref(),
+ false,
+ )
+ }
+
+ pub(crate) fn detach_dedicated_worker_session_after_target_removal_event_plan(
+ &mut self,
+ cleanup_plan: TargetSessionDetachCleanupPlan,
+ ) -> TargetEventPlan {
+ let parent_session_id = cleanup_plan
+ .parent_session_id()
+ .or_else(|| {
+ self.target_control
+ .attached_session_owner_session_id(cleanup_plan.session_id())
+ })
+ .map(str::to_owned);
+ self.detach_known_session_event_plan_with_attached_state_delta(
+ cleanup_plan.target_id(),
+ cleanup_plan.session_id(),
+ cleanup_plan.reason(),
+ parent_session_id.as_deref(),
+ false,
+ )
+ }
+
+ pub(crate) async fn detach_target_sessions_with_binding_cleanup_event_plan_async(
+ &mut self,
+ cleanup_plan: TargetClosureCleanupPlan,
+ parent_session_id: Option<&str>,
+ ) -> TargetEventPlan {
+ let target_id = cleanup_plan.target_id().to_owned();
+ let reason = cleanup_plan.reason().map(str::to_owned);
+ let session_ids = cleanup_plan
+ .session_ids()
+ .map(str::to_owned)
+ .collect::<Vec<_>>();
+ let mut plan = TargetEventPlan::default();
+ for session_id in session_ids {
+ if self
+ .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
+ .await
+ {
+ plan.extend(self.detach_known_session_event_plan(
+ &target_id,
+ &session_id,
+ reason.as_deref(),
+ parent_session_id,
+ ));
+ }
+ }
+ plan
+ }
+
+ pub(crate) async fn detach_active_target_session_binding_event_plan_async(
+ &mut self,
+ cleanup_plan: TargetSessionDetachCleanupPlan,
+ ) -> Result<TargetEventPlan, String> {
+ let session_id = cleanup_plan.session_id().to_owned();
+ let target_id = cleanup_plan.target_id().to_owned();
+ let reason = cleanup_plan.reason().map(str::to_owned);
+ let parent_session_id = cleanup_plan.parent_session_id().map(str::to_owned);
+ self.clear_active_target_session_binding_for_detach_async()
+ .await?;
+ Ok(self.detach_known_session_event_plan(
+ &target_id,
+ &session_id,
+ reason.as_deref(),
+ parent_session_id.as_deref(),
+ ))
+ }
+
+ pub(crate) async fn detach_background_target_session_binding_event_plan_async(
+ &mut self,
+ cleanup_plan: TargetSessionDetachCleanupPlan,
+ ) -> Result<Option<TargetEventPlan>, String> {
+ let session_id = cleanup_plan.session_id().to_owned();
+ let target_id = cleanup_plan.target_id().to_owned();
+ let reason = cleanup_plan.reason().map(str::to_owned);
+ let parent_session_id = cleanup_plan.parent_session_id().map(str::to_owned);
+ let Some(detached_target_id) = self
+ .clear_background_target_session_binding_for_detach_async(&session_id)
+ .await?
+ else {
+ return Ok(None);
+ };
+ debug_assert_eq!(detached_target_id, target_id);
+ Ok(Some(self.detach_known_session_event_plan(
+ &target_id,
+ &session_id,
+ reason.as_deref(),
+ parent_session_id.as_deref(),
+ )))
+ }
+
+ pub(crate) fn background_target_session_detach_cleanup_plans(
+ &self,
+ reason: Option<&str>,
+ parent_session_id: Option<&str>,
+ ) -> Vec<TargetSessionDetachCleanupPlan> {
+ self.browser_context
+ .as_ref()
+ .map(|bc| {
+ bc.background_targets
+ .iter()
+ .filter_map(|target| {
+ Some(TargetSessionDetachCleanupPlan::new(
+ target.target_id().to_owned(),
+ target.session_id()?.to_owned(),
+ reason,
+ parent_session_id,
+ ))
+ })
+ .collect()
+ })
+ .unwrap_or_default()
+ }
+
+ pub(crate) async fn clear_active_target_session_binding_for_detach_async(
+ &mut self,
+ ) -> Result<(), String> {
+ let Some(bc) = self.browser_context.as_mut() else {
+ return Ok(());
+ };
+ bc.clear_active_target_session_binding_and_scoped_state_async()
+ .await
+ }
+
+ pub(crate) async fn clear_background_target_session_binding_for_detach_async(
+ &mut self,
+ session_id: &str,
+ ) -> Result<Option<String>, String> {
+ let Some(bc) = self.browser_context.as_mut() else {
+ return Ok(None);
+ };
+ bc.clear_background_target_session_binding_and_scoped_state_async(session_id)
+ .await
+ }
+
+ pub(crate) async fn detach_all_shared_worker_target_sessions_event_plan_async(
+ &mut self,
+ reason: Option<&str>,
+ parent_session_id: Option<&str>,
+ ) -> TargetEventPlan {
+ let target_ids = self
+ .browser_context
+ .as_ref()
+ .map(|bc| {
+ bc.shared_worker_targets
+ .values()
+ .filter(|target| target.has_session())
+ .map(|target| target.target_id.clone())
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ let mut plan = TargetEventPlan::default();
+ for target_id in target_ids {
+ let session_ids = self
+ .browser_context
+ .as_ref()
+ .and_then(|bc| bc.shared_worker_target(&target_id))
+ .map(|target| target.session_ids())
+ .unwrap_or_default();
+ for session_id in session_ids {
+ if self
+ .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
+ .await
+ {
+ plan.extend(self.detach_known_session_event_plan(
+ &target_id,
+ &session_id,
+ reason,
+ parent_session_id,
+ ));
+ }
+ }
+ }
+ plan
+ }
+
+ pub(crate) async fn detach_all_service_worker_target_sessions_event_plan_async(
+ &mut self,
+ reason: Option<&str>,
+ parent_session_id: Option<&str>,
+ ) -> TargetEventPlan {
+ let target_ids = self
+ .browser_context
+ .as_ref()
+ .map(|bc| {
+ bc.service_worker_targets
+ .values()
+ .filter(|target| target.has_session())
+ .map(|target| target.target_id.clone())
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ let mut plan = TargetEventPlan::default();
+ for target_id in target_ids {
+ let session_ids = self
+ .browser_context
+ .as_ref()
+ .and_then(|bc| bc.service_worker_target(&target_id))
+ .map(|target| target.session_ids())
+ .unwrap_or_default();
+ for session_id in session_ids {
+ if self
+ .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
+ .await
+ {
+ plan.extend(self.detach_known_session_event_plan(
+ &target_id,
+ &session_id,
+ reason,
+ parent_session_id,
+ ));
+ }
+ }
+ }
+ plan
+ }
+
+ pub(crate) async fn detach_all_dedicated_worker_target_sessions_event_plan_async(
+ &mut self,
+ reason: Option<&str>,
+ parent_session_id: Option<&str>,
+ ) -> TargetEventPlan {
+ let target_ids = self
+ .browser_context
+ .as_ref()
+ .map(|bc| {
+ bc.dedicated_worker_targets
+ .values()
+ .filter(|target| target.has_session())
+ .map(|target| target.target_id.clone())
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ let mut plan = TargetEventPlan::default();
+ for target_id in target_ids {
+ let session_ids = self
+ .browser_context
+ .as_ref()
+ .and_then(|bc| bc.dedicated_worker_target(&target_id))
+ .map(|target| target.session_ids())
+ .unwrap_or_default();
+ for session_id in session_ids {
+ if self
+ .execute_target_binding_cleanup_for_session_without_event_async(&session_id)
+ .await
+ {
+ plan.extend(self.detach_known_session_event_plan(
+ &target_id,
+ &session_id,
+ reason,
+ parent_session_id,
+ ));
+ }
+ }
+ }
+ plan
+ }
+
+ fn clear_detached_target_session_owner_state(&mut self, session_id: &str) {
+ self.download_behavior
+ .set_browser_events_enabled_for_session(Some(session_id), false);
+ self.cancel_tracing_for_session_owner(Some(session_id));
+ self.clear_auto_attach_owner(Some(session_id));
+ self.set_service_worker_pause_on_start_owner(Some(session_id), false);
+ self.target_control.remove_owner(Some(session_id));
+ }
+
+ pub(crate) fn attached_sessions_for_target(&self, target_id: &str) -> Vec<String> {
+ self.target_control.attached_sessions_for_target(target_id)
+ }
+
+ pub(crate) fn target_has_waiting_for_debugger_session(&self, target_id: &str) -> bool {
+ self.target_control
+ .target_has_waiting_for_debugger_session(target_id)
+ }
+
+ pub(crate) fn auto_attached_sessions_for_owner(
+ &self,
+ owner_session_id: Option<&str>,
+ ) -> Vec<String> {
+ self.target_control
+ .auto_attached_sessions_for_owner(owner_session_id)
+ }
+
+ pub(crate) fn attached_session_cascade_for_owner(
+ &self,
+ owner_session_id: Option<&str>,
+ ) -> Vec<String> {
+ self.target_control
+ .attached_session_cascade_for_owner(owner_session_id)
+ }
+
+ pub(crate) fn attached_session_cascade_for_root_frontend(&self) -> Vec<String> {
+ self.target_control
+ .attached_session_cascade_for_root_frontend()
+ }
+
+ pub(crate) fn auto_attached_session_cascade_for_owner(
+ &self,
+ owner_session_id: Option<&str>,
+ ) -> Vec<String> {
+ self.target_control
+ .auto_attached_session_cascade_for_owner(owner_session_id)
+ }
+}
diff --git a/moli-protocol/src/conn/target/worker_auto_attach.rs b/moli-protocol/src/conn/target/worker_auto_attach.rs
new file mode 100644
index 000000000..4b058c777
--- /dev/null
+++ b/moli-protocol/src/conn/target/worker_auto_attach.rs
@@ -0,0 +1,188 @@
+use crate::conn::{
+ BrowserContext, CdpConnection, ServiceWorkerAutoAttachRelatedOwner,
+ ServiceWorkerAutoAttachRelatedOwnerSession,
+};
+
+impl CdpConnection {
+ pub(crate) fn set_service_worker_auto_attach_related_owner(
+ &mut self,
+ owner_session_id: Option<&str>,
+ browser_context_id: &str,
+ registration_id: u64,
+ base_version_id: u64,
+ script_url: String,
+ scope_url: String,
+ allow_service_worker_targets: bool,
+ wait_for_debugger_on_start: bool,
+ ) {
+ let owner_key = owner_session_id.map(str::to_owned);
+ self.service_worker_auto_attach_related_owners
+ .retain(|owner| {
+ !(owner.owner_session_id == owner_key
+ && owner.browser_context_id == browser_context_id
+ && owner.registration_id == registration_id
+ && owner.script_url == script_url
+ && owner.scope_url == scope_url)
+ });
+ self.service_worker_auto_attach_related_owners
+ .push(ServiceWorkerAutoAttachRelatedOwner {
+ owner_session_id: owner_key,
+ browser_context_id: browser_context_id.to_owned(),
+ registration_id,
+ base_version_id,
+ script_url,
+ scope_url,
+ allow_service_worker_targets,
+ wait_for_debugger_on_start,
+ });
+ self.sync_service_worker_related_pause_on_start_for_devtools();
+ }
+
+ pub(crate) fn replace_service_worker_auto_attach_related_owner(
+ &mut self,
+ owner_session_id: Option<&str>,
+ browser_context_id: &str,
+ registration_id: u64,
+ base_version_id: u64,
+ script_url: String,
+ scope_url: String,
+ allow_service_worker_targets: bool,
+ wait_for_debugger_on_start: bool,
+ ) {
+ self.clear_auto_attach_owner(owner_session_id);
+ self.set_service_worker_auto_attach_related_owner(
+ owner_session_id,
+ browser_context_id,
+ registration_id,
+ base_version_id,
+ script_url,
+ scope_url,
+ allow_service_worker_targets,
+ wait_for_debugger_on_start,
+ );
+ }
+
+ pub(crate) fn clear_service_worker_auto_attach_related_owner(
+ &mut self,
+ owner_session_id: Option<&str>,
+ ) {
+ let owner_key = owner_session_id.map(str::to_owned);
+ self.service_worker_auto_attach_related_owners
+ .retain(|owner| owner.owner_session_id != owner_key);
+ self.sync_service_worker_related_pause_on_start_for_devtools();
+ }
+
+ pub(crate) fn service_worker_auto_attach_related_owner_sessions_for_target(
+ &self,
+ browser_context_id: &str,
+ registration_id: u64,
+ version_id: u64,
+ script_url: &str,
+ scope_url: &str,
+ ) -> Vec<ServiceWorkerAutoAttachRelatedOwnerSession> {
+ let mut owners = Vec::new();
+ for owner in &self.service_worker_auto_attach_related_owners {
+ if !owner.allow_service_worker_targets
+ || owner.browser_context_id != browser_context_id
+ || owner.registration_id != registration_id
+ || version_id <= owner.base_version_id
+ || owner.script_url != script_url
+ || owner.scope_url != scope_url
+ {
+ continue;
+ }
+ if !owners
+ .iter()
+ .any(|existing: &ServiceWorkerAutoAttachRelatedOwnerSession| {
+ existing.owner_session_id == owner.owner_session_id
+ })
+ {
+ owners.push(ServiceWorkerAutoAttachRelatedOwnerSession {
+ owner_session_id: owner.owner_session_id.clone(),
+ wait_for_debugger_on_start: owner.wait_for_debugger_on_start,
+ });
+ }
+ }
+ owners
+ }
+
+ fn sync_service_worker_related_pause_on_start_for_devtools(&self) {
+ for browser_context in self.browser_contexts() {
+ let policies = self
+ .service_worker_auto_attach_related_owners
+ .iter()
+ .filter(|owner| {
+ owner.browser_context_id == browser_context.id
+ && owner.allow_service_worker_targets
+ && owner.wait_for_debugger_on_start
+ })
+ .map(|owner| {
+ (
+ owner.registration_id,
+ owner.base_version_id,
+ owner.script_url.clone(),
+ owner.scope_url.clone(),
+ )
+ })
+ .collect::<Vec<_>>();
+ browser_context
+ .renderer_runtime()
+ .set_service_worker_related_pause_on_start_policies_for_devtools(policies);
+ }
+ }
+
+ pub(crate) fn set_service_worker_pause_on_start_owner(
+ &mut self,
+ session_id: Option<&str>,
+ enabled: bool,
+ ) -> bool {
+ let key = session_id.map(str::to_owned);
+ if enabled {
+ self.service_worker_pause_on_start_owner_sessions
+ .insert(key);
+ } else {
+ self.service_worker_pause_on_start_owner_sessions
+ .remove(&key);
+ }
+ let pause = self.service_worker_pause_on_start_for_devtools();
+ let runtimes = self
+ .browser_contexts()
+ .map(BrowserContext::renderer_runtime)
+ .collect::<Vec<_>>();
+ for runtime in runtimes {
+ runtime.set_service_worker_pause_on_start_for_devtools(pause);
+ }
+ pause
+ }
+
+ pub(crate) fn service_worker_pause_on_start_for_devtools(&self) -> bool {
+ !self.service_worker_pause_on_start_owner_sessions.is_empty()
+ }
+
+ pub(crate) fn set_dedicated_worker_pause_on_start_owner(
+ &mut self,
+ session_id: Option<&str>,
+ enabled: bool,
+ ) -> bool {
+ let key = session_id.map(str::to_owned);
+ if enabled {
+ self.dedicated_worker_pause_on_start_owner_sessions
+ .insert(key);
+ } else {
+ self.dedicated_worker_pause_on_start_owner_sessions
+ .remove(&key);
+ }
+ self.dedicated_worker_pause_on_start_for_devtools()
+ }
+
+ pub(crate) fn dedicated_worker_pause_on_start_for_devtools(&self) -> bool {
+ !self
+ .dedicated_worker_pause_on_start_owner_sessions
+ .is_empty()
+ }
+
+ #[cfg(test)]
+ pub(crate) fn service_worker_pause_on_start_owner_count(&self) -> usize {
+ self.service_worker_pause_on_start_owner_sessions.len()
+ }
+}
diff --git a/moli-protocol/src/conn/target/worker_session.rs b/moli-protocol/src/conn/target/worker_session.rs
new file mode 100644
index 000000000..942710e4d
--- /dev/null
+++ b/moli-protocol/src/conn/target/worker_session.rs
@@ -0,0 +1,142 @@
+use crate::conn::{
+ CdpConnection, DedicatedWorkerTargetState, ServiceWorkerTargetState, SharedWorkerTargetState,
+ TargetSharedWorkerProtocolAttachmentIdentity,
+};
+
+use super::CdpSessionRoute;
+
+impl CdpConnection {
+ pub(crate) fn shared_worker_target_for_session(
+ &self,
+ session_id: Option<&str>,
+ ) -> Option<&SharedWorkerTargetState> {
+ let session_id = session_id?;
+ match self.session_route(Some(session_id))? {
+ CdpSessionRoute::SharedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } => self
+ .browser_context_by_id(&browser_context_id)?
+ .shared_worker_target(&target_id),
+ CdpSessionRoute::DedicatedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } => self
+ .browser_context_by_id(&browser_context_id)?
+ .dedicated_worker_target(&target_id)
+ .map(|target| &target.inner),
+ _ => None,
+ }
+ }
+
+ /// Captures the exact renderer worker and protocol attachment addressed by
+ /// `session_id`.
+ ///
+ /// The attachment scope lives with the SharedWorker target's per-session
+ /// state. Holding this weak identity across a publication-capture boundary does
+ /// not keep a normally detached session alive and cannot be rebound by a
+ /// later current-session lookup.
+ pub(crate) fn shared_worker_protocol_attachment_identity_for_session(
+ &self,
+ session_id: Option<&str>,
+ ) -> Option<TargetSharedWorkerProtocolAttachmentIdentity> {
+ let session_id = session_id?;
+ let CdpSessionRoute::SharedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } = self.session_route(Some(session_id))?
+ else {
+ return None;
+ };
+ self.browser_context_by_id(&browser_context_id)?
+ .shared_worker_target(&target_id)?
+ .protocol_attachment_identity(&browser_context_id, session_id)
+ }
+
+ pub(crate) fn shared_worker_target_for_session_mut(
+ &mut self,
+ session_id: Option<&str>,
+ ) -> Option<&mut SharedWorkerTargetState> {
+ let session_id = session_id?;
+ match self.session_route(Some(session_id))? {
+ CdpSessionRoute::SharedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } => self
+ .browser_context_by_id_mut(&browser_context_id)?
+ .shared_worker_target_mut(&target_id),
+ CdpSessionRoute::DedicatedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } => self
+ .browser_context_by_id_mut(&browser_context_id)?
+ .dedicated_worker_target_mut(&target_id)
+ .map(|target| &mut target.inner),
+ _ => None,
+ }
+ }
+
+ pub(crate) fn dedicated_worker_target_for_session(
+ &self,
+ session_id: Option<&str>,
+ ) -> Option<&DedicatedWorkerTargetState> {
+ let session_id = session_id?;
+ let CdpSessionRoute::DedicatedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } = self.session_route(Some(session_id))?
+ else {
+ return None;
+ };
+ self.browser_context_by_id(&browser_context_id)?
+ .dedicated_worker_target(&target_id)
+ }
+
+ pub(crate) fn dedicated_worker_target_for_session_mut(
+ &mut self,
+ session_id: Option<&str>,
+ ) -> Option<&mut DedicatedWorkerTargetState> {
+ let session_id = session_id?;
+ let CdpSessionRoute::DedicatedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } = self.session_route(Some(session_id))?
+ else {
+ return None;
+ };
+ self.browser_context_by_id_mut(&browser_context_id)?
+ .dedicated_worker_target_mut(&target_id)
+ }
+
+ pub(crate) fn service_worker_target_for_session(
+ &self,
+ session_id: Option<&str>,
+ ) -> Option<&ServiceWorkerTargetState> {
+ let session_id = session_id?;
+ let CdpSessionRoute::ServiceWorkerTarget {
+ browser_context_id,
+ target_id,
+ } = self.session_route(Some(session_id))?
+ else {
+ return None;
+ };
+ self.browser_context_by_id(&browser_context_id)?
+ .service_worker_target(&target_id)
+ }
+
+ pub(crate) fn service_worker_target_for_session_mut(
+ &mut self,
+ session_id: Option<&str>,
+ ) -> Option<&mut ServiceWorkerTargetState> {
+ let session_id = session_id?;
+ let CdpSessionRoute::ServiceWorkerTarget {
+ browser_context_id,
+ target_id,
+ } = self.session_route(Some(session_id))?
+ else {
+ return None;
+ };
+ self.browser_context_by_id_mut(&browser_context_id)?
+ .service_worker_target_mut(&target_id)
+ }
+}
diff --git a/moli-protocol/src/domains/target.rs b/moli-protocol/src/domains/target.rs
index f480d37e8..8de247378 100644
--- a/moli-protocol/src/domains/target.rs
+++ b/moli-protocol/src/domains/target.rs
@@ -13,17 +13,24 @@ use crate::domains::command_output::CommandOutputPlan;
use super::page;
+mod activation;
mod attachment;
+mod auto_attach;
mod browser_context;
mod browser_context_disposal;
+mod closing;
+mod creation;
mod events;
-mod lifecycle;
+mod info;
+mod popup;
+#[cfg(test)]
+mod protocol_neutral_tests;
#[cfg(test)]
mod tests;
mod worker_target;
pub(in crate::domains) use browser_context::devtools_client_window_info_for_target;
-pub(crate) use lifecycle::{
+pub(crate) use popup::{
PopupTargetCreation, PopupTargetOpenerIdentity, complete_popup_target_activation_action_async,
complete_popup_target_navigation_owner_action_async,
create_popup_target_from_renderer_output_background_events_async,
@@ -280,7 +287,7 @@ impl CdpConnection {
let _ = self
.detach_runtime_inspector_session_for_session_owner_async(None)
.await;
- lifecycle::release_attached_sessions_for_root_frontend_async(
+ auto_attach::release_attached_sessions_for_root_frontend_async(
self,
&mut side_effects,
&mut command_context,
@@ -313,7 +320,7 @@ enum PendingTargetCommandKind {
},
CreateTarget {
response_plan: CommandOutputPlan,
- protocol_events: lifecycle::CreatedTargetProtocolEvents,
+ creation_commit: creation::TargetCreationCommit,
initial_document_route: Option<crate::conn::CdpSessionRoute>,
initial_document: Option<Box<crate::conn::PendingInitialDocumentPageBuild>>,
},
@@ -354,7 +361,7 @@ enum CompletedTargetCommandKind {
},
CreateTarget {
response_plan: CommandOutputPlan,
- protocol_events: lifecycle::CreatedTargetProtocolEvents,
+ creation_commit: creation::TargetCreationCommit,
initial_document_route: Option<crate::conn::CdpSessionRoute>,
initial_document: Option<
Result<
@@ -408,12 +415,12 @@ impl PendingTargetCommandDispatch {
},
PendingTargetCommandKind::CreateTarget {
response_plan,
- protocol_events,
+ creation_commit,
initial_document_route,
initial_document,
} => CompletedTargetCommandKind::CreateTarget {
response_plan,
- protocol_events,
+ creation_commit,
initial_document_route,
initial_document: match initial_document {
Some(pending) => Some(pending.wait().await.map(Box::new)),
@@ -479,7 +486,7 @@ pub(crate) fn try_start_target_command_dispatch(
Some(TargetAction::CreateBrowserContext) => Some(TargetCommandTaskStep::Complete(
browser_context::create_browser_context(conn, cmd),
)),
- Some(TargetAction::CreateTarget) => Some(lifecycle::start_create_target_command(conn, cmd)),
+ Some(TargetAction::CreateTarget) => Some(creation::start_create_target_command(conn, cmd)),
Some(TargetAction::AttachToTarget) => {
Some(attachment::start_attach_to_target_command(conn, cmd))
}
@@ -487,24 +494,24 @@ pub(crate) fn try_start_target_command_dispatch(
attachment::attach_to_browser_target_command(conn, cmd),
)),
Some(TargetAction::GetTargetInfo) => Some(TargetCommandTaskStep::Complete(
- lifecycle::get_target_info(conn, cmd),
+ info::get_target_info(conn, cmd),
)),
Some(TargetAction::SetDiscoverTargets) => Some(TargetCommandTaskStep::Complete(
set_discover_targets(conn, cmd),
)),
Some(TargetAction::ActivateTarget) => {
- Some(lifecycle::start_activate_target_command(conn, cmd))
+ Some(activation::start_activate_target_command(conn, cmd))
}
Some(TargetAction::SetAutoAttach) => {
- Some(lifecycle::start_set_auto_attach_command(conn, cmd))
+ Some(auto_attach::start_set_auto_attach_command(conn, cmd))
}
Some(TargetAction::AutoAttachRelated) => Some(TargetCommandTaskStep::Complete(
- lifecycle::auto_attach_related(conn, cmd),
+ auto_attach::auto_attach_related(conn, cmd),
)),
Some(TargetAction::DetachFromTarget) => {
Some(attachment::start_detach_from_target_command(cmd))
}
- Some(TargetAction::CloseTarget) => Some(lifecycle::start_close_target_command(conn, cmd)),
+ Some(TargetAction::CloseTarget) => Some(closing::start_close_target_command(conn, cmd)),
Some(TargetAction::DisposeBrowserContext) => {
Some(browser_context::start_dispose_browser_context_command(cmd))
}
@@ -522,14 +529,14 @@ fn start_devtools_target_command(
command: DevToolsCommand,
) -> TargetCommandTaskStep {
match command {
- DevToolsCommand::CreateTarget(command) => lifecycle::start_devtools_create_target_command(
+ DevToolsCommand::CreateTarget(command) => creation::start_devtools_create_target_command(
conn,
command_id,
command_session_id,
command,
),
DevToolsCommand::CloseTarget(command) => {
- lifecycle::start_devtools_close_target_command(command_id, command_session_id, command)
+ closing::start_devtools_close_target_command(command_id, command_session_id, command)
}
DevToolsCommand::ActivateTarget(command) => {
pending_activate_target_command(command_id, command_session_id, command)
@@ -571,7 +578,7 @@ fn start_devtools_target_command(
)),
),
DevToolsCommand::GetTargetInfo(command) => TargetCommandTaskStep::Complete(
- lifecycle::start_devtools_get_target_info_command(conn, command),
+ info::start_devtools_get_target_info_command(conn, command),
),
_ => target_command_error(-32000, "UnsupportedDevToolsCommand"),
}
@@ -586,7 +593,7 @@ pub(crate) fn execute_immediate_devtools_target_command_with_protocol_events(
) {
match command {
DevToolsCommand::CreateTarget(command) => {
- let result = lifecycle::execute_devtools_create_target_command(conn, command)
+ let result = creation::execute_devtools_create_target_command(conn, command)
.map(|execution| DevToolsCommandResult::CreateTarget(execution.result));
(result, Vec::new())
}
@@ -617,7 +624,7 @@ pub(crate) fn execute_immediate_devtools_target_command_with_protocol_events(
Vec::new(),
),
DevToolsCommand::GetTargetInfo(command) => (
- lifecycle::execute_devtools_get_target_info_command(conn, command)
+ info::execute_devtools_get_target_info_command(conn, command)
.map(DevToolsCommandResult::GetTargetInfo),
Vec::new(),
),
@@ -639,25 +646,27 @@ pub(crate) async fn execute_devtools_create_target_command_async_with_protocol_e
Vec<crate::conn::BackgroundProtocolEvent>,
Option<moli_core::RendererOutputFence>,
) {
- let execution = match lifecycle::execute_devtools_create_target_command(conn, command) {
+ let execution = match creation::execute_devtools_create_target_command(conn, command) {
Ok(execution) => execution,
Err(error) => return (Err(error), Vec::new(), None),
};
let result = execution.result;
+ let creation_commit = execution.commit;
let mut protocol_events = Vec::new();
let (initial_document_events, renderer_output_predecessor) = conn
.ensure_created_target_initial_document_page(&result.target_id)
.await;
protocol_events.extend(initial_document_events);
- protocol_events.extend(
- lifecycle::synchronize_created_target_activation_async(conn, &execution.protocol_events)
- .await,
- );
- if let Err(error) = lifecycle::emit_created_target_protocol_events(
- conn,
- execution.protocol_events,
- &mut protocol_events,
- ) {
+ if let Some(activation) = creation_commit.activation() {
+ protocol_events.extend(
+ conn.complete_staged_target_activation_async(activation)
+ .await
+ .into_protocol_events(),
+ );
+ }
+ if let Err(error) =
+ creation::emit_target_creation_protocol_events(conn, creation_commit, &mut protocol_events)
+ {
return (Err(error), Vec::new(), renderer_output_predecessor);
}
(
@@ -678,7 +687,7 @@ pub(crate) async fn execute_devtools_target_command_async_with_protocol_events(
DevToolsCommand::CloseTarget(command) => {
let mut command_context = crate::conn::CommandDispatchContext::default();
let mut side_effects = events::TargetProtocolSideEffects::default();
- let result = lifecycle::execute_devtools_close_target_command_async(
+ let result = closing::execute_devtools_close_target_command_async(
conn,
command,
&mut side_effects,
@@ -691,7 +700,7 @@ pub(crate) async fn execute_devtools_target_command_async_with_protocol_events(
(result, protocol_events)
}
DevToolsCommand::ActivateTarget(command) => {
- match lifecycle::execute_devtools_activate_target_command_async(conn, command).await {
+ match activation::execute_devtools_activate_target_command_async(conn, command).await {
Ok(events) => (Ok(DevToolsCommandResult::Empty), events),
Err(error) => (Err(error), Vec::new()),
}
@@ -725,21 +734,21 @@ pub(crate) async fn execute_devtools_target_command_async_with_protocol_events(
}
}
-async fn created_target_response_plan_after_initial_document(
+async fn target_creation_response_plan_after_initial_document(
conn: &mut CdpConnection,
response_plan: CommandOutputPlan,
- protocol_events: lifecycle::CreatedTargetProtocolEvents,
+ creation_commit: creation::TargetCreationCommit,
activation_events: Vec<BackgroundProtocolEvent>,
) -> CommandOutputPlan {
- let target_id = protocol_events.page_target_id().to_owned();
+ let target_id = creation_commit.page_target_id().to_owned();
let mut plan = CommandOutputPlan::default();
let mut events = activation_events;
if let Err(error) =
- lifecycle::emit_created_target_protocol_events(conn, protocol_events, &mut events)
+ creation::emit_target_creation_protocol_events(conn, creation_commit, &mut events)
{
return CommandOutputPlan::from_devtools_error(error);
}
- lifecycle::start_target_url_navigation_if_allowed_background_events_async(
+ popup::start_target_url_navigation_if_allowed_background_events_async(
conn,
&mut events,
&target_id,
@@ -776,7 +785,7 @@ pub(crate) async fn complete_pending_target_command(
}
CompletedTargetCommandKind::ActivateTarget { command } => {
return TargetCommandTaskStep::Complete(
- lifecycle::complete_activate_target_command_async(conn, command).await,
+ activation::complete_activate_target_command_async(conn, command).await,
);
}
CompletedTargetCommandKind::SetAutoAttach {
@@ -785,7 +794,7 @@ pub(crate) async fn complete_pending_target_command(
legacy_disable_all,
} => {
return TargetCommandTaskStep::Complete(
- lifecycle::complete_set_auto_attach_command_async(
+ auto_attach::complete_set_auto_attach_command_async(
conn,
auto_attach,
owner_session_id.as_deref(),
@@ -797,13 +806,17 @@ pub(crate) async fn complete_pending_target_command(
}
CompletedTargetCommandKind::CreateTarget {
response_plan,
- protocol_events,
+ creation_commit,
initial_document_route,
initial_document,
} => {
- let activation_events =
- lifecycle::synchronize_created_target_activation_async(conn, &protocol_events)
- .await;
+ let activation_events = if let Some(activation) = creation_commit.activation() {
+ conn.complete_staged_target_activation_async(activation)
+ .await
+ .into_protocol_events()
+ } else {
+ Vec::new()
+ };
match initial_document {
Some(Ok(completed_initial_document)) => {
let completed_initial_document = *completed_initial_document;
@@ -843,10 +856,10 @@ pub(crate) async fn complete_pending_target_command(
None => {}
}
TargetCommandTaskStep::Complete(
- created_target_response_plan_after_initial_document(
+ target_creation_response_plan_after_initial_document(
conn,
response_plan,
- protocol_events,
+ creation_commit,
activation_events,
)
.await,
@@ -869,8 +882,7 @@ pub(crate) async fn complete_pending_target_command(
}
CompletedTargetCommandKind::CloseTarget { command } => {
return TargetCommandTaskStep::Complete(
- lifecycle::complete_close_target_command_async(conn, command, command_context)
- .await,
+ closing::complete_close_target_command_async(conn, command, command_context).await,
);
}
CompletedTargetCommandKind::DisposeBrowserContext { browser_context_id } => {
diff --git a/moli-protocol/src/domains/target/activation.rs b/moli-protocol/src/domains/target/activation.rs
new file mode 100644
index 000000000..194d95ffc
--- /dev/null
+++ b/moli-protocol/src/domains/target/activation.rs
@@ -0,0 +1,167 @@
+use serde::Deserialize;
+
+use crate::devtools_runtime::DevToolsTargetId;
+
+use super::*;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct ActivateTargetParams {
+ pub(super) target_id: String,
+}
+
+pub(super) fn start_activate_target_command(
+ conn: &mut CdpConnection,
+ cmd: &Cmd<'_>,
+) -> TargetCommandTaskStep {
+ let params: ActivateTargetParams = match cmd.get_params() {
+ Ok(Some(params)) => params,
+ _ => {
+ return super::target_command_error(-32602, "InvalidParams");
+ }
+ };
+ let command = build_cdp_activate_target_command(cmd, params);
+ super::start_devtools_target_command(
+ conn,
+ cmd.id,
+ cmd.session_id,
+ DevToolsCommand::ActivateTarget(command),
+ )
+}
+
+pub(super) fn build_cdp_activate_target_command(
+ cmd: &Cmd<'_>,
+ params: ActivateTargetParams,
+) -> DevToolsActivateTargetCommand {
+ DevToolsActivateTargetCommand {
+ context: cmd
+ .devtools_command_context(Some(params.target_id.as_str()), Option::<&str>::None),
+ target_id: DevToolsTargetId::from(params.target_id),
+ }
+}
+
+pub(super) async fn complete_activate_target_command_async(
+ conn: &mut CdpConnection,
+ command: DevToolsActivateTargetCommand,
+) -> CommandOutputPlan {
+ match execute_devtools_activate_target_command_async(conn, command).await {
+ Ok(events) => {
+ let mut plan = CommandOutputPlan::default();
+ plan.extend_background_events(events);
+ plan.push_success();
+ plan
+ }
+ Err(error) => CommandOutputPlan::from_devtools_error(error),
+ }
+}
+
+pub(super) async fn execute_devtools_activate_target_command_async(
+ conn: &mut CdpConnection,
+ command: DevToolsActivateTargetCommand,
+) -> Result<Vec<BackgroundProtocolEvent>, DevToolsError> {
+ let target_id = conn
+ .primary_page_target_id_for_tab_target_id(command.target_id.as_str())
+ .map(str::to_owned)
+ .unwrap_or_else(|| command.target_id.as_str().to_owned());
+ let previously_active_browser_context_id = previously_active_browser_context_id(conn);
+ if let Err(message) = select_browser_context_for_target(conn, &target_id) {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Err(DevToolsError::new(DevToolsErrorKind::NoSuchTarget, message));
+ }
+ let bc = match conn.browser_context.as_ref() {
+ Some(bc) => bc,
+ None => {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "BrowserContextNotLoaded",
+ ));
+ }
+ };
+ if bc.has_shared_worker_target(&target_id) {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Ok(Vec::new());
+ }
+ if bc.has_dedicated_worker_target(&target_id) {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Ok(Vec::new());
+ }
+ if bc.has_service_worker_target(&target_id) {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Ok(Vec::new());
+ }
+ if !bc.has_active_target() && bc.background_targets.is_empty() {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "TargetNotLoaded",
+ ));
+ }
+ let protocol_events = if !matches!(
+ bc.active_target_identity(),
+ Some((ref active_target_id, _)) if active_target_id == &target_id
+ ) && bc.background_target(&target_id).is_some()
+ {
+ match conn
+ .promote_background_target_to_active_for_connection_async(&target_id)
+ .await
+ {
+ Ok(Some(activation)) => activation.into_protocol_events(),
+ Ok(None) => {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "UnknownTargetId",
+ ));
+ }
+ Err(message) => {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Err(DevToolsError::new(DevToolsErrorKind::NoSuchTarget, message));
+ }
+ }
+ } else if !matches!(
+ bc.active_target_identity(),
+ Some((ref active_target_id, _)) if active_target_id == &target_id
+ ) {
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "UnknownTargetId",
+ ));
+ } else {
+ Vec::new()
+ };
+
+ restore_previously_active_browser_context(
+ conn,
+ previously_active_browser_context_id.as_deref(),
+ );
+ Ok(protocol_events)
+}
diff --git a/moli-protocol/src/domains/target/attachment.rs b/moli-protocol/src/domains/target/attachment.rs
index d9fca9988..38cd8b36b 100644
--- a/moli-protocol/src/domains/target/attachment.rs
+++ b/moli-protocol/src/domains/target/attachment.rs
@@ -578,7 +578,7 @@ async fn detach_from_target_inner_async(
}
if let Some(session_id) = params.session_id.as_deref() {
- super::lifecycle::detach_attached_sessions_for_owner_async(
+ super::auto_attach::detach_attached_sessions_for_owner_async(
conn,
out.target_events_mut(),
Some(session_id),
@@ -651,7 +651,7 @@ async fn detach_from_target_inner_async(
let _ = conn
.detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
.await;
- super::lifecycle::clear_emulated_media_for_detached_session_best_effort(conn, session_id)
+ super::auto_attach::clear_emulated_media_for_detached_session_best_effort(conn, session_id)
.await;
super::clear_detached_target_fetch_state_background_events_async(
conn,
diff --git a/moli-protocol/src/domains/target/auto_attach.rs b/moli-protocol/src/domains/target/auto_attach.rs
new file mode 100644
index 000000000..0d84c2aac
--- /dev/null
+++ b/moli-protocol/src/domains/target/auto_attach.rs
@@ -0,0 +1,1415 @@
+use serde::Deserialize;
+
+use crate::conn::{CdpTargetFilter, CdpTargetFilterEntry, PreparedTargetAttach};
+
+use super::*;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AutoAttachParams {
+ auto_attach: bool,
+ #[serde(rename = "waitForDebuggerOnStart")]
+ wait_for_debugger_on_start: bool,
+ flatten: Option<bool>,
+ filter: Option<Vec<TargetFilterEntry>>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AutoAttachRelatedParams {
+ target_id: String,
+ #[serde(rename = "waitForDebuggerOnStart")]
+ wait_for_debugger_on_start: bool,
+ filter: Option<Vec<TargetFilterEntry>>,
+}
+
+#[derive(Deserialize)]
+struct TargetFilterEntry {
+ #[serde(default)]
+ exclude: bool,
+ #[serde(rename = "type")]
+ target_type: Option<String>,
+}
+
+#[derive(Debug)]
+struct ServiceWorkerAutoAttachRelatedTarget {
+ target_id: String,
+ browser_context_id: String,
+ registration_id: u64,
+ version_id: u64,
+ script_url: String,
+ scope_url: String,
+}
+
+pub(super) fn auto_attach_related(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {
+ let params: AutoAttachRelatedParams = match cmd.get_params() {
+ Ok(Some(p)) => p,
+ _ => {
+ return CommandOutputPlan::error_without_session(-32602, "InvalidParams");
+ }
+ };
+ if cmd.session_id.is_some() && !conn.is_browser_session_id(cmd.session_id) {
+ return CommandOutputPlan::error_without_session(
+ -32000,
+ "Target.autoAttachRelated is only supported on the Browser target",
+ );
+ }
+
+ let restore_browser_context_id = previously_active_browser_context_id(conn);
+ let target = match service_worker_auto_attach_related_target(conn, params.target_id.as_str()) {
+ Ok(target) => target,
+ Err(plan) => {
+ restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
+ return plan;
+ }
+ };
+ let allow_service_worker_targets =
+ cdp_target_filter_from_entries(params.filter).matches("service_worker");
+ conn.replace_service_worker_auto_attach_related_owner(
+ cmd.session_id,
+ &target.browser_context_id,
+ target.registration_id,
+ target.version_id,
+ target.script_url,
+ target.scope_url,
+ allow_service_worker_targets,
+ params.wait_for_debugger_on_start,
+ );
+ let mut plan = CommandOutputPlan::default();
+ if allow_service_worker_targets
+ && !owner_already_auto_attached_to_target(conn, cmd.session_id, &target.target_id)
+ && let Some((session_id, target_info)) =
+ attach_service_worker_target_for_auto_attach_related(conn, &target.target_id)
+ {
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ &target.target_id,
+ target_info,
+ [conn.prepare_auto_attach_session_commit(
+ session_id,
+ cmd.session_id.map(str::to_owned),
+ false,
+ )],
+ ));
+ for event in event_plan {
+ plan.push_background_event(event);
+ }
+ }
+ restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
+ // Chromium completes autoAttachRelated only after its existing-target
+ // attach pass. Existing targets are already running, so they cannot be
+ // paused on start even when the policy requests it.
+ plan.push_success();
+ plan
+}
+
+fn service_worker_auto_attach_related_target(
+ conn: &mut CdpConnection,
+ target_id: &str,
+) -> Result<ServiceWorkerAutoAttachRelatedTarget, CommandOutputPlan> {
+ if let Err(message) = select_browser_context_for_target(conn, target_id) {
+ return Err(CommandOutputPlan::error_without_session(-31998, message));
+ }
+ let Some(browser_context) = conn.browser_context.as_ref() else {
+ return Err(CommandOutputPlan::error_without_session(
+ -31998,
+ "BrowserContextNotLoaded",
+ ));
+ };
+ let Some(target) = browser_context.service_worker_target(target_id) else {
+ return Err(CommandOutputPlan::error_without_session(
+ -32000,
+ "Target does not support auto-attaching",
+ ));
+ };
+ Ok(ServiceWorkerAutoAttachRelatedTarget {
+ target_id: target.target_id.clone(),
+ browser_context_id: browser_context.id.clone(),
+ registration_id: target.renderer_registration_id,
+ version_id: target.renderer_version_id,
+ script_url: target.script_url.clone(),
+ scope_url: target.scope_url.clone(),
+ })
+}
+
+fn attach_service_worker_target_for_auto_attach_related(
+ conn: &mut CdpConnection,
+ target_id: &str,
+) -> Option<(String, DevToolsTargetInfo)> {
+ let session_id = conn.gen_session_id();
+ let target_info = conn
+ .prepare_auto_attached_service_worker_session_binding_info(target_id, session_id.clone())?;
+ Some((session_id, target_info))
+}
+
+fn owner_already_auto_attached_to_target(
+ conn: &CdpConnection,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+) -> bool {
+ conn.auto_attached_sessions_for_owner(owner_session_id)
+ .into_iter()
+ .any(|session_id| {
+ matches!(
+ conn.session_route(Some(&session_id)),
+ Some(crate::conn::CdpSessionRoute::ServiceWorkerTarget {
+ target_id: attached_target_id,
+ ..
+ }) if attached_target_id == target_id
+ )
+ })
+}
+
+fn owner_already_auto_attached_to_exact_target(
+ conn: &CdpConnection,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+) -> bool {
+ let attached_sessions = conn.attached_sessions_for_target(target_id);
+ conn.auto_attached_sessions_for_owner(owner_session_id)
+ .iter()
+ .any(|session_id| attached_sessions.contains(session_id))
+}
+
+fn owner_already_auto_attached_to_page_target(
+ conn: &CdpConnection,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+) -> bool {
+ conn.auto_attached_sessions_for_owner(owner_session_id)
+ .into_iter()
+ .any(|session_id| match conn.session_route(Some(&session_id)) {
+ Some(crate::conn::CdpSessionRoute::ActiveTarget {
+ browser_context_id,
+ target_id: route_target_id,
+ }) => {
+ route_target_id.as_deref() == Some(target_id)
+ || conn
+ .browser_context_by_id(&browser_context_id)
+ .and_then(BrowserContext::active_target_id)
+ == Some(target_id)
+ }
+ Some(crate::conn::CdpSessionRoute::BackgroundTarget {
+ target_id: route_target_id,
+ ..
+ })
+ | Some(crate::conn::CdpSessionRoute::AuxiliaryTarget {
+ target_id: route_target_id,
+ ..
+ }) => route_target_id == target_id,
+ _ => false,
+ })
+}
+
+fn owner_already_auto_attached_to_tab_target(
+ conn: &CdpConnection,
+ owner_session_id: Option<&str>,
+ tab_target_id: &str,
+) -> bool {
+ conn.auto_attached_sessions_for_owner(owner_session_id)
+ .into_iter()
+ .any(|session_id| {
+ matches!(
+ conn.session_route(Some(&session_id)),
+ Some(crate::conn::CdpSessionRoute::TabTarget {
+ tab_target_id: attached_target_id,
+ ..
+ }) if attached_target_id == tab_target_id
+ )
+ })
+}
+
+fn should_auto_attach_page_target_for_owner(
+ conn: &CdpConnection,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+ target_has_primary_session: bool,
+) -> bool {
+ if owner_session_id.is_none() && target_has_primary_session {
+ return false;
+ }
+ if owner_session_is_attached_to_page_target(conn, owner_session_id, target_id) {
+ return false;
+ }
+ !owner_already_auto_attached_to_page_target(conn, owner_session_id, target_id)
+}
+
+fn should_auto_attach_tab_target_for_owner(
+ conn: &CdpConnection,
+ owner_session_id: Option<&str>,
+ tab_target_id: &str,
+) -> bool {
+ if owner_session_id.is_none()
+ && conn
+ .primary_session_id_for_tab_target_id(tab_target_id)
+ .is_some()
+ {
+ return false;
+ }
+ !owner_already_auto_attached_to_tab_target(conn, owner_session_id, tab_target_id)
+}
+
+fn owner_session_is_attached_to_page_target(
+ conn: &CdpConnection,
+ owner_session_id: Option<&str>,
+ target_id: &str,
+) -> bool {
+ let Some(owner_session_id) = owner_session_id else {
+ return false;
+ };
+ page_session_route_matches_target(conn, owner_session_id, target_id)
+}
+
+fn page_session_route_matches_target(
+ conn: &CdpConnection,
+ session_id: &str,
+ target_id: &str,
+) -> bool {
+ match conn.session_route(Some(session_id)) {
+ Some(crate::conn::CdpSessionRoute::ActiveTarget {
+ browser_context_id,
+ target_id: route_target_id,
+ }) => {
+ route_target_id.as_deref() == Some(target_id)
+ || conn
+ .browser_context_by_id(&browser_context_id)
+ .and_then(BrowserContext::active_target_id)
+ == Some(target_id)
+ }
+ Some(crate::conn::CdpSessionRoute::BackgroundTarget {
+ target_id: route_target_id,
+ ..
+ })
+ | Some(crate::conn::CdpSessionRoute::AuxiliaryTarget {
+ target_id: route_target_id,
+ ..
+ }) => route_target_id == target_id,
+ _ => false,
+ }
+}
+
+fn cdp_target_filter_from_entries(filter: Option<Vec<TargetFilterEntry>>) -> CdpTargetFilter {
+ match filter {
+ Some(entries) => CdpTargetFilter::from_entries(
+ entries
+ .into_iter()
+ .map(|entry| CdpTargetFilterEntry {
+ exclude: entry.exclude,
+ target_type: entry.target_type,
+ })
+ .collect(),
+ ),
+ None => CdpTargetFilter::default_auto_attach(),
+ }
+}
+
+pub(super) fn start_set_auto_attach_command(
+ conn: &mut CdpConnection,
+ cmd: &Cmd<'_>,
+) -> TargetCommandTaskStep {
+ let params: AutoAttachParams = match cmd.get_params() {
+ Ok(Some(p)) => p,
+ _ => {
+ return super::target_command_error(-32602, "InvalidParams");
+ }
+ };
+ if cmd
+ .session_id
+ .is_some_and(|session_id| conn.is_browser_session_id(Some(session_id)))
+ && params.flatten != Some(true)
+ {
+ return super::target_command_error(
+ -32602,
+ "Only flatten protocol is supported with browser level auto-attach",
+ );
+ }
+ if !params.auto_attach
+ && params
+ .filter
+ .as_ref()
+ .is_some_and(|filter| !filter.is_empty())
+ {
+ return super::target_command_error(
+ -32602,
+ "Target filter should be empty when disabling auto-attach",
+ );
+ }
+ let target_filter = cdp_target_filter_from_entries(params.filter);
+ let owner_is_browser_or_root =
+ cmd.session_id.is_none() || conn.is_browser_session_id(cmd.session_id);
+ if params.auto_attach
+ && owner_is_browser_or_root
+ && target_filter.matches("tab")
+ && target_filter.matches("page")
+ {
+ return super::target_command_error(
+ -32602,
+ "Filter should not simultaneously allow \"tab\" and \"page\", page targets are attached via tab targets",
+ );
+ }
+ let owner_was_enabled = conn.has_auto_attach_owner(cmd.session_id);
+ let legacy_disable_all = !params.auto_attach
+ && !owner_was_enabled
+ && conn.auto_attach_owner_count() == 0
+ && conn.auto_attach;
+ if params.auto_attach {
+ conn.install_default_browser_target_for_auto_attach_if_enabled();
+ }
+ let pause_service_workers_on_start = params.auto_attach
+ && params.wait_for_debugger_on_start
+ && target_filter.matches("service_worker")
+ && super::browser_level_auto_attach_owner_session_allowed(conn, cmd.session_id);
+ let pause_dedicated_workers_on_start =
+ params.auto_attach && params.wait_for_debugger_on_start && target_filter.matches("worker");
+ conn.set_auto_attach_owner(
+ cmd.session_id,
+ params.auto_attach,
+ params.wait_for_debugger_on_start,
+ target_filter,
+ );
+ super::set_service_worker_pause_on_start_owner(
+ conn,
+ cmd.session_id,
+ pause_service_workers_on_start,
+ );
+ super::set_dedicated_worker_pause_on_start_owner(
+ conn,
+ cmd.session_id,
+ pause_dedicated_workers_on_start,
+ );
+ pending_set_auto_attach_command(
+ cmd.id,
+ cmd.session_id,
+ params.auto_attach,
+ cmd.session_id,
+ legacy_disable_all,
+ )
+}
+
+pub(super) async fn complete_set_auto_attach_command_async(
+ conn: &mut CdpConnection,
+ auto_attach: bool,
+ owner_session_id: Option<&str>,
+ legacy_disable_all: bool,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) -> CommandOutputPlan {
+ let mut side_effects = events::TargetProtocolSideEffects::default();
+ let restore_browser_context_id = previously_active_browser_context_id(conn);
+ set_auto_attach_inner_async(
+ conn,
+ &mut side_effects,
+ auto_attach,
+ owner_session_id,
+ legacy_disable_all,
+ command_context,
+ )
+ .await;
+ restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
+ // Chromium runs the AddClient existing-target sweep before invoking the
+ // SetAutoAttach completion callback. Puppeteer consumes attachedToTarget
+ // during that sweep and assumes every pre-existing session is registered
+ // by the time the command response resolves.
+ let mut plan = side_effects.into_plan();
+ plan.push_success();
+ plan
+}
+
+async fn set_auto_attach_inner_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ auto_attach: bool,
+ owner_session_id: Option<&str>,
+ legacy_disable_all: bool,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) {
+ if !auto_attach && !legacy_disable_all {
+ detach_auto_attached_sessions_for_owner_async(conn, out, owner_session_id, command_context)
+ .await;
+ return;
+ }
+ if auto_attach
+ && let Some(owner_session_id) = owner_session_id
+ && let Some(tab_target_id) = conn
+ .tab_target_id_for_session_id(owner_session_id)
+ .map(str::to_owned)
+ {
+ auto_attach_child_page_for_tab_session_async(conn, out, owner_session_id, &tab_target_id)
+ .await;
+ return;
+ }
+
+ let context_ids: Vec<String> = conn.browser_contexts().map(|bc| bc.id.clone()).collect();
+ for context_id in context_ids {
+ if !conn.activate_browser_context_by_id_async(&context_id).await {
+ continue;
+ }
+ if auto_attach {
+ let attach_page_targets = conn
+ .auto_attach_owner_allows_target_type(owner_session_id, "page")
+ && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
+ let attach_tab_targets = conn
+ .auto_attach_owner_allows_target_type(owner_session_id, "tab")
+ && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
+ let attach_shared_worker_targets = conn
+ .auto_attach_owner_allows_target_type(owner_session_id, "shared_worker")
+ && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
+ let attach_dedicated_worker_targets =
+ conn.auto_attach_owner_allows_target_type(owner_session_id, "worker");
+ let attach_service_worker_targets = conn
+ .auto_attach_owner_allows_target_type(owner_session_id, "service_worker")
+ && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
+ // waitForDebuggerOnStart applies to targets created after the
+ // policy is installed. Chromium reports every target found by the
+ // initial AddClient sweep as already running.
+ let waiting_for_debugger = false;
+ let pending_attach_target_ids = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when attaching existing targets");
+ if !attach_page_targets {
+ Vec::new()
+ } else {
+ let mut target_ids = Vec::new();
+ if let Some(target_id) = bc.active_target_id_owned()
+ && should_auto_attach_page_target_for_owner(
+ conn,
+ owner_session_id,
+ &target_id,
+ bc.has_active_session(),
+ )
+ {
+ target_ids.push(target_id);
+ }
+ target_ids.extend(
+ bc.background_targets
+ .iter()
+ .filter(|target| {
+ should_auto_attach_page_target_for_owner(
+ conn,
+ owner_session_id,
+ target.target_id(),
+ target.has_session(),
+ )
+ })
+ .map(|target| target.target_id().to_owned()),
+ );
+ target_ids
+ }
+ };
+ let pending_attach_tab_target_ids = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when attaching existing tab targets");
+ if !attach_tab_targets {
+ Vec::new()
+ } else {
+ let mut tab_target_ids = Vec::new();
+ if let Some(page_target_id) = bc.active_target_id()
+ && let Some(tab_target_id) =
+ conn.tab_target_id_for_page_target_id(page_target_id)
+ && should_auto_attach_tab_target_for_owner(
+ conn,
+ owner_session_id,
+ tab_target_id,
+ )
+ {
+ tab_target_ids.push(tab_target_id.to_owned());
+ }
+ tab_target_ids.extend(bc.background_targets.iter().filter_map(|target| {
+ let tab_target_id =
+ conn.tab_target_id_for_page_target_id(target.target_id())?;
+ should_auto_attach_tab_target_for_owner(
+ conn,
+ owner_session_id,
+ tab_target_id,
+ )
+ .then(|| tab_target_id.to_owned())
+ }));
+ tab_target_ids
+ }
+ };
+ let pending_attach_shared_worker_target_ids = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when attaching existing targets");
+ if attach_shared_worker_targets {
+ bc.shared_worker_targets
+ .values()
+ .filter(|target| {
+ !owner_already_auto_attached_to_exact_target(
+ conn,
+ owner_session_id,
+ &target.target_id,
+ )
+ })
+ .map(|target| target.target_id.clone())
+ .collect::<Vec<_>>()
+ } else {
+ Vec::new()
+ }
+ };
+ let pending_attach_service_worker_target_ids = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when attaching existing targets");
+ if attach_service_worker_targets {
+ bc.service_worker_targets
+ .values()
+ .filter(|target| {
+ !owner_already_auto_attached_to_exact_target(
+ conn,
+ owner_session_id,
+ &target.target_id,
+ )
+ })
+ .map(|target| target.target_id.clone())
+ .collect::<Vec<_>>()
+ } else {
+ Vec::new()
+ }
+ };
+ let pending_attach_dedicated_worker_target_ids = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when attaching existing targets");
+ if attach_dedicated_worker_targets {
+ bc.dedicated_worker_targets
+ .values()
+ .filter(|target| {
+ super::worker_target::dedicated_worker_auto_attach_owner_session_allowed(
+ conn,
+ owner_session_id,
+ &target.owner_page,
+ ) && !owner_already_auto_attached_to_exact_target(
+ conn,
+ owner_session_id,
+ &target.target_id,
+ )
+ })
+ .map(|target| target.target_id.clone())
+ .collect::<Vec<_>>()
+ } else {
+ Vec::new()
+ }
+ };
+ let attached_targets = pending_attach_target_ids
+ .into_iter()
+ .map(|target_id| (target_id, conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let attached_tab_targets = pending_attach_tab_target_ids
+ .into_iter()
+ .map(|target_id| (target_id, conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let attached_shared_worker_targets = pending_attach_shared_worker_target_ids
+ .into_iter()
+ .map(|target_id| (target_id, conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let attached_service_worker_targets = pending_attach_service_worker_target_ids
+ .into_iter()
+ .map(|target_id| (target_id, conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let attached_dedicated_worker_targets = pending_attach_dedicated_worker_target_ids
+ .into_iter()
+ .map(|target_id| (target_id, conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let promote_target_id = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when considering auto-attach promotion");
+ if !attach_page_targets || bc.has_loaded_page() {
+ None
+ } else {
+ bc.background_targets
+ .iter()
+ .rposition(|target| !target.has_session() && target.has_loaded_page())
+ .map(|index| bc.background_targets[index].target_id().to_owned())
+ .or_else(|| {
+ bc.background_targets
+ .iter()
+ .find(|target| !target.has_session())
+ .map(|target| target.target_id().to_owned())
+ })
+ }
+ };
+ {
+ for (target_id, session_id) in &attached_targets {
+ let assigned = conn
+ .prepare_auto_attached_page_session_binding(target_id, session_id.clone());
+ debug_assert!(assigned, "attached target must remain addressable");
+ }
+ for (target_id, session_id) in &attached_shared_worker_targets {
+ let assigned = conn.prepare_auto_attached_shared_worker_session_binding(
+ target_id,
+ session_id.clone(),
+ );
+ debug_assert!(
+ assigned,
+ "attached shared worker target must remain addressable"
+ );
+ }
+ for (target_id, session_id) in &attached_dedicated_worker_targets {
+ let assigned = conn.prepare_auto_attached_dedicated_worker_session_binding(
+ target_id,
+ session_id.clone(),
+ );
+ debug_assert!(
+ assigned,
+ "attached dedicated worker target must remain addressable"
+ );
+ }
+ for (target_id, session_id) in &attached_service_worker_targets {
+ let assigned = conn.prepare_auto_attached_service_worker_session_binding(
+ target_id,
+ session_id.clone(),
+ );
+ debug_assert!(
+ assigned,
+ "attached service worker target must remain addressable"
+ );
+ }
+ }
+ for (target_id, session_id) in &attached_tab_targets {
+ let assigned = conn.prepare_auto_attached_tab_session_binding(
+ target_id,
+ session_id.clone(),
+ owner_session_id,
+ );
+ debug_assert!(assigned, "attached tab target must remain addressable");
+ }
+ if let Some(promote_target_id) = promote_target_id {
+ match conn
+ .promote_background_target_to_active_for_connection_async(&promote_target_id)
+ .await
+ {
+ Ok(Some(activation)) => {
+ out.extend_background_events(activation.into_protocol_events());
+ }
+ Ok(None) => {}
+ Err(message) => {
+ panic!(
+ "same-context target should remain promotable during auto-attach: {message}"
+ );
+ }
+ }
+ }
+ ensure_initial_document_for_attached_page_targets_async(conn, &attached_targets).await;
+ for (target_id, session_id) in &attached_targets {
+ if let Err(message) = conn
+ .apply_runtime_binding_state_for_session_owner_async(Some(session_id))
+ .await
+ && message != "NoDocumentLoaded"
+ {
+ tracing::warn!(
+ %message,
+ target_id = target_id.as_str(),
+ session_id = session_id.as_str(),
+ "failed to apply renderer binding state during target auto-attach"
+ );
+ }
+ }
+ for (target_id, session_id) in attached_tab_targets {
+ let ti = conn
+ .tab_target_info(&target_id)
+ .expect("attached tab target must remain addressable");
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ &target_id,
+ ti,
+ [conn.prepare_auto_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ waiting_for_debugger,
+ )],
+ ));
+ out.extend_background_events(event_plan);
+ }
+ for (target_id, session_id) in attached_targets {
+ let ti = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when emitting attach events");
+ bc.devtools_target_info(&target_id)
+ .expect("attached target must remain addressable")
+ };
+ if let Some(message) =
+ super::transient_no_page_devtools_target_info_error(conn, &ti)
+ {
+ warn_target_protocol_side_effect_failure(
+ &target_id,
+ "emit_attached_to_target",
+ &message,
+ );
+ }
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ &target_id,
+ ti,
+ [conn.prepare_auto_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ waiting_for_debugger,
+ )],
+ ));
+ out.extend_background_events(event_plan);
+ }
+ for (target_id, session_id) in attached_shared_worker_targets {
+ let ti = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when emitting attach events");
+ bc.devtools_target_info(&target_id)
+ .expect("attached shared worker target must remain addressable")
+ };
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ &target_id,
+ ti,
+ [conn.prepare_auto_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ waiting_for_debugger,
+ )],
+ ));
+ out.extend_background_events(event_plan);
+ }
+ for (target_id, session_id) in attached_dedicated_worker_targets {
+ let ti = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when emitting attach events");
+ bc.devtools_target_info(&target_id)
+ .expect("attached dedicated worker target must remain addressable")
+ };
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ &target_id,
+ ti,
+ [conn.prepare_auto_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ waiting_for_debugger,
+ )],
+ ));
+ out.extend_background_events(event_plan);
+ }
+ for (target_id, session_id) in attached_service_worker_targets {
+ let ti = {
+ let bc = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist when emitting attach events");
+ bc.devtools_target_info(&target_id)
+ .expect("attached service worker target must remain addressable")
+ };
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ &target_id,
+ ti,
+ [conn.prepare_auto_attach_session_commit(
+ session_id,
+ owner_session_id.map(str::to_owned),
+ waiting_for_debugger,
+ )],
+ ));
+ out.extend_background_events(event_plan);
+ }
+ continue;
+ }
+
+ if let Some((target_id, Some(session_id))) = conn
+ .browser_context
+ .as_ref()
+ .and_then(BrowserContext::active_target_identity)
+ {
+ events::fail_pending_fetch_state_for_target_background_events_async(
+ conn,
+ out.background_events_mut(),
+ Some(&session_id),
+ "Target detached",
+ )
+ .await;
+
+ let event_plan = conn
+ .detach_active_target_session_binding_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id, session_id, None, None,
+ ),
+ )
+ .await
+ .expect("clearing session-scoped state during auto-attach reset should succeed");
+ out.extend_background_events(event_plan);
+ }
+
+ let detached_background_targets =
+ conn.background_target_session_detach_cleanup_plans(None, None);
+ for cleanup_plan in detached_background_targets {
+ if let Some(event_plan) = conn
+ .detach_background_target_session_binding_event_plan_async(cleanup_plan)
+ .await
+ .expect("clearing background target session-scoped state during auto-attach reset should succeed")
+ {
+ out.extend_background_events(event_plan);
+ }
+ }
+
+ let shared_worker_sessions_to_release = conn
+ .browser_context
+ .as_ref()
+ .map(|bc| {
+ bc.shared_worker_targets
+ .values()
+ .flat_map(|target| target.session_ids())
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ for session_id in &shared_worker_sessions_to_release {
+ conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
+ session_id,
+ )
+ .await;
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ }
+
+ let shared_worker_event_plan = conn
+ .detach_all_shared_worker_target_sessions_event_plan_async(None, None)
+ .await;
+ out.extend_background_events(shared_worker_event_plan);
+
+ let dedicated_worker_sessions_to_release = conn
+ .browser_context
+ .as_ref()
+ .map(|bc| {
+ bc.dedicated_worker_targets
+ .values()
+ .flat_map(|target| target.session_ids())
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ for session_id in &dedicated_worker_sessions_to_release {
+ conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
+ session_id,
+ )
+ .await;
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ }
+ let dedicated_worker_event_plan = conn
+ .detach_all_dedicated_worker_target_sessions_event_plan_async(None, None)
+ .await;
+ out.extend_background_events(dedicated_worker_event_plan);
+
+ let service_worker_sessions_to_detach = conn
+ .browser_context
+ .as_ref()
+ .map(|bc| {
+ bc.service_worker_targets
+ .values()
+ .flat_map(|target| target.session_ids())
+ .collect::<Vec<_>>()
+ })
+ .unwrap_or_default();
+ let service_worker_event_plan = conn
+ .detach_all_service_worker_target_sessions_event_plan_async(None, None)
+ .await;
+ for session_id in service_worker_sessions_to_detach {
+ super::set_service_worker_pause_on_start_owner(conn, Some(&session_id), false);
+ }
+ out.extend_background_events(service_worker_event_plan);
+ }
+}
+
+async fn auto_attach_child_page_for_tab_session_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ tab_session_id: &str,
+ tab_target_id: &str,
+) {
+ if !conn.auto_attach_owner_allows_target_type(Some(tab_session_id), "page") {
+ return;
+ }
+ let Some(page_target_id) = conn
+ .primary_page_target_id_for_tab_target_id(tab_target_id)
+ .map(str::to_owned)
+ else {
+ return;
+ };
+ let Some(browser_context_id) = conn.browser_context_id_for_tab_target_id(tab_target_id) else {
+ return;
+ };
+ if !conn
+ .activate_browser_context_by_id_async(&browser_context_id)
+ .await
+ {
+ return;
+ }
+ let target_has_primary_session = {
+ let Some(bc) = conn.browser_context.as_ref() else {
+ return;
+ };
+ if bc.active_target_id() == Some(page_target_id.as_str()) {
+ bc.has_active_session()
+ } else {
+ bc.background_target(&page_target_id)
+ .is_some_and(|target| target.has_session())
+ }
+ };
+ if !should_auto_attach_page_target_for_owner(
+ conn,
+ Some(tab_session_id),
+ &page_target_id,
+ target_has_primary_session,
+ ) {
+ return;
+ }
+ let session_id = conn.gen_session_id();
+ let assigned =
+ conn.prepare_auto_attached_page_session_binding(&page_target_id, session_id.clone());
+ if !assigned {
+ return;
+ }
+ ensure_initial_document_for_attached_page_targets_async(
+ conn,
+ &[(page_target_id.clone(), session_id.clone())],
+ )
+ .await;
+ if let Err(message) = conn
+ .apply_runtime_binding_state_for_session_owner_async(Some(&session_id))
+ .await
+ && message != "NoDocumentLoaded"
+ {
+ tracing::warn!(
+ %message,
+ target_id = page_target_id.as_str(),
+ session_id = session_id.as_str(),
+ "failed to apply renderer binding state during tab child page auto-attach"
+ );
+ }
+ let prepared_session = conn.prepare_auto_attach_session_commit(
+ session_id.clone(),
+ Some(tab_session_id.to_owned()),
+ false,
+ );
+ let Some(target_info) = conn
+ .browser_context
+ .as_ref()
+ .and_then(|bc| bc.devtools_target_info(&page_target_id))
+ else {
+ conn.rollback_prepared_attach_session_without_event_async(&prepared_session)
+ .await;
+ return;
+ };
+ if let Some(message) = super::transient_no_page_devtools_target_info_error(conn, &target_info) {
+ warn_target_protocol_side_effect_failure(
+ &page_target_id,
+ "emit_tab_child_attached_to_target",
+ &message,
+ );
+ conn.rollback_prepared_attach_session_without_event_async(&prepared_session)
+ .await;
+ return;
+ }
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ &page_target_id,
+ target_info,
+ [prepared_session],
+ ));
+ out.extend_background_events(event_plan);
+}
+
+pub(super) async fn detach_auto_attached_sessions_for_owner_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ owner_session_id: Option<&str>,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) {
+ let session_ids = conn.auto_attached_session_cascade_for_owner(owner_session_id);
+ for session_id in session_ids {
+ detach_attached_session_for_owner_async(conn, out, &session_id, command_context).await;
+ }
+}
+
+pub(super) async fn detach_attached_sessions_for_owner_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ owner_session_id: Option<&str>,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) {
+ let session_ids = conn.attached_session_cascade_for_owner(owner_session_id);
+ for session_id in session_ids {
+ detach_attached_session_for_owner_async(conn, out, &session_id, command_context).await;
+ }
+}
+
+pub(super) async fn release_attached_sessions_for_root_frontend_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) {
+ // Root-owned browser sessions include the scheduler's private page-control
+ // session and must outlive a browser frontend disconnect. A target session
+ // owned directly by that frontend still belongs to the release cascade.
+ let session_ids = conn.attached_session_cascade_for_root_frontend();
+ for session_id in session_ids {
+ let detach_plan = conn.auto_attached_session_detach_plan(&session_id);
+ let preserves_other_frontends = matches!(
+ detach_plan.cleanup_plan().map(|plan| plan.action()),
+ Some(
+ crate::conn::TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached
+ | crate::conn::TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached {
+ ..
+ }
+ )
+ );
+ if !preserves_other_frontends {
+ detach_attached_session_for_owner_async(conn, out, &session_id, command_context).await;
+ continue;
+ }
+
+ let Some(browser_context_id) = detach_plan.browser_context_id().map(str::to_owned) else {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ continue;
+ };
+ if !conn
+ .activate_browser_context_by_id_async(&browser_context_id)
+ .await
+ {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ continue;
+ }
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(&session_id),
+ "Target detached",
+ );
+ super::clear_detached_target_fetch_state_background_events_async(
+ conn,
+ out.background_events_mut(),
+ &session_id,
+ )
+ .await;
+ let _ = conn
+ .detach_runtime_inspector_session_for_session_owner_async(Some(&session_id))
+ .await;
+ clear_emulated_media_for_detached_session_best_effort(conn, &session_id).await;
+ if !conn.release_primary_target_session_binding_without_event(&session_id) {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ }
+ }
+}
+
+async fn detach_attached_session_for_owner_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ session_id: &str,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) {
+ if conn.is_browser_session_id(Some(session_id)) {
+ conn.cancel_tracing_for_session_owner_async(Some(session_id))
+ .await;
+ let detached = conn.detach_browser_session_owner_without_event(session_id);
+ debug_assert!(detached.is_some());
+ return;
+ }
+ let detach_plan = conn.auto_attached_session_detach_plan(session_id);
+ let Some(browser_context_id) = detach_plan.browser_context_id().map(str::to_owned) else {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ return;
+ };
+ if !conn
+ .activate_browser_context_by_id_async(&browser_context_id)
+ .await
+ {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ return;
+ }
+
+ let Some(cleanup_plan) = detach_plan.cleanup_plan() else {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ return;
+ };
+ match cleanup_plan.action().clone() {
+ crate::conn::TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached => {
+ let target_id = conn
+ .browser_context
+ .as_ref()
+ .and_then(BrowserContext::active_target_identity)
+ .and_then(|(target_id, current_session_id)| {
+ (current_session_id.as_deref() == Some(session_id))
+ .then(|| target_id.to_owned())
+ });
+ let Some(target_id) = target_id else {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ return;
+ };
+ // A parent-session detach cascade bypasses the direct
+ // Target.detachFromTarget path. Release the renderer inspector
+ // here before resetting protocol state so the replacement primary
+ // session gets a fresh Runtime.enable context inventory.
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ let _ = conn
+ .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
+ .await;
+ events::fail_pending_fetch_state_for_target_background_events_async(
+ conn,
+ out.background_events_mut(),
+ Some(session_id),
+ "Target detached",
+ )
+ .await;
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id, session_id, None, None,
+ ),
+ )
+ .await;
+ out.extend_background_events(event_plan);
+ }
+ crate::conn::TargetBindingCleanupAction::AuxiliaryTarget { target_id } => {
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ let _ = conn
+ .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
+ .await;
+ clear_emulated_media_for_detached_session_best_effort(conn, session_id).await;
+ super::clear_detached_target_fetch_state_background_events_async(
+ conn,
+ out.background_events_mut(),
+ session_id,
+ )
+ .await;
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id, session_id, None, None,
+ ),
+ )
+ .await;
+ out.extend_background_events(event_plan);
+ }
+ crate::conn::TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached {
+ target_id,
+ } => {
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ let _ = conn
+ .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
+ .await;
+ clear_emulated_media_for_detached_session_best_effort(conn, session_id).await;
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id, session_id, None, None,
+ ),
+ )
+ .await;
+ out.extend_background_events(event_plan);
+ }
+ crate::conn::TargetBindingCleanupAction::TabTarget { tab_target_id } => {
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ tab_target_id,
+ session_id,
+ None,
+ None,
+ ),
+ )
+ .await;
+ out.extend_background_events(event_plan);
+ }
+ crate::conn::TargetBindingCleanupAction::SharedWorkerTarget { target_id } => {
+ let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {
+ bc.shared_worker_target(&target_id)
+ .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))
+ });
+ conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
+ session_id,
+ )
+ .await;
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ if let Some((renderer_runtime, instance_id)) = renderer_detach {
+ renderer_runtime.detach_shared_worker_runtime_inspector_session(
+ instance_id,
+ Some(session_id.to_owned()),
+ );
+ }
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id, session_id, None, None,
+ ),
+ )
+ .await;
+ out.extend_background_events(event_plan);
+ }
+ crate::conn::TargetBindingCleanupAction::DedicatedWorkerTarget { target_id } => {
+ let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {
+ bc.dedicated_worker_target(&target_id)
+ .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))
+ });
+ conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
+ session_id,
+ )
+ .await;
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ if let Some((renderer_runtime, instance_id)) = renderer_detach {
+ renderer_runtime.detach_dedicated_worker_runtime_inspector_session(
+ instance_id,
+ Some(session_id.to_owned()),
+ );
+ }
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id, session_id, None, None,
+ ),
+ )
+ .await;
+ out.extend_background_events(event_plan);
+ }
+ crate::conn::TargetBindingCleanupAction::ServiceWorkerTarget { target_id } => {
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ Some(session_id),
+ "Target detached",
+ );
+ super::set_service_worker_pause_on_start_owner(conn, Some(session_id), false);
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id, session_id, None, None,
+ ),
+ )
+ .await;
+ out.extend_background_events(event_plan);
+ }
+ crate::conn::TargetBindingCleanupAction::None => {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ }
+ }
+}
+
+pub(super) async fn clear_emulated_media_for_detached_session_best_effort(
+ conn: &mut CdpConnection,
+ session_id: &str,
+) {
+ if let Err(error) =
+ crate::domains::emulation::clear_emulated_media_for_detached_session_async(conn, session_id)
+ .await
+ {
+ tracing::warn!(
+ session_id,
+ error,
+ "failed to clear emulated media while detaching target session"
+ );
+ }
+}
+
+async fn ensure_initial_document_for_attached_page_targets_async(
+ conn: &mut CdpConnection,
+ attached_targets: &[(String, String)],
+) {
+ for (target_id, _session_id) in attached_targets {
+ if !conn.browser_contexts().any(|browser_context| {
+ browser_context.target_has_pending_initial_document_page_build(target_id)
+ }) {
+ continue;
+ }
+ 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 Some(pending) = pending else {
+ continue;
+ };
+ match pending.wait().await {
+ Ok(completed) => {
+ if let Err(message) = conn
+ .complete_initial_document_page_build_for_owner(completed)
+ .await
+ {
+ warn_target_protocol_side_effect_failure(
+ target_id,
+ "complete_initial_document_page_build",
+ &message,
+ );
+ }
+ }
+ Err(failed) => {
+ let message = conn.reset_failed_initial_document_page_build_for_owner(failed);
+ warn_target_protocol_side_effect_failure(
+ target_id,
+ "reset_failed_initial_document_page_build",
+ &message,
+ );
+ }
+ }
+ }
+}
+
+fn warn_target_protocol_side_effect_failure(
+ target_id: &str,
+ operation: &'static str,
+ message: &str,
+) {
+ tracing::warn!(
+ target_id,
+ operation,
+ %message,
+ "target protocol side effect failed; continuing auto-attach event emission"
+ );
+}
diff --git a/moli-protocol/src/domains/target/closing.rs b/moli-protocol/src/domains/target/closing.rs
new file mode 100644
index 000000000..1ded28a38
--- /dev/null
+++ b/moli-protocol/src/domains/target/closing.rs
@@ -0,0 +1,275 @@
+use serde::Deserialize;
+
+use crate::devtools_runtime::{DevToolsCloseTargetResult, DevToolsTargetId};
+
+use super::*;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct CloseTargetParams {
+ pub(super) target_id: String,
+}
+
+pub(super) fn start_close_target_command(
+ conn: &mut CdpConnection,
+ cmd: &Cmd<'_>,
+) -> TargetCommandTaskStep {
+ let params: CloseTargetParams = match cmd.get_params() {
+ Ok(Some(p)) => p,
+ _ => {
+ return super::target_command_error(-32602, "InvalidParams");
+ }
+ };
+ if !conn.target_handler_may_close_target(cmd.session_id, &params.target_id) {
+ return super::target_command_error(-32000, "Not allowed");
+ }
+ let command = build_cdp_close_target_command(cmd, params);
+ super::start_devtools_target_command(
+ conn,
+ cmd.id,
+ cmd.session_id,
+ DevToolsCommand::CloseTarget(command),
+ )
+}
+
+pub(super) fn build_cdp_close_target_command(
+ cmd: &Cmd<'_>,
+ params: CloseTargetParams,
+) -> DevToolsCloseTargetCommand {
+ DevToolsCloseTargetCommand {
+ context: cmd.devtools_command_context(Some(params.target_id.as_str()), None::<&str>),
+ target_id: DevToolsTargetId::from(params.target_id),
+ }
+}
+
+pub(super) fn start_devtools_close_target_command(
+ command_id: Option<u64>,
+ command_session_id: Option<&str>,
+ command: DevToolsCloseTargetCommand,
+) -> TargetCommandTaskStep {
+ pending_close_target_command(command_id, command_session_id, command)
+}
+
+pub(super) async fn complete_close_target_command_async(
+ conn: &mut CdpConnection,
+ command: DevToolsCloseTargetCommand,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) -> CommandOutputPlan {
+ let mut side_effects = events::TargetProtocolSideEffects::default();
+ match execute_devtools_close_target_command_async(
+ conn,
+ command,
+ &mut side_effects,
+ command_context,
+ )
+ .await
+ {
+ Ok(result) => {
+ let mut plan =
+ CommandOutputPlan::from_devtools_result(DevToolsCommandResult::CloseTarget(result));
+ plan.extend(side_effects.into_plan());
+ plan
+ }
+ Err(error) => CommandOutputPlan::from_devtools_error(error),
+ }
+}
+
+pub(super) async fn execute_devtools_close_target_command_async(
+ conn: &mut CdpConnection,
+ command: DevToolsCloseTargetCommand,
+ out: &mut events::TargetProtocolSideEffects,
+ command_context: &mut crate::conn::CommandDispatchContext,
+) -> Result<DevToolsCloseTargetResult, DevToolsError> {
+ let target_id = command.target_id.into_string();
+ let restore_browser_context_id = previously_active_browser_context_id(conn);
+ let result = close_target_inner_async(conn, out, command_context, target_id).await;
+ restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
+ result
+}
+
+async fn close_target_inner_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ command_context: &mut crate::conn::CommandDispatchContext,
+ target_id: String,
+) -> Result<DevToolsCloseTargetResult, DevToolsError> {
+ let target_id = conn
+ .primary_page_target_id_for_tab_target_id(&target_id)
+ .map(str::to_owned)
+ .unwrap_or(target_id);
+ if let Err(message) = select_browser_context_for_target(conn, &target_id) {
+ return Err(DevToolsError::new(DevToolsErrorKind::NoSuchTarget, message));
+ }
+ if conn
+ .browser_context
+ .as_ref()
+ .is_some_and(|bc| bc.has_shared_worker_target(&target_id))
+ {
+ if !worker_target::close_shared_worker_target_for_target_close_async(
+ conn,
+ &target_id,
+ command_context,
+ )
+ .await
+ {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "UnknownTargetId",
+ ));
+ }
+ return Ok(DevToolsCloseTargetResult { success: true });
+ }
+ if conn
+ .browser_context
+ .as_ref()
+ .is_some_and(|bc| bc.has_dedicated_worker_target(&target_id))
+ {
+ if !worker_target::close_dedicated_worker_target_for_target_close_async(
+ conn,
+ &target_id,
+ command_context,
+ )
+ .await
+ {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "UnknownTargetId",
+ ));
+ }
+ return Ok(DevToolsCloseTargetResult { success: true });
+ }
+ if conn
+ .browser_context
+ .as_ref()
+ .is_some_and(|bc| bc.has_service_worker_target(&target_id))
+ {
+ return Ok(DevToolsCloseTargetResult { success: true });
+ }
+ if conn.browser_context.as_ref().is_some_and(|bc| {
+ !matches!(
+ bc.active_target_identity(),
+ Some((ref active_target_id, _)) if active_target_id == &target_id
+ )
+ }) {
+ let target_route = conn
+ .target_session_route_for_target_id(&target_id)
+ .ok_or_else(|| {
+ DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId")
+ })?;
+ let session_id = conn
+ .browser_context
+ .as_ref()
+ .and_then(|browser_context| browser_context.background_target(&target_id))
+ .and_then(|target| target.session_id().map(str::to_owned));
+ let owner_scope = crate::conn::CommandOwnerScope::from_session_and_owner_route(
+ session_id.as_deref(),
+ session_id.is_none().then_some(target_route),
+ );
+ let renderer_output_predecessor =
+ events::fail_pending_fetch_state_for_target_background_events_async(
+ conn,
+ out.background_events_mut(),
+ session_id.as_deref(),
+ "Target closed",
+ )
+ .await;
+ settle_target_close_after_pending_fetches_async(
+ conn,
+ out,
+ command_context,
+ renderer_output_predecessor,
+ owner_scope,
+ target_id,
+ )
+ .await;
+ return Ok(DevToolsCloseTargetResult { success: true });
+ }
+
+ let session_id = match conn.browser_context.as_ref() {
+ Some(bc) => {
+ if !bc.has_active_target() && bc.background_targets.is_empty() {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "TargetNotLoaded",
+ ));
+ }
+ match bc.active_target_identity() {
+ Some((_active_target_id, session_id)) => session_id,
+ None => {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "TargetNotLoaded",
+ ));
+ }
+ }
+ }
+ None => {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "BrowserContextNotLoaded",
+ ));
+ }
+ };
+
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ session_id.as_deref(),
+ "Target closed",
+ );
+ let renderer_output_predecessor =
+ events::fail_pending_fetch_state_for_target_background_events_async(
+ conn,
+ out.background_events_mut(),
+ session_id.as_deref(),
+ "Target closed",
+ )
+ .await;
+ let owner_scope = crate::conn::CommandOwnerScope::capture(conn, session_id.as_deref());
+ settle_target_close_after_pending_fetches_async(
+ conn,
+ out,
+ command_context,
+ renderer_output_predecessor,
+ owner_scope,
+ target_id,
+ )
+ .await;
+ Ok(DevToolsCloseTargetResult { success: true })
+}
+
+/// Preserves the final renderer publication without changing the ordinary
+/// `Target.closeTarget` transaction boundary.
+///
+/// Most target closes produce no renderer output. Those closes still complete
+/// synchronously and return their detach/destroy side effects with the command,
+/// matching Chromium's target-domain behavior. A paused request can first
+/// produce a terminal renderer record, however. Only that case must defer
+/// target retirement until the command's exact cursor has crossed ordered
+/// ingress; otherwise retiring the route would discard that final record.
+async fn settle_target_close_after_pending_fetches_async(
+ conn: &mut CdpConnection,
+ out: &mut events::TargetProtocolSideEffects,
+ command_context: &mut crate::conn::CommandDispatchContext,
+ renderer_output_predecessor: Option<moli_core::RendererOutputFence>,
+ owner_scope: crate::conn::CommandOwnerScope,
+ target_id: String,
+) {
+ let action = crate::domains::page::PageTargetTerminationOwnerAction::new(
+ owner_scope,
+ target_id,
+ crate::domains::page::PageTargetTerminationKind::TargetClose,
+ );
+ if let Some(predecessor) = renderer_output_predecessor {
+ command_context.set_renderer_output_predecessor(predecessor);
+ conn.publish_page_target_termination_owner_action(action);
+ return;
+ }
+
+ let outcome =
+ crate::domains::page::complete_page_target_termination_owner_action_async(conn, action)
+ .await;
+ let (events, scheduler_events) = outcome.into_protocol_event_parts();
+ out.extend_background_events(events);
+ conn.extend_scheduler_events(scheduler_events);
+}
diff --git a/moli-protocol/src/domains/target/creation.rs b/moli-protocol/src/domains/target/creation.rs
new file mode 100644
index 000000000..790e8cc36
--- /dev/null
+++ b/moli-protocol/src/domains/target/creation.rs
@@ -0,0 +1,523 @@
+use serde::Deserialize;
+
+use crate::conn::{PreparedTargetAttach, TargetActivationTransition, TargetAttachSessionCommit};
+use crate::devtools_runtime::{
+ DevToolsBrowserContextId, DevToolsCreateTargetResult, DevToolsTargetId,
+};
+
+use super::*;
+
+pub(super) struct DevToolsCreateTargetExecution {
+ pub(super) result: DevToolsCreateTargetResult,
+ pub(super) commit: TargetCreationCommit,
+}
+
+pub(super) struct TargetCreationCommit {
+ page_target_id: String,
+ tab_target_id: String,
+ activation: Option<TargetActivationTransition>,
+ attached_tab_sessions: Vec<TargetAttachSessionCommit>,
+ attached_sessions: Vec<TargetAttachSessionCommit>,
+}
+
+impl TargetCreationCommit {
+ pub(super) fn page_target_id(&self) -> &str {
+ &self.page_target_id
+ }
+
+ pub(super) fn activation(&self) -> Option<&TargetActivationTransition> {
+ self.activation.as_ref()
+ }
+}
+
+#[derive(Clone, Copy)]
+enum CreateTargetResultHost {
+ Page,
+ Tab,
+}
+
+pub(super) fn emit_target_creation_protocol_events(
+ conn: &mut CdpConnection,
+ events: TargetCreationCommit,
+ out: &mut impl events::CdpTargetAutomationEventSink,
+) -> Result<(), DevToolsError> {
+ let has_discovery = conn.has_any_target_discovery();
+ if !has_discovery
+ && events.attached_tab_sessions.is_empty()
+ && events.attached_sessions.is_empty()
+ {
+ return Ok(());
+ }
+ let bc = conn
+ .browser_contexts()
+ .find(|browser_context| {
+ browser_context
+ .devtools_target_info(&events.page_target_id)
+ .is_some()
+ })
+ .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId"))?;
+ let target_info = bc
+ .devtools_target_info(&events.page_target_id)
+ .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId"))?;
+ if let Some(message) = super::transient_no_page_devtools_target_info_error(conn, &target_info) {
+ return Err(DevToolsError::new(DevToolsErrorKind::Internal, message));
+ }
+ if has_discovery {
+ for event in conn.target_created_event_plan(&events.page_target_id) {
+ out.push_target_background_event(event);
+ }
+ }
+ if let Some(tab_target_info) = conn.tab_target_info_for_page_target_info(&target_info) {
+ let tab_target_id = tab_target_info
+ .target_id
+ .as_ref()
+ .map(|target_id| target_id.as_str().to_owned())
+ .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::Internal, "MissingTabTargetId"))?;
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ tab_target_id,
+ tab_target_info,
+ events.attached_tab_sessions,
+ ));
+ for event in event_plan {
+ out.push_target_background_event(event);
+ }
+ }
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ events.page_target_id,
+ target_info,
+ events.attached_sessions,
+ ));
+ for event in event_plan {
+ out.push_target_background_event(event);
+ }
+ Ok(())
+}
+
+pub(super) fn push_target_created_events(
+ conn: &mut CdpConnection,
+ out: &mut impl events::CdpTargetAutomationEventSink,
+ page_target_id: &str,
+) {
+ for event in conn.target_created_event_plan(page_target_id) {
+ out.push_target_background_event(event);
+ }
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct CreateTargetParams {
+ #[serde(default = "default_blank")]
+ pub(super) url: String,
+ pub(super) browser_context_id: Option<String>,
+ pub(super) for_tab: Option<bool>,
+ pub(super) background: Option<bool>,
+ pub(super) focus: Option<bool>,
+}
+
+fn default_blank() -> String {
+ "about:blank".into()
+}
+
+pub(super) fn start_create_target_command(
+ conn: &mut CdpConnection,
+ cmd: &Cmd<'_>,
+) -> TargetCommandTaskStep {
+ if let Some(session_id) = cmd.session_id
+ && matches!(
+ conn.session_route(Some(session_id)),
+ Some(
+ crate::conn::CdpSessionRoute::SharedWorkerTarget { .. }
+ | crate::conn::CdpSessionRoute::DedicatedWorkerTarget { .. }
+ )
+ )
+ {
+ return super::target_command_error(-31998, "DirectSessionRouteRequired");
+ }
+
+ let params: CreateTargetParams = match cmd.get_params() {
+ Ok(Some(p)) => p,
+ Ok(None) => CreateTargetParams {
+ url: "about:blank".into(),
+ browser_context_id: None,
+ for_tab: None,
+ background: None,
+ focus: None,
+ },
+ Err(e) => {
+ return super::target_command_error(-32602, e);
+ }
+ };
+ let result_host = if params.for_tab.unwrap_or(false) {
+ CreateTargetResultHost::Tab
+ } else {
+ CreateTargetResultHost::Page
+ };
+ let command = match build_cdp_create_target_command(cmd, params) {
+ Ok(command) => command,
+ Err(message) => return super::target_command_error(-32602, message),
+ };
+ start_devtools_create_target_command_with_result_host(
+ conn,
+ cmd.id,
+ cmd.session_id,
+ command,
+ result_host,
+ )
+}
+
+pub(super) fn build_cdp_create_target_command(
+ cmd: &Cmd<'_>,
+ params: CreateTargetParams,
+) -> Result<DevToolsCreateTargetCommand, &'static str> {
+ let should_focus = params.focus.unwrap_or(!params.background.unwrap_or(false));
+ let create_in_background = params.background.unwrap_or(false) || params.focus == Some(false);
+ if should_focus && create_in_background {
+ return Err("Can't focus a target in the background. Use background=false instead.");
+ }
+ Ok(DevToolsCreateTargetCommand {
+ context: cmd.devtools_command_context(None::<&str>, params.browser_context_id.as_deref()),
+ url: params.url,
+ browser_context_id: params
+ .browser_context_id
+ .map(DevToolsBrowserContextId::from),
+ activate: !create_in_background,
+ })
+}
+
+pub(super) fn start_devtools_create_target_command(
+ conn: &mut CdpConnection,
+ command_id: Option<u64>,
+ command_session_id: Option<&str>,
+ command: DevToolsCreateTargetCommand,
+) -> TargetCommandTaskStep {
+ start_devtools_create_target_command_with_result_host(
+ conn,
+ command_id,
+ command_session_id,
+ command,
+ CreateTargetResultHost::Page,
+ )
+}
+
+fn start_devtools_create_target_command_with_result_host(
+ conn: &mut CdpConnection,
+ command_id: Option<u64>,
+ command_session_id: Option<&str>,
+ command: DevToolsCreateTargetCommand,
+ result_host: CreateTargetResultHost,
+) -> TargetCommandTaskStep {
+ let mut plan = CommandOutputPlan::default();
+ let execution = execute_devtools_create_target_command(conn, command);
+ let (created_target_id, creation_commit) = match execution {
+ Ok(execution) => {
+ let target_id = execution.result.target_id.clone();
+ let response_target_id = match result_host {
+ CreateTargetResultHost::Page => execution.result.target_id,
+ CreateTargetResultHost::Tab => {
+ DevToolsTargetId::from(execution.commit.tab_target_id.as_str())
+ }
+ };
+ plan.extend(CommandOutputPlan::from_devtools_result(
+ DevToolsCommandResult::CreateTarget(DevToolsCreateTargetResult {
+ target_id: response_target_id,
+ }),
+ ));
+ (target_id, execution.commit)
+ }
+ Err(error) => {
+ plan.extend(CommandOutputPlan::from_devtools_error(error));
+ return TargetCommandTaskStep::Complete(plan);
+ }
+ };
+ 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)
+ } else {
+ Ok(None)
+ };
+ match pending_initial_document {
+ Ok(Some(initial_document)) => {
+ TargetCommandTaskStep::Pending(PendingTargetCommandDispatch {
+ command_id,
+ session_id: command_session_id.map(str::to_owned),
+ kind: Box::new(PendingTargetCommandKind::CreateTarget {
+ response_plan: plan,
+ creation_commit,
+ initial_document_route,
+ initial_document: Some(Box::new(initial_document)),
+ }),
+ })
+ }
+ Ok(None) => {
+ let mut output_plan = CommandOutputPlan::default();
+ let mut protocol_events = Vec::new();
+ if let Err(error) =
+ emit_target_creation_protocol_events(conn, creation_commit, &mut protocol_events)
+ {
+ return TargetCommandTaskStep::Complete(CommandOutputPlan::from_devtools_error(
+ error,
+ ));
+ }
+ for event in protocol_events {
+ output_plan.push_background_event(event);
+ }
+ output_plan.extend(plan);
+ TargetCommandTaskStep::Complete(output_plan)
+ }
+ Err(message) => TargetCommandTaskStep::Complete(CommandOutputPlan::error(-32000, message)),
+ }
+}
+
+pub(super) fn execute_devtools_create_target_command(
+ conn: &mut CdpConnection,
+ command: DevToolsCreateTargetCommand,
+) -> Result<DevToolsCreateTargetExecution, DevToolsError> {
+ let restore_browser_context_id = previously_active_browser_context_id(conn);
+ if let Err(error) = activate_browser_context_for_create_target(conn, &command) {
+ restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
+ return Err(error);
+ }
+ if conn.browser_context.is_none() && conn.inactive_browser_contexts.is_empty() {
+ let id = conn.gen_bc_id();
+ conn.insert_browser_context(conn.new_browser_context(id));
+ }
+
+ let target_id = conn.gen_target_id();
+ let default_target_id = conn.default_target_id();
+ let (has_active_target, previous_active_target_id) = {
+ let browser_context = conn
+ .browser_context
+ .as_ref()
+ .expect("browser context must exist before target creation");
+ (
+ browser_context.active_target_identity().is_some()
+ && !browser_context
+ .active_target_is_unclaimed_default_placeholder(default_target_id),
+ browser_context.active_target_id_owned(),
+ )
+ };
+ let auto_attach_page_owners = top_level_page_auto_attach_owner_sessions(conn);
+ let auto_attach_tab_owners = top_level_tab_auto_attach_owner_sessions(conn);
+ let auto_attached_page_sessions = auto_attach_page_owners
+ .iter()
+ .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let auto_attached_tab_sessions = auto_attach_tab_owners
+ .iter()
+ .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let creating_background_target = has_active_target && !command.activate;
+ let auto_attached_background_session_id = if creating_background_target {
+ auto_attached_page_sessions
+ .first()
+ .map(|(_, session_id)| session_id.clone())
+ } else {
+ None
+ };
+ let activating_created_target = has_active_target && command.activate;
+ let activation = activating_created_target
+ .then(|| TargetActivationTransition::new(target_id.clone(), previous_active_target_id));
+ let initial_empty_document_url = create_target_initial_empty_document_url(&command.url);
+ if activating_created_target {
+ conn.handoff_navigation_engine_for_active_target_demotion();
+ }
+ {
+ let bc = conn.browser_context.as_mut().unwrap();
+ if creating_background_target {
+ bc.stage_background_target(
+ target_id.clone(),
+ auto_attached_background_session_id.clone(),
+ command.url.clone(),
+ Some(initial_empty_document_url.clone()),
+ None,
+ );
+ } else if activating_created_target {
+ bc.stage_active_target_demoting_current(
+ target_id.clone(),
+ None,
+ command.url.clone(),
+ Some(initial_empty_document_url.clone()),
+ );
+ } else {
+ bc.set_active_target_id(target_id.clone());
+ bc.set_target_url(command.url.clone());
+ bc.begin_active_target_initial_empty_document(initial_empty_document_url.clone());
+ bc.active_target.owner_state.target_crash_state.clear();
+ }
+ if command.url != initial_empty_document_url {
+ // Chromium gives Target.createTarget(url) one initial
+ // auto_toplevel history entry for url. The implementation still
+ // materializes an internal about:blank document for target setup,
+ // so replace that bookkeeping entry when the requested URL commits.
+ bc.mark_target_initial_url_replaces_empty_document(&target_id);
+ }
+ }
+ let tab_target_id = conn.register_top_level_page_target(&target_id);
+ if !creating_background_target {
+ conn.notify_target_host_activated(&target_id);
+ }
+ let created_target_id = target_id.clone();
+
+ let mut attached_tab_sessions = Vec::new();
+ for (owner_session_id, session_id) in &auto_attached_tab_sessions {
+ let waiting_for_debugger =
+ conn.auto_attach_owner_waits_for_debugger_on_start(owner_session_id.as_deref());
+ let assigned = conn.prepare_auto_attached_tab_session_binding(
+ &tab_target_id,
+ session_id.clone(),
+ owner_session_id.as_deref(),
+ );
+ debug_assert!(assigned, "created tab target must remain addressable");
+ attached_tab_sessions.push(conn.prepare_auto_attach_session_commit(
+ session_id.clone(),
+ owner_session_id.clone(),
+ waiting_for_debugger,
+ ));
+ }
+
+ let mut attached_sessions = Vec::new();
+ for (index, (owner_session_id, session_id)) in auto_attached_page_sessions.iter().enumerate() {
+ let waiting_for_debugger =
+ conn.auto_attach_owner_waits_for_debugger_on_start(owner_session_id.as_deref());
+ if creating_background_target && index == 0 {
+ attached_sessions.push(conn.prepare_auto_attach_session_commit(
+ session_id.clone(),
+ owner_session_id.clone(),
+ waiting_for_debugger,
+ ));
+ } else {
+ let assigned =
+ conn.prepare_auto_attached_page_session_binding(&target_id, session_id.clone());
+ debug_assert!(
+ assigned,
+ "newly created target must remain addressable for auto attach"
+ );
+ attached_sessions.push(conn.prepare_auto_attach_session_commit(
+ session_id.clone(),
+ owner_session_id.clone(),
+ waiting_for_debugger,
+ ));
+ }
+ }
+ if activating_created_target {
+ conn.apply_active_engine_fetch_overrides();
+ conn.invalidate_resource_runtime();
+ }
+
+ // Chromium parity: Target.createTarget acks from target lifecycle, while
+ // the initial document page build remains target-owned pending work. CDP
+ // observation commands must only see an already-installed Page or a real
+ // no-document state; they do not create the initial document themselves.
+ // See content/browser/devtools/protocol/target_handler.cc:1291.
+ restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
+
+ Ok(DevToolsCreateTargetExecution {
+ result: DevToolsCreateTargetResult {
+ target_id: DevToolsTargetId::from(created_target_id),
+ },
+ commit: TargetCreationCommit {
+ page_target_id: target_id,
+ tab_target_id,
+ activation,
+ attached_tab_sessions,
+ attached_sessions,
+ },
+ })
+}
+
+fn create_target_initial_empty_document_url(target_url: &str) -> String {
+ if url::Url::parse(target_url)
+ .ok()
+ .as_ref()
+ .is_some_and(moli_url::is_about_blank)
+ {
+ target_url.to_owned()
+ } else {
+ "about:blank".to_owned()
+ }
+}
+
+pub(super) fn top_level_page_auto_attach_owner_sessions(
+ conn: &CdpConnection,
+) -> Vec<Option<String>> {
+ conn.auto_attach_owner_sessions_for_target_type("page")
+ .into_iter()
+ .filter(|owner_session_id| {
+ super::browser_level_auto_attach_owner_session_allowed(
+ conn,
+ owner_session_id.as_deref(),
+ )
+ })
+ .collect()
+}
+
+pub(super) fn top_level_tab_auto_attach_owner_sessions(
+ conn: &CdpConnection,
+) -> Vec<Option<String>> {
+ conn.auto_attach_owner_sessions_for_target_type("tab")
+ .into_iter()
+ .filter(|owner_session_id| {
+ super::browser_level_auto_attach_owner_session_allowed(
+ conn,
+ owner_session_id.as_deref(),
+ )
+ })
+ .collect()
+}
+
+fn activate_browser_context_for_create_target(
+ conn: &mut CdpConnection,
+ command: &DevToolsCreateTargetCommand,
+) -> Result<(), DevToolsError> {
+ if let Some(wanted_id) = command.browser_context_id.as_ref() {
+ if wanted_id.as_str() == conn.default_browser_context_id()
+ && !conn.has_browser_context_id(wanted_id.as_str())
+ {
+ conn.insert_browser_context(conn.new_browser_context(wanted_id.as_str().to_owned()));
+ }
+ if conn.activate_browser_context_by_id(wanted_id.as_str()) {
+ return Ok(());
+ }
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "UnknownBrowserContextId",
+ ));
+ }
+
+ let Some(reference_target_id) = command.context.target_id.as_ref() else {
+ return Ok(());
+ };
+ let Some(route) = conn.target_session_route_for_target_id(reference_target_id.as_str()) else {
+ if conn
+ .target_session_route_for_child_frame_id(reference_target_id.as_str())
+ .is_some()
+ {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::InvalidArgument,
+ "ReferenceContextNotTopLevel",
+ ));
+ }
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "NoSuchTarget",
+ ));
+ };
+ let Some(browser_context_id) = route.browser_context_id() else {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "NoSuchTarget",
+ ));
+ };
+ if conn.activate_browser_context_by_id(browser_context_id) {
+ Ok(())
+ } else {
+ Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "NoSuchTarget",
+ ))
+ }
+}
diff --git a/moli-protocol/src/domains/target/info.rs b/moli-protocol/src/domains/target/info.rs
new file mode 100644
index 000000000..ee8612066
--- /dev/null
+++ b/moli-protocol/src/domains/target/info.rs
@@ -0,0 +1,126 @@
+use serde::Deserialize;
+
+use crate::devtools_runtime::{
+ DevToolsGetTargetInfoCommand, DevToolsGetTargetInfoResult, DevToolsTargetId,
+};
+
+use super::*;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct GetTargetInfoParams {
+ target_id: Option<String>,
+}
+
+pub(super) fn get_target_info(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {
+ let params: GetTargetInfoParams = match cmd.get_params() {
+ Ok(Some(p)) => p,
+ Ok(None) => GetTargetInfoParams { target_id: None },
+ Err(e) => {
+ return CommandOutputPlan::error_without_session(-32602, e);
+ }
+ };
+ if !conn.target_handler_may_get_target_info(cmd.session_id, params.target_id.as_deref()) {
+ return CommandOutputPlan::error(-32000, "Not allowed");
+ }
+ let command = build_cdp_get_target_info_command(cmd, params);
+ match super::start_devtools_target_command(
+ conn,
+ cmd.id,
+ cmd.session_id,
+ DevToolsCommand::GetTargetInfo(command),
+ ) {
+ TargetCommandTaskStep::Complete(plan) => plan,
+ TargetCommandTaskStep::Pending(_) => {
+ CommandOutputPlan::error_without_session(-32000, "UnexpectedPending")
+ }
+ }
+}
+
+fn build_cdp_get_target_info_command(
+ cmd: &Cmd<'_>,
+ params: GetTargetInfoParams,
+) -> DevToolsGetTargetInfoCommand {
+ DevToolsGetTargetInfoCommand {
+ context: cmd.devtools_command_context(params.target_id.as_deref(), None::<&str>),
+ target_id: params.target_id.map(DevToolsTargetId::from),
+ }
+}
+
+pub(super) fn start_devtools_get_target_info_command(
+ conn: &CdpConnection,
+ command: DevToolsGetTargetInfoCommand,
+) -> CommandOutputPlan {
+ match execute_devtools_get_target_info_command(conn, command) {
+ Ok(result) => {
+ CommandOutputPlan::from_devtools_result(DevToolsCommandResult::GetTargetInfo(result))
+ }
+ Err(error) => CommandOutputPlan::from_devtools_error(error),
+ }
+}
+
+pub(super) fn execute_devtools_get_target_info_command(
+ conn: &CdpConnection,
+ command: DevToolsGetTargetInfoCommand,
+) -> Result<DevToolsGetTargetInfoResult, DevToolsError> {
+ let owner_target_id = command
+ .context
+ .target_id
+ .as_ref()
+ .map(|target_id| target_id.as_str().to_owned())
+ .or_else(|| {
+ conn.non_browser_target_id_for_session(
+ command
+ .context
+ .session_id
+ .as_ref()
+ .map(|session_id| session_id.as_str()),
+ )
+ });
+ let wanted = command
+ .target_id
+ .as_ref()
+ .map(|target_id| target_id.as_str())
+ .or(owner_target_id.as_deref());
+ let Some(wanted) = wanted else {
+ return Ok(DevToolsGetTargetInfoResult {
+ target_info: super::browser_context::devtools_browser_target_info(),
+ });
+ };
+ if wanted == super::browser_context::DEVTOOLS_BROWSER_TARGET_ID {
+ return Ok(DevToolsGetTargetInfoResult {
+ target_info: super::browser_context::devtools_browser_target_info(),
+ });
+ }
+ if conn.browser_context.is_none() && conn.inactive_browser_contexts.is_empty() {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "BrowserContextNotLoaded",
+ ));
+ }
+ let target_exists = conn.browser_contexts().any(|bc| {
+ bc.has_active_target()
+ || !bc.background_targets.is_empty()
+ || bc.has_any_shared_worker_targets()
+ || bc.has_any_dedicated_worker_targets()
+ || bc.has_any_service_worker_targets()
+ });
+ if !target_exists {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::NoSuchTarget,
+ "TargetNotLoaded",
+ ));
+ }
+ let target_info = conn.tab_target_info(wanted);
+ if let Some(target_info) = target_info {
+ return Ok(DevToolsGetTargetInfoResult { target_info });
+ }
+ let target_info = conn
+ .browser_contexts()
+ .find_map(|browser_context| browser_context.devtools_target_info(wanted))
+ .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId"))?;
+ if let Some(message) = super::transient_no_page_devtools_target_info_error(conn, &target_info) {
+ return Err(DevToolsError::new(DevToolsErrorKind::Internal, message));
+ }
+ Ok(DevToolsGetTargetInfoResult { target_info })
+}
diff --git a/moli-protocol/src/domains/target/lifecycle.rs b/moli-protocol/src/domains/target/lifecycle.rs
deleted file mode 100644
index 40e40a24b..000000000
--- a/moli-protocol/src/domains/target/lifecycle.rs
+++ /dev/null
@@ -1,3262 +0,0 @@
-use serde::Deserialize;
-
-use crate::conn::{
- BackgroundProtocolEvent, CdpTargetFilter, CdpTargetFilterEntry, PopupTargetActivationAction,
- PopupTargetNavigationKind, PopupTargetNavigationOwnerAction, PreparedTargetAttach,
- TargetAttachSessionCommit,
-};
-use crate::devtools_runtime::{
- DevToolsActivateTargetCommand, DevToolsBrowserContextId, DevToolsCloseTargetCommand,
- DevToolsCloseTargetResult, DevToolsCommand, DevToolsCommandResult, DevToolsCreateTargetCommand,
- DevToolsCreateTargetResult, DevToolsError, DevToolsErrorKind, DevToolsGetTargetInfoCommand,
- DevToolsGetTargetInfoResult, DevToolsTargetId, DevToolsTargetInfo,
-};
-
-use crate::domains::command_output::CommandOutputPlan;
-
-use super::*;
-
-pub(super) struct DevToolsCreateTargetExecution {
- pub(super) result: DevToolsCreateTargetResult,
- pub(super) protocol_events: CreatedTargetProtocolEvents,
-}
-
-pub(super) struct CreatedTargetProtocolEvents {
- page_target_id: String,
- tab_target_id: String,
- demoted_target_id: Option<String>,
- attached_tab_sessions: Vec<TargetAttachSessionCommit>,
- attached_sessions: Vec<TargetAttachSessionCommit>,
-}
-
-impl CreatedTargetProtocolEvents {
- pub(super) fn page_target_id(&self) -> &str {
- &self.page_target_id
- }
-
- pub(super) fn demoted_target_id(&self) -> Option<&str> {
- self.demoted_target_id.as_deref()
- }
-}
-
-pub(super) async fn synchronize_created_target_activation_async(
- conn: &mut CdpConnection,
- events: &CreatedTargetProtocolEvents,
-) -> Vec<BackgroundProtocolEvent> {
- let Some(demoted_target_id) = events.demoted_target_id() else {
- return Vec::new();
- };
- let screencast_visibility_events = conn
- .page_screencast_session_ids_for_target(demoted_target_id)
- .into_iter()
- .map(|session_id| {
- BackgroundProtocolEvent::page_screencast_visibility_changed(
- session_id.as_deref(),
- false,
- )
- })
- .collect();
- if let Err(error) = conn
- .apply_parked_target_surface_overrides_async(demoted_target_id)
- .await
- {
- tracing::warn!(
- target_id = demoted_target_id,
- %error,
- "failed to update Page visibility after createTarget activation"
- );
- }
- screencast_visibility_events
-}
-
-#[derive(Clone, Copy)]
-enum CreateTargetResultHost {
- Page,
- Tab,
-}
-
-pub(super) fn emit_created_target_protocol_events(
- conn: &mut CdpConnection,
- events: CreatedTargetProtocolEvents,
- out: &mut impl events::CdpTargetAutomationEventSink,
-) -> Result<(), DevToolsError> {
- let has_discovery = conn.has_any_target_discovery();
- if !has_discovery
- && events.attached_tab_sessions.is_empty()
- && events.attached_sessions.is_empty()
- {
- return Ok(());
- }
- let bc = conn
- .browser_contexts()
- .find(|browser_context| {
- browser_context
- .devtools_target_info(&events.page_target_id)
- .is_some()
- })
- .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId"))?;
- let target_info = bc
- .devtools_target_info(&events.page_target_id)
- .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId"))?;
- if let Some(message) = super::transient_no_page_devtools_target_info_error(conn, &target_info) {
- return Err(DevToolsError::new(DevToolsErrorKind::Internal, message));
- }
- if has_discovery {
- for event in conn.target_created_event_plan(&events.page_target_id) {
- out.push_target_background_event(event);
- }
- }
- if let Some(tab_target_info) = conn.tab_target_info_for_page_target_info(&target_info) {
- let tab_target_id = tab_target_info
- .target_id
- .as_ref()
- .map(|target_id| target_id.as_str().to_owned())
- .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::Internal, "MissingTabTargetId"))?;
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- tab_target_id,
- tab_target_info,
- events.attached_tab_sessions,
- ));
- for event in event_plan {
- out.push_target_background_event(event);
- }
- }
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- events.page_target_id,
- target_info,
- events.attached_sessions,
- ));
- for event in event_plan {
- out.push_target_background_event(event);
- }
- Ok(())
-}
-
-fn push_target_created_events(
- conn: &mut CdpConnection,
- out: &mut impl events::CdpTargetAutomationEventSink,
- page_target_id: &str,
-) {
- for event in conn.target_created_event_plan(page_target_id) {
- out.push_target_background_event(event);
- }
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct CreateTargetParams {
- #[serde(default = "default_blank")]
- url: String,
- browser_context_id: Option<String>,
- for_tab: Option<bool>,
- background: Option<bool>,
- focus: Option<bool>,
-}
-
-fn default_blank() -> String {
- "about:blank".into()
-}
-
-pub(super) fn start_create_target_command(
- conn: &mut CdpConnection,
- cmd: &Cmd<'_>,
-) -> TargetCommandTaskStep {
- if let Some(session_id) = cmd.session_id
- && matches!(
- conn.session_route(Some(session_id)),
- Some(
- crate::conn::CdpSessionRoute::SharedWorkerTarget { .. }
- | crate::conn::CdpSessionRoute::DedicatedWorkerTarget { .. }
- )
- )
- {
- return super::target_command_error(-31998, "DirectSessionRouteRequired");
- }
-
- let params: CreateTargetParams = match cmd.get_params() {
- Ok(Some(p)) => p,
- Ok(None) => CreateTargetParams {
- url: "about:blank".into(),
- browser_context_id: None,
- for_tab: None,
- background: None,
- focus: None,
- },
- Err(e) => {
- return super::target_command_error(-32602, e);
- }
- };
- let result_host = if params.for_tab.unwrap_or(false) {
- CreateTargetResultHost::Tab
- } else {
- CreateTargetResultHost::Page
- };
- let command = match build_cdp_create_target_command(cmd, params) {
- Ok(command) => command,
- Err(message) => return super::target_command_error(-32602, message),
- };
- start_devtools_create_target_command_with_result_host(
- conn,
- cmd.id,
- cmd.session_id,
- command,
- result_host,
- )
-}
-
-fn build_cdp_create_target_command(
- cmd: &Cmd<'_>,
- params: CreateTargetParams,
-) -> Result<DevToolsCreateTargetCommand, &'static str> {
- let should_focus = params.focus.unwrap_or(!params.background.unwrap_or(false));
- let create_in_background = params.background.unwrap_or(false) || params.focus == Some(false);
- if should_focus && create_in_background {
- return Err("Can't focus a target in the background. Use background=false instead.");
- }
- Ok(DevToolsCreateTargetCommand {
- context: cmd.devtools_command_context(None::<&str>, params.browser_context_id.as_deref()),
- url: params.url,
- browser_context_id: params
- .browser_context_id
- .map(DevToolsBrowserContextId::from),
- activate: !create_in_background,
- })
-}
-
-pub(super) fn start_devtools_create_target_command(
- conn: &mut CdpConnection,
- command_id: Option<u64>,
- command_session_id: Option<&str>,
- command: DevToolsCreateTargetCommand,
-) -> TargetCommandTaskStep {
- start_devtools_create_target_command_with_result_host(
- conn,
- command_id,
- command_session_id,
- command,
- CreateTargetResultHost::Page,
- )
-}
-
-fn start_devtools_create_target_command_with_result_host(
- conn: &mut CdpConnection,
- command_id: Option<u64>,
- command_session_id: Option<&str>,
- command: DevToolsCreateTargetCommand,
- result_host: CreateTargetResultHost,
-) -> TargetCommandTaskStep {
- let mut plan = CommandOutputPlan::default();
- let execution = execute_devtools_create_target_command(conn, command);
- let (created_target_id, created_target_protocol_events) = match execution {
- Ok(execution) => {
- let target_id = execution.result.target_id.clone();
- let response_target_id = match result_host {
- CreateTargetResultHost::Page => execution.result.target_id,
- CreateTargetResultHost::Tab => {
- DevToolsTargetId::from(execution.protocol_events.tab_target_id.as_str())
- }
- };
- plan.extend(CommandOutputPlan::from_devtools_result(
- DevToolsCommandResult::CreateTarget(DevToolsCreateTargetResult {
- target_id: response_target_id,
- }),
- ));
- (target_id, execution.protocol_events)
- }
- Err(error) => {
- plan.extend(CommandOutputPlan::from_devtools_error(error));
- return TargetCommandTaskStep::Complete(plan);
- }
- };
- 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)
- } else {
- Ok(None)
- };
- match pending_initial_document {
- Ok(Some(initial_document)) => {
- TargetCommandTaskStep::Pending(PendingTargetCommandDispatch {
- command_id,
- session_id: command_session_id.map(str::to_owned),
- kind: Box::new(PendingTargetCommandKind::CreateTarget {
- response_plan: plan,
- protocol_events: created_target_protocol_events,
- initial_document_route,
- initial_document: Some(Box::new(initial_document)),
- }),
- })
- }
- Ok(None) => {
- let mut output_plan = CommandOutputPlan::default();
- let mut protocol_events = Vec::new();
- if let Err(error) = emit_created_target_protocol_events(
- conn,
- created_target_protocol_events,
- &mut protocol_events,
- ) {
- return TargetCommandTaskStep::Complete(CommandOutputPlan::from_devtools_error(
- error,
- ));
- }
- for event in protocol_events {
- output_plan.push_background_event(event);
- }
- output_plan.extend(plan);
- TargetCommandTaskStep::Complete(output_plan)
- }
- Err(message) => TargetCommandTaskStep::Complete(CommandOutputPlan::error(-32000, message)),
- }
-}
-
-pub(super) fn execute_devtools_create_target_command(
- conn: &mut CdpConnection,
- command: DevToolsCreateTargetCommand,
-) -> Result<DevToolsCreateTargetExecution, DevToolsError> {
- let restore_browser_context_id = previously_active_browser_context_id(conn);
- if let Err(error) = activate_browser_context_for_create_target(conn, &command) {
- restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
- return Err(error);
- }
- if conn.browser_context.is_none() && conn.inactive_browser_contexts.is_empty() {
- let id = conn.gen_bc_id();
- conn.insert_browser_context(conn.new_browser_context(id));
- }
-
- let target_id = conn.gen_target_id();
- let default_target_id = conn.default_target_id();
- let (has_active_target, previous_active_target_id) = {
- let browser_context = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist before target creation");
- (
- browser_context.active_target_identity().is_some()
- && !browser_context
- .active_target_is_unclaimed_default_placeholder(default_target_id),
- browser_context.active_target_id_owned(),
- )
- };
- let auto_attach_page_owners = top_level_page_auto_attach_owner_sessions(conn);
- let auto_attach_tab_owners = top_level_tab_auto_attach_owner_sessions(conn);
- let auto_attached_page_sessions = auto_attach_page_owners
- .iter()
- .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
- .collect::<Vec<_>>();
- let auto_attached_tab_sessions = auto_attach_tab_owners
- .iter()
- .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
- .collect::<Vec<_>>();
- let creating_background_target = has_active_target && !command.activate;
- let auto_attached_background_session_id = if creating_background_target {
- auto_attached_page_sessions
- .first()
- .map(|(_, session_id)| session_id.clone())
- } else {
- None
- };
- let activating_created_target = has_active_target && command.activate;
- let demoted_target_id = if activating_created_target {
- previous_active_target_id
- } else {
- None
- };
- let initial_empty_document_url = create_target_initial_empty_document_url(&command.url);
- if activating_created_target {
- conn.handoff_navigation_engine_for_active_target_demotion();
- }
- {
- let bc = conn.browser_context.as_mut().unwrap();
- if creating_background_target {
- bc.stage_background_target(
- target_id.clone(),
- auto_attached_background_session_id.clone(),
- command.url.clone(),
- Some(initial_empty_document_url.clone()),
- None,
- );
- } else if activating_created_target {
- bc.stage_active_target_demoting_current(
- target_id.clone(),
- None,
- command.url.clone(),
- Some(initial_empty_document_url.clone()),
- );
- } else {
- bc.set_active_target_id(target_id.clone());
- bc.set_target_url(command.url.clone());
- bc.begin_active_target_initial_empty_document(initial_empty_document_url.clone());
- bc.active_target.owner_state.target_crash_state.clear();
- }
- if command.url != initial_empty_document_url {
- // Chromium gives Target.createTarget(url) one initial
- // auto_toplevel history entry for url. The implementation still
- // materializes an internal about:blank document for target setup,
- // so replace that bookkeeping entry when the requested URL commits.
- bc.mark_target_initial_url_replaces_empty_document(&target_id);
- }
- }
- let tab_target_id = conn.register_top_level_page_target(&target_id);
- if !creating_background_target {
- conn.notify_target_host_activated(&target_id);
- }
- let created_target_id = target_id.clone();
-
- let mut attached_tab_sessions = Vec::new();
- for (owner_session_id, session_id) in &auto_attached_tab_sessions {
- let waiting_for_debugger =
- conn.auto_attach_owner_waits_for_debugger_on_start(owner_session_id.as_deref());
- let assigned = conn.prepare_auto_attached_tab_session_binding(
- &tab_target_id,
- session_id.clone(),
- owner_session_id.as_deref(),
- );
- debug_assert!(assigned, "created tab target must remain addressable");
- attached_tab_sessions.push(conn.prepare_auto_attach_session_commit(
- session_id.clone(),
- owner_session_id.clone(),
- waiting_for_debugger,
- ));
- }
-
- let mut attached_sessions = Vec::new();
- for (index, (owner_session_id, session_id)) in auto_attached_page_sessions.iter().enumerate() {
- let waiting_for_debugger =
- conn.auto_attach_owner_waits_for_debugger_on_start(owner_session_id.as_deref());
- if creating_background_target && index == 0 {
- attached_sessions.push(conn.prepare_auto_attach_session_commit(
- session_id.clone(),
- owner_session_id.clone(),
- waiting_for_debugger,
- ));
- } else {
- let assigned =
- conn.prepare_auto_attached_page_session_binding(&target_id, session_id.clone());
- debug_assert!(
- assigned,
- "newly created target must remain addressable for auto attach"
- );
- attached_sessions.push(conn.prepare_auto_attach_session_commit(
- session_id.clone(),
- owner_session_id.clone(),
- waiting_for_debugger,
- ));
- }
- }
- if activating_created_target {
- conn.apply_active_engine_fetch_overrides();
- conn.invalidate_resource_runtime();
- }
-
- // Chromium parity: Target.createTarget acks from target lifecycle, while
- // the initial document page build remains target-owned pending work. CDP
- // observation commands must only see an already-installed Page or a real
- // no-document state; they do not create the initial document themselves.
- // See content/browser/devtools/protocol/target_handler.cc:1291.
- restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
-
- Ok(DevToolsCreateTargetExecution {
- result: DevToolsCreateTargetResult {
- target_id: DevToolsTargetId::from(created_target_id),
- },
- protocol_events: CreatedTargetProtocolEvents {
- page_target_id: target_id,
- tab_target_id,
- demoted_target_id,
- attached_tab_sessions,
- attached_sessions,
- },
- })
-}
-
-fn create_target_initial_empty_document_url(target_url: &str) -> String {
- if url::Url::parse(target_url)
- .ok()
- .as_ref()
- .is_some_and(moli_url::is_about_blank)
- {
- target_url.to_owned()
- } else {
- "about:blank".to_owned()
- }
-}
-
-fn top_level_page_auto_attach_owner_sessions(conn: &CdpConnection) -> Vec<Option<String>> {
- conn.auto_attach_owner_sessions_for_target_type("page")
- .into_iter()
- .filter(|owner_session_id| {
- super::browser_level_auto_attach_owner_session_allowed(
- conn,
- owner_session_id.as_deref(),
- )
- })
- .collect()
-}
-
-fn top_level_tab_auto_attach_owner_sessions(conn: &CdpConnection) -> Vec<Option<String>> {
- conn.auto_attach_owner_sessions_for_target_type("tab")
- .into_iter()
- .filter(|owner_session_id| {
- super::browser_level_auto_attach_owner_session_allowed(
- conn,
- owner_session_id.as_deref(),
- )
- })
- .collect()
-}
-
-fn activate_browser_context_for_create_target(
- conn: &mut CdpConnection,
- command: &DevToolsCreateTargetCommand,
-) -> Result<(), DevToolsError> {
- if let Some(wanted_id) = command.browser_context_id.as_ref() {
- if wanted_id.as_str() == conn.default_browser_context_id()
- && !conn.has_browser_context_id(wanted_id.as_str())
- {
- conn.insert_browser_context(conn.new_browser_context(wanted_id.as_str().to_owned()));
- }
- if conn.activate_browser_context_by_id(wanted_id.as_str()) {
- return Ok(());
- }
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "UnknownBrowserContextId",
- ));
- }
-
- let Some(reference_target_id) = command.context.target_id.as_ref() else {
- return Ok(());
- };
- let Some(route) = conn.target_session_route_for_target_id(reference_target_id.as_str()) else {
- if conn
- .target_session_route_for_child_frame_id(reference_target_id.as_str())
- .is_some()
- {
- return Err(DevToolsError::new(
- DevToolsErrorKind::InvalidArgument,
- "ReferenceContextNotTopLevel",
- ));
- }
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "NoSuchTarget",
- ));
- };
- let Some(browser_context_id) = route.browser_context_id() else {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "NoSuchTarget",
- ));
- };
- if conn.activate_browser_context_by_id(browser_context_id) {
- Ok(())
- } else {
- Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "NoSuchTarget",
- ))
- }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct PopupTargetOpenerIdentity {
- target_id: String,
- frame_id: String,
-}
-
-impl PopupTargetOpenerIdentity {
- pub(crate) fn new(target_id: impl Into<String>, frame_id: impl Into<String>) -> Self {
- Self {
- target_id: target_id.into(),
- frame_id: frame_id.into(),
- }
- }
-}
-
-/// A renderer-accepted auxiliary browsing-context action whose destination
-/// browser context, DevTools opener identity, and DOM opener access were
-/// frozen before protocol emission.
-///
-/// Unlike a protocol Target.createTarget command, this action must not select
-/// the browser context or opener from whichever session happens to drain it.
-#[derive(Clone, Debug)]
-pub(crate) struct PopupTargetCreation {
- browser_context_id: String,
- popup_id: Option<u64>,
- url: String,
- target_name: String,
- opener: Option<PopupTargetOpenerIdentity>,
- can_access_opener: bool,
- disposition: moli_core::page::RendererPopupDisposition,
- session_storage_store: Option<moli_core::network::SharedWebStorageStore>,
- initial_empty_document_storage_key: Option<moli_storage_key::MoliStorageKey>,
-}
-
-impl PopupTargetCreation {
- pub(crate) fn new(
- browser_context_id: String,
- popup_id: Option<u64>,
- url: String,
- target_name: String,
- opener: Option<PopupTargetOpenerIdentity>,
- can_access_opener: bool,
- disposition: moli_core::page::RendererPopupDisposition,
- session_storage_store: Option<moli_core::network::SharedWebStorageStore>,
- initial_empty_document_storage_key: Option<moli_storage_key::MoliStorageKey>,
- ) -> Self {
- Self {
- browser_context_id,
- popup_id,
- url,
- target_name,
- opener,
- can_access_opener,
- disposition,
- session_storage_store,
- initial_empty_document_storage_key,
- }
- }
-}
-
-pub(crate) async fn create_popup_target_from_renderer_output_background_events_async(
- conn: &mut CdpConnection,
- out: &mut Vec<BackgroundProtocolEvent>,
- creation: PopupTargetCreation,
-) -> Option<String> {
- let PopupTargetCreation {
- browser_context_id,
- popup_id,
- url,
- target_name,
- opener,
- can_access_opener,
- disposition,
- session_storage_store,
- initial_empty_document_storage_key,
- } = creation;
- let Some(browser_context) = conn.browser_context_by_id(&browser_context_id) else {
- tracing::debug!(
- browser_context_id,
- ?popup_id,
- ?target_name,
- "dropping accepted popup action after its browser context was removed"
- );
- return None;
- };
-
- if let Some(existing_target_id) = browser_context
- .target_id_for_window_name(&target_name)
- .map(str::to_owned)
- {
- let navigation =
- popup_target_has_loaded_page(conn, &browser_context_id, &existing_target_id)
- .then(|| {
- PopupTargetNavigationOwnerAction::capture(
- conn,
- &browser_context_id,
- &existing_target_id,
- url.clone(),
- PopupTargetNavigationKind::NamedTargetReuse,
- )
- })
- .flatten();
- let activation = (disposition == moli_core::page::RendererPopupDisposition::Foreground)
- .then(|| {
- PopupTargetActivationAction::capture(conn, &browser_context_id, &existing_target_id)
- })
- .flatten();
-
- let target_url_updated = conn
- .browser_context_by_id_mut(&browser_context_id)
- .is_some_and(|browser_context| {
- browser_context.update_target_url(&existing_target_id, url.clone())
- });
- if target_url_updated {
- emit_target_info_changed_for_target_background_event(
- conn,
- out,
- &browser_context_id,
- &existing_target_id,
- );
- if let Some(navigation) = navigation {
- conn.publish_popup_target_navigation_owner_action(navigation);
- }
- if let Some(activation) = activation {
- conn.publish_popup_target_activation_action(activation);
- }
- }
- return (target_url_updated
- && remember_resolved_popup_target(
- conn,
- &browser_context_id,
- popup_id,
- &existing_target_id,
- ))
- .then_some(existing_target_id);
- }
-
- // The renderer has already accepted an auxiliary-context action. Even when
- // noopener blocks script access, Chromium preserves the creator target and
- // frame as DevTools attribution for the new auxiliary target.
- let opener = opener.filter(|opener| {
- conn.browser_context_by_id(&browser_context_id)
- .and_then(|browser_context| browser_context.devtools_target_info(&opener.target_id))
- .is_some()
- });
- let can_access_opener = can_access_opener && opener.is_some();
- let popup_creator = if can_access_opener {
- opener.as_ref().and_then(|opener| {
- conn.browser_context_by_id(&browser_context_id)
- .and_then(|browser_context| {
- browser_context.initial_empty_document_creator_for_target(&opener.target_id)
- })
- })
- } else {
- None
- };
- let target_id = conn.gen_target_id();
- let auto_attach_page_owners = top_level_page_auto_attach_owner_sessions(conn);
- let auto_attach_tab_owners = top_level_tab_auto_attach_owner_sessions(conn);
- let auto_attached_page_sessions = auto_attach_page_owners
- .iter()
- .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
- .collect::<Vec<_>>();
- let auto_attached_tab_sessions = auto_attach_tab_owners
- .iter()
- .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
- .collect::<Vec<_>>();
- let auto_attached_background_session_id = auto_attached_page_sessions
- .first()
- .map(|(_, session_id)| session_id.clone());
- let requested_url = url.clone();
-
- {
- let browser_context = conn.browser_context_by_id_mut(&browser_context_id)?;
- browser_context.stage_popup_background_target(
- target_id.clone(),
- auto_attached_background_session_id.clone(),
- url,
- Some("about:blank".to_owned()),
- popup_creator,
- session_storage_store,
- initial_empty_document_storage_key,
- );
- if let Some(opener) = opener {
- browser_context.remember_target_opener(
- &target_id,
- opener.target_id,
- opener.frame_id,
- can_access_opener,
- );
- }
- browser_context.remember_target_window_name(&target_name, &target_id);
- browser_context.remember_target_popup_id(popup_id, &target_id);
- }
-
- let tab_target_id = conn.register_top_level_page_target(&target_id);
- for (owner_session_id, session_id) in &auto_attached_tab_sessions {
- let assigned = conn.prepare_auto_attached_tab_session_binding(
- &tab_target_id,
- session_id.clone(),
- owner_session_id.as_deref(),
- );
- assert!(assigned, "created popup tab target must remain addressable");
- }
- for (index, (_, session_id)) in auto_attached_page_sessions.iter().enumerate() {
- if index != 0 || auto_attached_background_session_id.is_none() {
- let assigned = conn.prepare_auto_attached_page_session_binding_in_browser_context(
- &browser_context_id,
- &target_id,
- session_id.clone(),
- );
- assert!(
- assigned,
- "newly created popup target must remain addressable"
- );
- }
- }
-
- if !ensure_popup_initial_document_page_async(conn, &target_id).await {
- rollback_incomplete_popup_target_async(conn, Some(&browser_context_id), &target_id).await;
- return None;
- }
-
- let Some(target_info) = conn
- .browser_context_by_id(&browser_context_id)
- .and_then(|browser_context| browser_context.devtools_target_info(&target_id))
- else {
- rollback_incomplete_popup_target_async(conn, Some(&browser_context_id), &target_id).await;
- return None;
- };
- let Some(tab_target_info) = conn.tab_target_info(&tab_target_id) else {
- rollback_incomplete_popup_target_async(conn, Some(&browser_context_id), &target_id).await;
- return None;
- };
- if conn.has_any_target_discovery() {
- push_target_created_events(conn, out, &target_id);
- } else {
- // Chromium's BiDi mapper keeps a target observer alive independently
- // of whether any frontend subscribed to `Target.targetCreated`.
- // Preserve that separation here: CDP discovery controls only the CDP
- // notification, while the accepted auxiliary browsing-context action
- // always publishes one typed automation lifecycle fact. This is
- // especially important for popup creation that settles after the
- // causing Runtime command response.
- out.push(BackgroundProtocolEvent::automation_only(
- events::target_created_automation_event(target_info.clone()),
- ));
- }
- push_committed_auto_attached_session_events(
- conn,
- out,
- &auto_attached_tab_sessions,
- &tab_target_id,
- tab_target_info,
- );
- push_committed_auto_attached_session_events(
- conn,
- out,
- &auto_attached_page_sessions,
- &target_id,
- target_info,
- );
- if !conn.target_has_waiting_for_debugger_session(&target_id)
- && let Some(navigation) = PopupTargetNavigationOwnerAction::capture(
- conn,
- &browser_context_id,
- &target_id,
- requested_url,
- PopupTargetNavigationKind::InitialDocument,
- )
- {
- conn.publish_popup_target_navigation_owner_action(navigation);
- }
- if disposition == moli_core::page::RendererPopupDisposition::Foreground
- && let Some(activation) =
- PopupTargetActivationAction::capture(conn, &browser_context_id, &target_id)
- {
- conn.publish_popup_target_activation_action(activation);
- }
- Some(target_id)
-}
-
-fn remember_resolved_popup_target(
- conn: &mut CdpConnection,
- browser_context_id: &str,
- popup_id: Option<u64>,
- target_id: &str,
-) -> bool {
- conn.browser_context_by_id_mut(browser_context_id)
- .is_some_and(|browser_context| {
- if browser_context.devtools_target_info(target_id).is_none() {
- return false;
- }
- browser_context.remember_target_popup_id(popup_id, target_id);
- true
- })
-}
-async fn ensure_popup_initial_document_page_async(
- conn: &mut CdpConnection,
- target_id: &str,
-) -> bool {
- let Some(route) = conn.target_session_route_for_target_id(target_id) else {
- return false;
- };
- {
- 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)
- {
- Ok(pending) => pending,
- Err(message) => {
- tracing::debug!(
- target_id,
- ?message,
- "failed to start popup initial document page ensure"
- );
- return false;
- }
- };
- if let Some(pending) = pending {
- 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);
- tracing::debug!(
- target_id,
- ?message,
- "failed to await popup initial document page ensure"
- );
- return false;
- }
- };
- if let Err(message) = route_scope
- .conn_mut()
- .complete_initial_document_page_build_for_owner(completed)
- .await
- {
- tracing::debug!(
- target_id,
- ?message,
- "failed to complete popup initial document page ensure"
- );
- return false;
- }
- }
- }
- true
-}
-
-fn push_committed_auto_attached_session_events(
- conn: &mut CdpConnection,
- out: &mut impl events::CdpTargetAutomationEventSink,
- sessions: &[(Option<String>, String)],
- target_id: &str,
- target_info: DevToolsTargetInfo,
-) {
- let sessions = sessions
- .iter()
- .map(|(owner_session_id, session_id)| {
- conn.prepare_auto_attach_session_commit(
- session_id.clone(),
- owner_session_id.clone(),
- conn.auto_attach_owner_waits_for_debugger_on_start(owner_session_id.as_deref()),
- )
- })
- .collect::<Vec<_>>();
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- target_id,
- target_info,
- sessions,
- ));
- for event in event_plan {
- out.push_target_background_event(event);
- }
-}
-
-pub(super) async fn rollback_incomplete_popup_target_async(
- conn: &mut CdpConnection,
- browser_context_id: Option<&str>,
- target_id: &str,
-) {
- conn.rollback_incomplete_popup_target_without_event_async(browser_context_id, target_id)
- .await;
-}
-
-pub(super) async fn start_target_url_navigation_if_allowed_background_events_async(
- conn: &mut CdpConnection,
- out: &mut Vec<BackgroundProtocolEvent>,
- target_id: &str,
-) {
- if conn.target_has_waiting_for_debugger_session(target_id) {
- return;
- }
- 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
- };
- 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_should_start_initial_document_navigation(session_id) {
- return false;
- }
- let Some(target_url) = conn.runtime_session_owner_target_url(session_id) else {
- return false;
- };
- crate::domains::page::navigate_session_owner_from_renderer_background_events_async(
- conn,
- out,
- session_id,
- &target_url,
- )
- .await;
- true
-}
-
-fn popup_target_has_loaded_page(
- conn: &CdpConnection,
- browser_context_id: &str,
- target_id: &str,
-) -> bool {
- let Some(browser_context) = conn.browser_context_by_id(browser_context_id) else {
- return false;
- };
- if browser_context.is_active_target(target_id) {
- return browser_context.has_loaded_page();
- }
- browser_context
- .background_target(target_id)
- .is_some_and(|target| target.has_loaded_page())
-}
-
-pub(crate) async fn complete_popup_target_navigation_owner_action_async(
- conn: &mut CdpConnection,
- 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)| {
- 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,
- target_id,
- url,
- ?kind,
- "dropping popup navigation after its exact target owner retired"
- );
- return crate::conn::CdpTurnOutcome::new_with_protocol_events(
- Vec::new(),
- conn.take_scheduler_events(),
- );
- }
-
- let mut protocol_events = Vec::new();
- match kind {
- PopupTargetNavigationKind::InitialDocument => {
- if !conn.runtime_session_owner_should_start_initial_document_navigation(None) {
- return crate::conn::CdpTurnOutcome::new_with_protocol_events(
- Vec::new(),
- conn.take_scheduler_events(),
- );
- }
- }
- PopupTargetNavigationKind::NamedTargetReuse => {}
- }
- crate::domains::page::navigate_session_owner_from_renderer_background_events_async(
- conn,
- &mut protocol_events,
- None,
- &url,
- )
- .await;
- if kind == PopupTargetNavigationKind::InitialDocument {
- emit_target_info_changed_for_target_background_event(
- conn,
- &mut protocol_events,
- &browser_context_id,
- &target_id,
- );
- }
- crate::conn::CdpTurnOutcome::new_with_protocol_events(
- protocol_events,
- conn.take_scheduler_events(),
- )
-}
-
-pub(crate) async fn complete_popup_target_activation_action_async(
- conn: &mut CdpConnection,
- action: PopupTargetActivationAction,
-) -> crate::conn::CdpTurnOutcome {
- let (owner_scope, browser_context_id, target_id) = action.into_parts();
- let target_is_current = {
- let mut route_scope = owner_scope.enter(conn);
- let conn = route_scope.conn_mut();
- conn.target_owner_identity_for_session(None).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())
- },
- ) && popup_target_has_loaded_page(conn, &browser_context_id, &target_id)
- };
- if !target_is_current {
- tracing::debug!(
- browser_context_id,
- target_id,
- "dropping popup activation after its exact target owner retired"
- );
- return crate::conn::CdpTurnOutcome::new_with_protocol_events(
- Vec::new(),
- conn.take_scheduler_events(),
- );
- }
- let protocol_events =
- match activate_popup_target_async(conn, &browser_context_id, &target_id).await {
- Ok(events) => events,
- Err(error) => {
- tracing::debug!(
- browser_context_id,
- target_id,
- %error,
- "popup target could not be activated"
- );
- Vec::new()
- }
- };
- crate::conn::CdpTurnOutcome::new_with_protocol_events(
- protocol_events,
- conn.take_scheduler_events(),
- )
-}
-
-async fn activate_popup_target_async(
- conn: &mut CdpConnection,
- browser_context_id: &str,
- target_id: &str,
-) -> Result<Vec<BackgroundProtocolEvent>, String> {
- let restore_browser_context_id = previously_active_browser_context_id(conn);
- let result = if let Err(message) = select_browser_context_for_target(conn, target_id) {
- Err(message.to_owned())
- } else if conn
- .browser_context
- .as_ref()
- .is_none_or(|browser_context| browser_context.id != browser_context_id)
- {
- Err("PopupTargetBrowserContextChanged".to_owned())
- } else if conn
- .browser_context
- .as_ref()
- .is_some_and(|browser_context| browser_context.is_active_target(target_id))
- {
- Ok(Vec::new())
- } else {
- match conn
- .promote_background_target_to_active_for_connection_async(target_id)
- .await
- {
- Ok(Some(activation)) => Ok(activation.into_protocol_events()),
- Ok(None) => Err("PopupTargetUnavailable".to_owned()),
- Err(message) => Err(message),
- }
- };
- restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
- result
-}
-
-pub(crate) fn emit_target_info_changed_for_session_owner_background_event(
- conn: &mut CdpConnection,
- out: &mut Vec<BackgroundProtocolEvent>,
- session_id: Option<&str>,
-) {
- out.extend(conn.target_info_changed_event_plan_for_session_owner(session_id));
-}
-
-fn emit_target_info_changed_for_target_background_event(
- conn: &mut CdpConnection,
- out: &mut Vec<BackgroundProtocolEvent>,
- browser_context_id: &str,
- target_id: &str,
-) {
- out.extend(
- conn.target_info_changed_event_plan_for_observable_target(browser_context_id, target_id),
- );
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct CloseTargetParams {
- target_id: String,
-}
-
-pub(super) fn start_close_target_command(
- conn: &mut CdpConnection,
- cmd: &Cmd<'_>,
-) -> TargetCommandTaskStep {
- let params: CloseTargetParams = match cmd.get_params() {
- Ok(Some(p)) => p,
- _ => {
- return super::target_command_error(-32602, "InvalidParams");
- }
- };
- if !conn.target_handler_may_close_target(cmd.session_id, &params.target_id) {
- return super::target_command_error(-32000, "Not allowed");
- }
- let command = build_cdp_close_target_command(cmd, params);
- super::start_devtools_target_command(
- conn,
- cmd.id,
- cmd.session_id,
- DevToolsCommand::CloseTarget(command),
- )
-}
-
-fn build_cdp_close_target_command(
- cmd: &Cmd<'_>,
- params: CloseTargetParams,
-) -> DevToolsCloseTargetCommand {
- DevToolsCloseTargetCommand {
- context: cmd.devtools_command_context(Some(params.target_id.as_str()), None::<&str>),
- target_id: DevToolsTargetId::from(params.target_id),
- }
-}
-
-pub(super) fn start_devtools_close_target_command(
- command_id: Option<u64>,
- command_session_id: Option<&str>,
- command: DevToolsCloseTargetCommand,
-) -> TargetCommandTaskStep {
- pending_close_target_command(command_id, command_session_id, command)
-}
-
-pub(super) async fn complete_close_target_command_async(
- conn: &mut CdpConnection,
- command: DevToolsCloseTargetCommand,
- command_context: &mut crate::conn::CommandDispatchContext,
-) -> CommandOutputPlan {
- let mut side_effects = events::TargetProtocolSideEffects::default();
- match execute_devtools_close_target_command_async(
- conn,
- command,
- &mut side_effects,
- command_context,
- )
- .await
- {
- Ok(result) => {
- let mut plan =
- CommandOutputPlan::from_devtools_result(DevToolsCommandResult::CloseTarget(result));
- plan.extend(side_effects.into_plan());
- plan
- }
- Err(error) => CommandOutputPlan::from_devtools_error(error),
- }
-}
-
-pub(super) async fn execute_devtools_close_target_command_async(
- conn: &mut CdpConnection,
- command: DevToolsCloseTargetCommand,
- out: &mut events::TargetProtocolSideEffects,
- command_context: &mut crate::conn::CommandDispatchContext,
-) -> Result<DevToolsCloseTargetResult, DevToolsError> {
- let target_id = command.target_id.into_string();
- let restore_browser_context_id = previously_active_browser_context_id(conn);
- let result = close_target_inner_async(conn, out, command_context, target_id).await;
- restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
- result
-}
-
-async fn close_target_inner_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- command_context: &mut crate::conn::CommandDispatchContext,
- target_id: String,
-) -> Result<DevToolsCloseTargetResult, DevToolsError> {
- let target_id = conn
- .primary_page_target_id_for_tab_target_id(&target_id)
- .map(str::to_owned)
- .unwrap_or(target_id);
- if let Err(message) = select_browser_context_for_target(conn, &target_id) {
- return Err(DevToolsError::new(DevToolsErrorKind::NoSuchTarget, message));
- }
- if conn
- .browser_context
- .as_ref()
- .is_some_and(|bc| bc.has_shared_worker_target(&target_id))
- {
- if !worker_target::close_shared_worker_target_for_target_close_async(
- conn,
- &target_id,
- command_context,
- )
- .await
- {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "UnknownTargetId",
- ));
- }
- return Ok(DevToolsCloseTargetResult { success: true });
- }
- if conn
- .browser_context
- .as_ref()
- .is_some_and(|bc| bc.has_dedicated_worker_target(&target_id))
- {
- if !worker_target::close_dedicated_worker_target_for_target_close_async(
- conn,
- &target_id,
- command_context,
- )
- .await
- {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "UnknownTargetId",
- ));
- }
- return Ok(DevToolsCloseTargetResult { success: true });
- }
- if conn
- .browser_context
- .as_ref()
- .is_some_and(|bc| bc.has_service_worker_target(&target_id))
- {
- return Ok(DevToolsCloseTargetResult { success: true });
- }
- if conn.browser_context.as_ref().is_some_and(|bc| {
- !matches!(
- bc.active_target_identity(),
- Some((ref active_target_id, _)) if active_target_id == &target_id
- )
- }) {
- let target_route = conn
- .target_session_route_for_target_id(&target_id)
- .ok_or_else(|| {
- DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId")
- })?;
- let session_id = conn
- .browser_context
- .as_ref()
- .and_then(|browser_context| browser_context.background_target(&target_id))
- .and_then(|target| target.session_id().map(str::to_owned));
- let owner_scope = crate::conn::CommandOwnerScope::from_session_and_owner_route(
- session_id.as_deref(),
- session_id.is_none().then_some(target_route),
- );
- let renderer_output_predecessor =
- events::fail_pending_fetch_state_for_target_background_events_async(
- conn,
- out.background_events_mut(),
- session_id.as_deref(),
- "Target closed",
- )
- .await;
- settle_target_close_after_pending_fetches_async(
- conn,
- out,
- command_context,
- renderer_output_predecessor,
- owner_scope,
- target_id,
- )
- .await;
- return Ok(DevToolsCloseTargetResult { success: true });
- }
-
- let session_id = match conn.browser_context.as_ref() {
- Some(bc) => {
- if !bc.has_active_target() && bc.background_targets.is_empty() {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "TargetNotLoaded",
- ));
- }
- match bc.active_target_identity() {
- Some((_active_target_id, session_id)) => session_id,
- None => {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "TargetNotLoaded",
- ));
- }
- }
- }
- None => {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "BrowserContextNotLoaded",
- ));
- }
- };
-
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- session_id.as_deref(),
- "Target closed",
- );
- let renderer_output_predecessor =
- events::fail_pending_fetch_state_for_target_background_events_async(
- conn,
- out.background_events_mut(),
- session_id.as_deref(),
- "Target closed",
- )
- .await;
- let owner_scope = crate::conn::CommandOwnerScope::capture(conn, session_id.as_deref());
- settle_target_close_after_pending_fetches_async(
- conn,
- out,
- command_context,
- renderer_output_predecessor,
- owner_scope,
- target_id,
- )
- .await;
- Ok(DevToolsCloseTargetResult { success: true })
-}
-
-/// Preserves the final renderer publication without changing the ordinary
-/// `Target.closeTarget` transaction boundary.
-///
-/// Most target closes produce no renderer output. Those closes still complete
-/// synchronously and return their detach/destroy side effects with the command,
-/// matching Chromium's target-domain behavior. A paused request can first
-/// produce a terminal renderer record, however. Only that case must defer
-/// target retirement until the command's exact cursor has crossed ordered
-/// ingress; otherwise retiring the route would discard that final record.
-async fn settle_target_close_after_pending_fetches_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- command_context: &mut crate::conn::CommandDispatchContext,
- renderer_output_predecessor: Option<moli_core::RendererOutputFence>,
- owner_scope: crate::conn::CommandOwnerScope,
- target_id: String,
-) {
- let action = crate::domains::page::PageTargetTerminationOwnerAction::new(
- owner_scope,
- target_id,
- crate::domains::page::PageTargetTerminationKind::TargetClose,
- );
- if let Some(predecessor) = renderer_output_predecessor {
- command_context.set_renderer_output_predecessor(predecessor);
- conn.publish_page_target_termination_owner_action(action);
- return;
- }
-
- let outcome =
- crate::domains::page::complete_page_target_termination_owner_action_async(conn, action)
- .await;
- let (events, scheduler_events) = outcome.into_protocol_event_parts();
- out.extend_background_events(events);
- conn.extend_scheduler_events(scheduler_events);
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct GetTargetInfoParams {
- target_id: Option<String>,
-}
-
-pub(super) fn get_target_info(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {
- let params: GetTargetInfoParams = match cmd.get_params() {
- Ok(Some(p)) => p,
- Ok(None) => GetTargetInfoParams { target_id: None },
- Err(e) => {
- return CommandOutputPlan::error_without_session(-32602, e);
- }
- };
- if !conn.target_handler_may_get_target_info(cmd.session_id, params.target_id.as_deref()) {
- return CommandOutputPlan::error(-32000, "Not allowed");
- }
- let command = build_cdp_get_target_info_command(cmd, params);
- match super::start_devtools_target_command(
- conn,
- cmd.id,
- cmd.session_id,
- DevToolsCommand::GetTargetInfo(command),
- ) {
- TargetCommandTaskStep::Complete(plan) => plan,
- TargetCommandTaskStep::Pending(_) => {
- CommandOutputPlan::error_without_session(-32000, "UnexpectedPending")
- }
- }
-}
-
-fn build_cdp_get_target_info_command(
- cmd: &Cmd<'_>,
- params: GetTargetInfoParams,
-) -> DevToolsGetTargetInfoCommand {
- DevToolsGetTargetInfoCommand {
- context: cmd.devtools_command_context(params.target_id.as_deref(), None::<&str>),
- target_id: params.target_id.map(DevToolsTargetId::from),
- }
-}
-
-pub(super) fn start_devtools_get_target_info_command(
- conn: &CdpConnection,
- command: DevToolsGetTargetInfoCommand,
-) -> CommandOutputPlan {
- match execute_devtools_get_target_info_command(conn, command) {
- Ok(result) => {
- CommandOutputPlan::from_devtools_result(DevToolsCommandResult::GetTargetInfo(result))
- }
- Err(error) => CommandOutputPlan::from_devtools_error(error),
- }
-}
-
-pub(super) fn execute_devtools_get_target_info_command(
- conn: &CdpConnection,
- command: DevToolsGetTargetInfoCommand,
-) -> Result<DevToolsGetTargetInfoResult, DevToolsError> {
- let owner_target_id = command
- .context
- .target_id
- .as_ref()
- .map(|target_id| target_id.as_str().to_owned())
- .or_else(|| {
- conn.non_browser_target_id_for_session(
- command
- .context
- .session_id
- .as_ref()
- .map(|session_id| session_id.as_str()),
- )
- });
- let wanted = command
- .target_id
- .as_ref()
- .map(|target_id| target_id.as_str())
- .or(owner_target_id.as_deref());
- let Some(wanted) = wanted else {
- return Ok(DevToolsGetTargetInfoResult {
- target_info: super::browser_context::devtools_browser_target_info(),
- });
- };
- if wanted == super::browser_context::DEVTOOLS_BROWSER_TARGET_ID {
- return Ok(DevToolsGetTargetInfoResult {
- target_info: super::browser_context::devtools_browser_target_info(),
- });
- }
- if conn.browser_context.is_none() && conn.inactive_browser_contexts.is_empty() {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "BrowserContextNotLoaded",
- ));
- }
- let target_exists = conn.browser_contexts().any(|bc| {
- bc.has_active_target()
- || !bc.background_targets.is_empty()
- || bc.has_any_shared_worker_targets()
- || bc.has_any_dedicated_worker_targets()
- || bc.has_any_service_worker_targets()
- });
- if !target_exists {
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "TargetNotLoaded",
- ));
- }
- let target_info = conn.tab_target_info(wanted);
- if let Some(target_info) = target_info {
- return Ok(DevToolsGetTargetInfoResult { target_info });
- }
- let target_info = conn
- .browser_contexts()
- .find_map(|browser_context| browser_context.devtools_target_info(wanted))
- .ok_or_else(|| DevToolsError::new(DevToolsErrorKind::NoSuchTarget, "UnknownTargetId"))?;
- if let Some(message) = super::transient_no_page_devtools_target_info_error(conn, &target_info) {
- return Err(DevToolsError::new(DevToolsErrorKind::Internal, message));
- }
- Ok(DevToolsGetTargetInfoResult { target_info })
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct AutoAttachParams {
- auto_attach: bool,
- #[serde(rename = "waitForDebuggerOnStart")]
- wait_for_debugger_on_start: bool,
- flatten: Option<bool>,
- filter: Option<Vec<TargetFilterEntry>>,
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct AutoAttachRelatedParams {
- target_id: String,
- #[serde(rename = "waitForDebuggerOnStart")]
- wait_for_debugger_on_start: bool,
- filter: Option<Vec<TargetFilterEntry>>,
-}
-
-#[derive(Deserialize)]
-struct TargetFilterEntry {
- #[serde(default)]
- exclude: bool,
- #[serde(rename = "type")]
- target_type: Option<String>,
-}
-
-#[derive(Debug)]
-struct ServiceWorkerAutoAttachRelatedTarget {
- target_id: String,
- browser_context_id: String,
- registration_id: u64,
- version_id: u64,
- script_url: String,
- scope_url: String,
-}
-
-pub(super) fn auto_attach_related(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {
- let params: AutoAttachRelatedParams = match cmd.get_params() {
- Ok(Some(p)) => p,
- _ => {
- return CommandOutputPlan::error_without_session(-32602, "InvalidParams");
- }
- };
- if cmd.session_id.is_some() && !conn.is_browser_session_id(cmd.session_id) {
- return CommandOutputPlan::error_without_session(
- -32000,
- "Target.autoAttachRelated is only supported on the Browser target",
- );
- }
-
- let restore_browser_context_id = previously_active_browser_context_id(conn);
- let target = match service_worker_auto_attach_related_target(conn, params.target_id.as_str()) {
- Ok(target) => target,
- Err(plan) => {
- restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
- return plan;
- }
- };
- let allow_service_worker_targets =
- cdp_target_filter_from_entries(params.filter).matches("service_worker");
- conn.replace_service_worker_auto_attach_related_owner(
- cmd.session_id,
- &target.browser_context_id,
- target.registration_id,
- target.version_id,
- target.script_url,
- target.scope_url,
- allow_service_worker_targets,
- params.wait_for_debugger_on_start,
- );
- let mut plan = CommandOutputPlan::default();
- if allow_service_worker_targets
- && !owner_already_auto_attached_to_target(conn, cmd.session_id, &target.target_id)
- && let Some((session_id, target_info)) =
- attach_service_worker_target_for_auto_attach_related(conn, &target.target_id)
- {
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- &target.target_id,
- target_info,
- [conn.prepare_auto_attach_session_commit(
- session_id,
- cmd.session_id.map(str::to_owned),
- false,
- )],
- ));
- for event in event_plan {
- plan.push_background_event(event);
- }
- }
- restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
- // Chromium completes autoAttachRelated only after its existing-target
- // attach pass. Existing targets are already running, so they cannot be
- // paused on start even when the policy requests it.
- plan.push_success();
- plan
-}
-
-fn service_worker_auto_attach_related_target(
- conn: &mut CdpConnection,
- target_id: &str,
-) -> Result<ServiceWorkerAutoAttachRelatedTarget, CommandOutputPlan> {
- if let Err(message) = select_browser_context_for_target(conn, target_id) {
- return Err(CommandOutputPlan::error_without_session(-31998, message));
- }
- let Some(browser_context) = conn.browser_context.as_ref() else {
- return Err(CommandOutputPlan::error_without_session(
- -31998,
- "BrowserContextNotLoaded",
- ));
- };
- let Some(target) = browser_context.service_worker_target(target_id) else {
- return Err(CommandOutputPlan::error_without_session(
- -32000,
- "Target does not support auto-attaching",
- ));
- };
- Ok(ServiceWorkerAutoAttachRelatedTarget {
- target_id: target.target_id.clone(),
- browser_context_id: browser_context.id.clone(),
- registration_id: target.renderer_registration_id,
- version_id: target.renderer_version_id,
- script_url: target.script_url.clone(),
- scope_url: target.scope_url.clone(),
- })
-}
-
-fn attach_service_worker_target_for_auto_attach_related(
- conn: &mut CdpConnection,
- target_id: &str,
-) -> Option<(String, DevToolsTargetInfo)> {
- let session_id = conn.gen_session_id();
- let target_info = conn
- .prepare_auto_attached_service_worker_session_binding_info(target_id, session_id.clone())?;
- Some((session_id, target_info))
-}
-
-fn owner_already_auto_attached_to_target(
- conn: &CdpConnection,
- owner_session_id: Option<&str>,
- target_id: &str,
-) -> bool {
- conn.auto_attached_sessions_for_owner(owner_session_id)
- .into_iter()
- .any(|session_id| {
- matches!(
- conn.session_route(Some(&session_id)),
- Some(crate::conn::CdpSessionRoute::ServiceWorkerTarget {
- target_id: attached_target_id,
- ..
- }) if attached_target_id == target_id
- )
- })
-}
-
-fn owner_already_auto_attached_to_exact_target(
- conn: &CdpConnection,
- owner_session_id: Option<&str>,
- target_id: &str,
-) -> bool {
- let attached_sessions = conn.attached_sessions_for_target(target_id);
- conn.auto_attached_sessions_for_owner(owner_session_id)
- .iter()
- .any(|session_id| attached_sessions.contains(session_id))
-}
-
-fn owner_already_auto_attached_to_page_target(
- conn: &CdpConnection,
- owner_session_id: Option<&str>,
- target_id: &str,
-) -> bool {
- conn.auto_attached_sessions_for_owner(owner_session_id)
- .into_iter()
- .any(|session_id| match conn.session_route(Some(&session_id)) {
- Some(crate::conn::CdpSessionRoute::ActiveTarget {
- browser_context_id,
- target_id: route_target_id,
- }) => {
- route_target_id.as_deref() == Some(target_id)
- || conn
- .browser_context_by_id(&browser_context_id)
- .and_then(BrowserContext::active_target_id)
- == Some(target_id)
- }
- Some(crate::conn::CdpSessionRoute::BackgroundTarget {
- target_id: route_target_id,
- ..
- })
- | Some(crate::conn::CdpSessionRoute::AuxiliaryTarget {
- target_id: route_target_id,
- ..
- }) => route_target_id == target_id,
- _ => false,
- })
-}
-
-fn owner_already_auto_attached_to_tab_target(
- conn: &CdpConnection,
- owner_session_id: Option<&str>,
- tab_target_id: &str,
-) -> bool {
- conn.auto_attached_sessions_for_owner(owner_session_id)
- .into_iter()
- .any(|session_id| {
- matches!(
- conn.session_route(Some(&session_id)),
- Some(crate::conn::CdpSessionRoute::TabTarget {
- tab_target_id: attached_target_id,
- ..
- }) if attached_target_id == tab_target_id
- )
- })
-}
-
-fn should_auto_attach_page_target_for_owner(
- conn: &CdpConnection,
- owner_session_id: Option<&str>,
- target_id: &str,
- target_has_primary_session: bool,
-) -> bool {
- if owner_session_id.is_none() && target_has_primary_session {
- return false;
- }
- if owner_session_is_attached_to_page_target(conn, owner_session_id, target_id) {
- return false;
- }
- !owner_already_auto_attached_to_page_target(conn, owner_session_id, target_id)
-}
-
-fn should_auto_attach_tab_target_for_owner(
- conn: &CdpConnection,
- owner_session_id: Option<&str>,
- tab_target_id: &str,
-) -> bool {
- if owner_session_id.is_none()
- && conn
- .primary_session_id_for_tab_target_id(tab_target_id)
- .is_some()
- {
- return false;
- }
- !owner_already_auto_attached_to_tab_target(conn, owner_session_id, tab_target_id)
-}
-
-fn owner_session_is_attached_to_page_target(
- conn: &CdpConnection,
- owner_session_id: Option<&str>,
- target_id: &str,
-) -> bool {
- let Some(owner_session_id) = owner_session_id else {
- return false;
- };
- page_session_route_matches_target(conn, owner_session_id, target_id)
-}
-
-fn page_session_route_matches_target(
- conn: &CdpConnection,
- session_id: &str,
- target_id: &str,
-) -> bool {
- match conn.session_route(Some(session_id)) {
- Some(crate::conn::CdpSessionRoute::ActiveTarget {
- browser_context_id,
- target_id: route_target_id,
- }) => {
- route_target_id.as_deref() == Some(target_id)
- || conn
- .browser_context_by_id(&browser_context_id)
- .and_then(BrowserContext::active_target_id)
- == Some(target_id)
- }
- Some(crate::conn::CdpSessionRoute::BackgroundTarget {
- target_id: route_target_id,
- ..
- })
- | Some(crate::conn::CdpSessionRoute::AuxiliaryTarget {
- target_id: route_target_id,
- ..
- }) => route_target_id == target_id,
- _ => false,
- }
-}
-
-fn cdp_target_filter_from_entries(filter: Option<Vec<TargetFilterEntry>>) -> CdpTargetFilter {
- match filter {
- Some(entries) => CdpTargetFilter::from_entries(
- entries
- .into_iter()
- .map(|entry| CdpTargetFilterEntry {
- exclude: entry.exclude,
- target_type: entry.target_type,
- })
- .collect(),
- ),
- None => CdpTargetFilter::default_auto_attach(),
- }
-}
-
-pub(super) fn start_set_auto_attach_command(
- conn: &mut CdpConnection,
- cmd: &Cmd<'_>,
-) -> TargetCommandTaskStep {
- let params: AutoAttachParams = match cmd.get_params() {
- Ok(Some(p)) => p,
- _ => {
- return super::target_command_error(-32602, "InvalidParams");
- }
- };
- if cmd
- .session_id
- .is_some_and(|session_id| conn.is_browser_session_id(Some(session_id)))
- && params.flatten != Some(true)
- {
- return super::target_command_error(
- -32602,
- "Only flatten protocol is supported with browser level auto-attach",
- );
- }
- if !params.auto_attach
- && params
- .filter
- .as_ref()
- .is_some_and(|filter| !filter.is_empty())
- {
- return super::target_command_error(
- -32602,
- "Target filter should be empty when disabling auto-attach",
- );
- }
- let target_filter = cdp_target_filter_from_entries(params.filter);
- let owner_is_browser_or_root =
- cmd.session_id.is_none() || conn.is_browser_session_id(cmd.session_id);
- if params.auto_attach
- && owner_is_browser_or_root
- && target_filter.matches("tab")
- && target_filter.matches("page")
- {
- return super::target_command_error(
- -32602,
- "Filter should not simultaneously allow \"tab\" and \"page\", page targets are attached via tab targets",
- );
- }
- let owner_was_enabled = conn.has_auto_attach_owner(cmd.session_id);
- let legacy_disable_all = !params.auto_attach
- && !owner_was_enabled
- && conn.auto_attach_owner_count() == 0
- && conn.auto_attach;
- if params.auto_attach {
- conn.install_default_browser_target_for_auto_attach_if_enabled();
- }
- let pause_service_workers_on_start = params.auto_attach
- && params.wait_for_debugger_on_start
- && target_filter.matches("service_worker")
- && super::browser_level_auto_attach_owner_session_allowed(conn, cmd.session_id);
- let pause_dedicated_workers_on_start =
- params.auto_attach && params.wait_for_debugger_on_start && target_filter.matches("worker");
- conn.set_auto_attach_owner(
- cmd.session_id,
- params.auto_attach,
- params.wait_for_debugger_on_start,
- target_filter,
- );
- super::set_service_worker_pause_on_start_owner(
- conn,
- cmd.session_id,
- pause_service_workers_on_start,
- );
- super::set_dedicated_worker_pause_on_start_owner(
- conn,
- cmd.session_id,
- pause_dedicated_workers_on_start,
- );
- pending_set_auto_attach_command(
- cmd.id,
- cmd.session_id,
- params.auto_attach,
- cmd.session_id,
- legacy_disable_all,
- )
-}
-
-pub(super) async fn complete_set_auto_attach_command_async(
- conn: &mut CdpConnection,
- auto_attach: bool,
- owner_session_id: Option<&str>,
- legacy_disable_all: bool,
- command_context: &mut crate::conn::CommandDispatchContext,
-) -> CommandOutputPlan {
- let mut side_effects = events::TargetProtocolSideEffects::default();
- let restore_browser_context_id = previously_active_browser_context_id(conn);
- set_auto_attach_inner_async(
- conn,
- &mut side_effects,
- auto_attach,
- owner_session_id,
- legacy_disable_all,
- command_context,
- )
- .await;
- restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
- // Chromium runs the AddClient existing-target sweep before invoking the
- // SetAutoAttach completion callback. Puppeteer consumes attachedToTarget
- // during that sweep and assumes every pre-existing session is registered
- // by the time the command response resolves.
- let mut plan = side_effects.into_plan();
- plan.push_success();
- plan
-}
-
-async fn set_auto_attach_inner_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- auto_attach: bool,
- owner_session_id: Option<&str>,
- legacy_disable_all: bool,
- command_context: &mut crate::conn::CommandDispatchContext,
-) {
- if !auto_attach && !legacy_disable_all {
- detach_auto_attached_sessions_for_owner_async(conn, out, owner_session_id, command_context)
- .await;
- return;
- }
- if auto_attach
- && let Some(owner_session_id) = owner_session_id
- && let Some(tab_target_id) = conn
- .tab_target_id_for_session_id(owner_session_id)
- .map(str::to_owned)
- {
- auto_attach_child_page_for_tab_session_async(conn, out, owner_session_id, &tab_target_id)
- .await;
- return;
- }
-
- let context_ids: Vec<String> = conn.browser_contexts().map(|bc| bc.id.clone()).collect();
- for context_id in context_ids {
- if !conn.activate_browser_context_by_id_async(&context_id).await {
- continue;
- }
- if auto_attach {
- let attach_page_targets = conn
- .auto_attach_owner_allows_target_type(owner_session_id, "page")
- && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
- let attach_tab_targets = conn
- .auto_attach_owner_allows_target_type(owner_session_id, "tab")
- && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
- let attach_shared_worker_targets = conn
- .auto_attach_owner_allows_target_type(owner_session_id, "shared_worker")
- && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
- let attach_dedicated_worker_targets =
- conn.auto_attach_owner_allows_target_type(owner_session_id, "worker");
- let attach_service_worker_targets = conn
- .auto_attach_owner_allows_target_type(owner_session_id, "service_worker")
- && super::browser_level_auto_attach_owner_session_allowed(conn, owner_session_id);
- // waitForDebuggerOnStart applies to targets created after the
- // policy is installed. Chromium reports every target found by the
- // initial AddClient sweep as already running.
- let waiting_for_debugger = false;
- let pending_attach_target_ids = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when attaching existing targets");
- if !attach_page_targets {
- Vec::new()
- } else {
- let mut target_ids = Vec::new();
- if let Some(target_id) = bc.active_target_id_owned()
- && should_auto_attach_page_target_for_owner(
- conn,
- owner_session_id,
- &target_id,
- bc.has_active_session(),
- )
- {
- target_ids.push(target_id);
- }
- target_ids.extend(
- bc.background_targets
- .iter()
- .filter(|target| {
- should_auto_attach_page_target_for_owner(
- conn,
- owner_session_id,
- target.target_id(),
- target.has_session(),
- )
- })
- .map(|target| target.target_id().to_owned()),
- );
- target_ids
- }
- };
- let pending_attach_tab_target_ids = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when attaching existing tab targets");
- if !attach_tab_targets {
- Vec::new()
- } else {
- let mut tab_target_ids = Vec::new();
- if let Some(page_target_id) = bc.active_target_id()
- && let Some(tab_target_id) =
- conn.tab_target_id_for_page_target_id(page_target_id)
- && should_auto_attach_tab_target_for_owner(
- conn,
- owner_session_id,
- tab_target_id,
- )
- {
- tab_target_ids.push(tab_target_id.to_owned());
- }
- tab_target_ids.extend(bc.background_targets.iter().filter_map(|target| {
- let tab_target_id =
- conn.tab_target_id_for_page_target_id(target.target_id())?;
- should_auto_attach_tab_target_for_owner(
- conn,
- owner_session_id,
- tab_target_id,
- )
- .then(|| tab_target_id.to_owned())
- }));
- tab_target_ids
- }
- };
- let pending_attach_shared_worker_target_ids = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when attaching existing targets");
- if attach_shared_worker_targets {
- bc.shared_worker_targets
- .values()
- .filter(|target| {
- !owner_already_auto_attached_to_exact_target(
- conn,
- owner_session_id,
- &target.target_id,
- )
- })
- .map(|target| target.target_id.clone())
- .collect::<Vec<_>>()
- } else {
- Vec::new()
- }
- };
- let pending_attach_service_worker_target_ids = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when attaching existing targets");
- if attach_service_worker_targets {
- bc.service_worker_targets
- .values()
- .filter(|target| {
- !owner_already_auto_attached_to_exact_target(
- conn,
- owner_session_id,
- &target.target_id,
- )
- })
- .map(|target| target.target_id.clone())
- .collect::<Vec<_>>()
- } else {
- Vec::new()
- }
- };
- let pending_attach_dedicated_worker_target_ids = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when attaching existing targets");
- if attach_dedicated_worker_targets {
- bc.dedicated_worker_targets
- .values()
- .filter(|target| {
- super::worker_target::dedicated_worker_auto_attach_owner_session_allowed(
- conn,
- owner_session_id,
- &target.owner_page,
- ) && !owner_already_auto_attached_to_exact_target(
- conn,
- owner_session_id,
- &target.target_id,
- )
- })
- .map(|target| target.target_id.clone())
- .collect::<Vec<_>>()
- } else {
- Vec::new()
- }
- };
- let attached_targets = pending_attach_target_ids
- .into_iter()
- .map(|target_id| (target_id, conn.gen_session_id()))
- .collect::<Vec<_>>();
- let attached_tab_targets = pending_attach_tab_target_ids
- .into_iter()
- .map(|target_id| (target_id, conn.gen_session_id()))
- .collect::<Vec<_>>();
- let attached_shared_worker_targets = pending_attach_shared_worker_target_ids
- .into_iter()
- .map(|target_id| (target_id, conn.gen_session_id()))
- .collect::<Vec<_>>();
- let attached_service_worker_targets = pending_attach_service_worker_target_ids
- .into_iter()
- .map(|target_id| (target_id, conn.gen_session_id()))
- .collect::<Vec<_>>();
- let attached_dedicated_worker_targets = pending_attach_dedicated_worker_target_ids
- .into_iter()
- .map(|target_id| (target_id, conn.gen_session_id()))
- .collect::<Vec<_>>();
- let promote_target_id = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when considering auto-attach promotion");
- if !attach_page_targets || bc.has_loaded_page() {
- None
- } else {
- bc.background_targets
- .iter()
- .rposition(|target| !target.has_session() && target.has_loaded_page())
- .map(|index| bc.background_targets[index].target_id().to_owned())
- .or_else(|| {
- bc.background_targets
- .iter()
- .find(|target| !target.has_session())
- .map(|target| target.target_id().to_owned())
- })
- }
- };
- {
- for (target_id, session_id) in &attached_targets {
- let assigned = conn
- .prepare_auto_attached_page_session_binding(target_id, session_id.clone());
- debug_assert!(assigned, "attached target must remain addressable");
- }
- for (target_id, session_id) in &attached_shared_worker_targets {
- let assigned = conn.prepare_auto_attached_shared_worker_session_binding(
- target_id,
- session_id.clone(),
- );
- debug_assert!(
- assigned,
- "attached shared worker target must remain addressable"
- );
- }
- for (target_id, session_id) in &attached_dedicated_worker_targets {
- let assigned = conn.prepare_auto_attached_dedicated_worker_session_binding(
- target_id,
- session_id.clone(),
- );
- debug_assert!(
- assigned,
- "attached dedicated worker target must remain addressable"
- );
- }
- for (target_id, session_id) in &attached_service_worker_targets {
- let assigned = conn.prepare_auto_attached_service_worker_session_binding(
- target_id,
- session_id.clone(),
- );
- debug_assert!(
- assigned,
- "attached service worker target must remain addressable"
- );
- }
- }
- for (target_id, session_id) in &attached_tab_targets {
- let assigned = conn.prepare_auto_attached_tab_session_binding(
- target_id,
- session_id.clone(),
- owner_session_id,
- );
- debug_assert!(assigned, "attached tab target must remain addressable");
- }
- if let Some(promote_target_id) = promote_target_id {
- match conn
- .promote_background_target_to_active_for_connection_async(&promote_target_id)
- .await
- {
- Ok(Some(activation)) => {
- out.extend_background_events(activation.into_protocol_events());
- }
- Ok(None) => {}
- Err(message) => {
- panic!(
- "same-context target should remain promotable during auto-attach: {message}"
- );
- }
- }
- }
- ensure_initial_document_for_attached_page_targets_async(conn, &attached_targets).await;
- for (target_id, session_id) in &attached_targets {
- if let Err(message) = conn
- .apply_runtime_binding_state_for_session_owner_async(Some(session_id))
- .await
- && message != "NoDocumentLoaded"
- {
- tracing::warn!(
- %message,
- target_id = target_id.as_str(),
- session_id = session_id.as_str(),
- "failed to apply renderer binding state during target auto-attach"
- );
- }
- }
- for (target_id, session_id) in attached_tab_targets {
- let ti = conn
- .tab_target_info(&target_id)
- .expect("attached tab target must remain addressable");
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- &target_id,
- ti,
- [conn.prepare_auto_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- waiting_for_debugger,
- )],
- ));
- out.extend_background_events(event_plan);
- }
- for (target_id, session_id) in attached_targets {
- let ti = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when emitting attach events");
- bc.devtools_target_info(&target_id)
- .expect("attached target must remain addressable")
- };
- if let Some(message) =
- super::transient_no_page_devtools_target_info_error(conn, &ti)
- {
- warn_target_protocol_side_effect_failure(
- &target_id,
- "emit_attached_to_target",
- &message,
- );
- }
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- &target_id,
- ti,
- [conn.prepare_auto_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- waiting_for_debugger,
- )],
- ));
- out.extend_background_events(event_plan);
- }
- for (target_id, session_id) in attached_shared_worker_targets {
- let ti = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when emitting attach events");
- bc.devtools_target_info(&target_id)
- .expect("attached shared worker target must remain addressable")
- };
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- &target_id,
- ti,
- [conn.prepare_auto_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- waiting_for_debugger,
- )],
- ));
- out.extend_background_events(event_plan);
- }
- for (target_id, session_id) in attached_dedicated_worker_targets {
- let ti = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when emitting attach events");
- bc.devtools_target_info(&target_id)
- .expect("attached dedicated worker target must remain addressable")
- };
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- &target_id,
- ti,
- [conn.prepare_auto_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- waiting_for_debugger,
- )],
- ));
- out.extend_background_events(event_plan);
- }
- for (target_id, session_id) in attached_service_worker_targets {
- let ti = {
- let bc = conn
- .browser_context
- .as_ref()
- .expect("browser context must exist when emitting attach events");
- bc.devtools_target_info(&target_id)
- .expect("attached service worker target must remain addressable")
- };
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- &target_id,
- ti,
- [conn.prepare_auto_attach_session_commit(
- session_id,
- owner_session_id.map(str::to_owned),
- waiting_for_debugger,
- )],
- ));
- out.extend_background_events(event_plan);
- }
- continue;
- }
-
- if let Some((target_id, Some(session_id))) = conn
- .browser_context
- .as_ref()
- .and_then(BrowserContext::active_target_identity)
- {
- events::fail_pending_fetch_state_for_target_background_events_async(
- conn,
- out.background_events_mut(),
- Some(&session_id),
- "Target detached",
- )
- .await;
-
- let event_plan = conn
- .detach_active_target_session_binding_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id, session_id, None, None,
- ),
- )
- .await
- .expect("clearing session-scoped state during auto-attach reset should succeed");
- out.extend_background_events(event_plan);
- }
-
- let detached_background_targets =
- conn.background_target_session_detach_cleanup_plans(None, None);
- for cleanup_plan in detached_background_targets {
- if let Some(event_plan) = conn
- .detach_background_target_session_binding_event_plan_async(cleanup_plan)
- .await
- .expect("clearing background target session-scoped state during auto-attach reset should succeed")
- {
- out.extend_background_events(event_plan);
- }
- }
-
- let shared_worker_sessions_to_release = conn
- .browser_context
- .as_ref()
- .map(|bc| {
- bc.shared_worker_targets
- .values()
- .flat_map(|target| target.session_ids())
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- for session_id in &shared_worker_sessions_to_release {
- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
- session_id,
- )
- .await;
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- }
-
- let shared_worker_event_plan = conn
- .detach_all_shared_worker_target_sessions_event_plan_async(None, None)
- .await;
- out.extend_background_events(shared_worker_event_plan);
-
- let dedicated_worker_sessions_to_release = conn
- .browser_context
- .as_ref()
- .map(|bc| {
- bc.dedicated_worker_targets
- .values()
- .flat_map(|target| target.session_ids())
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- for session_id in &dedicated_worker_sessions_to_release {
- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
- session_id,
- )
- .await;
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- }
- let dedicated_worker_event_plan = conn
- .detach_all_dedicated_worker_target_sessions_event_plan_async(None, None)
- .await;
- out.extend_background_events(dedicated_worker_event_plan);
-
- let service_worker_sessions_to_detach = conn
- .browser_context
- .as_ref()
- .map(|bc| {
- bc.service_worker_targets
- .values()
- .flat_map(|target| target.session_ids())
- .collect::<Vec<_>>()
- })
- .unwrap_or_default();
- let service_worker_event_plan = conn
- .detach_all_service_worker_target_sessions_event_plan_async(None, None)
- .await;
- for session_id in service_worker_sessions_to_detach {
- super::set_service_worker_pause_on_start_owner(conn, Some(&session_id), false);
- }
- out.extend_background_events(service_worker_event_plan);
- }
-}
-
-async fn auto_attach_child_page_for_tab_session_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- tab_session_id: &str,
- tab_target_id: &str,
-) {
- if !conn.auto_attach_owner_allows_target_type(Some(tab_session_id), "page") {
- return;
- }
- let Some(page_target_id) = conn
- .primary_page_target_id_for_tab_target_id(tab_target_id)
- .map(str::to_owned)
- else {
- return;
- };
- let Some(browser_context_id) = conn.browser_context_id_for_tab_target_id(tab_target_id) else {
- return;
- };
- if !conn
- .activate_browser_context_by_id_async(&browser_context_id)
- .await
- {
- return;
- }
- let target_has_primary_session = {
- let Some(bc) = conn.browser_context.as_ref() else {
- return;
- };
- if bc.active_target_id() == Some(page_target_id.as_str()) {
- bc.has_active_session()
- } else {
- bc.background_target(&page_target_id)
- .is_some_and(|target| target.has_session())
- }
- };
- if !should_auto_attach_page_target_for_owner(
- conn,
- Some(tab_session_id),
- &page_target_id,
- target_has_primary_session,
- ) {
- return;
- }
- let session_id = conn.gen_session_id();
- let assigned =
- conn.prepare_auto_attached_page_session_binding(&page_target_id, session_id.clone());
- if !assigned {
- return;
- }
- ensure_initial_document_for_attached_page_targets_async(
- conn,
- &[(page_target_id.clone(), session_id.clone())],
- )
- .await;
- if let Err(message) = conn
- .apply_runtime_binding_state_for_session_owner_async(Some(&session_id))
- .await
- && message != "NoDocumentLoaded"
- {
- tracing::warn!(
- %message,
- target_id = page_target_id.as_str(),
- session_id = session_id.as_str(),
- "failed to apply renderer binding state during tab child page auto-attach"
- );
- }
- let prepared_session = conn.prepare_auto_attach_session_commit(
- session_id.clone(),
- Some(tab_session_id.to_owned()),
- false,
- );
- let Some(target_info) = conn
- .browser_context
- .as_ref()
- .and_then(|bc| bc.devtools_target_info(&page_target_id))
- else {
- conn.rollback_prepared_attach_session_without_event_async(&prepared_session)
- .await;
- return;
- };
- if let Some(message) = super::transient_no_page_devtools_target_info_error(conn, &target_info) {
- warn_target_protocol_side_effect_failure(
- &page_target_id,
- "emit_tab_child_attached_to_target",
- &message,
- );
- conn.rollback_prepared_attach_session_without_event_async(&prepared_session)
- .await;
- return;
- }
- let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
- &page_target_id,
- target_info,
- [prepared_session],
- ));
- out.extend_background_events(event_plan);
-}
-
-pub(super) async fn detach_auto_attached_sessions_for_owner_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- owner_session_id: Option<&str>,
- command_context: &mut crate::conn::CommandDispatchContext,
-) {
- let session_ids = conn.auto_attached_session_cascade_for_owner(owner_session_id);
- for session_id in session_ids {
- detach_attached_session_for_owner_async(conn, out, &session_id, command_context).await;
- }
-}
-
-pub(super) async fn detach_attached_sessions_for_owner_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- owner_session_id: Option<&str>,
- command_context: &mut crate::conn::CommandDispatchContext,
-) {
- let session_ids = conn.attached_session_cascade_for_owner(owner_session_id);
- for session_id in session_ids {
- detach_attached_session_for_owner_async(conn, out, &session_id, command_context).await;
- }
-}
-
-pub(super) async fn release_attached_sessions_for_root_frontend_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- command_context: &mut crate::conn::CommandDispatchContext,
-) {
- // Root-owned browser sessions include the scheduler's private page-control
- // session and must outlive a browser frontend disconnect. A target session
- // owned directly by that frontend still belongs to the release cascade.
- let session_ids = conn.attached_session_cascade_for_root_frontend();
- for session_id in session_ids {
- let detach_plan = conn.auto_attached_session_detach_plan(&session_id);
- let preserves_other_frontends = matches!(
- detach_plan.cleanup_plan().map(|plan| plan.action()),
- Some(
- crate::conn::TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached
- | crate::conn::TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached {
- ..
- }
- )
- );
- if !preserves_other_frontends {
- detach_attached_session_for_owner_async(conn, out, &session_id, command_context).await;
- continue;
- }
-
- let Some(browser_context_id) = detach_plan.browser_context_id().map(str::to_owned) else {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- continue;
- };
- if !conn
- .activate_browser_context_by_id_async(&browser_context_id)
- .await
- {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- continue;
- }
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(&session_id),
- "Target detached",
- );
- super::clear_detached_target_fetch_state_background_events_async(
- conn,
- out.background_events_mut(),
- &session_id,
- )
- .await;
- let _ = conn
- .detach_runtime_inspector_session_for_session_owner_async(Some(&session_id))
- .await;
- clear_emulated_media_for_detached_session_best_effort(conn, &session_id).await;
- if !conn.release_primary_target_session_binding_without_event(&session_id) {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- }
- }
-}
-
-async fn detach_attached_session_for_owner_async(
- conn: &mut CdpConnection,
- out: &mut events::TargetProtocolSideEffects,
- session_id: &str,
- command_context: &mut crate::conn::CommandDispatchContext,
-) {
- if conn.is_browser_session_id(Some(session_id)) {
- conn.cancel_tracing_for_session_owner_async(Some(session_id))
- .await;
- let detached = conn.detach_browser_session_owner_without_event(session_id);
- debug_assert!(detached.is_some());
- return;
- }
- let detach_plan = conn.auto_attached_session_detach_plan(session_id);
- let Some(browser_context_id) = detach_plan.browser_context_id().map(str::to_owned) else {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- return;
- };
- if !conn
- .activate_browser_context_by_id_async(&browser_context_id)
- .await
- {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- return;
- }
-
- let Some(cleanup_plan) = detach_plan.cleanup_plan() else {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- return;
- };
- match cleanup_plan.action().clone() {
- crate::conn::TargetBindingCleanupAction::ActiveTargetPrimaryAutoAttached => {
- let target_id = conn
- .browser_context
- .as_ref()
- .and_then(BrowserContext::active_target_identity)
- .and_then(|(target_id, current_session_id)| {
- (current_session_id.as_deref() == Some(session_id))
- .then(|| target_id.to_owned())
- });
- let Some(target_id) = target_id else {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- return;
- };
- // A parent-session detach cascade bypasses the direct
- // Target.detachFromTarget path. Release the renderer inspector
- // here before resetting protocol state so the replacement primary
- // session gets a fresh Runtime.enable context inventory.
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- let _ = conn
- .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
- .await;
- events::fail_pending_fetch_state_for_target_background_events_async(
- conn,
- out.background_events_mut(),
- Some(session_id),
- "Target detached",
- )
- .await;
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id, session_id, None, None,
- ),
- )
- .await;
- out.extend_background_events(event_plan);
- }
- crate::conn::TargetBindingCleanupAction::AuxiliaryTarget { target_id } => {
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- let _ = conn
- .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
- .await;
- clear_emulated_media_for_detached_session_best_effort(conn, session_id).await;
- super::clear_detached_target_fetch_state_background_events_async(
- conn,
- out.background_events_mut(),
- session_id,
- )
- .await;
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id, session_id, None, None,
- ),
- )
- .await;
- out.extend_background_events(event_plan);
- }
- crate::conn::TargetBindingCleanupAction::BackgroundTargetPrimaryAutoAttached {
- target_id,
- } => {
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- let _ = conn
- .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
- .await;
- clear_emulated_media_for_detached_session_best_effort(conn, session_id).await;
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id, session_id, None, None,
- ),
- )
- .await;
- out.extend_background_events(event_plan);
- }
- crate::conn::TargetBindingCleanupAction::TabTarget { tab_target_id } => {
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- tab_target_id,
- session_id,
- None,
- None,
- ),
- )
- .await;
- out.extend_background_events(event_plan);
- }
- crate::conn::TargetBindingCleanupAction::SharedWorkerTarget { target_id } => {
- let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {
- bc.shared_worker_target(&target_id)
- .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))
- });
- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
- session_id,
- )
- .await;
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- if let Some((renderer_runtime, instance_id)) = renderer_detach {
- renderer_runtime.detach_shared_worker_runtime_inspector_session(
- instance_id,
- Some(session_id.to_owned()),
- );
- }
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id, session_id, None, None,
- ),
- )
- .await;
- out.extend_background_events(event_plan);
- }
- crate::conn::TargetBindingCleanupAction::DedicatedWorkerTarget { target_id } => {
- let renderer_detach = conn.browser_context.as_ref().and_then(|bc| {
- bc.dedicated_worker_target(&target_id)
- .map(|target| (bc.renderer_runtime(), target.renderer_instance_id))
- });
- conn.release_shared_worker_runtime_remote_objects_for_session_best_effort_async(
- session_id,
- )
- .await;
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- if let Some((renderer_runtime, instance_id)) = renderer_detach {
- renderer_runtime.detach_dedicated_worker_runtime_inspector_session(
- instance_id,
- Some(session_id.to_owned()),
- );
- }
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id, session_id, None, None,
- ),
- )
- .await;
- out.extend_background_events(event_plan);
- }
- crate::conn::TargetBindingCleanupAction::ServiceWorkerTarget { target_id } => {
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id),
- "Target detached",
- );
- super::set_service_worker_pause_on_start_owner(conn, Some(session_id), false);
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id, session_id, None, None,
- ),
- )
- .await;
- out.extend_background_events(event_plan);
- }
- crate::conn::TargetBindingCleanupAction::None => {
- conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
- }
- }
-}
-
-pub(super) async fn clear_emulated_media_for_detached_session_best_effort(
- conn: &mut CdpConnection,
- session_id: &str,
-) {
- if let Err(error) =
- crate::domains::emulation::clear_emulated_media_for_detached_session_async(conn, session_id)
- .await
- {
- tracing::warn!(
- session_id,
- error,
- "failed to clear emulated media while detaching target session"
- );
- }
-}
-
-async fn ensure_initial_document_for_attached_page_targets_async(
- conn: &mut CdpConnection,
- attached_targets: &[(String, String)],
-) {
- for (target_id, _session_id) in attached_targets {
- if !conn.browser_contexts().any(|browser_context| {
- browser_context.target_has_pending_initial_document_page_build(target_id)
- }) {
- continue;
- }
- 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 Some(pending) = pending else {
- continue;
- };
- match pending.wait().await {
- Ok(completed) => {
- if let Err(message) = conn
- .complete_initial_document_page_build_for_owner(completed)
- .await
- {
- warn_target_protocol_side_effect_failure(
- target_id,
- "complete_initial_document_page_build",
- &message,
- );
- }
- }
- Err(failed) => {
- let message = conn.reset_failed_initial_document_page_build_for_owner(failed);
- warn_target_protocol_side_effect_failure(
- target_id,
- "reset_failed_initial_document_page_build",
- &message,
- );
- }
- }
- }
-}
-
-fn warn_target_protocol_side_effect_failure(
- target_id: &str,
- operation: &'static str,
- message: &str,
-) {
- tracing::warn!(
- target_id,
- operation,
- %message,
- "target protocol side effect failed; continuing auto-attach event emission"
- );
-}
-
-#[derive(Deserialize)]
-#[serde(rename_all = "camelCase")]
-struct ActivateTargetParams {
- target_id: String,
-}
-
-pub(super) fn start_activate_target_command(
- conn: &mut CdpConnection,
- cmd: &Cmd<'_>,
-) -> TargetCommandTaskStep {
- let params: ActivateTargetParams = match cmd.get_params() {
- Ok(Some(params)) => params,
- _ => {
- return super::target_command_error(-32602, "InvalidParams");
- }
- };
- let command = build_cdp_activate_target_command(cmd, params);
- super::start_devtools_target_command(
- conn,
- cmd.id,
- cmd.session_id,
- DevToolsCommand::ActivateTarget(command),
- )
-}
-
-fn build_cdp_activate_target_command(
- cmd: &Cmd<'_>,
- params: ActivateTargetParams,
-) -> DevToolsActivateTargetCommand {
- DevToolsActivateTargetCommand {
- context: cmd
- .devtools_command_context(Some(params.target_id.as_str()), Option::<&str>::None),
- target_id: DevToolsTargetId::from(params.target_id),
- }
-}
-
-pub(super) async fn complete_activate_target_command_async(
- conn: &mut CdpConnection,
- command: DevToolsActivateTargetCommand,
-) -> CommandOutputPlan {
- match execute_devtools_activate_target_command_async(conn, command).await {
- Ok(events) => {
- let mut plan = CommandOutputPlan::default();
- plan.extend_background_events(events);
- plan.push_success();
- plan
- }
- Err(error) => CommandOutputPlan::from_devtools_error(error),
- }
-}
-
-pub(super) async fn execute_devtools_activate_target_command_async(
- conn: &mut CdpConnection,
- command: DevToolsActivateTargetCommand,
-) -> Result<Vec<BackgroundProtocolEvent>, DevToolsError> {
- let target_id = conn
- .primary_page_target_id_for_tab_target_id(command.target_id.as_str())
- .map(str::to_owned)
- .unwrap_or_else(|| command.target_id.as_str().to_owned());
- let previously_active_browser_context_id = previously_active_browser_context_id(conn);
- if let Err(message) = select_browser_context_for_target(conn, &target_id) {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Err(DevToolsError::new(DevToolsErrorKind::NoSuchTarget, message));
- }
- let bc = match conn.browser_context.as_ref() {
- Some(bc) => bc,
- None => {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "BrowserContextNotLoaded",
- ));
- }
- };
- if bc.has_shared_worker_target(&target_id) {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Ok(Vec::new());
- }
- if bc.has_dedicated_worker_target(&target_id) {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Ok(Vec::new());
- }
- if bc.has_service_worker_target(&target_id) {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Ok(Vec::new());
- }
- if !bc.has_active_target() && bc.background_targets.is_empty() {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "TargetNotLoaded",
- ));
- }
- let protocol_events = if !matches!(
- bc.active_target_identity(),
- Some((ref active_target_id, _)) if active_target_id == &target_id
- ) && bc.background_target(&target_id).is_some()
- {
- match conn
- .promote_background_target_to_active_for_connection_async(&target_id)
- .await
- {
- Ok(Some(activation)) => activation.into_protocol_events(),
- Ok(None) => {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "UnknownTargetId",
- ));
- }
- Err(message) => {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Err(DevToolsError::new(DevToolsErrorKind::NoSuchTarget, message));
- }
- }
- } else if !matches!(
- bc.active_target_identity(),
- Some((ref active_target_id, _)) if active_target_id == &target_id
- ) {
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- return Err(DevToolsError::new(
- DevToolsErrorKind::NoSuchTarget,
- "UnknownTargetId",
- ));
- } else {
- Vec::new()
- };
-
- restore_previously_active_browser_context(
- conn,
- previously_active_browser_context_id.as_deref(),
- );
- Ok(protocol_events)
-}
-
-#[cfg(test)]
-mod protocol_neutral_tests {
- use crate::devtools_runtime::DevToolsProtocol;
- use serde_json::Value;
-
- use crate::conn::Cmd;
-
- use super::{
- ActivateTargetParams, CloseTargetParams, CreateTargetParams,
- build_cdp_activate_target_command, build_cdp_close_target_command,
- build_cdp_create_target_command,
- };
-
- #[test]
- fn cdp_create_target_builds_protocol_neutral_target_command() {
- let params = Value::Null;
- let cmd = Cmd::for_test(
- Some(31),
- "Target.createTarget",
- &params,
- Some("SID-create"),
- r#"{"id":31,"method":"Target.createTarget"}"#,
- );
-
- let command = build_cdp_create_target_command(
- &cmd,
- CreateTargetParams {
- url: "https://example.com/new".to_owned(),
- browser_context_id: Some("BID-create".to_owned()),
- for_tab: None,
- background: None,
- focus: None,
- },
- )
- .expect("valid target disposition");
-
- assert_eq!(command.context.protocol, DevToolsProtocol::Cdp);
- assert_eq!(
- command.context.session_id.as_ref().map(|id| id.as_str()),
- Some("SID-create")
- );
- assert_eq!(command.context.target_id, None);
- assert_eq!(
- command
- .context
- .browser_context_id
- .as_ref()
- .map(|id| id.as_str()),
- Some("BID-create")
- );
- assert_eq!(command.url, "https://example.com/new");
- assert_eq!(
- command.browser_context_id.as_ref().map(|id| id.as_str()),
- Some("BID-create")
- );
- assert!(command.activate);
- }
-
- #[test]
- fn cdp_close_target_builds_protocol_neutral_target_command() {
- let params = Value::Null;
- let cmd = Cmd::for_test(
- Some(32),
- "Target.closeTarget",
- &params,
- Some("SID-close"),
- r#"{"id":32,"method":"Target.closeTarget"}"#,
- );
-
- let command = build_cdp_close_target_command(
- &cmd,
- CloseTargetParams {
- target_id: "TID-close".to_owned(),
- },
- );
-
- assert_eq!(command.context.protocol, DevToolsProtocol::Cdp);
- assert_eq!(
- command.context.session_id.as_ref().map(|id| id.as_str()),
- Some("SID-close")
- );
- assert_eq!(
- command.context.target_id.as_ref().map(|id| id.as_str()),
- Some("TID-close")
- );
- assert_eq!(command.context.browser_context_id, None);
- assert_eq!(command.target_id.as_str(), "TID-close");
- }
-
- #[test]
- fn cdp_activate_target_builds_protocol_neutral_target_command() {
- let params = Value::Null;
- let cmd = Cmd::for_test(
- Some(33),
- "Target.activateTarget",
- &params,
- Some("SID-activate"),
- r#"{"id":33,"method":"Target.activateTarget"}"#,
- );
-
- let command = build_cdp_activate_target_command(
- &cmd,
- ActivateTargetParams {
- target_id: "TID-activate".to_owned(),
- },
- );
-
- assert_eq!(command.context.protocol, DevToolsProtocol::Cdp);
- assert_eq!(
- command.context.session_id.as_ref().map(|id| id.as_str()),
- Some("SID-activate")
- );
- assert_eq!(
- command.context.target_id.as_ref().map(|id| id.as_str()),
- Some("TID-activate")
- );
- assert_eq!(command.context.browser_context_id, None);
- assert_eq!(command.target_id.as_str(), "TID-activate");
- }
-}
diff --git a/moli-protocol/src/domains/target/popup.rs b/moli-protocol/src/domains/target/popup.rs
new file mode 100644
index 000000000..4c7dd684c
--- /dev/null
+++ b/moli-protocol/src/domains/target/popup.rs
@@ -0,0 +1,627 @@
+use crate::conn::{
+ PopupTargetActivationAction, PopupTargetNavigationKind, PopupTargetNavigationOwnerAction,
+ PreparedTargetAttach,
+};
+
+use super::creation::{
+ push_target_created_events, top_level_page_auto_attach_owner_sessions,
+ top_level_tab_auto_attach_owner_sessions,
+};
+use super::*;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct PopupTargetOpenerIdentity {
+ target_id: String,
+ frame_id: String,
+}
+
+impl PopupTargetOpenerIdentity {
+ pub(crate) fn new(target_id: impl Into<String>, frame_id: impl Into<String>) -> Self {
+ Self {
+ target_id: target_id.into(),
+ frame_id: frame_id.into(),
+ }
+ }
+}
+
+/// A renderer-accepted auxiliary browsing-context action whose destination
+/// browser context, DevTools opener identity, and DOM opener access were
+/// frozen before protocol emission.
+///
+/// Unlike a protocol Target.createTarget command, this action must not select
+/// the browser context or opener from whichever session happens to drain it.
+#[derive(Clone, Debug)]
+pub(crate) struct PopupTargetCreation {
+ browser_context_id: String,
+ popup_id: Option<u64>,
+ url: String,
+ target_name: String,
+ opener: Option<PopupTargetOpenerIdentity>,
+ can_access_opener: bool,
+ disposition: moli_core::page::RendererPopupDisposition,
+ session_storage_store: Option<moli_core::network::SharedWebStorageStore>,
+ initial_empty_document_storage_key: Option<moli_storage_key::MoliStorageKey>,
+}
+
+impl PopupTargetCreation {
+ pub(crate) fn new(
+ browser_context_id: String,
+ popup_id: Option<u64>,
+ url: String,
+ target_name: String,
+ opener: Option<PopupTargetOpenerIdentity>,
+ can_access_opener: bool,
+ disposition: moli_core::page::RendererPopupDisposition,
+ session_storage_store: Option<moli_core::network::SharedWebStorageStore>,
+ initial_empty_document_storage_key: Option<moli_storage_key::MoliStorageKey>,
+ ) -> Self {
+ Self {
+ browser_context_id,
+ popup_id,
+ url,
+ target_name,
+ opener,
+ can_access_opener,
+ disposition,
+ session_storage_store,
+ initial_empty_document_storage_key,
+ }
+ }
+}
+
+pub(crate) async fn create_popup_target_from_renderer_output_background_events_async(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ creation: PopupTargetCreation,
+) -> Option<String> {
+ let PopupTargetCreation {
+ browser_context_id,
+ popup_id,
+ url,
+ target_name,
+ opener,
+ can_access_opener,
+ disposition,
+ session_storage_store,
+ initial_empty_document_storage_key,
+ } = creation;
+ let Some(browser_context) = conn.browser_context_by_id(&browser_context_id) else {
+ tracing::debug!(
+ browser_context_id,
+ ?popup_id,
+ ?target_name,
+ "dropping accepted popup action after its browser context was removed"
+ );
+ return None;
+ };
+
+ if let Some(existing_target_id) = browser_context
+ .target_id_for_window_name(&target_name)
+ .map(str::to_owned)
+ {
+ let navigation =
+ popup_target_has_loaded_page(conn, &browser_context_id, &existing_target_id)
+ .then(|| {
+ PopupTargetNavigationOwnerAction::capture(
+ conn,
+ &browser_context_id,
+ &existing_target_id,
+ url.clone(),
+ PopupTargetNavigationKind::NamedTargetReuse,
+ )
+ })
+ .flatten();
+ let activation = (disposition == moli_core::page::RendererPopupDisposition::Foreground)
+ .then(|| {
+ PopupTargetActivationAction::capture(conn, &browser_context_id, &existing_target_id)
+ })
+ .flatten();
+
+ let target_url_updated = conn
+ .browser_context_by_id_mut(&browser_context_id)
+ .is_some_and(|browser_context| {
+ browser_context.update_target_url(&existing_target_id, url.clone())
+ });
+ if target_url_updated {
+ emit_target_info_changed_for_target_background_event(
+ conn,
+ out,
+ &browser_context_id,
+ &existing_target_id,
+ );
+ if let Some(navigation) = navigation {
+ conn.publish_popup_target_navigation_owner_action(navigation);
+ }
+ if let Some(activation) = activation {
+ conn.publish_popup_target_activation_action(activation);
+ }
+ }
+ return (target_url_updated
+ && remember_resolved_popup_target(
+ conn,
+ &browser_context_id,
+ popup_id,
+ &existing_target_id,
+ ))
+ .then_some(existing_target_id);
+ }
+
+ // The renderer has already accepted an auxiliary-context action. Even when
+ // noopener blocks script access, Chromium preserves the creator target and
+ // frame as DevTools attribution for the new auxiliary target.
+ let opener = opener.filter(|opener| {
+ conn.browser_context_by_id(&browser_context_id)
+ .and_then(|browser_context| browser_context.devtools_target_info(&opener.target_id))
+ .is_some()
+ });
+ let can_access_opener = can_access_opener && opener.is_some();
+ let popup_creator = if can_access_opener {
+ opener.as_ref().and_then(|opener| {
+ conn.browser_context_by_id(&browser_context_id)
+ .and_then(|browser_context| {
+ browser_context.initial_empty_document_creator_for_target(&opener.target_id)
+ })
+ })
+ } else {
+ None
+ };
+ let target_id = conn.gen_target_id();
+ let auto_attach_page_owners = top_level_page_auto_attach_owner_sessions(conn);
+ let auto_attach_tab_owners = top_level_tab_auto_attach_owner_sessions(conn);
+ let auto_attached_page_sessions = auto_attach_page_owners
+ .iter()
+ .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let auto_attached_tab_sessions = auto_attach_tab_owners
+ .iter()
+ .map(|owner_session_id| (owner_session_id.clone(), conn.gen_session_id()))
+ .collect::<Vec<_>>();
+ let auto_attached_background_session_id = auto_attached_page_sessions
+ .first()
+ .map(|(_, session_id)| session_id.clone());
+ let requested_url = url.clone();
+
+ {
+ let browser_context = conn.browser_context_by_id_mut(&browser_context_id)?;
+ browser_context.stage_popup_background_target(
+ target_id.clone(),
+ auto_attached_background_session_id.clone(),
+ url,
+ Some("about:blank".to_owned()),
+ popup_creator,
+ session_storage_store,
+ initial_empty_document_storage_key,
+ );
+ if let Some(opener) = opener {
+ browser_context.remember_target_opener(
+ &target_id,
+ opener.target_id,
+ opener.frame_id,
+ can_access_opener,
+ );
+ }
+ browser_context.remember_target_window_name(&target_name, &target_id);
+ browser_context.remember_target_popup_id(popup_id, &target_id);
+ }
+
+ let tab_target_id = conn.register_top_level_page_target(&target_id);
+ for (owner_session_id, session_id) in &auto_attached_tab_sessions {
+ let assigned = conn.prepare_auto_attached_tab_session_binding(
+ &tab_target_id,
+ session_id.clone(),
+ owner_session_id.as_deref(),
+ );
+ assert!(assigned, "created popup tab target must remain addressable");
+ }
+ for (index, (_, session_id)) in auto_attached_page_sessions.iter().enumerate() {
+ if index != 0 || auto_attached_background_session_id.is_none() {
+ let assigned = conn.prepare_auto_attached_page_session_binding_in_browser_context(
+ &browser_context_id,
+ &target_id,
+ session_id.clone(),
+ );
+ assert!(
+ assigned,
+ "newly created popup target must remain addressable"
+ );
+ }
+ }
+
+ if !ensure_popup_initial_document_page_async(conn, &target_id).await {
+ rollback_incomplete_popup_target_async(conn, Some(&browser_context_id), &target_id).await;
+ return None;
+ }
+
+ let Some(target_info) = conn
+ .browser_context_by_id(&browser_context_id)
+ .and_then(|browser_context| browser_context.devtools_target_info(&target_id))
+ else {
+ rollback_incomplete_popup_target_async(conn, Some(&browser_context_id), &target_id).await;
+ return None;
+ };
+ let Some(tab_target_info) = conn.tab_target_info(&tab_target_id) else {
+ rollback_incomplete_popup_target_async(conn, Some(&browser_context_id), &target_id).await;
+ return None;
+ };
+ if conn.has_any_target_discovery() {
+ push_target_created_events(conn, out, &target_id);
+ } else {
+ // Chromium's BiDi mapper keeps a target observer alive independently
+ // of whether any frontend subscribed to `Target.targetCreated`.
+ // Preserve that separation here: CDP discovery controls only the CDP
+ // notification, while the accepted auxiliary browsing-context action
+ // always publishes one typed automation lifecycle fact. This is
+ // especially important for popup creation that settles after the
+ // causing Runtime command response.
+ out.push(BackgroundProtocolEvent::automation_only(
+ events::target_created_automation_event(target_info.clone()),
+ ));
+ }
+ push_committed_auto_attached_session_events(
+ conn,
+ out,
+ &auto_attached_tab_sessions,
+ &tab_target_id,
+ tab_target_info,
+ );
+ push_committed_auto_attached_session_events(
+ conn,
+ out,
+ &auto_attached_page_sessions,
+ &target_id,
+ target_info,
+ );
+ if !conn.target_has_waiting_for_debugger_session(&target_id)
+ && let Some(navigation) = PopupTargetNavigationOwnerAction::capture(
+ conn,
+ &browser_context_id,
+ &target_id,
+ requested_url,
+ PopupTargetNavigationKind::InitialDocument,
+ )
+ {
+ conn.publish_popup_target_navigation_owner_action(navigation);
+ }
+ if disposition == moli_core::page::RendererPopupDisposition::Foreground
+ && let Some(activation) =
+ PopupTargetActivationAction::capture(conn, &browser_context_id, &target_id)
+ {
+ conn.publish_popup_target_activation_action(activation);
+ }
+ Some(target_id)
+}
+
+fn remember_resolved_popup_target(
+ conn: &mut CdpConnection,
+ browser_context_id: &str,
+ popup_id: Option<u64>,
+ target_id: &str,
+) -> bool {
+ conn.browser_context_by_id_mut(browser_context_id)
+ .is_some_and(|browser_context| {
+ if browser_context.devtools_target_info(target_id).is_none() {
+ return false;
+ }
+ browser_context.remember_target_popup_id(popup_id, target_id);
+ true
+ })
+}
+async fn ensure_popup_initial_document_page_async(
+ conn: &mut CdpConnection,
+ target_id: &str,
+) -> bool {
+ let Some(route) = conn.target_session_route_for_target_id(target_id) else {
+ return false;
+ };
+ {
+ 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)
+ {
+ Ok(pending) => pending,
+ Err(message) => {
+ tracing::debug!(
+ target_id,
+ ?message,
+ "failed to start popup initial document page ensure"
+ );
+ return false;
+ }
+ };
+ if let Some(pending) = pending {
+ 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);
+ tracing::debug!(
+ target_id,
+ ?message,
+ "failed to await popup initial document page ensure"
+ );
+ return false;
+ }
+ };
+ if let Err(message) = route_scope
+ .conn_mut()
+ .complete_initial_document_page_build_for_owner(completed)
+ .await
+ {
+ tracing::debug!(
+ target_id,
+ ?message,
+ "failed to complete popup initial document page ensure"
+ );
+ return false;
+ }
+ }
+ }
+ true
+}
+
+fn push_committed_auto_attached_session_events(
+ conn: &mut CdpConnection,
+ out: &mut impl events::CdpTargetAutomationEventSink,
+ sessions: &[(Option<String>, String)],
+ target_id: &str,
+ target_info: DevToolsTargetInfo,
+) {
+ let sessions = sessions
+ .iter()
+ .map(|(owner_session_id, session_id)| {
+ conn.prepare_auto_attach_session_commit(
+ session_id.clone(),
+ owner_session_id.clone(),
+ conn.auto_attach_owner_waits_for_debugger_on_start(owner_session_id.as_deref()),
+ )
+ })
+ .collect::<Vec<_>>();
+ let event_plan = conn.commit_prepared_attach_event_plan(PreparedTargetAttach::new(
+ target_id,
+ target_info,
+ sessions,
+ ));
+ for event in event_plan {
+ out.push_target_background_event(event);
+ }
+}
+
+pub(super) async fn rollback_incomplete_popup_target_async(
+ conn: &mut CdpConnection,
+ browser_context_id: Option<&str>,
+ target_id: &str,
+) {
+ conn.rollback_incomplete_popup_target_without_event_async(browser_context_id, target_id)
+ .await;
+}
+
+pub(super) async fn start_target_url_navigation_if_allowed_background_events_async(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ target_id: &str,
+) {
+ if conn.target_has_waiting_for_debugger_session(target_id) {
+ return;
+ }
+ 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
+ };
+ 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_should_start_initial_document_navigation(session_id) {
+ return false;
+ }
+ let Some(target_url) = conn.runtime_session_owner_target_url(session_id) else {
+ return false;
+ };
+ crate::domains::page::navigate_session_owner_from_renderer_background_events_async(
+ conn,
+ out,
+ session_id,
+ &target_url,
+ )
+ .await;
+ true
+}
+
+fn popup_target_has_loaded_page(
+ conn: &CdpConnection,
+ browser_context_id: &str,
+ target_id: &str,
+) -> bool {
+ let Some(browser_context) = conn.browser_context_by_id(browser_context_id) else {
+ return false;
+ };
+ if browser_context.is_active_target(target_id) {
+ return browser_context.has_loaded_page();
+ }
+ browser_context
+ .background_target(target_id)
+ .is_some_and(|target| target.has_loaded_page())
+}
+
+pub(crate) async fn complete_popup_target_navigation_owner_action_async(
+ conn: &mut CdpConnection,
+ 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)| {
+ 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,
+ target_id,
+ url,
+ ?kind,
+ "dropping popup navigation after its exact target owner retired"
+ );
+ return crate::conn::CdpTurnOutcome::new_with_protocol_events(
+ Vec::new(),
+ conn.take_scheduler_events(),
+ );
+ }
+
+ let mut protocol_events = Vec::new();
+ match kind {
+ PopupTargetNavigationKind::InitialDocument => {
+ if !conn.runtime_session_owner_should_start_initial_document_navigation(None) {
+ return crate::conn::CdpTurnOutcome::new_with_protocol_events(
+ Vec::new(),
+ conn.take_scheduler_events(),
+ );
+ }
+ }
+ PopupTargetNavigationKind::NamedTargetReuse => {}
+ }
+ crate::domains::page::navigate_session_owner_from_renderer_background_events_async(
+ conn,
+ &mut protocol_events,
+ None,
+ &url,
+ )
+ .await;
+ if kind == PopupTargetNavigationKind::InitialDocument {
+ emit_target_info_changed_for_target_background_event(
+ conn,
+ &mut protocol_events,
+ &browser_context_id,
+ &target_id,
+ );
+ }
+ crate::conn::CdpTurnOutcome::new_with_protocol_events(
+ protocol_events,
+ conn.take_scheduler_events(),
+ )
+}
+
+pub(crate) async fn complete_popup_target_activation_action_async(
+ conn: &mut CdpConnection,
+ action: PopupTargetActivationAction,
+) -> crate::conn::CdpTurnOutcome {
+ let (owner_scope, browser_context_id, target_id) = action.into_parts();
+ let target_is_current = {
+ let mut route_scope = owner_scope.enter(conn);
+ let conn = route_scope.conn_mut();
+ conn.target_owner_identity_for_session(None).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())
+ },
+ ) && popup_target_has_loaded_page(conn, &browser_context_id, &target_id)
+ };
+ if !target_is_current {
+ tracing::debug!(
+ browser_context_id,
+ target_id,
+ "dropping popup activation after its exact target owner retired"
+ );
+ return crate::conn::CdpTurnOutcome::new_with_protocol_events(
+ Vec::new(),
+ conn.take_scheduler_events(),
+ );
+ }
+ let protocol_events =
+ match activate_popup_target_async(conn, &browser_context_id, &target_id).await {
+ Ok(events) => events,
+ Err(error) => {
+ tracing::debug!(
+ browser_context_id,
+ target_id,
+ %error,
+ "popup target could not be activated"
+ );
+ Vec::new()
+ }
+ };
+ crate::conn::CdpTurnOutcome::new_with_protocol_events(
+ protocol_events,
+ conn.take_scheduler_events(),
+ )
+}
+
+async fn activate_popup_target_async(
+ conn: &mut CdpConnection,
+ browser_context_id: &str,
+ target_id: &str,
+) -> Result<Vec<BackgroundProtocolEvent>, String> {
+ let restore_browser_context_id = previously_active_browser_context_id(conn);
+ let result = if let Err(message) = select_browser_context_for_target(conn, target_id) {
+ Err(message.to_owned())
+ } else if conn
+ .browser_context
+ .as_ref()
+ .is_none_or(|browser_context| browser_context.id != browser_context_id)
+ {
+ Err("PopupTargetBrowserContextChanged".to_owned())
+ } else if conn
+ .browser_context
+ .as_ref()
+ .is_some_and(|browser_context| browser_context.is_active_target(target_id))
+ {
+ Ok(Vec::new())
+ } else {
+ match conn
+ .promote_background_target_to_active_for_connection_async(target_id)
+ .await
+ {
+ Ok(Some(activation)) => Ok(activation.into_protocol_events()),
+ Ok(None) => Err("PopupTargetUnavailable".to_owned()),
+ Err(message) => Err(message),
+ }
+ };
+ restore_previously_active_browser_context(conn, restore_browser_context_id.as_deref());
+ result
+}
+
+pub(crate) fn emit_target_info_changed_for_session_owner_background_event(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ session_id: Option<&str>,
+) {
+ out.extend(conn.target_info_changed_event_plan_for_session_owner(session_id));
+}
+
+fn emit_target_info_changed_for_target_background_event(
+ conn: &mut CdpConnection,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ browser_context_id: &str,
+ target_id: &str,
+) {
+ out.extend(
+ conn.target_info_changed_event_plan_for_observable_target(browser_context_id, target_id),
+ );
+}
diff --git a/moli-protocol/src/domains/target/protocol_neutral_tests.rs b/moli-protocol/src/domains/target/protocol_neutral_tests.rs
new file mode 100644
index 000000000..a2d577d3e
--- /dev/null
+++ b/moli-protocol/src/domains/target/protocol_neutral_tests.rs
@@ -0,0 +1,115 @@
+use crate::devtools_runtime::DevToolsProtocol;
+use serde_json::Value;
+
+use crate::conn::Cmd;
+
+use super::activation::{ActivateTargetParams, build_cdp_activate_target_command};
+use super::closing::{CloseTargetParams, build_cdp_close_target_command};
+use super::creation::{CreateTargetParams, build_cdp_create_target_command};
+
+#[test]
+fn cdp_create_target_builds_protocol_neutral_target_command() {
+ let params = Value::Null;
+ let cmd = Cmd::for_test(
+ Some(31),
+ "Target.createTarget",
+ &params,
+ Some("SID-create"),
+ r#"{"id":31,"method":"Target.createTarget"}"#,
+ );
+
+ let command = build_cdp_create_target_command(
+ &cmd,
+ CreateTargetParams {
+ url: "https://example.com/new".to_owned(),
+ browser_context_id: Some("BID-create".to_owned()),
+ for_tab: None,
+ background: None,
+ focus: None,
+ },
+ )
+ .expect("valid target disposition");
+
+ assert_eq!(command.context.protocol, DevToolsProtocol::Cdp);
+ assert_eq!(
+ command.context.session_id.as_ref().map(|id| id.as_str()),
+ Some("SID-create")
+ );
+ assert_eq!(command.context.target_id, None);
+ assert_eq!(
+ command
+ .context
+ .browser_context_id
+ .as_ref()
+ .map(|id| id.as_str()),
+ Some("BID-create")
+ );
+ assert_eq!(command.url, "https://example.com/new");
+ assert_eq!(
+ command.browser_context_id.as_ref().map(|id| id.as_str()),
+ Some("BID-create")
+ );
+ assert!(command.activate);
+}
+
+#[test]
+fn cdp_close_target_builds_protocol_neutral_target_command() {
+ let params = Value::Null;
+ let cmd = Cmd::for_test(
+ Some(32),
+ "Target.closeTarget",
+ &params,
+ Some("SID-close"),
+ r#"{"id":32,"method":"Target.closeTarget"}"#,
+ );
+
+ let command = build_cdp_close_target_command(
+ &cmd,
+ CloseTargetParams {
+ target_id: "TID-close".to_owned(),
+ },
+ );
+
+ assert_eq!(command.context.protocol, DevToolsProtocol::Cdp);
+ assert_eq!(
+ command.context.session_id.as_ref().map(|id| id.as_str()),
+ Some("SID-close")
+ );
+ assert_eq!(
+ command.context.target_id.as_ref().map(|id| id.as_str()),
+ Some("TID-close")
+ );
+ assert_eq!(command.context.browser_context_id, None);
+ assert_eq!(command.target_id.as_str(), "TID-close");
+}
+
+#[test]
+fn cdp_activate_target_builds_protocol_neutral_target_command() {
+ let params = Value::Null;
+ let cmd = Cmd::for_test(
+ Some(33),
+ "Target.activateTarget",
+ &params,
+ Some("SID-activate"),
+ r#"{"id":33,"method":"Target.activateTarget"}"#,
+ );
+
+ let command = build_cdp_activate_target_command(
+ &cmd,
+ ActivateTargetParams {
+ target_id: "TID-activate".to_owned(),
+ },
+ );
+
+ assert_eq!(command.context.protocol, DevToolsProtocol::Cdp);
+ assert_eq!(
+ command.context.session_id.as_ref().map(|id| id.as_str()),
+ Some("SID-activate")
+ );
+ assert_eq!(
+ command.context.target_id.as_ref().map(|id| id.as_str()),
+ Some("TID-activate")
+ );
+ assert_eq!(command.context.browser_context_id, None);
+ assert_eq!(command.target_id.as_str(), "TID-activate");
+}
diff --git a/moli-protocol/src/domains/target/tests/tests_target_creation.rs b/moli-protocol/src/domains/target/tests/tests_target_creation.rs
index b1ab30fc9..e770a6316 100644
--- a/moli-protocol/src/domains/target/tests/tests_target_creation.rs
+++ b/moli-protocol/src/domains/target/tests/tests_target_creation.rs
@@ -3070,7 +3070,7 @@ async fn incomplete_popup_rollback_clears_tab_page_sessions_and_target_graph() {
assert!(ctx.conn.session_route(Some("SID-popup-page-aux")).is_some());
assert_eq!(ctx.conn.tab_target_count(), 1);
- lifecycle::rollback_incomplete_popup_target_async(
+ popup::rollback_incomplete_popup_target_async(
&mut ctx.conn,
Some("BID-popup-rollback"),
page_target_id,
@@ -3144,7 +3144,7 @@ async fn incomplete_active_popup_rollback_clears_active_slot_sessions_and_target
);
assert_eq!(ctx.conn.tab_target_count(), 1);
- lifecycle::rollback_incomplete_popup_target_async(
+ popup::rollback_incomplete_popup_target_async(
&mut ctx.conn,
Some("BID-active-popup-rollback"),
page_target_id,