Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(cdp): derive page metrics from initialized layout

ldm025109295330f
diff --git a/moli-protocol/src/conn/browser_context/target_session_owner.rs b/moli-protocol/src/conn/browser_context/target_session_owner.rs
index 1a6dfa1d7..1961e6a70 100644
--- a/moli-protocol/src/conn/browser_context/target_session_owner.rs
+++ b/moli-protocol/src/conn/browser_context/target_session_owner.rs
@@ -2289,14 +2289,6 @@ impl CdpConnection {
.frame_tree_loader_id()
}
- pub(crate) fn target_session_owner_emulated_device_metrics(
- &self,
- session_id: Option<&str>,
- ) -> Option<crate::conn::EmulatedDeviceMetrics> {
- self.target_session_owner_ref(session_id)?
- .emulated_device_metrics()
- }
-
pub(crate) fn target_session_owner_emulated_device_metrics_for_owner(
&self,
owner: &CommandOwnerScope,
diff --git a/moli-protocol/src/conn/dispatch_tests.rs b/moli-protocol/src/conn/dispatch_tests.rs
index 437e5f45c..8b9f8cfab 100644
--- a/moli-protocol/src/conn/dispatch_tests.rs
+++ b/moli-protocol/src/conn/dispatch_tests.rs
@@ -4371,8 +4371,9 @@ async fn devtools_command_executes_context_viewport_override() {
DevToolsCommandResult::Empty
);
+ let owner = CommandOwnerScope::capture(&conn, None);
let metrics = conn
- .target_session_owner_emulated_device_metrics(None)
+ .target_session_owner_emulated_device_metrics_for_owner(&owner)
.expect("active target should hold emulated device metrics");
assert_eq!(metrics.width, 800);
assert_eq!(metrics.height, 600);
@@ -7214,7 +7215,8 @@ fn command_dispatch_completes_additional_page_sync_commands_without_legacy_fallb
let messages = complete_messages(step);
assert_eq!(messages.len(), 1);
assert_eq!(messages[0]["id"], json!(412));
- assert!(messages[0]["result"]["layoutViewport"].is_object());
+ assert_eq!(messages[0]["error"]["code"], -32000);
+ assert_eq!(messages[0]["error"]["message"], "NoDocumentLoaded");
let print_raw = serde_json::to_string(&json!({
"id": 413,
diff --git a/moli-protocol/src/domains/emulation/tests.rs b/moli-protocol/src/domains/emulation/tests.rs
index d8a83d17c..dd3ad74ca 100644
--- a/moli-protocol/src/domains/emulation/tests.rs
+++ b/moli-protocol/src/domains/emulation/tests.rs
@@ -2641,6 +2641,9 @@ async fn device_metrics_override_updates_layout_metrics() {
let mut bc = BrowserContext::new("BID-1".into());
bc.set_active_target_id("TID-1");
ctx.conn.install_browser_context_fixture_for_test(bc);
+ ctx.install_navigation_fixture_for_session_owner("about:blank", None)
+ .await;
+ ctx.sent.clear();
ctx.process_async(json!({
"id": 12,
diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rs
index 68ce479c7..256c1ead6 100644
--- a/moli-protocol/src/domains/page.rs
+++ b/moli-protocol/src/domains/page.rs
@@ -41,7 +41,7 @@ use crate::conn::{
CommandOwnerScope, NETWORK_ERROR_PAGE_URL, PageLifecycleEventsEnableResult,
PageScreencastConfig, PageScreencastFormat,
};
-use crate::conn::{CdpConnection, Cmd, EmulatedViewportSurface};
+use crate::conn::{CdpConnection, Cmd};
pub(crate) use crate::conn::{DEFAULT_LOADER_ID as LOADER_ID, monotonic_timestamp_seconds};
use crate::domains::actions::PageAction;
use crate::domains::activity::{
@@ -5890,32 +5890,6 @@ struct PageSetDownloadBehaviorParams {
download_path: Option<String>,
}
-fn current_viewport_surface(
- conn: &CdpConnection,
- session_id: Option<&str>,
-) -> EmulatedViewportSurface {
- (conn
- .target_session_owner_emulated_device_metrics(session_id)
- .as_ref())
- .map_or_else(
- EmulatedViewportSurface::default,
- crate::conn::EmulatedDeviceMetrics::viewport_surface,
- )
-}
-
-fn current_viewport_surface_for_owner(
- conn: &CdpConnection,
- owner: &CommandOwnerScope,
-) -> EmulatedViewportSurface {
- (conn
- .target_session_owner_emulated_device_metrics_for_owner(owner)
- .as_ref())
- .map_or_else(
- EmulatedViewportSurface::default,
- crate::conn::EmulatedDeviceMetrics::viewport_surface,
- )
-}
-
async fn execute_devtools_get_layout_metrics_command(
conn: &mut CdpConnection,
command: DevToolsGetLayoutMetricsCommand,
@@ -5929,14 +5903,12 @@ async fn execute_devtools_get_layout_metrics_for_current_owner(
conn: &mut CdpConnection,
owner: &CommandOwnerScope,
) -> Result<DevToolsLayoutMetricsResult, DevToolsError> {
- let fallback =
- layout_metrics_result_from_surface(current_viewport_surface_for_owner(conn, owner));
let Some(page) = conn
.runtime_session_owner_slot_mut_for_owner(owner)
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
- return Ok(fallback);
+ return Err(devtools_layout_metrics_error("NoDocumentLoaded"));
};
let pending = page.start_layout_metrics().map_err(|error| {
devtools_layout_metrics_error(format!("Failed to start layout metrics: {error}"))
@@ -5958,20 +5930,6 @@ async fn execute_devtools_get_layout_metrics_for_current_owner(
})
}
-fn layout_metrics_result_from_surface(
- surface: EmulatedViewportSurface,
-) -> DevToolsLayoutMetricsResult {
- DevToolsLayoutMetricsResult {
- layout_viewport_width: surface.inner_width,
- layout_viewport_height: surface.inner_height,
- page_x: 0.0,
- page_y: 0.0,
- content_width: f64::from(surface.inner_width),
- content_height: f64::from(surface.inner_height),
- device_pixel_ratio: surface.device_pixel_ratio,
- }
-}
-
fn layout_metrics_result_from_renderer(
metrics: RendererLayoutMetrics,
) -> DevToolsLayoutMetricsResult {
@@ -7165,8 +7123,8 @@ mod protocol_neutral_tests {
let mut out = Vec::new();
plan.emit_into(&mut out, cmd.id, cmd.session_id);
assert_eq!(out[0]["id"], json!(123));
- assert!(out[0]["result"]["layoutViewport"]["clientWidth"].is_u64());
- assert!(out[0]["result"]["visualViewport"]["clientHeight"].is_u64());
+ assert_eq!(out[0]["error"]["code"], -32000);
+ assert_eq!(out[0]["error"]["message"], "NoDocumentLoaded");
}
#[test]
@@ -7538,16 +7496,14 @@ fn start_devtools_get_layout_metrics_command(
command: crate::devtools_runtime::DevToolsGetLayoutMetricsCommand,
) -> PageCommandTaskStep {
let command_session_id = command.context.session_id.as_ref().map(|id| id.as_str());
- let fallback =
- layout_metrics_result_from_surface(current_viewport_surface(conn, command_session_id));
let owner_scope = CommandOwnerScope::capture(conn, command_session_id);
let Some(page) = conn
.runtime_session_owner_slot_mut(command_session_id)
.ok()
.and_then(|slot| slot.loaded_page_mut())
else {
- return PageCommandTaskStep::Complete(CommandOutputPlan::from_devtools_result(
- DevToolsCommandResult::LayoutMetrics(fallback),
+ return PageCommandTaskStep::Complete(CommandOutputPlan::from_devtools_error(
+ devtools_layout_metrics_error("NoDocumentLoaded"),
));
};
match page.start_layout_metrics() {
diff --git a/moli-protocol/src/domains/page/tests/capture.rs b/moli-protocol/src/domains/page/tests/capture.rs
index dbd272ccb..b91493412 100644
--- a/moli-protocol/src/domains/page/tests/capture.rs
+++ b/moli-protocol/src/domains/page/tests/capture.rs
@@ -1058,7 +1058,7 @@ fn screenshot_data_url(html: &str) -> String {
)
}
#[tokio::test(flavor = "multi_thread")]
-async fn get_layout_metrics_before_first_screenshot_does_not_publish_layout() {
+async fn get_layout_metrics_initializes_layout_and_reuses_content_until_capture() {
let mut ctx = TestContext::new();
let session = "SID-COLD-METRICS";
install_active_screenshot_page(
@@ -1081,7 +1081,7 @@ async fn get_layout_metrics_before_first_screenshot_does_not_publish_layout() {
assert_eq!(result["visualViewport"]["scale"], 1.0);
assert_eq!(
result["cssContentSize"],
- json!({"x":0,"y":0,"width":320.0,"height":240.0})
+ json!({"x":0,"y":0,"width":320.0,"height":900.0})
);
let geometry = json!({
@@ -1094,7 +1094,7 @@ async fn get_layout_metrics_before_first_screenshot_does_not_publish_layout() {
80
);
- // Playwright gets these metrics before issuing its first capture request.
+ // A viewport capture still uses the caller's explicit clip.
ctx.process_async(json!({
"id":123,"method":"Page.captureScreenshot","sessionId":session,
"params":{"format":"png","clip":{
@@ -1134,6 +1134,13 @@ async fn get_layout_metrics_before_first_screenshot_does_not_publish_layout() {
assert_eq!(live["result"]["visualViewport"]["pageY"], 100.0);
assert_eq!(live["result"]["visualViewport"]["scale"], 2.0);
assert_eq!(live["result"]["contentSize"]["height"], 900.0);
+ assert_eq!(live["result"]["contentSize"]["width"], 320.0);
+ ctx.capture_fixture_layout(Some(session)).await;
+ ctx.process_async(json!({"id":128,"method":"Page.getLayoutMetrics","sessionId":session}))
+ .await;
+ let refreshed = take_response_by_id(&mut ctx, 128);
+ assert_eq!(refreshed["result"]["cssContentSize"]["height"], 1600.0);
+ assert_eq!(refreshed["result"]["cssContentSize"]["width"], 400.0);
}
#[tokio::test(flavor = "multi_thread")]
@@ -1161,11 +1168,6 @@ async fn full_page_clip_from_dom_initialized_layout_preserves_capture_semantics(
"returnByValue":true
}
});
- ctx.process_async(geometry.clone()).await;
- assert_eq!(
- take_response_by_id(&mut ctx, 121)["result"]["result"]["value"],
- json!([305, 240, 80])
- );
// Empty clips are invalid both before and after layout publication.
let empty_capture = json!({
@@ -1177,12 +1179,18 @@ async fn full_page_clip_from_dom_initialized_layout_preserves_capture_semantics(
let cold_error = take_response_by_id(&mut ctx, 122);
assert_eq!(cold_error["error"]["code"], -32602, "{cold_error}");
+ ctx.process_async(geometry.clone()).await;
+ assert_eq!(
+ take_response_by_id(&mut ctx, 121)["result"]["result"]["value"],
+ json!([305, 240, 80])
+ );
+
ctx.process_async(json!({
"id":123,"method":"Page.getLayoutMetrics","sessionId":session
}))
.await;
- let unpublished = take_response_by_id(&mut ctx, 123);
- let mut clip = unpublished["result"]["cssContentSize"].clone();
+ let initial = take_response_by_id(&mut ctx, 123);
+ let mut clip = initial["result"]["cssContentSize"].clone();
assert_eq!(clip, json!({"x":0,"y":0,"width":320.0,"height":900.0}));
clip["scale"] = json!(scale);
@@ -1235,13 +1243,22 @@ async fn full_page_clip_from_dom_initialized_layout_preserves_capture_semantics(
}
}
-/// cdp.page: getLayoutMetrics – falls back to viewport metrics without a live page
+/// cdp.page: getLayoutMetrics – initializes an actual blank document
#[tokio::test(flavor = "multi_thread")]
async fn get_layout_metrics() {
let mut ctx = TestContext::new();
- load_bc_with_target(&mut ctx, "BID-9", "FID-000000000X", "about:blank");
- ctx.process_async(json!({"id": 12, "method": "Page.getLayoutMetrics"}))
- .await;
+ install_active_screenshot_page(
+ &mut ctx,
+ "BID-9",
+ "FID-000000000X",
+ "SID-BLANK-METRICS",
+ "about:blank",
+ )
+ .await;
+ ctx.process_async(
+ json!({"id": 12, "method": "Page.getLayoutMetrics", "sessionId": "SID-BLANK-METRICS"}),
+ )
+ .await;
let msg = ctx.take_one();
let r = &msg["result"];
assert_eq!(r["layoutViewport"]["clientWidth"], 1920);
@@ -1250,7 +1267,7 @@ async fn get_layout_metrics() {
assert_eq!(r["contentSize"]["height"], 1080.0);
}
#[tokio::test(flavor = "multi_thread")]
-async fn get_layout_metrics_uses_viewport_fallback_without_live_page() {
+async fn get_layout_metrics_without_live_page_does_not_fabricate_content_size() {
let mut ctx = TestContext::new();
load_bc_with_session(
&mut ctx,
@@ -1283,23 +1300,8 @@ async fn get_layout_metrics_uses_viewport_fallback_without_live_page() {
}))
.await;
let metrics = take_response_by_id(&mut ctx, 122);
- let result = &metrics["result"];
- assert_eq!(result["layoutViewport"]["clientWidth"], json!(800));
- assert_eq!(result["layoutViewport"]["clientHeight"], json!(600));
- assert_eq!(result["visualViewport"]["scale"], json!(1.0));
- assert_eq!(
- result["contentSize"],
- json!({ "x": 0, "y": 0, "width": 800.0, "height": 600.0 }),
- "without a live renderer page, content size should use the owner viewport"
- );
- assert_eq!(
- result["cssContentSize"]["width"],
- result["contentSize"]["width"]
- );
- assert_eq!(
- result["cssContentSize"]["height"],
- result["contentSize"]["height"]
- );
+ assert_eq!(metrics["error"]["code"], -32000, "{metrics}");
+ assert_eq!(metrics["error"]["message"], "NoDocumentLoaded");
}
#[tokio::test(flavor = "multi_thread")]
async fn get_layout_metrics_queries_live_renderer_for_loaded_pages() {
@@ -1325,8 +1327,6 @@ async fn get_layout_metrics_queries_live_renderer_for_loaded_pages() {
.runtime_slot
.replace_loaded_page(Some(page));
- ctx.capture_fixture_layout(Some("SID-PENDING-LAYOUT-METRICS"))
- .await;
ctx.process_async(json!({
"id": 125,
"method": "Page.getLayoutMetrics",
@@ -1381,7 +1381,6 @@ async fn get_layout_metrics_targets_loaded_background_owner_without_activation()
.await;
ctx.expect_result(121, json!({}), Some("SID-background"));
- ctx.capture_fixture_layout(Some("SID-background")).await;
ctx.process_async(json!({
"id": 123,
"method": "Page.getLayoutMetrics",
@@ -1435,7 +1434,6 @@ async fn get_layout_metrics_targets_inactive_loaded_owner_without_activation() {
.await;
ctx.expect_result(121, json!({}), Some("SID-inactive"));
- ctx.capture_fixture_layout(Some("SID-inactive")).await;
ctx.process_async(json!({
"id": 124,
"method": "Page.getLayoutMetrics",
diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs
index 752f67fd4..0cfd25b70 100644
--- a/moli-renderer-v8/src/native_bridge/element.rs
+++ b/moli-renderer-v8/src/native_bridge/element.rs
@@ -394,9 +394,9 @@ pub use geometry::ClientRect;
pub(crate) use geometry::observable_scrollbar_hit_test;
pub(crate) use geometry::{
InputSurfaceHit, apply_scroll_observable_effects, input_surface_hit_test,
- observable_caret_position, observable_deep_hit_test, observable_event_offset,
- observable_geometry_batch, observable_hit_test, observable_hit_test_all,
- observable_input_hit_test, observable_sources_with_fragments,
+ observable_caret_position, observable_deep_hit_test, observable_document_metrics,
+ observable_event_offset, observable_geometry_batch, observable_hit_test,
+ observable_hit_test_all, observable_input_hit_test, observable_sources_with_fragments,
perform_scrollbar_scroll_default_action, perform_wheel_scroll_default_action,
published_geometry_batch, queue_scroll_observable_effects, scroll_node_into_view_at_center,
scroll_node_into_view_at_start,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry.rs b/moli-renderer-v8/src/native_bridge/element/geometry.rs
index e12d73c68..c20776371 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry.rs
@@ -31,10 +31,10 @@ pub(crate) use mock::{
compute_mock_intersection_scrollport_client_rect,
};
pub(crate) use provider::{
- observable_bounding_client_rects, observable_caret_position, observable_event_offset,
- observable_geometry_batch, observable_hit_test_all, observable_sources_with_fragments,
- observable_used_grid_tracks, published_geometry_batch, read_bounding_client_rect,
- read_client_rects, read_element_metrics,
+ observable_bounding_client_rects, observable_caret_position, observable_document_metrics,
+ observable_event_offset, observable_geometry_batch, observable_hit_test_all,
+ observable_sources_with_fragments, observable_used_grid_tracks, published_geometry_batch,
+ read_bounding_client_rect, read_client_rects, read_element_metrics,
};
pub(in crate::native_bridge) use rects::{
node_get_bounding_client_rect_callback, node_get_client_rects_callback,
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs b/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
index 57486035a..d3ee1fd9a 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
@@ -62,6 +62,21 @@ pub(crate) fn published_geometry_batch(
}
}
+pub(crate) fn observable_document_metrics(
+ runtime: &JsContextHost,
+ document: DomHandle,
+) -> Result<LayoutDocumentMetrics, LayoutError> {
+ let answers = observable_geometry_batch(
+ runtime,
+ document,
+ &LayoutQueryBatch::new(vec![LayoutQuery::DocumentMetrics]),
+ )?;
+ match answers.answers.into_iter().next() {
+ Some(LayoutQueryAnswer::DocumentMetrics(metrics)) => Ok(metrics),
+ _ => Err(provider_contract_error("document metrics")),
+ }
+}
+
pub(crate) fn read_client_rects(
runtime: &JsContextHost,
source: DomHandle,
diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rs
index e7146037d..5dfe3a281 100644
--- a/moli-renderer-v8/src/runtime/page_commands.rs
+++ b/moli-renderer-v8/src/runtime/page_commands.rs
@@ -854,7 +854,7 @@ impl PageVm {
Ok(RendererPageReply::OptionalString(Some(self.serialize_html())))
}
RendererPageCommand::LayoutMetrics => {
- Ok(RendererPageReply::LayoutMetrics(self.layout_metrics()))
+ Ok(RendererPageReply::LayoutMetrics(self.layout_metrics()?))
}
RendererPageCommand::PublishLayout => {
self.vm_mut().publish_layout()?;
diff --git a/moli-renderer-v8/src/runtime/page_geometry.rs b/moli-renderer-v8/src/runtime/page_geometry.rs
index e2d1f5af2..847da643f 100644
--- a/moli-renderer-v8/src/runtime/page_geometry.rs
+++ b/moli-renderer-v8/src/runtime/page_geometry.rs
@@ -1,9 +1,9 @@
use super::{PageVm, RendererLayoutMetrics};
impl PageVm {
- pub(crate) fn layout_metrics(&self) -> RendererLayoutMetrics {
- let metrics = self.vm().document_metrics_for_current_document();
- RendererLayoutMetrics {
+ pub(crate) fn layout_metrics(&self) -> anyhow::Result<RendererLayoutMetrics> {
+ let metrics = self.vm().document_metrics_for_current_document()?;
+ Ok(RendererLayoutMetrics {
viewport_width: metrics.viewport.css_width,
viewport_height: metrics.viewport.css_height,
page_x: f64::from(metrics.viewport_scroll.x),
@@ -11,6 +11,6 @@ impl PageVm {
content_width: f64::from(metrics.content_size.width),
content_height: f64::from(metrics.content_size.height),
device_pixel_ratio: f64::from(metrics.viewport.device_pixel_ratio),
- }
+ })
}
}
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 4050591e4..54892d7c1 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -2764,14 +2764,14 @@ impl ScriptVm {
self.start_stylesheet_subresource_fetches(bound);
}
- /// Viewport and scroll state are live browser state, including before the
- /// first capture. Only the content extent comes from published layout;
- /// without a snapshot it falls back to the viewport, without running layout.
+ /// Initializes the first layout on demand, then keeps its content extent
+ /// until an explicit refresh. Viewport and scroll remain live browser state.
pub(crate) fn document_metrics_for_current_document(
&self,
- ) -> moli_layout::LayoutDocumentMetrics {
+ ) -> Result<moli_layout::LayoutDocumentMetrics, moli_layout::LayoutError> {
let host = self._context_host.borrow();
let document = host.document_handle();
+ let metrics = crate::native_bridge::element::observable_document_metrics(&host, document)?;
let viewport = host.layout_viewport_for_document(document);
let viewport_scroll = host
.dom_host()
@@ -2786,16 +2786,11 @@ impl ScriptVm {
)
})
.unwrap_or(moli_layout::LayoutPoint::ZERO);
- let content_size = host
- .with_latest_layout_tree_for_document(document, |tree| tree.content_size)
- .unwrap_or_else(|| {
- moli_layout::LayoutSize::new(viewport.css_width as f32, viewport.css_height as f32)
- });
- moli_layout::LayoutDocumentMetrics {
+ Ok(moli_layout::LayoutDocumentMetrics {
viewport,
viewport_scroll,
- content_size,
- }
+ content_size: metrics.content_size,
+ })
}
pub(crate) fn observable_geometry_batch_for_document(