mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 08:02:59 +00:00
Run tree beforeunload from the existing Inspector scope so navigation can start its request while the old script remains paused. Bind the active Page per owner-task poll and preserve the beforeunload output prefix and navigation fence without completing a suspended Runtime command. Keep document-replacement termination pauses internal while preserving real output and balancing pauses already reported to frontend sessions. Keep intentional pagehide/unload callbacks debuggable during replacement. Cover root/child lifecycle ordering, 204 recovery, resumable unload, multiple sessions and cancellation between pause notification and loop entry.
735 lines
26 KiB
Rust
735 lines
26 KiB
Rust
//! Typed metadata and payloads crossing the renderer DevTools ingress boundary.
|
|
|
|
use crate::runtime::RendererDevToolsPageCommand;
|
|
use moli_command_types::InspectorPauseEffect as RendererInspectorPauseCommandEffect;
|
|
|
|
mod nested;
|
|
|
|
use crate::runtime::RendererInspectorPageCommand;
|
|
use crate::runtime::{RendererPageCommand, RendererRuntimeInspectorResponseSender};
|
|
use crate::script_execution_control::RendererScriptExecutionControl;
|
|
use moli_page_types::{DevToolsSessionKey, RendererAgentAttachmentId, RendererDevToolsCommandId};
|
|
use serde_json::Value;
|
|
|
|
/// Chromium routes Page DevTools work through separate main-thread and IO
|
|
/// session ingress paths. Main preserves its receiver order independently,
|
|
/// while IO commands enter one target-level Inspector task FIFO and may
|
|
/// overtake blocked main-thread work.
|
|
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
pub enum RendererInspectorCommandRoute {
|
|
MainThread,
|
|
Io,
|
|
}
|
|
|
|
/// Pause-loop transition owned by an Inspector command. This is derived once
|
|
/// when the ingress envelope is created so executors do not need to reparse
|
|
/// protocol JSON to decide how resumed/paused notifications are attributed.
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
enum RendererInspectorMainDispatchBoundary {
|
|
InspectorSession,
|
|
PageOwner,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub struct RendererInspectorIngressTicket {
|
|
attachment: Option<RendererAgentAttachmentId>,
|
|
session: DevToolsSessionKey,
|
|
route: RendererInspectorCommandRoute,
|
|
command_id: RendererDevToolsCommandId,
|
|
}
|
|
|
|
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,
|
|
command_id: RendererDevToolsCommandId::allocate(),
|
|
}
|
|
}
|
|
|
|
pub fn attachment(&self) -> Option<RendererAgentAttachmentId> {
|
|
self.attachment
|
|
}
|
|
|
|
pub fn session(&self) -> &DevToolsSessionKey {
|
|
&self.session
|
|
}
|
|
|
|
pub fn route(&self) -> RendererInspectorCommandRoute {
|
|
self.route
|
|
}
|
|
|
|
pub fn command_id(&self) -> RendererDevToolsCommandId {
|
|
self.command_id
|
|
}
|
|
|
|
/// Transitional raw identity accessor for existing renderer queues.
|
|
pub fn sequence(&self) -> u64 {
|
|
self.command_id.get()
|
|
}
|
|
|
|
pub(crate) 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Strongly typed DevToolsSession ingress. The payload deliberately does not
|
|
/// carry another session id: every operation that accesses a frontend
|
|
/// `V8InspectorSession` must obtain its identity and dispatch policy from this
|
|
/// envelope.
|
|
pub struct RendererInspectorCommandEnvelope {
|
|
ticket: RendererInspectorIngressTicket,
|
|
pause_effect: RendererInspectorPauseCommandEffect,
|
|
main_dispatch_boundary: RendererInspectorMainDispatchBoundary,
|
|
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-level IO task FIFO.
|
|
#[doc(hidden)]
|
|
pub struct RendererDevToolsIoCommandEnvelope {
|
|
ticket: RendererInspectorIngressTicket,
|
|
payload: RendererDevToolsIoCommandPayload,
|
|
}
|
|
|
|
pub(crate) enum RendererDevToolsIoCommandPayload {
|
|
Inspector(RendererInspectorCommandEnvelope),
|
|
PerformanceGetMetrics {
|
|
result: Value,
|
|
response: Option<RendererRuntimeInspectorResponseSender>,
|
|
},
|
|
SetScriptExecutionDisabled {
|
|
control: RendererScriptExecutionControl,
|
|
disabled: bool,
|
|
response: Option<RendererRuntimeInspectorResponseSender>,
|
|
},
|
|
}
|
|
|
|
#[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 {
|
|
result: Value::Null,
|
|
response: None,
|
|
},
|
|
)
|
|
}
|
|
|
|
pub(crate) fn performance_get_metrics_with_response(
|
|
ticket: RendererInspectorIngressTicket,
|
|
result: Value,
|
|
response: RendererRuntimeInspectorResponseSender,
|
|
) -> Self {
|
|
Self::new_agent_command(
|
|
ticket,
|
|
RendererDevToolsIoCommandPayload::PerformanceGetMetrics {
|
|
result,
|
|
response: Some(response),
|
|
},
|
|
)
|
|
}
|
|
|
|
pub(crate) fn set_script_execution_disabled(
|
|
ticket: RendererInspectorIngressTicket,
|
|
control: RendererScriptExecutionControl,
|
|
disabled: bool,
|
|
) -> Self {
|
|
Self::new_agent_command(
|
|
ticket,
|
|
RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {
|
|
control,
|
|
disabled,
|
|
response: None,
|
|
},
|
|
)
|
|
}
|
|
|
|
pub(crate) fn set_script_execution_disabled_with_response(
|
|
ticket: RendererInspectorIngressTicket,
|
|
control: RendererScriptExecutionControl,
|
|
disabled: bool,
|
|
response: RendererRuntimeInspectorResponseSender,
|
|
) -> Self {
|
|
Self::new_agent_command(
|
|
ticket,
|
|
RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled {
|
|
control,
|
|
disabled,
|
|
response: Some(response),
|
|
},
|
|
)
|
|
}
|
|
|
|
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 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 response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
|
|
match &self.payload {
|
|
RendererDevToolsIoCommandPayload::Inspector(envelope) => envelope.response(),
|
|
RendererDevToolsIoCommandPayload::PerformanceGetMetrics { response, .. }
|
|
| RendererDevToolsIoCommandPayload::SetScriptExecutionDisabled { response, .. } => {
|
|
response.as_ref()
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
/// agent-neutral: protocol commands that ultimately need the renderer Page,
|
|
/// DOM, CSS, Accessibility, or V8 agents all enter the same Main receiver.
|
|
/// The payload retains the backend entry requirement for both internal queries
|
|
/// and frontend native operations; wrapping a command cannot make it reentrant.
|
|
#[doc(hidden)]
|
|
pub struct RendererDevToolsMainCommandEnvelope {
|
|
ticket: RendererInspectorIngressTicket,
|
|
payload: Box<RendererPageCommand>,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub(crate) enum RendererDevToolsMainNestedDispatch {
|
|
InspectorSession,
|
|
/// V8 session dispatch followed by a native terminal in the same Main turn.
|
|
NativeInspectorSession,
|
|
PageAgent,
|
|
BeforeUnload,
|
|
OwnerOnly,
|
|
}
|
|
|
|
impl RendererDevToolsMainCommandEnvelope {
|
|
pub(crate) fn from_protocol_command(command: RendererPageCommand) -> Self {
|
|
Self::from_protocol_command_in_session(command, None)
|
|
}
|
|
|
|
pub(crate) fn from_protocol_command_in_session(
|
|
command: RendererPageCommand,
|
|
inspector_session_id: Option<String>,
|
|
) -> Self {
|
|
let ticket = match &command {
|
|
RendererPageCommand::DevTools(RendererDevToolsPageCommand::Inspector(envelope)) => {
|
|
envelope.ticket().clone()
|
|
}
|
|
_ => RendererInspectorIngressTicket::new(
|
|
None,
|
|
inspector_session_id,
|
|
RendererInspectorCommandRoute::MainThread,
|
|
),
|
|
};
|
|
Self {
|
|
ticket,
|
|
payload: Box::new(command),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn ticket(&self) -> &RendererInspectorIngressTicket {
|
|
&self.ticket
|
|
}
|
|
|
|
pub(crate) fn is_session_connection(&self) -> bool {
|
|
matches!(
|
|
self.payload.as_ref(),
|
|
RendererPageCommand::DevTools(
|
|
RendererDevToolsPageCommand::ConnectRuntimeInspectorSession { .. }
|
|
)
|
|
)
|
|
}
|
|
|
|
pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch {
|
|
self.payload.nested_dispatch()
|
|
}
|
|
|
|
pub(crate) fn inspector_envelope(&self) -> Option<&RendererInspectorCommandEnvelope> {
|
|
match self.payload.as_ref() {
|
|
RendererPageCommand::DevTools(RendererDevToolsPageCommand::Inspector(envelope)) => {
|
|
Some(envelope)
|
|
}
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
|
|
self.inspector_envelope()
|
|
.and_then(RendererInspectorCommandEnvelope::response)
|
|
}
|
|
|
|
pub(crate) fn into_nested_inspector_envelope(self) -> RendererInspectorCommandEnvelope {
|
|
assert_eq!(
|
|
self.nested_dispatch(),
|
|
RendererDevToolsMainNestedDispatch::InspectorSession,
|
|
"only a session-boundary Inspector command may enter nested V8 dispatch"
|
|
);
|
|
let RendererPageCommand::DevTools(RendererDevToolsPageCommand::Inspector(envelope)) =
|
|
*self.payload
|
|
else {
|
|
unreachable!("nested Inspector dispatch kind requires an Inspector payload")
|
|
};
|
|
envelope
|
|
}
|
|
|
|
pub(crate) fn into_nested_agent_command(self) -> RendererPageCommand {
|
|
assert!(
|
|
matches!(
|
|
self.nested_dispatch(),
|
|
RendererDevToolsMainNestedDispatch::PageAgent
|
|
| RendererDevToolsMainNestedDispatch::NativeInspectorSession
|
|
),
|
|
"only a supported Main agent command may enter nested agent dispatch"
|
|
);
|
|
*self.payload
|
|
}
|
|
|
|
pub(crate) fn into_payload(self) -> RendererPageCommand {
|
|
*self.payload
|
|
}
|
|
}
|
|
|
|
enum RendererInspectorCommandPayload {
|
|
MainThread(RendererInspectorPageCommand),
|
|
Io {
|
|
raw_json: String,
|
|
response: Option<RendererRuntimeInspectorResponseSender>,
|
|
completes_idle_termination: bool,
|
|
},
|
|
}
|
|
|
|
impl RendererInspectorCommandEnvelope {
|
|
pub(crate) fn new(
|
|
inspector_session_id: Option<String>,
|
|
command: RendererInspectorPageCommand,
|
|
) -> Self {
|
|
Self {
|
|
ticket: RendererInspectorIngressTicket::new(
|
|
None,
|
|
inspector_session_id,
|
|
RendererInspectorCommandRoute::MainThread,
|
|
),
|
|
pause_effect: RendererInspectorPauseCommandEffect::None,
|
|
main_dispatch_boundary: RendererInspectorMainDispatchBoundary::PageOwner,
|
|
payload: RendererInspectorCommandPayload::MainThread(command),
|
|
}
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
pub fn new_main_protocol(
|
|
ticket: RendererInspectorIngressTicket,
|
|
owner_context_resolution_action: Option<String>,
|
|
raw_json: String,
|
|
response: RendererRuntimeInspectorResponseSender,
|
|
) -> Self {
|
|
assert_eq!(
|
|
ticket.route(),
|
|
RendererInspectorCommandRoute::MainThread,
|
|
"a Main Inspector protocol payload must use the MainThread route"
|
|
);
|
|
let message = serde_json::from_str::<Value>(&raw_json).ok();
|
|
let main_dispatch_boundary = if main_protocol_can_dispatch_at_inspector_session_boundary(
|
|
owner_context_resolution_action.as_deref(),
|
|
message.as_ref(),
|
|
) {
|
|
RendererInspectorMainDispatchBoundary::InspectorSession
|
|
} else {
|
|
RendererInspectorMainDispatchBoundary::PageOwner
|
|
};
|
|
let command = match owner_context_resolution_action {
|
|
Some(action) => RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {
|
|
action,
|
|
raw_json,
|
|
deferred_response: response,
|
|
},
|
|
None => RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {
|
|
raw_json,
|
|
deferred_response: response,
|
|
},
|
|
};
|
|
Self {
|
|
ticket,
|
|
pause_effect: RendererInspectorPauseCommandEffect::from_message(message.as_ref()),
|
|
main_dispatch_boundary,
|
|
payload: RendererInspectorCommandPayload::MainThread(command),
|
|
}
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
pub fn new_io(
|
|
ticket: RendererInspectorIngressTicket,
|
|
raw_json: String,
|
|
response: Option<RendererRuntimeInspectorResponseSender>,
|
|
) -> Self {
|
|
assert_eq!(
|
|
ticket.route(),
|
|
RendererInspectorCommandRoute::Io,
|
|
"an Inspector IO payload must use the IO route"
|
|
);
|
|
let message = serde_json::from_str::<Value>(&raw_json).ok();
|
|
Self {
|
|
ticket,
|
|
pause_effect: RendererInspectorPauseCommandEffect::from_message(message.as_ref()),
|
|
main_dispatch_boundary: RendererInspectorMainDispatchBoundary::InspectorSession,
|
|
payload: RendererInspectorCommandPayload::Io {
|
|
raw_json,
|
|
response,
|
|
completes_idle_termination: message
|
|
.as_ref()
|
|
.and_then(|message| message["method"].as_str())
|
|
== Some("Runtime.terminateExecution"),
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn ticket(&self) -> &RendererInspectorIngressTicket {
|
|
&self.ticket
|
|
}
|
|
|
|
pub(crate) fn pause_effect(&self) -> RendererInspectorPauseCommandEffect {
|
|
self.pause_effect
|
|
}
|
|
|
|
pub(crate) fn response(&self) -> Option<&RendererRuntimeInspectorResponseSender> {
|
|
match &self.payload {
|
|
RendererInspectorCommandPayload::MainThread(
|
|
RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {
|
|
deferred_response,
|
|
..
|
|
}
|
|
| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {
|
|
deferred_response,
|
|
..
|
|
},
|
|
) => Some(deferred_response),
|
|
RendererInspectorCommandPayload::Io { response, .. } => response.as_ref(),
|
|
RendererInspectorCommandPayload::MainThread(_) => None,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn can_dispatch_at_nested_inspector_session_boundary(&self) -> bool {
|
|
self.main_dispatch_boundary == RendererInspectorMainDispatchBoundary::InspectorSession
|
|
}
|
|
|
|
pub(crate) fn runtime_binding_removal_name(&self) -> Option<&str> {
|
|
match &self.payload {
|
|
RendererInspectorCommandPayload::MainThread(
|
|
RendererInspectorPageCommand::RuntimeBindingEvents {
|
|
binding,
|
|
remove: true,
|
|
},
|
|
) => Some(&binding.name),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub(crate) fn is_runtime_binding_removal_commit(&self) -> bool {
|
|
matches!(
|
|
self.payload,
|
|
RendererInspectorCommandPayload::MainThread(
|
|
RendererInspectorPageCommand::CommitRuntimeBindingRemoval { .. }
|
|
)
|
|
)
|
|
}
|
|
|
|
pub(crate) fn into_runtime_binding_removal_commit(
|
|
mut self,
|
|
output: Result<crate::runtime::RendererRuntimeCommandOutput, String>,
|
|
) -> Self {
|
|
let name = self
|
|
.runtime_binding_removal_name()
|
|
.expect("only removeBinding can finish nested Inspector dispatch")
|
|
.to_owned();
|
|
self.payload = RendererInspectorCommandPayload::MainThread(
|
|
RendererInspectorPageCommand::CommitRuntimeBindingRemoval { name, output },
|
|
);
|
|
self
|
|
}
|
|
|
|
pub(crate) fn bind_attachment(&mut self, attachment: RendererAgentAttachmentId) {
|
|
self.ticket.bind_attachment(attachment);
|
|
}
|
|
|
|
pub(crate) fn into_main_thread_parts(
|
|
self,
|
|
) -> (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
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub(crate) fn main_protocol_raw_json(&self) -> &str {
|
|
match self.main_thread_payload() {
|
|
RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {
|
|
raw_json,
|
|
..
|
|
}
|
|
| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {
|
|
raw_json,
|
|
..
|
|
} => raw_json,
|
|
_ => panic!("only a deferred Main protocol command can enter the nested receiver"),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn main_protocol_response(&self) -> &RendererRuntimeInspectorResponseSender {
|
|
self.response()
|
|
.expect("only a deferred Main protocol command can enter the nested receiver")
|
|
}
|
|
|
|
pub(crate) fn into_main_protocol_parts(
|
|
self,
|
|
) -> (
|
|
RendererInspectorIngressTicket,
|
|
String,
|
|
RendererRuntimeInspectorResponseSender,
|
|
) {
|
|
assert_eq!(
|
|
self.main_dispatch_boundary,
|
|
RendererInspectorMainDispatchBoundary::InspectorSession,
|
|
"a Page-owner-dependent Main command cannot enter direct nested Inspector dispatch"
|
|
);
|
|
match self.payload {
|
|
RendererInspectorCommandPayload::MainThread(
|
|
RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithDeferredResponse {
|
|
raw_json,
|
|
deferred_response,
|
|
}
|
|
| RendererInspectorPageCommand::DispatchRuntimeProtocolMessageWithContextResolutionAndDeferredResponse {
|
|
raw_json,
|
|
deferred_response,
|
|
..
|
|
},
|
|
) => (self.ticket, raw_json, deferred_response),
|
|
_ => panic!("only a deferred Main protocol command can enter the nested receiver"),
|
|
}
|
|
}
|
|
|
|
pub(crate) fn completes_idle_termination(&self) -> bool {
|
|
matches!(
|
|
self.payload,
|
|
RendererInspectorCommandPayload::Io {
|
|
completes_idle_termination: true,
|
|
..
|
|
}
|
|
)
|
|
}
|
|
|
|
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 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.main_thread_payload(),
|
|
RendererInspectorPageCommand::RuntimeEnableEvents
|
|
)
|
|
}
|
|
|
|
pub(crate) fn cdp_nav_timing_label(&self) -> Option<&'static str> {
|
|
match self.main_thread_payload() {
|
|
RendererInspectorPageCommand::RuntimeEnableEvents => Some("RuntimeEnableEvents"),
|
|
RendererInspectorPageCommand::RuntimeDisableEvents => Some("RuntimeDisableEvents"),
|
|
RendererInspectorPageCommand::RuntimeBindingEvents { .. } => {
|
|
Some("RuntimeBindingEvents")
|
|
}
|
|
RendererInspectorPageCommand::CommitRuntimeBindingRemoval { .. } => {
|
|
Some("CommitRuntimeBindingRemoval")
|
|
}
|
|
RendererInspectorPageCommand::ApplyRuntimeProtocolState { .. } => {
|
|
Some("ApplyRuntimeProtocolState")
|
|
}
|
|
RendererInspectorPageCommand::DetachRuntimeInspectorSession { .. } => {
|
|
Some("DetachRuntimeInspectorSession")
|
|
}
|
|
RendererInspectorPageCommand::DocumentNodeSnapshotForObjectId { .. } => {
|
|
Some("DocumentNodeSnapshotForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::RequestDocumentNodeForObjectId { .. } => {
|
|
Some("RequestDocumentNodeForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::AccessibilityTreePayloadsForObjectId { .. } => {
|
|
Some("AccessibilityTreePayloadsForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::AccessibilityNodeAndAncestorPayloadsForObjectId {
|
|
..
|
|
} => Some("AccessibilityNodeAndAncestorPayloadsForObjectId"),
|
|
RendererInspectorPageCommand::AccessibilityPartialTreePayloadsForObjectId {
|
|
..
|
|
} => Some("AccessibilityPartialTreePayloadsForObjectId"),
|
|
RendererInspectorPageCommand::OuterHtmlForObjectId { .. } => {
|
|
Some("OuterHtmlForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::PrepareElementClick { .. } => Some("PrepareElementClick"),
|
|
RendererInspectorPageCommand::ScrollObjectNodeIntoViewIfNeeded { .. } => {
|
|
Some("ScrollObjectNodeIntoViewIfNeeded")
|
|
}
|
|
RendererInspectorPageCommand::ClientRectForObjectId { .. } => {
|
|
Some("ClientRectForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::DocumentGeometryForObjectId { .. } => {
|
|
Some("DocumentGeometryForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::NodeHasGeometryForObjectId { .. } => {
|
|
Some("NodeHasGeometryForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::SetFileInputFilesForObjectId { .. } => {
|
|
Some("SetFileInputFilesForObjectId")
|
|
}
|
|
RendererInspectorPageCommand::ResolveRuntimeObjectForBackendNodeId { .. } => {
|
|
Some("ResolveRuntimeObjectForBackendNodeId")
|
|
}
|
|
RendererInspectorPageCommand::ResolveBlobObject { .. } => Some("ResolveBlobObject"),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main_protocol_can_dispatch_at_inspector_session_boundary(
|
|
owner_context_resolution_action: Option<&str>,
|
|
message: Option<&Value>,
|
|
) -> bool {
|
|
let Some(message) = message else {
|
|
return false;
|
|
};
|
|
let method = message.get("method").and_then(Value::as_str);
|
|
let params = message.get("params").and_then(Value::as_object);
|
|
|
|
// These transitions have renderer-owned restore state and must therefore
|
|
// pass through PageVm even though their final sink is V8InspectorSession.
|
|
if matches!(
|
|
method,
|
|
Some("Runtime.enable" | "Runtime.disable" | "Console.enable" | "Console.disable")
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
let has_owner_scoped_runtime_semantics = params.is_some_and(|params| {
|
|
params.get("userGesture").and_then(Value::as_bool) == Some(true)
|
|
|| params.contains_key(crate::script_vm::WEBDRIVER_BIDI_FILE_PROMPT_HANDLER_PARAM)
|
|
});
|
|
if has_owner_scoped_runtime_semantics {
|
|
return false;
|
|
}
|
|
|
|
match owner_context_resolution_action {
|
|
// Page.createIsolatedWorld and Runtime.executionContextCreated expose
|
|
// V8 Inspector's native context id. Context-targeted commands can
|
|
// therefore enter Chromium's nested Main receiver without borrowing
|
|
// PageVm; an unknown or retired id is rejected by V8 itself.
|
|
Some("evaluate") => true,
|
|
// A target supplied by object, unique context, or numeric Inspector
|
|
// context is complete. Only the target-less compatibility form needs
|
|
// PageVm to insert Moli's default execution context.
|
|
Some("callFunctionOn") => params.is_some_and(|params| {
|
|
params.contains_key("objectId")
|
|
|| params.contains_key("uniqueContextId")
|
|
|| params.contains_key("executionContextId")
|
|
}),
|
|
Some(_) => false,
|
|
None => true,
|
|
}
|
|
}
|