Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(devtools): unify Page IO agent ingress

ldm0f90729edf39d
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rs
index 0199ce67e..cb4888f65 100644
--- a/moli-core/src/page/command_dispatch.rs
+++ b/moli-core/src/page/command_dispatch.rs
@@ -16,9 +16,21 @@ pub struct PendingRuntimeInspectorCommandDispatch {
kind: PendingRuntimeInspectorCommandDispatchKind,
}
+/// One non-V8 renderer agent command admitted through the Page IO
+/// `DevToolsSession` receiver.
+pub struct PendingDevToolsIoCommandDispatch {
+ route: RendererRuntimeInspectorIoCommandRoute,
+}
+
enum PendingRuntimeInspectorCommandDispatchKind {
MainIngress(Box<RendererRuntimeInspectorMainCommandRoute>),
- Io(RendererRuntimeInspectorIoCommandRoute),
+ Io(PendingDevToolsIoCommandDispatch),
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum CompletedDevToolsIoCommandDispatch {
+ Dispatched,
+ Canceled,
}
/// Identifies which execution owner consumed one routable Inspector command.
@@ -144,10 +156,18 @@ impl Page {
route: RendererRuntimeInspectorIoCommandRoute,
) -> PendingRuntimeInspectorCommandDispatch {
Self::pending_runtime_inspector_command_dispatch(
- PendingRuntimeInspectorCommandDispatchKind::Io(route),
+ PendingRuntimeInspectorCommandDispatchKind::Io(
+ Self::pending_devtools_io_command_dispatch(route),
+ ),
)
}
+ pub(crate) fn pending_devtools_io_command_dispatch(
+ route: RendererRuntimeInspectorIoCommandRoute,
+ ) -> PendingDevToolsIoCommandDispatch {
+ PendingDevToolsIoCommandDispatch { route }
+ }
+
pub(crate) fn pending_main_ingress_runtime_inspector_command_dispatch(
route: RendererRuntimeInspectorMainCommandRoute,
) -> PendingRuntimeInspectorCommandDispatch {
@@ -403,12 +423,12 @@ impl PendingRuntimeInspectorCommandDispatch {
}
}
}
- PendingRuntimeInspectorCommandDispatchKind::Io(route) => {
- match route.wait_for_claim().await.map_err(anyhow::Error::msg)? {
- RendererRuntimeInspectorIoCommandClaim::Inspector => {
+ PendingRuntimeInspectorCommandDispatchKind::Io(pending) => {
+ match pending.wait().await? {
+ CompletedDevToolsIoCommandDispatch::Dispatched => {
Ok(CompletedRuntimeInspectorCommandDispatch::Inspector)
}
- RendererRuntimeInspectorIoCommandClaim::Canceled => {
+ CompletedDevToolsIoCommandDispatch::Canceled => {
Ok(CompletedRuntimeInspectorCommandDispatch::Canceled)
}
}
@@ -416,3 +436,21 @@ impl PendingRuntimeInspectorCommandDispatch {
}
}
}
+
+impl PendingDevToolsIoCommandDispatch {
+ pub async fn wait(self) -> Result<CompletedDevToolsIoCommandDispatch> {
+ match self
+ .route
+ .wait_for_first_dispatch()
+ .await
+ .map_err(anyhow::Error::msg)?
+ {
+ RendererRuntimeInspectorIoCommandClaim::Dispatched => {
+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched)
+ }
+ RendererRuntimeInspectorIoCommandClaim::Canceled => {
+ Ok(CompletedDevToolsIoCommandDispatch::Canceled)
+ }
+ }
+ }
+}
diff --git a/moli-core/src/page/js_evaluation.rs b/moli-core/src/page/js_evaluation.rs
index b7257c225..bcb9140cc 100644
--- a/moli-core/src/page/js_evaluation.rs
+++ b/moli-core/src/page/js_evaluation.rs
@@ -8,9 +8,10 @@ use super::protocol_support::{
RuntimeIsolatedWorldDefinition,
};
use super::{
- CompletedPageCommand, PendingPageCommand, PendingRuntimeInspectorCommandDispatch,
- RendererCommandTurnOutput, RendererInspectorSessionRestoreSnapshot,
- RendererRuntimeCommandOutput, RendererRuntimeInspectorMessage, RendererRuntimeRealmInfo,
+ CompletedPageCommand, PendingDevToolsIoCommandDispatch, PendingPageCommand,
+ PendingRuntimeInspectorCommandDispatch, RendererCommandTurnOutput,
+ RendererInspectorSessionRestoreSnapshot, RendererRuntimeCommandOutput,
+ RendererRuntimeInspectorMessage, RendererRuntimeRealmInfo,
};
use crate::RendererOutputFence;
use crate::renderer::{
@@ -826,6 +827,26 @@ impl Page {
self.start_page_command(RendererPageCommand::PerformanceMetricSnapshot)
}
+ /// Admits `Performance.getMetrics` through the same IO session lane used
+ /// by interruptible V8 Inspector commands. The snapshot remains the latest
+ /// owner-published value because collecting a fresh JS-derived snapshot is
+ /// not re-entrant while the isolate is executing JavaScript.
+ pub fn start_performance_metric_snapshot_from_io(
+ &self,
+ ) -> (
+ PendingDevToolsIoCommandDispatch,
+ RendererPerformanceMetricSnapshot,
+ ) {
+ let route = self.handle.enqueue_performance_get_metrics_io_command(
+ self.renderer_agent_attachment_id,
+ self.renderer_devtools_command_session_id.clone(),
+ );
+ (
+ Self::pending_devtools_io_command_dispatch(route),
+ self.cached_performance_metric_snapshot(),
+ )
+ }
+
pub fn cached_performance_metric_snapshot(&self) -> RendererPerformanceMetricSnapshot {
self.page_state.performance_metric_snapshot().clone()
}
diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rs
index cc9e6a52b..8963c348d 100644
--- a/moli-core/src/page/mod.rs
+++ b/moli-core/src/page/mod.rs
@@ -39,7 +39,8 @@ use crate::renderer::{
};
use anyhow::Result;
pub use command_dispatch::{
- CompletedPageCommand, CompletedRuntimeInspectorCommandDispatch, PendingPageCommand,
+ CompletedDevToolsIoCommandDispatch, CompletedPageCommand,
+ CompletedRuntimeInspectorCommandDispatch, PendingDevToolsIoCommandDispatch, PendingPageCommand,
PendingRuntimeInspectorCommandDispatch,
};
diff --git a/moli-core/src/page/settings_support.rs b/moli-core/src/page/settings_support.rs
index 94396c170..c7a902636 100644
--- a/moli-core/src/page/settings_support.rs
+++ b/moli-core/src/page/settings_support.rs
@@ -7,7 +7,7 @@ use super::protocol_support::{
EmulatedIdleOverride, EmulatedMediaOverrides, PermissionOverrideRegistration,
SubresourceResourceType, ViewportSurface,
};
-use super::{CompletedPageCommand, Page, PendingPageCommand};
+use super::{CompletedPageCommand, Page, PendingDevToolsIoCommandDispatch, PendingPageCommand};
use crate::renderer::{
RendererPageCommand, RendererPageCookieFacadeSnapshotReply, RendererPageReply,
};
@@ -235,10 +235,20 @@ impl Page {
.await
}
- /// Applies the DevTools IO-agent setting without entering the renderer
- /// owner's Main command queue.
- pub fn set_script_execution_disabled_from_io(&self, disabled: bool) {
- self.handle.set_script_execution_disabled_from_io(disabled);
+ /// Admits the DevTools IO-agent setting through the target's shared IO
+ /// session lane without entering the renderer owner's Main command queue.
+ pub fn start_set_script_execution_disabled_from_io(
+ &self,
+ disabled: bool,
+ ) -> PendingDevToolsIoCommandDispatch {
+ let route = self
+ .handle
+ .enqueue_set_script_execution_disabled_io_command(
+ self.renderer_agent_attachment_id,
+ self.renderer_devtools_command_session_id.clone(),
+ disabled,
+ );
+ Self::pending_devtools_io_command_dispatch(route)
}
pub async fn set_bypass_content_security_policy_async(&mut self, bypass: bool) -> Result<()> {
diff --git a/moli-protocol/src/domains/emulation.rs b/moli-protocol/src/domains/emulation.rs
index 38c01e1b2..78cf7c3fa 100644
--- a/moli-protocol/src/domains/emulation.rs
+++ b/moli-protocol/src/domains/emulation.rs
@@ -17,7 +17,10 @@ use crate::domains::actions::EmulationAction;
use crate::domains::command_output::CommandOutputPlan;
use moli_core::{
RendererRuntimeInspectorResponseSender,
- page::{CompletedPageCommand, PendingPageCommand},
+ page::{
+ CompletedDevToolsIoCommandDispatch, CompletedPageCommand, PendingDevToolsIoCommandDispatch,
+ PendingPageCommand,
+ },
};
use serde_json::json;
@@ -31,13 +34,23 @@ mod tests;
pub(crate) struct PendingEmulationCommandDispatch {
command_id: Option<u64>,
session_id: Option<String>,
- pending: Vec<PendingEmulationPageCommand>,
+ pending: PendingEmulationRendererDispatch,
}
pub(crate) struct CompletedEmulationCommandDispatch {
command_id: Option<u64>,
session_id: Option<String>,
- completed: Vec<CompletedEmulationPageCommand>,
+ completed: CompletedEmulationRendererDispatch,
+}
+
+enum PendingEmulationRendererDispatch {
+ Pages(Vec<PendingEmulationPageCommand>),
+ Io(PendingDevToolsIoCommandDispatch),
+}
+
+enum CompletedEmulationRendererDispatch {
+ Pages(Vec<CompletedEmulationPageCommand>),
+ Io(Result<CompletedDevToolsIoCommandDispatch, String>),
}
struct PendingEmulationPageCommand {
@@ -88,26 +101,36 @@ enum PendingEmulationPageOperation {
impl PendingEmulationCommandDispatch {
pub(crate) async fn wait(self) -> CompletedEmulationCommandDispatch {
- let mut completed = Vec::with_capacity(self.pending.len());
- for pending in self.pending {
- let PendingEmulationPageCommand {
- target,
- operation,
- pending,
- runtime_response_rx,
- } = pending;
- let completed_page = pending.wait().await.map_err(|error| error.to_string());
- if completed_page.is_ok()
- && let Some(response_rx) = runtime_response_rx
- {
- let _ = response_rx.await;
+ let completed = match self.pending {
+ PendingEmulationRendererDispatch::Pages(pending_pages) => {
+ let mut completed = Vec::with_capacity(pending_pages.len());
+ for pending in pending_pages {
+ let PendingEmulationPageCommand {
+ target,
+ operation,
+ pending,
+ runtime_response_rx,
+ } = pending;
+ let completed_page = pending.wait().await.map_err(|error| error.to_string());
+ if completed_page.is_ok()
+ && let Some(response_rx) = runtime_response_rx
+ {
+ let _ = response_rx.await;
+ }
+ completed.push(CompletedEmulationPageCommand {
+ target,
+ operation,
+ completed: completed_page,
+ });
+ }
+ CompletedEmulationRendererDispatch::Pages(completed)
}
- completed.push(CompletedEmulationPageCommand {
- target,
- operation,
- completed: completed_page,
- });
- }
+ PendingEmulationRendererDispatch::Io(pending) => {
+ CompletedEmulationRendererDispatch::Io(
+ pending.wait().await.map_err(|error| error.to_string()),
+ )
+ }
+ };
CompletedEmulationCommandDispatch {
command_id: self.command_id,
session_id: self.session_id,
@@ -325,8 +348,12 @@ fn start_script_execution_disabled_command(
let Some(page) = loaded_page_mut_for_session(conn, cmd.session_id) else {
return EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({})));
};
- page.set_script_execution_disabled_from_io(params.value);
- EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({})))
+ let pending = page.start_set_script_execution_disabled_from_io(params.value);
+ EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
+ command_id: cmd.id,
+ session_id: cmd.session_id.map(str::to_owned),
+ pending: PendingEmulationRendererDispatch::Io(pending),
+ })
}
fn start_locale_override_command(
@@ -377,7 +404,7 @@ fn start_locale_override_command(
EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
command_id: cmd.id,
session_id: cmd.session_id.map(str::to_owned),
- pending,
+ pending: PendingEmulationRendererDispatch::Pages(pending),
})
}
@@ -560,7 +587,7 @@ fn start_update_geolocation_override_command(
EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
command_id: cmd.id,
session_id: cmd.session_id.map(str::to_owned),
- pending,
+ pending: PendingEmulationRendererDispatch::Pages(pending),
})
}
@@ -625,7 +652,7 @@ fn start_emulated_media_command(
EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
command_id: cmd.id,
session_id: cmd.session_id.map(str::to_owned),
- pending,
+ pending: PendingEmulationRendererDispatch::Pages(pending),
})
}
@@ -649,12 +676,12 @@ fn start_user_agent_override_command(
Ok(Some(pending)) => EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
command_id: cmd.id,
session_id: cmd.session_id.map(str::to_owned),
- pending: vec![PendingEmulationPageCommand {
+ pending: PendingEmulationRendererDispatch::Pages(vec![PendingEmulationPageCommand {
target: PendingEmulationPageTarget::SessionOwner { owner_scope },
operation: PendingEmulationPageOperation::SetUserAgentLoader,
pending,
runtime_response_rx: None,
- }],
+ }]),
}),
Ok(None) => EmulationCommandTaskStep::Complete(CommandOutputPlan::result(json!({}))),
Err(message) if message == "BrowserContextNotLoaded" => EmulationCommandTaskStep::Complete(
@@ -779,7 +806,7 @@ fn start_clear_device_metrics_override_command(
EmulationCommandTaskStep::Pending(PendingEmulationCommandDispatch {
command_id: cmd.id,
session_id: session_id.clone(),
- pending: vec![
+ pending: PendingEmulationRendererDispatch::Pages(vec![
PendingEmulationPageCommand {
target: PendingEmulationPageTarget::SessionOwner {
owner_scope: owner_scope.clone(),
@@ -794,7 +821,7 @@ fn start_clear_device_metrics_override_command(
pending: pending_runtime,
runtime_response_rx,
},
- ],
+ ]),
})
}
Err(error) => EmulationCommandTaskStep::Complete(CommandOutputPlan::error(-32000, error)),
@@ -844,7 +871,7 @@ fn start_devtools_set_viewport_command(
Ok(Some(PendingEmulationCommandDispatch {
command_id,
session_id: session_id.clone(),
- pending: vec![
+ pending: PendingEmulationRendererDispatch::Pages(vec![
PendingEmulationPageCommand {
target: PendingEmulationPageTarget::SessionOwner {
owner_scope: owner_scope.clone(),
@@ -859,7 +886,7 @@ fn start_devtools_set_viewport_command(
pending: pending_runtime,
runtime_response_rx,
},
- ],
+ ]),
}))
}
@@ -1532,7 +1559,7 @@ async fn complete_emulation_page_updates(
PendingEmulationCommandDispatch {
command_id: None,
session_id,
- pending,
+ pending: PendingEmulationRendererDispatch::Pages(pending),
}
.wait()
.await,
@@ -2111,7 +2138,7 @@ async fn execute_devtools_set_viewport_for_browser_contexts(
.session_id
.as_ref()
.map(|session_id| session_id.as_str().to_owned()),
- pending,
+ pending: PendingEmulationRendererDispatch::Pages(pending),
}
.wait()
.await,
@@ -2280,7 +2307,13 @@ fn complete_pending_devtools_emulation_command(
conn: &mut CdpConnection,
completed: CompletedEmulationCommandDispatch,
) -> Result<DevToolsCommandResult, DevToolsError> {
- for completed_page in completed.completed {
+ let CompletedEmulationRendererDispatch::Pages(completed_pages) = completed.completed else {
+ return Err(DevToolsError::new(
+ DevToolsErrorKind::Internal,
+ "DevTools emulation command completed through the CDP-only IO receiver",
+ ));
+ };
+ for completed_page in completed_pages {
let completion = completed_page
.completed
.map_err(|error| DevToolsError::new(DevToolsErrorKind::Internal, error))?;
@@ -2335,7 +2368,21 @@ pub(crate) fn complete_pending_emulation_command(
conn: &mut CdpConnection,
completed: CompletedEmulationCommandDispatch,
) -> CommandOutputPlan {
- for completed_page in completed.completed {
+ let completed_pages = match completed.completed {
+ CompletedEmulationRendererDispatch::Pages(completed_pages) => completed_pages,
+ CompletedEmulationRendererDispatch::Io(completed) => {
+ return match completed {
+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {
+ CommandOutputPlan::result(json!({}))
+ }
+ Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {
+ CommandOutputPlan::error(-32000, "Emulation IO command was canceled")
+ }
+ Err(error) => CommandOutputPlan::error(-32000, error),
+ };
+ }
+ };
+ for completed_page in completed_pages {
let completion = match completed_page.completed {
Ok(completion) => completion,
Err(error) => return CommandOutputPlan::error(-32000, error),
@@ -2401,12 +2448,12 @@ fn single_pending_emulation_dispatch(
PendingEmulationCommandDispatch {
command_id,
session_id: session_id.clone(),
- pending: vec![PendingEmulationPageCommand {
+ pending: PendingEmulationRendererDispatch::Pages(vec![PendingEmulationPageCommand {
target: PendingEmulationPageTarget::SessionOwner { owner_scope },
operation,
pending,
runtime_response_rx,
- }],
+ }]),
}
}
diff --git a/moli-protocol/src/domains/emulation/tests.rs b/moli-protocol/src/domains/emulation/tests.rs
index 280fc567d..473cbb6da 100644
--- a/moli-protocol/src/domains/emulation/tests.rs
+++ b/moli-protocol/src/domains/emulation/tests.rs
@@ -183,7 +183,7 @@ async fn bidi_set_extra_headers_merges_global_user_context_and_context_layers()
}
#[tokio::test(flavor = "multi_thread")]
-async fn script_execution_disabled_completes_without_waiting_for_main_owner() {
+async fn script_execution_disabled_completes_through_io_pending_dispatch() {
let mut ctx = TestContext::new();
load_session_page_for_pending_emulation_test(&mut ctx).await;
@@ -194,10 +194,11 @@ async fn script_execution_disabled_completes_without_waiting_for_main_owner() {
"params": { "value": true }
})
.to_string();
- let CdpCommandTaskStep::Complete(outcome) = ctx.conn.start_command_dispatch(&raw) else {
- panic!("the IO-routed script execution override must not wait for the Main owner");
- };
- let messages = outcome.into_parts().0;
+ let pending = ctx
+ .conn
+ .try_start_pending_command_dispatch(&raw)
+ .expect("the script execution override should use IO pending dispatch");
+ let messages = complete_pending_command_task_for_test(&mut ctx, pending).await;
assert!(messages.iter().any(|message| {
message["id"] == json!(9101)
diff --git a/moli-protocol/src/domains/performance.rs b/moli-protocol/src/domains/performance.rs
index 05223bf32..e01f2c978 100644
--- a/moli-protocol/src/domains/performance.rs
+++ b/moli-protocol/src/domains/performance.rs
@@ -5,7 +5,8 @@ use crate::conn::{
use crate::domains::actions::PerformanceAction;
use crate::domains::command_output::CommandOutputPlan;
use moli_core::page::{
- CompletedPageCommand, Page, PendingPageCommand, RendererPerformanceMetricSnapshot,
+ CompletedDevToolsIoCommandDispatch, CompletedPageCommand, Page,
+ PendingDevToolsIoCommandDispatch, PendingPageCommand, RendererPerformanceMetricSnapshot,
};
use serde::Deserialize;
use serde_json::{Value, json};
@@ -27,7 +28,7 @@ pub(crate) struct PendingPerformanceCommandDispatch {
owner_scope: CommandOwnerScope,
renderer_access: CdpRendererCommandAccess,
renderer_page: crate::conn::RendererPageResidenceIdentity,
- pending: PendingPageCommand,
+ pending: Box<PendingPerformanceRendererCommand>,
}
pub(crate) struct CompletedPerformanceCommandDispatch {
@@ -35,7 +36,20 @@ pub(crate) struct CompletedPerformanceCommandDispatch {
owner_scope: CommandOwnerScope,
renderer_access: CdpRendererCommandAccess,
renderer_page: crate::conn::RendererPageResidenceIdentity,
- completed: Result<CompletedPageCommand, String>,
+ completed: Result<CompletedPerformanceRendererCommand, String>,
+}
+
+enum PendingPerformanceRendererCommand {
+ Main(PendingPageCommand),
+ Io {
+ pending: PendingDevToolsIoCommandDispatch,
+ snapshot: RendererPerformanceMetricSnapshot,
+ },
+}
+
+enum CompletedPerformanceRendererCommand {
+ Main(CompletedPageCommand),
+ Io(RendererPerformanceMetricSnapshot),
}
pub(crate) enum PerformanceCommandTaskStep {
@@ -49,12 +63,29 @@ impl PendingPerformanceCommandDispatch {
}
pub async fn wait(self) -> CompletedPerformanceCommandDispatch {
+ let completed = match *self.pending {
+ PendingPerformanceRendererCommand::Main(pending) => pending
+ .wait()
+ .await
+ .map(CompletedPerformanceRendererCommand::Main),
+ PendingPerformanceRendererCommand::Io { pending, snapshot } => {
+ match pending.wait().await {
+ Ok(CompletedDevToolsIoCommandDispatch::Dispatched) => {
+ Ok(CompletedPerformanceRendererCommand::Io(snapshot))
+ }
+ Ok(CompletedDevToolsIoCommandDispatch::Canceled) => {
+ Err(anyhow::anyhow!("Performance IO command was canceled"))
+ }
+ Err(error) => Err(error),
+ }
+ }
+ };
CompletedPerformanceCommandDispatch {
command_id: self.command_id,
owner_scope: self.owner_scope,
renderer_access: self.renderer_access,
renderer_page: self.renderer_page,
- completed: self.pending.wait().await.map_err(|error| error.to_string()),
+ completed: completed.map_err(|error| error.to_string()),
}
}
}
@@ -198,9 +229,15 @@ pub(crate) fn try_start_performance_command_dispatch(
}
};
if renderer_access == CdpRendererCommandAccess::Io {
- return PerformanceCommandTaskStep::Complete(performance_metrics_command_output_plan(
- &page.cached_performance_metric_snapshot(),
- ));
+ let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);
+ let (pending, snapshot) = page.start_performance_metric_snapshot_from_io();
+ return PerformanceCommandTaskStep::Pending(PendingPerformanceCommandDispatch {
+ command_id: cmd.id,
+ owner_scope,
+ renderer_access,
+ renderer_page,
+ pending: Box::new(PendingPerformanceRendererCommand::Io { pending, snapshot }),
+ });
}
let renderer_page = crate::conn::RendererPageResidenceIdentity::from_page(page);
let pending = match page.start_performance_metric_snapshot() {
@@ -214,7 +251,7 @@ pub(crate) fn try_start_performance_command_dispatch(
owner_scope,
renderer_access,
renderer_page,
- pending,
+ pending: Box::new(PendingPerformanceRendererCommand::Main(pending)),
})
}
@@ -246,15 +283,35 @@ pub(crate) async fn complete_pending_performance_command(
let session_id = owner_scope.session_id().map(str::to_owned);
let mut owner_scope = owner_scope.enter(conn);
let snapshot = match completed {
- Ok(completed_page) => loaded_page_mut_for_renderer_access(
- owner_scope.conn_mut(),
- session_id.as_deref(),
- renderer_access,
- )
- .ok()
- .filter(|page| crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page)
- .and_then(|page| page.finish_performance_metric_snapshot(completed_page).ok())
- .unwrap_or_default(),
+ Ok(CompletedPerformanceRendererCommand::Main(completed_page)) => {
+ loaded_page_mut_for_renderer_access(
+ owner_scope.conn_mut(),
+ session_id.as_deref(),
+ renderer_access,
+ )
+ .ok()
+ .filter(|page| {
+ crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page
+ })
+ .and_then(|page| page.finish_performance_metric_snapshot(completed_page).ok())
+ .unwrap_or_default()
+ }
+ Ok(CompletedPerformanceRendererCommand::Io(snapshot)) => {
+ let remains_current = loaded_page_mut_for_renderer_access(
+ owner_scope.conn_mut(),
+ session_id.as_deref(),
+ renderer_access,
+ )
+ .ok()
+ .is_some_and(|page| {
+ crate::conn::RendererPageResidenceIdentity::from_page(page) == renderer_page
+ });
+ if remains_current {
+ snapshot
+ } else {
+ RendererPerformanceMetricSnapshot::default()
+ }
+ }
Err(_) => RendererPerformanceMetricSnapshot::default(),
};
CommandOutputPlan::result(json!({ "metrics": build_performance_metrics(&snapshot) }))
@@ -756,8 +813,8 @@ mod tests {
"sessionId": "SID-1"
})
.to_string();
- let old_messages =
- complete_immediate_command_task_step_for_test(ctx.conn.start_command_dispatch(&raw));
+ let step = ctx.conn.start_command_dispatch(&raw);
+ let old_messages = complete_command_task_step_for_test(&mut ctx, step).await;
let old_response = old_messages
.iter()
.find(|message| message["id"] == json!(4_011))
@@ -789,9 +846,8 @@ mod tests {
"sessionId": "SID-1"
})
.to_string();
- let replacement_messages = complete_immediate_command_task_step_for_test(
- ctx.conn.start_command_dispatch(&replacement_raw),
- );
+ let step = ctx.conn.start_command_dispatch(&replacement_raw);
+ let replacement_messages = complete_command_task_step_for_test(&mut ctx, step).await;
let replacement_response = replacement_messages
.iter()
.find(|message| message["id"] == json!(4_012))
diff --git a/moli-renderer-v8/src/devtools/command.rs b/moli-renderer-v8/src/devtools/command.rs
index 9c1418f0a..ed6a15294 100644
--- a/moli-renderer-v8/src/devtools/command.rs
+++ b/moli-renderer-v8/src/devtools/command.rs
@@ -3,6 +3,7 @@
use crate::runtime::{
RendererInspectorPageCommand, RendererPageCommand, RendererRuntimeInspectorResponseSender,
};
+use crate::script_execution_control::RendererScriptExecutionControl;
use moli_page_types::{DevToolsSessionKey, RendererAgentAttachmentId};
use serde_json::Value;
use std::sync::atomic::{AtomicU64, Ordering};
@@ -133,6 +134,120 @@ pub struct RendererInspectorCommandEnvelope {
payload: RendererInspectorCommandPayload,
}
+/// One command delivered by the renderer's IO DevTools receiver.
+///
+/// Chromium chooses the IO receiver at the `DevToolsSession` boundary, before
+/// it chooses the renderer agent that will execute the command. Keep that
+/// ordering structural here as well: V8 Inspector, Performance, and Emulation
+/// commands share one `(target, session, IO)` first-dispatch lane.
+#[doc(hidden)]
+pub struct RendererDevToolsIoCommandEnvelope {
+ ticket: RendererInspectorIngressTicket,
+ payload: RendererDevToolsIoCommandPayload,
+}
+
+pub(crate) enum RendererDevToolsIoCommandPayload {
+ Inspector(RendererInspectorCommandEnvelope),
+ PerformanceGetMetrics,
+ SetScriptExecutionDisabled {
+ control: RendererScriptExecutionControl,
+ disabled: bool,
+ },
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum RendererDevToolsIoCommandKind {
+ Inspector,
+ Performance,
+ Emulation,
+}
+
+impl RendererDevToolsIoCommandEnvelope {
+ pub(crate) fn inspector(envelope: RendererInspectorCommandEnvelope) -> Self {
+ assert_eq!(
+ envelope.ticket().route(),
+ RendererInspectorCommandRoute::Io,
+ "an Inspector payload entering the IO receiver must use the IO route"
+ );
+ Self {
+ ticket: envelope.ticket().clone(),
+ payload: RendererDevToolsIoCommandPayload::Inspector(envelope),
+ }
+ }
+
+ pub(crate) fn performance_get_metrics(ticket: RendererInspectorIngressTicket) -> Self {
+ Self::new_agent_command(
+ ticket,
+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics,
+ )
+ }
+
+ pub(crate) fn set_script_execution_disabled(
+ ticket: RendererInspectorIngressTicket,
+ control: RendererScriptExecutionControl,
+ disabled: bool,
+ ) -> Self {
+ Self::new_agent_command(
+ ticket,
+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { control, disabled },
+ )
+ }
+
+ fn new_agent_command(
+ ticket: RendererInspectorIngressTicket,
+ payload: RendererDevToolsIoCommandPayload,
+ ) -> Self {
+ assert_eq!(
+ ticket.route(),
+ RendererInspectorCommandRoute::Io,
+ "a renderer IO agent payload must use the IO route"
+ );
+ Self { ticket, payload }
+ }
+
+ pub(crate) fn ticket(&self) -> &RendererInspectorIngressTicket {
+ &self.ticket
+ }
+
+ pub(crate) fn first_dispatch_lifecycle(&self) -> RendererInspectorFirstDispatchLifecycle {
+ RendererInspectorFirstDispatchLifecycle::OrderedUntilFirstDispatch
+ }
+
+ pub(crate) fn kind(&self) -> RendererDevToolsIoCommandKind {
+ match &self.payload {
+ RendererDevToolsIoCommandPayload::Inspector(_) => {
+ RendererDevToolsIoCommandKind::Inspector
+ }
+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics => {
+ RendererDevToolsIoCommandKind::Performance
+ }
+ RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { .. } => {
+ RendererDevToolsIoCommandKind::Emulation
+ }
+ }
+ }
+
+ pub(crate) fn inspector_envelope(&self) -> Option<&RendererInspectorCommandEnvelope> {
+ match &self.payload {
+ RendererDevToolsIoCommandPayload::Inspector(envelope) => Some(envelope),
+ _ => None,
+ }
+ }
+
+ pub(crate) fn inspector_envelope_mut(
+ &mut self,
+ ) -> Option<&mut RendererInspectorCommandEnvelope> {
+ match &mut self.payload {
+ RendererDevToolsIoCommandPayload::Inspector(envelope) => Some(envelope),
+ _ => None,
+ }
+ }
+
+ pub(crate) fn into_payload(self) -> RendererDevToolsIoCommandPayload {
+ self.payload
+ }
+}
+
/// One command delivered by the renderer's Main DevTools receiver.
///
/// Unlike `RendererInspectorCommandEnvelope`, this envelope is deliberately
diff --git a/moli-renderer-v8/src/devtools/ingress/io.rs b/moli-renderer-v8/src/devtools/ingress/io.rs
index 4cb8a7b69..75aae61f3 100644
--- a/moli-renderer-v8/src/devtools/ingress/io.rs
+++ b/moli-renderer-v8/src/devtools/ingress/io.rs
@@ -20,9 +20,10 @@ use crate::{
route::RendererInspectorSessionExecutorRouteId,
},
runtime::{
- RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
- RendererInspectorIngressTicket, RendererInspectorPauseCommandEffect,
- RendererRuntimeInspectorResponseSender,
+ RendererDevToolsIoCommandEnvelope, RendererDevToolsIoCommandKind,
+ RendererDevToolsIoCommandPayload, RendererInspectorCommandEnvelope,
+ RendererInspectorCommandRoute, RendererInspectorIngressTicket,
+ RendererInspectorPauseCommandEffect, RendererRuntimeInspectorResponseSender,
},
};
@@ -49,8 +50,8 @@ pub(crate) enum RendererInspectorIoCommandConsumer {
pub(crate) struct RendererInspectorIoCommand {
command_id: u64,
pub(crate) agent_token: RendererDevToolsAgentToken,
- envelope: RendererInspectorCommandEnvelope,
- claim_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorIoCommandClaim>>,
+ envelope: RendererDevToolsIoCommandEnvelope,
+ first_dispatch_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorIoCommandClaim>>,
claimed_by: Option<RendererInspectorIoCommandConsumer>,
}
@@ -69,20 +70,39 @@ impl RendererInspectorIoCommand {
self.envelope.first_dispatch_lifecycle()
}
+ pub(crate) fn kind(&self) -> RendererDevToolsIoCommandKind {
+ self.envelope.kind()
+ }
+
pub(crate) fn raw_json(&self) -> &str {
- self.envelope.io_raw_json()
+ self.envelope
+ .inspector_envelope()
+ .expect("only an Inspector IO payload has protocol JSON")
+ .io_raw_json()
}
pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
- self.envelope.io_response()
+ self.envelope
+ .inspector_envelope()
+ .and_then(RendererInspectorCommandEnvelope::io_response)
}
pub(crate) fn pause_effect(&self) -> RendererInspectorPauseCommandEffect {
- self.envelope.pause_effect()
+ self.envelope
+ .inspector_envelope()
+ .map_or(RendererInspectorPauseCommandEffect::None, |envelope| {
+ envelope.pause_effect()
+ })
}
pub(crate) fn take_response(&mut self) -> Option<RendererRuntimeInspectorResponseSender> {
- self.envelope.take_io_response()
+ self.envelope
+ .inspector_envelope_mut()
+ .and_then(RendererInspectorCommandEnvelope::take_io_response)
+ }
+
+ pub(crate) fn into_payload(self) -> RendererDevToolsIoCommandPayload {
+ self.envelope.into_payload()
}
#[cfg(test)]
@@ -99,14 +119,15 @@ impl RendererDevToolsIngressCommand for RendererInspectorIoCommand {
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RendererRuntimeInspectorIoCommandClaim {
- Inspector,
+ Dispatched,
Canceled,
}
pub struct RendererRuntimeInspectorIoCommandRoute {
command_id: u64,
ticket: RendererInspectorIngressTicket,
- claim_rx: Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorIoCommandClaim>>,
+ first_dispatch_rx:
+ Option<tokio::sync::oneshot::Receiver<RendererRuntimeInspectorIoCommandClaim>>,
ingress: RendererInspectorIoIngress,
}
@@ -119,14 +140,14 @@ impl RendererRuntimeInspectorIoCommandRoute {
&self.ticket
}
- pub async fn wait_for_claim(
+ pub async fn wait_for_first_dispatch(
mut self,
) -> Result<RendererRuntimeInspectorIoCommandClaim, &'static str> {
- self.claim_rx
+ self.first_dispatch_rx
.take()
- .expect("runtime inspector IO command claim receiver should only be awaited once")
+ .expect("runtime Inspector IO first dispatch should only be awaited once")
.await
- .map_err(|_| "runtime inspector IO command claim channel closed")
+ .map_err(|_| "runtime Inspector IO first-dispatch channel closed")
}
}
@@ -178,6 +199,7 @@ pub(crate) struct RendererInspectorIoFirstDispatchGuard {
ingress: RendererInspectorIoIngress,
active: Option<(RendererDevToolsSessionLaneKey, u64)>,
consumer: RendererInspectorIoCommandConsumer,
+ first_dispatch_tx: Option<tokio::sync::oneshot::Sender<RendererRuntimeInspectorIoCommandClaim>>,
}
pub(crate) struct RendererInspectorIoPostDispatchWakeGuard {
@@ -219,7 +241,11 @@ impl RendererInspectorIoFirstDispatchGuard {
.interrupt_armed
.store(false, Ordering::Release);
}
- self.ingress.finish_first_dispatch(lane, command_id)
+ let has_ready = self.ingress.finish_first_dispatch(lane, command_id);
+ if let Some(first_dispatch_tx) = self.first_dispatch_tx.take() {
+ let _ = first_dispatch_tx.send(RendererRuntimeInspectorIoCommandClaim::Dispatched);
+ }
+ has_ready
}
}
@@ -297,15 +323,15 @@ impl RendererInspectorIoIngress {
pub(crate) fn enqueue_command(
&self,
agent_token: RendererDevToolsAgentToken,
- envelope: RendererInspectorCommandEnvelope,
+ envelope: RendererDevToolsIoCommandEnvelope,
) -> RendererRuntimeInspectorIoCommandRoute {
assert_eq!(
envelope.ticket().route(),
RendererInspectorCommandRoute::Io,
- "only IO Inspector commands may enter RendererInspectorIoIngress"
+ "only IO DevTools commands may enter RendererInspectorIoIngress"
);
let ticket = envelope.ticket().clone();
- let (claim_tx, claim_rx) = tokio::sync::oneshot::channel();
+ let (first_dispatch_tx, first_dispatch_rx) = tokio::sync::oneshot::channel();
let mut state = self.shared.state.lock();
let command_id = ticket.sequence();
let lane_key = RendererDevToolsSessionLaneKey::new(agent_token, ticket.session().clone());
@@ -313,7 +339,7 @@ impl RendererInspectorIoIngress {
command_id,
agent_token,
envelope,
- claim_tx: Some(claim_tx),
+ first_dispatch_tx: Some(first_dispatch_tx),
claimed_by: None,
};
if let Err(rejected) = state.lanes.enqueue(lane_key, command) {
@@ -333,7 +359,7 @@ impl RendererInspectorIoIngress {
RendererRuntimeInspectorIoCommandRoute {
command_id,
ticket,
- claim_rx: Some(claim_rx),
+ first_dispatch_rx: Some(first_dispatch_rx),
ingress: self.clone(),
}
}
@@ -378,15 +404,12 @@ impl RendererInspectorIoIngress {
let mut state = self.shared.state.lock();
let (_, mut command) = state.lanes.claim_next(|_| true)?;
command.claimed_by = Some(consumer);
- if let Some(claim_tx) = command.claim_tx.take() {
- let _ = claim_tx.send(RendererRuntimeInspectorIoCommandClaim::Inspector);
- }
Some(command)
}
pub(crate) fn first_dispatch_guard(
&self,
- command: &RendererInspectorIoCommand,
+ command: &mut RendererInspectorIoCommand,
) -> RendererInspectorIoFirstDispatchGuard {
let lane_key = RendererDevToolsSessionLaneKey::new(
command.agent_token,
@@ -409,6 +432,7 @@ impl RendererInspectorIoIngress {
consumer: command
.claimed_by
.expect("a first-dispatch guard requires a claimed IO command"),
+ first_dispatch_tx: command.first_dispatch_tx.take(),
}
}
@@ -528,8 +552,8 @@ impl std::fmt::Debug for RendererInspectorIoIngress {
}
fn fail_io_command(mut command: RendererInspectorIoCommand, message: &str) {
- if let Some(claim_tx) = command.claim_tx.take() {
- let _ = claim_tx.send(RendererRuntimeInspectorIoCommandClaim::Canceled);
+ if let Some(first_dispatch_tx) = command.first_dispatch_tx.take() {
+ let _ = first_dispatch_tx.send(RendererRuntimeInspectorIoCommandClaim::Canceled);
}
let Some(response) = command.take_response() else {
return;
@@ -548,7 +572,8 @@ fn fail_io_command(mut command: RendererInspectorIoCommand, message: &str) {
mod tests {
use super::*;
use crate::{
- devtools::pause::RendererInspectorPauseBridge, runtime::RendererInspectorIngressTicket,
+ devtools::pause::RendererInspectorPauseBridge,
+ runtime::{RendererInspectorCommandEnvelope, RendererInspectorIngressTicket},
};
fn ingress() -> RendererInspectorIoIngress {
@@ -564,7 +589,7 @@ mod tests {
) -> RendererRuntimeInspectorIoCommandRoute {
ingress.enqueue_command(
agent_token,
- RendererInspectorCommandEnvelope::new_io(
+ RendererDevToolsIoCommandEnvelope::inspector(RendererInspectorCommandEnvelope::new_io(
RendererInspectorIngressTicket::new(
None,
session.map(str::to_owned),
@@ -572,7 +597,15 @@ mod tests {
),
raw_json.to_owned(),
None,
- ),
+ )),
+ )
+ }
+
+ fn io_ticket(session: &str) -> RendererInspectorIngressTicket {
+ RendererInspectorIngressTicket::new(
+ None,
+ Some(session.to_owned()),
+ RendererInspectorCommandRoute::Io,
)
}
@@ -645,9 +678,9 @@ mod tests {
1,
"round {round} must have one successful consumer"
);
- let command = claimed.pop().expect("exactly one claimed command");
+ let mut command = claimed.pop().expect("exactly one claimed command");
assert_eq!(command.raw_json(), format!("command-{round}"));
- ingress.first_dispatch_guard(&command).release();
+ ingress.first_dispatch_guard(&mut command).release();
drop(route);
}
@@ -665,17 +698,76 @@ mod tests {
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");
+ let mut first = ingress.claim_for_owner().expect("first ready session");
assert_eq!(first.raw_json(), "a1");
- let second = ingress
+ let mut 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");
+ ingress.first_dispatch_guard(&mut first).release();
+ ingress.first_dispatch_guard(&mut second).release();
+ let mut third = ingress.claim_for_pause().expect("a2 after a1 dispatch");
assert_eq!(third.raw_json(), "a2");
+ ingress.first_dispatch_guard(&mut third).release();
+ }
+
+ #[tokio::test]
+ async fn one_io_lane_orders_inspector_performance_and_emulation_first_dispatch() {
+ let ingress = ingress();
+ let agent = RendererDevToolsAgentToken::allocate();
+ let inspector = enqueue(&ingress, agent, Some("session-mixed"), "inspector");
+ let performance = ingress.enqueue_command(
+ agent,
+ RendererDevToolsIoCommandEnvelope::performance_get_metrics(io_ticket("session-mixed")),
+ );
+ let emulation = ingress.enqueue_command(
+ agent,
+ RendererDevToolsIoCommandEnvelope::set_script_execution_disabled(
+ io_ticket("session-mixed"),
+ crate::script_execution_control::RendererScriptExecutionControl::default(),
+ true,
+ ),
+ );
+
+ let mut first = ingress
+ .claim_for_interrupt()
+ .expect("Inspector must be the first mixed IO command");
+ assert_eq!(first.kind(), RendererDevToolsIoCommandKind::Inspector);
+ assert!(
+ ingress.claim_for_owner().is_none(),
+ "Performance must not overtake an active Inspector first dispatch"
+ );
+ ingress.first_dispatch_guard(&mut first).release();
+ assert_eq!(
+ inspector.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)
+ );
+
+ let mut second = ingress
+ .claim_for_owner()
+ .expect("Performance must follow Inspector");
+ assert_eq!(second.kind(), RendererDevToolsIoCommandKind::Performance);
+ assert!(
+ ingress.claim_for_pause().is_none(),
+ "Emulation must not overtake an active Performance first dispatch"
+ );
+ ingress.first_dispatch_guard(&mut second).release();
+ assert_eq!(
+ performance.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)
+ );
+
+ let mut third = ingress
+ .claim_for_pause()
+ .expect("Emulation must follow Performance");
+ assert_eq!(third.kind(), RendererDevToolsIoCommandKind::Emulation);
+ ingress.first_dispatch_guard(&mut third).release();
+ assert_eq!(
+ emulation.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)
+ );
}
#[tokio::test]
@@ -687,19 +779,20 @@ mod tests {
.collect::<Vec<_>>();
let first_route = routes.remove(0);
- let first = ingress
+ let mut first = ingress
.claim_for_interrupt()
.expect("the session head should be claimable");
- let mut first_dispatch = ingress.first_dispatch_guard(&first);
+ let mut first_dispatch = ingress.first_dispatch_guard(&mut first);
+ first_dispatch.release();
assert_eq!(
- first_route.wait_for_claim().await,
- Ok(RendererRuntimeInspectorIoCommandClaim::Inspector)
+ first_route.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)
);
ingress.detach_session(agent, &DevToolsSessionKey::Attached("session-a".to_owned()));
for (index, route) in routes.into_iter().enumerate() {
assert_eq!(
- route.wait_for_claim().await,
+ route.wait_for_first_dispatch().await,
Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),
"detach must cancel queued command {}",
index + 1
@@ -709,7 +802,6 @@ mod tests {
assert!(ingress.claim_for_interrupt().is_none());
assert!(ingress.claim_for_pause().is_none());
- first_dispatch.release();
assert!(
ingress.shared.state.lock().lanes.session_count() == 0,
"the detached lane must retire after its active first dispatch releases"
@@ -725,19 +817,20 @@ mod tests {
let b1_route = enqueue(&ingress, agent, Some("session-b"), "b1");
let b2_route = enqueue(&ingress, agent, Some("session-b"), "b2");
- let active = ingress
+ let mut active = ingress
.claim_for_owner()
.expect("one session head should become active");
- let mut first_dispatch = ingress.first_dispatch_guard(&active);
+ let mut first_dispatch = ingress.first_dispatch_guard(&mut active);
+ first_dispatch.release();
assert_eq!(
- a1_route.wait_for_claim().await,
- Ok(RendererRuntimeInspectorIoCommandClaim::Inspector)
+ a1_route.wait_for_first_dispatch().await,
+ Ok(RendererRuntimeInspectorIoCommandClaim::Dispatched)
);
ingress.close("test target closed");
for route in [a2_route, b1_route, b2_route] {
assert_eq!(
- route.wait_for_claim().await,
+ route.wait_for_first_dispatch().await,
Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),
"close must cancel every unclaimed session command"
);
@@ -746,7 +839,6 @@ mod tests {
assert!(ingress.claim_for_interrupt().is_none());
assert!(ingress.claim_for_pause().is_none());
- first_dispatch.release();
assert!(
ingress.shared.state.lock().lanes.session_count() == 0,
"the active lane must retire safely after target close"
@@ -754,14 +846,14 @@ mod tests {
let late = enqueue(&ingress, agent, Some("session-late"), "late");
assert_eq!(
- late.wait_for_claim().await,
+ late.wait_for_first_dispatch().await,
Ok(RendererRuntimeInspectorIoCommandClaim::Canceled),
"a closed target must reject late IO ingress"
);
}
#[test]
- #[should_panic(expected = "only IO Inspector commands")]
+ #[should_panic(expected = "must use the IO route")]
fn main_thread_command_cannot_enter_io_ingress() {
let ingress = ingress();
let page_command = crate::runtime::RendererPageCommand::dispatch_runtime_protocol_message(
@@ -771,6 +863,7 @@ mod tests {
let crate::runtime::RendererPageCommand::Inspector(envelope) = page_command else {
panic!("runtime protocol message must use an Inspector envelope");
};
+ let envelope = RendererDevToolsIoCommandEnvelope::inspector(envelope);
let _ = ingress.enqueue_command(RendererDevToolsAgentToken::allocate(), envelope);
}
}
diff --git a/moli-renderer-v8/src/devtools/pause/tests.rs b/moli-renderer-v8/src/devtools/pause/tests.rs
index a22241feb..9eaf02c0d 100644
--- a/moli-renderer-v8/src/devtools/pause/tests.rs
+++ b/moli-renderer-v8/src/devtools/pause/tests.rs
@@ -54,14 +54,16 @@ fn enqueue_command(
) -> crate::devtools::ingress::io::RendererRuntimeInspectorIoCommandRoute {
ingress.enqueue_command(
agent_token,
- crate::runtime::RendererInspectorCommandEnvelope::new_io(
- crate::runtime::RendererInspectorIngressTicket::new(
- None,
- inspector_session_id,
- crate::runtime::RendererInspectorCommandRoute::Io,
+ crate::runtime::RendererDevToolsIoCommandEnvelope::inspector(
+ crate::runtime::RendererInspectorCommandEnvelope::new_io(
+ crate::runtime::RendererInspectorIngressTicket::new(
+ None,
+ inspector_session_id,
+ crate::runtime::RendererInspectorCommandRoute::Io,
+ ),
+ raw_json,
+ Some(response),
),
- raw_json,
- Some(response),
),
)
}
@@ -133,10 +135,10 @@ fn step_transition_keeps_the_exact_command_cause_through_repause() {
command_route.ticket().route(),
RendererInspectorCommandRoute::Io
);
- let command = io_ingress
+ let mut command = io_ingress
.wait_and_claim_for_pause(&bridge)
.expect("the nested pause loop should claim stepOut");
- let first_dispatch = io_ingress.first_dispatch_guard(&command);
+ let first_dispatch = io_ingress.first_dispatch_guard(&mut command);
assert_eq!(command.ticket(), command_route.ticket());
let dispatch = bridge.begin_command_dispatch(
command.command_id(),
@@ -200,10 +202,10 @@ fn step_cause_ends_with_the_owner_turn_when_no_repause_occurs() {
r#"{"id":43,"method":"Debugger.stepOut","params":{}}"#.to_owned(),
response,
);
- let command = io_ingress
+ let mut command = io_ingress
.wait_and_claim_for_pause(&bridge)
.expect("the nested pause loop should claim stepOut");
- let first_dispatch = io_ingress.first_dispatch_guard(&command);
+ let first_dispatch = io_ingress.first_dispatch_guard(&mut command);
let dispatch = bridge.begin_command_dispatch(
command.command_id(),
command.ticket(),
@@ -259,10 +261,10 @@ fn failed_step_command_does_not_own_a_later_resume_transition() {
r#"{"id":42,"method":"Debugger.stepOut","params":{}}"#.to_owned(),
response,
);
- let command = io_ingress
+ let mut command = io_ingress
.wait_and_claim_for_pause(&bridge)
.expect("the nested pause loop should claim stepOut");
- let first_dispatch = io_ingress.first_dispatch_guard(&command);
+ let first_dispatch = io_ingress.first_dispatch_guard(&mut command);
let dispatch = bridge.begin_command_dispatch(
command.command_id(),
command.ticket(),
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index fed337a27..150ed1e2e 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -402,11 +402,12 @@ pub use self::protocol_output::{
};
pub use self::service_worker_run::RendererServiceWorkerRunIdentity;
pub use crate::devtools::command::{
- RendererDevToolsMainCommandEnvelope, RendererInspectorCommandEnvelope,
- RendererInspectorCommandRoute, RendererInspectorFirstDispatchLifecycle,
- RendererInspectorIngressTicket,
+ RendererDevToolsIoCommandEnvelope, RendererDevToolsMainCommandEnvelope,
+ RendererInspectorCommandEnvelope, RendererInspectorCommandRoute,
+ RendererInspectorFirstDispatchLifecycle, RendererInspectorIngressTicket,
};
pub(crate) use crate::devtools::command::{
+ RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload,
RendererDevToolsMainNestedDispatch, RendererInspectorPauseCommandEffect,
};
pub use crate::devtools::ingress::io::{
diff --git a/moli-renderer-v8/src/runtime/owner_local.rs b/moli-renderer-v8/src/runtime/owner_local.rs
index 3aa499ab1..1c8c40b1d 100644
--- a/moli-renderer-v8/src/runtime/owner_local.rs
+++ b/moli-renderer-v8/src/runtime/owner_local.rs
@@ -173,9 +173,28 @@ impl RendererPageHandle {
&self,
envelope: RendererInspectorCommandEnvelope,
) -> RendererRuntimeInspectorIoCommandRoute {
- self.devtools_target
- .io_ref()
- .enqueue_command(self.devtools_agent_token, envelope)
+ self.devtools_target.io_ref().enqueue_command(
+ self.devtools_agent_token,
+ RendererDevToolsIoCommandEnvelope::inspector(envelope),
+ )
+ }
+
+ #[doc(hidden)]
+ pub fn enqueue_performance_get_metrics_io_command(
+ &self,
+ attachment: Option<RendererAgentAttachmentId>,
+ inspector_session_id: Option<String>,
+ ) -> RendererRuntimeInspectorIoCommandRoute {
+ self.devtools_target.io_ref().enqueue_command(
+ self.devtools_agent_token,
+ RendererDevToolsIoCommandEnvelope::performance_get_metrics(
+ RendererInspectorIngressTicket::new(
+ attachment,
+ inspector_session_id,
+ RendererInspectorCommandRoute::Io,
+ ),
+ ),
+ )
}
pub fn enqueue_runtime_inspector_main_command(
@@ -193,10 +212,27 @@ impl RendererPageHandle {
self.devtools_target.pause_ref().is_pause_active()
}
- /// Publishes the DevTools IO-agent script policy without borrowing the
+ /// Enqueues the DevTools IO-agent script policy without borrowing the
/// owner-resident `PageVm` that may currently be executing JavaScript.
- pub fn set_script_execution_disabled_from_io(&self, disabled: bool) {
- self.script_execution_control.set_disabled(disabled);
+ #[doc(hidden)]
+ pub fn enqueue_set_script_execution_disabled_io_command(
+ &self,
+ attachment: Option<RendererAgentAttachmentId>,
+ inspector_session_id: Option<String>,
+ disabled: bool,
+ ) -> RendererRuntimeInspectorIoCommandRoute {
+ self.devtools_target.io_ref().enqueue_command(
+ self.devtools_agent_token,
+ RendererDevToolsIoCommandEnvelope::set_script_execution_disabled(
+ RendererInspectorIngressTicket::new(
+ attachment,
+ inspector_session_id,
+ RendererInspectorCommandRoute::Io,
+ ),
+ self.script_execution_control.clone(),
+ disabled,
+ ),
+ )
}
pub fn arm_runtime_inspector_session_detach(
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 50e3bdfbc..ec7f28188 100644
--- a/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/v8_backend.rs
@@ -20,6 +20,7 @@ use crate::{
},
inspector_microtasks::with_scoped_inspector_microtasks,
runtime::{
+ RendererDevToolsIoCommandKind, RendererDevToolsIoCommandPayload,
RendererDevToolsMainNestedDispatch, RendererOwnerReply,
RendererRuntimeInspectorResponseSender, dispatch_nested_main_page_command,
},
@@ -223,13 +224,15 @@ impl RendererInspectorSessionExecutorLocal {
}
fn dispatch_io_command(&self, context_group_id: i32, command: RendererInspectorIoCommand) {
- let session_key = command.ticket().session().clone();
- let session = self
- .sessions
- .borrow()
- .get(&(context_group_id, session_key))
- .filter(|session| session.agent_token == command.agent_token)
- .cloned();
+ let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {
+ let session_key = command.ticket().session().clone();
+ self.sessions
+ .borrow()
+ .get(&(context_group_id, session_key))
+ .filter(|session| session.agent_token == command.agent_token)
+ .cloned()
+ });
+ let session = session.flatten();
self.dispatch_io_command_to_session(command, session);
}
@@ -262,12 +265,14 @@ impl RendererInspectorSessionExecutorLocal {
let Some(command) = self.target.io_ref().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();
+ let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {
+ let session_key = command.ticket().session();
+ self.interrupt_sessions
+ .borrow()
+ .get(&(command.agent_token, session_key.clone()))
+ .cloned()
+ });
+ let session = session.flatten();
self.dispatch_io_command_to_session(command, session);
}
@@ -275,12 +280,14 @@ impl RendererInspectorSessionExecutorLocal {
let Some(command) = self.target.io_ref().claim_for_owner() else {
return;
};
- let session_key = command.ticket().session();
- let session = self
- .interrupt_sessions
- .borrow()
- .get(&(command.agent_token, session_key.clone()))
- .cloned();
+ let session = (command.kind() == RendererDevToolsIoCommandKind::Inspector).then(|| {
+ let session_key = command.ticket().session();
+ self.interrupt_sessions
+ .borrow()
+ .get(&(command.agent_token, session_key.clone()))
+ .cloned()
+ });
+ let session = session.flatten();
self.dispatch_io_command_to_session(command, session);
}
@@ -327,7 +334,33 @@ impl RendererInspectorSessionExecutorLocal {
mut command: RendererInspectorIoCommand,
session: Option<RendererInspectorSessionRoute>,
) {
- let mut first_dispatch = self.target.io_ref().first_dispatch_guard(&command);
+ let mut first_dispatch = self.target.io_ref().first_dispatch_guard(&mut command);
+ match command.kind() {
+ RendererDevToolsIoCommandKind::Performance => {
+ assert!(
+ matches!(
+ command.into_payload(),
+ RendererDevToolsIoCommandPayload::PerformanceGetMetrics
+ ),
+ "Performance IO command kind must carry a Performance payload"
+ );
+ first_dispatch.release();
+ return;
+ }
+ RendererDevToolsIoCommandKind::Emulation => {
+ let RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {
+ control,
+ disabled,
+ } = command.into_payload()
+ else {
+ unreachable!("Emulation IO command kind must carry an Emulation payload")
+ };
+ control.set_disabled(disabled);
+ first_dispatch.release();
+ return;
+ }
+ RendererDevToolsIoCommandKind::Inspector => {}
+ }
let Some(session) = session else {
send_inspector_dispatch_error(
command.take_response(),