Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(cdp): publish CSS and accessibility replies at the renderer

ldm044011a899cef
diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
index 0996f34b5..23eaf7b2c 100644
--- a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
+++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs
@@ -3381,3 +3381,175 @@ async fn websocket_cdp_owner_registry_shutdown_joins_shared_default_page_owner()
abort_test_cdp_server(server).await;
}
+
+async fn assert_native_isolate_handler_waits_for_resume(method: &str) {
+ let (fixture_addr, _fixture) = spawn_dedicated_fixture_server(
+ Router::new().route("/page", get(|| async {
+ axum::response::Html("<!doctype html><style>input {color: red}</style><form><input id=number autocomplete=cc-number></form>")
+ })),
+ "native-isolate-entry",
+ );
+ let (addr, server) = spawn_test_protocol_server().await;
+ let (mut browser, _) =
+ connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}"))
+ .await
+ .unwrap();
+ let context = cdp_create_browser_context(&mut browser, 1).await;
+ let target = cdp_create_attached_target(&mut browser, 2, &context).await;
+ let session = Some(target.session_id.as_str());
+ navigate_fixture_document(
+ &mut browser,
+ 4,
+ &target,
+ &format!("http://{fixture_addr}/page"),
+ )
+ .await;
+ let document = send_cdp_command(&mut browser, 5, "DOM.getDocument", session, json!({})).await;
+ let root = response_by_id(&document, 5)["result"]["root"]["nodeId"]
+ .as_u64()
+ .unwrap();
+ let query = send_cdp_command(
+ &mut browser,
+ 6,
+ "DOM.querySelector",
+ session,
+ json!({"nodeId": root, "selector": "#number"}),
+ )
+ .await;
+ let node = response_by_id(&query, 6)["result"]["nodeId"]
+ .as_u64()
+ .unwrap_or_else(|| panic!("fixture query failed after parsing: {query:#?}"));
+ let describe = send_cdp_command(
+ &mut browser,
+ 7,
+ "DOM.describeNode",
+ session,
+ json!({"nodeId": node}),
+ )
+ .await;
+ let backend = response_by_id(&describe, 7)["result"]["node"]["backendNodeId"]
+ .as_u64()
+ .unwrap();
+ let css = send_cdp_command(&mut browser, 8, "CSS.enable", session, json!({})).await;
+ let stylesheet = css
+ .iter()
+ .find(|message| message["method"] == "CSS.styleSheetAdded")
+ .expect("fixture inline stylesheet")["params"]["header"]["styleSheetId"]
+ .clone();
+ let (params, expression, expected) = match method {
+ "Page.setDocumentContent" => (
+ json!({"frameId": target.target_id, "html": "<!doctype html><body>resumed content</body>"}),
+ "document.body.textContent",
+ json!("resumed content"),
+ ),
+ "Page.resetNavigationHistory" => (json!({}), "history.length", json!(1)),
+ "Autofill.trigger" => (
+ json!({"fieldId": backend, "card": {
+ "number": "4444444444444448", "name": "Test Card", "expiryMonth": "12", "expiryYear": "2030", "cvc": "123"
+ }}),
+ "document.getElementById('number').value",
+ json!("4444444444444448"),
+ ),
+ "CSS.setStyleSheetText" => (
+ json!({"styleSheetId": stylesheet, "text": "input {color: blue}"}),
+ "document.querySelector('style').textContent",
+ json!("input {color: blue}"),
+ ),
+ "Emulation.setHardwareConcurrencyOverride" => (
+ json!({"hardwareConcurrency": 4}),
+ "navigator.hardwareConcurrency",
+ json!(4),
+ ),
+ _ => panic!("unsupported isolate-entry fixture: {method}"),
+ };
+ let enabled = send_cdp_command(&mut browser, 10, "Debugger.enable", session, json!({})).await;
+ assert!(response_by_id(&enabled, 10)["error"].is_null());
+ send_cdp_command_without_wait(
+ &mut browser,
+ 12,
+ "Runtime.evaluate",
+ session,
+ json!({
+ "expression": "(() => { history.pushState(null, '', '#one'); debugger; return 42; })()",
+ "returnByValue": true
+ }),
+ )
+ .await;
+ let paused = recv_until_match(&mut browser, |message| {
+ message["sessionId"] == target.session_id && message["method"] == "Debugger.paused"
+ })
+ .await;
+ assert!(paused.iter().all(|message| message["id"] != 12));
+
+ // This must be the first Main command after pausing. An earlier owner-only
+ // command would hide a missing requirement by blocking the session lane.
+ send_cdp_command_without_wait(&mut browser, 13, method, session, params).await;
+ let gate = send_cdp_command(
+ &mut browser,
+ 14,
+ "Performance.getMetrics",
+ session,
+ json!({}),
+ )
+ .await;
+ assert!(response_by_id(&gate, 14)["error"].is_null());
+ assert!(
+ gate.iter()
+ .all(|message| message["id"] != 12 && message["id"] != 13),
+ "{method} must wait for its independent V8 entry: {gate:?}"
+ );
+ send_cdp_command_without_wait(&mut browser, 15, "Debugger.resume", session, json!({})).await;
+ let mut completed = std::collections::HashSet::new();
+ let resumed = recv_until_match(&mut browser, |message| {
+ if message["sessionId"] == target.session_id
+ && let Some(id) = message["id"].as_u64()
+ {
+ assert!(completed.insert(id), "duplicate terminal: {message}");
+ }
+ [12, 13, 15].iter().all(|id| completed.contains(id))
+ })
+ .await;
+ assert_eq!(
+ response_by_id(&resumed, 12)["result"]["result"]["value"],
+ 42
+ );
+ assert!(
+ response_by_id(&resumed, 13)["error"].is_null(),
+ "{method}: {resumed:?}"
+ );
+ assert!(response_by_id(&resumed, 15)["error"].is_null());
+ let state = send_cdp_command(
+ &mut browser,
+ 16,
+ "Runtime.evaluate",
+ session,
+ json!({"expression": expression, "returnByValue": true}),
+ )
+ .await;
+ assert_eq!(
+ response_by_id(&state, 16)["result"]["result"]["value"],
+ expected,
+ "{method}: {state:?}"
+ );
+ assert!(
+ state.iter().all(|message| message["id"] != 13),
+ "duplicate terminal: {state:?}"
+ );
+ browser.close(None).await.unwrap();
+ abort_test_cdp_server(server).await;
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn cdp_ordering_document_content_waits_for_isolate_owner() {
+ assert_native_isolate_handler_waits_for_resume("Page.setDocumentContent").await;
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn cdp_ordering_history_reset_waits_for_isolate_owner() {
+ assert_native_isolate_handler_waits_for_resume("Page.resetNavigationHistory").await;
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn cdp_ordering_stylesheet_edit_waits_for_isolate_owner() {
+ assert_native_isolate_handler_waits_for_resume("CSS.setStyleSheetText").await;
+}
diff --git a/moli-protocol/src/domains/accessibility.rs b/moli-protocol/src/domains/accessibility.rs
index 9a1429f25..a3d9680c9 100644
--- a/moli-protocol/src/domains/accessibility.rs
+++ b/moli-protocol/src/domains/accessibility.rs
@@ -1,3 +1,5 @@
+pub(crate) mod native;
+
use crate::conn::{CdpConnection, Cmd, CommandOwnerScope};
use crate::domains::actions::AccessibilityAction;
use crate::domains::command_output::CommandOutputPlan;
diff --git a/moli-protocol/src/domains/accessibility/native.rs b/moli-protocol/src/domains/accessibility/native.rs
new file mode 100644
index 000000000..3c83e2e81
--- /dev/null
+++ b/moli-protocol/src/domains/accessibility/native.rs
@@ -0,0 +1,325 @@
+use super::*;
+use crate::domains::native::{self, NativeCommandStep};
+use moli_core::{
+ RendererNativeOperation as Operation, RendererNativeOperationStep as Step,
+ RendererNativeProtocolResponse as Response, RendererPageCommand as Command,
+ RendererPageReply as Reply,
+};
+
+pub(crate) fn try_start(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> Option<NativeCommandStep> {
+ let action = cmd.parse_action::<AccessibilityAction>()?;
+ if !action.queries_tree() {
+ return None;
+ }
+ let operation = prepare(conn, cmd, action);
+ Some(match operation {
+ Ok(operation) => native::start_operation(conn, cmd, operation),
+ Err(error) => {
+ NativeCommandStep::Complete(CommandOutputPlan::error(error.code, error.message))
+ }
+ })
+}
+
+type StartError = PendingAccessibilityCommandStartError;
+
+fn prepare(
+ conn: &CdpConnection,
+ cmd: &Cmd<'_>,
+ action: AccessibilityAction,
+) -> Result<Operation, StartError> {
+ let top_frame_id = helpers::top_frame_id_for_session(conn, cmd.session_id)
+ .ok_or_else(StartError::no_document_loaded)?;
+ match action {
+ AccessibilityAction::GetFullAxTree => {
+ let params = cmd
+ .get_params::<helpers::GetFullAxTreeParams>()
+ .map_err(|_| StartError::invalid_params())?
+ .unwrap_or(helpers::GetFullAxTreeParams {
+ depth: None,
+ frame_id: None,
+ });
+ let max_depth = match params.depth {
+ Some(depth) => {
+ let depth = i32::try_from(depth).map_err(|_| StartError::invalid_params())?;
+ (depth >= 0).then_some(depth)
+ }
+ None => None,
+ };
+ Ok(frame_operation(
+ top_frame_id,
+ params.frame_id.map(|id| id.as_ref().to_owned()),
+ max_depth,
+ false,
+ ))
+ }
+ AccessibilityAction::GetRootAxNode => {
+ let params = cmd
+ .get_params::<helpers::FrameScopedParams>()
+ .map_err(|_| StartError::invalid_params())?
+ .unwrap_or(helpers::FrameScopedParams { frame_id: None });
+ Ok(frame_operation(top_frame_id, params.frame_id, None, true))
+ }
+ AccessibilityAction::GetChildAxNodes => {
+ let params = cmd
+ .get_params::<helpers::ChildAxNodesParams>()
+ .ok()
+ .flatten()
+ .ok_or_else(StartError::invalid_params)?;
+ let backend_node_id = helpers::parse_ax_backend_node_id(params.id.as_ref())
+ .ok_or_else(StartError::invalid_params)?;
+ let frame_id = params
+ .frame_id
+ .map(|id| id.as_ref().to_owned())
+ .unwrap_or_else(|| top_frame_id.clone());
+ Ok(backend_operation(
+ backend_node_id,
+ frame_id,
+ top_frame_id,
+ AccessibilityNodeOperation::Children,
+ ))
+ }
+ AccessibilityAction::GetAxNodeAndAncestors => {
+ let params = cmd
+ .get_params::<helpers::AncestorsParams>()
+ .ok()
+ .flatten()
+ .ok_or_else(StartError::invalid_params)?;
+ reference_operation(
+ conn,
+ cmd,
+ params.reference,
+ params.frame_id,
+ top_frame_id,
+ AccessibilityNodeOperation::Ancestors,
+ )
+ }
+ AccessibilityAction::QueryAxTree => {
+ let params = cmd
+ .get_params::<helpers::QueryAxTreeParams>()
+ .ok()
+ .flatten()
+ .ok_or_else(StartError::invalid_params)?;
+ reference_operation(
+ conn,
+ cmd,
+ params.reference,
+ params.frame_id,
+ top_frame_id,
+ AccessibilityNodeOperation::Query {
+ accessible_name: params.accessible_name,
+ role: params.role,
+ },
+ )
+ }
+ AccessibilityAction::GetPartialAxTree => {
+ let params = cmd
+ .get_params::<helpers::PartialAxTreeParams>()
+ .ok()
+ .flatten()
+ .ok_or_else(StartError::invalid_params)?;
+ reference_operation(
+ conn,
+ cmd,
+ params.reference,
+ params.frame_id,
+ top_frame_id,
+ AccessibilityNodeOperation::Partial {
+ fetch_relatives: params.fetch_relatives.unwrap_or(true),
+ },
+ )
+ }
+ AccessibilityAction::Enable | AccessibilityAction::Disable => unreachable!(),
+ }
+}
+
+fn frame_operation(
+ top_frame_id: String,
+ frame_id: Option<String>,
+ max_depth: Option<i32>,
+ root_only: bool,
+) -> Operation {
+ let frame_id = frame_id.unwrap_or_else(|| top_frame_id.clone());
+ let child = frame_id != top_frame_id;
+ let command = match (child, root_only) {
+ (false, false) => Command::AccessibilityTreePayloadsForDocument { max_depth },
+ (false, true) => Command::AccessibilityNodePayloadForDocument,
+ (true, false) => Command::AccessibilityTreePayloadsForChildFrame {
+ frame_id,
+ max_depth,
+ },
+ (true, true) => Command::AccessibilityNodePayloadForChildFrame { frame_id },
+ };
+ Operation::new(command, move |reply| match reply {
+ Ok(Reply::OptionalAccessibilityPayload(Some(node))) => {
+ Response::success(json!({"node": node}))
+ }
+ Ok(Reply::OptionalAccessibilityPayloads(Some(nodes))) => {
+ Response::success(json!({"nodes": nodes}))
+ }
+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(Some(payload))) => {
+ match payload.payloads {
+ Some(mut nodes) if root_only => {
+ if nodes.is_empty() {
+ node_not_found()
+ } else {
+ Response::success(json!({"node": nodes.remove(0)}))
+ }
+ }
+ Some(nodes) => Response::success(json!({"nodes": nodes})),
+ None => node_not_found(),
+ }
+ }
+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(None)) => Response::error(
+ -32000,
+ "Frame with the given id does not belong to the target.",
+ ),
+ Ok(
+ Reply::OptionalAccessibilityPayload(None) | Reply::OptionalAccessibilityPayloads(None),
+ ) => Response::error(-32000, "NoDocumentLoaded"),
+ Err(error) => {
+ let kind = if root_only {
+ "root accessibility node"
+ } else {
+ "accessibility tree"
+ };
+ let suffix = if child { " for frame" } else { "" };
+ Response::error(-32000, format!("Could not build {kind}{suffix}: {error}"))
+ }
+ _ => unreachable!("frame accessibility reply"),
+ })
+}
+
+fn reference_operation(
+ conn: &CdpConnection,
+ cmd: &Cmd<'_>,
+ reference: helpers::NodeReferenceParams,
+ frame_id: Option<String>,
+ top_frame_id: String,
+ operation: AccessibilityNodeOperation,
+) -> Result<Operation, StartError> {
+ let frame_id = frame_id.unwrap_or_else(|| top_frame_id.clone());
+ if let Some(object_id) = reference.object_id {
+ let session = cmd.session_id.map(str::to_owned);
+ let command = match &operation {
+ AccessibilityNodeOperation::Ancestors => {
+ Command::accessibility_node_and_ancestor_payloads_for_object_id(session, object_id)
+ }
+ AccessibilityNodeOperation::Query { .. } => {
+ Command::accessibility_tree_payloads_for_object_id(session, object_id)
+ }
+ AccessibilityNodeOperation::Partial { fetch_relatives } => {
+ Command::accessibility_partial_tree_payloads_for_object_id(
+ session,
+ object_id,
+ *fetch_relatives,
+ )
+ }
+ AccessibilityNodeOperation::Children => unreachable!(),
+ };
+ return Ok(Operation::new(command, move |reply| {
+ project_nodes(reply, frame_id, top_frame_id, operation)
+ }));
+ }
+ if let Some(backend_node_id) = renderer_backend_node_id_for_reference(&reference) {
+ return Ok(backend_operation(
+ backend_node_id,
+ frame_id,
+ top_frame_id,
+ operation,
+ ));
+ }
+ let frontend_node_id = reference.node_id.ok_or_else(StartError::node_not_found)?;
+ let inspector_session_id =
+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);
+ Ok(Operation::then_on_nested_main(
+ Command::DocumentFrontendNodeBinding {
+ inspector_session_id,
+ frontend_node_id,
+ },
+ move |reply| match reply {
+ Ok(Reply::DocumentFrontendNodeBinding(
+ RendererDomFrontendNodeBindingResolution::BackendNodeId(id),
+ )) => Step::Continue(backend_operation(id, frame_id, top_frame_id, operation)),
+ Ok(Reply::DocumentFrontendNodeBinding(
+ RendererDomFrontendNodeBindingResolution::NotFound,
+ )) => Step::Complete(node_not_found()),
+ Err(error) => Step::Complete(Response::error(
+ -32000,
+ format!("Could not resolve frontend node binding: {error}"),
+ )),
+ _ => unreachable!("accessibility frontend-node lookup reply"),
+ },
+ ))
+}
+
+fn backend_operation(
+ backend_node_id: u32,
+ frame_id: String,
+ top_frame_id: String,
+ operation: AccessibilityNodeOperation,
+) -> Operation {
+ let command = match &operation {
+ AccessibilityNodeOperation::Children => {
+ Command::AccessibilityChildNodePayloadsForBackendNodeId { backend_node_id }
+ }
+ AccessibilityNodeOperation::Ancestors => {
+ Command::AccessibilityNodeAndAncestorPayloadsForBackendNodeId { backend_node_id }
+ }
+ AccessibilityNodeOperation::Query { .. } => {
+ Command::AccessibilityTreePayloadsForBackendNodeId {
+ backend_node_id,
+ max_depth: None,
+ }
+ }
+ AccessibilityNodeOperation::Partial { fetch_relatives } => {
+ Command::AccessibilityPartialTreePayloadsForBackendNodeId {
+ backend_node_id,
+ fetch_relatives: *fetch_relatives,
+ }
+ }
+ };
+ Operation::new(command, move |reply| {
+ project_nodes(reply, frame_id, top_frame_id, operation)
+ })
+}
+
+fn project_nodes(
+ reply: anyhow::Result<Reply>,
+ frame_id: String,
+ top_frame_id: String,
+ operation: AccessibilityNodeOperation,
+) -> Response {
+ let payload = match reply {
+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(Some(payload))) => payload,
+ Ok(Reply::OptionalAccessibilityPayloadsForObjectId(None)) => return node_not_found(),
+ Err(error) => {
+ return Response::error(
+ -32000,
+ format!("Could not build accessibility payload for node: {error}"),
+ );
+ }
+ _ => unreachable!("accessibility node reply"),
+ };
+ if payload.frame_id.as_deref().unwrap_or(&top_frame_id) != frame_id {
+ return node_not_found();
+ }
+ let Some(mut nodes) = payload.payloads else {
+ return node_not_found();
+ };
+ if let AccessibilityNodeOperation::Query {
+ accessible_name,
+ role,
+ } = operation
+ {
+ retain_matching_accessibility_nodes(
+ &mut nodes,
+ accessible_name.as_deref(),
+ role.as_deref(),
+ );
+ }
+ Response::success(json!({"nodes": nodes}))
+}
+
+fn node_not_found() -> Response {
+ Response::error(-32000, "Could not find node with given id")
+}
diff --git a/moli-protocol/src/domains/accessibility/tests.rs b/moli-protocol/src/domains/accessibility/tests.rs
index 9a798a17f..077fb5aae 100644
--- a/moli-protocol/src/domains/accessibility/tests.rs
+++ b/moli-protocol/src/domains/accessibility/tests.rs
@@ -13,7 +13,9 @@ async fn complete_pending_command_task_for_test(
let completed = pending.wait().await;
match ctx.conn.complete_pending_command_dispatch(completed).await {
CdpCommandTaskStep::Pending(next) => pending = *next,
- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts(),
+ CdpCommandTaskStep::Complete(outcome) => {
+ return ctx.route_completed_command_outcome_for_test(outcome).await;
+ }
}
}
}
@@ -23,7 +25,11 @@ async fn complete_command_task_for_test(
step: CdpCommandTaskStep,
) -> Vec<Value> {
match step {
- CdpCommandTaskStep::Complete(outcome) => outcome.into_parts().0,
+ CdpCommandTaskStep::Complete(outcome) => {
+ ctx.route_completed_command_outcome_for_test(outcome)
+ .await
+ .0
+ }
CdpCommandTaskStep::Pending(pending) => {
complete_pending_command_task_for_test(ctx, *pending)
.await
@@ -435,7 +441,7 @@ async fn accessibility_loaded_page_methods_target_background_owner_without_activ
"method": "Accessibility.getFullAXTree"
}))
.await;
- let full_tree = ctx.take_one();
+ let full_tree = ctx.take_response_by_id(201);
assert_eq!(full_tree["sessionId"], "SID-background");
let nodes = full_tree["result"]["nodes"]
.as_array()
@@ -554,7 +560,7 @@ async fn accessibility_loaded_page_methods_target_inactive_owner_without_activat
"method": "Accessibility.getFullAXTree"
}))
.await;
- let full_tree = ctx.take_one();
+ let full_tree = ctx.take_response_by_id(211);
assert_eq!(full_tree["sessionId"], "SID-inactive");
let nodes = full_tree["result"]["nodes"]
.as_array()
@@ -570,7 +576,7 @@ async fn accessibility_loaded_page_methods_target_inactive_owner_without_activat
"method": "Accessibility.getRootAXNode"
}))
.await;
- let root = ctx.take_one();
+ let root = ctx.take_response_by_id(212);
assert_eq!(root["sessionId"], "SID-inactive");
assert_eq!(root["result"]["node"]["role"]["value"], "RootWebArea");
assert_eq!(
@@ -1970,7 +1976,7 @@ async fn get_ax_node_and_ancestors_object_id_completes_with_single_renderer_comm
else {
panic!("top-frame object id AX lookup should complete after one renderer command");
};
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
"AX top-frame object lookup should not enqueue scheduler events: {scheduler_events:?}"
@@ -2282,7 +2288,7 @@ async fn async_dispatch_get_ax_node_and_ancestors_accepts_child_frame_object_id(
else {
panic!("child-frame object id AX lookup should complete after one renderer command");
};
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
"AX child-frame object lookup should not enqueue scheduler events: {scheduler_events:?}"
@@ -2364,7 +2370,8 @@ async fn child_frame_ax_reference_accepts_renderer_backend_node_id_live() {
"{method} with child renderer backend id should complete after one renderer command"
);
};
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) =
+ ctx.route_completed_command_outcome_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
"{method} should not enqueue scheduler events: {scheduler_events:?}"
@@ -2839,7 +2846,7 @@ async fn async_dispatch_query_ax_tree_accepts_child_frame_object_id() {
else {
panic!("child-frame object id AX query should complete after one renderer command");
};
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
"AX child-frame object query should not enqueue scheduler events: {scheduler_events:?}"
@@ -3165,7 +3172,7 @@ async fn async_dispatch_get_partial_ax_tree_accepts_child_frame_object_id() {
"child-frame object id partial AX lookup should complete after one renderer command"
);
};
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.route_completed_command_outcome_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
"AX child-frame object partial lookup should not enqueue scheduler events: {scheduler_events:?}"
diff --git a/moli-protocol/src/domains/css.rs b/moli-protocol/src/domains/css.rs
index b022d2656..1827c3a3b 100644
--- a/moli-protocol/src/domains/css.rs
+++ b/moli-protocol/src/domains/css.rs
@@ -1,3 +1,5 @@
+pub(crate) mod native;
+
use crate::conn::{CdpConnection, Cmd, CommandOwnerScope};
use crate::domains::actions::CssAction;
use crate::domains::command_output::CommandOutputPlan;
@@ -777,7 +779,9 @@ mod tests {
let completed = pending.wait().await;
match ctx.conn.complete_pending_command_dispatch(completed).await {
CdpCommandTaskStep::Pending(next) => pending = *next,
- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts(),
+ CdpCommandTaskStep::Complete(outcome) => {
+ return ctx.route_completed_command_outcome_for_test(outcome).await;
+ }
}
}
}
@@ -1276,8 +1280,8 @@ mod tests {
.position(|message| message["method"] == json!("CSS.styleSheetAdded"))
.expect("CSS.styleSheetAdded event");
assert!(
- response_pos < first_event_pos,
- "stylesheet event should follow CSS.enable response: {:?}",
+ first_event_pos < response_pos,
+ "stylesheet event should precede CSS.enable response: {:?}",
ctx.sent
);
@@ -1683,6 +1687,9 @@ mod tests {
.await
.expect("background page should load");
+ let active_renderer = crate::conn::RendererPageResidenceIdentity::from_page(&active_page);
+ let background_renderer =
+ crate::conn::RendererPageResidenceIdentity::from_page(&background_page);
let mut browser_context = BrowserContext::new("BID-css-owner-route".to_owned());
browser_context.set_active_target_id("TID-css-active".to_owned());
browser_context
@@ -1702,6 +1709,26 @@ mod tests {
.replace_loaded_page(Some(background_page));
ctx.conn
.install_browser_context_fixture_for_test(browser_context);
+ // These fixture Pages bypass production attachment. Preserve their
+ // exact stream owners before any command publishes a native response.
+ for (target, renderer) in [
+ ("TID-css-active", active_renderer),
+ ("TID-css-background", background_renderer),
+ ] {
+ let owner = crate::conn::CommandOwnerScope::for_route(
+ crate::conn::CdpSessionRoute::PageTarget {
+ browser_context_id: "BID-css-owner-route".to_owned(),
+ target_id: target.to_owned(),
+ session_key: moli_page_types::DevToolsSessionKey::Primary,
+ },
+ );
+ let residence = ctx
+ .conn
+ .target_page_residence_identity_for_owner(&owner)
+ .unwrap();
+ ctx.conn
+ .bind_renderer_page_output_owner(renderer, residence);
+ }
let background_session = attach_page_session_async(&mut ctx, "TID-css-background").await;
let active_style_sheet_id = inline_style_sheet_id_for_session_async(&mut ctx, None).await;
@@ -2370,7 +2397,8 @@ mod tests {
let CdpCommandTaskStep::Complete(outcome) = step else {
panic!("CSS objectId computed style should complete after one renderer command");
};
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) =
+ ctx.route_completed_command_outcome_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
"computed style objectId lookup should not enqueue scheduler events: {scheduler_events:?}"
diff --git a/moli-protocol/src/domains/css/native.rs b/moli-protocol/src/domains/css/native.rs
new file mode 100644
index 000000000..571ea267f
--- /dev/null
+++ b/moli-protocol/src/domains/css/native.rs
@@ -0,0 +1,212 @@
+use super::*;
+use crate::domains::native::{self, NativeCommandStep};
+use moli_core::{
+ RendererNativeOperation as Operation, RendererNativeOperationStep as Step,
+ RendererNativeProtocolResponse as Response, RendererPageCommand as Command,
+ RendererPageReply as Reply,
+};
+
+pub(crate) fn try_start(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> Option<NativeCommandStep> {
+ let action = cmd.parse_action::<CssAction>()?;
+ let inspector_session_id =
+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id);
+ let frame_id = top_frame_id_for_session(conn, cmd.session_id).unwrap_or_default();
+ let invalid_params =
+ || NativeCommandStep::Complete(CommandOutputPlan::error(-32602, "InvalidParams"));
+ let operation = match action {
+ CssAction::Enable => {
+ conn.mutate_target_page_state_for_session(cmd.session_id, |state| {
+ state.css_enabled = true
+ });
+ Operation::new(
+ Command::StyleSheetInventoryForDocument {
+ inspector_session_id,
+ },
+ move |reply| match reply {
+ Ok(Reply::StyleSheetInventory(update)) => {
+ let mut response = Response::success(json!({}));
+ for id in update.removed {
+ response.notifications.push(json!({"method": "CSS.styleSheetRemoved", "params": {"styleSheetId": id}}).into());
+ }
+ for header in update.added {
+ response.notifications.push(json!({"method": "CSS.styleSheetAdded", "params": {
+ "header": style_sheets::style_sheet_header_value(&frame_id, &header),
+ }}).into());
+ }
+ response
+ }
+ Err(error) => Response::error(-32000, error.to_string()),
+ _ => unreachable!("CSS inventory reply"),
+ },
+ )
+ }
+ CssAction::Disable => {
+ conn.mutate_target_page_state_for_session(cmd.session_id, |state| {
+ state.css_enabled = false
+ });
+ Operation::new(
+ Command::ResetCssAgentSession {
+ inspector_session_id,
+ },
+ |reply| match reply {
+ Ok(Reply::Unit) => Response::success(json!({})),
+ Err(error) => Response::error(-32000, error.to_string()),
+ _ => unreachable!("CSS reset reply"),
+ },
+ )
+ }
+ CssAction::GetStyleSheet => {
+ let params = match cmd.get_params::<StyleSheetIdParams>() {
+ Ok(Some(params)) => params,
+ _ => return Some(invalid_params()),
+ };
+ let id = params.style_sheet_id.as_ref().to_owned();
+ Operation::new(
+ Command::StyleSheetPayloadForStyleSheetId {
+ inspector_session_id,
+ style_sheet_id: id.clone(),
+ },
+ move |reply| match reply {
+ Ok(Reply::OptionalStyleSheetPayload(Some(payload))) => {
+ style_sheets::get_style_sheet_command_output_plan(&id, &frame_id, payload)
+ .into_native_response()
+ }
+ Ok(Reply::OptionalStyleSheetPayload(None)) => {
+ Response::error(-32000, "Could not find stylesheet with given id")
+ }
+ Err(error) => Response::error(-32000, error.to_string()),
+ _ => unreachable!("CSS stylesheet reply"),
+ },
+ )
+ }
+ CssAction::SetStyleSheetText => {
+ let params = match cmd.get_params::<SetStyleSheetTextParams>() {
+ Ok(Some(params)) => params,
+ _ => return Some(invalid_params()),
+ };
+ let id = params.style_sheet_id.as_ref().to_owned();
+ Operation::new(
+ Command::SetInlineStyleSheetTextForStyleSheetId {
+ inspector_session_id,
+ style_sheet_id: id.clone(),
+ text: params.text,
+ },
+ move |reply| match reply {
+ Ok(Reply::Bool(true)) => {
+ Response::success(json!({"styleSheetId": id, "sourceMapURL": ""}))
+ }
+ Ok(Reply::Bool(false)) => {
+ Response::error(-32000, "Could not find stylesheet with given id")
+ }
+ Err(error) => Response::error(-32000, error.to_string()),
+ _ => unreachable!("CSS text mutation reply"),
+ },
+ )
+ }
+ CssAction::GetComputedStyleForNode
+ | CssAction::GetInlineStylesForNode
+ | CssAction::GetMatchedStylesForNode => {
+ let params = match cmd.get_params::<NodeReferenceParams>() {
+ Ok(Some(params)) => params,
+ _ => return Some(invalid_params()),
+ };
+ let query = match action {
+ CssAction::GetComputedStyleForNode => StyleQuery::Computed,
+ CssAction::GetInlineStylesForNode => {
+ StyleQuery::Inline(InlineStyleQueryKind::InlineStyles)
+ }
+ CssAction::GetMatchedStylesForNode => {
+ StyleQuery::Inline(InlineStyleQueryKind::MatchedStyles)
+ }
+ _ => unreachable!(),
+ };
+ if let Some(object_id) = params.object_id {
+ if matches!(query, StyleQuery::Inline(_)) {
+ // The existing native API has no inline-style object-id
+ // lookup. Preserve its explicit unsupported-method result.
+ return None;
+ }
+ Operation::new(
+ Command::computed_style_properties_for_object_id(
+ cmd.session_id.map(str::to_owned),
+ object_id,
+ ),
+ move |reply| project_style(reply, query),
+ )
+ } else if let Some(frontend_node_id) = params.node_id {
+ Operation::then_on_nested_main(
+ Command::DocumentFrontendNodeBinding {
+ inspector_session_id,
+ frontend_node_id,
+ },
+ move |reply| match reply {
+ Ok(Reply::DocumentFrontendNodeBinding(resolution)) => {
+ match node_references::backend_node_id_from_frontend_resolution(
+ resolution,
+ ) {
+ Some(id) => Step::Continue(backend_style_operation(id, query)),
+ None => Step::Complete(Response::error(
+ -32000,
+ "Could not find node with given id",
+ )),
+ }
+ }
+ Err(error) => Step::Complete(Response::error(
+ -32000,
+ format!("Could not resolve frontend node binding: {error}"),
+ )),
+ _ => unreachable!("CSS frontend-node lookup reply"),
+ },
+ )
+ } else if let Some(backend_node_id) = params.backend_node_id {
+ backend_style_operation(backend_node_id, query)
+ } else {
+ return Some(NativeCommandStep::Complete(CommandOutputPlan::error(
+ -32000,
+ "Could not find node with given id",
+ )));
+ }
+ }
+ };
+ Some(native::start_operation(conn, cmd, operation))
+}
+
+#[derive(Clone, Copy)]
+enum StyleQuery {
+ Computed,
+ Inline(InlineStyleQueryKind),
+}
+
+fn backend_style_operation(backend_node_id: u32, query: StyleQuery) -> Operation {
+ let command = match query {
+ StyleQuery::Computed => {
+ Command::ComputedStylePropertiesForBackendNodeId { backend_node_id }
+ }
+ StyleQuery::Inline(_) => {
+ Command::DocumentNodeAttributesForBackendNodeId { backend_node_id }
+ }
+ };
+ Operation::new(command, move |reply| project_style(reply, query))
+}
+
+fn project_style(reply: anyhow::Result<Reply>, query: StyleQuery) -> Response {
+ match (query, reply) {
+ (StyleQuery::Computed, Ok(Reply::ComputedStyleProperties(Some(properties)))) => {
+ computed_style_command_output_plan(properties).into_native_response()
+ }
+ (StyleQuery::Computed, Ok(Reply::ComputedStyleProperties(None))) => {
+ Response::error(-32000, "Could not find node with given id")
+ }
+ (StyleQuery::Inline(kind), Ok(Reply::DocumentNodeAttributesResolution(attributes))) => {
+ match inline_style_result_from_attributes_resolution(attributes, kind) {
+ Ok(result) => Response::success(result),
+ Err(error) => Response::error(error.code, error.message),
+ }
+ }
+ (StyleQuery::Computed, Err(error)) => {
+ Response::error(-32000, format!("failed to compute style: {error}"))
+ }
+ (_, Err(error)) => Response::error(-32000, error.to_string()),
+ _ => unreachable!("CSS native style reply"),
+ }
+}
diff --git a/moli-protocol/src/domains/css/style_sheets.rs b/moli-protocol/src/domains/css/style_sheets.rs
index 19bf31693..bb945e96f 100644
--- a/moli-protocol/src/domains/css/style_sheets.rs
+++ b/moli-protocol/src/domains/css/style_sheets.rs
@@ -127,7 +127,7 @@ fn set_css_enabled(conn: &mut CdpConnection, cmd: &Cmd<'_>, enabled: bool) {
});
}
-fn style_sheet_header_value(frame_id: &str, header: &RendererStyleSheetHeader) -> Value {
+pub(super) fn style_sheet_header_value(frame_id: &str, header: &RendererStyleSheetHeader) -> Value {
json!({
"styleSheetId": header.style_sheet_id,
"frameId": frame_id,
diff --git a/moli-protocol/src/domains/native.rs b/moli-protocol/src/domains/native.rs
index d9335ffa8..667d2dc25 100644
--- a/moli-protocol/src/domains/native.rs
+++ b/moli-protocol/src/domains/native.rs
@@ -155,6 +155,8 @@ pub(crate) fn try_start(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> Option<Nativ
match cmd.method.split_once('.')?.0 {
"Page" => super::page::native::try_start,
"DOMSnapshot" => super::dom_snapshot::try_start_native_command,
+ "CSS" => super::css::native::try_start,
+ "Accessibility" => super::accessibility::native::try_start,
_ => return None,
};
frontend_attachment(conn, cmd)?;