Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor: split inspector IO dispatch from page owner

ldm0310b886f511d
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rs
index 5baeb00d1..fe8311082 100644
--- a/moli-core/src/page/command_dispatch.rs
+++ b/moli-core/src/page/command_dispatch.rs
@@ -12,8 +12,12 @@ pub struct PendingPageCommand {
}
pub struct PendingRuntimeInspectorCommandDispatch {
- route: RendererRuntimeInspectorCommandRoute,
- owner_pending: Option<PendingPageCommand>,
+ kind: PendingRuntimeInspectorCommandDispatchKind,
+}
+
+enum PendingRuntimeInspectorCommandDispatchKind {
+ MainThread(PendingPageCommand),
+ Io(RendererRuntimeInspectorCommandRoute),
}
/// Identifies which execution owner consumed one routable Inspector command.
@@ -85,15 +89,24 @@ impl CompletedPageCommand {
impl Page {
pub(crate) fn start_page_command(
&self,
- command: RendererPageCommand,
+ mut command: RendererPageCommand,
) -> Result<PendingPageCommand> {
+ if let Some(attachment_id) = self.renderer_agent_attachment_id {
+ command.bind_inspector_attachment(attachment_id);
+ }
Ok(PendingPageCommand {
pending: self.handle.enqueue_protocol_command(command)?,
renderer_agent_attachment_id: self.renderer_agent_attachment_id,
})
}
- fn start_full_page_command(&self, command: RendererPageCommand) -> Result<PendingPageCommand> {
+ fn start_full_page_command(
+ &self,
+ mut command: RendererPageCommand,
+ ) -> Result<PendingPageCommand> {
+ if let Some(attachment_id) = self.renderer_agent_attachment_id {
+ command.bind_inspector_attachment(attachment_id);
+ }
Ok(PendingPageCommand {
pending: self.handle.enqueue_async_command(command)?,
renderer_agent_attachment_id: self.renderer_agent_attachment_id,
@@ -108,14 +121,26 @@ impl Page {
completion.output
}
- pub(crate) fn pending_runtime_inspector_command_dispatch(
+ fn pending_runtime_inspector_command_dispatch(
+ kind: PendingRuntimeInspectorCommandDispatchKind,
+ ) -> PendingRuntimeInspectorCommandDispatch {
+ PendingRuntimeInspectorCommandDispatch { kind }
+ }
+
+ pub(crate) fn pending_main_thread_runtime_inspector_command_dispatch(
+ pending: PendingPageCommand,
+ ) -> PendingRuntimeInspectorCommandDispatch {
+ Self::pending_runtime_inspector_command_dispatch(
+ PendingRuntimeInspectorCommandDispatchKind::MainThread(pending),
+ )
+ }
+
+ pub(crate) fn pending_io_runtime_inspector_command_dispatch(
route: RendererRuntimeInspectorCommandRoute,
- owner_pending: Option<PendingPageCommand>,
) -> PendingRuntimeInspectorCommandDispatch {
- PendingRuntimeInspectorCommandDispatch {
- route,
- owner_pending,
- }
+ Self::pending_runtime_inspector_command_dispatch(
+ PendingRuntimeInspectorCommandDispatchKind::Io(route),
+ )
}
pub(crate) fn finish_page_command(
@@ -339,53 +364,14 @@ impl PendingPageCommand {
impl PendingRuntimeInspectorCommandDispatch {
pub async fn wait(self) -> Result<CompletedRuntimeInspectorCommandDispatch> {
- let Self {
- route,
- owner_pending,
- } = self;
- let Some(owner_pending) = owner_pending else {
- let claim = route.wait_for_claim().await.map_err(anyhow::Error::msg)?;
- return match claim {
- RendererRuntimeInspectorCommandClaim::Owner => Err(anyhow::anyhow!(
- "runtime inspector command was claimed by owner without an owner task"
- )),
- RendererRuntimeInspectorCommandClaim::Inspector => {
- Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)
- }
- RendererRuntimeInspectorCommandClaim::Canceled => {
- Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)
- }
- };
- };
-
- let mut claim = Box::pin(route.wait_for_claim());
- let mut owner = Box::pin(owner_pending.wait());
- tokio::select! {
- biased;
- claim = &mut claim => {
- let claim = claim.map_err(anyhow::Error::msg)?;
- match claim {
- RendererRuntimeInspectorCommandClaim::Owner => owner
- .await
- .map(Box::new)
- .map(CompletedRuntimeInspectorCommandDispatch::Owner),
- RendererRuntimeInspectorCommandClaim::Inspector => {
- Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)
- }
- RendererRuntimeInspectorCommandClaim::Canceled => {
- Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)
- }
- }
- }
- owner = &mut owner => {
- let completion = owner?;
- let claim = claim.await.map_err(anyhow::Error::msg)?;
- match claim {
- RendererRuntimeInspectorCommandClaim::Owner => {
- Ok(CompletedRuntimeInspectorCommandDispatch::Owner(Box::new(
- completion,
- )))
- }
+ match self.kind {
+ PendingRuntimeInspectorCommandDispatchKind::MainThread(pending) => pending
+ .wait()
+ .await
+ .map(Box::new)
+ .map(CompletedRuntimeInspectorCommandDispatch::Owner),
+ PendingRuntimeInspectorCommandDispatchKind::Io(route) => {
+ match route.wait_for_claim().await.map_err(anyhow::Error::msg)? {
RendererRuntimeInspectorCommandClaim::Inspector => {
Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)
}
diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rs
index 3f978c5df..0e749fca6 100644
--- a/moli-core/src/page/js_evaluation.rs
+++ b/moli-core/src/page/js_evaluation.rs
@@ -16,7 +16,8 @@ use crate::RendererOutputFence;
use crate::renderer::{
RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListenerBreakpoint,
RendererDomDebuggerEventListenersResolution, RendererDomDebuggerXhrBreakpoint,
- RendererInspectorCommandRoute, RendererPageCommand, RendererPageReply,
+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
+ RendererInspectorIngressTicket, RendererPageCommand, RendererPageReply,
RendererPerformanceMetricSnapshot, RendererRuntimeHeapUsage,
RendererRuntimeInspectorResponseSender,
};
@@ -473,35 +474,10 @@ impl Page {
&self,
inspector_session_id: Option<String>,
raw_json: String,
- ) -> Result<PendingPageCommand> {
- self.start_runtime_protocol_message_for_inspector_session_with_route(
- inspector_session_id,
- RendererInspectorCommandRoute::MainThread,
- raw_json,
- )
- }
-
- pub fn start_runtime_interrupt_protocol_message_for_inspector_session(
- &self,
- inspector_session_id: Option<String>,
- raw_json: String,
- ) -> Result<PendingPageCommand> {
- self.start_runtime_protocol_message_for_inspector_session_with_route(
- inspector_session_id,
- RendererInspectorCommandRoute::Io,
- raw_json,
- )
- }
-
- fn start_runtime_protocol_message_for_inspector_session_with_route(
- &self,
- inspector_session_id: Option<String>,
- route: RendererInspectorCommandRoute,
- raw_json: String,
) -> Result<PendingPageCommand> {
self.start_page_command(RendererPageCommand::dispatch_runtime_protocol_message(
inspector_session_id,
- route,
+ RendererInspectorCommandRoute::MainThread,
raw_json,
))
}
@@ -523,26 +499,11 @@ impl Page {
inspector_session_id: Option<String>,
raw_json: String,
deferred_response: RendererRuntimeInspectorResponseSender,
- ) -> Result<PendingPageCommand> {
- self.start_runtime_protocol_message_for_inspector_session_with_deferred_response_and_route(
- inspector_session_id,
- RendererInspectorCommandRoute::MainThread,
- raw_json,
- deferred_response,
- )
- }
-
- fn start_runtime_protocol_message_for_inspector_session_with_deferred_response_and_route(
- &self,
- inspector_session_id: Option<String>,
- route: RendererInspectorCommandRoute,
- raw_json: String,
- deferred_response: RendererRuntimeInspectorResponseSender,
) -> Result<PendingPageCommand> {
self.start_page_command(
RendererPageCommand::dispatch_runtime_protocol_message_with_deferred_response(
inspector_session_id,
- route,
+ RendererInspectorCommandRoute::MainThread,
raw_json,
deferred_response,
),
@@ -557,36 +518,65 @@ impl Page {
raw_json: String,
deferred_response: RendererRuntimeInspectorResponseSender,
) -> Result<PendingRuntimeInspectorCommandDispatch> {
- let route = self.handle.enqueue_routable_runtime_inspector_command(
- inspector_session_id,
- inspector_route,
- owner_context_resolution_action,
- raw_json,
- deferred_response,
- );
- let owner_pending = if route.requires_owner_fallback() {
- let command_id = route.command_id();
- let command = RendererPageCommand::dispatch_queued_runtime_inspector_command(
- route.metadata().clone(),
- command_id,
- );
- match self.start_page_command(command) {
- Ok(pending) => Some(pending),
- Err(error) => {
- self.handle.cancel_queued_runtime_inspector_command(
- command_id,
- "Failed to enqueue runtime inspector owner command",
- );
- return Err(error);
+ match inspector_route {
+ RendererInspectorCommandRoute::MainThread => {
+ let command = match owner_context_resolution_action {
+ Some(action) => RendererPageCommand::dispatch_runtime_protocol_message_with_context_resolution_and_deferred_response(
+ inspector_session_id,
+ RendererInspectorCommandRoute::MainThread,
+ action,
+ raw_json,
+ deferred_response,
+ ),
+ None => RendererPageCommand::dispatch_runtime_protocol_message_with_deferred_response(
+ inspector_session_id,
+ RendererInspectorCommandRoute::MainThread,
+ raw_json,
+ deferred_response,
+ ),
+ };
+ self.start_page_command(command)
+ .map(Self::pending_main_thread_runtime_inspector_command_dispatch)
+ }
+ RendererInspectorCommandRoute::Io => {
+ if owner_context_resolution_action.is_some() {
+ return Err(anyhow!(
+ "an IO Inspector command cannot require Page owner context resolution"
+ ));
}
+ let route = self.handle.enqueue_runtime_inspector_io_command(
+ RendererInspectorCommandEnvelope::new_io(
+ RendererInspectorIngressTicket::new(
+ self.renderer_agent_attachment_id,
+ inspector_session_id,
+ RendererInspectorCommandRoute::Io,
+ ),
+ raw_json,
+ Some(deferred_response),
+ ),
+ );
+ Ok(Self::pending_io_runtime_inspector_command_dispatch(route))
}
- } else {
- None
- };
- Ok(Self::pending_runtime_inspector_command_dispatch(
- route,
- owner_pending,
- ))
+ }
+ }
+
+ pub fn start_runtime_inspector_io_message_without_response(
+ &self,
+ inspector_session_id: Option<String>,
+ raw_json: String,
+ ) -> Result<PendingRuntimeInspectorCommandDispatch> {
+ let route = self.handle.enqueue_runtime_inspector_io_command(
+ RendererInspectorCommandEnvelope::new_io(
+ RendererInspectorIngressTicket::new(
+ self.renderer_agent_attachment_id,
+ inspector_session_id,
+ RendererInspectorCommandRoute::Io,
+ ),
+ raw_json,
+ None,
+ ),
+ );
+ Ok(Self::pending_io_runtime_inspector_command_dispatch(route))
}
pub fn runtime_inspector_pause_active(&self) -> bool {
diff --git a/moli-core/src/renderer.rs b/moli-core/src/renderer.rs
index ba7685fbe..d23e60d62 100644
--- a/moli-core/src/renderer.rs
+++ b/moli-core/src/renderer.rs
@@ -17,7 +17,8 @@ pub(crate) use moli_renderer_v8::{
RendererDomDebuggerDomBreakpointResolution, RendererDomDebuggerEventListenerBreakpoint,
RendererDomDebuggerEventListenersResolution, RendererDomDebuggerXhrBreakpoint,
RendererDomFocusOutcome, RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload,
- RendererInspectorCommandRoute, RendererLayoutMetrics, RendererOwnerCommand,
+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
+ RendererInspectorIngressTicket, RendererLayoutMetrics, RendererOwnerCommand,
RendererOwnerHandle, RendererOwnerReply, RendererPageCommand, RendererPageCommandPending,
RendererPageCookieFacadeSnapshotReply, RendererPageDumpOptions, RendererPageHandle,
RendererPageReply, RendererPageState, RendererPendingDownloadActivation,
diff --git a/moli-page-types/src/inspector_identity.rs b/moli-page-types/src/inspector_identity.rs
index 5d051e19f..e4c3992ab 100644
--- a/moli-page-types/src/inspector_identity.rs
+++ b/moli-page-types/src/inspector_identity.rs
@@ -29,7 +29,7 @@ impl DevToolsSessionKey {
}
}
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RendererDevToolsAgentToken(NonZeroU64);
impl RendererDevToolsAgentToken {
diff --git a/moli-protocol-server/src/protocol_server/tests/websocket.rs b/moli-protocol-server/src/protocol_server/tests/websocket.rs
index a9df91f13..61204bd66 100644
--- a/moli-protocol-server/src/protocol_server/tests/websocket.rs
+++ b/moli-protocol-server/src/protocol_server/tests/websocket.rs
@@ -1607,6 +1607,18 @@ async fn websocket_cdp_io_terminate_interrupts_busy_main_thread_and_skips_main_f
json!(42),
"the skipped MainThread follower must run normally after termination: {observed:#?}"
);
+ let terminate_response_index = observed
+ .iter()
+ .position(|message| message["id"] == json!(10_u64))
+ .expect("terminateExecution response position");
+ let follower_response_index = observed
+ .iter()
+ .position(|message| message["id"] == json!(9_u64))
+ .expect("MainThread follower response position");
+ assert!(
+ terminate_response_index < follower_response_index,
+ "the MainThread follower must not first-dispatch ahead of IO termination: {observed:#?}"
+ );
let _ = socket.close(None).await;
abort_test_cdp_server(protocol_server).await;
@@ -5010,7 +5022,7 @@ async fn websocket_cdp_fetch_routes_pending_background_parser_script_to_exact_se
}
#[tokio::test]
-async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_pause() {
+async fn websocket_cdp_debugger_step_out_main_thread_waits_for_io_resume() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
@@ -5076,64 +5088,50 @@ async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_paus
json!("inner")
);
- let mut stepped = send_cdp_command(
+ socket
+ .send(WsMessage::Text(
+ json!({
+ "id": 6_u64,
+ "method": "Debugger.stepOut",
+ "sessionId": session_id,
+ "params": {}
+ })
+ .to_string()
+ .into(),
+ ))
+ .await
+ .expect("queue MainThread Debugger.stepOut while paused");
+
+ // Chromium routes step controls over its main DevToolsSession, not its IO
+ // session. Moli's Page owner is still inside the Runtime.evaluate that
+ // entered this pause, so the step command must remain queued until the IO
+ // resume releases that owner call.
+ let resumed = send_cdp_command(
&mut socket,
- 6,
- "Debugger.stepOut",
+ 7,
+ "Debugger.resume",
Some(&session_id),
json!({}),
)
.await;
- if !stepped.iter().any(|message| {
- message["method"] == json!("Debugger.paused")
- && message["params"]["reason"] == json!("step")
- && message["params"]["callFrames"][0]["functionName"] == json!("outer")
- }) {
- stepped.extend(
+ assert!(
+ resumed.iter().all(|message| message["id"] != json!(6_u64)),
+ "MainThread stepOut must not dispatch from the IO-only pause loop: {resumed:#?}"
+ );
+ observed.extend(resumed);
+
+ let mut saw_evaluate_response = observed.iter().any(|message| message["id"] == json!(5_u64));
+ let mut saw_step_response = observed.iter().any(|message| message["id"] == json!(6_u64));
+ if !saw_evaluate_response || !saw_step_response {
+ observed.extend(
recv_until_match(&mut socket, |message| {
- message["sessionId"].as_str() == Some(session_id.as_str())
- && message["method"] == json!("Debugger.paused")
- && message["params"]["reason"] == json!("step")
- && message["params"]["callFrames"][0]["functionName"] == json!("outer")
+ saw_evaluate_response |= message["id"] == json!(5_u64);
+ saw_step_response |= message["id"] == json!(6_u64);
+ saw_evaluate_response && saw_step_response
})
.await,
);
}
- let response_position = stepped
- .iter()
- .position(|message| message["id"] == json!(6_u64))
- .expect("stepOut should respond");
- let resumed_position = stepped
- .iter()
- .position(|message| message["method"] == json!("Debugger.resumed"))
- .expect("stepOut should emit Debugger.resumed");
- let caller_pause_position = stepped
- .iter()
- .position(|message| {
- message["method"] == json!("Debugger.paused")
- && message["params"]["reason"] == json!("step")
- && message["params"]["callFrames"][0]["functionName"] == json!("outer")
- })
- .expect("stepOut should pause in the caller");
- assert!(
- response_position < resumed_position && resumed_position < caller_pause_position,
- "stepOut must preserve response -> resumed -> caller pause: {stepped:#?}"
- );
-
- observed.extend(
- send_cdp_command(
- &mut socket,
- 7,
- "Debugger.resume",
- Some(&session_id),
- json!({}),
- )
- .await,
- );
- if !observed.iter().any(|message| message["id"] == json!(5_u64)) {
- observed
- .extend(recv_until_match(&mut socket, |message| message["id"] == json!(5_u64)).await);
- }
let evaluate = observed
.iter()
.find(|message| message["id"] == json!(5_u64))
@@ -5143,13 +5141,33 @@ async fn websocket_cdp_debugger_step_out_responds_before_resumed_and_caller_paus
json!(42),
"resuming the exact pause must return to the blocked Runtime command: {observed:#?}"
);
+ let step = observed
+ .iter()
+ .find(|message| message["id"] == json!(6_u64))
+ .expect("queued stepOut response after resume");
+ assert!(
+ step.get("error").is_some(),
+ "stepOut reaches V8 only after execution is no longer paused: {observed:#?}"
+ );
+ let resume_position = observed
+ .iter()
+ .position(|message| message["id"] == json!(7_u64))
+ .expect("IO resume response position");
+ let step_position = observed
+ .iter()
+ .position(|message| message["id"] == json!(6_u64))
+ .expect("MainThread stepOut response position");
+ assert!(
+ resume_position < step_position,
+ "IO resume must overtake the queued MainThread stepOut: {observed:#?}"
+ );
let _ = socket.close(None).await;
protocol_server.abort();
}
#[tokio::test]
-async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {
+async fn websocket_cdp_debugger_pause_blocks_auxiliary_main_thread_commands_until_resume() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
let (mut socket, _) = connect_async(format!(
"ws://{cdp_addr}/devtools/browser/{DEFAULT_BROWSER_ID}"
@@ -5234,63 +5252,14 @@ async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {
!observed.iter().any(|message| message["id"] == json!(6_u64)),
"Runtime.evaluate must remain pending while the renderer owner is paused: {observed:#?}"
);
- // Chromium's normal debugger loop pumps its main-thread DevTools receiver.
- // This command must therefore reach the auxiliary V8 session even though
- // the ordinary Page owner turn that entered the pause has not returned.
- let auxiliary_evaluate = tokio::time::timeout(
- Duration::from_secs(5),
- send_cdp_command(
- &mut socket,
- 7,
- "Runtime.evaluate",
- Some(&auxiliary_session_id),
- json!({ "expression": "21 * 2", "returnByValue": true }),
- ),
- )
- .await
- .expect("auxiliary Main Runtime.evaluate must complete in the debugger loop");
- assert!(
- auxiliary_evaluate.iter().any(|message| {
- message["id"] == json!(7_u64)
- && message["sessionId"] == json!(auxiliary_session_id)
- && message["result"]["result"]["value"] == json!(42)
- }),
- "pause-loop Main Runtime.evaluate should complete before resume: {auxiliary_evaluate:#?}"
- );
-
- let auxiliary_object = tokio::time::timeout(
- Duration::from_secs(5),
- send_cdp_command(
- &mut socket,
- 51,
- "Runtime.evaluate",
- Some(&auxiliary_session_id),
- json!({ "expression": "({ answer: 42 })" }),
- ),
- )
- .await
- .expect("object-valued Main Runtime.evaluate must complete in the debugger loop");
- assert!(
- auxiliary_object.iter().any(|message| {
- message["id"] == json!(51_u64)
- && message["sessionId"] == json!(auxiliary_session_id)
- && message["result"]["result"]["type"] == json!("object")
- && message["result"]["result"]["objectId"]
- .as_str()
- .is_some_and(|object_id| !object_id.is_empty())
- }),
- "pause-loop object response must remain owner-independent: {auxiliary_object:#?}"
- );
-
socket
.send(WsMessage::Text(
json!({
- "id": 52_u64,
+ "id": 7_u64,
"method": "Runtime.evaluate",
"sessionId": auxiliary_session_id,
"params": {
- "expression": "Promise.resolve(43)",
- "awaitPromise": true,
+ "expression": "21 * 2",
"returnByValue": true
}
})
@@ -5298,28 +5267,33 @@ async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {
.into(),
))
.await
- .expect("send pause-loop awaitPromise Runtime.evaluate");
+ .expect("queue auxiliary MainThread Runtime.evaluate while paused");
- observed.extend(
- send_cdp_command(
- &mut socket,
- 8,
- "Debugger.resume",
- Some(&session_id),
- json!({}),
- )
- .await,
+ let resumed = send_cdp_command(
+ &mut socket,
+ 8,
+ "Debugger.resume",
+ Some(&session_id),
+ json!({}),
+ )
+ .await;
+ assert!(
+ resumed.iter().all(|message| message["id"] != json!(7_u64)),
+ "auxiliary MainThread evaluate must not dispatch from the IO-only pause loop: {resumed:#?}"
);
- if !observed.iter().any(|message| message["id"] == json!(6_u64)) {
- observed
- .extend(recv_until_match(&mut socket, |message| message["id"] == json!(6_u64)).await);
- }
- if !observed
- .iter()
- .any(|message| message["id"] == json!(52_u64))
- {
- observed
- .extend(recv_until_match(&mut socket, |message| message["id"] == json!(52_u64)).await);
+ observed.extend(resumed);
+
+ let mut saw_paused_evaluate = observed.iter().any(|message| message["id"] == json!(6_u64));
+ let mut saw_auxiliary_evaluate = observed.iter().any(|message| message["id"] == json!(7_u64));
+ if !saw_paused_evaluate || !saw_auxiliary_evaluate {
+ observed.extend(
+ recv_until_match(&mut socket, |message| {
+ saw_paused_evaluate |= message["id"] == json!(6_u64);
+ saw_auxiliary_evaluate |= message["id"] == json!(7_u64);
+ saw_paused_evaluate && saw_auxiliary_evaluate
+ })
+ .await,
+ );
}
let evaluate = observed
.iter()
@@ -5330,14 +5304,26 @@ async fn websocket_cdp_debugger_pause_allows_auxiliary_main_thread_commands() {
json!(42),
"resuming the exact pause must return to the blocked Runtime command: {observed:#?}"
);
+ let auxiliary_evaluate = observed
+ .iter()
+ .find(|message| message["id"] == json!(7_u64))
+ .expect("auxiliary Runtime.evaluate should complete after Debugger.resume");
+ assert_eq!(
+ auxiliary_evaluate["result"]["result"]["value"],
+ json!(42),
+ "the queued auxiliary MainThread command must run normally after resume: {observed:#?}"
+ );
+ let resume_position = observed
+ .iter()
+ .position(|message| message["id"] == json!(8_u64))
+ .expect("IO resume response position");
+ let auxiliary_position = observed
+ .iter()
+ .position(|message| message["id"] == json!(7_u64))
+ .expect("auxiliary MainThread response position");
assert!(
- observed.iter().any(|message| {
- message["id"] == json!(52_u64)
- && message["sessionId"] == json!(auxiliary_session_id)
- && message["result"]["result"]["value"] == json!(43)
- }),
- "awaitPromise should settle after Debugger.resume without a deferred-reply deadlock: \
- {observed:#?}"
+ resume_position < auxiliary_position,
+ "IO resume must overtake the queued auxiliary MainThread command: {observed:#?}"
);
let _ = socket.close(None).await;
diff --git a/moli-protocol/src/conn/runtime_eval.rs b/moli-protocol/src/conn/runtime_eval.rs
index ac191d809..fa5ee3b36 100644
--- a/moli-protocol/src/conn/runtime_eval.rs
+++ b/moli-protocol/src/conn/runtime_eval.rs
@@ -4246,7 +4246,9 @@ impl CdpConnection {
raw_json: String,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
self.start_runtime_protocol_message_for_session_owner_with_access(
- session_id, raw_json, false,
+ session_id,
+ raw_json,
+ RendererInspectorCommandRoute::MainThread,
)
}
@@ -4256,7 +4258,9 @@ impl CdpConnection {
raw_json: String,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
self.start_runtime_protocol_message_for_session_owner_with_access(
- session_id, raw_json, true,
+ session_id,
+ raw_json,
+ RendererInspectorCommandRoute::Io,
)
}
@@ -4264,34 +4268,37 @@ impl CdpConnection {
&mut self,
session_id: Option<&str>,
raw_json: String,
- allow_suspended_document_access: bool,
+ inspector_route: RendererInspectorCommandRoute,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
let route = self.runtime_protocol_message_page_route_for_session_owner(session_id)?;
let raw_json =
self.rewrite_runtime_inspector_command_for_session_owner(session_id, &raw_json, None)?;
let inspector_session_id =
self.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let page = if allow_suspended_document_access {
- self.runtime_session_owner_page_mut_for_interruptible_control(session_id)?
- } else {
- self.runtime_session_owner_page_mut(session_id)?
+ let page = match inspector_route {
+ RendererInspectorCommandRoute::MainThread => {
+ self.runtime_session_owner_page_mut(session_id)?
+ }
+ RendererInspectorCommandRoute::Io => {
+ self.runtime_session_owner_page_mut_for_interruptible_control(session_id)?
+ }
};
- let pending = if allow_suspended_document_access {
- page.start_runtime_interrupt_protocol_message_for_inspector_session(
- inspector_session_id,
- raw_json,
- )
- } else {
- page.start_runtime_protocol_message_for_inspector_session(
- inspector_session_id,
- raw_json,
- )
+ let pending = match inspector_route {
+ RendererInspectorCommandRoute::MainThread => page
+ .start_runtime_protocol_message_for_inspector_session(
+ inspector_session_id,
+ raw_json,
+ )
+ .map(PendingRuntimeProtocolMessageDispatchKind::Page),
+ RendererInspectorCommandRoute::Io => page
+ .start_runtime_inspector_io_message_without_response(inspector_session_id, raw_json)
+ .map(PendingRuntimeProtocolMessageDispatchKind::Routable),
}
.map_err(|error| format!("runtime inspector dispatch failed: {error}"))?;
Ok(PendingRuntimeProtocolMessageDispatch {
session_id: session_id.map(str::to_owned),
route,
- pending: PendingRuntimeProtocolMessageDispatchKind::Page(pending),
+ pending,
deferred_response_rx: None,
})
}
@@ -4303,7 +4310,10 @@ impl CdpConnection {
command_id: u64,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
self.start_runtime_protocol_message_for_session_owner_with_deferred_response_and_access(
- session_id, descriptor, command_id, false,
+ session_id,
+ descriptor,
+ command_id,
+ RendererInspectorCommandRoute::MainThread,
)
}
@@ -4314,7 +4324,10 @@ impl CdpConnection {
command_id: u64,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
self.start_runtime_protocol_message_for_session_owner_with_deferred_response_and_access(
- session_id, descriptor, command_id, true,
+ session_id,
+ descriptor,
+ command_id,
+ RendererInspectorCommandRoute::Io,
)
}
@@ -4323,7 +4336,7 @@ impl CdpConnection {
session_id: Option<&str>,
descriptor: RendererCommandDescriptor,
command_id: u64,
- allow_suspended_document_access: bool,
+ inspector_route: RendererInspectorCommandRoute,
) -> Result<PendingRuntimeProtocolMessageDispatch, String> {
let route = self.runtime_protocol_message_page_route_for_session_owner(session_id)?;
let (correlation, raw_json, response_sender, response_receiver) = self
@@ -4335,11 +4348,15 @@ impl CdpConnection {
)?;
let inspector_session_id =
self.target_renderer_runtime_inspector_session_id_for_session(session_id);
- let page = match if allow_suspended_document_access {
- self.runtime_session_owner_page_mut_for_interruptible_control(session_id)
- } else {
- self.runtime_session_owner_page_mut(session_id)
- } {
+ let page_result = match inspector_route {
+ RendererInspectorCommandRoute::MainThread => {
+ self.runtime_session_owner_page_mut(session_id)
+ }
+ RendererInspectorCommandRoute::Io => {
+ self.runtime_session_owner_page_mut_for_interruptible_control(session_id)
+ }
+ };
+ let page = match page_result {
Ok(page) => page,
Err(error) => {
let removed =
@@ -4350,11 +4367,7 @@ impl CdpConnection {
};
let pending = match page.start_routable_runtime_protocol_message_for_inspector_session(
inspector_session_id,
- if allow_suspended_document_access {
- RendererInspectorCommandRoute::Io
- } else {
- RendererInspectorCommandRoute::MainThread
- },
+ inspector_route,
None,
raw_json,
response_sender,
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index 79d231411..48048d339 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -248,8 +248,8 @@ pub use runtime::{
RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload, RendererDragData,
RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererFrameToken,
RendererGeometryQuad, RendererInputDispatchOutcome, RendererInspectorCommandEnvelope,
- RendererInspectorCommandMetadata, RendererInspectorCommandRoute,
- RendererInspectorFirstDispatchLifecycle, RendererInspectorProtocolConfiguration,
+ RendererInspectorCommandRoute, RendererInspectorFirstDispatchLifecycle,
+ RendererInspectorIngressTicket, RendererInspectorProtocolConfiguration,
RendererInspectorProtocolConfigurationCommand, RendererInspectorSessionRestoreSnapshot,
RendererJavaScriptDialogCompletion, RendererJavaScriptDialogId, RendererJavaScriptDialogResult,
RendererJavaScriptDialogSource, RendererLayoutMetrics, RendererLifecycleDecider,
diff --git a/moli-renderer-v8/src/render_runtime.rs b/moli-renderer-v8/src/render_runtime.rs
index 3cb1b1e86..ea051414e 100644
--- a/moli-renderer-v8/src/render_runtime.rs
+++ b/moli-renderer-v8/src/render_runtime.rs
@@ -7,6 +7,7 @@ use tokio::sync::{mpsc, oneshot};
use super::page_task_queue::RendererOwnerWake;
use super::runtime::{RendererOwnerCommand, RendererOwnerHandle, RendererOwnerReply};
+use super::script_vm::inspector_io::RendererInspectorIoOwnerWake;
use super::service_worker_runtime::ServiceWorkerRuntimeOwnerWake;
use super::shared_worker_runtime::SharedWorkerRuntimeOwnerWake;
@@ -92,6 +93,7 @@ impl RenderRuntimeOwner {
pub(crate) fn spawn(
owner: RendererOwnerHandle,
page_wake_rx: mpsc::UnboundedReceiver<RendererOwnerWake>,
+ inspector_io_wake_rx: mpsc::UnboundedReceiver<RendererInspectorIoOwnerWake>,
shared_worker_wake_rx: mpsc::UnboundedReceiver<SharedWorkerRuntimeOwnerWake>,
service_worker_wake_rx: mpsc::UnboundedReceiver<ServiceWorkerRuntimeOwnerWake>,
) -> Self {
@@ -113,6 +115,7 @@ impl RenderRuntimeOwner {
owner,
rx,
page_wake_rx,
+ inspector_io_wake_rx,
shared_worker_wake_rx,
service_worker_wake_rx,
));
@@ -232,6 +235,7 @@ async fn render_runtime_main_loop(
owner: RendererOwnerHandle,
rx: mpsc::UnboundedReceiver<RenderRuntimeEnvelope>,
page_wake_rx: mpsc::UnboundedReceiver<RendererOwnerWake>,
+ inspector_io_wake_rx: mpsc::UnboundedReceiver<RendererInspectorIoOwnerWake>,
shared_worker_wake_rx: mpsc::UnboundedReceiver<SharedWorkerRuntimeOwnerWake>,
service_worker_wake_rx: mpsc::UnboundedReceiver<ServiceWorkerRuntimeOwnerWake>,
) {
@@ -239,6 +243,7 @@ async fn render_runtime_main_loop(
.run_render_runtime_loop(
rx,
page_wake_rx,
+ inspector_io_wake_rx,
shared_worker_wake_rx,
service_worker_wake_rx,
)
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index ded7813f0..f62518471 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -329,12 +329,12 @@ pub use self::page_surface::{
RendererDomSearchRegistration, RendererDomSearchResultNode, RendererDomSearchResultsResolution,
RendererDomSnapshotCaptureOptions, RendererDomSnapshotCapturePayload, RendererDragData,
RendererDragDataItem, RendererDraggedDirectory, RendererDraggedFile, RendererGeometryQuad,
- RendererInputDispatchOutcome, RendererInspectorCommandEnvelope,
- RendererInspectorCommandMetadata, RendererInspectorCommandRoute,
- RendererInspectorFirstDispatchLifecycle, RendererInspectorProtocolConfiguration,
- RendererInspectorProtocolConfigurationCommand, RendererInspectorSessionRestoreSnapshot,
- RendererJavaScriptDialogId, RendererJavaScriptDialogSource, RendererLayoutMetrics,
- RendererMainDocumentCommit, RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,
+ RendererInputDispatchOutcome, RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
+ RendererInspectorFirstDispatchLifecycle, RendererInspectorIngressTicket,
+ RendererInspectorProtocolConfiguration, RendererInspectorProtocolConfigurationCommand,
+ RendererInspectorSessionRestoreSnapshot, RendererJavaScriptDialogId,
+ RendererJavaScriptDialogSource, RendererLayoutMetrics, RendererMainDocumentCommit,
+ RendererMoliDomMemoryDiagnostics, RendererMoliMemoryDiagnostics,
RendererMoliMemoryScopeDiagnostics, RendererMoliRuntimeMemoryDiagnostics, RendererPageCommand,
RendererPageCommandPostResponseContinuation, RendererPageCookieFacadeSnapshotReply,
RendererPageCreationDiagnostics, RendererPageDiagnosticsSnapshot, RendererPageDumpFormat,
@@ -403,7 +403,7 @@ pub use self::protocol_output::{
};
pub use self::service_worker_run::RendererServiceWorkerRunIdentity;
pub(crate) use crate::renderer::PageVmInitStage;
-pub use crate::script_vm::inspector_pause::{
+pub use crate::script_vm::inspector_io::{
RendererRuntimeInspectorCommandClaim, RendererRuntimeInspectorCommandRoute,
};
pub(crate) use crate::service_worker_runtime::{
diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rs
index f2380d92f..b5a2cd14b 100644
--- a/moli-renderer-v8/src/runtime/owner.rs
+++ b/moli-renderer-v8/src/runtime/owner.rs
@@ -79,7 +79,10 @@ use crate::page_task_queue::{
};
use crate::referrer_policy::response_referrer_policy_from_headers;
use crate::render_runtime::{RenderRuntimeEnvelope, RenderRuntimeHandle, RenderRuntimeOwner};
-use crate::script_vm::{PendingRuntimeEvaluateCall, RendererDocumentIsolateBootstrap};
+use crate::script_vm::{
+ PendingRuntimeEvaluateCall, RendererDocumentIsolateBootstrap, dispatch_inspector_io_owner_wake,
+ inspector_io::RendererInspectorIoOwnerWake,
+};
use crate::service_worker_runtime::{
ServiceWorkerRuntimeOwnerWake, service_worker_owner_wake_channel,
};
@@ -380,7 +383,6 @@ struct PageCommandFirstDispatchIdentity {
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub(super) struct PageCommandFirstDispatchLane {
inspector_session: DevToolsSessionKey,
- route: RendererInspectorCommandRoute,
}
impl RenderRuntimePendingTurn {
@@ -676,16 +678,20 @@ impl RenderRuntimeTurn {
) -> Option<PageCommandFirstDispatchIdentity> {
match self {
Self::RunLivePageCommand { token, command, .. } => {
- command.inspector_metadata().map(|metadata| {
+ command.inspector_ticket().map(|ticket| {
+ debug_assert_eq!(
+ ticket.route(),
+ RendererInspectorCommandRoute::MainThread,
+ "IO Inspector commands must bypass owner admission",
+ );
debug_assert_eq!(
- metadata.first_dispatch_lifecycle(),
- RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
+ command.inspector_first_dispatch_lifecycle(),
+ Some(RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,),
);
PageCommandFirstDispatchIdentity {
token: *token,
lane: PageCommandFirstDispatchLane {
- inspector_session: metadata.session().clone(),
- route: metadata.route(),
+ inspector_session: ticket.session().clone(),
},
}
})
@@ -907,6 +913,7 @@ pub(super) struct RendererOwnerState {
pub(super) local_executor: JsLocalExecutor,
pub(super) next_page_id: Arc<AtomicU64>,
pub(super) page_wake_tx: mpsc::UnboundedSender<RendererOwnerWake>,
+ pub(super) inspector_io_wake_tx: mpsc::UnboundedSender<RendererInspectorIoOwnerWake>,
pub(super) browser_context_runtime: RendererBrowserContextRuntime,
pub(super) owner_local_host_id: RendererOwnerLocalHostId,
layout_policy: Mutex<RendererOwnerLayoutPolicyState>,
@@ -1693,6 +1700,7 @@ impl RendererOwnerHandle {
browser_context_runtime: RendererBrowserContextRuntime,
) -> (Self, RenderRuntimeOwner) {
let (page_wake_tx, page_wake_rx) = mpsc::unbounded_channel();
+ let (inspector_io_wake_tx, inspector_io_wake_rx) = mpsc::unbounded_channel();
let (shared_worker_wake_tx, shared_worker_wake_rx) = shared_worker_owner_wake_channel();
browser_context_runtime.add_shared_worker_owner_wake_sender(shared_worker_wake_tx);
let (service_worker_wake_tx, service_worker_wake_rx) = service_worker_owner_wake_channel();
@@ -1706,6 +1714,7 @@ impl RendererOwnerHandle {
local_executor,
next_page_id,
page_wake_tx,
+ inspector_io_wake_tx,
browser_context_runtime,
owner_local_host_id,
layout_policy: Mutex::new(RendererOwnerLayoutPolicyState::default()),
@@ -1722,6 +1731,7 @@ impl RendererOwnerHandle {
let render_runtime_owner = RenderRuntimeOwner::spawn(
provisional.clone(),
page_wake_rx,
+ inspector_io_wake_rx,
shared_worker_wake_rx,
service_worker_wake_rx,
);
@@ -2457,10 +2467,10 @@ impl RendererOwnerHandle {
}
}
- /// The stable Page slot owns each Inspector `(session, route)` arrival
- /// order. Chromium intentionally separates main-thread and IO ingress,
- /// so each route has its own FIFO lane. Only the command that owns that
- /// lane enters the owner-wide runnable queue; other routes, sessions and
+ /// The stable Page slot owns each MainThread Inspector session's arrival
+ /// order. IO commands use their physically separate ingress and never
+ /// enter this owner admission structure. Only the command that owns the
+ /// session lane enters the owner-wide runnable queue; other sessions and
/// non-Inspector Page commands remain independent.
fn admit_page_command_first_dispatch(
turn: RenderRuntimePendingTurn,
@@ -2495,6 +2505,7 @@ impl RendererOwnerHandle {
&self,
mut rx: mpsc::UnboundedReceiver<RenderRuntimeEnvelope>,
mut page_wake_rx: mpsc::UnboundedReceiver<RendererOwnerWake>,
+ mut inspector_io_wake_rx: mpsc::UnboundedReceiver<RendererInspectorIoOwnerWake>,
mut shared_worker_wake_rx: mpsc::UnboundedReceiver<SharedWorkerRuntimeOwnerWake>,
mut service_worker_wake_rx: mpsc::UnboundedReceiver<ServiceWorkerRuntimeOwnerWake>,
) {
@@ -2561,6 +2572,15 @@ impl RendererOwnerHandle {
if !pending_turns.has_owner_maintenance_turn() {
self.enqueue_one_due_owner_maintenance_turn(&mut pending_turns);
}
+ // IO Inspector ingress is independent of normal owner command
+ // admission. Give at most one command an owner execution
+ // chance at each boundary, then continue with the ordinary
+ // pending turn so sustained IO cannot starve MainThread work.
+ match inspector_io_wake_rx.try_recv() {
+ Ok(wake) => dispatch_inspector_io_owner_wake(wake),
+ Err(mpsc::error::TryRecvError::Empty) => {}
+ Err(mpsc::error::TryRecvError::Disconnected) => {}
+ }
if let Some(mut pending_turn) = pending_turns.pop_front() {
if pending_turn.allow_command_overtake
&& pending_turn.turn.page_turn_should_yield_to_ready_command()
@@ -2932,6 +2952,12 @@ impl RendererOwnerHandle {
&mut pending_turns,
);
}
+ inspector_io_wake_opt = inspector_io_wake_rx.recv() => {
+ let Some(wake) = inspector_io_wake_opt else {
+ break;
+ };
+ dispatch_inspector_io_owner_wake(wake);
+ }
shared_worker_wake_opt = shared_worker_wake_rx.recv() => {
let Some(wake) = shared_worker_wake_opt else {
break;
@@ -7069,16 +7095,14 @@ mod tests {
}
#[test]
- fn first_dispatch_identity_uses_the_exact_inspector_session_and_route() {
+ fn first_dispatch_identity_uses_the_exact_main_thread_inspector_session() {
let token = RendererPageToken::new_for_testing(PageId::new_for_testing(8));
let attached = RenderRuntimeTurn::RunLivePageCommand {
token,
- command: RendererPageCommand::dispatch_queued_runtime_inspector_command(
- RendererInspectorCommandMetadata::new(
- Some("SID-aux".to_owned()),
- RendererInspectorCommandRoute::MainThread,
- ),
- 1,
+ command: RendererPageCommand::dispatch_runtime_protocol_message(
+ Some("SID-aux".to_owned()),
+ RendererInspectorCommandRoute::MainThread,
+ r#"{"id":1,"method":"Runtime.evaluate","params":{"expression":"1"}}"#.to_owned(),
),
capture_policy: RendererPageStateCapturePolicy::ProtocolTurn,
};
@@ -7088,16 +7112,16 @@ mod tests {
token,
lane: PageCommandFirstDispatchLane {
inspector_session: DevToolsSessionKey::Attached("SID-aux".to_owned()),
- route: RendererInspectorCommandRoute::MainThread,
},
})
);
let primary = RenderRuntimeTurn::RunLivePageCommand {
token,
- command: RendererPageCommand::dispatch_queued_runtime_inspector_command(
- RendererInspectorCommandMetadata::new(None, RendererInspectorCommandRoute::Io),
- 2,
+ command: RendererPageCommand::dispatch_runtime_protocol_message(
+ None,
+ RendererInspectorCommandRoute::MainThread,
+ r#"{"id":2,"method":"Runtime.evaluate","params":{"expression":"2"}}"#.to_owned(),
),
capture_policy: RendererPageStateCapturePolicy::ProtocolTurn,
};
@@ -7107,7 +7131,6 @@ mod tests {
token,
lane: PageCommandFirstDispatchLane {
inspector_session: DevToolsSessionKey::Primary,
- route: RendererInspectorCommandRoute::Io,
},
})
);
@@ -7140,25 +7163,13 @@ mod tests {
RendererInspectorCommandRoute::MainThread,
r#"{"id":1,"method":"Runtime.disable"}"#.to_owned(),
));
- let raw_io = turn_for(RendererPageCommand::dispatch_runtime_protocol_message(
- Some("SID-shared-lane".to_owned()),
- RendererInspectorCommandRoute::Io,
- r#"{"id":2,"method":"Runtime.terminateExecution"}"#.to_owned(),
- ));
-
let enable_identity = enable
.live_page_command_first_dispatch_identity()
.expect("Runtime.enable must enter the Inspector boundary");
let main_identity = raw_main
.live_page_command_first_dispatch_identity()
.expect("raw main-thread dispatch must enter the Inspector boundary");
- let io_identity = raw_io
- .live_page_command_first_dispatch_identity()
- .expect("raw IO dispatch must enter the Inspector boundary");
-
assert_eq!(enable_identity, main_identity);
- assert_ne!(enable_identity, io_identity);
- assert_eq!(io_identity.lane.route, RendererInspectorCommandRoute::Io);
}
#[test]
diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rs
index 724a92215..a8dbccaae 100644
--- a/moli-renderer-v8/src/runtime/owner_local.rs
+++ b/moli-renderer-v8/src/runtime/owner_local.rs
@@ -22,6 +22,7 @@ pub struct RendererAttachedPage {
pub(super) javascript_dialog_broker: RendererJavaScriptDialogBroker,
pub(super) inspector_pause_bridge:
crate::script_vm::inspector_pause::RendererInspectorPauseBridge,
+ pub(super) inspector_io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,
pub(super) page_state: Arc<RendererPageState>,
pub(super) creation_diagnostics: RendererPageCreationDiagnostics,
pub(super) creation_artifacts: RendererPageCreationArtifacts,
@@ -69,6 +70,7 @@ impl RendererAttachedPage {
page_context_cancel_tx: self.page_context_cancel_tx,
javascript_dialog_broker: self.javascript_dialog_broker,
inspector_pause_bridge: self.inspector_pause_bridge,
+ inspector_io_ingress: self.inspector_io_ingress,
committed_document_post_response_continuation: self
.committed_document_post_response_continuation,
_not_send: PhantomData,
@@ -89,6 +91,7 @@ pub struct RendererPageHandle {
page_context_cancel_tx: RendererPageContextCancelSender,
javascript_dialog_broker: RendererJavaScriptDialogBroker,
inspector_pause_bridge: crate::script_vm::inspector_pause::RendererInspectorPauseBridge,
+ inspector_io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,
committed_document_post_response_continuation:
Option<RendererPageCommandPostResponseContinuation>,
_not_send: PhantomData<Rc<()>>,
@@ -163,27 +166,12 @@ impl RendererPageHandle {
self.javascript_dialog_broker.take_pending()
}
- pub fn enqueue_routable_runtime_inspector_command(
+ pub fn enqueue_runtime_inspector_io_command(
&self,
- inspector_session_id: Option<String>,
- route: RendererInspectorCommandRoute,
- owner_context_resolution_action: Option<String>,
- raw_json: String,
- response: RendererRuntimeInspectorResponseSender,
- ) -> crate::script_vm::inspector_pause::RendererRuntimeInspectorCommandRoute {
- self.inspector_pause_bridge.enqueue_command(
- self.devtools_agent_token,
- inspector_session_id,
- route,
- owner_context_resolution_action,
- raw_json,
- response,
- )
- }
-
- pub fn cancel_queued_runtime_inspector_command(&self, command_id: u64, message: &str) {
- self.inspector_pause_bridge
- .cancel_queued_command(command_id, message);
+ envelope: RendererInspectorCommandEnvelope,
+ ) -> RendererRuntimeInspectorCommandRoute {
+ self.inspector_io_ingress
+ .enqueue_command(self.devtools_agent_token, envelope)
}
pub fn runtime_inspector_pause_active(&self) -> bool {
@@ -320,6 +308,8 @@ impl RendererPageHandle {
return Ok(());
};
self.inspector_pause_bridge.close_target();
+ self.inspector_io_ingress
+ .close("Inspector target closed with its Page handle");
self.javascript_dialog_broker.dismiss_pending();
self.page_context_cancel_tx
.cancel(RendererPageContextCancelReason::PageClosed);
@@ -393,7 +383,10 @@ impl Drop for RendererPageHandle {
let Some(token) = self.token.take() else {
return;
};
- self.inspector_pause_bridge.detach_page(token.page_id);
+ if self.inspector_pause_bridge.detach_page(token.page_id) {
+ self.inspector_io_ingress
+ .cancel_all_queued("Inspector Page handle was dropped");
+ }
self.javascript_dialog_broker.dismiss_pending();
self.page_context_cancel_tx
.cancel(RendererPageContextCancelReason::PageClosed);
diff --git a/moli-renderer-v8/src/runtime/owner_local_store.rs b/moli-renderer-v8/src/runtime/owner_local_store.rs
index 42ecd262d..5ac9f37ea 100644
--- a/moli-renderer-v8/src/runtime/owner_local_store.rs
+++ b/moli-renderer-v8/src/runtime/owner_local_store.rs
@@ -3479,6 +3479,7 @@ impl RendererOwnerLocalStore {
}
let javascript_dialog_broker = entry.page_vm().javascript_dialog_broker();
let inspector_pause_bridge = entry.page_vm().inspector_pause_bridge();
+ let inspector_io_ingress = entry.page_vm().inspector_io_ingress();
let page_state = Self::commit_current_vm_page_state_on_entry(&mut entry)?;
let initial_runtime_realms = entry.page_vm_mut().vm_mut().runtime_realm_inventory();
let devtools_agent_token = entry.page_vm().devtools_agent_token();
@@ -3490,6 +3491,7 @@ impl RendererOwnerLocalStore {
Ok((
javascript_dialog_broker,
inspector_pause_bridge,
+ inspector_io_ingress,
page_state,
devtools_agent_token,
creation_diagnostics,
@@ -3517,6 +3519,7 @@ impl RendererOwnerLocalStore {
|(
javascript_dialog_broker,
inspector_pause_bridge,
+ inspector_io_ingress,
page_state,
devtools_agent_token,
mut creation_diagnostics,
@@ -3530,6 +3533,7 @@ impl RendererOwnerLocalStore {
page_context_cancel_tx,
javascript_dialog_broker,
inspector_pause_bridge,
+ inspector_io_ingress,
page_state,
creation_diagnostics,
creation_artifacts,
@@ -3971,6 +3975,10 @@ impl RendererOwnerLocalStore {
.expect("an attached Page must own a renderer script environment")
.output_journal(),
);
+ attached_entry
+ .page_vm()
+ .inspector_io_ingress()
+ .configure_owner_wake(owner.owner_state.inspector_io_wake_tx.clone());
let _ = attached_entry
.page_vm_mut()
.replay_pending_owner_wakes_after_attach(has_page_task_source);
diff --git a/moli-renderer-v8/src/runtime/page_command_residence.rs b/moli-renderer-v8/src/runtime/page_command_residence.rs
index 3804afaf2..699ab33cb 100644
--- a/moli-renderer-v8/src/runtime/page_command_residence.rs
+++ b/moli-renderer-v8/src/runtime/page_command_residence.rs
@@ -80,46 +80,38 @@ impl<Key: Ord, Command> PageCommandFirstDispatchResidence<Key, Command> {
#[cfg(test)]
mod tests {
use super::*;
- use crate::runtime::RendererInspectorCommandRoute;
- type Lane = (&'static str, RendererInspectorCommandRoute);
+ type Lane = &'static str;
#[test]
- fn each_inspector_session_and_route_owns_an_independent_fifo_dispatch_lane() {
+ fn each_main_thread_inspector_session_owns_an_independent_fifo_dispatch_lane() {
let mut first_page = PageCommandFirstDispatchResidence::default();
let mut other_page = PageCommandFirstDispatchResidence::default();
- let session_a_main: Lane = ("session-a", RendererInspectorCommandRoute::MainThread);
- let session_a_io: Lane = ("session-a", RendererInspectorCommandRoute::Io);
- let session_b_main: Lane = ("session-b", RendererInspectorCommandRoute::MainThread);
+ let session_a: Lane = "session-a";
+ let session_b: Lane = "session-b";
assert_eq!(
- first_page.admit(session_a_main, "a-main-first"),
+ first_page.admit(session_a, "a-main-first"),
Some("a-main-first")
);
- assert_eq!(first_page.admit(session_a_main, "a-main-second"), None);
+ assert_eq!(first_page.admit(session_a, "a-main-second"), None);
assert_eq!(
- first_page.admit(session_a_io, "a-io-first"),
- Some("a-io-first"),
- "an IO command must not wait for main-thread work in the same session"
- );
- assert_eq!(
- first_page.admit(session_b_main, "b-first"),
+ first_page.admit(session_b, "b-first"),
Some("b-first"),
"a parked command must not block a different Inspector session"
);
- assert_eq!(first_page.admit(session_b_main, "b-second"), None);
+ assert_eq!(first_page.admit(session_b, "b-second"), None);
- assert_eq!(other_page.admit(session_a_main, "other"), Some("other"));
- assert_eq!(other_page.complete(&session_a_main), None);
+ assert_eq!(other_page.admit(session_a, "other"), Some("other"));
+ assert_eq!(other_page.complete(&session_a), None);
- assert_eq!(first_page.complete(&session_b_main), Some("b-second"));
- assert_eq!(first_page.complete(&session_b_main), None);
- assert_eq!(first_page.complete(&session_a_io), None);
- assert_eq!(first_page.complete(&session_a_main), Some("a-main-second"));
- assert_eq!(first_page.complete(&session_a_main), None);
+ assert_eq!(first_page.complete(&session_b), Some("b-second"));
+ assert_eq!(first_page.complete(&session_b), None);
+ assert_eq!(first_page.complete(&session_a), Some("a-main-second"));
+ assert_eq!(first_page.complete(&session_a), None);
assert_eq!(
- first_page.admit(session_a_main, "a-after-idle"),
+ first_page.admit(session_a, "a-after-idle"),
Some("a-after-idle")
);
}
@@ -127,17 +119,17 @@ mod tests {
#[test]
fn retiring_a_page_drains_waiters_and_resets_every_lane() {
let mut residence = PageCommandFirstDispatchResidence::default();
- let main: Lane = ("session-a", RendererInspectorCommandRoute::MainThread);
- let io: Lane = ("session-a", RendererInspectorCommandRoute::Io);
+ let main: Lane = "session-a";
+ let other: Lane = "session-b";
assert_eq!(residence.admit(main, "main-active"), Some("main-active"));
assert_eq!(residence.admit(main, "main-waiting"), None);
- assert_eq!(residence.admit(io, "io-active"), Some("io-active"));
- assert_eq!(residence.admit(io, "io-waiting"), None);
+ assert_eq!(residence.admit(other, "other-active"), Some("other-active"));
+ assert_eq!(residence.admit(other, "other-waiting"), None);
let mut drained = residence.drain_waiting();
drained.sort_unstable();
- assert_eq!(drained, ["io-waiting", "main-waiting"]);
+ assert_eq!(drained, ["main-waiting", "other-waiting"]);
assert_eq!(
residence.admit(main, "main-after-retirement"),
Some("main-after-retirement"),
diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rs
index 8967ca597..7c7e0ce42 100644
--- a/moli-renderer-v8/src/runtime/page_commands.rs
+++ b/moli-renderer-v8/src/runtime/page_commands.rs
@@ -1120,8 +1120,8 @@ impl PageVm {
&mut self,
envelope: RendererInspectorCommandEnvelope,
) -> Result<RendererPageReply> {
- let (metadata, command) = envelope.into_parts();
- let inspector_session_id = metadata.session().wire_session_id();
+ let (ticket, command) = envelope.into_main_thread_parts();
+ let inspector_session_id = ticket.session().wire_session_id();
match command {
RendererInspectorPageCommand::DispatchRuntimeProtocolMessage { raw_json } => self
.dispatch_runtime_protocol_message_for_inspector_session(
@@ -1141,12 +1141,6 @@ impl PageVm {
)
.map(RendererRuntimeCommandOutput::from_messages)
.map(RendererPageReply::RuntimeInspectorProtocolMessages),
- RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand {
- command_id,
- } => self
- .dispatch_queued_runtime_inspector_command(command_id)
- .map(RendererRuntimeCommandOutput::from_messages)
- .map(RendererPageReply::RuntimeInspectorProtocolMessages),
RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolution {
action,
raw_json,
diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rs
index 547606750..ee5c9c2b0 100644
--- a/moli-renderer-v8/src/runtime/page_dom.rs
+++ b/moli-renderer-v8/src/runtime/page_dom.rs
@@ -743,34 +743,6 @@ impl PageVm {
)
}
- pub(crate) fn dispatch_queued_runtime_inspector_command(
- &mut self,
- command_id: u64,
- ) -> Result<Vec<RendererRuntimeInspectorMessage>> {
- let pause_bridge = self.inspector_pause_bridge();
- let Some(command) = pause_bridge.claim_command_for_owner(command_id) else {
- return Ok(Vec::new());
- };
- let mut first_dispatch = pause_bridge.first_dispatch_guard(&command);
- let inspector_session = command.metadata.session().clone();
- let inspector_session_id = inspector_session.wire_session_id();
- match command.owner_context_resolution_action.as_deref() {
- Some(action) => self.dispatch_queued_runtime_protocol_message_with_context_resolution(
- inspector_session_id,
- action,
- &command.raw_json,
- command.response,
- &mut first_dispatch,
- ),
- None => self.dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(
- inspector_session_id,
- &command.raw_json,
- command.response,
- Some(&mut first_dispatch),
- ),
- }
- }
-
pub(crate) fn dispatch_runtime_protocol_message_for_inspector_session_with_context_resolution(
&mut self,
inspector_session_id: Option<&str>,
@@ -830,65 +802,11 @@ impl PageVm {
)
}
- fn dispatch_queued_runtime_protocol_message_with_context_resolution(
- &mut self,
- inspector_session_id: Option<&str>,
- action: &str,
- raw_json: &str,
- deferred_response: RendererRuntimeInspectorResponseSender,
- first_dispatch: &mut crate::script_vm::inspector_pause::RendererInspectorFirstDispatchGuard,
- ) -> Result<Vec<RendererRuntimeInspectorMessage>> {
- if action == "evaluate" {
- // The child-default fast path dispatches while probing, so expose
- // its first-dispatch edge before entering that helper.
- first_dispatch.release();
- if let Some(messages) = self.try_dispatch_child_default_runtime_evaluate(raw_json)? {
- let call_id = deferred_response.call_id();
- if let Some(message) = messages.into_iter().next()
- && let Err(message) =
- deferred_response.send(message.into_v8_inspector_message())
- {
- tracing::debug!(
- call_id,
- message = ?message,
- "dropping child-frame runtime response because deferred receiver was closed"
- );
- }
- return Ok(Vec::new());
- }
- }
- let prepared_json =
- self.prepare_runtime_protocol_message_with_context_resolution(action, raw_json)?;
- self.dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(
- inspector_session_id,
- &prepared_json,
- deferred_response,
- Some(first_dispatch),
- )
- }
-
fn dispatch_runtime_protocol_message_with_command_output(
- &mut self,
- inspector_session_id: Option<&str>,
- raw_json: &str,
- deferred_response: RendererRuntimeInspectorResponseSender,
- ) -> Result<Vec<RendererRuntimeInspectorMessage>> {
- self.dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(
- inspector_session_id,
- raw_json,
- deferred_response,
- None,
- )
- }
-
- fn dispatch_runtime_protocol_message_with_command_output_at_first_dispatch(
&mut self,
inspector_session_id: Option<&str>,
raw_json: &str,
mut deferred_response: RendererRuntimeInspectorResponseSender,
- mut first_dispatch: Option<
- &mut crate::script_vm::inspector_pause::RendererInspectorFirstDispatchGuard,
- >,
) -> Result<Vec<RendererRuntimeInspectorMessage>> {
ensure!(
self.pending_runtime_command_output.is_none(),
@@ -925,9 +843,6 @@ impl PageVm {
lifecycle_target:
PageVmRuntimeCommandLifecycleTarget::AwaitingExplicitDocumentReplacement,
});
- if let Some(first_dispatch) = first_dispatch.as_mut() {
- first_dispatch.release();
- }
let dispatch_result = self
.vm_mut()
.dispatch_inspector_protocol_message_for_session_with_deferred_response_and_command_output(
diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rs
index 97280a3e9..9edec6359 100644
--- a/moli-renderer-v8/src/runtime/page_surface.rs
+++ b/moli-renderer-v8/src/runtime/page_surface.rs
@@ -22,6 +22,7 @@ use std::{
cell::RefCell,
collections::{BTreeMap, BTreeSet},
rc::Rc,
+ sync::atomic::{AtomicU64, Ordering},
};
use tokio::sync::oneshot;
@@ -3547,26 +3548,42 @@ pub enum RendererInspectorFirstDispatchLifecycle {
OrderedUntilFirstDispatch,
}
+static NEXT_RENDERER_INSPECTOR_INGRESS_SEQUENCE: AtomicU64 = AtomicU64::new(1);
+
#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct RendererInspectorCommandMetadata {
+pub struct RendererInspectorIngressTicket {
+ attachment: Option<RendererAgentAttachmentId>,
session: DevToolsSessionKey,
route: RendererInspectorCommandRoute,
- first_dispatch: RendererInspectorFirstDispatchLifecycle,
+ sequence: u64,
}
-impl RendererInspectorCommandMetadata {
- pub fn new(inspector_session_id: Option<String>, route: RendererInspectorCommandRoute) -> Self {
+impl RendererInspectorIngressTicket {
+ pub fn new(
+ attachment: Option<RendererAgentAttachmentId>,
+ inspector_session_id: Option<String>,
+ route: RendererInspectorCommandRoute,
+ ) -> Self {
Self {
+ attachment,
session: DevToolsSessionKey::from_wire_session_id(
inspector_session_id
.as_deref()
.filter(|session_id| !session_id.is_empty()),
),
route,
- first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
+ sequence: NEXT_RENDERER_INSPECTOR_INGRESS_SEQUENCE
+ .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |sequence| {
+ sequence.checked_add(1)
+ })
+ .expect("renderer Inspector ingress sequence overflow"),
}
}
+ pub fn attachment(&self) -> Option<RendererAgentAttachmentId> {
+ self.attachment
+ }
+
pub fn session(&self) -> &DevToolsSessionKey {
&self.session
}
@@ -3575,8 +3592,19 @@ impl RendererInspectorCommandMetadata {
self.route
}
- pub fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {
- self.first_dispatch
+ pub fn sequence(&self) -> u64 {
+ self.sequence
+ }
+
+ fn bind_attachment(&mut self, attachment: RendererAgentAttachmentId) {
+ if let Some(bound) = self.attachment {
+ assert_eq!(
+ bound, attachment,
+ "an Inspector ingress ticket cannot be retargeted to another attachment"
+ );
+ } else {
+ self.attachment = Some(attachment);
+ }
}
}
@@ -3585,8 +3613,17 @@ impl RendererInspectorCommandMetadata {
/// `V8InspectorSession` must obtain its identity and dispatch policy from this
/// envelope.
pub struct RendererInspectorCommandEnvelope {
- metadata: RendererInspectorCommandMetadata,
- command: RendererInspectorPageCommand,
+ ticket: RendererInspectorIngressTicket,
+ first_dispatch: RendererInspectorFirstDispatchLifecycle,
+ payload: RendererInspectorCommandPayload,
+}
+
+enum RendererInspectorCommandPayload {
+ MainThread(RendererInspectorPageCommand),
+ Io {
+ raw_json: String,
+ response: Option<RendererRuntimeInspectorResponseSender>,
+ },
}
impl RendererInspectorCommandEnvelope {
@@ -3595,44 +3632,94 @@ impl RendererInspectorCommandEnvelope {
route: RendererInspectorCommandRoute,
command: RendererInspectorPageCommand,
) -> Self {
- Self::with_metadata(
- RendererInspectorCommandMetadata::new(inspector_session_id, route),
- command,
- )
+ assert_eq!(
+ route,
+ RendererInspectorCommandRoute::MainThread,
+ "a Page-owned Inspector payload must use the MainThread route"
+ );
+ Self {
+ ticket: RendererInspectorIngressTicket::new(None, inspector_session_id, route),
+ first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
+ payload: RendererInspectorCommandPayload::MainThread(command),
+ }
}
- fn with_metadata(
- metadata: RendererInspectorCommandMetadata,
- command: RendererInspectorPageCommand,
+ #[doc(hidden)]
+ pub fn new_io(
+ ticket: RendererInspectorIngressTicket,
+ raw_json: String,
+ response: Option<RendererRuntimeInspectorResponseSender>,
) -> Self {
- Self { metadata, command }
+ assert_eq!(
+ ticket.route(),
+ RendererInspectorCommandRoute::Io,
+ "an Inspector IO payload must use the IO route"
+ );
+ Self {
+ ticket,
+ first_dispatch: RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
+ payload: RendererInspectorCommandPayload::Io { raw_json, response },
+ }
}
- pub fn metadata(&self) -> &RendererInspectorCommandMetadata {
- &self.metadata
+ pub fn ticket(&self) -> &RendererInspectorIngressTicket {
+ &self.ticket
}
- pub(crate) fn into_parts(
+ pub fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {
+ self.first_dispatch
+ }
+
+ fn bind_attachment(&mut self, attachment: RendererAgentAttachmentId) {
+ self.ticket.bind_attachment(attachment);
+ }
+
+ pub(crate) fn into_main_thread_parts(
self,
- ) -> (
- RendererInspectorCommandMetadata,
- RendererInspectorPageCommand,
- ) {
- (self.metadata, self.command)
+ ) -> (RendererInspectorIngressTicket, RendererInspectorPageCommand) {
+ let RendererInspectorCommandPayload::MainThread(command) = self.payload else {
+ panic!("an Inspector IO envelope cannot enter Page owner dispatch");
+ };
+ (self.ticket, command)
+ }
+
+ fn main_thread_payload(&self) -> &RendererInspectorPageCommand {
+ let RendererInspectorCommandPayload::MainThread(command) = &self.payload else {
+ panic!("an Inspector IO envelope cannot enter Page owner dispatch");
+ };
+ command
+ }
+
+ pub(crate) fn io_raw_json(&self) -> &str {
+ let RendererInspectorCommandPayload::Io { raw_json, .. } = &self.payload else {
+ panic!("a MainThread Inspector envelope cannot enter IO dispatch");
+ };
+ raw_json
+ }
+
+ pub(crate) fn io_response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
+ let RendererInspectorCommandPayload::Io { response, .. } = &self.payload else {
+ panic!("a MainThread Inspector envelope cannot enter IO dispatch");
+ };
+ response.as_ref()
+ }
+
+ pub(crate) fn take_io_response(&mut self) -> Option<RendererRuntimeInspectorResponseSender> {
+ let RendererInspectorCommandPayload::Io { response, .. } = &mut self.payload else {
+ panic!("a MainThread Inspector envelope cannot enter IO dispatch");
+ };
+ response.take()
}
pub(crate) fn requires_materialized_child_realms(&self) -> bool {
matches!(
- &self.command,
+ self.main_thread_payload(),
RendererInspectorPageCommand::RuntimeEnableEvents
)
}
pub(crate) fn cdp_nav_timing_label(&self) -> Option<&'static str> {
- match &self.command {
- RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand { .. } => {
- Some("DispatchQueuedRuntimeInspectorCommand")
- }
+ match self.main_thread_payload() {
RendererInspectorPageCommand::RuntimeEnableEvents => Some("RuntimeEnableEvents"),
RendererInspectorPageCommand::ApplyRuntimeProtocolState { .. } => {
Some("ApplyRuntimeProtocolState")
@@ -3680,10 +3767,9 @@ impl RendererInspectorCommandEnvelope {
pub(crate) fn uses_cpu_throttling(&self) -> bool {
matches!(
- &self.command,
+ self.main_thread_payload(),
RendererInspectorPageCommand::DispatchRuntimeProtocolMessage { .. }
| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse { .. }
- | RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand { .. }
| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolution { .. }
| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse { .. }
| RendererInspectorPageCommand::DomDebuggerGetEventListeners { .. }
@@ -3700,9 +3786,6 @@ pub(crate) enum RendererInspectorPageCommand {
raw_json: String,
deferred_response: RendererRuntimeInspectorResponseSender,
},
- DispatchQueuedRuntimeInspectorCommand {
- command_id: u64,
- },
DispatchRuntimeProtocolMessageWithContextResolution {
action: String,
raw_json: String,
@@ -4317,6 +4400,11 @@ impl RendererPageCommand {
route: RendererInspectorCommandRoute,
command: RendererInspectorPageCommand,
) -> Self {
+ assert_eq!(
+ route,
+ RendererInspectorCommandRoute::MainThread,
+ "IO Inspector commands must enter RendererInspectorIoIngress"
+ );
Self::Inspector(RendererInspectorCommandEnvelope::new(
inspector_session_id,
route,
@@ -4352,16 +4440,6 @@ impl RendererPageCommand {
)
}
- pub fn dispatch_queued_runtime_inspector_command(
- metadata: RendererInspectorCommandMetadata,
- command_id: u64,
- ) -> Self {
- Self::Inspector(RendererInspectorCommandEnvelope::with_metadata(
- metadata,
- RendererInspectorPageCommand::DispatchQueuedRuntimeInspectorCommand { command_id },
- ))
- }
-
pub fn dispatch_runtime_protocol_message_with_context_resolution(
inspector_session_id: Option<String>,
route: RendererInspectorCommandRoute,
@@ -4429,7 +4507,7 @@ impl RendererPageCommand {
) -> Self {
Self::inspector_command(
inspector_session_id,
- RendererInspectorCommandRoute::Io,
+ RendererInspectorCommandRoute::MainThread,
RendererInspectorPageCommand::DetachRuntimeInspectorSession { pause_guard },
)
}
@@ -4652,13 +4730,28 @@ impl RendererPageCommand {
/// Metadata is structurally present for every command that can access a
/// frontend V8 Inspector session; no command-variant allowlist is involved.
- pub fn inspector_metadata(&self) -> Option<&RendererInspectorCommandMetadata> {
+ pub fn inspector_ticket(&self) -> Option<&RendererInspectorIngressTicket> {
+ match self {
+ Self::Inspector(envelope) => Some(envelope.ticket()),
+ _ => None,
+ }
+ }
+
+ pub fn inspector_first_dispatch_lifecycle(
+ &self,
+ ) -> Option<RendererInspectorFirstDispatchLifecycle> {
match self {
- Self::Inspector(envelope) => Some(envelope.metadata()),
+ Self::Inspector(envelope) => Some(envelope.first_dispatch_lifecycle()),
_ => None,
}
}
+ pub fn bind_inspector_attachment(&mut self, attachment: RendererAgentAttachmentId) {
+ if let Self::Inspector(envelope) = self {
+ envelope.bind_attachment(attachment);
+ }
+ }
+
pub(crate) fn interruptible_by_javascript_dialog(&self) -> bool {
#[cfg(test)]
if matches!(self, Self::TakeDocumentLifecycleEvents) {
@@ -4811,19 +4904,20 @@ impl RendererPageCommand {
mod renderer_inspector_command_envelope_tests {
use super::*;
- fn assert_metadata(
+ fn assert_ticket(
command: &RendererPageCommand,
session: DevToolsSessionKey,
route: RendererInspectorCommandRoute,
) {
- let metadata = command
- .inspector_metadata()
- .expect("every frontend V8 Inspector operation must carry command metadata");
- assert_eq!(metadata.session(), &session);
- assert_eq!(metadata.route(), route);
+ let ticket = command
+ .inspector_ticket()
+ .expect("every frontend V8 Inspector operation must carry an ingress ticket");
+ assert_eq!(ticket.session(), &session);
+ assert_eq!(ticket.route(), route);
+ assert!(ticket.sequence() > 0);
assert_eq!(
- metadata.first_dispatch_lifecycle(),
- RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch
+ command.inspector_first_dispatch_lifecycle(),
+ Some(RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch)
);
}
@@ -4851,41 +4945,74 @@ mod renderer_inspector_command_envelope_tests {
),
];
for command in &main_thread_commands {
- assert_metadata(
+ assert_ticket(
command,
DevToolsSessionKey::Attached("SID-envelope".to_owned()),
RendererInspectorCommandRoute::MainThread,
);
}
- let io_command = RendererPageCommand::dispatch_runtime_protocol_message(
- None,
- RendererInspectorCommandRoute::Io,
- r#"{"id":1,"method":"Runtime.terminateExecution"}"#.to_owned(),
- );
- assert_metadata(
- &io_command,
- DevToolsSessionKey::Primary,
- RendererInspectorCommandRoute::Io,
- );
-
assert!(
RendererPageCommand::PageDiagnosticsSnapshot
- .inspector_metadata()
+ .inspector_ticket()
.is_none(),
"ordinary Page commands must remain outside Inspector lanes"
);
}
+ #[test]
+ #[should_panic(expected = "IO Inspector commands must enter RendererInspectorIoIngress")]
+ fn io_command_cannot_use_the_main_thread_page_envelope() {
+ let _ = RendererPageCommand::dispatch_runtime_protocol_message(
+ None,
+ RendererInspectorCommandRoute::Io,
+ r#"{"id":1,"method":"Runtime.terminateExecution"}"#.to_owned(),
+ );
+ }
+
#[test]
fn empty_wire_session_id_normalizes_to_the_primary_session() {
let command = RendererPageCommand::runtime_enable_events(Some(String::new()));
- assert_metadata(
+ assert_ticket(
&command,
DevToolsSessionKey::Primary,
RendererInspectorCommandRoute::MainThread,
);
}
+
+ #[test]
+ fn ingress_tickets_bind_one_attachment_and_allocate_monotonic_sequences() {
+ let mut first = RendererPageCommand::runtime_enable_events(Some("SID-first".to_owned()));
+ let second = RendererPageCommand::runtime_enable_events(Some("SID-second".to_owned()));
+ let first_sequence = first
+ .inspector_ticket()
+ .expect("first Inspector ticket")
+ .sequence();
+ let second_sequence = second
+ .inspector_ticket()
+ .expect("second Inspector ticket")
+ .sequence();
+ assert!(second_sequence > first_sequence);
+
+ let attachment = RendererAgentAttachmentId::allocate();
+ first.bind_inspector_attachment(attachment);
+ first.bind_inspector_attachment(attachment);
+ assert_eq!(
+ first
+ .inspector_ticket()
+ .expect("bound Inspector ticket")
+ .attachment(),
+ Some(attachment)
+ );
+ }
+
+ #[test]
+ #[should_panic(expected = "cannot be retargeted to another attachment")]
+ fn ingress_ticket_cannot_be_retargeted_during_navigation() {
+ let mut command = RendererPageCommand::runtime_enable_events(None);
+ command.bind_inspector_attachment(RendererAgentAttachmentId::allocate());
+ command.bind_inspector_attachment(RendererAgentAttachmentId::allocate());
+ }
}
#[derive(Debug, Clone, PartialEq)]
diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rs
index 7db678d57..87b063efb 100644
--- a/moli-renderer-v8/src/runtime/page_vm/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs
@@ -1832,6 +1832,12 @@ impl PageVm {
self.vm().inspector_pause_bridge()
}
+ pub(crate) fn inspector_io_ingress(
+ &self,
+ ) -> crate::script_vm::inspector_io::RendererInspectorIoIngress {
+ self.vm().inspector_io_ingress()
+ }
+
pub(super) fn close_for_context_teardown(&mut self) {
let _ = self.document_lifecycle.request_termination(
self.document_lifecycle.identity(),
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index bb82f7448..c70f3a343 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -692,7 +692,9 @@ mod indexed_db_task_body;
mod input_dispatch;
mod input_helpers;
mod inspector;
+pub(crate) mod inspector_io;
pub(crate) mod inspector_pause;
+pub(crate) use inspector::dispatch_inspector_io_owner_wake;
mod isolated_worlds;
mod main_document_lifecycle;
mod main_document_lifecycle_body;
@@ -1024,6 +1026,10 @@ impl ScriptVm {
self.page_inspector.pause_bridge()
}
+ pub(crate) fn inspector_io_ingress(&self) -> inspector_io::RendererInspectorIoIngress {
+ self.page_inspector.io_ingress()
+ }
+
pub(super) fn set_root_document_lifecycle(
&mut self,
lifecycle: crate::runtime::RendererDocumentLifecycleJournalHandle,
diff --git a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs
index 0c99d7188..e7555b4c2 100644
--- a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs
@@ -1,11 +1,10 @@
use super::{
InspectorOutbound,
context_registry::DocumentInspectorContextGroupId,
- v8_backend::{RendererInspectorIsolateBackend, RendererInspectorPauseSessionRegistration},
+ v8_backend::{RendererInspectorIsolateBackend, RendererInspectorSessionExecutorRegistration},
};
use crate::protocol_types::RuntimeBindingRegistration;
use crate::runtime::RendererTurnOutputJournal;
-use crate::script_vm::inspector_pause::RendererInspectorPauseBridge;
use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken, V8InspectorSessionState};
use std::{collections::HashMap, rc::Rc};
@@ -76,13 +75,14 @@ impl RendererDevToolsSessionConnection {
fn outbound(
&self,
- pause_bridge: &RendererInspectorPauseBridge,
+ backend: &RendererInspectorIsolateBackend,
session_key: DevToolsSessionKey,
) -> InspectorOutbound {
+ let pause_bridge = backend.pause_bridge();
InspectorOutbound::for_frontend(
self.agent_token,
session_key.clone(),
- pause_bridge.outbound_route(self.agent_token, session_key),
+ pause_bridge.outbound_route(backend.io_ingress(), self.agent_token, session_key),
self.output_journal.clone(),
)
}
@@ -124,7 +124,7 @@ impl RendererDevToolsAgentSessions {
.cloned()
.unwrap_or_default();
let session = self.frontend.entry(session_key.clone()).or_insert_with(|| {
- let outbound = connection.outbound(&backend.pause_bridge(), session_key.clone());
+ let outbound = connection.outbound(backend, session_key.clone());
RendererDevToolsSession::connect(
backend,
connection.context_group_id,
@@ -184,14 +184,14 @@ impl RendererDevToolsAgentSessions {
session,
outbound,
replayed_runtime_bindings,
- _pause_registration,
+ _executor_registration,
} = previous;
drop(session);
- drop(_pause_registration);
+ drop(_executor_registration);
(outbound, replayed_runtime_bindings)
}
None => (
- connection.outbound(&backend.pause_bridge(), session_key.clone()),
+ connection.outbound(backend, session_key.clone()),
Vec::new(),
),
};
@@ -213,7 +213,7 @@ impl RendererDevToolsAgentSessions {
session_key: DevToolsSessionKey,
) {
self.frontend.entry(session_key.clone()).or_insert_with(|| {
- let outbound = connection.outbound(&backend.pause_bridge(), session_key.clone());
+ let outbound = connection.outbound(backend, session_key.clone());
RendererDevToolsSession::connect(
backend,
connection.context_group_id,
@@ -340,7 +340,7 @@ struct RendererDevToolsSession {
session: Rc<v8::inspector::V8InspectorSession>,
outbound: InspectorOutbound,
replayed_runtime_bindings: Vec<RuntimeBindingRegistration>,
- _pause_registration: Option<RendererInspectorPauseSessionRegistration>,
+ _executor_registration: Option<RendererInspectorSessionExecutorRegistration>,
}
impl RendererDevToolsSession {
@@ -349,7 +349,7 @@ impl RendererDevToolsSession {
context_group_id: DocumentInspectorContextGroupId,
outbound: InspectorOutbound,
state: Option<&V8InspectorSessionState>,
- pause_session: Option<(RendererDevToolsAgentToken, DevToolsSessionKey)>,
+ frontend_session_route: Option<(RendererDevToolsAgentToken, DevToolsSessionKey)>,
) -> Self {
let first_attach_state = b"{}";
let state = state.map_or(
@@ -364,8 +364,8 @@ impl RendererDevToolsSession {
state,
);
let session = Rc::new(session);
- let pause_registration = pause_session.map(|(agent_token, session_key)| {
- backend.register_pause_session(
+ let executor_registration = frontend_session_route.map(|(agent_token, session_key)| {
+ backend.register_session_executor_route(
context_group_id,
agent_token,
session_key,
@@ -377,7 +377,7 @@ impl RendererDevToolsSession {
session,
outbound,
replayed_runtime_bindings: Vec::new(),
- _pause_registration: pause_registration,
+ _executor_registration: executor_registration,
}
}
diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rs
index e85f16569..1a2f38a67 100644
--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs
@@ -27,7 +27,9 @@ pub(super) use self::outbound::ScriptVmInspectorCommandTurnOutputScope;
#[cfg(test)]
use self::v8_backend::RendererInspectorClientUniqueIdState;
pub(in crate::script_vm) use self::v8_backend::RendererInspectorIsolateBackend;
-pub(crate) use self::v8_backend::RendererInspectorIsolateBackendHandle;
+pub(crate) use self::v8_backend::{
+ RendererInspectorIsolateBackendHandle, dispatch_inspector_io_owner_wake,
+};
#[cfg(test)]
use crate::runtime::{
RendererRuntimeCommandOutputRecorder, RendererRuntimeInspectorResponseSender,
@@ -53,6 +55,7 @@ pub(crate) struct DocumentInspectorBinding {
agent: RendererDevToolsAgent,
backend: RefCell<DocumentInspectorBackendState>,
pause_bridge: RendererInspectorPauseBridge,
+ io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,
}
impl std::fmt::Debug for DocumentInspectorBinding {
@@ -93,11 +96,13 @@ pub(super) struct ReportedExecutionContext {
impl DocumentInspectorBinding {
pub(crate) fn new(isolate_backend: RendererInspectorIsolateBackendHandle) -> Self {
let pause_bridge = isolate_backend.pause_bridge();
+ let io_ingress = isolate_backend.io_ingress();
Self {
context_registrations: DocumentInspectorContextRegistrations::default(),
agent: RendererDevToolsAgent::new(isolate_backend),
backend: RefCell::new(DocumentInspectorBackendState::new()),
pause_bridge,
+ io_ingress,
}
}
@@ -113,6 +118,10 @@ impl DocumentInspectorBinding {
self.pause_bridge.clone()
}
+ pub(crate) fn io_ingress(&self) -> crate::script_vm::inspector_io::RendererInspectorIoIngress {
+ self.io_ingress.clone()
+ }
+
pub(crate) fn dom_debugger_pause_scheduler(&self) -> RendererDomDebuggerPauseScheduler {
self.agent.dom_debugger_pause_scheduler()
}
diff --git a/moli-renderer-v8/src/script_vm/inspector/outbound.rs b/moli-renderer-v8/src/script_vm/inspector/outbound.rs
index a64a51504..530902513 100644
--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs
@@ -713,10 +713,14 @@ mod tests {
pause_bridge.configure_page_route(journal.clone());
let agent_token = RendererDevToolsAgentToken::allocate();
let session = DevToolsSessionKey::Primary;
+ let io_ingress = crate::script_vm::inspector_io::RendererInspectorIoIngress::new(
+ pause_bridge.pause_loop_wake(),
+ None,
+ );
let outbound = InspectorOutbound::for_frontend(
agent_token,
session.clone(),
- pause_bridge.outbound_route(agent_token, session.clone()),
+ pause_bridge.outbound_route(io_ingress, agent_token, session.clone()),
Some(journal.clone()),
);
let recorder = RendererCommandTurnOutputRecorder::default();
diff --git a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
index cd6465b84..f03d51d27 100644
--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
@@ -6,7 +6,13 @@ use super::context_registry::{
use crate::{
inspector_microtasks::with_scoped_inspector_microtasks,
runtime::RendererRuntimeInspectorResponseSender,
- script_vm::inspector_pause::{RendererInspectorPauseBridge, RendererInspectorPauseCommand},
+ script_vm::{
+ inspector_io::{
+ RendererInspectorInterruptTarget, RendererInspectorIoCommand,
+ RendererInspectorIoIngress, RendererInspectorIoOwnerWake, RendererInspectorIoRouteId,
+ },
+ inspector_pause::RendererInspectorPauseBridge,
+ },
};
use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken, V8InspectorSessionState};
use serde_json::json;
@@ -14,11 +20,14 @@ use std::{
cell::{Cell, RefCell, UnsafeCell},
collections::HashMap,
rc::{Rc, Weak},
- sync::atomic::{AtomicI64, AtomicUsize, Ordering},
+ sync::{
+ Arc,
+ atomic::{AtomicI64, AtomicUsize, Ordering},
+ },
};
thread_local! {
- static INTERRUPT_LOOPS: RefCell<HashMap<usize, Weak<RendererInspectorPauseLoopLocal>>> =
+ static INSPECTOR_SESSION_EXECUTORS: RefCell<HashMap<RendererInspectorIoRouteId, Weak<RendererInspectorSessionExecutorLocal>>> =
RefCell::new(HashMap::new());
}
@@ -28,52 +37,55 @@ struct RendererInspectorClient {
isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,
context_registry: DocumentInspectorContextRegistry,
unique_id_state: Rc<RendererInspectorClientUniqueIdState>,
- pause_loop: Rc<RendererInspectorPauseLoopLocal>,
+ session_executor: Rc<RendererInspectorSessionExecutorLocal>,
}
#[derive(Clone)]
-struct RendererInspectorPauseSession {
+struct RendererInspectorSessionRoute {
session: Weak<v8::inspector::V8InspectorSession>,
outbound: InspectorOutbound,
agent_token: RendererDevToolsAgentToken,
session_key: DevToolsSessionKey,
}
-pub(super) struct RendererInspectorPauseSessionRegistration {
- pause_loop: Weak<RendererInspectorPauseLoopLocal>,
+pub(super) struct RendererInspectorSessionExecutorRegistration {
+ session_executor: Weak<RendererInspectorSessionExecutorLocal>,
context_group_id: i32,
agent_token: RendererDevToolsAgentToken,
session_key: DevToolsSessionKey,
session: Weak<v8::inspector::V8InspectorSession>,
}
-struct RendererInspectorPauseLoopLocal {
+struct RendererInspectorSessionExecutorLocal {
+ isolate: UnsafeCell<v8::UnsafeRawIsolatePtr>,
bridge: RendererInspectorPauseBridge,
- interrupt_route_id: Option<usize>,
- sessions: RefCell<HashMap<(i32, DevToolsSessionKey), RendererInspectorPauseSession>>,
+ io_ingress: RendererInspectorIoIngress,
+ interrupt_route_id: Option<RendererInspectorIoRouteId>,
+ sessions: RefCell<HashMap<(i32, DevToolsSessionKey), RendererInspectorSessionRoute>>,
interrupt_sessions: RefCell<
- HashMap<(RendererDevToolsAgentToken, DevToolsSessionKey), RendererInspectorPauseSession>,
+ HashMap<(RendererDevToolsAgentToken, DevToolsSessionKey), RendererInspectorSessionRoute>,
>,
}
-impl Drop for RendererInspectorPauseLoopLocal {
+impl Drop for RendererInspectorSessionExecutorLocal {
fn drop(&mut self) {
- let Some(interrupt_route_id) = self.interrupt_route_id else {
- return;
- };
- let _ = INTERRUPT_LOOPS.try_with(|loops| {
- loops.borrow_mut().remove(&interrupt_route_id);
- });
+ if let Some(interrupt_route_id) = self.interrupt_route_id {
+ let _ = INSPECTOR_SESSION_EXECUTORS.try_with(|executors| {
+ executors.borrow_mut().remove(&interrupt_route_id);
+ });
+ }
+ self.io_ingress
+ .close("Inspector session executor was destroyed");
}
}
-impl Drop for RendererInspectorPauseSessionRegistration {
+impl Drop for RendererInspectorSessionExecutorRegistration {
fn drop(&mut self) {
- let Some(pause_loop) = self.pause_loop.upgrade() else {
+ let Some(session_executor) = self.session_executor.upgrade() else {
return;
};
let key = (self.context_group_id, self.session_key.clone());
- let mut sessions = pause_loop.sessions.borrow_mut();
+ let mut sessions = session_executor.sessions.borrow_mut();
if sessions
.get(&key)
.is_some_and(|entry| Weak::ptr_eq(&entry.session, &self.session))
@@ -81,7 +93,7 @@ impl Drop for RendererInspectorPauseSessionRegistration {
sessions.remove(&key);
}
let interrupt_key = (self.agent_token, self.session_key.clone());
- let mut interrupt_sessions = pause_loop.interrupt_sessions.borrow_mut();
+ let mut interrupt_sessions = session_executor.interrupt_sessions.borrow_mut();
if interrupt_sessions
.get(&interrupt_key)
.is_some_and(|entry| Weak::ptr_eq(&entry.session, &self.session))
@@ -91,27 +103,33 @@ impl Drop for RendererInspectorPauseSessionRegistration {
}
}
-impl RendererInspectorPauseLoopLocal {
- fn new(bridge: RendererInspectorPauseBridge) -> Rc<Self> {
- let interrupt_route_id = bridge.interrupt_route_id();
- let pause_loop = Rc::new(Self {
+impl RendererInspectorSessionExecutorLocal {
+ fn new(
+ isolate: v8::UnsafeRawIsolatePtr,
+ bridge: RendererInspectorPauseBridge,
+ io_ingress: RendererInspectorIoIngress,
+ ) -> Rc<Self> {
+ let interrupt_route_id = io_ingress.route_id();
+ let session_executor = Rc::new(Self {
+ isolate: UnsafeCell::new(isolate),
bridge,
+ io_ingress,
interrupt_route_id,
sessions: RefCell::new(HashMap::new()),
interrupt_sessions: RefCell::new(HashMap::new()),
});
if let Some(interrupt_route_id) = interrupt_route_id {
- let previous = INTERRUPT_LOOPS.with(|loops| {
- loops
+ let previous = INSPECTOR_SESSION_EXECUTORS.with(|executors| {
+ executors
.borrow_mut()
- .insert(interrupt_route_id, Rc::downgrade(&pause_loop))
+ .insert(interrupt_route_id, Rc::downgrade(&session_executor))
});
assert!(
previous.is_none(),
"renderer Inspector interrupt route IDs must be unique"
);
}
- pause_loop
+ session_executor
}
fn register_session(
@@ -121,9 +139,9 @@ impl RendererInspectorPauseLoopLocal {
session_key: DevToolsSessionKey,
session: &Rc<v8::inspector::V8InspectorSession>,
outbound: InspectorOutbound,
- ) -> RendererInspectorPauseSessionRegistration {
+ ) -> RendererInspectorSessionExecutorRegistration {
let weak_session = Rc::downgrade(session);
- let route = RendererInspectorPauseSession {
+ let route = RendererInspectorSessionRoute {
session: weak_session.clone(),
outbound,
agent_token,
@@ -139,8 +157,8 @@ impl RendererInspectorPauseLoopLocal {
self.interrupt_sessions
.borrow_mut()
.insert((agent_token, session_key.clone()), route);
- RendererInspectorPauseSessionRegistration {
- pause_loop: Rc::downgrade(self),
+ RendererInspectorSessionExecutorRegistration {
+ session_executor: Rc::downgrade(self),
context_group_id: context_group_id.get(),
agent_token,
session_key,
@@ -152,14 +170,14 @@ impl RendererInspectorPauseLoopLocal {
if !self.bridge.enter_pause() {
return;
}
- while let Some(command) = self.bridge.wait_for_command() {
+ while let Some(command) = self.io_ingress.wait_and_claim_for_pause(&self.bridge) {
self.dispatch_command(context_group_id, command);
}
self.bridge.leave_pause();
}
- fn dispatch_command(&self, context_group_id: i32, command: RendererInspectorPauseCommand) {
- let session_key = command.metadata.session().clone();
+ fn dispatch_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {
+ let session_key = command.ticket().session().clone();
let session = self
.sessions
.borrow()
@@ -170,10 +188,23 @@ impl RendererInspectorPauseLoopLocal {
}
fn dispatch_next_io_command_from_interrupt(&self) {
- let Some(command) = self.bridge.claim_io_command_for_interrupt() else {
+ let Some(command) = self.io_ingress.claim_for_interrupt() else {
+ return;
+ };
+ let session_key = command.ticket().session();
+ let session = self
+ .interrupt_sessions
+ .borrow()
+ .get(&(command.agent_token, session_key.clone()))
+ .cloned();
+ self.dispatch_command_to_session(command, session);
+ }
+
+ fn dispatch_next_io_command_from_owner(&self) {
+ let Some(command) = self.io_ingress.claim_for_owner() else {
return;
};
- let session_key = command.metadata.session();
+ let session_key = command.ticket().session();
let session = self
.interrupt_sessions
.borrow()
@@ -184,25 +215,31 @@ impl RendererInspectorPauseLoopLocal {
fn dispatch_command_to_session(
&self,
- command: RendererInspectorPauseCommand,
- session: Option<RendererInspectorPauseSession>,
+ mut command: RendererInspectorIoCommand,
+ session: Option<RendererInspectorSessionRoute>,
) {
- let mut first_dispatch = self.bridge.first_dispatch_guard(&command);
+ let mut first_dispatch = self.io_ingress.first_dispatch_guard(&command);
let Some(session) = session else {
- send_pause_dispatch_error(command.response, "Inspector session is not available");
+ send_inspector_dispatch_error(
+ command.take_response(),
+ "Inspector session is not available",
+ );
return;
};
let Some(v8_session) = session.session.upgrade() else {
- send_pause_dispatch_error(command.response, "Inspector session has been detached");
+ send_inspector_dispatch_error(
+ command.take_response(),
+ "Inspector session has been detached",
+ );
return;
};
let _command_dispatch = self.bridge.begin_command_dispatch(&command);
- session
- .outbound
- .register_response_callback(command.response);
- first_dispatch.release();
+ if let Some(response) = command.take_response() {
+ session.outbound.register_response_callback(response);
+ }
+ let _post_dispatch_wake = first_dispatch.release_for_dispatch();
v8_session.dispatch_protocol_message(v8::inspector::StringView::from(
- command.raw_json.as_bytes(),
+ command.raw_json().as_bytes(),
));
self.bridge.record_v8_state_update(
session.agent_token,
@@ -228,27 +265,57 @@ unsafe extern "C" fn dispatch_inspector_interrupt(
isolate: v8::UnsafeRawIsolatePtr,
data: *mut std::ffi::c_void,
) {
- let interrupt_route_id = data as usize;
- let pause_loop = INTERRUPT_LOOPS
- .try_with(|loops| {
- loops
+ // SAFETY: every accepted request passes one `Arc::into_raw` reference to
+ // V8, and V8 invokes its interrupt callback at most once for that request.
+ // Reconstructing it here consumes exactly that callback-owned reference.
+ let callback_target = unsafe { Arc::from_raw(data.cast::<RendererInspectorInterruptTarget>()) };
+ let interrupt_route_id = callback_target.route_id();
+ let session_executor = INSPECTOR_SESSION_EXECUTORS
+ .try_with(|executors| {
+ executors
.borrow()
.get(&interrupt_route_id)
.and_then(Weak::upgrade)
})
.ok()
.flatten();
- let Some(pause_loop) = pause_loop else {
+ let Some(session_executor) = session_executor else {
return;
};
let mut isolate_ptr = isolate;
let isolate = unsafe { v8::Isolate::ref_from_raw_isolate_ptr_mut(&mut isolate_ptr) };
with_scoped_inspector_microtasks(isolate, || {
- pause_loop.dispatch_next_io_command_from_interrupt();
+ session_executor.dispatch_next_io_command_from_interrupt();
});
}
-fn send_pause_dispatch_error(response: RendererRuntimeInspectorResponseSender, message: &str) {
+pub(crate) fn dispatch_inspector_io_owner_wake(wake: RendererInspectorIoOwnerWake) {
+ let session_executor = INSPECTOR_SESSION_EXECUTORS
+ .try_with(|executors| {
+ executors
+ .borrow()
+ .get(&wake.route_id())
+ .and_then(Weak::upgrade)
+ })
+ .ok()
+ .flatten();
+ let Some(session_executor) = session_executor else {
+ return;
+ };
+ let isolate = unsafe { &mut *session_executor.isolate.get() };
+ let isolate = unsafe { v8::Isolate::ref_from_raw_isolate_ptr_mut(isolate) };
+ with_scoped_inspector_microtasks(isolate, || {
+ session_executor.dispatch_next_io_command_from_owner();
+ });
+}
+
+fn send_inspector_dispatch_error(
+ response: Option<RendererRuntimeInspectorResponseSender>,
+ message: &str,
+) {
+ let Some(response) = response else {
+ return;
+ };
let call_id = response.call_id();
let _ = response.send(json!({
"id": call_id,
@@ -324,13 +391,13 @@ impl RendererInspectorClient {
isolate: v8::UnsafeRawIsolatePtr,
context_registry: DocumentInspectorContextRegistry,
unique_id_state: Rc<RendererInspectorClientUniqueIdState>,
- pause_loop: Rc<RendererInspectorPauseLoopLocal>,
+ session_executor: Rc<RendererInspectorSessionExecutorLocal>,
) -> Self {
Self {
isolate: UnsafeCell::new(isolate),
context_registry,
unique_id_state,
- pause_loop,
+ session_executor,
}
}
}
@@ -344,12 +411,13 @@ impl v8::inspector::V8InspectorClientImpl for RendererInspectorClient {
let isolate = unsafe { &mut *self.isolate.get() };
let isolate = unsafe { v8::Isolate::ref_from_raw_isolate_ptr_mut(isolate) };
with_scoped_inspector_microtasks(isolate, || {
- self.pause_loop.run_message_loop_on_pause(context_group_id);
+ self.session_executor
+ .run_message_loop_on_pause(context_group_id);
});
}
fn quit_message_loop_on_pause(&self) {
- self.pause_loop.quit_message_loop_on_pause();
+ self.session_executor.quit_message_loop_on_pause();
}
fn generate_unique_id(&self) -> i64 {
@@ -382,6 +450,7 @@ struct RendererInspectorIsolateBackendIdentity;
pub(crate) struct RendererInspectorIsolateBackendHandle {
identity: Rc<RendererInspectorIsolateBackendIdentity>,
pause_bridge: RendererInspectorPauseBridge,
+ io_ingress: RendererInspectorIoIngress,
}
impl std::fmt::Debug for RendererInspectorIsolateBackendHandle {
@@ -398,7 +467,8 @@ pub(in crate::script_vm) struct RendererInspectorIsolateBackend {
pub(super) context_registry: DocumentInspectorContextRegistry,
unique_id_state: Rc<RendererInspectorClientUniqueIdState>,
pause_bridge: RendererInspectorPauseBridge,
- pause_loop: Rc<RendererInspectorPauseLoopLocal>,
+ io_ingress: RendererInspectorIoIngress,
+ session_executor: Rc<RendererInspectorSessionExecutorLocal>,
}
impl RendererInspectorIsolateBackend {
@@ -406,18 +476,26 @@ impl RendererInspectorIsolateBackend {
let isolate_ptr = unsafe { isolate.as_raw_isolate_ptr() };
let context_registry = DocumentInspectorContextRegistry::default();
let unique_id_state = Rc::new(RendererInspectorClientUniqueIdState::new());
- let pause_bridge = RendererInspectorPauseBridge::new_interruptible(
- isolate.thread_safe_handle(),
- dispatch_inspector_interrupt,
- allocate_interrupt_route_id(),
+ let pause_bridge = RendererInspectorPauseBridge::default();
+ let io_ingress = RendererInspectorIoIngress::new(
+ pause_bridge.pause_loop_wake(),
+ Some((
+ isolate.thread_safe_handle(),
+ dispatch_inspector_interrupt,
+ RendererInspectorIoRouteId::new(allocate_interrupt_route_id()),
+ )),
+ );
+ let session_executor = RendererInspectorSessionExecutorLocal::new(
+ isolate_ptr,
+ pause_bridge.clone(),
+ io_ingress.clone(),
);
- let pause_loop = RendererInspectorPauseLoopLocal::new(pause_bridge.clone());
let inspector_client =
v8::inspector::V8InspectorClient::new(Box::new(RendererInspectorClient::new(
isolate_ptr,
context_registry.clone(),
unique_id_state.clone(),
- pause_loop.clone(),
+ session_executor.clone(),
)));
Self {
identity: Rc::new(RendererInspectorIsolateBackendIdentity),
@@ -425,7 +503,8 @@ impl RendererInspectorIsolateBackend {
context_registry,
unique_id_state,
pause_bridge,
- pause_loop,
+ io_ingress,
+ session_executor,
}
}
@@ -433,6 +512,7 @@ impl RendererInspectorIsolateBackend {
RendererInspectorIsolateBackendHandle {
identity: Rc::clone(&self.identity),
pause_bridge: self.pause_bridge.clone(),
+ io_ingress: self.io_ingress.clone(),
}
}
@@ -440,15 +520,19 @@ impl RendererInspectorIsolateBackend {
self.pause_bridge.clone()
}
- pub(super) fn register_pause_session(
+ pub(super) fn io_ingress(&self) -> RendererInspectorIoIngress {
+ self.io_ingress.clone()
+ }
+
+ pub(super) fn register_session_executor_route(
&self,
context_group_id: DocumentInspectorContextGroupId,
agent_token: RendererDevToolsAgentToken,
session_key: DevToolsSessionKey,
session: &Rc<v8::inspector::V8InspectorSession>,
outbound: InspectorOutbound,
- ) -> RendererInspectorPauseSessionRegistration {
- self.pause_loop.register_session(
+ ) -> RendererInspectorSessionExecutorRegistration {
+ self.session_executor.register_session(
context_group_id,
agent_token,
session_key,
@@ -554,6 +638,10 @@ impl RendererInspectorIsolateBackendHandle {
self.pause_bridge.clone()
}
+ pub(super) fn io_ingress(&self) -> RendererInspectorIoIngress {
+ self.io_ingress.clone()
+ }
+
pub(super) fn assert_matches(&self, backend: &RendererInspectorIsolateBackend) {
assert!(
Rc::ptr_eq(&self.identity, &backend.identity),
@@ -563,9 +651,12 @@ impl RendererInspectorIsolateBackendHandle {
#[cfg(test)]
pub(super) fn new_for_test() -> Self {
+ let pause_bridge = RendererInspectorPauseBridge::default();
+ let io_ingress = RendererInspectorIoIngress::new(pause_bridge.pause_loop_wake(), None);
Self {
identity: Rc::new(RendererInspectorIsolateBackendIdentity),
- pause_bridge: RendererInspectorPauseBridge::default(),
+ pause_bridge,
+ io_ingress,
}
}
diff --git a/moli-renderer-v8/src/script_vm/inspector_io.rs b/moli-renderer-v8/src/script_vm/inspector_io.rs
new file mode 100644
index 000000000..4f2811d5e
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/inspector_io.rs
@@ -0,0 +1,779 @@
+use std::{
+ collections::{BTreeMap, VecDeque},
+ ffi::c_void,
+ num::NonZeroUsize,
+ sync::{
+ Arc,
+ atomic::{AtomicBool, Ordering},
+ },
+};
+
+use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken};
+use parking_lot::Mutex;
+use serde_json::json;
+
+use crate::{
+ runtime::{
+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
+ RendererInspectorIngressTicket, RendererRuntimeInspectorResponseSender,
+ },
+ script_vm::inspector_pause::RendererInspectorPauseLoopWake,
+};
+
+type RendererInspectorInterruptCallback =
+ unsafe extern "C" fn(v8::UnsafeRawIsolatePtr, *mut c_void);
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub(crate) struct RendererInspectorIoRouteId(NonZeroUsize);
+
+impl RendererInspectorIoRouteId {
+ pub(crate) fn new(raw: usize) -> Self {
+ Self(NonZeroUsize::new(raw).expect("Inspector IO route ID must be non-zero"))
+ }
+}
+
+pub(crate) struct RendererInspectorInterruptTarget {
+ route_id: RendererInspectorIoRouteId,
+}
+
+impl RendererInspectorInterruptTarget {
+ pub(crate) fn route_id(&self) -> RendererInspectorIoRouteId {
+ self.route_id
+ }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum RendererInspectorIoCommandConsumer {
+ Owner,
+ Interrupt,
+ Pause,
+}
+
+pub(crate) struct RendererInspectorIoCommand {
+ command_id: u64,
+ pub(crate) agent_token: RendererDevToolsAgentToken,
+ envelope: RendererInspectorCommandEnvelope,
+ claim_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorCommandClaim>>,
+ claimed_by: Option<RendererInspectorIoCommandConsumer>,
+}
+
+impl RendererInspectorIoCommand {
+ pub(crate) fn command_id(&self) -> u64 {
+ self.command_id
+ }
+
+ pub(crate) fn ticket(&self) -> &RendererInspectorIngressTicket {
+ self.envelope.ticket()
+ }
+
+ pub(crate) fn first_dispatch_lifecycle(
+ &self,
+ ) -> crate::runtime::RendererInspectorFirstDispatchLifecycle {
+ self.envelope.first_dispatch_lifecycle()
+ }
+
+ pub(crate) fn raw_json(&self) -> &str {
+ self.envelope.io_raw_json()
+ }
+
+ pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
+ self.envelope.io_response()
+ }
+
+ pub(crate) fn take_response(&mut self) -> Option<RendererRuntimeInspectorResponseSender> {
+ self.envelope.take_io_response()
+ }
+
+ #[cfg(test)]
+ pub(crate) fn claimed_by(&self) -> Option<RendererInspectorIoCommandConsumer> {
+ self.claimed_by
+ }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum RendererRuntimeInspectorCommandClaim {
+ Inspector,
+ Canceled,
+}
+
+pub struct RendererRuntimeInspectorCommandRoute {
+ command_id: u64,
+ ticket: RendererInspectorIngressTicket,
+ claim_rx: Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorCommandClaim>>,
+ ingress: RendererInspectorIoIngress,
+}
+
+impl RendererRuntimeInspectorCommandRoute {
+ pub fn command_id(&self) -> u64 {
+ self.command_id
+ }
+
+ pub fn ticket(&self) -> &RendererInspectorIngressTicket {
+ &self.ticket
+ }
+
+ pub async fn wait_for_claim(
+ mut self,
+ ) -> Result<RendererRuntimeInspectorCommandClaim, &'static str> {
+ self.claim_rx
+ .take()
+ .expect("runtime inspector IO command claim receiver should only be awaited once")
+ .await
+ .map_err(|_| "runtime inspector IO command claim channel closed")
+ }
+}
+
+impl Drop for RendererRuntimeInspectorCommandRoute {
+ fn drop(&mut self) {
+ self.ingress.cancel_queued_command(
+ self.command_id,
+ "Runtime inspector IO route was canceled before dispatch",
+ );
+ }
+}
+
+#[derive(Clone)]
+pub(crate) struct RendererInspectorIoIngress {
+ shared: Arc<RendererInspectorIoShared>,
+}
+
+struct RendererInspectorIoShared {
+ state: Mutex<RendererInspectorIoState>,
+ interrupt_armed: AtomicBool,
+ interrupt_route: Option<RendererInspectorInterruptRoute>,
+ pause_wake: RendererInspectorPauseLoopWake,
+}
+
+struct RendererInspectorInterruptRoute {
+ isolate: v8::IsolateHandle,
+ callback: RendererInspectorInterruptCallback,
+ target: Arc<RendererInspectorInterruptTarget>,
+}
+
+#[derive(Clone)]
+pub(crate) struct RendererInspectorIoOwnerWake {
+ route_id: RendererInspectorIoRouteId,
+}
+
+impl RendererInspectorIoOwnerWake {
+ pub(crate) fn route_id(&self) -> RendererInspectorIoRouteId {
+ self.route_id
+ }
+}
+
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct RendererInspectorIoSessionLaneKey {
+ agent_token: RendererDevToolsAgentToken,
+ session: DevToolsSessionKey,
+}
+
+#[derive(Default)]
+struct RendererInspectorIoSessionLane {
+ active_command_id: Option<u64>,
+ queued: VecDeque<RendererInspectorIoCommand>,
+ ready: bool,
+ detached: bool,
+}
+
+struct RendererInspectorIoState {
+ next_command_id: u64,
+ sessions: BTreeMap<RendererInspectorIoSessionLaneKey, RendererInspectorIoSessionLane>,
+ ready_sessions: VecDeque<RendererInspectorIoSessionLaneKey>,
+ owner_wake_tx: Option<tokio::sync::mpsc::UnboundedSender<RendererInspectorIoOwnerWake>>,
+ closed: bool,
+}
+
+pub(crate) struct RendererInspectorIoFirstDispatchGuard {
+ ingress: RendererInspectorIoIngress,
+ active: Option<(RendererInspectorIoSessionLaneKey, u64)>,
+ consumer: RendererInspectorIoCommandConsumer,
+}
+
+pub(crate) struct RendererInspectorIoPostDispatchWakeGuard {
+ ingress: Option<RendererInspectorIoIngress>,
+}
+
+impl Drop for RendererInspectorIoFirstDispatchGuard {
+ fn drop(&mut self) {
+ self.release();
+ }
+}
+
+impl RendererInspectorIoFirstDispatchGuard {
+ pub(crate) fn release(&mut self) {
+ let has_ready = self.release_lane();
+ if has_ready {
+ self.ingress.notify_execution_opportunities();
+ }
+ }
+
+ /// Commits the first-dispatch lifecycle immediately before entering V8,
+ /// but defers scheduling another callback until this dispatch returns. A
+ /// nested pause entered by this dispatch still sees the advanced lane when
+ /// it first polls the IO ingress.
+ pub(crate) fn release_for_dispatch(&mut self) -> RendererInspectorIoPostDispatchWakeGuard {
+ let has_ready = self.release_lane();
+ RendererInspectorIoPostDispatchWakeGuard {
+ ingress: has_ready.then(|| self.ingress.clone()),
+ }
+ }
+
+ fn release_lane(&mut self) -> bool {
+ let Some((lane, command_id)) = self.active.take() else {
+ return false;
+ };
+ if self.consumer == RendererInspectorIoCommandConsumer::Interrupt {
+ self.ingress
+ .shared
+ .interrupt_armed
+ .store(false, Ordering::Release);
+ }
+ self.ingress.finish_first_dispatch(lane, command_id)
+ }
+}
+
+impl Drop for RendererInspectorIoPostDispatchWakeGuard {
+ fn drop(&mut self) {
+ if let Some(ingress) = self.ingress.take() {
+ ingress.notify_execution_opportunities();
+ }
+ }
+}
+
+impl RendererInspectorIoIngress {
+ pub(crate) fn new(
+ pause_wake: RendererInspectorPauseLoopWake,
+ interrupt_route: Option<(
+ v8::IsolateHandle,
+ RendererInspectorInterruptCallback,
+ RendererInspectorIoRouteId,
+ )>,
+ ) -> Self {
+ Self {
+ shared: Arc::new(RendererInspectorIoShared {
+ state: Mutex::new(RendererInspectorIoState {
+ next_command_id: 1,
+ sessions: BTreeMap::new(),
+ ready_sessions: VecDeque::new(),
+ owner_wake_tx: None,
+ closed: false,
+ }),
+ interrupt_armed: AtomicBool::new(false),
+ interrupt_route: interrupt_route.map(|(isolate, callback, route_id)| {
+ RendererInspectorInterruptRoute {
+ isolate,
+ callback,
+ target: Arc::new(RendererInspectorInterruptTarget { route_id }),
+ }
+ }),
+ pause_wake,
+ }),
+ }
+ }
+
+ pub(crate) fn route_id(&self) -> Option<RendererInspectorIoRouteId> {
+ self.shared
+ .interrupt_route
+ .as_ref()
+ .map(|route| route.target.route_id())
+ }
+
+ pub(crate) fn configure_owner_wake(
+ &self,
+ owner_wake_tx: tokio::sync::mpsc::UnboundedSender<RendererInspectorIoOwnerWake>,
+ ) {
+ let has_ready = {
+ let mut state = self.shared.state.lock();
+ state.owner_wake_tx = Some(owner_wake_tx);
+ !state.ready_sessions.is_empty()
+ };
+ if has_ready {
+ self.notify_execution_opportunities();
+ }
+ }
+
+ pub(crate) fn enqueue_command(
+ &self,
+ agent_token: RendererDevToolsAgentToken,
+ envelope: RendererInspectorCommandEnvelope,
+ ) -> RendererRuntimeInspectorCommandRoute {
+ assert_eq!(
+ envelope.ticket().route(),
+ RendererInspectorCommandRoute::Io,
+ "only IO Inspector commands may enter RendererInspectorIoIngress"
+ );
+ let ticket = envelope.ticket().clone();
+ let (claim_tx, claim_rx) = tokio::sync::oneshot::channel();
+ let mut state = self.shared.state.lock();
+ let command_id = state.next_command_id;
+ state.next_command_id = state
+ .next_command_id
+ .checked_add(1)
+ .expect("runtime inspector IO command ID overflow");
+ let lane_key = RendererInspectorIoSessionLaneKey {
+ agent_token,
+ session: ticket.session().clone(),
+ };
+ let command = RendererInspectorIoCommand {
+ command_id,
+ agent_token,
+ envelope,
+ claim_tx: Some(claim_tx),
+ claimed_by: None,
+ };
+ if state.closed {
+ drop(state);
+ fail_io_command(command, "Inspector IO target is closed");
+ return RendererRuntimeInspectorCommandRoute {
+ command_id,
+ ticket,
+ claim_rx: Some(claim_rx),
+ ingress: self.clone(),
+ };
+ }
+ let lane = state.sessions.entry(lane_key.clone()).or_default();
+ if lane.detached {
+ drop(state);
+ fail_io_command(command, "Inspector IO session was detached");
+ return RendererRuntimeInspectorCommandRoute {
+ command_id,
+ ticket,
+ claim_rx: Some(claim_rx),
+ ingress: self.clone(),
+ };
+ }
+ lane.queued.push_back(command);
+ if lane.active_command_id.is_none() && !lane.ready {
+ lane.ready = true;
+ state.ready_sessions.push_back(lane_key);
+ }
+ drop(state);
+ self.notify_execution_opportunities();
+ RendererRuntimeInspectorCommandRoute {
+ command_id,
+ ticket,
+ claim_rx: Some(claim_rx),
+ ingress: self.clone(),
+ }
+ }
+
+ pub(crate) fn claim_for_owner(&self) -> Option<RendererInspectorIoCommand> {
+ self.claim_next(RendererInspectorIoCommandConsumer::Owner)
+ }
+
+ pub(crate) fn claim_for_interrupt(&self) -> Option<RendererInspectorIoCommand> {
+ let command = self.claim_next(RendererInspectorIoCommandConsumer::Interrupt);
+ if command.is_none() {
+ self.shared.interrupt_armed.store(false, Ordering::Release);
+ let has_ready = !self.shared.state.lock().ready_sessions.is_empty();
+ if has_ready {
+ self.request_interrupt();
+ }
+ }
+ command
+ }
+
+ pub(crate) fn claim_for_pause(&self) -> Option<RendererInspectorIoCommand> {
+ self.claim_next(RendererInspectorIoCommandConsumer::Pause)
+ }
+
+ pub(crate) fn wait_and_claim_for_pause(
+ &self,
+ pause_bridge: &crate::script_vm::inspector_pause::RendererInspectorPauseBridge,
+ ) -> Option<RendererInspectorIoCommand> {
+ pause_bridge.wait_for_pause_work(|| self.claim_for_pause())
+ }
+
+ fn claim_next(
+ &self,
+ consumer: RendererInspectorIoCommandConsumer,
+ ) -> Option<RendererInspectorIoCommand> {
+ let mut state = self.shared.state.lock();
+ if state.closed {
+ return None;
+ }
+ while let Some(lane_key) = state.ready_sessions.pop_front() {
+ let Some(lane) = state.sessions.get_mut(&lane_key) else {
+ continue;
+ };
+ lane.ready = false;
+ if lane.active_command_id.is_some() {
+ continue;
+ }
+ let Some(mut command) = lane.queued.pop_front() else {
+ continue;
+ };
+ lane.active_command_id = Some(command.command_id);
+ command.claimed_by = Some(consumer);
+ if let Some(claim_tx) = command.claim_tx.take() {
+ let _ = claim_tx.send(RendererRuntimeInspectorCommandClaim::Inspector);
+ }
+ return Some(command);
+ }
+ None
+ }
+
+ pub(crate) fn first_dispatch_guard(
+ &self,
+ command: &RendererInspectorIoCommand,
+ ) -> RendererInspectorIoFirstDispatchGuard {
+ let lane_key = RendererInspectorIoSessionLaneKey {
+ agent_token: command.agent_token,
+ session: command.ticket().session().clone(),
+ };
+ let state = self.shared.state.lock();
+ assert_eq!(
+ command.first_dispatch_lifecycle(),
+ crate::runtime::RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch,
+ );
+ assert_eq!(
+ state
+ .sessions
+ .get(&lane_key)
+ .and_then(|lane| lane.active_command_id),
+ Some(command.command_id),
+ "a claimed Inspector IO command must own its session lane"
+ );
+ drop(state);
+ RendererInspectorIoFirstDispatchGuard {
+ ingress: self.clone(),
+ active: Some((lane_key, command.command_id)),
+ consumer: command
+ .claimed_by
+ .expect("a first-dispatch guard requires a claimed IO command"),
+ }
+ }
+
+ fn finish_first_dispatch(
+ &self,
+ lane_key: RendererInspectorIoSessionLaneKey,
+ command_id: u64,
+ ) -> bool {
+ {
+ let mut state = self.shared.state.lock();
+ let (make_ready, remove_lane) = {
+ let lane = state
+ .sessions
+ .get_mut(&lane_key)
+ .expect("an active Inspector IO lane must still exist");
+ assert_eq!(
+ lane.active_command_id.take(),
+ Some(command_id),
+ "only the active Inspector IO command may release its lane"
+ );
+ let make_ready = !lane.detached && !lane.queued.is_empty() && !lane.ready;
+ if make_ready {
+ lane.ready = true;
+ }
+ (make_ready, lane.queued.is_empty())
+ };
+ if make_ready {
+ state.ready_sessions.push_back(lane_key.clone());
+ }
+ if remove_lane {
+ state.sessions.remove(&lane_key);
+ }
+ !state.ready_sessions.is_empty()
+ }
+ }
+
+ pub(crate) fn cancel_queued_command(&self, command_id: u64, message: &str) {
+ let command = {
+ let mut state = self.shared.state.lock();
+ let lane_key = state.sessions.iter().find_map(|(key, lane)| {
+ lane.queued
+ .iter()
+ .any(|command| command.command_id == command_id)
+ .then(|| key.clone())
+ });
+ let Some(lane_key) = lane_key else {
+ return;
+ };
+ let lane = state
+ .sessions
+ .get_mut(&lane_key)
+ .expect("located Inspector IO lane must remain present");
+ let position = lane
+ .queued
+ .iter()
+ .position(|command| command.command_id == command_id)
+ .expect("located Inspector IO command must remain queued");
+ let command = lane.queued.remove(position);
+ if lane.queued.is_empty() && lane.active_command_id.is_none() {
+ lane.ready = false;
+ state.ready_sessions.retain(|ready| ready != &lane_key);
+ state.sessions.remove(&lane_key);
+ }
+ command
+ };
+ if let Some(command) = command {
+ fail_io_command(command, message);
+ }
+ }
+
+ pub(crate) fn detach_session(
+ &self,
+ agent_token: RendererDevToolsAgentToken,
+ session: &DevToolsSessionKey,
+ ) {
+ let commands = {
+ let mut state = self.shared.state.lock();
+ let lane_key = RendererInspectorIoSessionLaneKey {
+ agent_token,
+ session: session.clone(),
+ };
+ state.ready_sessions.retain(|ready| ready != &lane_key);
+ let Some(_) = state.sessions.get(&lane_key) else {
+ return;
+ };
+ let (commands, remove_lane) = {
+ let lane = state
+ .sessions
+ .get_mut(&lane_key)
+ .expect("located Inspector IO lane must remain present");
+ lane.ready = false;
+ lane.detached = true;
+ (
+ lane.queued.drain(..).collect::<Vec<_>>(),
+ lane.active_command_id.is_none(),
+ )
+ };
+ if remove_lane {
+ state.sessions.remove(&lane_key);
+ }
+ commands
+ };
+ for command in commands {
+ fail_io_command(command, "Inspector IO session was detached");
+ }
+ }
+
+ pub(crate) fn close(&self, message: &str) {
+ let commands = {
+ let mut state = self.shared.state.lock();
+ state.closed = true;
+ drain_queued_commands(&mut state)
+ };
+ self.shared.pause_wake.notify_all();
+ for command in commands {
+ fail_io_command(command, message);
+ }
+ }
+
+ pub(crate) fn cancel_all_queued(&self, message: &str) {
+ let commands = drain_queued_commands(&mut self.shared.state.lock());
+ for command in commands {
+ fail_io_command(command, message);
+ }
+ }
+
+ fn notify_execution_opportunities(&self) {
+ let owner_wake = {
+ let state = self.shared.state.lock();
+ state.owner_wake_tx.clone().zip(self.route_id())
+ };
+ if let Some((owner_wake_tx, route_id)) = owner_wake {
+ let _ = owner_wake_tx.send(RendererInspectorIoOwnerWake { route_id });
+ }
+ self.request_interrupt();
+ self.shared.pause_wake.notify_one();
+ }
+
+ fn request_interrupt(&self) {
+ let Some(route) = self.shared.interrupt_route.as_ref() else {
+ return;
+ };
+ if self
+ .shared
+ .interrupt_armed
+ .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+ .is_err()
+ {
+ return;
+ }
+ // Match Chromium's InspectorTaskRunner lifetime protocol: every V8
+ // interrupt owns one strong callback target until V8 invokes it. A
+ // late callback after executor teardown can therefore safely observe
+ // that its TLS route disappeared without dereferencing stale state.
+ let callback_target = Arc::into_raw(Arc::clone(&route.target));
+ let callback_data = callback_target.cast_mut().cast::<c_void>();
+ if !route
+ .isolate
+ .request_interrupt(route.callback, callback_data)
+ {
+ // SAFETY: `callback_target` came from `Arc::into_raw` immediately
+ // above, and V8 rejected the request, so no callback can consume
+ // this one strong reference.
+ unsafe { drop(Arc::from_raw(callback_target)) };
+ self.shared.interrupt_armed.store(false, Ordering::Release);
+ }
+ }
+}
+
+fn drain_queued_commands(state: &mut RendererInspectorIoState) -> Vec<RendererInspectorIoCommand> {
+ state.ready_sessions.clear();
+ let commands = state
+ .sessions
+ .values_mut()
+ .flat_map(|lane| lane.queued.drain(..))
+ .collect();
+ state
+ .sessions
+ .retain(|_, lane| lane.active_command_id.is_some());
+ commands
+}
+
+impl std::fmt::Debug for RendererInspectorIoIngress {
+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let state = self.shared.state.lock();
+ formatter
+ .debug_struct("RendererInspectorIoIngress")
+ .field("route_id", &self.route_id())
+ .field("session_lanes", &state.sessions.len())
+ .field("ready_sessions", &state.ready_sessions.len())
+ .field(
+ "interrupt_armed",
+ &self.shared.interrupt_armed.load(Ordering::Acquire),
+ )
+ .field("closed", &state.closed)
+ .finish()
+ }
+}
+
+fn fail_io_command(mut command: RendererInspectorIoCommand, message: &str) {
+ if let Some(claim_tx) = command.claim_tx.take() {
+ let _ = claim_tx.send(RendererRuntimeInspectorCommandClaim::Canceled);
+ }
+ let Some(response) = command.take_response() else {
+ return;
+ };
+ let call_id = response.call_id();
+ let _ = response.send(json!({
+ "id": call_id,
+ "error": {
+ "code": -32000,
+ "message": message,
+ },
+ }));
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::{
+ runtime::RendererInspectorIngressTicket,
+ script_vm::inspector_pause::RendererInspectorPauseBridge,
+ };
+
+ fn ingress() -> RendererInspectorIoIngress {
+ let pause_bridge = RendererInspectorPauseBridge::default();
+ RendererInspectorIoIngress::new(pause_bridge.pause_loop_wake(), None)
+ }
+
+ fn enqueue(
+ ingress: &RendererInspectorIoIngress,
+ agent_token: RendererDevToolsAgentToken,
+ session: Option<&str>,
+ raw_json: &str,
+ ) -> RendererRuntimeInspectorCommandRoute {
+ ingress.enqueue_command(
+ agent_token,
+ RendererInspectorCommandEnvelope::new_io(
+ RendererInspectorIngressTicket::new(
+ None,
+ session.map(str::to_owned),
+ RendererInspectorCommandRoute::Io,
+ ),
+ raw_json.to_owned(),
+ None,
+ ),
+ )
+ }
+
+ #[test]
+ fn owner_interrupt_and_pause_race_can_claim_one_command_only_once() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let _route = enqueue(&ingress, agent, Some("session-a"), "first");
+
+ let owner = ingress.claim_for_owner();
+ let interrupt = ingress.claim_for_interrupt();
+ let pause = ingress.claim_for_pause();
+ assert_eq!(
+ usize::from(owner.is_some())
+ + usize::from(interrupt.is_some())
+ + usize::from(pause.is_some()),
+ 1
+ );
+ assert_eq!(
+ owner.and_then(|command| command.claimed_by()),
+ Some(RendererInspectorIoCommandConsumer::Owner)
+ );
+ }
+
+ #[test]
+ fn one_session_is_fifo_while_another_session_is_independent() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let _a1 = enqueue(&ingress, agent, Some("session-a"), "a1");
+ let _a2 = enqueue(&ingress, agent, Some("session-a"), "a2");
+ let _b1 = enqueue(&ingress, agent, Some("session-b"), "b1");
+
+ let first = ingress.claim_for_owner().expect("first ready session");
+ assert_eq!(first.raw_json(), "a1");
+ let second = ingress
+ .claim_for_interrupt()
+ .expect("other session must remain independently ready");
+ assert_eq!(second.raw_json(), "b1");
+ assert!(ingress.claim_for_pause().is_none());
+
+ ingress.first_dispatch_guard(&first).release();
+ let third = ingress.claim_for_pause().expect("a2 after a1 dispatch");
+ assert_eq!(third.raw_json(), "a2");
+ }
+
+ #[tokio::test]
+ async fn detach_cancels_the_queue_while_an_active_first_dispatch_guard_finishes_safely() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let first_route = enqueue(&ingress, agent, Some("session-a"), "a1");
+ let second_route = enqueue(&ingress, agent, Some("session-a"), "a2");
+
+ let first = ingress
+ .claim_for_interrupt()
+ .expect("the session head should be claimable");
+ let mut first_dispatch = ingress.first_dispatch_guard(&first);
+ assert_eq!(
+ first_route.wait_for_claim().await,
+ Ok(RendererRuntimeInspectorCommandClaim::Inspector)
+ );
+
+ ingress.detach_session(agent, &DevToolsSessionKey::Attached("session-a".to_owned()));
+ assert_eq!(
+ second_route.wait_for_claim().await,
+ Ok(RendererRuntimeInspectorCommandClaim::Canceled),
+ "detach must cancel commands that have not been claimed"
+ );
+
+ first_dispatch.release();
+ assert!(
+ ingress.shared.state.lock().sessions.is_empty(),
+ "the detached lane must retire after its active first dispatch releases"
+ );
+ }
+
+ #[test]
+ #[should_panic(expected = "only IO Inspector commands")]
+ fn main_thread_command_cannot_enter_io_ingress() {
+ let ingress = ingress();
+ let page_command = crate::runtime::RendererPageCommand::dispatch_runtime_protocol_message(
+ Some("session-a".to_owned()),
+ RendererInspectorCommandRoute::MainThread,
+ "main".to_owned(),
+ );
+ let crate::runtime::RendererPageCommand::Inspector(envelope) = page_command else {
+ panic!("runtime protocol message must use an Inspector envelope");
+ };
+ let _ = ingress.enqueue_command(RendererDevToolsAgentToken::allocate(), envelope);
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/inspector_pause.rs b/moli-renderer-v8/src/script_vm/inspector_pause.rs
index 06ba9c39e..e8c5d7ec4 100644
--- a/moli-renderer-v8/src/script_vm/inspector_pause.rs
+++ b/moli-renderer-v8/src/script_vm/inspector_pause.rs
@@ -1,114 +1,32 @@
use std::{
- collections::{HashMap, HashSet, VecDeque},
- ffi::c_void,
- sync::Arc,
+ collections::{HashSet, VecDeque},
+ sync::{Arc, Weak},
};
use moli_page_types::{DevToolsSessionKey, RendererDevToolsAgentToken, V8InspectorSessionState};
use parking_lot::{Condvar, Mutex};
-use serde_json::{Value, json};
+use serde_json::Value;
+#[cfg(test)]
+use serde_json::json;
+#[cfg(test)]
+use crate::runtime::RendererRuntimeInspectorResponseSender;
use crate::runtime::{
- PageId, PendingRendererOutputRecord, RendererInspectorCommandMetadata,
- RendererInspectorCommandRoute, RendererOutputResidenceIdentity, RendererProtocolObservation,
- RendererRuntimeCommandCausalIdentity, RendererRuntimeInspectorMessage,
- RendererRuntimeInspectorMessageBatch, RendererRuntimeInspectorResponseSender,
+ PageId, PendingRendererOutputRecord, RendererOutputResidenceIdentity,
+ RendererProtocolObservation, RendererRuntimeCommandCausalIdentity,
+ RendererRuntimeInspectorMessage, RendererRuntimeInspectorMessageBatch,
RendererTurnOutputJournal,
};
-
-pub(crate) struct RendererInspectorPauseCommand {
- command_id: u64,
- pub(crate) agent_token: RendererDevToolsAgentToken,
- pub(crate) metadata: RendererInspectorCommandMetadata,
- pub(crate) owner_context_resolution_action: Option<String>,
- pub(crate) raw_json: String,
- pub(crate) response: RendererRuntimeInspectorResponseSender,
- claim_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorCommandClaim>>,
-}
-
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-struct RendererInspectorFirstDispatchLane {
- agent_token: RendererDevToolsAgentToken,
- session: DevToolsSessionKey,
- route: RendererInspectorCommandRoute,
-}
-
-impl RendererInspectorPauseCommand {
- fn first_dispatch_lane(&self) -> RendererInspectorFirstDispatchLane {
- RendererInspectorFirstDispatchLane {
- agent_token: self.agent_token,
- session: self.metadata.session().clone(),
- route: self.metadata.route(),
- }
- }
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum RendererRuntimeInspectorCommandClaim {
- Owner,
- Inspector,
- Canceled,
-}
-
-pub struct RendererRuntimeInspectorCommandRoute {
- command_id: u64,
- metadata: RendererInspectorCommandMetadata,
- requires_owner_fallback: bool,
- claim_rx: Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorCommandClaim>>,
- bridge: RendererInspectorPauseBridge,
-}
-
-impl RendererRuntimeInspectorCommandRoute {
- pub fn command_id(&self) -> u64 {
- self.command_id
- }
-
- pub fn metadata(&self) -> &RendererInspectorCommandMetadata {
- &self.metadata
- }
-
- pub fn requires_owner_fallback(&self) -> bool {
- self.requires_owner_fallback
- }
-
- pub async fn wait_for_claim(
- mut self,
- ) -> Result<RendererRuntimeInspectorCommandClaim, &'static str> {
- self.claim_rx
- .take()
- .expect("runtime inspector command claim receiver should only be awaited once")
- .await
- .map_err(|_| "runtime inspector command claim channel closed")
- }
-}
-
-impl Drop for RendererRuntimeInspectorCommandRoute {
- fn drop(&mut self) {
- self.bridge.cancel_queued_command(
- self.command_id,
- "Runtime inspector command route was canceled before dispatch",
- );
- }
-}
+use crate::script_vm::inspector_io::{RendererInspectorIoCommand, RendererInspectorIoIngress};
#[derive(Clone)]
pub(crate) struct RendererInspectorPauseBridge {
shared: Arc<RendererInspectorPauseBridgeShared>,
}
-struct RendererInspectorPauseBridgeShared {
+pub(crate) struct RendererInspectorPauseBridgeShared {
state: Mutex<RendererInspectorPauseBridgeState>,
- command_ready: Condvar,
- interrupt_route: Option<RendererInspectorInterruptRoute>,
-}
-
-type RendererInspectorInterruptCallback =
- unsafe extern "C" fn(v8::UnsafeRawIsolatePtr, *mut c_void);
-
-struct RendererInspectorInterruptRoute {
- isolate: v8::IsolateHandle,
- callback: RendererInspectorInterruptCallback,
- callback_data: usize,
+ pause_loop_wake: Condvar,
}
#[derive(Clone)]
@@ -124,14 +42,11 @@ enum RendererInspectorPausePhase {
}
struct RendererInspectorPauseBridgeState {
- next_command_id: u64,
next_preface_id: u64,
phase: RendererInspectorPausePhase,
quit_requested: bool,
session_detach_arms: usize,
target_closed: bool,
- active_first_dispatch_lanes: HashMap<RendererInspectorFirstDispatchLane, u64>,
- commands: VecDeque<RendererInspectorPauseCommand>,
pending_prefaces: VecDeque<RendererInspectorPausePreface>,
paused_sessions_awaiting_resumed: HashSet<(RendererDevToolsAgentToken, DevToolsSessionKey)>,
// V8 dispatches one nested-loop command synchronously. A successful
@@ -239,25 +154,26 @@ pub(super) struct RendererInspectorPausePrefaceGuard {
id: u64,
}
-pub(crate) struct RendererInspectorFirstDispatchGuard {
- bridge: RendererInspectorPauseBridge,
- active: Option<(RendererInspectorFirstDispatchLane, u64)>,
+#[derive(Clone)]
+pub(crate) struct RendererInspectorPauseLoopWake {
+ shared: Weak<RendererInspectorPauseBridgeShared>,
}
-impl Drop for RendererInspectorFirstDispatchGuard {
- fn drop(&mut self) {
- self.release();
+impl RendererInspectorPauseLoopWake {
+ pub(crate) fn notify_one(&self) {
+ let Some(shared) = self.shared.upgrade() else {
+ return;
+ };
+ let _state = shared.state.lock();
+ shared.pause_loop_wake.notify_one();
}
-}
-impl RendererInspectorFirstDispatchGuard {
- /// Releases the lane at the call boundary into V8 Inspector. The command
- /// response and any JavaScript it starts may remain pending after this
- /// point; neither is part of the first-dispatch lifetime.
- pub(crate) fn release(&mut self) {
- if let Some((lane, command_id)) = self.active.take() {
- self.bridge.finish_first_dispatch(lane, command_id);
- }
+ pub(crate) fn notify_all(&self) {
+ let Some(shared) = self.shared.upgrade() else {
+ return;
+ };
+ let _state = shared.state.lock();
+ shared.pause_loop_wake.notify_all();
}
}
@@ -269,55 +185,35 @@ impl Drop for RendererInspectorPausePrefaceGuard {
#[derive(Clone)]
pub(super) struct RendererInspectorPauseOutboundRoute {
bridge: RendererInspectorPauseBridge,
+ io_ingress: RendererInspectorIoIngress,
agent_token: RendererDevToolsAgentToken,
session: DevToolsSessionKey,
}
impl Default for RendererInspectorPauseBridge {
fn default() -> Self {
- Self::new(None)
+ Self::new()
}
}
impl RendererInspectorPauseBridge {
- pub(super) fn new_interruptible(
- isolate: v8::IsolateHandle,
- callback: RendererInspectorInterruptCallback,
- callback_data: usize,
- ) -> Self {
- assert_ne!(
- callback_data, 0,
- "Inspector interrupt route ID must be non-zero"
- );
- Self::new(Some(RendererInspectorInterruptRoute {
- isolate,
- callback,
- callback_data,
- }))
- }
-
- fn new(interrupt_route: Option<RendererInspectorInterruptRoute>) -> Self {
- Self {
- shared: Arc::new(RendererInspectorPauseBridgeShared {
- state: Mutex::new(RendererInspectorPauseBridgeState {
- next_command_id: 1,
- next_preface_id: 1,
- phase: RendererInspectorPausePhase::Running,
- quit_requested: false,
- session_detach_arms: 0,
- target_closed: false,
- active_first_dispatch_lanes: HashMap::new(),
- commands: VecDeque::new(),
- pending_prefaces: VecDeque::new(),
- paused_sessions_awaiting_resumed: HashSet::new(),
- active_command_dispatch: None,
- pending_command_transition: None,
- route: None,
- }),
- command_ready: Condvar::new(),
- interrupt_route,
+ fn new() -> Self {
+ let shared = Arc::new(RendererInspectorPauseBridgeShared {
+ state: Mutex::new(RendererInspectorPauseBridgeState {
+ next_preface_id: 1,
+ phase: RendererInspectorPausePhase::Running,
+ quit_requested: false,
+ session_detach_arms: 0,
+ target_closed: false,
+ pending_prefaces: VecDeque::new(),
+ paused_sessions_awaiting_resumed: HashSet::new(),
+ active_command_dispatch: None,
+ pending_command_transition: None,
+ route: None,
}),
- }
+ pause_loop_wake: Condvar::new(),
+ });
+ Self { shared }
}
}
@@ -330,11 +226,6 @@ impl std::fmt::Debug for RendererInspectorPauseBridge {
.field("quit_requested", &state.quit_requested)
.field("session_detach_arms", &state.session_detach_arms)
.field("target_closed", &state.target_closed)
- .field(
- "active_first_dispatch_lanes",
- &state.active_first_dispatch_lanes,
- )
- .field("pending_commands", &state.commands.len())
.field("pending_prefaces", &state.pending_prefaces.len())
.field(
"paused_sessions_awaiting_resumed",
@@ -353,20 +244,21 @@ impl std::fmt::Debug for RendererInspectorPauseBridge {
}
impl RendererInspectorPauseBridge {
- pub(super) fn interrupt_route_id(&self) -> Option<usize> {
- self.shared
- .interrupt_route
- .as_ref()
- .map(|route| route.callback_data)
+ pub(crate) fn pause_loop_wake(&self) -> RendererInspectorPauseLoopWake {
+ RendererInspectorPauseLoopWake {
+ shared: Arc::downgrade(&self.shared),
+ }
}
pub(super) fn outbound_route(
&self,
+ io_ingress: RendererInspectorIoIngress,
agent_token: RendererDevToolsAgentToken,
session: DevToolsSessionKey,
) -> RendererInspectorPauseOutboundRoute {
RendererInspectorPauseOutboundRoute {
bridge: self.clone(),
+ io_ingress,
agent_token,
session,
}
@@ -386,19 +278,24 @@ impl RendererInspectorPauseBridge {
pub(super) fn begin_command_dispatch(
&self,
- command: &RendererInspectorPauseCommand,
+ command: &RendererInspectorIoCommand,
) -> RendererInspectorPauseCommandDispatchGuard {
- let effect = RendererInspectorPauseCommandEffect::from_raw_json(&command.raw_json);
+ let effect = RendererInspectorPauseCommandEffect::from_raw_json(command.raw_json());
if effect == RendererInspectorPauseCommandEffect::None {
return RendererInspectorPauseCommandDispatchGuard {
bridge: self.clone(),
command_id: None,
};
}
- let call_id = command.response.call_id();
+ let Some(call_id) = command.response().map(|response| response.call_id()) else {
+ return RendererInspectorPauseCommandDispatchGuard {
+ bridge: self.clone(),
+ command_id: None,
+ };
+ };
let causal_identity = RendererRuntimeCommandCausalIdentity::new(
command
- .metadata
+ .ticket()
.session()
.wire_session_id()
.map(str::to_owned),
@@ -411,7 +308,7 @@ impl RendererInspectorPauseBridge {
"Inspector pause commands must dispatch serially in the nested loop"
);
state.active_command_dispatch = Some(RendererInspectorPauseCommandDispatch {
- command_id: command.command_id,
+ command_id: command.command_id(),
transition: RendererInspectorPauseCommandTransition {
causal_identity,
effect,
@@ -422,7 +319,7 @@ impl RendererInspectorPauseBridge {
});
RendererInspectorPauseCommandDispatchGuard {
bridge: self.clone(),
- command_id: Some(command.command_id),
+ command_id: Some(command.command_id()),
}
}
@@ -522,7 +419,7 @@ impl RendererInspectorPauseBridge {
.checked_add(1)
.expect("runtime inspector session detach arm count overflow");
if state.phase != RendererInspectorPausePhase::Running {
- self.shared.command_ready.notify_all();
+ self.shared.pause_loop_wake.notify_all();
}
}
@@ -534,130 +431,6 @@ impl RendererInspectorPauseBridge {
.expect("runtime inspector session detach arm count underflow");
}
- pub(crate) fn enqueue_command(
- &self,
- agent_token: RendererDevToolsAgentToken,
- inspector_session_id: Option<String>,
- route: RendererInspectorCommandRoute,
- owner_context_resolution_action: Option<String>,
- raw_json: String,
- response: RendererRuntimeInspectorResponseSender,
- ) -> RendererRuntimeInspectorCommandRoute {
- let (claim_tx, claim_rx) = tokio::sync::oneshot::channel();
- let mut state = self.shared.state.lock();
- let command_id = state.next_command_id;
- state.next_command_id = state
- .next_command_id
- .checked_add(1)
- .expect("runtime inspector pause command ID overflow");
- let metadata = RendererInspectorCommandMetadata::new(inspector_session_id, route);
- let command = RendererInspectorPauseCommand {
- command_id,
- agent_token,
- metadata: metadata.clone(),
- owner_context_resolution_action,
- raw_json,
- response,
- claim_tx: Some(claim_tx),
- };
- if state.target_closed {
- drop(state);
- fail_pause_command(command, "Inspector target closed while paused");
- return RendererRuntimeInspectorCommandRoute {
- command_id,
- metadata,
- requires_owner_fallback: false,
- claim_rx: Some(claim_rx),
- bridge: self.clone(),
- };
- }
- let pause_active = state.phase != RendererInspectorPausePhase::Running;
- state.commands.push_back(command);
- if pause_active {
- self.shared.command_ready.notify_one();
- }
- drop(state);
- if route == RendererInspectorCommandRoute::Io {
- self.request_io_interrupt();
- }
- RendererRuntimeInspectorCommandRoute {
- command_id,
- metadata,
- // Every route keeps an owner fallback. IO can win through a V8
- // interrupt, while both Chromium transport routes can run in the
- // nested debugger loop. If V8 unwinds first, the already-queued
- // owner turn can dispatch the still-unclaimed command.
- requires_owner_fallback: true,
- claim_rx: Some(claim_rx),
- bridge: self.clone(),
- }
- }
-
- fn request_io_interrupt(&self) {
- let Some(route) = self.shared.interrupt_route.as_ref() else {
- return;
- };
- let _ = route
- .isolate
- .request_interrupt(route.callback, route.callback_data as *mut c_void);
- }
-
- pub(crate) fn claim_command_for_owner(
- &self,
- command_id: u64,
- ) -> Option<RendererInspectorPauseCommand> {
- let mut state = self.shared.state.lock();
- if state.target_closed || state.phase != RendererInspectorPausePhase::Running {
- return None;
- }
- let position = state
- .commands
- .iter()
- .position(|command| command.command_id == command_id)?;
- let lane = state.commands[position].first_dispatch_lane();
- if state.active_first_dispatch_lanes.contains_key(&lane)
- || state
- .commands
- .iter()
- .take(position)
- .any(|command| command.first_dispatch_lane() == lane)
- {
- return None;
- }
- let command = state
- .commands
- .remove(position)
- .expect("queued runtime inspector command position should remain valid");
- assert!(
- state
- .active_first_dispatch_lanes
- .insert(lane, command.command_id)
- .is_none(),
- "a first-dispatch lane must have at most one active command"
- );
- Some(claim_pause_command(
- command,
- RendererRuntimeInspectorCommandClaim::Owner,
- ))
- }
-
- pub(crate) fn cancel_queued_command(&self, command_id: u64, message: &str) {
- let command = {
- let mut state = self.shared.state.lock();
- let Some(position) = state
- .commands
- .iter()
- .position(|command| command.command_id == command_id)
- else {
- return;
- };
- state.commands.remove(position)
- };
- if let Some(command) = command {
- fail_pause_command(command, message);
- }
- }
-
pub(super) fn enter_pause(&self) -> bool {
let mut state = self.shared.state.lock();
if state.target_closed || state.phase != RendererInspectorPausePhase::Entering {
@@ -667,101 +440,16 @@ impl RendererInspectorPauseBridge {
true
}
- pub(super) fn wait_for_command(&self) -> Option<RendererInspectorPauseCommand> {
+ pub(crate) fn wait_for_pause_work<T>(&self, mut claim: impl FnMut() -> Option<T>) -> Option<T> {
let mut state = self.shared.state.lock();
loop {
if state.target_closed || state.quit_requested || state.session_detach_arms != 0 {
return None;
}
- if let Some(position) = state.commands.iter().position(|command| {
- !state
- .active_first_dispatch_lanes
- .contains_key(&command.first_dispatch_lane())
- }) {
- let command = state
- .commands
- .remove(position)
- .expect("queued Inspector command position must remain valid");
- let lane = command.first_dispatch_lane();
- assert!(
- state
- .active_first_dispatch_lanes
- .insert(lane, command.command_id)
- .is_none(),
- "a first-dispatch lane must have at most one active command"
- );
- return Some(claim_pause_command(
- command,
- RendererRuntimeInspectorCommandClaim::Inspector,
- ));
+ if let Some(work) = claim() {
+ return Some(work);
}
- self.shared.command_ready.wait(&mut state);
- }
- }
-
- pub(super) fn claim_io_command_for_interrupt(&self) -> Option<RendererInspectorPauseCommand> {
- let mut state = self.shared.state.lock();
- if state.target_closed {
- return None;
- }
- let position = state.commands.iter().position(|command| {
- command.metadata.route() == RendererInspectorCommandRoute::Io
- && !state
- .active_first_dispatch_lanes
- .contains_key(&command.first_dispatch_lane())
- })?;
- let command = state
- .commands
- .remove(position)
- .expect("queued IO Inspector command position must remain valid");
- let lane = command.first_dispatch_lane();
- assert!(
- state
- .active_first_dispatch_lanes
- .insert(lane, command.command_id)
- .is_none(),
- "a first-dispatch lane must have at most one active command"
- );
- Some(claim_pause_command(
- command,
- RendererRuntimeInspectorCommandClaim::Inspector,
- ))
- }
-
- pub(crate) fn first_dispatch_guard(
- &self,
- command: &RendererInspectorPauseCommand,
- ) -> RendererInspectorFirstDispatchGuard {
- let lane = command.first_dispatch_lane();
- let state = self.shared.state.lock();
- assert_eq!(
- state.active_first_dispatch_lanes.get(&lane),
- Some(&command.command_id),
- "a claimed Inspector command must own its first-dispatch lane"
- );
- drop(state);
- RendererInspectorFirstDispatchGuard {
- bridge: self.clone(),
- active: Some((lane, command.command_id)),
- }
- }
-
- fn finish_first_dispatch(&self, lane: RendererInspectorFirstDispatchLane, command_id: u64) {
- let has_waiting_io = {
- let mut state = self.shared.state.lock();
- assert_eq!(
- state.active_first_dispatch_lanes.remove(&lane),
- Some(command_id),
- "only the active Inspector command may release its first-dispatch lane"
- );
- self.shared.command_ready.notify_all();
- state
- .commands
- .iter()
- .any(|command| command.metadata.route() == RendererInspectorCommandRoute::Io)
- };
- if has_waiting_io {
- self.request_io_interrupt();
+ self.shared.pause_loop_wake.wait(&mut state);
}
}
@@ -769,7 +457,7 @@ impl RendererInspectorPauseBridge {
let mut state = self.shared.state.lock();
if state.phase != RendererInspectorPausePhase::Running {
state.quit_requested = true;
- self.shared.command_ready.notify_all();
+ self.shared.pause_loop_wake.notify_all();
}
}
@@ -777,61 +465,48 @@ impl RendererInspectorPauseBridge {
let mut state = self.shared.state.lock();
state.phase = RendererInspectorPausePhase::Running;
state.quit_requested = false;
- // Commands that lost the nested-loop race to Debugger.resume stay
- // queued. Every live route has an owner fallback queued before it is
- // exposed to the caller, so owner dispatch claims them after V8
- // unwinds instead of reporting a synthetic cancellation.
+ // IO commands that lost the nested-loop race stay in their dedicated
+ // ingress and retain independent owner/interrupt execution chances.
}
- pub(crate) fn detach_page(&self, page_id: PageId) {
- let commands = {
- let mut state = self.shared.state.lock();
- let route_page_id = state.route.as_ref().and_then(|route| {
- match route.output_journal.stream().residence() {
- RendererOutputResidenceIdentity::Page { page_id, .. } => Some(page_id),
- RendererOutputResidenceIdentity::SharedWorker { .. }
- | RendererOutputResidenceIdentity::ServiceWorker { .. } => None,
- }
- });
- if route_page_id != Some(page_id) {
- return;
+ pub(crate) fn detach_page(&self, page_id: PageId) -> bool {
+ let mut state = self.shared.state.lock();
+ let route_page_id = state.route.as_ref().and_then(|route| {
+ match route.output_journal.stream().residence() {
+ RendererOutputResidenceIdentity::Page { page_id, .. } => Some(page_id),
+ RendererOutputResidenceIdentity::SharedWorker { .. }
+ | RendererOutputResidenceIdentity::ServiceWorker { .. } => None,
}
- state.route = None;
- state.pending_prefaces.clear();
- state.paused_sessions_awaiting_resumed.clear();
- state.pending_command_transition = None;
- match state.phase {
- RendererInspectorPausePhase::Running => {}
- RendererInspectorPausePhase::Entering => {
- state.phase = RendererInspectorPausePhase::Running;
- state.quit_requested = false;
- }
- RendererInspectorPausePhase::Paused => {
- state.quit_requested = true;
- self.shared.command_ready.notify_all();
- }
+ });
+ if route_page_id != Some(page_id) {
+ return false;
+ }
+ state.route = None;
+ state.pending_prefaces.clear();
+ state.paused_sessions_awaiting_resumed.clear();
+ state.pending_command_transition = None;
+ match state.phase {
+ RendererInspectorPausePhase::Running => {}
+ RendererInspectorPausePhase::Entering => {
+ state.phase = RendererInspectorPausePhase::Running;
+ state.quit_requested = false;
+ }
+ RendererInspectorPausePhase::Paused => {
+ state.quit_requested = true;
+ self.shared.pause_loop_wake.notify_all();
}
- state.commands.drain(..).collect::<Vec<_>>()
- };
- for command in commands {
- fail_pause_command(command, "Inspector page closed while paused");
}
+ true
}
pub(crate) fn close_target(&self) {
- let commands = {
- let mut state = self.shared.state.lock();
- state.target_closed = true;
- state.quit_requested = true;
- state.pending_prefaces.clear();
- state.paused_sessions_awaiting_resumed.clear();
- state.pending_command_transition = None;
- self.shared.command_ready.notify_all();
- state.commands.drain(..).collect::<Vec<_>>()
- };
- for command in commands {
- fail_pause_command(command, "Inspector target closed while paused");
- }
+ let mut state = self.shared.state.lock();
+ state.target_closed = true;
+ state.quit_requested = true;
+ state.pending_prefaces.clear();
+ state.paused_sessions_awaiting_resumed.clear();
+ state.pending_command_transition = None;
+ self.shared.pause_loop_wake.notify_all();
}
pub(super) fn record_v8_state_update(
@@ -990,6 +665,8 @@ impl RendererInspectorPauseOutboundRoute {
pub(super) fn detach_session(&self) {
self.bridge.detach_session(self.agent_token, &self.session);
+ self.io_ingress
+ .detach_session(self.agent_token, &self.session);
}
pub(super) fn stage_pause_preface(
@@ -1001,18 +678,6 @@ impl RendererInspectorPauseOutboundRoute {
}
}
-fn fail_pause_command(command: RendererInspectorPauseCommand, message: &str) {
- let command = claim_pause_command(command, RendererRuntimeInspectorCommandClaim::Canceled);
- let call_id = command.response.call_id();
- let _ = command.response.send(json!({
- "id": call_id,
- "error": {
- "code": -32000,
- "message": message,
- },
- }));
-}
-
pub(super) struct RendererInspectorPauseCommandDispatchGuard {
bridge: RendererInspectorPauseBridge,
command_id: Option<u64>,
@@ -1026,19 +691,19 @@ impl Drop for RendererInspectorPauseCommandDispatchGuard {
}
}
-fn claim_pause_command(
- mut command: RendererInspectorPauseCommand,
- claim: RendererRuntimeInspectorCommandClaim,
-) -> RendererInspectorPauseCommand {
- if let Some(claim_tx) = command.claim_tx.take() {
- let _ = claim_tx.send(claim);
- }
- command
-}
-
#[cfg(test)]
mod tests {
use super::*;
+ use crate::runtime::RendererInspectorCommandRoute;
+
+ fn io_ingress(
+ bridge: &RendererInspectorPauseBridge,
+ ) -> crate::script_vm::inspector_io::RendererInspectorIoIngress {
+ crate::script_vm::inspector_io::RendererInspectorIoIngress::new(
+ bridge.pause_loop_wake(),
+ None,
+ )
+ }
fn configure_page(bridge: &RendererInspectorPauseBridge, page_id: PageId) {
bridge.configure_page_route(RendererTurnOutputJournal::new(
@@ -1052,13 +717,42 @@ mod tests {
fn outbound_route(
bridge: &RendererInspectorPauseBridge,
+ ) -> RendererInspectorPauseOutboundRoute {
+ outbound_route_with_io(bridge, io_ingress(bridge))
+ }
+
+ fn outbound_route_with_io(
+ bridge: &RendererInspectorPauseBridge,
+ io_ingress: crate::script_vm::inspector_io::RendererInspectorIoIngress,
) -> RendererInspectorPauseOutboundRoute {
bridge.outbound_route(
+ io_ingress,
RendererDevToolsAgentToken::allocate(),
DevToolsSessionKey::Primary,
)
}
+ fn enqueue_command(
+ ingress: &crate::script_vm::inspector_io::RendererInspectorIoIngress,
+ agent_token: RendererDevToolsAgentToken,
+ inspector_session_id: Option<String>,
+ raw_json: String,
+ response: RendererRuntimeInspectorResponseSender,
+ ) -> crate::script_vm::inspector_io::RendererRuntimeInspectorCommandRoute {
+ ingress.enqueue_command(
+ agent_token,
+ crate::runtime::RendererInspectorCommandEnvelope::new_io(
+ crate::runtime::RendererInspectorIngressTicket::new(
+ None,
+ inspector_session_id,
+ crate::runtime::RendererInspectorCommandRoute::Io,
+ ),
+ raw_json,
+ Some(response),
+ ),
+ )
+ }
+
fn route_paused(
bridge: &RendererInspectorPauseBridge,
) -> RendererInspectorPauseNotificationRoute {
@@ -1101,8 +795,9 @@ mod tests {
#[test]
fn step_transition_keeps_the_exact_command_cause_through_repause() {
let bridge = RendererInspectorPauseBridge::default();
+ let io_ingress = io_ingress(&bridge);
configure_page(&bridge, PageId::new_for_testing(1));
- let outbound = outbound_route(&bridge);
+ let outbound = outbound_route_with_io(&bridge, io_ingress.clone());
assert!(
expect_immediate_preface(outbound.route_notification(&json!({
"method": "Debugger.paused",
@@ -1113,23 +808,22 @@ mod tests {
assert!(bridge.enter_pause());
let (response, _response_rx) = response_sender(41);
- let command_route = bridge.enqueue_command(
+ let command_route = enqueue_command(
+ &io_ingress,
RendererDevToolsAgentToken::allocate(),
None,
- RendererInspectorCommandRoute::MainThread,
- None,
r#"{"id":41,"method":"Debugger.stepOut","params":{}}"#.to_owned(),
response,
);
assert_eq!(
- command_route.metadata().route(),
- RendererInspectorCommandRoute::MainThread
+ command_route.ticket().route(),
+ RendererInspectorCommandRoute::Io
);
- let command = bridge
- .wait_for_command()
+ let command = io_ingress
+ .wait_and_claim_for_pause(&bridge)
.expect("the nested pause loop should claim stepOut");
- let first_dispatch = bridge.first_dispatch_guard(&command);
- assert_eq!(command.metadata, command_route.metadata().clone());
+ let first_dispatch = io_ingress.first_dispatch_guard(&command);
+ assert_eq!(command.ticket(), command_route.ticket());
let dispatch = bridge.begin_command_dispatch(&command);
outbound.mark_command_response(41, true);
drop(dispatch);
@@ -1164,8 +858,9 @@ mod tests {
#[test]
fn step_cause_ends_with_the_owner_turn_when_no_repause_occurs() {
let bridge = RendererInspectorPauseBridge::default();
+ let io_ingress = io_ingress(&bridge);
configure_page(&bridge, PageId::new_for_testing(1));
- let outbound = outbound_route(&bridge);
+ let outbound = outbound_route_with_io(&bridge, io_ingress.clone());
assert!(
expect_immediate_preface(outbound.route_notification(&json!({
"method": "Debugger.paused",
@@ -1176,18 +871,17 @@ mod tests {
assert!(bridge.enter_pause());
let (response, _response_rx) = response_sender(43);
- let command_route = bridge.enqueue_command(
+ let command_route = enqueue_command(
+ &io_ingress,
RendererDevToolsAgentToken::allocate(),
None,
- RendererInspectorCommandRoute::MainThread,
- None,
r#"{"id":43,"method":"Debugger.stepOut","params":{}}"#.to_owned(),
response,
);
- let command = bridge
- .wait_for_command()
+ let command = io_ingress
+ .wait_and_claim_for_pause(&bridge)
.expect("the nested pause loop should claim stepOut");
- let first_dispatch = bridge.first_dispatch_guard(&command);
+ let first_dispatch = io_ingress.first_dispatch_guard(&command);
let dispatch = bridge.begin_command_dispatch(&command);
outbound.mark_command_response(43, true);
drop(dispatch);
@@ -1215,8 +909,9 @@ mod tests {
#[test]
fn failed_step_command_does_not_own_a_later_resume_transition() {
let bridge = RendererInspectorPauseBridge::default();
+ let io_ingress = io_ingress(&bridge);
configure_page(&bridge, PageId::new_for_testing(1));
- let outbound = outbound_route(&bridge);
+ let outbound = outbound_route_with_io(&bridge, io_ingress.clone());
assert!(
expect_immediate_preface(outbound.route_notification(&json!({
"method": "Debugger.paused",
@@ -1227,18 +922,17 @@ mod tests {
assert!(bridge.enter_pause());
let (response, _response_rx) = response_sender(42);
- let command_route = bridge.enqueue_command(
+ let command_route = enqueue_command(
+ &io_ingress,
RendererDevToolsAgentToken::allocate(),
None,
- RendererInspectorCommandRoute::MainThread,
- None,
r#"{"id":42,"method":"Debugger.stepOut","params":{}}"#.to_owned(),
response,
);
- let command = bridge
- .wait_for_command()
+ let command = io_ingress
+ .wait_and_claim_for_pause(&bridge)
.expect("the nested pause loop should claim stepOut");
- let first_dispatch = bridge.first_dispatch_guard(&command);
+ let first_dispatch = io_ingress.first_dispatch_guard(&command);
let dispatch = bridge.begin_command_dispatch(&command);
outbound.mark_command_response(42, false);
drop(dispatch);
@@ -1307,300 +1001,6 @@ mod tests {
assert!(bridge.shared.state.lock().pending_prefaces.is_empty());
}
- #[tokio::test]
- async fn pause_loop_accepts_main_while_io_can_overtake_on_its_own_lane() {
- let bridge = RendererInspectorPauseBridge::default();
- configure_page(&bridge, PageId::new_for_testing(1));
- let agent_token = RendererDevToolsAgentToken::allocate();
- let (main_response, main_response_rx) = response_sender(7);
- let main_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::MainThread,
- Some("evaluate".to_owned()),
- r#"{"id":7,"method":"Runtime.evaluate","params":{"expression":"42"}}"#.to_owned(),
- main_response,
- );
- let (io_response, io_response_rx) = response_sender(8);
- let io_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":8,"method":"Runtime.terminateExecution"}"#.to_owned(),
- io_response,
- );
-
- assert_eq!(
- main_route.metadata().session(),
- &DevToolsSessionKey::Primary
- );
- assert_eq!(
- main_route.metadata().route(),
- RendererInspectorCommandRoute::MainThread
- );
- assert!(
- main_route.requires_owner_fallback(),
- "the command should initially schedule an owner fallback"
- );
-
- assert!(expect_immediate_preface(route_paused(&bridge)).is_empty());
- assert!(bridge.enter_pause());
- let io_command = bridge
- .claim_io_command_for_interrupt()
- .expect("the IO callback may overtake an earlier independent Main command");
- let io_first_dispatch = bridge.first_dispatch_guard(&io_command);
- assert_eq!(io_command.metadata, io_route.metadata().clone());
- assert_eq!(
- io_route.wait_for_claim().await,
- Ok(RendererRuntimeInspectorCommandClaim::Inspector)
- );
- io_command
- .response
- .send(json!({"id": 8, "result": {}}))
- .expect("IO response receiver should remain open");
- assert_eq!(io_response_rx.await.expect("IO response").call_id, 8);
- drop(io_first_dispatch);
-
- // A normal debugger pause pumps Chromium's main-thread DevTools
- // receiver too. Main does not interrupt running JavaScript, but it is
- // eligible once V8 has entered the nested message loop.
- let main_command = bridge
- .wait_for_command()
- .expect("the nested pause loop should claim Main work");
- let main_first_dispatch = bridge.first_dispatch_guard(&main_command);
- assert_eq!(main_command.metadata, main_route.metadata().clone());
- assert_eq!(
- main_command.owner_context_resolution_action.as_deref(),
- Some("evaluate"),
- "owner context-resolution metadata must stay attached"
- );
- assert_eq!(
- main_route.wait_for_claim().await,
- Ok(RendererRuntimeInspectorCommandClaim::Inspector)
- );
- main_command
- .response
- .send(json!({"id": 7, "result": {"result": {"value": 42}}}))
- .expect("Main response receiver should remain open");
- assert_eq!(main_response_rx.await.expect("Main response").call_id, 7);
- drop(main_first_dispatch);
-
- bridge.request_quit();
- assert!(bridge.wait_for_command().is_none());
- bridge.leave_pause();
- }
-
- #[test]
- fn active_owner_io_dispatch_cannot_be_overtaken_by_its_io_successor() {
- let bridge = RendererInspectorPauseBridge::default();
- let agent_token = RendererDevToolsAgentToken::allocate();
- let (first_response, _first_response_rx) = response_sender(11);
- let first_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":11,"method":"Debugger.pause"}"#.to_owned(),
- first_response,
- );
- let (second_response, _second_response_rx) = response_sender(12);
- let second_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":12,"method":"Runtime.terminateExecution"}"#.to_owned(),
- second_response,
- );
-
- let first = bridge
- .claim_command_for_owner(first_route.command_id())
- .expect("the first IO command should be owner-claimable while V8 is idle");
- let first_dispatch = bridge.first_dispatch_guard(&first);
- assert!(
- bridge.claim_io_command_for_interrupt().is_none(),
- "an interrupt callback must not overtake an owner-claimed IO predecessor"
- );
-
- drop(first_dispatch);
- let second = bridge
- .claim_io_command_for_interrupt()
- .expect("the IO successor should become claimable after first dispatch");
- assert_eq!(second.command_id, second_route.command_id());
- let second_dispatch = bridge.first_dispatch_guard(&second);
- drop(second_dispatch);
- }
-
- #[test]
- fn first_dispatch_fifo_is_scoped_to_the_exact_agent_session_and_route() {
- let bridge = RendererInspectorPauseBridge::default();
- let agent_token = RendererDevToolsAgentToken::allocate();
- let (first_response, _first_response_rx) = response_sender(21);
- let first_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":21,"method":"Debugger.pause"}"#.to_owned(),
- first_response,
- );
- let (second_response, _second_response_rx) = response_sender(22);
- let second_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":22,"method":"Runtime.terminateExecution"}"#.to_owned(),
- second_response,
- );
- let (other_response, _other_response_rx) = response_sender(23);
- let other_route = bridge.enqueue_command(
- agent_token,
- Some("SID-other".to_owned()),
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":23,"method":"Debugger.pause"}"#.to_owned(),
- other_response,
- );
-
- let first = bridge
- .claim_io_command_for_interrupt()
- .expect("the first primary-session IO command should be claimable");
- assert_eq!(first.command_id, first_route.command_id());
- let first_dispatch = bridge.first_dispatch_guard(&first);
-
- let other = bridge
- .claim_io_command_for_interrupt()
- .expect("a different session lane must remain independent");
- assert_eq!(other.command_id, other_route.command_id());
- let other_dispatch = bridge.first_dispatch_guard(&other);
- assert!(
- bridge.claim_io_command_for_interrupt().is_none(),
- "the primary-session successor must not overtake its active predecessor"
- );
- drop(other_dispatch);
- assert!(
- bridge.claim_io_command_for_interrupt().is_none(),
- "releasing another session must not release the primary lane"
- );
-
- drop(first_dispatch);
- let second = bridge
- .claim_io_command_for_interrupt()
- .expect("the exact-lane successor should become claimable once");
- assert_eq!(second.command_id, second_route.command_id());
- let second_dispatch = bridge.first_dispatch_guard(&second);
- drop(second_dispatch);
- assert!(bridge.claim_io_command_for_interrupt().is_none());
- }
-
- #[tokio::test]
- async fn page_teardown_cancels_waiters_while_an_io_dispatch_is_in_flight() {
- let bridge = RendererInspectorPauseBridge::default();
- let page_id = PageId::new_for_testing(1);
- configure_page(&bridge, page_id);
- let agent_token = RendererDevToolsAgentToken::allocate();
- let (active_response, _active_response_rx) = response_sender(31);
- let active_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":31,"method":"Debugger.pause"}"#.to_owned(),
- active_response,
- );
- let (waiting_response, waiting_response_rx) = response_sender(32);
- let waiting_route = bridge.enqueue_command(
- agent_token,
- None,
- RendererInspectorCommandRoute::Io,
- None,
- r#"{"id":32,"method":"Runtime.terminateExecution"}"#.to_owned(),
- waiting_response,
- );
-
- let active = bridge
- .claim_io_command_for_interrupt()
- .expect("the first IO command should enter dispatch");
- assert_eq!(active.command_id, active_route.command_id());
- let active_dispatch = bridge.first_dispatch_guard(&active);
- bridge.detach_page(page_id);
-
- let canceled = waiting_response_rx
- .await
- .expect("teardown must settle the queued IO response");
- let response = canceled
- .output
- .protocol_response(32)
- .expect("teardown cancellation response");
- assert_eq!(
- response["error"]["message"],
- json!("Inspector page closed while paused")
- );
- assert_eq!(waiting_route.command_id(), 2);
-
- drop(active_dispatch);
- assert!(
- bridge
- .shared
- .state
- .lock()
- .active_first_dispatch_lanes
- .is_empty(),
- "an in-flight callback must release its lane safely after teardown"
- );
- }
-
- #[tokio::test]
- async fn main_thread_command_is_handed_to_owner_after_resume() {
- let bridge = RendererInspectorPauseBridge::default();
- configure_page(&bridge, PageId::new_for_testing(1));
- assert!(
- expect_immediate_preface(outbound_route(&bridge).route_notification(&json!({
- "method": "Debugger.paused",
- "params": {"callFrames": []},
- })))
- .is_empty()
- );
- assert!(bridge.enter_pause());
-
- let (response, response_rx) = response_sender(9);
- let route = bridge.enqueue_command(
- RendererDevToolsAgentToken::allocate(),
- None,
- RendererInspectorCommandRoute::MainThread,
- Some("evaluate".to_owned()),
- r#"{"id":9,"method":"Runtime.evaluate","params":{"expression":"42"}}"#.to_owned(),
- response,
- );
- assert!(
- route.requires_owner_fallback(),
- "paused commands need an owner fallback in case resume wins the claim race"
- );
- let command_id = route.command_id();
-
- bridge.request_quit();
- assert!(
- bridge.wait_for_command().is_none(),
- "the resume request should win before the queued command is claimed"
- );
- bridge.leave_pause();
-
- let command = bridge
- .claim_command_for_owner(command_id)
- .expect("owner dispatch should claim the command after pause exit");
- assert_eq!(
- route.wait_for_claim().await,
- Ok(RendererRuntimeInspectorCommandClaim::Owner)
- );
- command
- .response
- .send(json!({"id": 9, "result": {"result": {"value": 42}}}))
- .expect("test response receiver should remain open");
- assert_eq!(response_rx.await.expect("test response").call_id, 9);
- }
-
#[test]
fn resumed_after_pause_loop_exit_stays_on_pause_bridge() {
let bridge = RendererInspectorPauseBridge::default();
@@ -1646,24 +1046,23 @@ mod tests {
}
#[tokio::test]
- async fn dropping_command_route_cancels_the_unclaimed_owner_fallback() {
+ async fn dropping_io_route_cancels_the_unclaimed_command() {
let bridge = RendererInspectorPauseBridge::default();
+ let io_ingress = io_ingress(&bridge);
configure_page(&bridge, PageId::new_for_testing(1));
let (response, response_rx) = response_sender(8);
- let route = bridge.enqueue_command(
+ let route = enqueue_command(
+ &io_ingress,
RendererDevToolsAgentToken::allocate(),
None,
- RendererInspectorCommandRoute::MainThread,
- None,
r#"{"id":8,"method":"Runtime.getIsolateId"}"#.to_owned(),
response,
);
- let command_id = route.command_id();
drop(route);
assert!(
- bridge.claim_command_for_owner(command_id).is_none(),
- "a canceled frontend route must remove its delayed owner command"
+ io_ingress.claim_for_owner().is_none(),
+ "a canceled frontend route must remove its queued IO command"
);
let completion = response_rx
.await
@@ -1674,7 +1073,7 @@ mod tests {
.expect("route cancellation response");
assert_eq!(
response["error"]["message"],
- json!("Runtime inspector command route was canceled before dispatch")
+ json!("Runtime inspector IO route was canceled before dispatch")
);
}
@@ -1686,7 +1085,7 @@ mod tests {
configure_page(&bridge, first_page_id);
assert!(expect_immediate_preface(route_paused(&bridge)).is_empty());
- bridge.detach_page(first_page_id);
+ assert!(bridge.detach_page(first_page_id));
{
let state = bridge.shared.state.lock();
assert_eq!(state.phase, RendererInspectorPausePhase::Running);
@@ -1695,7 +1094,7 @@ mod tests {
}
configure_page(&bridge, second_page_id);
- bridge.detach_page(first_page_id);
+ assert!(!bridge.detach_page(first_page_id));
{
let state = bridge.shared.state.lock();
assert_eq!(
@@ -1724,7 +1123,8 @@ mod tests {
bridge.request_quit();
assert!(bridge.enter_pause());
- assert!(bridge.wait_for_command().is_none());
+ let io_ingress = io_ingress(&bridge);
+ assert!(io_ingress.wait_and_claim_for_pause(&bridge).is_none());
bridge.leave_pause();
assert_eq!(
bridge.shared.state.lock().phase,