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): centralize target session disposal

ldm064d9a9fce721
diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rs
index dc1e7227d..f4e2608a9 100644
--- a/moli-core/src/page/mod.rs
+++ b/moli-core/src/page/mod.rs
@@ -82,13 +82,13 @@ pub use moli_renderer_v8::network::{
RendererNetworkResourceLoadResponse, RendererPreparedNetworkResourceLoad,
};
pub use moli_renderer_v8::{
- DevToolsSessionKey, RendererActivityDiagnostics, RendererAgentAttachmentId,
- RendererAutofillAddressField, RendererAutofillCreditCard, RendererAutofillTriggerOutcome,
- RendererAutofillTriggerRequest, RendererCaptureScreencastFrameReply,
- RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,
- RendererCaptureScreenshotRequest, RendererCommandTurnCompletion, RendererCommandTurnOutput,
- RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
- RendererDevToolsAgentToken, RendererDocumentHitTestResult,
+ CompletedWorkerRuntimeInspectorCommandDispatch, DevToolsSessionKey,
+ RendererActivityDiagnostics, RendererAgentAttachmentId, RendererAutofillAddressField,
+ RendererAutofillCreditCard, RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,
+ RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,
+ RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,
+ RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererDedicatedWorkerTargetEvent,
+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentHitTestResult,
RendererDocumentIsolateAccountingDiagnostics, RendererDocumentLifecycleEvent,
RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,
RendererDocumentLifecycleMilestone, RendererDocumentLifecycleSnapshot,
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index 3c50b125b..a137f2daf 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -122,6 +122,7 @@ pub use moli_protocol_cdp::{
use target::DEFAULT_BROWSER_CONTEXT_ID;
pub(crate) use target::{
CdpSessionRoute, DefaultTargetLifecycle, TargetActivationTransition, TargetHandlerAccessMode,
+ TargetWorkerProtocolAttachmentIdentity,
};
#[derive(Clone, Debug)]
@@ -558,12 +559,12 @@ pub(crate) use state::{
DedicatedWorkerTargetState, DevToolsBrowserIdentityOverride, DevToolsConsoleOutputSessionState,
DevToolsLogViolationThreshold, DocumentNavigationToken, DuplicatePendingRendererCommand,
EmulatedNetworkConditions, EmulatedViewportSurface, InspectorCommandDispatch,
- NETWORK_ERROR_PAGE_URL, NavigationResultProjection, NavigationSourceDocumentSecurityContext,
- NetworkErrorPageNavigation, PageScreencastConfig, PageScreencastFormat,
- PendingBidiChannelListener, PendingInspectorAwait, PendingRendererCommandKey,
- PerformanceTimeDomain, PreparedRendererCallDispatch, ProfilerAction, ProfilerInspectorCommand,
- RendererCommandCorrelation, RendererCommandDescriptor, RendererCommandReplay,
- RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,
+ NETWORK_ERROR_PAGE_URL, NavigationEngineHandoff, NavigationResultProjection,
+ NavigationSourceDocumentSecurityContext, NetworkErrorPageNavigation, PageScreencastConfig,
+ PageScreencastFormat, PendingBidiChannelListener, PendingInspectorAwait,
+ PendingRendererCommandKey, PerformanceTimeDomain, PreparedRendererCallDispatch, ProfilerAction,
+ ProfilerInspectorCommand, RendererCommandCorrelation, RendererCommandDescriptor,
+ RendererCommandReplay, RendererDocumentLifecycleObservation, RendererDocumentLifecycleObserver,
RendererMainDocumentCommitSeed, RendererPageResidenceIdentity,
ServiceWorkerRuntimeExceptionSnapshot, ServiceWorkerTargetState, SharedWorkerTargetState,
SiteDataClearOptions, TargetIdentityState, TargetInitialEmptyDocumentCreator, TargetOwnerState,
@@ -585,12 +586,11 @@ pub(crate) use state::{
};
pub(crate) use target::{
PreparedTargetAttach, PreparedTargetHostClosure, PreparedTargetHostDelta,
- TargetAttachSessionCommit, TargetBindingCleanupAction, TargetClosureCleanupPlan,
- TargetSessionDetachCleanupPlan,
+ TargetAttachSessionCommit, TargetBindingCleanupAction, TargetBindingCleanupPlan,
+ TargetClosureCleanupPlan, TargetEventPlan, TargetSessionDetachCleanupPlan,
};
use target::{
- TargetClosurePlan, TargetControlPlane, TargetEventPlan, TargetHostDelta,
- target_destroyed_automation_events,
+ TargetClosurePlan, TargetControlPlane, TargetHostDelta, target_destroyed_automation_events,
};
pub(crate) use top_level_navigation_work::TopLevelLocationNavigationOwnerAction;
@@ -2628,7 +2628,7 @@ impl CdpConnection {
// navigate_id-gated abort emission; the only thing we must avoid here
// is letting the stale background engine displace the live one.
let is_current = completion.is_current_for_connection(self);
- let completion = completion.materialize_with_engine_retention(self, is_current);
+ let completion = completion.materialize_with_engine_replacement(self, is_current);
if let Some(started) = timing_started {
tracing::info!(
target: "moli_cdp_nav_timing",
@@ -2957,7 +2957,7 @@ impl CdpConnection {
);
}
let is_current = completion.is_current_for_connection(self);
- let (token, state, navigation, engine) = completion.into_parts();
+ let (token, state, navigation, engine_handoff) = completion.into_parts();
if !is_current {
crate::domains::page::push_superseded_navigation_result(out, &state);
return;
@@ -2972,7 +2972,7 @@ impl CdpConnection {
command_context,
)
.await;
- if let Some(engine) = engine {
+ if let Some(engine) = engine_handoff.into_replacement() {
self.adopt_loaded_navigation_engine_for_owner(&navigation_owner, engine);
}
if let Some(started) = timing_started {
diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rs
index c924390f4..ac2b9fd80 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -824,28 +824,6 @@ impl<'a> TargetSessionOwnerMut<'a> {
Some(())
}
- pub(super) async fn close_page_target_async(&mut self) -> Option<ClosedPageTarget> {
- let mut target = self.browser_context.page_targets.remove(&self.target_id)?;
- self.browser_context
- .forget_target_opener_references_for_target(&self.target_id);
- self.browser_context
- .forget_target_window_names_for_target(&self.target_id);
- self.browser_context
- .forget_target_popup_id_for_target(&self.target_id);
- let auxiliary_session_ids = target
- .devtools_sessions
- .attached_session_ids()
- .map(str::to_owned)
- .collect::<Vec<_>>();
- let primary_session_id = target.detach_session();
- target.close_page_async().await;
- Some(ClosedPageTarget {
- target_id: self.target_id.clone(),
- primary_session_id,
- auxiliary_session_ids,
- })
- }
-
pub(super) fn runtime_slot_mut(&mut self) -> &mut TargetRuntimeSlot {
&mut self.target_mut().runtime_slot
}
@@ -1345,29 +1323,34 @@ impl CdpConnection {
.await
}
- pub(crate) async fn close_page_target_for_route_async(
- &mut self,
- session_id: Option<&str>,
- owner_route: Option<&CdpSessionRoute>,
- ) -> Option<ClosedPageTarget> {
- let collected_network_data_artifacts = self
- .target_session_owner_ref_for_route(session_id, owner_route)?
- .runtime_slot()
- .collected_network_data_artifacts();
- let closed = self
- .target_session_owner_mut_for_route(session_id, owner_route)?
- .close_page_target_async()
- .await?;
- self.record_collected_network_data_artifacts(collected_network_data_artifacts);
- Some(closed)
- }
-
- pub(crate) async fn close_background_page_target_for_target_close_async(
+ async fn close_page_target_for_target_close_async(
&mut self,
target_id: &str,
out: &mut Vec<BackgroundProtocolEvent>,
reason: &'static str,
) -> Option<ClosedPageTarget> {
+ let primary_route = self.target_session_route_for_target_id(target_id)?;
+ let session_owners = self
+ .page_event_session_ids_for_route(None, Some(&primary_route))
+ .into_iter()
+ .map(|session_id| {
+ session_id
+ .as_deref()
+ .map(CommandOwnerScope::for_session)
+ .unwrap_or_else(|| CommandOwnerScope::for_route(primary_route.clone()))
+ })
+ .collect::<Vec<_>>();
+ let mut claimed_await_events = Vec::new();
+ for owner in &session_owners {
+ self.fail_pending_inspector_awaits_for_owner_background_events_into(
+ out,
+ &mut claimed_await_events,
+ owner,
+ reason,
+ );
+ }
+ out.extend(claimed_await_events);
+
let (
mut target,
primary_session_id,
@@ -1375,18 +1358,15 @@ impl CdpConnection {
collected_network_data_artifacts,
) = {
let browser_context = self.browser_context.as_mut()?;
- let mut target = browser_context.remove_background_target(target_id)?;
+ let target = browser_context.take_page_target_for_close(target_id)?;
let collected_network_data_artifacts =
target.runtime_slot.collected_network_data_artifacts();
- browser_context.forget_target_opener_references_for_target(target_id);
- browser_context.forget_target_window_names_for_target(target_id);
- browser_context.forget_target_popup_id_for_target(target_id);
let auxiliary_session_ids = target
.devtools_sessions
.attached_session_ids()
.map(str::to_owned)
.collect::<Vec<_>>();
- let primary_session_id = target.detach_session();
+ let primary_session_id = target.session_id().map(str::to_owned);
(
target,
primary_session_id,
@@ -1397,21 +1377,6 @@ impl CdpConnection {
target.close_page_async().await;
self.record_collected_network_data_artifacts(collected_network_data_artifacts);
- let mut affected_sessions = Vec::new();
- if let Some(session_id) = primary_session_id.as_deref() {
- affected_sessions.push(session_id);
- }
- for session_id in &auxiliary_session_ids {
- affected_sessions.push(session_id.as_str());
- }
- CdpConnection::fail_pending_inspector_awaits_from_page_session_state_for_sessions_background_events_into(
- out,
- &mut target,
- primary_session_id.as_deref(),
- &affected_sessions,
- reason,
- );
-
Some(ClosedPageTarget {
target_id: target_id.to_owned(),
primary_session_id,
@@ -1419,35 +1384,35 @@ impl CdpConnection {
})
}
+ pub(crate) async fn close_background_page_target_for_target_close_async(
+ &mut self,
+ target_id: &str,
+ out: &mut Vec<BackgroundProtocolEvent>,
+ reason: &'static str,
+ ) -> Option<ClosedPageTarget> {
+ let is_background = self
+ .browser_context
+ .as_ref()
+ .is_some_and(|browser_context| {
+ browser_context.page_target(target_id).is_some()
+ && !browser_context.is_active_target(target_id)
+ });
+ if !is_background {
+ return None;
+ }
+ self.close_page_target_for_target_close_async(target_id, out, reason)
+ .await
+ }
+
pub(crate) async fn close_active_page_target_for_target_close_async(
&mut self,
out: &mut Vec<BackgroundProtocolEvent>,
+ reason: &'static str,
) -> Option<ClosedPageTarget> {
- let (
- target_id,
- primary_session_id,
- auxiliary_session_ids,
- collected_network_data_artifacts,
- ) = {
- let browser_context = self.browser_context.as_mut()?;
- let target_id = browser_context.active_target_id_owned()?;
- let primary_session_id = browser_context.active_session_id_owned();
- let auxiliary_session_ids =
- browser_context.remove_auxiliary_sessions_for_target(&target_id);
- let collected_network_data_artifacts = browser_context
- .active_page_target()
- .runtime_slot
- .collected_network_data_artifacts();
- browser_context.clear_active_target_session_scoped_state_without_loaded_page();
- browser_context.remove_active_page_target_async().await;
- (
- target_id,
- primary_session_id,
- auxiliary_session_ids,
- collected_network_data_artifacts,
- )
- };
- self.record_collected_network_data_artifacts(collected_network_data_artifacts);
+ let target_id = self.browser_context.as_ref()?.active_target_id_owned()?;
+ let closed = self
+ .close_page_target_for_target_close_async(&target_id, out, reason)
+ .await?;
let promoted_target_id = if let Some(browser_context) = self.browser_context.as_mut() {
browser_context
.promote_last_background_target_to_active_async()
@@ -1470,11 +1435,7 @@ impl CdpConnection {
);
}
- Some(ClosedPageTarget {
- target_id,
- primary_session_id,
- auxiliary_session_ids,
- })
+ Some(closed)
}
pub(crate) async fn rollback_incomplete_popup_target_without_event_async(
@@ -1495,46 +1456,20 @@ impl CdpConnection {
let mut page_session_ids = Vec::new();
if let Some(browser_context_id) = browser_context_id {
- let is_active_target = self
- .browser_context_by_id(&browser_context_id)
- .is_some_and(|browser_context| browser_context.is_active_target(target_id));
- if is_active_target {
- if let Some(browser_context) = self.browser_context_by_id_mut(&browser_context_id) {
- if let Some((_target_id, session_id)) = browser_context.active_target_identity()
- && let Some(session_id) = session_id
- {
- page_session_ids.push(session_id);
- }
- page_session_ids
- .extend(browser_context.remove_auxiliary_sessions_for_target(target_id));
- browser_context.remove_active_page_target_async().await;
- }
- } else {
- let close_background_target = {
- let Some(browser_context) = self.browser_context_by_id_mut(&browser_context_id)
- else {
- return;
- };
- let target = browser_context.remove_background_target(target_id);
- browser_context.forget_target_opener_references_for_target(target_id);
- browser_context.forget_target_window_names_for_target(target_id);
- browser_context.forget_target_popup_id_for_target(target_id);
- target.map(|mut target| {
- page_session_ids.extend(
- target
- .devtools_sessions
- .attached_session_ids()
- .map(str::to_owned),
- );
- if let Some(session_id) = target.detach_session() {
- page_session_ids.push(session_id);
- }
- target
- })
- };
- if let Some(mut target) = close_background_target {
- target.close_page_async().await;
+ let target = self
+ .browser_context_by_id_mut(&browser_context_id)
+ .and_then(|browser_context| browser_context.take_page_target_for_close(target_id));
+ if let Some(mut target) = target {
+ page_session_ids.extend(
+ target
+ .devtools_sessions
+ .attached_session_ids()
+ .map(str::to_owned),
+ );
+ if let Some(session_id) = target.session_id() {
+ page_session_ids.push(session_id.to_owned());
}
+ target.close_page_async().await;
}
}
diff --git a/moli-protocol/src/conn/fetch_support.rs b/moli-protocol/src/conn/fetch_support.rs
index 15b0dc611..51696d13b 100644
--- a/moli-protocol/src/conn/fetch_support.rs
+++ b/moli-protocol/src/conn/fetch_support.rs
@@ -1564,7 +1564,7 @@ impl DocumentBodySource {
} => {
if !has_response_override && let Some(prepared_document) = prepared_document {
let (engine, navigation) = prepared_document.resume_streaming(response, None);
- return Ok(navigation.with_navigation_engine(engine));
+ return Ok(navigation.with_navigation_engine_replacement(engine));
}
conn.build_navigation_from_streaming_raw_response_with_response_override_for_navigation_async(
navigation,
diff --git a/moli-protocol/src/conn/page_state/fetch_state.rs b/moli-protocol/src/conn/page_state/fetch_state.rs
index 67231353c..89cb9abae 100644
--- a/moli-protocol/src/conn/page_state/fetch_state.rs
+++ b/moli-protocol/src/conn/page_state/fetch_state.rs
@@ -505,24 +505,6 @@ mod tests {
assert!(read.eof);
}
- #[tokio::test]
- async fn clearing_session_scoped_state_clears_in_flight_subresources() {
- let mut bc = BrowserContext::new_with_page_for_test("BID-1", "TID-1");
- bc.register_in_flight_subresource_fetch_request(
- Some("INT-SUB-2".to_owned()),
- pending_subresource_fetch(2),
- );
-
- bc.clear_active_target_session_scoped_state_async()
- .await
- .unwrap();
- assert!(
- !bc.active_page_target()
- .fetch_owner
- .has_in_flight_subresource_fetches_for_test()
- );
- }
-
#[test]
fn network_and_io_stream_ids_cross_u32_max_without_reuse() {
let mut bc = BrowserContext::new_with_page_for_test("BID-1", "TID-1");
diff --git a/moli-protocol/src/conn/page_state/loaded.rs b/moli-protocol/src/conn/page_state/loaded.rs
index 27eb2e45b..ca19d4f6d 100644
--- a/moli-protocol/src/conn/page_state/loaded.rs
+++ b/moli-protocol/src/conn/page_state/loaded.rs
@@ -41,11 +41,6 @@ impl BrowserContext {
.and_then(|host| host.runtime_slot.page_attachment_id())
}
- fn clear_active_target_session_scoped_state_fields(&mut self) {
- self.active_page_target_mut()
- .clear_session_scoped_state_fields(false);
- }
-
#[cfg(test)]
fn clear_active_target_loaded_document_session_state(&mut self) {
for session in self.active_page_target_mut().devtools_sessions.states_mut() {
@@ -112,69 +107,12 @@ impl BrowserContext {
.ingest_owner_page_observable_output_updates()
}
- pub(crate) async fn clear_active_target_session_scoped_state_async(
- &mut self,
- ) -> Result<(), String> {
- self.clear_active_target_session_scoped_state_preserving_attached_async(false)
- .await
- }
-
- pub(crate) async fn clear_active_target_primary_session_scoped_state_async(
- &mut self,
- ) -> Result<(), String> {
- self.clear_active_target_session_scoped_state_preserving_attached_async(true)
- .await
- }
-
- async fn clear_active_target_session_scoped_state_preserving_attached_async(
- &mut self,
- preserve_attached_sessions: bool,
- ) -> Result<(), String> {
- self.active_page_target_mut()
- .clear_session_scoped_state_fields(preserve_attached_sessions);
- let emulated_media: moli_core::page::EmulatedMediaOverrides =
- (&self.active_page_target().emulated_media).into();
- if let Some(page) = self.active_page_target_mut().runtime_slot.loaded_page_mut() {
- page.set_extra_http_headers_async(&[])
- .await
- .map_err(|error| format!("failed to clear page extra headers: {error}"))?;
- page.set_network_offline_async(false)
- .await
- .map_err(|error| format!("failed to clear page offline state: {error}"))?;
- page.set_bypass_service_worker_async(false)
- .await
- .map_err(|error| format!("failed to clear page service worker bypass: {error}"))?;
- page.set_blocked_url_patterns_async(&[])
- .await
- .map_err(|error| format!("failed to clear page blocked URLs: {error}"))?;
- page.set_script_execution_disabled_async(false)
- .await
- .map_err(|error| {
- format!("failed to clear page script execution disabled state: {error}")
- })?;
- page.set_cpu_throttling_rate_async(1.0)
- .await
- .map_err(|error| format!("failed to clear page CPU throttling rate: {error}"))?;
- page.set_emulated_media_async(&emulated_media)
- .await
- .map_err(|error| format!("failed to clear page emulated media: {error}"))?;
- }
- self.apply_surface_overrides_to_loaded_page_async().await?;
- Ok(())
- }
-
- pub(crate) fn clear_active_target_session_scoped_state_without_loaded_page(&mut self) {
- self.clear_active_target_session_scoped_state_fields();
- }
-
+ #[cfg(test)]
pub(crate) async fn remove_active_page_target_async(&mut self) -> bool {
let Some(target_id) = self.active_target_id_owned() else {
return false;
};
- self.forget_target_opener_references_for_target(&target_id);
- self.forget_target_window_names_for_target(&target_id);
- self.forget_target_popup_id_for_target(&target_id);
- let Some(mut host) = self.page_targets.remove(&target_id) else {
+ let Some(mut host) = self.take_page_target_for_close(&target_id) else {
return false;
};
host.close_page_async().await;
diff --git a/moli-protocol/src/conn/page_state/parked.rs b/moli-protocol/src/conn/page_state/parked.rs
index 325e2fc1d..e2d30cf3f 100644
--- a/moli-protocol/src/conn/page_state/parked.rs
+++ b/moli-protocol/src/conn/page_state/parked.rs
@@ -10,11 +10,12 @@ use crate::devtools_runtime::{
use moli_core::network::SharedWebStorageStore;
impl BrowserContext {
- pub fn remove_background_target(&mut self, target_id: &str) -> Option<PageTargetHost> {
- if self.is_active_target(target_id) {
- return None;
- }
- self.page_targets.remove(target_id)
+ pub(crate) fn take_page_target_for_close(&mut self, target_id: &str) -> Option<PageTargetHost> {
+ let target = self.page_targets.remove(target_id)?;
+ self.forget_target_opener_references_for_target(target_id);
+ self.forget_target_window_names_for_target(target_id);
+ self.forget_target_popup_id_for_target(target_id);
+ Some(target)
}
pub(crate) fn stage_background_target(
@@ -315,7 +316,14 @@ impl BrowserContext {
target
.runtime_slot
.remove_network_session_observation_cursor(Some(session_id));
- target.devtools_sessions.remove_attached(session_id);
+ let disposed = target.devtools_sessions.dispose(
+ session_id,
+ &moli_page_types::DevToolsSessionKey::Attached(session_id.to_owned()),
+ );
+ debug_assert!(
+ disposed.is_some(),
+ "attached session must remain registered until disposal"
+ );
}
Some(target_id)
}
@@ -323,7 +331,7 @@ impl BrowserContext {
pub(crate) async fn clear_target_session_overrides_async(
&mut self,
session_id: &str,
- ) -> Result<bool, String> {
+ ) -> anyhow::Result<bool> {
let Some((target_id, session_key)) = self.page_targets.iter().find_map(|target| {
target
.devtools_sessions
@@ -372,75 +380,64 @@ impl BrowserContext {
)
.await
.map_err(|error| {
- format!("failed to restore detached session network request policy: {error}")
+ anyhow::anyhow!(
+ "failed to restore detached session network request policy: {error}"
+ )
})?;
}
if delta.locale {
page.set_locale_override_async(effective_locale.as_deref())
.await
- .map_err(|error| format!("failed to restore detached session locale: {error}"))?;
+ .map_err(|error| {
+ anyhow::anyhow!("failed to restore detached session locale: {error}")
+ })?;
}
if delta.timezone {
page.set_timezone_override_async(effective_timezone.as_deref())
.await
- .map_err(|error| format!("failed to restore detached session timezone: {error}"))?;
+ .map_err(|error| {
+ anyhow::anyhow!("failed to restore detached session timezone: {error}")
+ })?;
}
Ok(browser_identity_changed)
}
- pub(crate) fn remove_auxiliary_sessions_for_target(&mut self, target_id: &str) -> Vec<String> {
- let session_ids = self.auxiliary_session_ids_for_target(target_id);
- for session_id in &session_ids {
- let _ = self.remove_auxiliary_session(session_id);
- }
- session_ids
- }
-
- pub(crate) async fn clear_background_target_session_binding_and_scoped_state_async(
+ pub(crate) async fn dispose_primary_page_session_async(
&mut self,
+ target_id: &str,
session_id: &str,
- ) -> Result<Option<String>, String> {
- let Some(target_id) = self
- .background_targets_mut()
- .find(|target| target.is_session(session_id))
- .map(|target| {
- target.detach_session();
- let target_id = target.target_id().to_owned();
- target.runtime_slot.disable_primary_network_events();
- target
- .runtime_slot
- .clear_session_scoped_network_observation_artifacts();
- target
- .runtime_slot
- .request_id_allocator()
- .reset_fetch_navigation_request_counter();
- target
- .runtime_slot
- .request_id_allocator()
- .reset_subresource_fetch_request_counter();
- target_id
- })
- else {
- return Ok(None);
+ ) -> anyhow::Result<bool> {
+ let is_active = self.is_active_target(target_id);
+ let Some(target) = self.page_target_mut(target_id) else {
+ return Ok(false);
};
+ if !target.is_session(session_id) {
+ return Ok(false);
+ }
+ target.clear_primary_session_scoped_state_fields();
- let cleared_emulated_media = moli_core::page::EmulatedMediaOverrides::default();
- self.background_target_mut(&target_id)
- .expect("background target must exist")
- .clear_session_scoped_state_fields(true);
- self.background_target_mut(&target_id)
- .expect("background target must exist")
- .runtime_slot
- .remove_network_session_observation_cursor(Some(session_id));
-
- let effective_headers = self.effective_extra_headers_for_target(&target_id);
+ let effective_headers = self.effective_extra_headers_for_target(target_id);
let target = self
- .page_target(&target_id)
- .expect("background target must remain registered");
+ .page_target(target_id)
+ .expect("disposing page target must remain registered");
let effective_policy = target.effective_policy();
+ let effective_locale = effective_policy
+ .locale_override()
+ .map(str::to_owned)
+ .or_else(|| self.default_locale_override.clone());
+ let effective_timezone = effective_policy
+ .timezone_override()
+ .map(str::to_owned)
+ .or_else(|| self.default_timezone_override.clone());
+ let surface_script = if is_active {
+ self.generated_surface_override_script_for_active_target()
+ } else {
+ self.generated_surface_override_script_for_parked_target(target_id)
+ };
+ let cleared_emulated_media = moli_core::page::EmulatedMediaOverrides::default();
if let Some(page) = self
- .background_target_mut(&target_id)
+ .page_target_mut(target_id)
.and_then(|target| target.runtime_slot.loaded_page_mut())
{
page.set_network_request_policy_async(
@@ -450,59 +447,46 @@ impl BrowserContext {
effective_policy.blocked_url_patterns(),
)
.await
- .map_err(|error| format!("failed to clear page network request policy: {error}"))?;
+ .map_err(|error| {
+ anyhow::anyhow!("failed to clear page network request policy: {error}")
+ })?;
page.set_network_offline_async(false)
.await
- .map_err(|error| format!("failed to clear page offline state: {error}"))?;
+ .map_err(|error| anyhow::anyhow!("failed to clear page offline state: {error}"))?;
page.set_script_execution_disabled_async(false)
.await
.map_err(|error| {
- format!("failed to clear page script execution disabled state: {error}")
+ anyhow::anyhow!("failed to clear page script execution disabled state: {error}")
+ })?;
+ page.set_cpu_throttling_rate_async(1.0)
+ .await
+ .map_err(|error| {
+ anyhow::anyhow!("failed to clear page CPU throttling rate: {error}")
})?;
page.set_emulated_media_async(&cleared_emulated_media)
.await
- .map_err(|error| format!("failed to clear page emulated media: {error}"))?;
+ .map_err(|error| anyhow::anyhow!("failed to clear page emulated media: {error}"))?;
+ page.set_locale_override_async(effective_locale.as_deref())
+ .await
+ .map_err(|error| anyhow::anyhow!("failed to restore page locale: {error}"))?;
+ page.set_timezone_override_async(effective_timezone.as_deref())
+ .await
+ .map_err(|error| anyhow::anyhow!("failed to restore page timezone: {error}"))?;
+ if let Some(surface_script) = surface_script {
+ page.run_page_surface_override_script_async(&surface_script.source)
+ .await
+ .map_err(|error| {
+ anyhow::anyhow!("failed to restore page surface overrides: {error}")
+ })?;
+ }
}
- Ok(Some(target_id))
- }
-
- pub(crate) fn clear_background_target_primary_auto_attached_session(
- &mut self,
- session_id: &str,
- ) -> Option<String> {
- let target_id = self
- .background_targets_mut()
- .find(|target| target.is_session(session_id))
- .map(|target| {
- target.detach_session();
- let target_id = target.target_id().to_owned();
- target.runtime_slot.disable_primary_network_events();
- target
- .runtime_slot
- .clear_session_scoped_network_observation_artifacts();
- target
- .runtime_slot
- .request_id_allocator()
- .reset_fetch_navigation_request_counter();
- target
- .runtime_slot
- .request_id_allocator()
- .reset_subresource_fetch_request_counter();
- target_id
- })?;
- let target = self
- .page_target_mut(&target_id)
- .expect("background target must remain registered");
- target.devtools_sessions.reset(true);
- target.runtime_slot.disable_primary_network_events();
- target.network_policy.clear_session_scoped_state();
- target.fetch_owner.reset_config();
- self.background_target_mut(&target_id)
- .expect("background target must exist")
- .runtime_slot
- .remove_network_session_observation_cursor(Some(session_id));
- Some(target_id)
+ let disposed = self
+ .page_target_mut(target_id)
+ .expect("disposing page target must remain registered")
+ .devtools_sessions
+ .dispose(session_id, &moli_page_types::DevToolsSessionKey::Primary);
+ Ok(disposed.is_some())
}
#[cfg(test)]
@@ -550,52 +534,6 @@ impl BrowserContext {
))
}
- pub(crate) async fn clear_active_target_session_binding_and_scoped_state_async(
- &mut self,
- ) -> Result<(), String> {
- let target_id = self.active_target_id_owned();
- let auxiliary_inspector_session_ids = target_id
- .as_deref()
- .map(|target_id| self.auxiliary_session_ids_for_target(target_id))
- .unwrap_or_default();
- if let Some(page) = self.active_page_target_mut().runtime_slot.loaded_page_mut() {
- for session_id in &auxiliary_inspector_session_ids {
- page.detach_runtime_inspector_session_async(Some(session_id))
- .await
- .map_err(|error| {
- format!("failed to detach auxiliary renderer inspector session: {error}")
- })?;
- }
- page.detach_runtime_inspector_session_async(None)
- .await
- .map_err(|error| {
- format!("failed to detach primary renderer inspector session: {error}")
- })?;
- }
- self.clear_active_target_session_scoped_state_async()
- .await?;
- self.detach_active_session();
- for session_id in auxiliary_inspector_session_ids {
- self.active_page_target_mut()
- .runtime_slot
- .remove_auxiliary_network_session(&session_id);
- }
- Ok(())
- }
-
- pub(crate) async fn clear_active_target_primary_auto_attached_session_async(
- &mut self,
- ) -> Result<Option<String>, String> {
- let target_id = self.active_target_id_owned();
- if self.active_session_id().is_none() {
- return Ok(None);
- }
- self.clear_active_target_primary_session_scoped_state_async()
- .await?;
- self.detach_active_session();
- Ok(target_id)
- }
-
pub(crate) fn release_primary_session_binding_preserving_frontend_state(
&mut self,
session_id: &str,
diff --git a/moli-protocol/src/conn/page_state/surfaces.rs b/moli-protocol/src/conn/page_state/surfaces.rs
index f4510da8a..a90fc1192 100644
--- a/moli-protocol/src/conn/page_state/surfaces.rs
+++ b/moli-protocol/src/conn/page_state/surfaces.rs
@@ -673,72 +673,92 @@ impl BrowserContext {
}
impl CdpConnection {
- pub(crate) async fn remove_document_start_scripts_for_detached_session_best_effort_async(
+ pub(crate) async fn remove_document_start_scripts_for_detached_session_async(
&mut self,
session_id: &str,
- ) {
+ ) -> anyhow::Result<()> {
let renderer_inspector_session_id =
self.target_renderer_runtime_inspector_session_id_for_session(Some(session_id));
let devtools_session = moli_page_types::DevToolsSessionKey::from_wire_session_id(
renderer_inspector_session_id.as_deref(),
);
let registry_keys = self
- .with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {
- owner_state.take_document_start_script_registry_keys_for_session(&devtools_session)
+ .target_owner_state_for_session(Some(session_id))
+ .map(|owner_state| {
+ owner_state.document_start_script_registry_keys_for_session(&devtools_session)
})
.unwrap_or_default();
+ let has_loaded_page = self
+ .runtime_session_owner_slot_mut(Some(session_id))
+ .ok()
+ .is_some_and(|slot| slot.loaded_page().is_some());
+ if !has_loaded_page {
+ let _ = self.with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {
+ owner_state.remove_document_start_scripts_for_session(&devtools_session)
+ });
+ return Ok(());
+ }
+
for registry_key in registry_keys {
let pending = self
.runtime_session_owner_slot_mut(Some(session_id))
.ok()
.and_then(|slot| slot.loaded_page_mut())
- .map(|page| page.start_remove_document_start_script_by_registry_key(&registry_key));
- let Some(pending) = pending else {
- continue;
- };
- let pending = match pending {
- Ok(pending) => pending,
- Err(error) => {
- tracing::debug!(
- %error,
- session_id,
- registry_key,
- "failed to start detached-session document-start script cleanup"
- );
- continue;
- }
- };
- let completion = match pending.wait().await {
- Ok(completion) => completion,
- Err(error) => {
- tracing::debug!(
- %error,
- session_id,
- registry_key,
- "detached-session document-start script cleanup was canceled"
- );
- continue;
- }
- };
- let Some(page) = self
+ .ok_or_else(|| {
+ anyhow::anyhow!(
+ "page disappeared while removing detached-session document-start scripts"
+ )
+ })?
+ .start_remove_document_start_script_by_registry_key(&registry_key)
+ .map_err(|error| {
+ anyhow::anyhow!(
+ "failed to start detached-session document-start script cleanup: {error}"
+ )
+ })?;
+ let completion = pending.wait().await.map_err(|error| {
+ anyhow::anyhow!(
+ "detached-session document-start script cleanup was canceled: {error}"
+ )
+ })?;
+ let page = self
.runtime_session_owner_slot_mut(Some(session_id))
.ok()
.and_then(|slot| slot.loaded_page_mut())
- else {
- continue;
- };
- if let Err(error) = page.finish_unit_runtime_page_command(
+ .ok_or_else(|| {
+ anyhow::anyhow!(
+ "page disappeared while finishing detached-session document-start script cleanup"
+ )
+ })?;
+ page.finish_unit_runtime_page_command(
completion,
"remove detached-session document-start script",
- ) {
- tracing::debug!(
- %error,
- session_id,
- registry_key,
- "failed to finish detached-session document-start script cleanup"
- );
- }
+ )
+ .map_err(|error| {
+ anyhow::anyhow!(
+ "failed to finish detached-session document-start script cleanup: {error}"
+ )
+ })?;
+ self.with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {
+ owner_state.remove_document_start_script_registry_key_for_session(
+ &devtools_session,
+ &registry_key,
+ )
+ })
+ .ok_or_else(|| {
+ anyhow::anyhow!("session owner disappeared during document-start script cleanup")
+ })?;
}
+
+ // Scripts without a renderer registry key never require a renderer
+ // round trip. Successful keyed removals have already been committed,
+ // so a later retry cannot revisit a renderer object that is gone.
+ self.with_target_owner_state_for_session_mut(Some(session_id), |owner_state| {
+ owner_state.remove_document_start_scripts_for_session(&devtools_session)
+ })
+ .ok_or_else(|| {
+ anyhow::anyhow!("session owner disappeared during document-start script cleanup")
+ })?;
+ Ok(())
}
}
diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rs
index 99150f614..063fe3aaf 100644
--- a/moli-protocol/src/conn/runtime_eval.rs
+++ b/moli-protocol/src/conn/runtime_eval.rs
@@ -229,25 +229,6 @@ enum BidiChannelListenerRoute {
Event(BackgroundProtocolEvent),
}
-fn unregister_runtime_remote_object_group_from_page_target(
- page_session_state: &mut PageTargetHost,
- session_id: Option<&str>,
- object_group: &str,
-) {
- if let Some(session_id) = session_id
- && let Some(state) = page_session_state
- .devtools_sessions
- .attached_mut(session_id)
- {
- state.unregister_runtime_remote_object_group(object_group);
- return;
- }
- page_session_state
- .devtools_sessions
- .primary_mut()
- .unregister_runtime_remote_object_group(object_group);
-}
-
#[derive(Debug)]
pub(crate) struct OwnerRuntimeResponse {
command_id: u64,
@@ -397,15 +378,6 @@ impl RuntimeProtocolResponseRoute {
Self::DevToolsSession => None,
}
}
-
- fn into_command_reply_receiver(self) -> Option<RuntimeInspectorResponseReceiver> {
- match self {
- Self::CommandReply(receiver) => receiver,
- Self::DevToolsSession => {
- panic!("a DevTools session response cannot become a command reply")
- }
- }
- }
}
enum PendingRuntimeProtocolMessageDispatchKind {
@@ -416,13 +388,13 @@ enum PendingRuntimeProtocolMessageDispatchKind {
pub struct PendingSharedWorkerRuntimeProtocolMessageDispatch {
session_id: Option<String>,
pending: SharedWorkerRuntimeProtocolDispatchFuture,
- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,
+ response_route: RuntimeProtocolResponseRoute,
}
pub struct PendingServiceWorkerRuntimeProtocolMessageDispatch {
session_id: Option<String>,
pending: ServiceWorkerRuntimeProtocolDispatchFuture,
- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,
+ response_route: RuntimeProtocolResponseRoute,
}
pub struct PendingMoliDiagnosticsDispatch {
@@ -461,14 +433,41 @@ pub struct CompletedRuntimeProtocolMessageDispatch {
pub struct CompletedSharedWorkerRuntimeProtocolMessageDispatch {
session_id: Option<String>,
- messages: Vec<RendererRuntimeInspectorMessage>,
- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,
+ dispatch: CompletedWorkerRuntimeProtocolDispatch,
+ response_route: RuntimeProtocolResponseRoute,
}
pub struct CompletedServiceWorkerRuntimeProtocolMessageDispatch {
session_id: Option<String>,
+ dispatch: CompletedWorkerRuntimeProtocolDispatch,
+ response_route: RuntimeProtocolResponseRoute,
+}
+
+struct CompletedWorkerRuntimeProtocolDispatch {
messages: Vec<RendererRuntimeInspectorMessage>,
- deferred_response_rx: Option<RuntimeInspectorResponseReceiver>,
+ session_response_predecessor: Option<RendererOutputFence>,
+ session_response_succeeded: Option<bool>,
+}
+
+impl CompletedWorkerRuntimeProtocolDispatch {
+ fn command_reply(messages: Vec<RendererRuntimeInspectorMessage>) -> Self {
+ Self {
+ messages,
+ session_response_predecessor: None,
+ session_response_succeeded: None,
+ }
+ }
+
+ fn devtools_session(
+ completed: moli_core::page::CompletedWorkerRuntimeInspectorCommandDispatch,
+ ) -> Self {
+ let (messages, predecessor, response_succeeded) = completed.into_parts();
+ Self {
+ messages,
+ session_response_predecessor: Some(predecessor),
+ session_response_succeeded: Some(response_succeeded),
+ }
+ }
}
pub struct CompletedMoliDiagnosticsDispatch {
@@ -540,9 +539,9 @@ pub struct CompletedRuntimeChildDefaultContextLookupDispatch {
}
type SharedWorkerRuntimeProtocolDispatchFuture =
- Pin<Box<dyn Future<Output = Result<Vec<RendererRuntimeInspectorMessage>, String>>>>;
+ Pin<Box<dyn Future<Output = Result<CompletedWorkerRuntimeProtocolDispatch, String>>>>;
type ServiceWorkerRuntimeProtocolDispatchFuture =
- Pin<Box<dyn Future<Output = Result<Vec<RendererRuntimeInspectorMessage>, String>>>>;
+ Pin<Box<dyn Future<Output = Result<CompletedWorkerRuntimeProtocolDispatch, String>>>>;
#[derive(Clone, Debug)]
struct RuntimeProtocolMessagePageRoute {
@@ -621,11 +620,11 @@ impl PendingRuntimeProtocolMessageDispatch {
impl PendingSharedWorkerRuntimeProtocolMessageDispatch {
pub async fn wait(self) -> Result<CompletedSharedWorkerRuntimeProtocolMessageDispatch, String> {
- let messages = self.pending.await?;
+ let dispatch = self.pending.await?;
Ok(CompletedSharedWorkerRuntimeProtocolMessageDispatch {
session_id: self.session_id,
- messages,
- deferred_response_rx: self.deferred_response_rx,
+ dispatch,
+ response_route: self.response_route,
})
}
}
@@ -634,11 +633,11 @@ impl PendingServiceWorkerRuntimeProtocolMessageDispatch {
pub async fn wait(
self,
) -> Result<CompletedServiceWorkerRuntimeProtocolMessageDispatch, String> {
- let messages = self.pending.await?;
+ let dispatch = self.pending.await?;
Ok(CompletedServiceWorkerRuntimeProtocolMessageDispatch {
session_id: self.session_id,
- messages,
- deferred_response_rx: self.deferred_response_rx,
+ dispatch,
+ response_route: self.response_route,
})
}
}
@@ -699,7 +698,19 @@ impl CompletedSharedWorkerRuntimeProtocolMessageDispatch {
pub(crate) fn take_deferred_response_receiver(
&mut self,
) -> Option<RuntimeInspectorResponseReceiver> {
- self.deferred_response_rx.take()
+ self.response_route.take_command_reply_receiver()
+ }
+
+ pub(crate) const fn response_delivery(&self) -> RendererInspectorResponseDelivery {
+ self.response_route.delivery()
+ }
+
+ pub(crate) fn session_response_predecessor(&self) -> Option<RendererOutputFence> {
+ self.dispatch.session_response_predecessor.clone()
+ }
+
+ pub(crate) fn session_response_succeeded(&self) -> Option<bool> {
+ self.dispatch.session_response_succeeded
}
}
@@ -707,7 +718,19 @@ impl CompletedServiceWorkerRuntimeProtocolMessageDispatch {
pub(crate) fn take_deferred_response_receiver(
&mut self,
) -> Option<RuntimeInspectorResponseReceiver> {
- self.deferred_response_rx.take()
+ self.response_route.take_command_reply_receiver()
+ }
+
+ pub(crate) const fn response_delivery(&self) -> RendererInspectorResponseDelivery {
+ self.response_route.delivery()
+ }
+
+ pub(crate) fn session_response_predecessor(&self) -> Option<RendererOutputFence> {
+ self.dispatch.session_response_predecessor.clone()
+ }
+
+ pub(crate) fn session_response_succeeded(&self) -> Option<bool> {
+ self.dispatch.session_response_succeeded
}
}
@@ -1025,12 +1048,30 @@ impl CdpConnection {
&self,
session_id: Option<&str>,
renderer_call_id: RendererCallId,
- dispatched_attachment_id: RendererAgentAttachmentId,
+ dispatched_attachment_id: Option<RendererAgentAttachmentId>,
) -> Option<RendererCommandDescriptor> {
+ if let Some(owner_session_id) = session_id
+ && let Some(target) = self.shared_worker_target_for_session(session_id)
+ {
+ return target.renderer_command_descriptor_for_renderer_if_attachment_matches(
+ owner_session_id,
+ renderer_call_id,
+ dispatched_attachment_id,
+ );
+ }
+ if let Some(owner_session_id) = session_id
+ && let Some(target) = self.service_worker_target_for_session(session_id)
+ {
+ return target.renderer_command_descriptor_for_renderer_if_attachment_matches(
+ owner_session_id,
+ renderer_call_id,
+ dispatched_attachment_id,
+ );
+ }
self.target_devtools_session_state_for_session(session_id)?
.renderer_command_descriptor_for_renderer_if_attachment_matches(
renderer_call_id,
- Some(dispatched_attachment_id),
+ dispatched_attachment_id,
)
}
@@ -1985,63 +2026,6 @@ impl CdpConnection {
.is_some_and(DevToolsSessionState::has_pending_inspector_awaits)
}
- pub(crate) fn fail_pending_inspector_awaits_from_page_session_state_for_sessions_background_events_into(
- out: &mut Vec<BackgroundProtocolEvent>,
- page_session_state: &mut PageTargetHost,
- primary_session_id: Option<&str>,
- session_ids: &[&str],
- reason: &'static str,
- ) {
- for (cdp_id, entry) in page_session_state
- .devtools_sessions
- .drain_pending_inspector_awaits_for_sessions(session_ids)
- {
- if let Some(listener) = entry.bidi_channel_listener() {
- unregister_runtime_remote_object_group_from_page_target(
- page_session_state,
- entry.session_id(),
- listener.channel_object_group(),
- );
- continue;
- }
- push_pending_inspector_await_error_background_event(
- out,
- cdp_id,
- entry.session_id(),
- reason,
- );
- }
- if let Some(primary_session_id) = primary_session_id
- && session_ids.contains(&primary_session_id)
- {
- let terminated = page_session_state
- .devtools_sessions
- .primary_mut()
- .terminate_all_renderer_calls(reason);
- push_terminated_renderer_call_error_background_events(
- out,
- terminated,
- Some(primary_session_id),
- reason,
- );
- }
- for session_id in session_ids {
- let Some(state) = page_session_state
- .devtools_sessions
- .attached_mut(session_id)
- else {
- continue;
- };
- let terminated = state.terminate_all_renderer_calls(reason);
- push_terminated_renderer_call_error_background_events(
- out,
- terminated,
- Some(session_id),
- reason,
- );
- }
- }
-
pub(crate) fn fail_pending_inspector_awaits_from_shared_worker_target_session_background_events_into(
out: &mut Vec<BackgroundProtocolEvent>,
target: &mut SharedWorkerTargetState,
@@ -3788,7 +3772,24 @@ impl CdpConnection {
) {
self.restore_frontend_command_ids_in_devtools_session_output_with_projection(
session_id,
- dispatched_attachment_id,
+ Some(dispatched_attachment_id),
+ messages,
+ true,
+ );
+ }
+
+ /// Resolves terminal responses carried by a Worker target's concrete
+ /// renderer output stream. Worker Inspector sessions do not use a Page
+ /// attachment id; the exact worker session lifetime is validated by the
+ /// prepared-output authority at the same ingress boundary.
+ pub(crate) fn restore_frontend_command_ids_in_worker_devtools_session_output(
+ &mut self,
+ session_id: &str,
+ messages: &mut Vec<RendererRuntimeInspectorMessage>,
+ ) {
+ self.restore_frontend_command_ids_in_devtools_session_output_with_projection(
+ Some(session_id),
+ None,
messages,
true,
);
@@ -3811,7 +3812,7 @@ impl CdpConnection {
) {
self.restore_frontend_command_ids_in_devtools_session_output_with_projection(
session_id,
- dispatched_attachment_id,
+ Some(dispatched_attachment_id),
messages,
false,
);
@@ -3820,7 +3821,7 @@ impl CdpConnection {
fn restore_frontend_command_ids_in_devtools_session_output_with_projection(
&mut self,
session_id: Option<&str>,
- dispatched_attachment_id: RendererAgentAttachmentId,
+ dispatched_attachment_id: Option<RendererAgentAttachmentId>,
messages: &mut Vec<RendererRuntimeInspectorMessage>,
project_runtime_object_ownership: bool,
) {
@@ -3846,13 +3847,13 @@ impl CdpConnection {
.take_frontend_command_for_renderer_if_attachment_matches_for_session_owner(
session_id,
renderer_call_id,
- Some(dispatched_attachment_id),
+ dispatched_attachment_id,
)
else {
tracing::debug!(
session_id,
renderer_call_id = renderer_call_id.get(),
- attachment_id = dispatched_attachment_id.get(),
+ attachment_id = ?dispatched_attachment_id.map(RendererAgentAttachmentId::get),
"dropping DevTools session response without a live renderer correlation"
);
return false;
@@ -4648,6 +4649,7 @@ impl CdpConnection {
session_id,
raw_json,
None,
+ RuntimeProtocolResponseRoute::command_reply_without_receiver(),
)
}
@@ -4658,37 +4660,22 @@ impl CdpConnection {
command_id: u64,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
self.shared_worker_runtime_target_for_session(session_id)?;
- let (correlation, raw_json, response_sender, response_route) =
+ let (_correlation, raw_json, response_sender, response_route) =
self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;
- debug_assert_eq!(
- response_route.delivery(),
- RendererInspectorResponseDelivery::CommandReply,
- "worker responses have not migrated to the page DevTools session output"
- );
- let response_receiver = response_route
- .into_command_reply_receiver()
- .expect("CommandReply worker dispatch must allocate a response receiver");
- let result = self.start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
+ self.start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
- Some((response_sender, response_receiver)),
- );
- if result.is_err() {
- let removed =
- self.take_renderer_call_for_frontend_for_session_owner(session_id, command_id);
- debug_assert_eq!(removed, Some(correlation));
- }
- result
+ Some(response_sender),
+ response_route,
+ )
}
fn start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
&mut self,
session_id: Option<&str>,
raw_json: String,
- deferred_response: Option<(
- RendererRuntimeInspectorResponseSender,
- RuntimeInspectorResponseReceiver,
- )>,
+ response_sender: Option<RendererRuntimeInspectorResponseSender>,
+ response_route: RuntimeProtocolResponseRoute,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
let route = self.shared_worker_runtime_target_for_session(session_id)?;
let renderer_runtime = self
@@ -4697,24 +4684,51 @@ impl CdpConnection {
.ok_or_else(|| "UnknownSession".to_owned())?;
let worker = route.worker;
let inspector_session_id = session_id.map(str::to_owned);
- let (deferred_response, deferred_response_rx) = match deferred_response {
- Some((deferred_response, rx)) => (Some(deferred_response), Some(rx)),
- None => (None, None),
- };
- let pending: SharedWorkerRuntimeProtocolDispatchFuture = match (worker, deferred_response) {
- (WorkerRuntimeTarget::Shared(instance_id), Some(deferred_response)) => {
+ let response_delivery = response_route.delivery();
+ let pending: SharedWorkerRuntimeProtocolDispatchFuture = match (
+ worker,
+ response_sender,
+ response_delivery,
+ ) {
+ (
+ WorkerRuntimeTarget::Shared(instance_id),
+ Some(response),
+ RendererInspectorResponseDelivery::CommandReply,
+ ) => Box::pin(async move {
+ renderer_runtime
+ .dispatch_shared_worker_runtime_protocol_message_with_deferred_response(
+ instance_id,
+ inspector_session_id,
+ raw_json,
+ response,
+ )
+ .await
+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)
+ }),
+ (
+ WorkerRuntimeTarget::Shared(instance_id),
+ Some(response),
+ RendererInspectorResponseDelivery::DevToolsSession,
+ ) => {
+ let inspector_session_id =
+ inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;
Box::pin(async move {
renderer_runtime
- .dispatch_shared_worker_runtime_protocol_message_with_deferred_response(
+ .dispatch_shared_worker_runtime_protocol_message_with_devtools_session_response(
instance_id,
inspector_session_id,
raw_json,
- deferred_response,
+ response,
)
.await
+ .map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)
})
}
- (WorkerRuntimeTarget::Shared(instance_id), None) => Box::pin(async move {
+ (
+ WorkerRuntimeTarget::Shared(instance_id),
+ None,
+ RendererInspectorResponseDelivery::CommandReply,
+ ) => Box::pin(async move {
renderer_runtime
.dispatch_shared_worker_runtime_protocol_message(
instance_id,
@@ -4722,20 +4736,47 @@ impl CdpConnection {
raw_json,
)
.await
+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)
}),
- (WorkerRuntimeTarget::Dedicated(instance_id), Some(deferred_response)) => {
+ (
+ WorkerRuntimeTarget::Dedicated(instance_id),
+ Some(response),
+ RendererInspectorResponseDelivery::CommandReply,
+ ) => Box::pin(async move {
+ renderer_runtime
+ .dispatch_dedicated_worker_runtime_protocol_message_with_deferred_response(
+ instance_id,
+ inspector_session_id,
+ raw_json,
+ response,
+ )
+ .await
+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)
+ }),
+ (
+ WorkerRuntimeTarget::Dedicated(instance_id),
+ Some(response),
+ RendererInspectorResponseDelivery::DevToolsSession,
+ ) => {
+ let inspector_session_id =
+ inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;
Box::pin(async move {
renderer_runtime
- .dispatch_dedicated_worker_runtime_protocol_message_with_deferred_response(
+ .dispatch_dedicated_worker_runtime_protocol_message_with_devtools_session_response(
instance_id,
inspector_session_id,
raw_json,
- deferred_response,
+ response,
)
.await
+ .map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)
})
}
- (WorkerRuntimeTarget::Dedicated(instance_id), None) => Box::pin(async move {
+ (
+ WorkerRuntimeTarget::Dedicated(instance_id),
+ None,
+ RendererInspectorResponseDelivery::CommandReply,
+ ) => Box::pin(async move {
renderer_runtime
.dispatch_dedicated_worker_runtime_protocol_message(
instance_id,
@@ -4743,12 +4784,16 @@ impl CdpConnection {
raw_json,
)
.await
+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)
}),
+ (_, None, RendererInspectorResponseDelivery::DevToolsSession) => {
+ return Err("DevToolsSessionResponseSenderMissing".to_owned());
+ }
};
Ok(PendingSharedWorkerRuntimeProtocolMessageDispatch {
session_id: session_id.map(str::to_owned),
pending,
- deferred_response_rx,
+ response_route,
})
}
@@ -4788,9 +4833,9 @@ impl CdpConnection {
self.restore_frontend_command_ids_in_runtime_messages(
completed.session_id.as_deref(),
None,
- &mut completed.messages,
+ &mut completed.dispatch.messages,
);
- Ok(completed.messages)
+ Ok(completed.dispatch.messages)
}
pub(crate) fn start_service_worker_runtime_protocol_message_for_session(
@@ -4804,6 +4849,7 @@ impl CdpConnection {
session_id,
raw_json,
None,
+ RuntimeProtocolResponseRoute::command_reply_without_receiver(),
)
}
@@ -4814,37 +4860,22 @@ impl CdpConnection {
command_id: u64,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
self.service_worker_runtime_target_for_session(session_id)?;
- let (correlation, raw_json, response_sender, response_route) =
+ let (_correlation, raw_json, response_sender, response_route) =
self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;
- debug_assert_eq!(
- response_route.delivery(),
- RendererInspectorResponseDelivery::CommandReply,
- "worker responses have not migrated to the page DevTools session output"
- );
- let response_receiver = response_route
- .into_command_reply_receiver()
- .expect("CommandReply worker dispatch must allocate a response receiver");
- let result = self.start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
+ self.start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
- Some((response_sender, response_receiver)),
- );
- if result.is_err() {
- let removed =
- self.take_renderer_call_for_frontend_for_session_owner(session_id, command_id);
- debug_assert_eq!(removed, Some(correlation));
- }
- result
+ Some(response_sender),
+ response_route,
+ )
}
fn start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
&mut self,
session_id: Option<&str>,
raw_json: String,
- deferred_response: Option<(
- RendererRuntimeInspectorResponseSender,
- RuntimeInspectorResponseReceiver,
- )>,
+ response_sender: Option<RendererRuntimeInspectorResponseSender>,
+ response_route: RuntimeProtocolResponseRoute,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
let route = self.service_worker_runtime_target_for_session(session_id)?;
let renderer_runtime = self
@@ -4853,36 +4884,50 @@ impl CdpConnection {
.ok_or_else(|| "UnknownSession".to_owned())?;
let version_id = route.version_id;
let inspector_session_id = session_id.map(str::to_owned);
- let (deferred_response, deferred_response_rx) = match deferred_response {
- Some((deferred_response, rx)) => (Some(deferred_response), Some(rx)),
- None => (None, None),
- };
- let pending =
- Box::pin(async move {
- match deferred_response {
- Some(deferred_response) => renderer_runtime
+ let response_delivery = response_route.delivery();
+ let pending: ServiceWorkerRuntimeProtocolDispatchFuture = Box::pin(async move {
+ match (response_sender, response_delivery) {
+ (Some(response), RendererInspectorResponseDelivery::CommandReply) => {
+ renderer_runtime
.dispatch_service_worker_runtime_protocol_message_with_deferred_response(
version_id,
inspector_session_id,
raw_json,
- deferred_response,
+ response,
)
- .await,
- None => {
- renderer_runtime
- .dispatch_service_worker_runtime_protocol_message(
+ .await
+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply)
+ }
+ (Some(response), RendererInspectorResponseDelivery::DevToolsSession) => {
+ let inspector_session_id =
+ inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;
+ renderer_runtime
+ .dispatch_service_worker_runtime_protocol_message_with_devtools_session_response(
version_id,
inspector_session_id,
raw_json,
+ response,
)
.await
- }
+ .map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)
}
- });
+ (None, RendererInspectorResponseDelivery::CommandReply) => renderer_runtime
+ .dispatch_service_worker_runtime_protocol_message(
+ version_id,
+ inspector_session_id,
+ raw_json,
+ )
+ .await
+ .map(CompletedWorkerRuntimeProtocolDispatch::command_reply),
+ (None, RendererInspectorResponseDelivery::DevToolsSession) => {
+ Err("DevToolsSessionResponseSenderMissing".to_owned())
+ }
+ }
+ });
Ok(PendingServiceWorkerRuntimeProtocolMessageDispatch {
session_id: session_id.map(str::to_owned),
pending,
- deferred_response_rx,
+ response_route,
})
}
@@ -4893,9 +4938,9 @@ impl CdpConnection {
self.restore_frontend_command_ids_in_runtime_messages(
completed.session_id.as_deref(),
None,
- &mut completed.messages,
+ &mut completed.dispatch.messages,
);
- Ok(completed.messages)
+ Ok(completed.dispatch.messages)
}
pub(crate) fn start_moli_diagnostics(
diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rs
index 6427f5dcf..c4c5b16dc 100644
--- a/moli-protocol/src/conn/runtime_load.rs
+++ b/moli-protocol/src/conn/runtime_load.rs
@@ -305,7 +305,7 @@ pub struct ResponseCommitReady {
response_status: u16,
response_headers: Vec<(String, String)>,
response_from_cache: bool,
- navigation_engine: Option<NavigationEngine>,
+ navigation_engine_handoff: NavigationEngineHandoff,
timing_started: Option<std::time::Instant>,
main_document_commit: Option<Arc<RendererMainDocumentCommit>>,
network_error_page: Option<NetworkErrorPageNavigation>,
@@ -399,8 +399,8 @@ impl ResponseCommitReady {
.issue_commit_permit()
}
- pub(crate) fn with_navigation_engine(mut self, engine: NavigationEngine) -> Self {
- self.navigation_engine = Some(engine);
+ pub(crate) fn with_navigation_engine_replacement(mut self, engine: NavigationEngine) -> Self {
+ self.navigation_engine_handoff = NavigationEngineHandoff::replacement(engine);
self
}
@@ -492,7 +492,10 @@ impl ResponseCommitReady {
renderer_output_predecessor: diagnostics.renderer_output_predecessor,
main_document_commit: self.main_document_commit.take(),
document_progress_transfer,
- navigation_engine: self.navigation_engine.take(),
+ navigation_engine_handoff: std::mem::replace(
+ &mut self.navigation_engine_handoff,
+ NavigationEngineHandoff::retained_by_owner(),
+ ),
network_error_page: self.network_error_page.take(),
})
}
@@ -588,7 +591,7 @@ impl PausedResponsePreparedDocument {
response_status: self.response_status,
response_headers: self.response_headers,
response_from_cache: self.response_from_cache,
- navigation_engine: None,
+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),
timing_started: self.timing_started,
main_document_commit: self.main_document_commit,
network_error_page: None,
@@ -1437,7 +1440,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(
response_status,
response_headers,
response_from_cache,
- navigation_engine: None,
+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),
timing_started: timing_enabled.then_some(timing_started),
main_document_commit,
network_error_page: None,
@@ -1530,7 +1533,7 @@ async fn build_navigation_from_streaming_raw_response_with_engine_async(
response_status,
response_headers,
response_from_cache,
- navigation_engine: None,
+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),
timing_started: timing_enabled.then_some(timing_started),
main_document_commit,
network_error_page: None,
@@ -2414,8 +2417,9 @@ impl CdpConnection {
)
.await
{
- return navigation
- .map(|navigation| navigation.with_navigation_engine(inline_engine));
+ return navigation.map(|navigation| {
+ navigation.with_navigation_engine_replacement(inline_engine)
+ });
}
if let Some(navigation) = load_data_url_navigation_with_engine_async(
&mut inline_engine,
@@ -2428,8 +2432,9 @@ impl CdpConnection {
)
.await
{
- return navigation
- .map(|navigation| navigation.with_navigation_engine(inline_engine));
+ return navigation.map(|navigation| {
+ navigation.with_navigation_engine_replacement(inline_engine)
+ });
}
}
@@ -2789,8 +2794,8 @@ impl CdpConnection {
}
pub async fn load_page_via_runtime_async(&mut self, raw_url: &str) -> Result<Page, String> {
- let navigation = self.load_navigation_via_runtime_async(raw_url).await?;
- if let Some(engine) = navigation.navigation_engine {
+ let mut navigation = self.load_navigation_via_runtime_async(raw_url).await?;
+ if let Some(engine) = navigation.take_navigation_engine_replacement() {
let page_owner = self.browser_context.as_ref().and_then(|context| {
Some((context.id.clone(), context.active_target_id()?.to_owned()))
});
@@ -3138,7 +3143,7 @@ impl CdpConnection {
false,
network_progress,
),
- navigation_engine: None,
+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),
network_error_page: None,
})
}
@@ -3436,7 +3441,7 @@ impl CdpConnection {
false,
network_progress,
),
- navigation_engine: None,
+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),
network_error_page: None,
})
}
@@ -3633,7 +3638,7 @@ impl CdpConnection {
)
.await?;
Ok(NavigationLoadOutcome::response_commit_ready(
- navigation.with_navigation_engine(engine),
+ navigation.with_navigation_engine_replacement(engine),
))
}
@@ -3786,7 +3791,7 @@ impl CdpConnection {
RendererReplyBoundary::Stage,
)
.await?;
- Ok(navigation.with_navigation_engine(engine))
+ Ok(navigation.with_navigation_engine_replacement(engine))
}
pub(crate) async fn collect_navigation_streaming_raw_response_async(
@@ -4055,7 +4060,7 @@ async fn prepare_captured_document_response_with_engine_async(
response_status,
response_headers,
response_from_cache,
- navigation_engine: None,
+ navigation_engine_handoff: NavigationEngineHandoff::retained_by_owner(),
timing_started: None,
main_document_commit,
network_error_page,
diff --git a/moli-protocol/src/conn/state/browser_context.rs b/moli-protocol/src/conn/state/browser_context.rs
index e352ff33b..e1681eb12 100644
--- a/moli-protocol/src/conn/state/browser_context.rs
+++ b/moli-protocol/src/conn/state/browser_context.rs
@@ -1713,6 +1713,7 @@ impl BrowserContext {
.attach_session(session_id.into());
}
+ #[cfg(test)]
pub(crate) fn detach_active_session(&mut self) -> Option<String> {
self.page_targets.active_mut()?.detach_session()
}
diff --git a/moli-protocol/src/conn/state/devtools_session.rs b/moli-protocol/src/conn/state/devtools_session.rs
index e23acd8c3..fcfdd651a 100644
--- a/moli-protocol/src/conn/state/devtools_session.rs
+++ b/moli-protocol/src/conn/state/devtools_session.rs
@@ -133,11 +133,6 @@ impl DevToolsSessionRegistry {
.get(&DevToolsSessionKey::Attached(session_id.to_owned()))
}
- pub(crate) fn attached_mut(&mut self, session_id: &str) -> Option<&mut DevToolsSessionState> {
- self.states
- .get_mut(&DevToolsSessionKey::Attached(session_id.to_owned()))
- }
-
pub(crate) fn ensure_attached(&mut self, session_id: &str) -> &mut DevToolsSessionState {
if !self
.states
@@ -160,10 +155,31 @@ impl DevToolsSessionRegistry {
removed
}
- pub(crate) fn clear_attached(&mut self) {
- self.states
- .retain(|key, _state| matches!(key, DevToolsSessionKey::Primary));
- self.attached_order.clear();
+ /// Removes one wire session and all domain-handler state it owns.
+ ///
+ /// The primary handler slot remains allocated for the renderer's implicit
+ /// root Inspector session, but its state is replaced atomically. Attached
+ /// sessions are removed from both the state map and attachment order.
+ pub(crate) fn dispose(
+ &mut self,
+ session_id: &str,
+ session_key: &DevToolsSessionKey,
+ ) -> Option<DevToolsSessionState> {
+ match session_key {
+ DevToolsSessionKey::Primary => {
+ if self.primary_session_id() != Some(session_id) {
+ return None;
+ }
+ self.primary_session_id = None;
+ Some(std::mem::take(self.primary_mut()))
+ }
+ DevToolsSessionKey::Attached(attached_session_id)
+ if attached_session_id == session_id =>
+ {
+ self.remove_attached(session_id)
+ }
+ DevToolsSessionKey::Attached(_) => None,
+ }
}
pub(crate) fn attached_len(&self) -> usize {
@@ -384,13 +400,6 @@ impl DevToolsSessionRegistry {
self.states.values_mut()
}
- pub(crate) fn reset(&mut self, preserve_attached_sessions: bool) {
- *self.primary_mut() = DevToolsSessionState::default();
- if !preserve_attached_sessions {
- self.clear_attached();
- }
- }
-
pub(crate) fn has_non_default_state(&self) -> bool {
self.primary() != &DevToolsSessionState::default() || !self.attached_is_empty()
}
@@ -406,15 +415,6 @@ impl DevToolsSessionRegistry {
.sum()
}
- pub(crate) fn drain_pending_inspector_awaits_for_sessions(
- &mut self,
- session_ids: &[&str],
- ) -> Vec<(u64, PendingInspectorAwait)> {
- self.states_mut()
- .flat_map(|state| state.drain_pending_inspector_awaits_for_sessions(session_ids))
- .collect()
- }
-
pub(crate) fn prepare_renderer_call_replacements(
&mut self,
primary_session_id: Option<&str>,
@@ -915,14 +915,6 @@ impl DevToolsSessionState {
self.pending_inspector_awaits.drain_all()
}
- pub(crate) fn drain_pending_inspector_awaits_for_sessions(
- &mut self,
- session_ids: &[&str],
- ) -> Vec<(u64, PendingInspectorAwait)> {
- self.pending_inspector_awaits
- .drain_for_sessions(session_ids)
- }
-
pub(crate) fn register_runtime_remote_object_ids<I>(&mut self, object_ids: I)
where
I: IntoIterator<Item = String>,
@@ -1428,13 +1420,71 @@ mod tests {
assert!(sessions.has_pending_inspector_awaits());
assert_eq!(sessions.pending_inspector_await_count(), 2);
- let drained = sessions.drain_pending_inspector_awaits_for_sessions(&["SID-attached"]);
- assert_eq!(drained.len(), 1);
+ let disposed = sessions
+ .dispose(
+ "SID-attached",
+ &DevToolsSessionKey::Attached("SID-attached".to_owned()),
+ )
+ .expect("attached session should be disposed");
+ assert_eq!(disposed.pending_inspector_await_count(), 1);
assert_eq!(sessions.pending_inspector_await_count(), 1);
- sessions.remove_attached("SID-attached");
+ assert!(sessions.attached_is_empty());
assert_eq!(sessions.pending_inspector_await_count(), 1);
- sessions.reset(false);
+ *sessions.primary_mut() = DevToolsSessionState::default();
assert!(!sessions.has_pending_inspector_awaits());
}
+
+ #[test]
+ fn registry_dispose_is_exactly_once_and_preserves_peer_sessions() {
+ let mut sessions = DevToolsSessionRegistry::default();
+ sessions.attach_primary("SID-primary".to_owned());
+ sessions
+ .primary_mut()
+ .runtime_bindings
+ .push(binding("primary"));
+ sessions
+ .ensure_attached("SID-attached")
+ .runtime_bindings
+ .push(binding("attached"));
+
+ let disposed_attached = sessions
+ .dispose(
+ "SID-attached",
+ &DevToolsSessionKey::Attached("SID-attached".to_owned()),
+ )
+ .expect("attached session should be disposed");
+ assert_eq!(
+ disposed_attached.runtime_bindings,
+ vec![binding("attached")]
+ );
+ assert!(sessions.attached_is_empty());
+ assert_eq!(sessions.primary_session_id(), Some("SID-primary"));
+ assert_eq!(
+ sessions.primary().runtime_bindings,
+ vec![binding("primary")]
+ );
+ assert!(
+ sessions
+ .dispose(
+ "SID-attached",
+ &DevToolsSessionKey::Attached("SID-attached".to_owned()),
+ )
+ .is_none(),
+ "a disposed session must not settle twice"
+ );
+
+ let disposed_primary = sessions
+ .dispose("SID-primary", &DevToolsSessionKey::Primary)
+ .expect("primary session should be disposed");
+ assert_eq!(disposed_primary.runtime_bindings, vec![binding("primary")]);
+ assert_eq!(sessions.primary_session_id(), None);
+ assert_eq!(sessions.primary(), &DevToolsSessionState::default());
+ assert!(
+ sessions
+ .dispose("SID-primary", &DevToolsSessionKey::Primary)
+ .is_none(),
+ "primary disposal must also be exactly once"
+ );
+ }
}
diff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rs
index 2845e7b0f..4bbe4a457 100644
--- a/moli-protocol/src/conn/state/fetch.rs
+++ b/moli-protocol/src/conn/state/fetch.rs
@@ -1158,6 +1158,7 @@ impl TargetFetchConfig {
})
}
+ #[cfg(test)]
pub(crate) fn reset(&mut self) {
*self = Self::default();
}
@@ -1763,6 +1764,7 @@ impl TargetFetchOwner {
self.config.remove_network_intercept(intercept_id)
}
+ #[cfg(test)]
pub(crate) fn reset_config(&mut self) {
self.config.reset();
}
diff --git a/moli-protocol/src/conn/state/mod.rs b/moli-protocol/src/conn/state/mod.rs
index f52b11a3d..28cb5a590 100644
--- a/moli-protocol/src/conn/state/mod.rs
+++ b/moli-protocol/src/conn/state/mod.rs
@@ -138,6 +138,7 @@ pub use navigation_outcome::{
NavigationRequestLoadPolicy, TargetInfo,
};
pub(crate) use navigation_outcome::{
- NETWORK_ERROR_PAGE_URL, NavigationResultProjection, NavigationSourceDocumentSecurityContext,
- NetworkErrorPageNavigation, RendererMainDocumentCommitSeed,
+ NETWORK_ERROR_PAGE_URL, NavigationEngineHandoff, NavigationResultProjection,
+ NavigationSourceDocumentSecurityContext, NetworkErrorPageNavigation,
+ RendererMainDocumentCommitSeed,
};
diff --git a/moli-protocol/src/conn/state/navigation_outcome.rs b/moli-protocol/src/conn/state/navigation_outcome.rs
index 840c4383a..05265997a 100644
--- a/moli-protocol/src/conn/state/navigation_outcome.rs
+++ b/moli-protocol/src/conn/state/navigation_outcome.rs
@@ -19,6 +19,35 @@ use super::browser_context::BrowserContext;
pub(crate) const NETWORK_ERROR_PAGE_URL: &str = "chrome-error://chromewebdata/";
+/// What must happen to the navigation engine after a completed load is
+/// committed.
+///
+/// Foreground loads borrow the engine already installed on their target.
+/// Background loads own a temporary engine and must return it to that exact
+/// target after commit. Keeping this distinction explicit prevents an omitted
+/// replacement handoff from silently looking like a valid background load.
+#[derive(Debug)]
+pub(crate) struct NavigationEngineHandoff(Option<NavigationEngine>);
+
+impl NavigationEngineHandoff {
+ pub(crate) fn retained_by_owner() -> Self {
+ Self(None)
+ }
+
+ pub(crate) fn replacement(engine: NavigationEngine) -> Self {
+ Self(Some(engine))
+ }
+
+ pub(crate) fn into_replacement(self) -> Option<NavigationEngine> {
+ self.0
+ }
+
+ #[cfg(test)]
+ pub(crate) fn replacement_ref(&self) -> Option<&NavigationEngine> {
+ self.0.as_ref()
+ }
+}
+
#[derive(Clone, Debug)]
pub(crate) struct NetworkErrorPageNavigation {
error_text: String,
@@ -194,16 +223,29 @@ pub struct LoadedNavigation {
pub renderer_output_predecessor: Option<moli_core::RendererOutputFence>,
pub(crate) main_document_commit: Option<Arc<RendererMainDocumentCommit>>,
pub(crate) document_progress_transfer: CompletedDocumentProgressTransfer,
- pub(crate) navigation_engine: Option<NavigationEngine>,
+ pub(crate) navigation_engine_handoff: NavigationEngineHandoff,
pub(crate) network_error_page: Option<NetworkErrorPageNavigation>,
}
impl LoadedNavigation {
- pub(crate) fn with_navigation_engine(mut self, engine: NavigationEngine) -> Self {
- self.navigation_engine = Some(engine);
+ pub(crate) fn with_navigation_engine_replacement(mut self, engine: NavigationEngine) -> Self {
+ self.navigation_engine_handoff = NavigationEngineHandoff::replacement(engine);
self
}
+ pub(crate) fn take_navigation_engine_replacement(&mut self) -> Option<NavigationEngine> {
+ std::mem::replace(
+ &mut self.navigation_engine_handoff,
+ NavigationEngineHandoff::retained_by_owner(),
+ )
+ .into_replacement()
+ }
+
+ #[cfg(test)]
+ pub(crate) fn navigation_engine_replacement(&self) -> Option<&NavigationEngine> {
+ self.navigation_engine_handoff.replacement_ref()
+ }
+
#[cfg(test)]
pub(crate) fn response_body(&self) -> String {
self.document_progress_transfer
@@ -253,12 +295,14 @@ impl NavigationLoadOutcome {
Self::NetworkFailure(error_text)
}
- pub(crate) fn with_navigation_engine(self, engine: NavigationEngine) -> Self {
+ pub(crate) fn with_navigation_engine_replacement(self, engine: NavigationEngine) -> Self {
match self {
Self::ResponseCommitReady(navigation) => {
- Self::response_commit_ready(navigation.with_navigation_engine(engine))
+ Self::response_commit_ready(navigation.with_navigation_engine_replacement(engine))
+ }
+ Self::Loaded(navigation) => {
+ Self::loaded(navigation.with_navigation_engine_replacement(engine))
}
- Self::Loaded(navigation) => Self::loaded(navigation.with_navigation_engine(engine)),
Self::Download(navigation) => Self::Download(navigation),
Self::NetworkFailure(error_text) => Self::NetworkFailure(error_text),
}
diff --git a/moli-protocol/src/conn/state/parking.rs b/moli-protocol/src/conn/state/parking.rs
index a72baa32b..11b13dc06 100644
--- a/moli-protocol/src/conn/state/parking.rs
+++ b/moli-protocol/src/conn/state/parking.rs
@@ -308,33 +308,6 @@ impl TargetPendingInspectorAwaitRegistry {
}
Some(entry)
}
-
- pub(crate) fn drain_for_sessions(
- &mut self,
- session_ids: &[&str],
- ) -> Vec<(u64, PendingInspectorAwait)> {
- if self.entries.is_empty() || session_ids.is_empty() {
- return Vec::new();
- }
- let to_remove: Vec<FrontendCommandId> = self
- .entries
- .iter()
- .filter_map(|(id, entry)| {
- entry
- .session_id
- .as_deref()
- .filter(|sid| session_ids.contains(sid))
- .map(|_| *id)
- })
- .collect();
- to_remove
- .into_iter()
- .filter_map(|id| {
- self.remove_for_cancellation(id)
- .map(|entry| (id.get(), entry))
- })
- .collect()
- }
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
@@ -533,21 +506,41 @@ impl TargetOwnerState {
.any(|(_, script)| script.has_bidi_channel_argument)
}
- pub(crate) fn take_document_start_script_registry_keys_for_session(
- &mut self,
+ pub(crate) fn document_start_script_registry_keys_for_session(
+ &self,
devtools_session: &DevToolsSessionKey,
) -> Vec<String> {
- let mut registry_keys = Vec::new();
- self.document_start_scripts.retain(|(_, script)| {
- if script.devtools_session.as_ref() != Some(devtools_session) {
- return true;
- }
- if let Some(registry_key) = script.registry_key.clone() {
- registry_keys.push(registry_key);
- }
- false
- });
- registry_keys
+ self.document_start_scripts
+ .iter()
+ .filter_map(|(_, script)| {
+ (script.devtools_session.as_ref() == Some(devtools_session))
+ .then(|| script.registry_key.clone())
+ .flatten()
+ })
+ .collect()
+ }
+
+ pub(crate) fn remove_document_start_scripts_for_session(
+ &mut self,
+ devtools_session: &DevToolsSessionKey,
+ ) {
+ self.document_start_scripts
+ .retain(|(_, script)| script.devtools_session.as_ref() != Some(devtools_session));
+ }
+
+ pub(crate) fn remove_document_start_script_registry_key_for_session(
+ &mut self,
+ devtools_session: &DevToolsSessionKey,
+ registry_key: &str,
+ ) -> bool {
+ let Some(index) = self.document_start_scripts.iter().position(|(_, script)| {
+ script.devtools_session.as_ref() == Some(devtools_session)
+ && script.registry_key.as_deref() == Some(registry_key)
+ }) else {
+ return false;
+ };
+ self.document_start_scripts.remove(index);
+ true
}
pub(crate) fn begin_initial_empty_document(
diff --git a/moli-protocol/src/conn/state/runtime_slot.rs b/moli-protocol/src/conn/state/runtime_slot.rs
index e0d30d741..3c552efc5 100644
--- a/moli-protocol/src/conn/state/runtime_slot.rs
+++ b/moli-protocol/src/conn/state/runtime_slot.rs
@@ -70,16 +70,6 @@ pub(crate) struct TargetNetworkRequestIdAllocator<'a> {
}
impl TargetNetworkRequestIdAllocator<'_> {
- pub(crate) fn reset_fetch_navigation_request_counter(&mut self) {
- self.runtime_slot.request_counters.next_fetch_request_id = 0;
- }
-
- pub(crate) fn reset_subresource_fetch_request_counter(&mut self) {
- self.runtime_slot
- .request_counters
- .next_subresource_fetch_request_id = 0;
- }
-
pub(crate) fn allocate_fetch_navigation_request_id(&mut self) -> String {
self.runtime_slot.request_counters.next_fetch_request_id += 1;
format!(
@@ -1238,11 +1228,6 @@ impl TargetRuntimeSlot {
.synthetic_websocket_socket_id_for_request(request_id)
}
- pub(crate) fn clear_session_scoped_network_observation_artifacts(&mut self) {
- self.network_agent
- .clear_session_scoped_observation_artifacts();
- }
-
pub(crate) fn reset_all_target_scoped_network_artifacts(&mut self) {
self.network_agent.reset_all_target_scoped_artifacts();
}
diff --git a/moli-protocol/src/conn/state/service_worker_target.rs b/moli-protocol/src/conn/state/service_worker_target.rs
index 80515b1e3..64babf567 100644
--- a/moli-protocol/src/conn/state/service_worker_target.rs
+++ b/moli-protocol/src/conn/state/service_worker_target.rs
@@ -1016,6 +1016,19 @@ impl ServiceWorkerTargetState {
)
}
+ pub(crate) fn renderer_command_descriptor_for_renderer_if_attachment_matches(
+ &self,
+ owner_session_id: &str,
+ renderer_call_id: moli_page_types::RendererCallId,
+ dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,
+ ) -> Option<RendererCommandDescriptor> {
+ self.session_state(owner_session_id)?
+ .renderer_command_descriptor_for_renderer_if_attachment_matches(
+ renderer_call_id,
+ dispatched_attachment_id,
+ )
+ }
+
pub(crate) fn has_pending_inspector_awaits(&self) -> bool {
self.sessions
.values()
diff --git a/moli-protocol/src/conn/state/session.rs b/moli-protocol/src/conn/state/session.rs
index 89d19cb99..4fedf0d2d 100644
--- a/moli-protocol/src/conn/state/session.rs
+++ b/moli-protocol/src/conn/state/session.rs
@@ -1,6 +1,5 @@
use super::devtools_session::DevToolsNetworkSessionState;
use super::emulation::EmulatedMediaOverrides;
-use super::fetch::TargetFetchOwner;
use super::javascript_dialog::TargetJavaScriptDialogState;
use super::page_target_host::PageTargetHost;
use crate::domains::audits_output_state::TargetAuditsSessionState;
@@ -200,12 +199,8 @@ impl PageTargetHost {
|| self.fetch_owner.config_snapshot() != super::fetch::TargetFetchConfig::default()
}
- pub(crate) fn clear_session_scoped_state_fields(
- &mut self,
- preserve_auxiliary_devtools_sessions: bool,
- ) {
- self.devtools_sessions
- .reset(preserve_auxiliary_devtools_sessions);
+ pub(crate) fn clear_primary_session_scoped_state_fields(&mut self) {
+ *self.devtools_sessions.primary_mut() = Default::default();
self.runtime_slot.disable_primary_network_events();
self.network_policy.clear_session_scoped_state();
self.http_proxy_override = None;
@@ -221,13 +216,9 @@ impl PageTargetHost {
self.focus_emulation_enabled = false;
self.script_execution_disabled = false;
self.css_enabled = false;
- self.fetch_owner = TargetFetchOwner::default();
- self.runtime_slot
- .clear_session_scoped_network_observation_artifacts();
+ self.fetch_owner.remove_fetch_session(None);
self.runtime_slot
- .request_id_allocator()
- .reset_fetch_navigation_request_counter();
- self.owner_state.clear_observable_output_state();
+ .remove_network_session_observation_cursor(None);
}
}
diff --git a/moli-protocol/src/conn/state/shared_worker_target.rs b/moli-protocol/src/conn/state/shared_worker_target.rs
index 2141d067c..c5e7d8d71 100644
--- a/moli-protocol/src/conn/state/shared_worker_target.rs
+++ b/moli-protocol/src/conn/state/shared_worker_target.rs
@@ -681,6 +681,19 @@ impl SharedWorkerTargetState {
)
}
+ pub(crate) fn renderer_command_descriptor_for_renderer_if_attachment_matches(
+ &self,
+ owner_session_id: &str,
+ renderer_call_id: moli_page_types::RendererCallId,
+ dispatched_attachment_id: Option<moli_page_types::RendererAgentAttachmentId>,
+ ) -> Option<RendererCommandDescriptor> {
+ self.session_state(owner_session_id)?
+ .renderer_command_descriptor_for_renderer_if_attachment_matches(
+ renderer_call_id,
+ dispatched_attachment_id,
+ )
+ }
+
pub(crate) fn remove_pending_inspector_await(
&mut self,
owner_session_id: &str,
diff --git a/moli-protocol/src/conn/target/mod.rs b/moli-protocol/src/conn/target/mod.rs
index f697ad9f5..ca21c295a 100644
--- a/moli-protocol/src/conn/target/mod.rs
+++ b/moli-protocol/src/conn/target/mod.rs
@@ -27,3 +27,4 @@ pub(crate) use transaction::{
TargetBindingCleanupAction, TargetBindingCleanupPlan, TargetClosureCleanupPlan,
TargetEventPlan, TargetSessionDetachCleanupPlan,
};
+pub(crate) use worker_session::TargetWorkerProtocolAttachmentIdentity;
diff --git a/moli-protocol/src/conn/target/session_binding.rs b/moli-protocol/src/conn/target/session_binding.rs
index 4e476820a..180cf94cd 100644
--- a/moli-protocol/src/conn/target/session_binding.rs
+++ b/moli-protocol/src/conn/target/session_binding.rs
@@ -11,7 +11,7 @@ impl CdpConnection {
pub(crate) async fn clear_target_session_overrides_async(
&mut self,
session_id: &str,
- ) -> Result<(), String> {
+ ) -> anyhow::Result<()> {
let browser_identity_changed = match self.browser_context.as_mut() {
Some(browser_context) => {
browser_context
@@ -24,16 +24,17 @@ impl CdpConnection {
return Ok(());
}
- let Some(pending) =
- self.start_rebuild_resource_runtime_for_session_owner(Some(session_id))?
+ let Some(pending) = self
+ .start_rebuild_resource_runtime_for_session_owner(Some(session_id))
+ .map_err(anyhow::Error::msg)?
else {
return Ok(());
};
- let completion = pending
- .wait()
- .await
- .map_err(|error| format!("failed to restore detached session user agent: {error}"))?;
+ let completion = pending.wait().await.map_err(|error| {
+ anyhow::anyhow!("failed to restore detached session user agent: {error}")
+ })?;
self.finish_rebuild_resource_runtime_for_session_owner(Some(session_id), completion)
+ .map_err(anyhow::Error::msg)
}
pub(crate) fn is_browser_session_id(&self, session_id: Option<&str>) -> bool {
@@ -674,8 +675,26 @@ impl CdpConnection {
}
if let Some(cleanup_plan) = rollback_plan.cleanup_plan() {
- self.execute_target_binding_cleanup_without_event_async(cleanup_plan)
- .await;
+ if let Err(error) = self
+ .remove_document_start_scripts_for_detached_session_async(cleanup_plan.session_id())
+ .await
+ {
+ tracing::warn!(
+ session_id = rollback_plan.session_id(),
+ %error,
+ "failed to remove target scripts during attach rollback"
+ );
+ }
+ if let Err(error) = self
+ .execute_target_binding_cleanup_without_event_async(cleanup_plan)
+ .await
+ {
+ tracing::warn!(
+ session_id = rollback_plan.session_id(),
+ %error,
+ "failed to clean prepared target binding during attach rollback"
+ );
+ }
}
self.rollback_attached_session_without_event(rollback_plan.session_id())
}
@@ -700,25 +719,18 @@ impl CdpConnection {
pub(crate) async fn execute_target_binding_cleanup_without_event_async(
&mut self,
cleanup_plan: &TargetBindingCleanupPlan,
- ) {
- self.remove_document_start_scripts_for_detached_session_best_effort_async(
- cleanup_plan.session_id(),
- )
- .await;
+ ) -> anyhow::Result<()> {
match cleanup_plan.action() {
TargetBindingCleanupAction::PageTarget {
target_id,
session_key: moli_page_types::DevToolsSessionKey::Primary,
} => {
if let Some(bc) = self.browser_context.as_mut() {
- if bc.is_active_target(target_id) {
- let _ = bc
- .clear_active_target_primary_auto_attached_session_async()
- .await;
- } else {
- let _ = bc.clear_background_target_primary_auto_attached_session(
- cleanup_plan.session_id(),
- );
+ let disposed = bc
+ .dispose_primary_page_session_async(target_id, cleanup_plan.session_id())
+ .await?;
+ if !disposed {
+ anyhow::bail!("InvalidSessionId");
}
}
}
@@ -750,27 +762,28 @@ impl CdpConnection {
}
TargetBindingCleanupAction::None => {}
}
+ Ok(())
}
pub(crate) async fn execute_target_binding_cleanup_for_session_without_event_async(
&mut self,
session_id: &str,
- ) -> bool {
+ ) -> anyhow::Result<bool> {
let Some(route) = self.session_route(Some(session_id)) else {
- return false;
+ return Ok(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
+ .await?;
+ Ok(true)
}
pub(crate) async fn detach_session_with_binding_cleanup_event_plan_async(
&mut self,
cleanup_plan: TargetSessionDetachCleanupPlan,
- ) -> TargetEventPlan {
+ ) -> anyhow::Result<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);
@@ -781,21 +794,24 @@ impl CdpConnection {
.attached_session_owner_session_id(&session_id)
})
.map(str::to_owned);
- let _ = self
+ let cleaned = self
.execute_target_binding_cleanup_for_session_without_event_async(&session_id)
- .await;
- self.detach_known_session_event_plan(
+ .await?;
+ if !cleaned {
+ anyhow::bail!("InvalidSessionId");
+ }
+ Ok(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 {
+ ) -> anyhow::Result<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);
@@ -806,15 +822,20 @@ impl CdpConnection {
.attached_session_owner_session_id(&session_id)
})
.map(str::to_owned);
- let _ = self
+ let cleaned = 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,
+ .await?;
+ if !cleaned {
+ anyhow::bail!("InvalidSessionId");
+ }
+ Ok(
+ self.detach_known_session_event_plan_with_attached_state_delta(
+ &target_id,
+ &session_id,
+ reason.as_deref(),
+ parent_session_id.as_deref(),
+ false,
+ ),
)
}
@@ -838,245 +859,6 @@ impl CdpConnection {
)
}
- 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.remove_document_start_scripts_for_detached_session_best_effort_async(&session_id)
- .await;
- 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);
- self.remove_document_start_scripts_for_detached_session_best_effort_async(&session_id)
- .await;
- 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()
- .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);
diff --git a/moli-protocol/src/conn/target/worker_session.rs b/moli-protocol/src/conn/target/worker_session.rs
index 942710e4d..ccfdb460d 100644
--- a/moli-protocol/src/conn/target/worker_session.rs
+++ b/moli-protocol/src/conn/target/worker_session.rs
@@ -1,11 +1,134 @@
use crate::conn::{
- CdpConnection, DedicatedWorkerTargetState, ServiceWorkerTargetState, SharedWorkerTargetState,
- TargetSharedWorkerProtocolAttachmentIdentity,
+ CdpConnection, DedicatedWorkerTargetState, RendererPageResidenceIdentity,
+ ServiceWorkerTargetState, SharedWorkerTargetState,
+ TargetServiceWorkerProtocolAttachmentIdentity, TargetSharedWorkerProtocolAttachmentIdentity,
};
+use moli_core::RendererOutputResidenceIdentity;
use super::CdpSessionRoute;
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum TargetWorkerProtocolAttachmentIdentity {
+ SharedOrDedicated(TargetSharedWorkerProtocolAttachmentIdentity),
+ Service(TargetServiceWorkerProtocolAttachmentIdentity),
+}
+
+impl TargetWorkerProtocolAttachmentIdentity {
+ pub(crate) fn session_id(&self) -> &str {
+ match self {
+ Self::SharedOrDedicated(identity) => identity.session_id(),
+ Self::Service(identity) => identity.session_id(),
+ }
+ }
+
+ pub(crate) fn target_id(&self) -> &str {
+ match self {
+ Self::SharedOrDedicated(identity) => identity.target_id(),
+ Self::Service(identity) => identity.target_id(),
+ }
+ }
+
+ pub(crate) fn is_current(&self) -> bool {
+ match self {
+ Self::SharedOrDedicated(identity) => identity.is_current(),
+ Self::Service(identity) => identity.is_current(),
+ }
+ }
+}
+
impl CdpConnection {
+ /// Captures the exact live Worker attachment addressed by one renderer
+ /// output stream and DevTools session.
+ ///
+ /// A browser-context stream owner is intentionally insufficient here: a
+ /// context can contain many workers and Pages. Matching the concrete
+ /// residence prevents a late response from following the active Page or a
+ /// replacement Worker that happens to reuse connection-local ids.
+ pub(crate) fn worker_protocol_attachment_identity_for_renderer_output(
+ &self,
+ session_id: &str,
+ residence: RendererOutputResidenceIdentity,
+ ) -> Option<TargetWorkerProtocolAttachmentIdentity> {
+ match self.session_route(Some(session_id))? {
+ CdpSessionRoute::SharedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } => {
+ let RendererOutputResidenceIdentity::SharedWorker {
+ browser_context_runtime_id,
+ instance_id,
+ } = residence
+ else {
+ return None;
+ };
+ let browser_context = self.browser_context_by_id(&browser_context_id)?;
+ if !browser_context
+ .routes_renderer_browser_context_runtime(browser_context_runtime_id)
+ {
+ return None;
+ }
+ let target = browser_context.shared_worker_target(&target_id)?;
+ if target.renderer_instance_id.as_u64() != instance_id {
+ return None;
+ }
+ target
+ .protocol_attachment_identity(&browser_context_id, session_id)
+ .map(TargetWorkerProtocolAttachmentIdentity::SharedOrDedicated)
+ }
+ CdpSessionRoute::DedicatedWorkerTarget {
+ browser_context_id,
+ target_id,
+ } => {
+ let renderer_page = RendererPageResidenceIdentity::from_residence(residence)?;
+ let browser_context = self.browser_context_by_id(&browser_context_id)?;
+ let target = browser_context.dedicated_worker_target(&target_id)?;
+ let owner_target_id = target.owner_page.target_id()?;
+ let owner_target = browser_context.page_target(owner_target_id)?;
+ if !owner_target
+ .runtime_slot()
+ .routes_current_renderer_page_owner(
+ renderer_page,
+ target.owner_page.page_attachment_id(),
+ )
+ {
+ return None;
+ }
+ target
+ .protocol_attachment_identity(&browser_context_id, session_id)
+ .map(TargetWorkerProtocolAttachmentIdentity::SharedOrDedicated)
+ }
+ CdpSessionRoute::ServiceWorkerTarget {
+ browser_context_id,
+ target_id,
+ } => {
+ let RendererOutputResidenceIdentity::ServiceWorker {
+ browser_context_runtime_id,
+ version_id,
+ } = residence
+ else {
+ return None;
+ };
+ let browser_context = self.browser_context_by_id(&browser_context_id)?;
+ if !browser_context
+ .routes_renderer_browser_context_runtime(browser_context_runtime_id)
+ {
+ return None;
+ }
+ let target = browser_context.service_worker_target(&target_id)?;
+ if target.renderer_version_id != version_id {
+ return None;
+ }
+ target
+ .protocol_attachment_identity(&browser_context_id, session_id)
+ .map(TargetWorkerProtocolAttachmentIdentity::Service)
+ }
+ CdpSessionRoute::Browser
+ | CdpSessionRoute::BrowserContext { .. }
+ | CdpSessionRoute::TabTarget { .. }
+ | CdpSessionRoute::PageTarget { .. } => None,
+ }
+ }
+
pub(crate) fn shared_worker_target_for_session(
&self,
session_id: Option<&str>,
diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rs
index f294d35df..3ec9ef5aa 100644
--- a/moli-protocol/src/conn/tests/resource_runtime.rs
+++ b/moli-protocol/src/conn/tests/resource_runtime.rs
@@ -135,8 +135,7 @@ async fn buffered_navigation_for_inactive_session_carries_its_target_engine() {
let loaded =
commit_navigation_outcome_for_session_test(&mut conn, outcome, Some("SID-target")).await;
let target_engine = loaded
- .navigation_engine
- .as_ref()
+ .navigation_engine_replacement()
.expect("target-scoped buffered navigation must carry its engine to commit");
let target_renderer_owner = target_engine.renderer_owner_id_for_diagnostics();
diff --git a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs
index 9241454b8..1897f9e95 100644
--- a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs
+++ b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs
@@ -71,6 +71,7 @@ impl PreparedProtocolOutputs {
pub(in crate::domains::activity) fn from_renderer_observation(
conn: &mut CdpConnection,
owner: &CommandOwnerScope,
+ source_residence: moli_core::RendererOutputResidenceIdentity,
source_renderer_agent: moli_core::page::RendererDevToolsAgentToken,
observation: &RendererProtocolObservation,
) -> Self {
@@ -113,6 +114,30 @@ impl PreparedProtocolOutputs {
.append_to_output_sink(&mut prepared);
}
RendererProtocolObservation::RuntimeInspector(batch) => {
+ let worker_output = match source_residence {
+ moli_core::RendererOutputResidenceIdentity::SharedWorker { .. }
+ | moli_core::RendererOutputResidenceIdentity::ServiceWorker { .. } => true,
+ moli_core::RendererOutputResidenceIdentity::Page { .. } => batch
+ .session
+ .wire_session_id()
+ .and_then(|session_id| conn.session_route(Some(session_id)))
+ .is_some_and(|route| {
+ matches!(
+ route,
+ crate::conn::CdpSessionRoute::DedicatedWorkerTarget { .. }
+ )
+ }),
+ };
+ if worker_output {
+ crate::domains::runtime::RuntimePreparedOutputs::
+ from_worker_renderer_runtime_inspector_message_batch(
+ conn,
+ source_residence,
+ batch,
+ )
+ .append_to_output_sink(&mut prepared);
+ return prepared;
+ }
let source_batches = vec![batch.clone()];
let batches = conn.route_current_renderer_inspector_output_for_owner(
owner,
diff --git a/moli-protocol/src/domains/activity/output_ingress/renderer.rs b/moli-protocol/src/domains/activity/output_ingress/renderer.rs
index 3e0d2768c..7949a8e18 100644
--- a/moli-protocol/src/domains/activity/output_ingress/renderer.rs
+++ b/moli-protocol/src/domains/activity/output_ingress/renderer.rs
@@ -232,6 +232,7 @@ async fn project_renderer_output_records_for_route(
PreparedProtocolOutputs::from_renderer_observation(
conn,
owner,
+ cursor.stream().residence(),
cursor.stream().renderer_agent(),
&observation,
)
diff --git a/moli-protocol/src/domains/activity/publication_route.rs b/moli-protocol/src/domains/activity/publication_route.rs
index d271f5db0..534233e16 100644
--- a/moli-protocol/src/domains/activity/publication_route.rs
+++ b/moli-protocol/src/domains/activity/publication_route.rs
@@ -46,7 +46,7 @@ pub(crate) enum RendererPublicationRoute {
/// are retained by the target; every other historical record is stale.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RendererPublicationProjection {
- CurrentPage,
+ CurrentOwner,
RetiringNetworkOnly,
}
@@ -118,18 +118,19 @@ impl RendererPublicationOwner {
pub(crate) fn resolve(&self, conn: &CdpConnection) -> Option<RendererPublicationRoute> {
match self {
Self::BrowserContext { browser_context_id } => {
- let browser_context = conn
+ if !conn
.browser_context
.iter()
.chain(conn.inactive_browser_contexts.iter())
- .find(|browser_context| browser_context.id == *browser_context_id)?;
+ .any(|browser_context| browser_context.id == *browser_context_id)
+ {
+ return None;
+ }
Some(RendererPublicationRoute::UnattachedOwner {
- owner_route: CdpSessionRoute::PageTarget {
- browser_context_id: browser_context.id.clone(),
- target_id: browser_context.active_target_id()?.to_owned(),
- session_key: moli_page_types::DevToolsSessionKey::Primary,
+ owner_route: CdpSessionRoute::BrowserContext {
+ browser_context_id: browser_context_id.clone(),
},
- projection: RendererPublicationProjection::CurrentPage,
+ projection: RendererPublicationProjection::CurrentOwner,
})
}
Self::PageTarget {
@@ -149,7 +150,7 @@ impl RendererPublicationOwner {
*renderer_page,
page_owner.page_attachment_id(),
) {
- Some(RendererPublicationProjection::CurrentPage)
+ Some(RendererPublicationProjection::CurrentOwner)
} else if runtime_slot.routes_retiring_renderer_page_owner(
*renderer_page,
page_owner.page_attachment_id(),
diff --git a/moli-protocol/src/domains/activity/runtime_command_barrier.rs b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
index 2e4079f40..921b16c71 100644
--- a/moli-protocol/src/domains/activity/runtime_command_barrier.rs
+++ b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
@@ -480,7 +480,8 @@ impl RuntimeCommandOutputBarriers {
#[cfg(test)]
mod tests {
use moli_core::{
- RendererOwnerAction, RendererProtocolObservation, RendererRuntimeCommandCausalIdentity,
+ RendererOutputResidenceIdentity, RendererOwnerAction, RendererProtocolObservation,
+ RendererRuntimeCommandCausalIdentity,
page::{
DevToolsSessionKey, RendererDocumentLifecycleIdentity,
RendererDocumentSourcedSameDocumentNavigation,
@@ -730,12 +731,16 @@ mod tests {
let mut barriers = RuntimeCommandOutputBarriers::default();
let permit = admit_registered_command(&mut conn, &mut barriers, 2);
let cause = renderer_cause_for_permit(&conn, &permit);
- let agent_token = conn
+ let page = conn
.runtime_session_owner_slot(Some(SESSION_ID))
.expect("loaded Page should retain its runtime slot")
.loaded_page()
- .expect("runtime slot should retain the loaded Page")
- .renderer_devtools_agent_token();
+ .expect("runtime slot should retain the loaded Page");
+ let agent_token = page.renderer_devtools_agent_token();
+ let source_residence = RendererOutputResidenceIdentity::Page {
+ owner_local_host_id: page.renderer_owner_local_host_id(),
+ page_id: page.renderer_page_id(),
+ };
let observation = RendererProtocolObservation::RuntimeInspector(
RendererRuntimeInspectorMessageBatch::new_after_command_response(
agent_token,
@@ -756,6 +761,7 @@ mod tests {
super::super::output_ingress::PreparedProtocolOutputs::from_renderer_observation(
&mut conn,
&crate::conn::CommandOwnerScope::for_session(SESSION_ID),
+ source_residence,
agent_token,
&observation,
);
diff --git a/moli-protocol/src/domains/activity/scheduler_work.rs b/moli-protocol/src/domains/activity/scheduler_work.rs
index f37fb688c..9d2560ac9 100644
--- a/moli-protocol/src/domains/activity/scheduler_work.rs
+++ b/moli-protocol/src/domains/activity/scheduler_work.rs
@@ -125,7 +125,6 @@ impl fmt::Debug for ProtocolSchedulerWork {
}
ProtocolSchedulerWorkPayload::PageTargetTerminationOwnerAction(action) => {
debug
- .field("action", &action.kind())
.field("session_id", &action.owner_scope().session_id())
.field("target_id", &action.target_id());
}
diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rs
index 47797d2db..681ed1e4c 100644
--- a/moli-protocol/src/domains/emulation.rs
+++ b/moli-protocol/src/domains/emulation.rs
@@ -2573,7 +2573,7 @@ fn loaded_page_mut_for_target_configuration<'a>(
pub(crate) async fn clear_emulated_media_for_detached_session_async(
conn: &mut CdpConnection,
session_id: &str,
-) -> Result<(), String> {
+) -> anyhow::Result<()> {
// Chromium's InspectorEmulationAgent::disable clears media overrides even
// though the resulting settings are observable by every session on the
// target. Match that contract when detach preserves the loaded page.
@@ -2597,7 +2597,9 @@ pub(crate) async fn clear_emulated_media_for_detached_session_async(
};
page.set_emulated_media_async(&page_overrides)
.await
- .map_err(|error| format!("failed to clear detached session emulated media: {error}"))
+ .map_err(|error| {
+ anyhow::anyhow!("failed to clear detached session emulated media: {error}")
+ })
}
fn single_pending_emulation_dispatch(
diff --git a/moli-protocol/src/domains/network/agent.rs b/moli-protocol/src/domains/network/agent.rs
index 5ad463284..b45769fa0 100644
--- a/moli-protocol/src/domains/network/agent.rs
+++ b/moli-protocol/src/domains/network/agent.rs
@@ -860,10 +860,6 @@ impl TargetNetworkAgentState {
.request_id_for_websocket_socket(socket_id, request_id_allocator)
}
- pub(crate) fn clear_session_scoped_observation_artifacts(&mut self) {
- self.artifacts.clear_session_scoped_observation_artifacts();
- }
-
pub(crate) fn reset_all_target_scoped_artifacts(&mut self) {
self.artifacts.reset_all_target_scoped_artifacts();
}
@@ -1549,12 +1545,6 @@ impl TargetNetworkArtifacts {
.set_request_id_for_socket_if_absent(socket_id, request_id);
}
- pub(crate) fn clear_session_scoped_observation_artifacts(&mut self) {
- self.body_artifacts.clear_session_scoped();
- self.subresource_network_artifacts.clear_request_ids();
- self.websocket_network_artifacts.clear_all();
- }
-
pub(crate) fn reset_all_target_scoped_artifacts(&mut self) {
self.request_id_allocator.reset();
self.body_artifacts.reset_all();
@@ -2282,7 +2272,7 @@ mod tests {
}
#[test]
- fn body_artifacts_clear_response_bodies_and_io_streams_together() {
+ fn target_artifact_reset_clears_response_bodies_and_io_streams_together() {
let mut agent = TargetNetworkAgentState::default();
agent.record_captured_response_body("REQ-1".to_owned(), "response body".to_owned(), [None]);
@@ -2290,17 +2280,8 @@ mod tests {
assert!(agent.has_captured_response_body("REQ-1"));
assert!(!agent.io_streams_empty());
- agent.clear_session_scoped_observation_artifacts();
- assert!(!agent.has_captured_response_body("REQ-1"));
- assert!(agent.io_streams_empty());
-
- agent.record_captured_response_body("REQ-2".to_owned(), "response body".to_owned(), [None]);
- agent.insert_io_stream("STREAM-2".to_owned(), b"stream body".to_vec(), 0);
- assert!(agent.has_captured_response_body("REQ-2"));
- assert!(!agent.io_streams_empty());
-
agent.reset_all_target_scoped_artifacts();
- assert!(!agent.has_captured_response_body("REQ-2"));
+ assert!(!agent.has_captured_response_body("REQ-1"));
assert!(agent.io_streams_empty());
}
diff --git a/moli-protocol/src/domains/network/main_document_progress/mod.rs b/moli-protocol/src/domains/network/main_document_progress/mod.rs
index 8f1b15640..bbfb41049 100644
--- a/moli-protocol/src/domains/network/main_document_progress/mod.rs
+++ b/moli-protocol/src/domains/network/main_document_progress/mod.rs
@@ -4,11 +4,11 @@ mod gate;
mod tests;
use moli_cookie_jar::{StoredCookieQueryReport, StoredCookieSetReport};
+use moli_core::RendererOutputFence;
use moli_core::page::{
NavigationRedirect, Page, RendererMainDocumentCommit, RendererPageCreationArtifacts,
RendererPendingDownloadActivation, RendererRuntimeRealmInfo, SubresourceRequestInitiatorType,
};
-use moli_core::{RendererOutputFence, runtime::NavigationEngine};
use moli_fetch::{
NegotiatedHttpVersion, NetworkExchangeObservation, NetworkObservationJournal, RedirectInfo,
StreamingRawResponse,
@@ -19,7 +19,7 @@ use url::Url;
use crate::conn::{
BackgroundEventSender, BackgroundProtocolEvent, CapturedBody, CdpConnection,
CompletedDownloadBodyArtifact, DownloadNavigation, LoadedNavigation, NavigationDispatchState,
- NavigationLoadOutcome, ResponseCommitReady, TargetRuntimeSlot,
+ NavigationEngineHandoff, NavigationLoadOutcome, ResponseCommitReady, TargetRuntimeSlot,
};
#[cfg(test)]
@@ -42,7 +42,7 @@ pub(crate) struct MaterializedLoadedDocumentProgress {
pub(crate) renderer_output_predecessor: Option<RendererOutputFence>,
pub(crate) main_document_commit: Option<Arc<RendererMainDocumentCommit>>,
pub(crate) progress_gate: MainDocumentProgressGate,
- pub(crate) navigation_engine: Option<NavigationEngine>,
+ pub(crate) navigation_engine_handoff: NavigationEngineHandoff,
pub(crate) network_error_page: Option<crate::conn::NetworkErrorPageNavigation>,
}
@@ -309,7 +309,7 @@ pub(crate) fn materialize_loaded_navigation_progress(
renderer_output_predecessor,
main_document_commit,
document_progress_transfer,
- navigation_engine,
+ navigation_engine_handoff,
network_error_page,
..
} = navigation;
@@ -330,7 +330,7 @@ pub(crate) fn materialize_loaded_navigation_progress(
renderer_output_predecessor,
main_document_commit,
progress_gate,
- navigation_engine,
+ navigation_engine_handoff,
network_error_page,
}
}
diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rs
index dadc1082e..161203618 100644
--- a/moli-protocol/src/domains/page.rs
+++ b/moli-protocol/src/domains/page.rs
@@ -121,8 +121,7 @@ use prepared_navigation::{
PagePreparedSameDocumentNavigation, PagePreparedTopLevelLocationNavigation,
};
pub(crate) use termination::{
- PageTargetTerminationKind, PageTargetTerminationOwnerAction,
- complete_page_target_termination_owner_action_async,
+ PageTargetTerminationOwnerAction, complete_page_target_termination_owner_action_async,
fail_pending_fetch_state_background_events_async, take_pending_fetch_state,
};
diff --git a/moli-protocol/src/domains/page/navigation.rs b/moli-protocol/src/domains/page/navigation.rs
index b2af61e1f..fa51b11d7 100644
--- a/moli-protocol/src/domains/page/navigation.rs
+++ b/moli-protocol/src/domains/page/navigation.rs
@@ -23,9 +23,10 @@ use url::Url;
use crate::conn::{
BackgroundNavigationLoadJob, BackgroundProtocolEvent, CapturedBody, CdpConnection,
CdpSessionRoute, Cmd, CommandDispatchContext, CommandOwnerScope, DocumentNavigationToken,
- FetchRequestStage, NavigationDispatchState, NavigationLoadOutcome, NavigationRequestLoadPolicy,
- NavigationResultProjection, NavigationSourceDocumentSecurityContext, PendingFetchNavigation,
- ResponseStageUrlMatchPolicy, monotonic_timestamp_seconds,
+ FetchRequestStage, NavigationDispatchState, NavigationEngineHandoff, NavigationLoadOutcome,
+ NavigationRequestLoadPolicy, NavigationResultProjection,
+ NavigationSourceDocumentSecurityContext, PendingFetchNavigation, ResponseStageUrlMatchPolicy,
+ monotonic_timestamp_seconds,
};
use moli_cookie_jar::{NetworkCookieRequestContext, StoredCookieQueryReport};
@@ -398,7 +399,7 @@ pub(crate) struct MaterializedNavigationCompletion {
token: DocumentNavigationToken,
state: NavigationDispatchState,
navigation: network::MaterializedNavigationLoadOutcome,
- engine: Option<NavigationEngine>,
+ engine_handoff: NavigationEngineHandoff,
}
impl MaterializedNavigationCompletion {
@@ -411,12 +412,12 @@ impl MaterializedNavigationCompletion {
token,
state,
navigation,
- engine: None,
+ engine_handoff: NavigationEngineHandoff::retained_by_owner(),
}
}
- pub(crate) fn with_navigation_engine(mut self, engine: NavigationEngine) -> Self {
- self.engine = Some(engine);
+ pub(crate) fn with_navigation_engine_replacement(mut self, engine: NavigationEngine) -> Self {
+ self.engine_handoff = NavigationEngineHandoff::replacement(engine);
self
}
@@ -446,9 +447,9 @@ impl MaterializedNavigationCompletion {
DocumentNavigationToken,
NavigationDispatchState,
network::MaterializedNavigationLoadOutcome,
- Option<NavigationEngine>,
+ NavigationEngineHandoff,
) {
- (self.token, self.state, self.navigation, self.engine)
+ (self.token, self.state, self.navigation, self.engine_handoff)
}
}
@@ -597,15 +598,16 @@ impl BackgroundNavigationLifecycleCompletion {
}
/// Materialize the background navigation outcome into a queued
- /// `MaterializedNavigationCompletion`. `retain_engine` should be `false`
+ /// `MaterializedNavigationCompletion`. `replace_owner_engine` should be
+ /// `false`
/// when the completion's token is no longer current — stale completions
/// still flow into the materialized queue so the drain can emit a
/// terminal abort response for any outstanding `navigate_id`, but the
/// stale background engine must not keep a renderer owner alive.
- pub(crate) fn materialize_with_engine_retention(
+ pub(crate) fn materialize_with_engine_replacement(
self,
conn: &mut CdpConnection,
- retain_engine: bool,
+ replace_owner_engine: bool,
) -> MaterializedNavigationCompletion {
let Self {
token,
@@ -614,7 +616,7 @@ impl BackgroundNavigationLifecycleCompletion {
navigation,
ready_at: _,
} = self;
- let should_retain_engine = retain_engine
+ let should_replace_owner_engine = replace_owner_engine
&& matches!(
navigation,
Ok(NavigationLoadOutcome::ResponseCommitReady(_)
@@ -622,8 +624,8 @@ impl BackgroundNavigationLifecycleCompletion {
);
let navigation = network::materialize_navigation_load_result(conn, &state, navigation);
let completion = MaterializedNavigationCompletion::new(token, state, navigation);
- if should_retain_engine {
- completion.with_navigation_engine(engine)
+ if should_replace_owner_engine {
+ completion.with_navigation_engine_replacement(engine)
} else {
completion
}
@@ -3172,15 +3174,15 @@ pub(super) async fn complete_pending_navigate_load_command(
state.owner.session_owner_route(),
&token,
);
- let should_retain_engine = is_current
+ let should_replace_owner_engine = is_current
&& matches!(
navigation,
Ok(NavigationLoadOutcome::ResponseCommitReady(_) | NavigationLoadOutcome::Loaded(_))
);
let navigation = network::materialize_navigation_load_result(conn, &state, navigation);
let completion = MaterializedNavigationCompletion::new(token, state, navigation);
- let completion = if should_retain_engine {
- completion.with_navigation_engine(engine)
+ let completion = if should_replace_owner_engine {
+ completion.with_navigation_engine_replacement(engine)
} else {
completion
};
diff --git a/moli-protocol/src/domains/page/navigation_commit.rs b/moli-protocol/src/domains/page/navigation_commit.rs
index d9d605769..51eb78b6b 100644
--- a/moli-protocol/src/domains/page/navigation_commit.rs
+++ b/moli-protocol/src/domains/page/navigation_commit.rs
@@ -42,7 +42,7 @@ pub(super) async fn commit_loaded_navigation_async(
renderer_output_predecessor,
main_document_commit,
progress_gate,
- navigation_engine,
+ navigation_engine_handoff,
network_error_page,
} = navigation;
let target_url = network_error_page
@@ -135,7 +135,7 @@ pub(super) async fn commit_loaded_navigation_async(
navigation_activity.defer_initial_renderer_document_lifecycle_events_until_load_boundary(
deferred_initial_renderer_document_lifecycle_events,
);
- if let Some(engine) = navigation_engine {
+ if let Some(engine) = navigation_engine_handoff.into_replacement() {
conn.adopt_loaded_navigation_engine_for_owner(&navigation_activity.state().owner, engine);
}
diff --git a/moli-protocol/src/domains/page/termination.rs b/moli-protocol/src/domains/page/termination.rs
index 684a35789..03a5303c2 100644
--- a/moli-protocol/src/domains/page/termination.rs
+++ b/moli-protocol/src/domains/page/termination.rs
@@ -10,29 +10,17 @@ use moli_core::RendererOutputFence;
use super::{PageCommandTaskStep, complete_materialized_navigation_into_buffer_async};
use crate::domains::command_output::{CommandOutputBuffer, CommandOutputPlan};
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum PageTargetTerminationKind {
- PageClose,
- TargetClose,
-}
-
#[derive(Debug)]
pub(crate) struct PageTargetTerminationOwnerAction {
owner_scope: CommandOwnerScope,
target_id: String,
- kind: PageTargetTerminationKind,
}
impl PageTargetTerminationOwnerAction {
- pub(crate) fn new(
- owner_scope: CommandOwnerScope,
- target_id: String,
- kind: PageTargetTerminationKind,
- ) -> Self {
+ pub(crate) fn new(owner_scope: CommandOwnerScope, target_id: String) -> Self {
Self {
owner_scope,
target_id,
- kind,
}
}
@@ -44,12 +32,8 @@ impl PageTargetTerminationOwnerAction {
&self.target_id
}
- pub(crate) fn kind(&self) -> PageTargetTerminationKind {
- self.kind
- }
-
- fn into_parts(self) -> (CommandOwnerScope, String, PageTargetTerminationKind) {
- (self.owner_scope, self.target_id, self.kind)
+ fn into_parts(self) -> (CommandOwnerScope, String) {
+ (self.owner_scope, self.target_id)
}
}
@@ -691,7 +675,6 @@ pub(super) async fn complete_close_command_dispatch(
conn.publish_page_target_termination_owner_action(PageTargetTerminationOwnerAction::new(
owner.clone(),
target_id,
- PageTargetTerminationKind::PageClose,
));
complete_success_with_background_events(out)
}
@@ -700,7 +683,7 @@ pub(crate) async fn complete_page_target_termination_owner_action_async(
conn: &mut CdpConnection,
action: PageTargetTerminationOwnerAction,
) -> crate::conn::CdpTurnOutcome {
- let (owner_scope, expected_target_id, kind) = action.into_parts();
+ let (owner_scope, expected_target_id) = action.into_parts();
let mut out = Vec::new();
let current_target_id = conn
.target_owner_identity_for_route(
@@ -715,33 +698,20 @@ pub(crate) async fn complete_page_target_termination_owner_action_async(
);
}
let target_host_closure = conn.prepare_target_host_closure(&expected_target_id);
- let closed = match kind {
- PageTargetTerminationKind::PageClose => {
- conn.close_page_target_for_route_async(
- owner_scope.session_id(),
- owner_scope.session_owner_route(),
- )
+ let is_active_target = conn
+ .browser_context
+ .as_ref()
+ .is_some_and(|browser_context| browser_context.is_active_target(&expected_target_id));
+ let closed = if is_active_target {
+ conn.close_active_page_target_for_target_close_async(&mut out, "Target closed")
.await
- }
- PageTargetTerminationKind::TargetClose => {
- let is_active_target = conn
- .browser_context
- .as_ref()
- .is_some_and(|browser_context| {
- browser_context.is_active_target(&expected_target_id)
- });
- if is_active_target {
- conn.close_active_page_target_for_target_close_async(&mut out)
- .await
- } else {
- conn.close_background_page_target_for_target_close_async(
- &expected_target_id,
- &mut out,
- "Target closed",
- )
- .await
- }
- }
+ } else {
+ conn.close_background_page_target_for_target_close_async(
+ &expected_target_id,
+ &mut out,
+ "Target closed",
+ )
+ .await
};
let Some(closed) = closed else {
return crate::conn::CdpTurnOutcome::new_with_protocol_events(
diff --git a/moli-protocol/src/domains/page/tests/document_content.rs b/moli-protocol/src/domains/page/tests/document_content.rs
index 336e24906..731014973 100644
--- a/moli-protocol/src/domains/page/tests/document_content.rs
+++ b/moli-protocol/src/domains/page/tests/document_content.rs
@@ -14,7 +14,7 @@ async fn install_document_content_test_page(ctx: &mut TestContext, url: &str) {
.load_navigation_via_runtime_for_session_owner_async(Some("SID-1"), url)
.await
.expect("document-content test page should load");
- let navigation_engine = navigation.navigation_engine.take();
+ let navigation_engine = navigation.take_navigation_engine_replacement();
let artifacts = navigation.page_creation_artifacts;
{
let browser_context = ctx.conn.browser_context.as_mut().expect("browser context");
diff --git a/moli-protocol/src/domains/page/tests/lifecycle.rs b/moli-protocol/src/domains/page/tests/lifecycle.rs
index 283316ab3..068ad3c27 100644
--- a/moli-protocol/src/domains/page/tests/lifecycle.rs
+++ b/moli-protocol/src/domains/page/tests/lifecycle.rs
@@ -276,7 +276,7 @@ async fn install_runtime_document_replacement_test_page(ctx: &mut TestContext) -
.load_navigation_via_runtime_async("data:text/html,<body>initial</body>")
.await
.expect("runtime replacement fixture page should load");
- let navigation_engine = navigation.navigation_engine.take();
+ let navigation_engine = navigation.take_navigation_engine_replacement();
let artifacts = navigation.page_creation_artifacts;
ctx.conn
.browser_context
@@ -829,7 +829,7 @@ async fn set_lifecycle_events_enabled_replays_loaded_page_events() {
.load_navigation_via_runtime_async("data:text/html,<body>hello</body>")
.await
.expect("page should load");
- let navigation_engine = navigation.navigation_engine.take();
+ let navigation_engine = navigation.take_navigation_engine_replacement();
let dom_timestamp = navigation
.page_creation_artifacts
.lifecycle_snapshot
@@ -911,7 +911,7 @@ async fn set_lifecycle_events_enabled_replays_only_protocol_visible_load_state()
.load_navigation_via_runtime_async("data:text/html,<body>visible lifecycle</body>")
.await
.expect("page should load");
- let navigation_engine = navigation.navigation_engine.take();
+ let navigation_engine = navigation.take_navigation_engine_replacement();
let artifacts = navigation.page_creation_artifacts;
ctx.conn
.browser_context
@@ -1014,7 +1014,7 @@ async fn set_lifecycle_events_enabled_is_session_local_for_active_auxiliary_sess
.load_navigation_via_runtime_async("data:text/html,<body>active auxiliary lifecycle</body>")
.await
.expect("page should load");
- let navigation_engine = navigation.navigation_engine.take();
+ let navigation_engine = navigation.take_navigation_engine_replacement();
let artifacts = navigation.page_creation_artifacts;
let browser_context = ctx.conn.browser_context.as_mut().unwrap();
browser_context
diff --git a/moli-protocol/src/domains/profiler.rs b/moli-protocol/src/domains/profiler.rs
index abb66d2fb..8974807db 100644
--- a/moli-protocol/src/domains/profiler.rs
+++ b/moli-protocol/src/domains/profiler.rs
@@ -857,13 +857,20 @@ mod tests {
.await;
assert_eq!(aux_enable["result"], json!({}));
- ctx.conn
- .browser_context
- .as_mut()
- .expect("browser context")
- .clear_active_target_session_binding_and_scoped_state_async()
- .await
- .expect("target session detach should clear scoped state");
+ let detach = process_and_take_response(
+ &mut ctx,
+ json!({
+ "id": 53,
+ "method": "Target.detachFromTarget",
+ "params": {
+ "targetId": "TID-profiler",
+ "sessionId": "SID-profiler-old"
+ }
+ }),
+ 53,
+ )
+ .await;
+ assert_eq!(detach["result"], json!({}));
{
let browser_context = ctx.conn.browser_context.as_ref().expect("browser context");
@@ -872,8 +879,9 @@ mod tests {
browser_context
.active_page_target()
.devtools_sessions
- .attached_is_empty(),
- "detaching the primary target session must drop active auxiliary inspector session state"
+ .attached("SID-profiler-aux-old")
+ .is_some(),
+ "detaching the primary target session must preserve independent auxiliary sessions"
);
}
@@ -885,11 +893,11 @@ mod tests {
let start_without_enable = process_and_take_response(
&mut ctx,
json!({
- "id": 53,
+ "id": 54,
"sessionId": "SID-profiler-new",
"method": "Profiler.start"
}),
- 53,
+ 54,
)
.await;
assert_eq!(start_without_enable["error"]["code"], json!(-32000));
diff --git a/moli-protocol/src/domains/runtime/activity.rs b/moli-protocol/src/domains/runtime/activity.rs
index 0cafdb91d..e7101725d 100644
--- a/moli-protocol/src/domains/runtime/activity.rs
+++ b/moli-protocol/src/domains/runtime/activity.rs
@@ -64,6 +64,7 @@ struct RuntimeInspectorMessageBatch {
#[derive(Clone, Debug, PartialEq)]
enum RuntimeInspectorMessageAuthority {
CurrentPage(crate::conn::TargetPageProtocolAttachmentIdentity),
+ CurrentWorker(crate::conn::TargetWorkerProtocolAttachmentIdentity),
AuthorizedRetiredTerminal {
browser_context_id: String,
target_id: Option<String>,
@@ -75,6 +76,7 @@ impl RuntimeInspectorMessageAuthority {
fn session_id(&self) -> Option<&str> {
match self {
Self::CurrentPage(attachment) => attachment.session_id(),
+ Self::CurrentWorker(attachment) => Some(attachment.session_id()),
Self::AuthorizedRetiredTerminal { session_id, .. } => session_id.as_deref(),
}
}
@@ -84,6 +86,7 @@ impl RuntimeInspectorMessageAuthority {
Self::CurrentPage(attachment) => {
conn.target_page_protocol_attachment_identity_is_current(attachment)
}
+ Self::CurrentWorker(attachment) => attachment.is_current(),
Self::AuthorizedRetiredTerminal {
browser_context_id,
target_id,
@@ -108,6 +111,9 @@ impl RuntimeInspectorMessageAuthority {
Self::CurrentPage(attachment) => Some(
crate::conn::CommandOwnerScope::for_page_attachment(attachment),
),
+ Self::CurrentWorker(attachment) => {
+ Some(CommandOwnerScope::for_session(attachment.session_id()))
+ }
Self::AuthorizedRetiredTerminal { .. } => None,
}
}
@@ -347,6 +353,53 @@ impl RuntimePreparedOutputs {
outputs
}
+ pub(crate) fn from_worker_renderer_runtime_inspector_message_batch(
+ conn: &mut CdpConnection,
+ residence: moli_core::RendererOutputResidenceIdentity,
+ batch: &RendererRuntimeInspectorMessageBatch,
+ ) -> Self {
+ let Some(session_id) = batch.session.wire_session_id() else {
+ return Self::default();
+ };
+ let Some(attachment) =
+ conn.worker_protocol_attachment_identity_for_renderer_output(session_id, residence)
+ else {
+ return Self::default();
+ };
+ let mut renderer_messages = batch.messages.clone();
+ conn.restore_frontend_command_ids_in_worker_devtools_session_output(
+ session_id,
+ &mut renderer_messages,
+ );
+ if renderer_messages.is_empty() {
+ return Self::default();
+ }
+ let target_id = attachment.target_id().to_owned();
+ let prepared = RuntimeInspectorMessageBatch {
+ authority: RuntimeInspectorMessageAuthority::CurrentWorker(attachment),
+ messages: renderer_messages
+ .into_iter()
+ .map(|message| {
+ RuntimeInspectorMessage::from_renderer_message(message, Some(&target_id))
+ })
+ .collect(),
+ // Worker contexts never own Page/BiDi preload-channel listeners.
+ created_execution_context_ids: Vec::new(),
+ };
+ let mut outputs = Self::default();
+ match batch.command_response_order() {
+ RendererRuntimeInspectorMessageResponseOrder::BeforeCommandResponse => {
+ outputs.inspector_message_batches.push(prepared);
+ }
+ RendererRuntimeInspectorMessageResponseOrder::AfterCommandResponse => {
+ outputs
+ .post_response_inspector_message_batches
+ .push(prepared);
+ }
+ }
+ outputs
+ }
+
/// Preserves only terminal session responses from an attachment that was
/// current when the response lease was claimed but retired before its Page
/// journal crossed protocol ingress.
diff --git a/moli-protocol/src/domains/runtime/dispatcher.rs b/moli-protocol/src/domains/runtime/dispatcher.rs
index 52b89ab99..e4278a68c 100644
--- a/moli-protocol/src/domains/runtime/dispatcher.rs
+++ b/moli-protocol/src/domains/runtime/dispatcher.rs
@@ -424,6 +424,9 @@ impl RuntimeInspectorRoutedOutput {
push_runtime_protocol_event_or_background_event(plan, command_id, event);
}
plan.extend_post_response_events(self.post_response_events);
+ if let Some(predecessor) = self.renderer_output_predecessor {
+ plan.set_renderer_output_predecessor(predecessor);
+ }
}
}
@@ -1292,22 +1295,25 @@ fn start_heap_profiler_inspector_shared_worker_command_dispatch(
));
}
- let pending =
- match start_shared_worker_frontend_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
- Ok(pending) => pending,
- Err(message)
- if matches!(
- action,
- HeapProfilerAction::Enable | HeapProfilerAction::Disable
- ) && (message == "NoDocumentLoaded"
- || worker_runtime_is_unavailable(&message)) =>
- {
- return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
- }
- Err(message) => {
- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));
- }
- };
+ let pending = match start_shared_worker_frontend_inspector_dispatch(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
+ Ok(pending) => pending,
+ Err(message)
+ if matches!(
+ action,
+ HeapProfilerAction::Enable | HeapProfilerAction::Disable
+ ) && (message == "NoDocumentLoaded" || worker_runtime_is_unavailable(&message)) =>
+ {
+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
+ }
+ Err(message) => {
+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));
+ }
+ };
let object_group = heap_profiler_object_group_for_command_result(cmd, action);
RuntimeCommandTaskStep::Pending(Box::new(PendingRuntimeCommandDispatch {
@@ -1391,6 +1397,7 @@ fn start_profiler_inspector_shared_worker_command_dispatch(
conn,
cmd,
dispatch.into_inspector_json(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
) {
Ok(pending) => pending,
Err(message) => {
@@ -1513,21 +1520,25 @@ fn start_console_inspector_shared_worker_command_dispatch(
));
}
- let pending =
- match start_shared_worker_frontend_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
- Ok(pending) => pending,
- Err(message) if worker_runtime_is_unavailable(&message) => {
- if !apply_console_output_state_for_session(conn, cmd.session_id, action) {
- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(
- "UnknownSession".to_owned(),
- ));
- }
- return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
- }
- Err(message) => {
- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));
+ let pending = match start_shared_worker_frontend_inspector_dispatch(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
+ Ok(pending) => pending,
+ Err(message) if worker_runtime_is_unavailable(&message) => {
+ if !apply_console_output_state_for_session(conn, cmd.session_id, action) {
+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(
+ "UnknownSession".to_owned(),
+ ));
}
- };
+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
+ }
+ Err(message) => {
+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));
+ }
+ };
RuntimeCommandTaskStep::Pending(Box::new(PendingRuntimeCommandDispatch {
command_id: cmd.id,
@@ -1572,23 +1583,25 @@ fn start_console_inspector_service_worker_command_dispatch(
));
}
- let pending =
- match start_service_worker_frontend_inspector_dispatch(conn, cmd, cmd.json.to_owned()) {
- Ok(pending) => pending,
- Err(message) if message == "ServiceWorkerRuntimeUnavailable" => {
- if !apply_console_output_state_for_session(conn, cmd.session_id, action) {
- return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(
- "UnknownSession".to_owned(),
- ));
- }
- return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
- }
- Err(message) => {
+ let pending = match start_service_worker_frontend_inspector_dispatch(
+ conn,
+ cmd,
+ cmd.json.to_owned(),
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession),
+ ) {
+ Ok(pending) => pending,
+ Err(message) if message == "ServiceWorkerRuntimeUnavailable" => {
+ if !apply_console_output_state_for_session(conn, cmd.session_id, action) {
return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(
- message,
+ "UnknownSession".to_owned(),
));
}
- };
+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::success());
+ }
+ Err(message) => {
+ return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(message));
+ }
+ };
RuntimeCommandTaskStep::Pending(Box::new(PendingRuntimeCommandDispatch {
command_id: cmd.id,
@@ -1991,12 +2004,13 @@ fn start_shared_worker_frontend_inspector_dispatch(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
inspector_json: String,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
let descriptor = RendererCommandDescriptor::from_frontend_policy(
inspector_json,
cmd.renderer_policy(),
- RendererInspectorResponseDelivery::CommandReply,
+ response_delivery,
);
conn.start_shared_worker_runtime_protocol_message_for_session_with_deferred_response(
cmd.session_id,
@@ -2015,12 +2029,13 @@ fn start_service_worker_frontend_inspector_dispatch(
conn: &mut CdpConnection,
cmd: &Cmd<'_>,
inspector_json: String,
+ response_delivery: RendererInspectorResponseDelivery,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
if let Some(command_id) = cmd.id {
let descriptor = RendererCommandDescriptor::from_frontend_policy(
inspector_json,
cmd.renderer_policy(),
- RendererInspectorResponseDelivery::CommandReply,
+ response_delivery,
);
conn.start_service_worker_runtime_protocol_message_for_session_with_deferred_response(
cmd.session_id,
@@ -9206,7 +9221,17 @@ fn start_pending_shared_worker_runtime_inspector_command(
action.label(),
)
.map_err(|error| error.to_string())?;
- let pending = match start_shared_worker_frontend_inspector_dispatch(conn, cmd, inspector_json) {
+ let response_delivery = if await_promise {
+ RendererInspectorResponseDelivery::CommandReply
+ } else {
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession)
+ };
+ let pending = match start_shared_worker_frontend_inspector_dispatch(
+ conn,
+ cmd,
+ inspector_json,
+ response_delivery,
+ ) {
Ok(pending) => pending,
Err(message) => {
forget_pre_registered_runtime_await(conn, pre_registered_await, &owner_scope);
@@ -9268,8 +9293,17 @@ fn start_pending_service_worker_runtime_inspector_command(
action.label(),
)
.map_err(|error| error.to_string())?;
- let pending = match start_service_worker_frontend_inspector_dispatch(conn, cmd, inspector_json)
- {
+ let response_delivery = if await_promise {
+ RendererInspectorResponseDelivery::CommandReply
+ } else {
+ cmd.terminal_response_delivery(RendererInspectorResponseDelivery::DevToolsSession)
+ };
+ let pending = match start_service_worker_frontend_inspector_dispatch(
+ conn,
+ cmd,
+ inspector_json,
+ response_delivery,
+ ) {
Ok(pending) => pending,
Err(message) => {
forget_pre_registered_runtime_await(conn, pre_registered_await, &owner_scope);
@@ -9422,13 +9456,28 @@ async fn complete_pending_shared_worker_runtime_inspector_command(
binding_effect: Option<SharedWorkerRuntimeBindingEffect>,
timing_started: Option<std::time::Instant>,
) -> RuntimeCommandTaskStep {
- let (messages, mut renderer_response_rx) = match completed_inspector {
+ let (
+ messages,
+ mut renderer_response_rx,
+ response_delivery,
+ session_response_predecessor,
+ session_response_succeeded,
+ ) = match completed_inspector {
Ok(mut completed_protocol) => {
+ let response_delivery = completed_protocol.response_delivery();
+ let session_response_predecessor = completed_protocol.session_response_predecessor();
+ let session_response_succeeded = completed_protocol.session_response_succeeded();
let renderer_response_rx = completed_protocol.take_deferred_response_receiver();
match conn
.complete_shared_worker_runtime_protocol_message_for_session(completed_protocol)
{
- Ok(messages) => (messages, renderer_response_rx),
+ Ok(messages) => (
+ messages,
+ renderer_response_rx,
+ response_delivery,
+ session_response_predecessor,
+ session_response_succeeded,
+ ),
Err(message) => {
return complete_shared_worker_runtime_inspector_error(
conn, completed, message,
@@ -9453,6 +9502,9 @@ async fn complete_pending_shared_worker_runtime_inspector_command(
let mut plan = CommandOutputPlan::default();
let mut routed_output = RuntimeInspectorRoutedOutput::default();
+ if let Some(predecessor) = session_response_predecessor {
+ routed_output.set_renderer_output_predecessor(predecessor);
+ }
let mut saw_current_response = route_inspector_messages_into_routed_output(
conn,
messages,
@@ -9460,7 +9512,14 @@ async fn complete_pending_shared_worker_runtime_inspector_command(
&completed.owner_scope,
&mut routed_output,
);
- if !completed.wait_for_deferred_reply
+ if saw_current_response {
+ renderer_response_rx.take();
+ }
+ if response_delivery == RendererInspectorResponseDelivery::DevToolsSession {
+ renderer_response_rx.take();
+ }
+ if response_delivery == RendererInspectorResponseDelivery::CommandReply
+ && !completed.wait_for_deferred_reply
&& let Some(renderer_response_rx) = renderer_response_rx.take()
{
saw_current_response |= route_registered_runtime_response_receiver_into(
@@ -9472,7 +9531,8 @@ async fn complete_pending_shared_worker_runtime_inspector_command(
)
.await;
}
- if completed.wait_for_deferred_reply
+ if response_delivery == RendererInspectorResponseDelivery::CommandReply
+ && completed.wait_for_deferred_reply
&& (renderer_response_rx.is_some() || !saw_current_response)
&& completed.command_id.is_some()
{
@@ -9483,7 +9543,8 @@ async fn complete_pending_shared_worker_runtime_inspector_command(
renderer_response_rx,
);
}
- let succeeded = routed_output.command_response_succeeded(completed.command_id);
+ let succeeded = session_response_succeeded
+ .unwrap_or_else(|| routed_output.command_response_succeeded(completed.command_id));
apply_shared_worker_runtime_completion_projection(
conn,
completed.session_id(),
@@ -9494,10 +9555,17 @@ async fn complete_pending_shared_worker_runtime_inspector_command(
if let Some(console_action) = console_action_from_protocol_method(completed.action)
&& !apply_console_output_state_for_session(conn, completed.session_id(), console_action)
{
- return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(format!(
- "ConsoleCommandCompletionFailed: {}",
- completed.action
- )));
+ let message = format!("ConsoleCommandCompletionFailed: {}", completed.action);
+ if session_response_succeeded.is_some() {
+ tracing::warn!(
+ command_id = completed.command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "could not apply shared-worker projection after the terminal response was published"
+ );
+ } else {
+ return RuntimeCommandTaskStep::Complete(shared_worker_runtime_error_plan(message));
+ }
}
if let Some(effect) = binding_effect {
match apply_shared_worker_runtime_binding_effect_after_success(
@@ -9559,13 +9627,28 @@ async fn complete_pending_service_worker_runtime_inspector_command(
completed_inspector: Result<CompletedServiceWorkerRuntimeProtocolMessageDispatch, String>,
timing_started: Option<std::time::Instant>,
) -> RuntimeCommandTaskStep {
- let (messages, mut renderer_response_rx) = match completed_inspector {
+ let (
+ messages,
+ mut renderer_response_rx,
+ response_delivery,
+ session_response_predecessor,
+ session_response_succeeded,
+ ) = match completed_inspector {
Ok(mut completed_protocol) => {
+ let response_delivery = completed_protocol.response_delivery();
+ let session_response_predecessor = completed_protocol.session_response_predecessor();
+ let session_response_succeeded = completed_protocol.session_response_succeeded();
let renderer_response_rx = completed_protocol.take_deferred_response_receiver();
match conn
.complete_service_worker_runtime_protocol_message_for_session(completed_protocol)
{
- Ok(messages) => (messages, renderer_response_rx),
+ Ok(messages) => (
+ messages,
+ renderer_response_rx,
+ response_delivery,
+ session_response_predecessor,
+ session_response_succeeded,
+ ),
Err(message) => {
return complete_service_worker_runtime_inspector_error(
conn, completed, message,
@@ -9590,6 +9673,9 @@ async fn complete_pending_service_worker_runtime_inspector_command(
let mut plan = CommandOutputPlan::default();
let mut routed_output = RuntimeInspectorRoutedOutput::default();
+ if let Some(predecessor) = session_response_predecessor {
+ routed_output.set_renderer_output_predecessor(predecessor);
+ }
let mut saw_current_response = route_inspector_messages_into_routed_output(
conn,
messages,
@@ -9597,7 +9683,14 @@ async fn complete_pending_service_worker_runtime_inspector_command(
&completed.owner_scope,
&mut routed_output,
);
- if !completed.wait_for_deferred_reply
+ if saw_current_response {
+ renderer_response_rx.take();
+ }
+ if response_delivery == RendererInspectorResponseDelivery::DevToolsSession {
+ renderer_response_rx.take();
+ }
+ if response_delivery == RendererInspectorResponseDelivery::CommandReply
+ && !completed.wait_for_deferred_reply
&& let Some(renderer_response_rx) = renderer_response_rx.take()
{
saw_current_response |= route_registered_runtime_response_receiver_into(
@@ -9609,7 +9702,8 @@ async fn complete_pending_service_worker_runtime_inspector_command(
)
.await;
}
- if completed.wait_for_deferred_reply
+ if response_delivery == RendererInspectorResponseDelivery::CommandReply
+ && completed.wait_for_deferred_reply
&& (renderer_response_rx.is_some() || !saw_current_response)
&& completed.command_id.is_some()
{
@@ -9620,7 +9714,8 @@ async fn complete_pending_service_worker_runtime_inspector_command(
renderer_response_rx,
);
}
- let succeeded = routed_output.command_response_succeeded(completed.command_id);
+ let succeeded = session_response_succeeded
+ .unwrap_or_else(|| routed_output.command_response_succeeded(completed.command_id));
apply_service_worker_runtime_completion_projection(
conn,
completed.session_id(),
@@ -9631,10 +9726,17 @@ async fn complete_pending_service_worker_runtime_inspector_command(
&& let Some(console_action) = console_action_from_protocol_method(completed.action)
&& !apply_console_output_state_for_session(conn, completed.session_id(), console_action)
{
- return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(format!(
- "ConsoleCommandCompletionFailed: {}",
- completed.action
- )));
+ let message = format!("ConsoleCommandCompletionFailed: {}", completed.action);
+ if session_response_succeeded.is_some() {
+ tracing::warn!(
+ command_id = completed.command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "could not apply service-worker projection after the terminal response was published"
+ );
+ } else {
+ return RuntimeCommandTaskStep::Complete(service_worker_runtime_error_plan(message));
+ }
}
if succeeded {
routed_output.register_object_group_for_success(
@@ -9725,7 +9827,18 @@ fn complete_shared_worker_runtime_inspector_error(
message: String,
) -> RuntimeCommandTaskStep {
if let Some(command_id) = completed.command_id {
+ let renderer_call = conn
+ .take_renderer_call_for_frontend_for_session_owner(completed.session_id(), command_id);
conn.forget_pending_inspector_await(command_id, completed.session_id());
+ if renderer_call.is_none() {
+ tracing::debug!(
+ command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "ignored shared-worker completion after another route settled the frontend call"
+ );
+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::default());
+ }
}
match completed.action {
"enable" if message == "NoDocumentLoaded" || worker_runtime_is_unavailable(&message) => {
@@ -9815,7 +9928,18 @@ fn complete_service_worker_runtime_inspector_error(
message: String,
) -> RuntimeCommandTaskStep {
if let Some(command_id) = completed.command_id {
+ let renderer_call = conn
+ .take_renderer_call_for_frontend_for_session_owner(completed.session_id(), command_id);
conn.forget_pending_inspector_await(command_id, completed.session_id());
+ if renderer_call.is_none() {
+ tracing::debug!(
+ command_id,
+ session_id = completed.session_id(),
+ error = %message,
+ "ignored service-worker completion after another route settled the frontend call"
+ );
+ return RuntimeCommandTaskStep::Complete(CommandOutputPlan::default());
+ }
}
match completed.action {
"enable"
diff --git a/moli-protocol/src/domains/target.rs b/moli-protocol/src/domains/target.rs
index 24625b738..f05acf793 100644
--- a/moli-protocol/src/domains/target.rs
+++ b/moli-protocol/src/domains/target.rs
@@ -25,6 +25,7 @@ mod info;
mod popup;
#[cfg(test)]
mod protocol_neutral_tests;
+mod session_disposal;
#[cfg(test)]
mod tests;
mod worker_target;
@@ -184,17 +185,17 @@ pub(in crate::domains::target) async fn clear_detached_target_fetch_state_backgr
conn: &mut CdpConnection,
out: &mut Vec<BackgroundProtocolEvent>,
session_id: &str,
-) {
+) -> Option<moli_core::RendererOutputFence> {
clear_detached_target_owner_fetch_state_background_events_async(conn, out, Some(session_id))
- .await;
+ .await
}
async fn clear_detached_target_owner_fetch_state_background_events_async(
conn: &mut CdpConnection,
out: &mut Vec<BackgroundProtocolEvent>,
session_id: Option<&str>,
-) {
- let Some((pending_fetch_state, pending_page_command)) =
+) -> Option<moli_core::RendererOutputFence> {
+ let (pending_fetch_state, pending_page_command) =
(match conn.start_disable_fetch_for_session_owner(session_id) {
Ok(disable_state) => disable_state,
Err(error) => {
@@ -203,12 +204,9 @@ async fn clear_detached_target_owner_fetch_state_background_events_async(
error,
"failed to disable Fetch interception while detaching target owner"
);
- return;
+ return None;
}
- })
- else {
- return;
- };
+ })?;
if let Some(pending_page_command) = pending_page_command {
match pending_page_command.wait().await {
@@ -252,7 +250,7 @@ async fn clear_detached_target_owner_fetch_state_background_events_async(
// Target-owner teardown has no command response to fence. The concrete
// renderer publication remains ordered on its own stream and will reach
// protocol ingress independently.
- let _ = page::fail_pending_fetch_state_background_events_async(
+ page::fail_pending_fetch_state_background_events_async(
conn,
out,
session_id,
@@ -265,7 +263,7 @@ async fn clear_detached_target_owner_fetch_state_background_events_async(
pending_subresource_auths,
pending_subresource_responses,
)
- .await;
+ .await
}
impl CdpConnection {
@@ -282,7 +280,7 @@ impl CdpConnection {
None,
"Inspector detached",
);
- clear_detached_target_owner_fetch_state_background_events_async(
+ let _ = clear_detached_target_owner_fetch_state_background_events_async(
self,
side_effects.background_events_mut(),
None,
@@ -1095,6 +1093,7 @@ fn select_browser_context_for_target(
#[cfg(test)]
mod devtools_runtime_entry_tests {
+ use crate::conn::RendererCommandDescriptor;
use crate::devtools_runtime::{
AutomationEvent, DevToolsActivateTargetCommand, DevToolsCloseTargetCommand,
DevToolsCommand, DevToolsCommandContext, DevToolsCreateTargetCommand,
@@ -1256,6 +1255,10 @@ mod devtools_runtime_entry_tests {
let mut browser_context = BrowserContext::new("BID-runtime-ready-close".to_owned());
browser_context.set_active_target_id("TID-runtime-ready-close");
browser_context.attach_active_session("SID-runtime-ready-close");
+ assert!(browser_context.assign_auxiliary_session_to_target(
+ "TID-runtime-ready-close",
+ "SID-runtime-ready-close-aux".to_owned(),
+ ));
conn.browser_context = Some(browser_context);
let page = conn
.load_page_via_runtime_async("data:text/html,<p>runtime ready close</p>")
@@ -1276,6 +1279,31 @@ mod devtools_runtime_entry_tests {
.is_some(),
"test must cover scheduler-deferred Runtime await owner cleanup"
);
+ conn.register_pending_inspector_await(7102, Some("SID-runtime-ready-close-aux"));
+ let auxiliary_dispatch = conn
+ .try_register_renderer_call_for_session_owner(
+ Some("SID-runtime-ready-close-aux"),
+ 7102,
+ None,
+ RendererCommandDescriptor::from_synthesized_payload(
+ json!({
+ "id": 7102,
+ "method": "Runtime.evaluate",
+ "params": { "expression": "new Promise(() => {})" },
+ })
+ .to_string(),
+ )
+ .expect("test Runtime command should parse"),
+ )
+ .expect("auxiliary renderer command should register");
+ assert!(
+ conn.claim_pending_inspector_await_for_scheduler_deferred_reply(
+ 7102,
+ &crate::conn::CommandOwnerScope::for_session("SID-runtime-ready-close-aux",),
+ )
+ .is_some(),
+ "test must cover an auxiliary scheduler-deferred Runtime await"
+ );
let (result, protocol_events) = execute_devtools_target_command_async_with_protocol_events(
&mut conn,
@@ -1306,6 +1334,15 @@ mod devtools_runtime_entry_tests {
&& response.error() == Some("Target closed"))),
"pending Runtime await cancellation must remain a typed runtime-ready event"
);
+ assert!(
+ protocol_events.iter().any(|event| event
+ .as_runtime_inspector_response_ready()
+ .is_some_and(|response| response.command_id() == 7102
+ && response.error() == Some("Target closed")
+ && response.has_bound_renderer_call_id())),
+ "an auxiliary claimed await must settle through its correlated typed response before the Page route retires"
+ );
+ drop(auxiliary_dispatch);
assert!(
protocol_events.iter().all(|event| {
event.protocol_message().is_none_or(|message| {
diff --git a/moli-protocol/src/domains/target/attachment.rs b/moli-protocol/src/domains/target/attachment.rs
index 245c96bf1..083230c5a 100644
--- a/moli-protocol/src/domains/target/attachment.rs
+++ b/moli-protocol/src/domains/target/attachment.rs
@@ -601,408 +601,78 @@ async fn detach_from_target_inner_async(
out.push_success();
return;
}
- if conn.browser_context.is_none() {
- out.push_success();
- return;
- }
- if let Some(session_id) = params.session_id.as_deref()
- && let Some(tab_target_id) = conn
- .tab_target_id_for_session_id(session_id)
- .map(str::to_owned)
- {
- if let Some(requested_target_id) = params.target_id.as_deref()
- && requested_target_id != tab_target_id
- {
- out.push_error(-31998, "UnknownTargetId");
+ if let Some(session_id) = params.session_id.as_deref() {
+ let Some(route) = conn.session_route(Some(session_id)) else {
+ out.push_error(-31998, "InvalidSessionId");
return;
- }
- out.push_success();
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- tab_target_id,
- session_id,
- None,
- command_session_id,
- ),
- )
- .await;
- out.target_events_mut().extend_background_events(event_plan);
- return;
- }
- if let Some(session_id) = params.session_id.as_deref()
- && let Some(target_id) = conn
- .browser_context
- .as_ref()
- .and_then(|bc| bc.auxiliary_target_id_for_session(session_id))
- .map(str::to_owned)
- {
- if let Some(requested_target_id) = params.target_id.as_deref()
- && requested_target_id != target_id
- {
- out.push_error(-31998, "UnknownTargetId");
+ };
+ let Some(target_id) = detach_session_route_target_id(&route).map(str::to_owned) else {
+ out.push_error(-31998, "InvalidSessionId");
return;
- }
- 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;
- super::auto_attach::clear_detached_session_target_overrides_best_effort(conn, session_id)
- .await;
- super::clear_detached_target_fetch_state_background_events_async(
+ };
+ match super::session_disposal::dispose_target_session_async(
conn,
- out.background_events_mut(),
- session_id,
- )
- .await;
- out.push_success();
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id,
- session_id,
- None,
- command_session_id,
- ),
- )
- .await;
- out.target_events_mut().extend_background_events(event_plan);
- return;
- }
- if let Some(session_id) = params.session_id.as_deref()
- && let Some(target_id) = conn
- .browser_context
- .as_ref()
- .and_then(|bc| bc.dedicated_worker_target_id_for_session(session_id))
- .map(str::to_owned)
- {
- if let Some(requested_target_id) = params.target_id.as_deref()
- && requested_target_id != target_id
- {
- out.push_error(-31998, "UnknownTargetId");
- return;
- }
- 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;
- out.push_success();
- 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.target_events_mut().extend_background_events(event_plan);
- return;
- }
- if let Some(session_id) = params.session_id.as_deref()
- && let Some(target_id) = conn
- .browser_context
- .as_ref()
- .and_then(|bc| bc.shared_worker_target_id_for_session(session_id))
- .map(str::to_owned)
- {
- if let Some(requested_target_id) = params.target_id.as_deref()
- && requested_target_id != target_id
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id,
+ session_id,
+ None,
+ command_session_id,
+ ),
+ )
+ .await
{
- out.push_error(-31998, "UnknownTargetId");
- return;
- }
- 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;
- out.push_success();
- 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()),
- );
+ Ok(outcome) => {
+ let (event_plan, predecessor) = outcome.into_parts();
+ if let Some(predecessor) = predecessor {
+ command_context.set_renderer_output_predecessor(predecessor);
+ }
+ out.push_success();
+ out.target_events_mut().extend_background_events(event_plan);
+ }
+ Err(error) => out.push_error(-32000, error.to_string()),
}
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(target_id, session_id, None, None),
- )
- .await;
- out.target_events_mut().extend_background_events(event_plan);
return;
}
- if let Some(session_id) = params.session_id.as_deref()
- && let Some(target_id) = conn
- .browser_context
- .as_ref()
- .and_then(|bc| bc.service_worker_target_id_for_session(session_id))
- .map(str::to_owned)
- {
- if let Some(requested_target_id) = params.target_id.as_deref()
- && requested_target_id != target_id
- {
- out.push_error(-31998, "UnknownTargetId");
- return;
- }
+ if conn.browser_context.is_none() {
out.push_success();
- 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.target_events_mut().extend_background_events(event_plan);
return;
}
- if let Some(session_id) = params.session_id.as_deref() {
- let background_target_id = conn.browser_context.as_ref().and_then(|bc| {
- bc.background_targets()
- .find(|target| target.is_session(session_id))
- .map(|target| target.target_id().to_owned())
- });
- if let Some(target_id) = background_target_id.as_deref() {
- if let Some(requested_target_id) = params.target_id.as_deref()
- && requested_target_id != target_id
- {
- out.push_error(-31998, "UnknownTargetId");
- return;
- }
- 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;
- match conn
- .detach_background_target_session_binding_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id,
- session_id,
- None,
- command_session_id,
- ),
- )
- .await
- {
- Ok(Some(event_plan)) => {
- out.push_success();
- out.target_events_mut().extend_background_events(event_plan);
- return;
- }
- Ok(None) => {}
- Err(message) => {
- out.push_error(-32000, message);
- return;
- }
- }
- }
- }
if let Some(target_id) = params.target_id.as_deref() {
- let shared_worker_detach_plan = conn.browser_context.as_ref().and_then(|bc| {
- bc.shared_worker_target(target_id).map(|target| {
- (
- bc.renderer_runtime(),
- target.renderer_instance_id,
- target.session_ids(),
- )
- })
- });
- if conn
- .browser_context
- .as_ref()
- .is_some_and(|bc| bc.has_shared_worker_target(target_id))
- {
- out.push_success();
- for session_id in shared_worker_detach_plan
- .as_ref()
- .map(|(_, _, sessions)| sessions.as_slice())
- .unwrap_or_default()
- {
- 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, session_ids)) = &shared_worker_detach_plan {
- for session_id in session_ids {
- renderer_runtime.detach_shared_worker_runtime_inspector_session(
- *instance_id,
- Some(session_id.clone()),
- );
- }
- }
- let detached_sessions = shared_worker_detach_plan
- .as_ref()
- .map(|(_, _, sessions)| sessions.clone())
- .unwrap_or_default();
- if !detached_sessions.is_empty() {
- let event_plan = conn
- .detach_target_sessions_with_binding_cleanup_event_plan_async(
- crate::conn::TargetClosureCleanupPlan::new(
- target_id,
- None,
- detached_sessions,
- ),
- None,
- )
- .await;
- out.target_events_mut().extend_background_events(event_plan);
- }
- return;
- }
- let dedicated_worker_detach_plan = conn.browser_context.as_ref().and_then(|bc| {
- bc.dedicated_worker_target(target_id).map(|target| {
- (
- bc.renderer_runtime(),
- target.renderer_instance_id,
- target.session_ids(),
- )
- })
+ let worker_session_ids = conn.browser_context.as_ref().and_then(|browser_context| {
+ browser_context
+ .shared_worker_target(target_id)
+ .map(|target| target.session_ids())
+ .or_else(|| {
+ browser_context
+ .dedicated_worker_target(target_id)
+ .map(|target| target.session_ids())
+ })
+ .or_else(|| {
+ browser_context
+ .service_worker_target(target_id)
+ .map(|target| target.session_ids())
+ })
});
- if conn
- .browser_context
- .as_ref()
- .is_some_and(|bc| bc.has_dedicated_worker_target(target_id))
- {
- out.push_success();
- for session_id in dedicated_worker_detach_plan
- .as_ref()
- .map(|(_, _, sessions)| sessions.as_slice())
- .unwrap_or_default()
+ if let Some(session_ids) = worker_session_ids {
+ match dispose_target_sessions_async(conn, out, command_context, target_id, session_ids)
+ .await
{
- 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, session_ids)) =
- &dedicated_worker_detach_plan
- {
- for session_id in session_ids {
- renderer_runtime.detach_dedicated_worker_runtime_inspector_session(
- *instance_id,
- Some(session_id.clone()),
- );
- }
- }
- let detached_sessions = dedicated_worker_detach_plan
- .as_ref()
- .map(|(_, _, sessions)| sessions.clone())
- .unwrap_or_default();
- if !detached_sessions.is_empty() {
- let event_plan = conn
- .detach_target_sessions_with_binding_cleanup_event_plan_async(
- crate::conn::TargetClosureCleanupPlan::new(
- target_id,
- None,
- detached_sessions,
- ),
- None,
- )
- .await;
- out.target_events_mut().extend_background_events(event_plan);
- }
- return;
- }
- if conn
- .browser_context
- .as_ref()
- .is_some_and(|bc| bc.has_service_worker_target(target_id))
- {
- out.push_success();
- let service_worker_session_ids: Vec<String> = conn
- .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 &service_worker_session_ids {
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(session_id.as_str()),
- "Target detached",
- );
- super::set_service_worker_pause_on_start_owner(
- conn,
- Some(session_id.as_str()),
- false,
- );
- }
- if !service_worker_session_ids.is_empty() {
- let event_plan = conn
- .detach_target_sessions_with_binding_cleanup_event_plan_async(
- crate::conn::TargetClosureCleanupPlan::new(
- target_id,
- None,
- service_worker_session_ids,
- ),
- None,
- )
- .await;
- out.target_events_mut().extend_background_events(event_plan);
+ Ok(()) => out.push_success(),
+ Err(error) => out.push_error(-32000, error.to_string()),
}
return;
}
}
- let Some(bc) = conn.browser_context.as_mut() else {
- out.push_success();
- return;
- };
- let Some((target_id, Some(current_session_id))) = bc.active_target_identity() else {
+ let Some((target_id, Some(current_session_id))) = conn
+ .browser_context
+ .as_ref()
+ .and_then(BrowserContext::active_target_identity)
+ else {
out.push_success();
return;
};
- if let Some(session_id) = params.session_id.as_deref()
- && session_id != current_session_id
- {
- out.push_error(-31998, "InvalidSessionId");
- return;
- }
if let Some(requested_target_id) = params.target_id.as_deref()
&& requested_target_id != target_id
{
@@ -1010,56 +680,48 @@ async fn detach_from_target_inner_async(
return;
}
- out.push_success();
-
- let (
- pending_navigations,
- pending_auth_navigations,
- pending_response_navigations,
- pending_subresource_fetches,
- pending_subresource_auths,
- pending_subresource_responses,
- ) = page::take_pending_fetch_state(conn, Some(&current_session_id));
-
- let renderer_output_predecessor = page::fail_pending_fetch_state_background_events_async(
+ match super::session_disposal::dispose_target_session_async(
conn,
out.background_events_mut(),
- Some(&current_session_id),
- "Target detached",
- "Target detached",
- pending_navigations,
- pending_auth_navigations,
- pending_response_navigations,
- pending_subresource_fetches,
- pending_subresource_auths,
- pending_subresource_responses,
+ command_context.protocol_events_mut(),
+ crate::conn::TargetSessionDetachCleanupPlan::new(target_id, current_session_id, None, None),
)
- .await;
- if let Some(predecessor) = renderer_output_predecessor {
- command_context.set_renderer_output_predecessor(predecessor);
+ .await
+ {
+ Ok(outcome) => {
+ let (event_plan, predecessor) = outcome.into_parts();
+ if let Some(predecessor) = predecessor {
+ command_context.set_renderer_output_predecessor(predecessor);
+ }
+ out.push_success();
+ out.target_events_mut().extend_background_events(event_plan);
+ }
+ Err(error) => out.push_error(-32000, error.to_string()),
}
+}
- conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
- out.background_events_mut(),
- command_context.protocol_events_mut(),
- Some(&current_session_id),
- "Target detached",
- );
-
- let _ = conn
- .detach_runtime_inspector_session_for_session_owner_async(Some(&current_session_id))
- .await;
- let event_plan = conn
- .detach_session_with_binding_cleanup_event_plan_async(
- crate::conn::TargetSessionDetachCleanupPlan::new(
- target_id,
- current_session_id,
- None,
- None,
- ),
+async fn dispose_target_sessions_async(
+ conn: &mut CdpConnection,
+ out: &mut TargetCommandOutput,
+ command_context: &mut crate::conn::CommandDispatchContext,
+ target_id: &str,
+ session_ids: Vec<String>,
+) -> anyhow::Result<()> {
+ for session_id in session_ids {
+ let outcome = super::session_disposal::dispose_target_session_async(
+ conn,
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ crate::conn::TargetSessionDetachCleanupPlan::new(target_id, &session_id, None, None),
)
- .await;
- out.target_events_mut().extend_background_events(event_plan);
+ .await?;
+ let (event_plan, predecessor) = outcome.into_parts();
+ if let Some(predecessor) = predecessor {
+ command_context.set_renderer_output_predecessor(predecessor);
+ }
+ out.target_events_mut().extend_background_events(event_plan);
+ }
+ Ok(())
}
fn detach_session_route_target_id(route: &crate::conn::CdpSessionRoute) -> Option<&str> {
diff --git a/moli-protocol/src/domains/target/auto_attach.rs b/moli-protocol/src/domains/target/auto_attach.rs
index 8de471196..b0319d341 100644
--- a/moli-protocol/src/domains/target/auto_attach.rs
+++ b/moli-protocol/src/domains/target/auto_attach.rs
@@ -789,114 +789,70 @@ async fn set_auto_attach_inner_async(
continue;
}
- if let Some((target_id, Some(session_id))) = conn
+ let sessions_to_dispose = 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<_>>()
+ .map(|browser_context| {
+ let mut sessions = browser_context
+ .active_target_identity()
+ .and_then(|(target_id, session_id)| {
+ session_id.map(|session_id| (target_id, session_id))
+ })
+ .into_iter()
+ .collect::<Vec<_>>();
+ sessions.extend(browser_context.background_targets().filter_map(|target| {
+ Some((
+ target.target_id().to_owned(),
+ target.session_id()?.to_owned(),
+ ))
+ }));
+ sessions.extend(browser_context.shared_worker_targets.values().flat_map(
+ |target| {
+ target
+ .session_ids()
+ .into_iter()
+ .map(|session_id| (target.target_id.clone(), session_id))
+ },
+ ));
+ sessions.extend(browser_context.dedicated_worker_targets.values().flat_map(
+ |target| {
+ target
+ .session_ids()
+ .into_iter()
+ .map(|session_id| (target.target_id.clone(), session_id))
+ },
+ ));
+ sessions.extend(browser_context.service_worker_targets.values().flat_map(
+ |target| {
+ target
+ .session_ids()
+ .into_iter()
+ .map(|session_id| (target.target_id.clone(), session_id))
+ },
+ ));
+ sessions
})
.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(
+ for (target_id, session_id) in sessions_to_dispose {
+ let outcome = super::session_disposal::dispose_target_session_async(
+ conn,
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,
+ crate::conn::TargetSessionDetachCleanupPlan::new(
+ target_id,
+ &session_id,
+ None,
+ None,
+ ),
)
- .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);
+ .await
+ .expect("target session cleanup during auto-attach reset should succeed");
+ let (event_plan, predecessor) = outcome.into_parts();
+ if let Some(predecessor) = predecessor {
+ command_context.set_renderer_output_predecessor(predecessor);
+ }
+ out.extend_background_events(event_plan);
}
- out.extend_background_events(service_worker_event_plan);
}
}
@@ -1056,22 +1012,27 @@ pub(super) async fn release_attached_sessions_for_root_frontend_async(
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(
+ let predecessor = match super::session_disposal::dispose_page_session_runtime_state_async(
conn,
out.background_events_mut(),
+ command_context.protocol_events_mut(),
&session_id,
)
- .await;
- let _ = conn
- .detach_runtime_inspector_session_for_session_owner_async(Some(&session_id))
- .await;
- clear_detached_session_target_overrides_best_effort(conn, &session_id).await;
+ .await
+ {
+ Ok(predecessor) => predecessor,
+ Err(error) => {
+ tracing::warn!(
+ session_id,
+ %error,
+ "failed to dispose root-owned page session runtime state"
+ );
+ continue;
+ }
+ };
+ if let Some(predecessor) = predecessor {
+ command_context.set_renderer_output_predecessor(predecessor);
+ }
if !conn.release_primary_target_session_binding_without_event(&session_id) {
conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
}
@@ -1108,178 +1069,46 @@ async fn detach_attached_session_for_owner_async(
conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
return;
};
- match cleanup_plan.action().clone() {
- crate::conn::TargetBindingCleanupAction::PageTarget {
- target_id,
- session_key,
- } => {
- // 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;
- if matches!(
- session_key,
- moli_page_types::DevToolsSessionKey::Attached(_)
- ) {
- clear_detached_session_target_overrides_best_effort(conn, session_id).await;
- super::clear_detached_target_fetch_state_background_events_async(
- conn,
- out.background_events_mut(),
- session_id,
- )
- .await;
- } else if conn
- .browser_context
- .as_ref()
- .is_some_and(|browser_context| browser_context.is_active_target(&target_id))
- {
- events::fail_pending_fetch_state_for_target_background_events_async(
- conn,
- out.background_events_mut(),
- Some(session_id),
- "Target detached",
- )
- .await;
- } else {
- clear_detached_session_target_overrides_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);
+ let target_id = match cleanup_plan.action() {
+ crate::conn::TargetBindingCleanupAction::PageTarget { target_id, .. }
+ | crate::conn::TargetBindingCleanupAction::SharedWorkerTarget { target_id }
+ | crate::conn::TargetBindingCleanupAction::DedicatedWorkerTarget { target_id }
+ | crate::conn::TargetBindingCleanupAction::ServiceWorkerTarget { target_id } => {
+ target_id.clone()
}
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);
+ tab_target_id.clone()
}
- 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::None => {
+ conn.rollback_auto_attached_session_detach_plan_without_event(&detach_plan);
+ return;
}
- 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()),
- );
+ };
+ match super::session_disposal::dispose_target_session_async(
+ conn,
+ out.background_events_mut(),
+ command_context.protocol_events_mut(),
+ crate::conn::TargetSessionDetachCleanupPlan::new(target_id, session_id, None, None),
+ )
+ .await
+ {
+ Ok(outcome) => {
+ let (event_plan, predecessor) = outcome.into_parts();
+ if let Some(predecessor) = predecessor {
+ command_context.set_renderer_output_predecessor(predecessor);
}
- 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",
+ Err(error) => {
+ tracing::warn!(
+ session_id,
+ %error,
+ "failed to dispose auto-attached target session"
);
- 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_detached_session_target_overrides_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"
- );
- }
- if let Err(error) = conn.clear_target_session_overrides_async(session_id).await {
- tracing::warn!(
- session_id,
- error,
- "failed to restore target overrides while detaching target session"
- );
- }
-}
-
async fn ensure_initial_document_for_attached_page_targets_async(
conn: &mut CdpConnection,
attached_targets: &[(String, String)],
diff --git a/moli-protocol/src/domains/target/browser_context_disposal.rs b/moli-protocol/src/domains/target/browser_context_disposal.rs
index 4ed3e1bbb..147f37352 100644
--- a/moli-protocol/src/domains/target/browser_context_disposal.rs
+++ b/moli-protocol/src/domains/target/browser_context_disposal.rs
@@ -256,8 +256,11 @@ async fn close_page_target(
.as_ref()
.is_some_and(|browser_context| browser_context.is_active_target(&target_id));
let closed = if is_active_target {
- conn.close_active_page_target_for_target_close_async(out.background_events_mut())
- .await
+ conn.close_active_page_target_for_target_close_async(
+ out.background_events_mut(),
+ DISPOSE_REASON,
+ )
+ .await
} else {
conn.close_background_page_target_for_target_close_async(
&target_id,
diff --git a/moli-protocol/src/domains/target/closing.rs b/moli-protocol/src/domains/target/closing.rs
index e0404d852..545e680a3 100644
--- a/moli-protocol/src/domains/target/closing.rs
+++ b/moli-protocol/src/domains/target/closing.rs
@@ -266,11 +266,8 @@ async fn settle_target_close_after_pending_fetches_async(
owner_scope: crate::conn::CommandOwnerScope,
target_id: String,
) {
- let action = crate::domains::page::PageTargetTerminationOwnerAction::new(
- owner_scope,
- target_id,
- crate::domains::page::PageTargetTerminationKind::TargetClose,
- );
+ let action =
+ crate::domains::page::PageTargetTerminationOwnerAction::new(owner_scope, target_id);
if let Some(predecessor) = renderer_output_predecessor {
command_context.set_renderer_output_predecessor(predecessor);
conn.publish_page_target_termination_owner_action(action);
diff --git a/moli-protocol/src/domains/target/session_disposal.rs b/moli-protocol/src/domains/target/session_disposal.rs
new file mode 100644
index 000000000..557938284
--- /dev/null
+++ b/moli-protocol/src/domains/target/session_disposal.rs
@@ -0,0 +1,177 @@
+use crate::conn::{
+ BackgroundProtocolEvent, CdpConnection, TargetBindingCleanupAction, TargetBindingCleanupPlan,
+ TargetEventPlan, TargetSessionDetachCleanupPlan,
+};
+
+pub(super) struct TargetSessionDisposalOutcome {
+ event_plan: TargetEventPlan,
+ renderer_output_predecessor: Option<moli_core::RendererOutputFence>,
+}
+
+impl TargetSessionDisposalOutcome {
+ pub(super) fn into_parts(self) -> (TargetEventPlan, Option<moli_core::RendererOutputFence>) {
+ (self.event_plan, self.renderer_output_predecessor)
+ }
+}
+
+pub(super) async fn dispose_target_session_async(
+ conn: &mut CdpConnection,
+ background_events: &mut Vec<BackgroundProtocolEvent>,
+ protocol_events: &mut Vec<BackgroundProtocolEvent>,
+ cleanup_plan: TargetSessionDetachCleanupPlan,
+) -> anyhow::Result<TargetSessionDisposalOutcome> {
+ let session_id = cleanup_plan.session_id().to_owned();
+ let route = conn
+ .session_route(Some(&session_id))
+ .ok_or_else(|| anyhow::anyhow!("InvalidSessionId"))?;
+ let binding_plan = TargetBindingCleanupPlan::from_route(&session_id, &route);
+ let expected_target_id = cleanup_plan.target_id();
+ let action_target_id = match binding_plan.action() {
+ TargetBindingCleanupAction::None => None,
+ TargetBindingCleanupAction::PageTarget { target_id, .. }
+ | TargetBindingCleanupAction::SharedWorkerTarget { target_id }
+ | TargetBindingCleanupAction::DedicatedWorkerTarget { target_id }
+ | TargetBindingCleanupAction::ServiceWorkerTarget { target_id } => Some(target_id.as_str()),
+ TargetBindingCleanupAction::TabTarget { tab_target_id } => Some(tab_target_id.as_str()),
+ };
+ if action_target_id.is_some_and(|target_id| target_id != expected_target_id) {
+ anyhow::bail!("UnknownTargetId");
+ }
+
+ let mut renderer_output_predecessor = None;
+ match binding_plan.action() {
+ TargetBindingCleanupAction::PageTarget { .. } => {
+ renderer_output_predecessor = dispose_page_session_runtime_state_async(
+ conn,
+ background_events,
+ protocol_events,
+ &session_id,
+ )
+ .await?;
+ }
+ TargetBindingCleanupAction::SharedWorkerTarget { target_id } => {
+ let renderer_detach = conn.browser_context.as_ref().and_then(|browser_context| {
+ browser_context
+ .shared_worker_target(target_id)
+ .map(|target| {
+ (
+ browser_context.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(
+ background_events,
+ protocol_events,
+ 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.clone()),
+ );
+ }
+ }
+ TargetBindingCleanupAction::DedicatedWorkerTarget { target_id } => {
+ let renderer_detach = conn.browser_context.as_ref().and_then(|browser_context| {
+ browser_context
+ .dedicated_worker_target(target_id)
+ .map(|target| {
+ (
+ browser_context.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(
+ background_events,
+ protocol_events,
+ 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.clone()),
+ );
+ }
+ }
+ TargetBindingCleanupAction::ServiceWorkerTarget { .. } => {
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ background_events,
+ protocol_events,
+ Some(&session_id),
+ "Target detached",
+ );
+ super::set_service_worker_pause_on_start_owner(conn, Some(&session_id), false);
+ }
+ TargetBindingCleanupAction::TabTarget { .. } => {}
+ TargetBindingCleanupAction::None => anyhow::bail!("InvalidSessionId"),
+ }
+
+ let event_plan = conn
+ .detach_session_with_binding_cleanup_event_plan_async(cleanup_plan)
+ .await?;
+ Ok(TargetSessionDisposalOutcome {
+ event_plan,
+ renderer_output_predecessor,
+ })
+}
+
+pub(super) async fn dispose_page_session_runtime_state_async(
+ conn: &mut CdpConnection,
+ background_events: &mut Vec<BackgroundProtocolEvent>,
+ protocol_events: &mut Vec<BackgroundProtocolEvent>,
+ session_id: &str,
+) -> anyhow::Result<Option<moli_core::RendererOutputFence>> {
+ let renderer_output_predecessor =
+ super::clear_detached_target_fetch_state_background_events_async(
+ conn,
+ background_events,
+ session_id,
+ )
+ .await;
+ conn.fail_pending_inspector_awaits_for_session_owner_background_events_into(
+ background_events,
+ protocol_events,
+ Some(session_id),
+ "Target detached",
+ );
+
+ // Document-start scripts are renderer-owned resources. Remove them before
+ // detaching the Inspector session that carries the cleanup commands.
+ conn.remove_document_start_scripts_for_detached_session_async(session_id)
+ .await?;
+ clear_page_session_target_state_async(conn, session_id).await?;
+ if let Err(error) = conn
+ .detach_runtime_inspector_session_for_session_owner_async(Some(session_id))
+ .await
+ {
+ tracing::debug!(
+ session_id,
+ %error,
+ "renderer Inspector session was already unavailable during disposal"
+ );
+ }
+ Ok(renderer_output_predecessor)
+}
+
+async fn clear_page_session_target_state_async(
+ conn: &mut CdpConnection,
+ session_id: &str,
+) -> anyhow::Result<()> {
+ crate::domains::emulation::clear_emulated_media_for_detached_session_async(conn, session_id)
+ .await?;
+ conn.clear_target_session_overrides_async(session_id)
+ .await?;
+ Ok(())
+}
diff --git a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs b/moli-protocol/src/domains/target/tests/tests_target_attachment.rs
index cf2ae3578..4bde11821 100644
--- a/moli-protocol/src/domains/target/tests/tests_target_attachment.rs
+++ b/moli-protocol/src/domains/target/tests/tests_target_attachment.rs
@@ -1665,7 +1665,8 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
}
ctx.sent.clear();
- let baseline_session_count = page_renderer_inspector_session_count(&mut ctx).await;
+ let baseline_session_count =
+ page_renderer_inspector_session_count(&mut ctx, "before Runtime.enable").await;
ctx.process_async(json!({
"id": 120_001,
"sessionId": "SID-detach-primary",
@@ -1683,7 +1684,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
ctx.sent.clear();
assert_eq!(
- page_renderer_inspector_session_count(&mut ctx).await,
+ page_renderer_inspector_session_count(&mut ctx, "after both sessions enabled").await,
baseline_session_count + 1,
"primary Runtime.enable must reuse the target default Inspector session while auxiliary Runtime.enable adds one session"
);
@@ -1712,7 +1713,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
"auxiliary detach must publish exactly one target detach event"
);
assert_eq!(
- page_renderer_inspector_session_count(&mut ctx).await,
+ page_renderer_inspector_session_count(&mut ctx, "after auxiliary detach").await,
baseline_session_count,
"auxiliary detach should drop only that renderer V8 inspector session"
);
@@ -1745,12 +1746,27 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
ctx.expect_result(120_006, json!({}), Some("SID-detach-aux-replacement"));
ctx.sent.clear();
assert_eq!(
- page_renderer_inspector_session_count(&mut ctx).await,
+ page_renderer_inspector_session_count(&mut ctx, "after replacement auxiliary enable").await,
baseline_session_count + 1
);
-
+ ctx.process_async(json!({
+ "id": 120_007,
+ "sessionId": "SID-detach-aux-replacement",
+ "method": "Network.enable"
+ }))
+ .await;
+ ctx.expect_result(120_007, json!({}), Some("SID-detach-aux-replacement"));
ctx.process_async(json!({
"id": 120_008,
+ "sessionId": "SID-detach-aux-replacement",
+ "method": "Network.setCacheDisabled",
+ "params": { "cacheDisabled": true }
+ }))
+ .await;
+ ctx.expect_result(120_008, json!({}), Some("SID-detach-aux-replacement"));
+
+ ctx.process_async(json!({
+ "id": 120_009,
"method": "Target.detachFromTarget",
"params": {
"targetId": "TID-detach-inspector",
@@ -1758,7 +1774,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
}
}))
.await;
- ctx.expect_result(120_008, json!({}), None);
+ ctx.expect_result(120_009, json!({}), None);
ctx.expect_event(
"Target.detachedFromTarget",
Some(&json!({
@@ -1773,13 +1789,12 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
"primary detach must publish exactly one target detach event"
);
assert_eq!(
- page_renderer_inspector_session_count(&mut ctx).await,
- 1,
- "primary target detach must preserve same-target auxiliary renderer V8 inspector sessions"
+ page_renderer_inspector_session_count(&mut ctx, "after primary detach").await,
+ baseline_session_count,
+ "primary detach must release the default Inspector session while preserving the attached replacement session"
);
-
ctx.process_async(json!({
- "id": 120_009,
+ "id": 120_010,
"sessionId": "SID-detach-primary",
"method": "Runtime.evaluate",
"params": {
@@ -1788,10 +1803,21 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
}
}))
.await;
- ctx.expect_error(120_009, -32001, "Unknown sessionId");
+ ctx.expect_error(120_010, -32001, "Unknown sessionId");
+
+ let bc = ctx.conn.browser_context.as_ref().unwrap();
+ assert_eq!(
+ bc.auxiliary_target_id_for_session("SID-detach-aux-replacement"),
+ Some("TID-detach-inspector"),
+ "detaching primary must preserve the attached session binding"
+ );
+ assert!(
+ bc.active_page_target().effective_policy().cache_disabled(),
+ "detaching primary must preserve the attached Network handler state"
+ );
ctx.process_async(json!({
- "id": 120_010,
+ "id": 120_011,
"sessionId": "SID-detach-aux-replacement",
"method": "Runtime.evaluate",
"params": {
@@ -1800,11 +1826,11 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
}
}))
.await;
- let evaluation = take_response_by_id(&mut ctx, 120_010);
+ let evaluation = take_response_by_id(&mut ctx, 120_011);
assert_eq!(evaluation["result"]["result"]["value"], json!(42));
ctx.process_async(json!({
- "id": 120_011,
+ "id": 120_012,
"method": "Target.detachFromTarget",
"params": {
"targetId": "TID-detach-inspector",
@@ -1812,7 +1838,7 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
}
}))
.await;
- ctx.expect_result(120_011, json!({}), None);
+ ctx.expect_result(120_012, json!({}), None);
ctx.expect_event(
"Target.detachedFromTarget",
Some(&json!({
@@ -1820,10 +1846,34 @@ async fn detach_from_target_drops_only_selected_page_renderer_inspector_session(
"sessionId": "SID-detach-aux-replacement"
})),
);
+ ctx.process_async(json!({
+ "id": 120_013,
+ "sessionId": "SID-detach-aux-replacement",
+ "method": "Runtime.evaluate",
+ "params": {
+ "expression": "21 + 21",
+ "returnByValue": true
+ }
+ }))
+ .await;
+ ctx.expect_error(120_013, -32001, "Unknown sessionId");
+
+ ctx.conn
+ .browser_context
+ .as_mut()
+ .expect("browser context")
+ .attach_active_session("SID-detach-diagnostic");
+ ctx.process_async(json!({
+ "id": 120_014,
+ "sessionId": "SID-detach-diagnostic",
+ "method": "Runtime.enable"
+ }))
+ .await;
+ ctx.expect_result(120_014, json!({}), Some("SID-detach-diagnostic"));
assert_eq!(
- page_renderer_inspector_session_count(&mut ctx).await,
- 0,
- "detaching the final auxiliary session should release its renderer V8 inspector session"
+ page_renderer_inspector_session_count(&mut ctx, "after fresh primary attach").await,
+ baseline_session_count,
+ "a fresh primary session must not observe a leaked auxiliary renderer session"
);
}
@@ -2002,16 +2052,24 @@ async fn detach_from_target_removes_only_selected_session_document_start_scripts
);
}
-async fn page_renderer_inspector_session_count(ctx: &mut TestContext) -> u64 {
- let response = ctx
+async fn page_renderer_inspector_session_count(ctx: &mut TestContext, stage: &str) -> u64 {
+ let page = ctx
.conn
.browser_context
.as_mut()
.and_then(|bc| bc.active_page_target_mut().runtime_slot.loaded_page_mut())
- .expect("active target should still have a loaded page")
+ .expect("active target should still have a loaded page");
+ // This diagnostic deliberately runs on the primary Inspector route. It
+ // bypasses CdpConnection's session-aware Page accessor, so bind that route
+ // explicitly instead of inheriting whichever auxiliary session the prior
+ // command happened to stamp on the Page facade.
+ page.set_renderer_devtools_command_session_id(None);
+ let response = page
.runtime_heap_usage_async()
.await
- .expect("runtime heap usage diagnostics should be available");
+ .unwrap_or_else(|error| {
+ panic!("runtime heap usage diagnostics should be available {stage}: {error}")
+ });
u64::try_from(response.moli.runtime.inspector_session_count)
.expect("inspector session count should fit u64")
}
diff --git a/moli-protocol/src/domains/target/tests/tests_target_basics.rs b/moli-protocol/src/domains/target/tests/tests_target_basics.rs
index 434ccf21a..db773359e 100644
--- a/moli-protocol/src/domains/target/tests/tests_target_basics.rs
+++ b/moli-protocol/src/domains/target/tests/tests_target_basics.rs
@@ -42,6 +42,12 @@ async fn close_active_target_fails_only_active_owner_pending_awaits() {
let mut bc = BrowserContext::new("BID-await-owner".into());
bc.set_active_target_id("TID-active-await".to_owned());
bc.attach_active_session("SID-active-await".to_owned());
+ assert!(
+ bc.assign_auxiliary_session_to_target(
+ "TID-active-await",
+ "SID-active-aux-await".to_owned(),
+ )
+ );
bc.insert_page_target_host(PageTargetHost::with_url(
"TID-bg-await".to_owned(),
Some("SID-bg-await".to_owned()),
@@ -50,6 +56,8 @@ async fn close_active_target_fails_only_active_owner_pending_awaits() {
ctx.conn.browser_context = Some(bc);
ctx.conn
.register_pending_inspector_await(1041201, Some("SID-active-await"));
+ ctx.conn
+ .register_pending_inspector_await(1041203, Some("SID-active-aux-await"));
ctx.conn
.register_pending_inspector_await(1041202, Some("SID-bg-await"));
@@ -65,11 +73,16 @@ async fn close_active_target_fails_only_active_owner_pending_awaits() {
let active_failed = take_response_by_id(&mut ctx, 1041201);
assert_eq!(active_failed["sessionId"], json!("SID-active-await"));
assert_eq!(active_failed["error"]["message"], json!("Target closed"));
+ let auxiliary_failed = take_response_by_id(&mut ctx, 1041203);
+ assert_eq!(auxiliary_failed["sessionId"], json!("SID-active-aux-await"));
+ assert_eq!(auxiliary_failed["error"]["message"], json!("Target closed"));
assert!(
- ctx.take_all()
- .into_iter()
- .all(|message| message["id"] != json!(1041202)),
- "closing the active target must not fail the background owner's pending await"
+ ctx.take_all().into_iter().all(|message| {
+ message["id"] != json!(1041201)
+ && message["id"] != json!(1041202)
+ && message["id"] != json!(1041203)
+ }),
+ "target-local awaits must settle exactly once without touching the background owner"
);
assert!(
ctx.conn
diff --git a/moli-protocol/src/domains/target/worker_target.rs b/moli-protocol/src/domains/target/worker_target.rs
index a883e6ed9..9c4ed1534 100644
--- a/moli-protocol/src/domains/target/worker_target.rs
+++ b/moli-protocol/src/domains/target/worker_target.rs
@@ -1251,7 +1251,8 @@ async fn commit_dedicated_worker_retirement_output_async(
conn.detach_dedicated_worker_session_with_binding_cleanup_event_plan_async(
cleanup_plan,
)
- .await,
+ .await
+ .expect("retired dedicated-worker session cleanup should succeed"),
);
}
WorkerTargetLifecycleOutput::DedicatedWorkerDestroyed {
@@ -2960,7 +2961,8 @@ async fn emit_target_lifecycle_events(
);
let event_plan = conn
.detach_session_with_binding_cleanup_event_plan_async(cleanup_plan)
- .await;
+ .await
+ .expect("retired shared-worker session cleanup should succeed");
side_effects.extend_background_events(event_plan);
retirement.retire();
}
@@ -2983,7 +2985,8 @@ async fn emit_target_lifecycle_events(
);
let event_plan = conn
.detach_session_with_binding_cleanup_event_plan_async(cleanup_plan)
- .await;
+ .await
+ .expect("retired service-worker session cleanup should succeed");
side_effects.extend_background_events(event_plan);
retirement.retire();
}
diff --git a/moli-protocol/src/domains/tracing/tests.rs b/moli-protocol/src/domains/tracing/tests.rs
index 81fc080af..5242f24da 100644
--- a/moli-protocol/src/domains/tracing/tests.rs
+++ b/moli-protocol/src/domains/tracing/tests.rs
@@ -286,6 +286,7 @@ async fn owner_cleanup_cancels_trace_without_emitting_completion() {
ctx.conn
.execute_target_binding_cleanup_for_session_without_event_async("SID-peer")
.await
+ .unwrap()
);
assert!(!ctx.conn.tracing_state.is_active());
assert!(
@@ -362,7 +363,7 @@ async fn owner_cleanup_waits_for_cpu_trace_release_before_replacement_start() {
)
.await
.expect("owner detach should wait for CPU trace cancellation");
- assert!(cleaned);
+ assert!(cleaned.unwrap());
assert!(stop_tasks > 0);
assert!(!ctx.conn.tracing_state.is_active());
diff --git a/moli-protocol/src/testing.rs b/moli-protocol/src/testing.rs
index d8e7ffe7e..9194dfebb 100644
--- a/moli-protocol/src/testing.rs
+++ b/moli-protocol/src/testing.rs
@@ -312,8 +312,8 @@ impl TestContext {
.target_owner_identity_for_route(owner.session_id(), owner.session_owner_route())
.expect("navigation fixture requires an installed browser context");
let target_id = target_id.expect("navigation fixture requires an exact target");
+ let navigation_engine = navigation.take_navigation_engine_replacement();
let renderer_output_predecessor = navigation.renderer_output_predecessor;
- let navigation_engine = navigation.navigation_engine.take();
let page_creation_artifacts = navigation.page_creation_artifacts;
let final_url = navigation.final_url;
let main_document_commit = navigation
diff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs
index 33a4ac519..991c3a4dd 100644
--- a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs
+++ b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs
@@ -162,7 +162,7 @@ pub(crate) fn dispatch_worker_event<'s>(
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
| WorkerToParentMessage::SharedWorkerClosed
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_) => false,
+ | WorkerToParentMessage::RuntimeInspectorResponse(_) => false,
}
}
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index 2290b9cbd..caefe1fc7 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -215,18 +215,19 @@ pub use local_executor::is_on_js_local_executor;
pub use native_bridge::element::ClientRect as RendererClientRect;
pub use runtime::RendererRuntimeInspectorMessageResponseOrder;
pub use runtime::{
- DetachedParserScriptFetchContinuation, DevToolsSessionKey, ExternalRawDocumentBodyStream,
- JsRuntime, JsRuntimeOwner, PageId, PendingHtmlPage, PreparedRendererDocument,
- RendererAccessibilityPayloadsForObjectId, RendererActivityDiagnostics,
- RendererAgentAttachmentId, RendererAutofillAddressField, RendererAutofillCreditCard,
- RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest, RendererBrowserContextRuntime,
- RendererBrowserContextRuntimeId, RendererBrowserContextRuntimeOwner,
- RendererBrowserContextRuntimeOwnerAccess, RendererCaptureScreencastFrameReply,
- RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,
- RendererCaptureScreenshotRequest, RendererCapturedScreencastFrame, RendererCapturedScreenshot,
- RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererCountEntry,
- RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
- RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,
+ CompletedWorkerRuntimeInspectorCommandDispatch, DetachedParserScriptFetchContinuation,
+ DevToolsSessionKey, ExternalRawDocumentBodyStream, JsRuntime, JsRuntimeOwner, PageId,
+ PendingHtmlPage, PreparedRendererDocument, RendererAccessibilityPayloadsForObjectId,
+ RendererActivityDiagnostics, RendererAgentAttachmentId, RendererAutofillAddressField,
+ RendererAutofillCreditCard, RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,
+ RendererBrowserContextRuntime, RendererBrowserContextRuntimeId,
+ RendererBrowserContextRuntimeOwner, RendererBrowserContextRuntimeOwnerAccess,
+ RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,
+ RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,
+ RendererCapturedScreencastFrame, RendererCapturedScreenshot, RendererCommandTurnCompletion,
+ RendererCommandTurnOutput, RendererCountEntry, RendererDedicatedWorkerTargetEvent,
+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken,
+ RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,
RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,
RendererDocumentChildNodeSnapshots, RendererDocumentCommitPermit,
RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/activity.rs b/moli-renderer-v8/src/native_bridge/context_host/activity.rs
index 8cc8aef60..88a526d9f 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/activity.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/activity.rs
@@ -39,6 +39,26 @@ impl JsContextHost {
self.output_journal = Some(output_journal);
}
+ pub(crate) fn renderer_output_journal(
+ &self,
+ ) -> Option<crate::runtime::RendererTurnOutputJournal> {
+ self.output_journal.clone()
+ }
+
+ pub(crate) fn publish_worker_runtime_inspector_response(
+ &self,
+ publication: crate::runtime::RendererRuntimeInspectorResponsePublication,
+ ) -> bool {
+ let Some(output_journal) = self.output_journal.as_ref() else {
+ return false;
+ };
+ self.publish_live_turn_output_prefix();
+ let predecessor = output_journal
+ .last_published_cursor()
+ .map(|cursor| output_journal.declare_fence(cursor));
+ publication.commit(predecessor).is_ok()
+ }
+
/// Appends a browser-owner action to the one concrete sink for this turn.
///
/// Command turns retain a distinct response boundary, but they use the
diff --git a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs
index b07f532e6..53b032cc9 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/workers/registration.rs
@@ -158,7 +158,11 @@ impl JsContextHost {
.browser_context_runtime()
.allocate_dedicated_worker_instance_id();
self.browser_context_runtime()
- .attach_dedicated_worker_devtools_handle(renderer_instance_id, &worker_handle);
+ .attach_dedicated_worker_devtools_handle(
+ renderer_instance_id,
+ &worker_handle,
+ self.renderer_output_journal(),
+ );
let client_event_producer = self.dedicated_worker_client_event_producer(worker_id, &owner);
Self::start_worker_message_relay(
worker_id,
@@ -544,7 +548,11 @@ impl JsContextHost {
.map(|state| state.renderer_instance_id)
.expect("loading DedicatedWorker must retain its renderer instance identity");
self.browser_context_runtime()
- .attach_dedicated_worker_devtools_handle(renderer_instance_id, &worker_handle);
+ .attach_dedicated_worker_devtools_handle(
+ renderer_instance_id,
+ &worker_handle,
+ self.renderer_output_journal(),
+ );
for message in pending_messages {
worker_handle.post_message(message);
}
diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime.rs
index 83874a1e2..59bfa4b0f 100644
--- a/moli-renderer-v8/src/runtime/browser_context_runtime.rs
+++ b/moli-renderer-v8/src/runtime/browser_context_runtime.rs
@@ -181,12 +181,18 @@ struct RendererBrowserContextRuntimeInner {
next_child_document_loader_id: AtomicU64,
next_detached_parser_script_fetch_id: AtomicU64,
next_dedicated_worker_instance_id: AtomicU64,
- dedicated_worker_devtools_handles: Mutex<HashMap<u64, crate::worker::WorkerDevToolsHandle>>,
+ dedicated_worker_devtools_targets: Mutex<HashMap<u64, DedicatedWorkerDevToolsTarget>>,
dedicated_worker_pause_on_start_for_devtools: AtomicBool,
javascript_dialog_handler_enabled: AtomicBool,
renderer_output_transport_tx: RendererOutputTransportSenderSlot,
}
+#[derive(Clone, Debug)]
+struct DedicatedWorkerDevToolsTarget {
+ handle: crate::worker::WorkerDevToolsHandle,
+ output_journal: Option<super::RendererTurnOutputJournal>,
+}
+
#[derive(Debug)]
struct DetachedParserScriptFetchContinuationInner {
script: PreparedScript,
@@ -309,10 +315,10 @@ impl Drop for RendererBrowserContextRuntimeInner {
}
fn terminate_browser_context_resource_producers(inner: &RendererBrowserContextRuntimeInner) {
- let dedicated_worker_handles =
- std::mem::take(&mut *inner.dedicated_worker_devtools_handles.lock());
- for handle in dedicated_worker_handles.into_values() {
- let _ = handle.terminate_for_devtools();
+ let dedicated_worker_targets =
+ std::mem::take(&mut *inner.dedicated_worker_devtools_targets.lock());
+ for target in dedicated_worker_targets.into_values() {
+ let _ = target.handle.terminate_for_devtools();
}
if let Some(shared_worker_runtime) = inner.shared_worker_runtime.get() {
shared_worker_runtime.terminate_all_for_context_shutdown();
@@ -527,7 +533,7 @@ impl RendererBrowserContextRuntime {
next_child_document_loader_id: AtomicU64::default(),
next_detached_parser_script_fetch_id: AtomicU64::default(),
next_dedicated_worker_instance_id: AtomicU64::default(),
- dedicated_worker_devtools_handles: Mutex::new(HashMap::new()),
+ dedicated_worker_devtools_targets: Mutex::new(HashMap::new()),
dedicated_worker_pause_on_start_for_devtools: AtomicBool::new(false),
javascript_dialog_handler_enabled: AtomicBool::new(false),
renderer_output_transport_tx,
diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs
index a4d0b5d16..9e1bacd9d 100644
--- a/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs
+++ b/moli-renderer-v8/src/runtime/browser_context_runtime/dedicated_workers.rs
@@ -3,7 +3,7 @@ use tokio::sync::oneshot;
use crate::runtime::{RendererRuntimeInspectorMessage, RendererRuntimeInspectorResponseSender};
use crate::worker::{WorkerDevToolsHandle, WorkerHandle};
-use super::RendererBrowserContextRuntime;
+use super::{DedicatedWorkerDevToolsTarget, RendererBrowserContextRuntime};
impl RendererBrowserContextRuntime {
/// Allocates a browser-context-unique identity for one DedicatedWorker
@@ -20,16 +20,20 @@ impl RendererBrowserContextRuntime {
&self,
instance_id: u64,
handle: &WorkerHandle,
+ output_journal: Option<crate::runtime::RendererTurnOutputJournal>,
) {
- self.inner
- .dedicated_worker_devtools_handles
- .lock()
- .insert(instance_id, handle.devtools_handle());
+ self.inner.dedicated_worker_devtools_targets.lock().insert(
+ instance_id,
+ DedicatedWorkerDevToolsTarget {
+ handle: handle.devtools_handle(),
+ output_journal,
+ },
+ );
}
pub(crate) fn unregister_dedicated_worker_devtools_handle(&self, instance_id: u64) {
self.inner
- .dedicated_worker_devtools_handles
+ .dedicated_worker_devtools_targets
.lock()
.remove(&instance_id);
}
@@ -48,7 +52,18 @@ impl RendererBrowserContextRuntime {
fn dedicated_worker_devtools_handle(&self, instance_id: u64) -> Option<WorkerDevToolsHandle> {
self.inner
- .dedicated_worker_devtools_handles
+ .dedicated_worker_devtools_targets
+ .lock()
+ .get(&instance_id)
+ .map(|target| target.handle.clone())
+ }
+
+ fn dedicated_worker_devtools_target(
+ &self,
+ instance_id: u64,
+ ) -> Option<DedicatedWorkerDevToolsTarget> {
+ self.inner
+ .dedicated_worker_devtools_targets
.lock()
.get(&instance_id)
.cloned()
@@ -85,6 +100,40 @@ impl RendererBrowserContextRuntime {
.await
}
+ pub async fn dispatch_dedicated_worker_runtime_protocol_message_with_devtools_session_response(
+ &self,
+ instance_id: u64,
+ inspector_session_id: String,
+ raw_json: String,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {
+ let Some(target) = self.dedicated_worker_devtools_target(instance_id) else {
+ return Err("DedicatedWorkerRuntimeUnavailable".to_owned());
+ };
+ let Some(output_journal) = target.output_journal else {
+ return Err("DedicatedWorkerRuntimeUnavailable".to_owned());
+ };
+ let response = response
+ .route_to_worker_devtools_session_output(inspector_session_id.clone(), output_journal);
+ let settlement = response
+ .take_session_response_settlement_receiver()
+ .expect("a Worker DevTools response must own one settlement receiver");
+ let (response_tx, response_rx) = oneshot::channel();
+ if !target.handle.dispatch_runtime_protocol_message(
+ Some(inspector_session_id),
+ raw_json,
+ Some(response),
+ response_tx,
+ ) {
+ return Err("DedicatedWorkerRuntimeUnavailable".to_owned());
+ }
+ let dispatch = response_rx
+ .await
+ .map_err(|_| "DedicatedWorkerRuntimeUnavailable".to_owned())?;
+ crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch::finish(dispatch, settlement)
+ .await
+ }
+
async fn dispatch_dedicated_worker_runtime_protocol_message_with_optional_deferred_response(
&self,
instance_id: u64,
diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs
index a3a018f93..cb747b447 100644
--- a/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs
+++ b/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs
@@ -414,6 +414,24 @@ impl RendererBrowserContextRuntime {
.await
}
+ pub async fn dispatch_service_worker_runtime_protocol_message_with_devtools_session_response(
+ &self,
+ version_id: u64,
+ inspector_session_id: String,
+ raw_json: String,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {
+ self.inner
+ .service_worker_runtime
+ .dispatch_runtime_protocol_message_with_devtools_session_response(
+ ServiceWorkerVersionId::from_u64_for_binding(version_id),
+ inspector_session_id,
+ raw_json,
+ response,
+ )
+ .await
+ }
+
pub fn detach_service_worker_runtime_inspector_session(
&self,
version_id: u64,
diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs
index 7806dc2c9..f19677784 100644
--- a/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs
+++ b/moli-renderer-v8/src/runtime/browser_context_runtime/shared_workers.rs
@@ -479,6 +479,24 @@ impl RendererBrowserContextRuntime {
.await
}
+ pub async fn dispatch_shared_worker_runtime_protocol_message_with_devtools_session_response(
+ &self,
+ instance_id: SharedWorkerInstanceId,
+ inspector_session_id: String,
+ raw_json: String,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {
+ self.inner
+ .shared_worker_runtime
+ .dispatch_runtime_protocol_message_with_devtools_session_response(
+ instance_id,
+ inspector_session_id,
+ raw_json,
+ response,
+ )
+ .await
+ }
+
pub fn detach_shared_worker_runtime_inspector_session(
&self,
instance_id: SharedWorkerInstanceId,
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index 8972bd1fc..f301b0c93 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -307,7 +307,8 @@ pub use self::page_state::RendererPageState;
use self::page_surface::RendererPageTable;
pub use self::page_surface::RendererRuntimeInspectorMessageResponseOrder;
pub use self::page_surface::{
- DevToolsSessionKey, RendererAccessibilityPayloadsForObjectId, RendererActivityDiagnostics,
+ CompletedWorkerRuntimeInspectorCommandDispatch, DevToolsSessionKey,
+ RendererAccessibilityPayloadsForObjectId, RendererActivityDiagnostics,
RendererAgentAttachmentId, RendererAutofillAddressField, RendererAutofillCreditCard,
RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,
RendererCaptureScreencastFrameReply, RendererCaptureScreenshotReply,
diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rs
index d0d1ee1a1..11d6e225b 100644
--- a/moli-renderer-v8/src/runtime/page_surface.rs
+++ b/moli-renderer-v8/src/runtime/page_surface.rs
@@ -2740,6 +2740,50 @@ impl RendererRuntimeInspectorSessionResponseSettlement {
}
}
+/// Result of one Worker Inspector command whose terminal response was
+/// committed to the target's concrete renderer output stream.
+///
+/// The immediate messages contain only non-terminal Inspector output returned
+/// by dispatch. The response itself is owned by `predecessor` and reaches the
+/// frontend through the same target journal as surrounding Worker events.
+#[derive(Debug)]
+pub struct CompletedWorkerRuntimeInspectorCommandDispatch {
+ messages: Vec<RendererRuntimeInspectorMessage>,
+ predecessor: RendererOutputFence,
+ response_succeeded: bool,
+}
+
+impl CompletedWorkerRuntimeInspectorCommandDispatch {
+ pub fn into_parts(
+ self,
+ ) -> (
+ Vec<RendererRuntimeInspectorMessage>,
+ RendererOutputFence,
+ bool,
+ ) {
+ (self.messages, self.predecessor, self.response_succeeded)
+ }
+
+ pub(crate) async fn finish(
+ dispatch: Result<Vec<RendererRuntimeInspectorMessage>, String>,
+ settlement: oneshot::Receiver<RendererRuntimeInspectorSessionResponseSettlement>,
+ ) -> Result<Self, String> {
+ match settlement.await {
+ Ok(settlement) => {
+ let (predecessor, response_succeeded) = settlement.into_parts();
+ Ok(Self {
+ messages: dispatch.unwrap_or_default(),
+ predecessor,
+ response_succeeded,
+ })
+ }
+ Err(_) => Err(dispatch
+ .err()
+ .unwrap_or_else(|| "WorkerRuntimeInspectorResponseCanceled".to_owned())),
+ }
+ }
+}
+
impl RendererRuntimeInspectorResponsePublication {
pub(crate) fn commit(
self,
@@ -3248,7 +3292,7 @@ impl RendererRuntimeInspectorResponseLease {
pub(crate) struct RendererDevToolsSessionOutputHost {
agent_token: RendererDevToolsAgentToken,
session: DevToolsSessionKey,
- attachment_id: RendererAgentAttachmentId,
+ attachment_id: Option<RendererAgentAttachmentId>,
output_journal: RendererTurnOutputJournal,
}
@@ -3262,7 +3306,16 @@ impl RendererDevToolsSessionOutputHost {
Self {
agent_token,
session,
- attachment_id,
+ attachment_id: Some(attachment_id),
+ output_journal,
+ }
+ }
+
+ fn for_worker(session_id: String, output_journal: RendererTurnOutputJournal) -> Self {
+ Self {
+ agent_token: output_journal.stream().renderer_agent(),
+ session: DevToolsSessionKey::Attached(session_id),
+ attachment_id: None,
output_journal,
}
}
@@ -3271,7 +3324,7 @@ impl RendererDevToolsSessionOutputHost {
&self,
completion: RendererRuntimeInspectorAsyncCompletion,
) -> Result<RendererOutputFence, RendererRuntimeInspectorAsyncCompletion> {
- if completion.renderer_agent_attachment_id() != Some(self.attachment_id) {
+ if completion.renderer_agent_attachment_id() != self.attachment_id {
return Err(completion);
}
if completion
@@ -3293,7 +3346,9 @@ impl RendererDevToolsSessionOutputHost {
messages,
);
batch.v8_state_update = v8_state_update;
- batch.bind_renderer_agent_attachment(self.attachment_id);
+ if let Some(attachment_id) = self.attachment_id {
+ batch.bind_renderer_agent_attachment(attachment_id);
+ }
if !batch.has_resolved_source_identities() {
return Err(completion);
}
@@ -3384,7 +3439,7 @@ impl RendererRuntimeInspectorResponseDestination {
enum RendererRuntimeInspectorResponsePublicationBoundary {
Immediate,
PageOwner(RendererOwnerWakeSender),
- SharedWorkerParent(tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerToParentMessage>),
+ WorkerParent(tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerToParentMessage>),
}
#[derive(Clone)]
@@ -3468,12 +3523,12 @@ impl RendererRuntimeInspectorResponseSender {
self
}
- pub(crate) fn defer_publication_to_shared_worker_parent(
+ pub(crate) fn defer_publication_to_worker_parent(
mut self,
parent_tx: tokio::sync::mpsc::UnboundedSender<crate::worker::WorkerToParentMessage>,
) -> Self {
self.publication_boundary =
- RendererRuntimeInspectorResponsePublicationBoundary::SharedWorkerParent(parent_tx);
+ RendererRuntimeInspectorResponsePublicationBoundary::WorkerParent(parent_tx);
self
}
@@ -3484,8 +3539,7 @@ impl RendererRuntimeInspectorResponseSender {
host: RendererDevToolsSessionOutputHost,
) -> Self {
assert_eq!(
- self.attachment_id,
- Some(host.attachment_id),
+ self.attachment_id, host.attachment_id,
"a DevTools session response host must belong to the command attachment"
);
self.destination = match self.destination {
@@ -3502,6 +3556,17 @@ impl RendererRuntimeInspectorResponseSender {
self
}
+ pub(crate) fn route_to_worker_devtools_session_output(
+ self,
+ session_id: String,
+ output_journal: RendererTurnOutputJournal,
+ ) -> Self {
+ self.route_to_devtools_session_output(RendererDevToolsSessionOutputHost::for_worker(
+ session_id,
+ output_journal,
+ ))
+ }
+
pub fn send(self, message: Value) -> Result<(), RendererRuntimeInspectorAsyncCompletion> {
self.send_output(RendererRuntimeCommandOutput::from_inspector_message(
RendererRuntimeInspectorMessage::from_v8_inspector_message(message),
@@ -3533,16 +3598,15 @@ impl RendererRuntimeInspectorResponseSender {
RendererRuntimeInspectorResponsePublicationBoundary::PageOwner(owner_wake) => {
owner_wake.defer_runtime_inspector_response_publication(publication)
}
- RendererRuntimeInspectorResponsePublicationBoundary::SharedWorkerParent(parent_tx) => {
+ RendererRuntimeInspectorResponsePublicationBoundary::WorkerParent(parent_tx) => {
match parent_tx.send(
- crate::worker::WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(
- publication,
- ),
+ crate::worker::WorkerToParentMessage::RuntimeInspectorResponse(publication),
) {
Ok(()) => Ok(()),
Err(error) => {
- let crate::worker::WorkerToParentMessage::
- SharedWorkerRuntimeInspectorResponse(publication) = error.0
+ let crate::worker::WorkerToParentMessage::RuntimeInspectorResponse(
+ publication,
+ ) = error.0
else {
unreachable!("the failed send must return the submitted publication")
};
diff --git a/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs b/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs
index 3c0f436bd..f3121fbf8 100644
--- a/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs
+++ b/moli-renderer-v8/src/script_vm/worker_host_bridge_body.rs
@@ -286,6 +286,27 @@ impl ScriptVm {
instance_id,
message,
} => self.apply_shared_worker_host_bridge_record_body(instance_id, *message),
+ WorkerRuntimeEvent::Message {
+ message,
+ worker_id: _,
+ } if matches!(
+ message.as_ref(),
+ WorkerToParentMessage::RuntimeInspectorResponse(_)
+ ) =>
+ {
+ let WorkerToParentMessage::RuntimeInspectorResponse(publication) = *message else {
+ unreachable!("the guarded Worker response variant must still match")
+ };
+ let published = self
+ ._context_host
+ .borrow()
+ .publish_worker_runtime_inspector_response(publication);
+ Ok(if published {
+ WorkerHostBridgeBodyEffect::StateAppliedWithoutPageContext
+ } else {
+ WorkerHostBridgeBodyEffect::ExactTargetUnavailable
+ })
+ }
WorkerRuntimeEvent::Message { worker_id, message } => {
self.apply_dedicated_worker_host_bridge_record_body(worker_id, *message)
}
@@ -470,7 +491,7 @@ impl ScriptVm {
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
| WorkerToParentMessage::SharedWorkerClosed
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_) => {}
+ | WorkerToParentMessage::RuntimeInspectorResponse(_) => {}
}
Ok(())
}
diff --git a/moli-renderer-v8/src/service_worker_runtime/host.rs b/moli-renderer-v8/src/service_worker_runtime/host.rs
index e7ea573da..d355365b3 100644
--- a/moli-renderer-v8/src/service_worker_runtime/host.rs
+++ b/moli-renderer-v8/src/service_worker_runtime/host.rs
@@ -854,9 +854,11 @@ fn spawn_parent_message_pump(
messages,
);
}
+ WorkerToParentMessage::RuntimeInspectorResponse(publication) => {
+ let _ = publication.commit(None);
+ }
WorkerToParentMessage::Post(_)
| WorkerToParentMessage::SharedWorkerClosed
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
| WorkerToParentMessage::SubresourceNetwork(_)
| WorkerToParentMessage::PendingSubresourceFetch(_)
| WorkerToParentMessage::PendingSubresourceFetchCanceled { .. }
diff --git a/moli-renderer-v8/src/service_worker_runtime/service.rs b/moli-renderer-v8/src/service_worker_runtime/service.rs
index d422a4ed9..ca90c8ddc 100644
--- a/moli-renderer-v8/src/service_worker_runtime/service.rs
+++ b/moli-renderer-v8/src/service_worker_runtime/service.rs
@@ -385,6 +385,13 @@ impl ServiceWorkerRuntimeService {
Some(host.clone())
}
+ pub(super) fn target_output_journal(
+ &self,
+ version_id: ServiceWorkerVersionId,
+ ) -> Option<crate::runtime::RendererTurnOutputJournal> {
+ self.inner.state.lock().target_output_journal(version_id)
+ }
+
pub(super) fn enqueue_target_console_message(
&self,
version_id: ServiceWorkerVersionId,
diff --git a/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rs b/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rs
index 3761766a3..c18a9dea9 100644
--- a/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rs
+++ b/moli-renderer-v8/src/service_worker_runtime/service/runtime_protocol.rs
@@ -38,6 +38,35 @@ impl ServiceWorkerRuntimeService {
.await
}
+ pub(crate) async fn dispatch_runtime_protocol_message_with_devtools_session_response(
+ &self,
+ version_id: ServiceWorkerVersionId,
+ inspector_session_id: String,
+ raw_json: String,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {
+ let Some(host) = self.running_host_for_version(version_id) else {
+ return Err("ServiceWorkerRuntimeUnavailable".to_owned());
+ };
+ let Some(output_journal) = self.target_output_journal(version_id) else {
+ return Err("ServiceWorkerRuntimeUnavailable".to_owned());
+ };
+ let response = response
+ .route_to_worker_devtools_session_output(inspector_session_id.clone(), output_journal);
+ let settlement = response
+ .take_session_response_settlement_receiver()
+ .expect("a Worker DevTools response must own one settlement receiver");
+ let dispatch = host
+ .dispatch_worker_runtime_protocol_message_with_deferred_response(
+ Some(inspector_session_id),
+ raw_json,
+ response,
+ )
+ .await;
+ crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch::finish(dispatch, settlement)
+ .await
+ }
+
pub(crate) fn detach_runtime_inspector_session(
&self,
version_id: ServiceWorkerVersionId,
diff --git a/moli-renderer-v8/src/service_worker_runtime/state.rs b/moli-renderer-v8/src/service_worker_runtime/state.rs
index ae9560b69..bb397bde3 100644
--- a/moli-renderer-v8/src/service_worker_runtime/state.rs
+++ b/moli-renderer-v8/src/service_worker_runtime/state.rs
@@ -355,6 +355,13 @@ impl ServiceWorkerRuntimeState {
self.live_target_run(version_id).as_ref() == Some(run)
}
+ pub(super) fn target_output_journal(
+ &self,
+ version_id: ServiceWorkerVersionId,
+ ) -> Option<crate::runtime::RendererTurnOutputJournal> {
+ self.target_output_streams.journal(version_id)
+ }
+
pub(super) fn record_target_created(
&mut self,
registration_id: ServiceWorkerRegistrationId,
diff --git a/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rs b/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rs
index 9539d4770..02c82daf4 100644
--- a/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rs
+++ b/moli-renderer-v8/src/service_worker_runtime/target_output_streams.rs
@@ -92,6 +92,13 @@ impl ServiceWorkerTargetOutputStreams {
journal.publish_record(Self::record(event));
}
+ pub(super) fn journal(
+ &self,
+ version_id: ServiceWorkerVersionId,
+ ) -> Option<RendererTurnOutputJournal> {
+ self.state.lock().live.get(&version_id).cloned()
+ }
+
pub(super) fn publish_destroyed(
&self,
version_id: ServiceWorkerVersionId,
diff --git a/moli-renderer-v8/src/shared_worker_runtime/events.rs b/moli-renderer-v8/src/shared_worker_runtime/events.rs
index dffbb5090..bc81e89af 100644
--- a/moli-renderer-v8/src/shared_worker_runtime/events.rs
+++ b/moli-renderer-v8/src/shared_worker_runtime/events.rs
@@ -52,7 +52,7 @@ impl RendererSharedWorkerHost {
self.begin_runtime_response_retirement();
self.notify_worker_closed();
}
- WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(publication) => {
+ WorkerToParentMessage::RuntimeInspectorResponse(publication) => {
self.publish_runtime_inspector_response(publication);
}
WorkerToParentMessage::ServiceWorkerLifecycleCompleted(_) => {
diff --git a/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rs b/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rs
index 9d470368e..92b577da0 100644
--- a/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rs
+++ b/moli-renderer-v8/src/shared_worker_runtime/protocol_routing.rs
@@ -36,6 +36,34 @@ impl SharedWorkerRuntimeService {
.await
}
+ pub(crate) async fn dispatch_runtime_protocol_message_with_devtools_session_response(
+ &self,
+ instance_id: SharedWorkerInstanceId,
+ inspector_session_id: String,
+ raw_json: String,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> Result<crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch, String> {
+ let Some(host) = self.running_host_for_instance(instance_id) else {
+ return Err("SharedWorkerRuntimeUnavailable".to_owned());
+ };
+ let response = response.route_to_worker_devtools_session_output(
+ inspector_session_id.clone(),
+ host.target_output().clone(),
+ );
+ let settlement = response
+ .take_session_response_settlement_receiver()
+ .expect("a Worker DevTools response must own one settlement receiver");
+ let dispatch = host
+ .dispatch_runtime_protocol_message_with_deferred_response(
+ Some(inspector_session_id),
+ raw_json,
+ response,
+ )
+ .await;
+ crate::runtime::CompletedWorkerRuntimeInspectorCommandDispatch::finish(dispatch, settlement)
+ .await
+ }
+
pub(crate) fn detach_runtime_inspector_session(
&self,
instance_id: SharedWorkerInstanceId,
diff --git a/moli-renderer-v8/src/worker/handle.rs b/moli-renderer-v8/src/worker/handle.rs
index 53e883c4b..91e00e446 100644
--- a/moli-renderer-v8/src/worker/handle.rs
+++ b/moli-renderer-v8/src/worker/handle.rs
@@ -289,16 +289,14 @@ pub(crate) enum WorkerToParentMessage {
Console(WorkerConsoleMessage),
/// A SharedWorker global is closing and its owner service should remove the instance.
SharedWorkerClosed,
- /// A SharedWorker V8 Inspector response waiting for the worker target's
- /// concrete output boundary.
+ /// A V8 Inspector response waiting for its Worker target's concrete output
+ /// boundary.
///
- /// This travels on the same worker-to-parent FIFO as `SharedWorkerClosed`.
- /// The host can therefore bind the response to the exact worker-stream
- /// cursor that precedes it instead of racing a separate response channel
- /// against target retirement.
- SharedWorkerRuntimeInspectorResponse(
- crate::runtime::RendererRuntimeInspectorResponsePublication,
- ),
+ /// This travels on the same worker-to-parent FIFO as lifecycle and runtime
+ /// observations. The host can therefore bind the response to the exact
+ /// target-stream cursor that precedes it instead of racing a separate
+ /// response channel against target retirement.
+ RuntimeInspectorResponse(crate::runtime::RendererRuntimeInspectorResponsePublication),
/// A Service Worker lifecycle event finished dispatch and all `waitUntil()` promises.
ServiceWorkerLifecycleCompleted(ServiceWorkerLifecycleCompletion),
/// A Service Worker fetch event finished dispatch and `respondWith()` settled or fell back.
diff --git a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
index 41711872d..2c61d4701 100644
--- a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
+++ b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
@@ -526,13 +526,16 @@ impl WorkerRuntimeInspector {
deferred_response,
response_tx,
} => {
- let deferred_response = if self.shared_worker {
- deferred_response.map(|response| {
- response.defer_publication_to_shared_worker_parent(self.parent_tx.clone())
- })
- } else {
- deferred_response
- };
+ let deferred_response = deferred_response.map(|response| {
+ if self.shared_worker
+ || response.response_delivery()
+ == moli_page_types::RendererInspectorResponseDelivery::DevToolsSession
+ {
+ response.defer_publication_to_worker_parent(self.parent_tx.clone())
+ } else {
+ response
+ }
+ });
let result = with_scoped_inspector_microtasks(isolate, || {
self.dispatch_protocol_message_scoped(
inspector_session_id.as_deref(),
diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
index 7ba4c1be6..f70ea2a41 100644
--- a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
@@ -1855,7 +1855,7 @@ async fn dispatch_service_worker_fetch_event_and_handled_console_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
if let (Some(completion), Some(handled_console)) =
@@ -2253,7 +2253,7 @@ async fn service_worker_fetch_respond_with_readable_stream_body_posts_stream_chu
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -4262,7 +4262,7 @@ async fn service_worker_skip_waiting_posts_runtime_request() {
| WorkerToParentMessage::Console(_)
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -4352,7 +4352,7 @@ async fn service_worker_clients_claim_posts_runtime_request() {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -4620,7 +4620,7 @@ async fn service_worker_clients_match_all_and_get_resolve_from_parent_query_resu
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -4739,7 +4739,7 @@ async fn service_worker_worker_client_query_builds_base_client_object() {
}
WorkerToParentMessage::Console(_)
| WorkerToParentMessage::RuntimeInspectorMessages(_)
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
other => panic!("unexpected worker message: {other:?}"),
}
@@ -4929,7 +4929,7 @@ self.addEventListener("message", event => {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -5073,7 +5073,7 @@ self.addEventListener("message", event => {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -5285,7 +5285,7 @@ self.addEventListener("message", event => {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -5429,7 +5429,7 @@ self.addEventListener("message", event => {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -5646,7 +5646,7 @@ self.addEventListener("message", event => {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
WorkerToParentMessage::ServiceWorkerClientsOpenWindow(open_window) => {
panic!(
@@ -7098,7 +7098,7 @@ self.addEventListener("notificationclick", event => {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -7258,7 +7258,7 @@ self.addEventListener("notificationclose", event => {
| WorkerToParentMessage::RuntimeInspectorMessages(_)
| WorkerToParentMessage::Post(_)
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -9467,7 +9467,7 @@ async fn worker_error_report_ignores_throwing_accessors() {
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => panic!("expected worker error"),
}
}
diff --git a/moli-renderer-v8/src/worker/thread/tests/mod.rs b/moli-renderer-v8/src/worker/thread/tests/mod.rs
index 513bedaaf..bd002398f 100644
--- a/moli-renderer-v8/src/worker/thread/tests/mod.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/mod.rs
@@ -368,7 +368,7 @@ async fn dispatch_service_worker_lifecycle_event_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -464,7 +464,7 @@ async fn dispatch_service_worker_fetch_event_with_request_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -550,7 +550,7 @@ async fn dispatch_service_worker_message_event_object_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -613,7 +613,7 @@ async fn dispatch_service_worker_notification_event_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -682,7 +682,7 @@ async fn dispatch_service_worker_push_event_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -753,7 +753,7 @@ async fn dispatch_service_worker_sync_event_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}
@@ -825,7 +825,7 @@ async fn dispatch_service_worker_periodic_sync_event_for_test(
| WorkerToParentMessage::ServiceWorkerSkipWaiting { .. }
| WorkerToParentMessage::ServiceWorkerClientsClaim { .. }
| WorkerToParentMessage::ServiceWorkerImportedScriptLoaded { .. }
- | WorkerToParentMessage::SharedWorkerRuntimeInspectorResponse(_)
+ | WorkerToParentMessage::RuntimeInspectorResponse(_)
| WorkerToParentMessage::SharedWorkerClosed => {}
}
}