Skip to content

armgit / moli

Public Imported from GitHub
0

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

Split geometry queries from hit testing and mock layout

ldm02e0140e53ad5
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry.rs b/moli-renderer-v8/src/native_bridge/element/geometry.rs
index 8c131b74e..f20637aed 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry.rs
@@ -1,12 +1,13 @@
-mod layout;
+mod client_rect;
+mod hit_test;
mod metrics;
+mod mock;
mod provider;
mod rects;
-pub use layout::ClientRect;
-pub(crate) use layout::{
- compute_mock_client_rect, compute_mock_intersection_client_rect,
- compute_mock_intersection_scrollport_client_rect,
+pub use client_rect::ClientRect;
+pub(crate) use hit_test::{
+ observable_deep_hit_test, observable_input_hit_test, observable_scrollbar_hit_test,
};
pub(crate) use metrics::{
apply_scroll_observable_effects, perform_scrollbar_scroll_default_action,
@@ -24,12 +25,15 @@ pub(in crate::native_bridge) use metrics::{
node_scroll_top_getter_function, node_scroll_top_setter_function,
node_scroll_width_getter_function,
};
+pub(crate) use mock::{
+ compute_mock_client_rect, compute_mock_intersection_client_rect,
+ compute_mock_intersection_scrollport_client_rect,
+};
pub(crate) use provider::{
observable_bounding_client_rect, observable_bounding_client_rects, observable_box_model,
- observable_caret_position, observable_client_rects, observable_deep_hit_test,
- observable_element_metrics, observable_event_offset, observable_geometry_batch,
- observable_hit_test_all, observable_input_hit_test, observable_scroll_adjusted_client_rect,
- observable_scroll_into_view_geometry, observable_scrollbar_hit_test,
+ observable_caret_position, observable_client_rects, observable_element_metrics,
+ observable_event_offset, observable_geometry_batch, observable_hit_test_all,
+ observable_scroll_adjusted_client_rect, observable_scroll_into_view_geometry,
observable_sources_with_fragments,
};
pub(in crate::native_bridge) use rects::{
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/client_rect.rs b/moli-renderer-v8/src/native_bridge/element/geometry/client_rect.rs
new file mode 100644
index 000000000..70e02c7f6
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/client_rect.rs
@@ -0,0 +1,64 @@
+use moli_layout::{LayoutPoint, LayoutQuad};
+
+#[derive(Clone, Copy, Debug)]
+pub struct ClientRect {
+ pub left: f64,
+ pub top: f64,
+ pub right: f64,
+ pub bottom: f64,
+ pub width: f64,
+ pub height: f64,
+}
+
+pub(super) fn zero_client_rect() -> ClientRect {
+ ClientRect {
+ left: 0.0,
+ top: 0.0,
+ right: 0.0,
+ bottom: 0.0,
+ width: 0.0,
+ height: 0.0,
+ }
+}
+
+pub(super) fn quad_from_client_rect(rect: ClientRect) -> LayoutQuad {
+ let left = rect.left as f32;
+ let top = rect.top as f32;
+ let right = rect.right as f32;
+ let bottom = rect.bottom as f32;
+ LayoutQuad {
+ points: [
+ LayoutPoint::new(left, top),
+ LayoutPoint::new(right, top),
+ LayoutPoint::new(right, bottom),
+ LayoutPoint::new(left, bottom),
+ ],
+ }
+}
+
+pub(super) fn client_rect_from_quad(quad: LayoutQuad) -> ClientRect {
+ let rect = quad.bounding_rect();
+ ClientRect {
+ left: f64::from(rect.x),
+ top: f64::from(rect.y),
+ right: f64::from(rect.right()),
+ bottom: f64::from(rect.bottom()),
+ width: f64::from(rect.width),
+ height: f64::from(rect.height),
+ }
+}
+
+pub(super) fn union_client_rect(left: ClientRect, right: ClientRect) -> ClientRect {
+ let min_x = left.left.min(right.left);
+ let min_y = left.top.min(right.top);
+ let max_x = left.right.max(right.right);
+ let max_y = left.bottom.max(right.bottom);
+ ClientRect {
+ left: min_x,
+ top: min_y,
+ right: max_x,
+ bottom: max_y,
+ width: (max_x - min_x).max(0.0),
+ height: (max_y - min_y).max(0.0),
+ }
+}
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/hit_test.rs b/moli-renderer-v8/src/native_bridge/element/geometry/hit_test.rs
new file mode 100644
index 000000000..6ed5d30d7
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/hit_test.rs
@@ -0,0 +1,307 @@
+use moli_layout::{
+ LayoutError, LayoutFlushReason, LayoutHit, LayoutPoint, LayoutQuery, LayoutQueryAnswer,
+ LayoutQueryBatch, LayoutScrollbarHit, LayoutTransform2D, LayoutViewport,
+};
+
+use super::provider::{
+ observable_geometry_batch, observable_hit_test_all, provider_contract_error,
+};
+use crate::{document_runtime::DomHandle, native_bridge::JsContextHost};
+
+const CHILD_FRAME_DEPTH_LIMIT: usize = 16;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct InputHit {
+ pub(crate) handle: DomHandle,
+ /// Converts a root-frame input position into the viewport of `handle`'s
+ /// owner frame. Keeping the affine map lets boundary and capture events
+ /// convert a new root position into a previously targeted child frame.
+ pub(crate) root_to_frame: LayoutTransform2D,
+}
+
+#[derive(Clone, Copy)]
+struct FrameHitTest {
+ document: DomHandle,
+ viewport: LayoutViewport,
+ point: LayoutPoint,
+ root_to_frame: LayoutTransform2D,
+}
+
+impl FrameHitTest {
+ fn root(runtime: &JsContextHost, document: DomHandle, point: LayoutPoint) -> Self {
+ Self {
+ document,
+ viewport: runtime.layout_viewport_for_document(document),
+ point,
+ root_to_frame: LayoutTransform2D::IDENTITY,
+ }
+ }
+
+ /// Blink performs the equivalent conversion through LocalFrameView when
+ /// an input hit crosses an embedded-content boundary.
+ fn child(
+ self,
+ runtime: &JsContextHost,
+ frame: DomHandle,
+ hit: LayoutHit<DomHandle>,
+ ) -> Option<Self> {
+ let document = runtime.child_browsing_context_document_handle(frame)?;
+ let content_box = hit.local_content_box?;
+ if !content_box.contains(hit.local_point) {
+ return None;
+ }
+ let frame_to_child = LayoutTransform2D::translation(-content_box.x, -content_box.y)
+ .concatenate(hit.viewport_to_local);
+ Some(Self {
+ document,
+ viewport: LayoutViewport::new(
+ css_viewport_dimension(content_box.width),
+ css_viewport_dimension(content_box.height),
+ self.viewport.device_pixel_ratio,
+ ),
+ point: frame_to_child.map_point(self.point),
+ root_to_frame: frame_to_child.concatenate(self.root_to_frame),
+ })
+ }
+}
+
+pub(crate) fn observable_input_hit_test(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ point: LayoutPoint,
+) -> Result<Option<InputHit>, LayoutError> {
+ input_hit_test(runtime, document, point, false)
+}
+
+pub(crate) fn observable_scrollbar_hit_test(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ point: LayoutPoint,
+) -> Result<Option<LayoutScrollbarHit<DomHandle>>, LayoutError> {
+ if !runtime.layout_policy().uses_real_layout() {
+ return Ok(None);
+ }
+ scrollbar_hit_test_in_frame(runtime, FrameHitTest::root(runtime, document, point), 0)
+}
+
+pub(crate) fn observable_deep_hit_test(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ point: LayoutPoint,
+ ignore_pointer_events_none: bool,
+) -> Result<Option<DomHandle>, LayoutError> {
+ Ok(input_hit_test(runtime, document, point, ignore_pointer_events_none)?.map(|hit| hit.handle))
+}
+
+fn input_hit_test(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ point: LayoutPoint,
+ ignore_pointer_events_none: bool,
+) -> Result<Option<InputHit>, LayoutError> {
+ input_hit_test_in_frame(
+ runtime,
+ FrameHitTest::root(runtime, document, point),
+ ignore_pointer_events_none,
+ 0,
+ )
+}
+
+fn input_hit_test_in_frame(
+ runtime: &JsContextHost,
+ frame: FrameHitTest,
+ ignore_pointer_events_none: bool,
+ depth: usize,
+) -> Result<Option<InputHit>, LayoutError> {
+ let Some((layout_hit, target)) = live_hit_in_frame(runtime, frame, ignore_pointer_events_none)?
+ else {
+ return Ok(None);
+ };
+ let target_hit = InputHit {
+ handle: target,
+ root_to_frame: frame.root_to_frame,
+ };
+ if depth >= CHILD_FRAME_DEPTH_LIMIT {
+ return Ok(Some(target_hit));
+ }
+ let Some(child) = frame.child(runtime, target, layout_hit) else {
+ return Ok(Some(target_hit));
+ };
+ Ok(
+ input_hit_test_in_frame(runtime, child, ignore_pointer_events_none, depth + 1)?
+ .or(Some(target_hit)),
+ )
+}
+
+fn scrollbar_hit_test_in_frame(
+ runtime: &JsContextHost,
+ frame: FrameHitTest,
+ depth: usize,
+) -> Result<Option<LayoutScrollbarHit<DomHandle>>, LayoutError> {
+ // Publish a current tree through the same exact-viewport hit-test
+ // boundary used for DOM input. Scrollbar geometry intentionally remains a
+ // frozen-tree control query because it is user-agent chrome, not a DOM
+ // target.
+ let live_hit = live_hit_in_frame(runtime, frame, false)?;
+ if let Some(mut hit) = runtime
+ .with_latest_layout_tree_for_document(frame.document, |tree| {
+ tree.scrollbar_hit_test(frame.point)
+ })
+ .flatten()
+ {
+ hit.viewport_to_local = hit.viewport_to_local.concatenate(frame.root_to_frame);
+ return Ok(Some(hit));
+ }
+ if depth >= CHILD_FRAME_DEPTH_LIMIT {
+ return Ok(None);
+ }
+ let Some((layout_hit, target)) = live_hit else {
+ return Ok(None);
+ };
+ let Some(child) = frame.child(runtime, target, layout_hit) else {
+ return Ok(None);
+ };
+ scrollbar_hit_test_in_frame(runtime, child, depth + 1)
+}
+
+fn live_hit_in_frame(
+ runtime: &JsContextHost,
+ frame: FrameHitTest,
+ ignore_pointer_events_none: bool,
+) -> Result<Option<(LayoutHit<DomHandle>, DomHandle)>, LayoutError> {
+ let first_hit = observable_hit_test_in_viewport(
+ runtime,
+ frame.document,
+ frame.viewport,
+ frame.point,
+ ignore_pointer_events_none,
+ )?;
+ let live_first_hit = first_hit.and_then(|hit| {
+ let target = element_for_hit_source(runtime, hit.source)?;
+ runtime
+ .dom_host()
+ .is_connected(target)
+ .then_some((hit, target))
+ });
+ // A latest-layout snapshot may still contain a text fragment whose DOM
+ // node was replaced after the snapshot was published. Walk the sampled
+ // paint stack only on that stale-source path until it identifies a
+ // currently connected element. This live DOM check neither refreshes nor
+ // invalidates layout; the common case retains the single-hit fast path.
+ if live_first_hit.is_some() || first_hit.is_none() {
+ return Ok(live_first_hit);
+ }
+ let hits = observable_hit_test_all_in_viewport(
+ runtime,
+ frame.document,
+ frame.viewport,
+ frame.point,
+ ignore_pointer_events_none,
+ )?;
+ Ok(hits.into_iter().find_map(|hit| {
+ let target = element_for_hit_source(runtime, hit.source)?;
+ runtime
+ .dom_host()
+ .is_connected(target)
+ .then_some((hit, target))
+ }))
+}
+
+fn observable_hit_test_in_viewport(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ viewport: LayoutViewport,
+ point: LayoutPoint,
+ ignore_pointer_events_none: bool,
+) -> Result<Option<LayoutHit<DomHandle>>, LayoutError> {
+ if !runtime.layout_policy().uses_real_layout() {
+ return observable_hit_test(runtime, document, point, ignore_pointer_events_none);
+ }
+ let answers = runtime.answer_layout_at_viewport(
+ document,
+ LayoutFlushReason::HitTest,
+ viewport,
+ &LayoutQueryBatch::new(vec![LayoutQuery::HitTest {
+ point,
+ ignore_pointer_events_none,
+ }]),
+ )?;
+ match answers.answers.into_iter().next() {
+ Some(LayoutQueryAnswer::HitTest(hit)) => Ok(hit),
+ _ => Err(provider_contract_error("viewport-scoped hit test")),
+ }
+}
+
+fn observable_hit_test(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ point: LayoutPoint,
+ ignore_pointer_events_none: bool,
+) -> Result<Option<LayoutHit<DomHandle>>, LayoutError> {
+ let answers = observable_geometry_batch(
+ runtime,
+ document,
+ LayoutFlushReason::HitTest,
+ &LayoutQueryBatch::new(vec![LayoutQuery::HitTest {
+ point,
+ ignore_pointer_events_none,
+ }]),
+ )?;
+ match answers.answers.into_iter().next() {
+ Some(LayoutQueryAnswer::HitTest(hit)) => Ok(hit),
+ _ => Err(provider_contract_error("hit test")),
+ }
+}
+
+fn observable_hit_test_all_in_viewport(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ viewport: LayoutViewport,
+ point: LayoutPoint,
+ ignore_pointer_events_none: bool,
+) -> Result<Vec<LayoutHit<DomHandle>>, LayoutError> {
+ if !runtime.layout_policy().uses_real_layout() {
+ return observable_hit_test_all(
+ runtime,
+ document,
+ point,
+ ignore_pointer_events_none,
+ LayoutFlushReason::HitTest,
+ )
+ .map(|(_, hits)| hits);
+ }
+ let answers = runtime.answer_layout_at_viewport(
+ document,
+ LayoutFlushReason::HitTest,
+ viewport,
+ &LayoutQueryBatch::new(vec![LayoutQuery::HitTestAll {
+ point,
+ ignore_pointer_events_none,
+ }]),
+ )?;
+ match answers.answers.into_iter().next() {
+ Some(LayoutQueryAnswer::HitTestAll(hits)) => Ok(hits),
+ _ => Err(provider_contract_error("viewport-scoped complete hit test")),
+ }
+}
+
+fn element_for_hit_source(runtime: &JsContextHost, mut source: DomHandle) -> Option<DomHandle> {
+ loop {
+ let node = runtime.dom_host().node(source)?;
+ if node.is_element() {
+ return Some(source);
+ }
+ let parent = node.parent_node()?;
+ if runtime.dom_host().is_shadow_root(parent) {
+ return runtime.dom_host().shadow_root_host(parent);
+ }
+ source = parent;
+ }
+}
+
+fn css_viewport_dimension(value: f32) -> u32 {
+ if !value.is_finite() {
+ return 0;
+ }
+ value.round().clamp(0.0, u32::MAX as f32) as u32
+}
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/layout.rs b/moli-renderer-v8/src/native_bridge/element/geometry/mock/layout.rs
similarity index 97%
rename from moli-renderer-v8/src/native_bridge/element/geometry/layout.rs
rename to moli-renderer-v8/src/native_bridge/element/geometry/mock/layout.rs
index 86f21e4ab..bf2f97673 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/layout.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/mock/layout.rs
@@ -2,8 +2,9 @@ use crate::document_runtime::DomHandle;
use moli_browser_profile::DEFAULT_WINDOW_SURFACE_PROFILE;
use std::time::Instant;
-use super::super::super::JsContextHost;
-use super::super::styles::{ComputedStyleRead, iframe_handle_viewport};
+use super::super::super::super::JsContextHost;
+use super::super::super::styles::{ComputedStyleRead, iframe_handle_viewport};
+use super::super::client_rect::{ClientRect, zero_client_rect};
use crate::native_bridge::element::raw_inline_style_property_value;
const MOCK_FLOW_STEP_PX: f64 = 24.0;
@@ -11,27 +12,6 @@ const CHILD_DOCUMENT_VISIBLE_FLOW_ORIGIN_PX: f64 = 1.0;
const MOCK_FLOW_COUNT_LIMIT: usize = 4096;
const HIT_TEST_CHILD_FRAME_DEPTH_LIMIT: usize = 16;
-#[derive(Clone, Copy, Debug)]
-pub struct ClientRect {
- pub left: f64,
- pub top: f64,
- pub right: f64,
- pub bottom: f64,
- pub width: f64,
- pub height: f64,
-}
-
-pub(super) fn zero_client_rect() -> ClientRect {
- ClientRect {
- left: 0.0,
- top: 0.0,
- right: 0.0,
- bottom: 0.0,
- width: 0.0,
- height: 0.0,
- }
-}
-
fn viewport_client_rect(runtime: &JsContextHost, handle: DomHandle) -> ClientRect {
let child_viewport = runtime
.dom_host()
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/mock/mod.rs b/moli-renderer-v8/src/native_bridge/element/geometry/mock/mod.rs
new file mode 100644
index 000000000..7cd054d00
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/mock/mod.rs
@@ -0,0 +1,8 @@
+mod layout;
+mod queries;
+
+pub(crate) use layout::{
+ compute_mock_client_rect, compute_mock_intersection_client_rect,
+ compute_mock_intersection_scrollport_client_rect, compute_mock_scroll_adjusted_client_rect,
+};
+pub(super) use queries::answer_queries;
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs b/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs
new file mode 100644
index 000000000..5586ef031
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/mock/queries.rs
@@ -0,0 +1,263 @@
+use std::time::Duration;
+
+use moli_layout::{
+ LayoutAnswers, LayoutBoxModel, LayoutCaretPosition, LayoutDocumentMetrics,
+ LayoutElementMetrics, LayoutFlushReason, LayoutHit, LayoutIntersectionGeometry,
+ LayoutPassMetrics, LayoutPoint, LayoutQuery, LayoutQueryAnswer, LayoutQueryBatch,
+ LayoutScrollContainerMetrics, LayoutScrollIntoViewGeometry, LayoutSize,
+};
+
+use super::super::client_rect::{quad_from_client_rect, zero_client_rect};
+use super::layout::{
+ compute_mock_client_rect, compute_mock_offset_parent, mock_hit_test_handle,
+ mock_layout_client_rect_for_node,
+};
+use crate::{document_runtime::DomHandle, dom::native::Node, native_bridge::JsContextHost};
+
+pub(crate) fn answer_queries(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ reason: LayoutFlushReason,
+ batch: &LayoutQueryBatch<DomHandle>,
+) -> LayoutAnswers<DomHandle> {
+ let viewport = runtime.layout_viewport_for_document(document);
+ let answers = batch
+ .queries
+ .iter()
+ .map(|query| match query {
+ LayoutQuery::DocumentMetrics => {
+ let viewport_scroll = runtime
+ .dom_host()
+ .dom()
+ .document_element_handle_for_document(document)
+ .and_then(|root| runtime.dom_host().node(root))
+ .and_then(Node::as_element)
+ .map(|element| {
+ LayoutPoint::new(element.scroll_left() as f32, element.scroll_top() as f32)
+ })
+ .unwrap_or(LayoutPoint::ZERO);
+ LayoutQueryAnswer::DocumentMetrics(LayoutDocumentMetrics {
+ viewport,
+ viewport_scroll,
+ content_size: LayoutSize::new(
+ viewport.css_width as f32,
+ viewport.css_height as f32,
+ ),
+ })
+ }
+ LayoutQuery::BoxModel { source } => {
+ LayoutQueryAnswer::BoxModel(mock_box_model(runtime, *source))
+ }
+ LayoutQuery::ClientRects { source } => LayoutQueryAnswer::ClientRects(
+ mock_layout_client_rect_for_node(runtime, *source)
+ .map(quad_from_client_rect)
+ .into_iter()
+ .collect(),
+ ),
+ LayoutQuery::ContentQuads { source } => LayoutQueryAnswer::ContentQuads(
+ mock_layout_client_rect_for_node(runtime, *source)
+ .map(quad_from_client_rect)
+ .into_iter()
+ .collect(),
+ ),
+ LayoutQuery::TextRangeRects { source, .. } => LayoutQueryAnswer::TextRangeRects(
+ mock_layout_client_rect_for_node(runtime, *source)
+ .map(quad_from_client_rect)
+ .into_iter()
+ .collect(),
+ ),
+ LayoutQuery::ElementMetrics { source } => {
+ LayoutQueryAnswer::ElementMetrics(mock_element_metrics(runtime, *source))
+ }
+ LayoutQuery::ScrollIntoViewGeometry { source } => {
+ LayoutQueryAnswer::ScrollIntoViewGeometry(mock_scroll_into_view_geometry(
+ runtime, document, *source,
+ ))
+ }
+ LayoutQuery::IntersectionGeometry { target, root } => {
+ LayoutQueryAnswer::IntersectionGeometry(mock_intersection_geometry(
+ runtime, document, *target, *root,
+ ))
+ }
+ LayoutQuery::HitTest {
+ point,
+ ignore_pointer_events_none: _,
+ } => LayoutQueryAnswer::HitTest(
+ mock_hit_test_handle(runtime, document, f64::from(point.x), f64::from(point.y))
+ .map(|source| LayoutHit {
+ source,
+ fragment: None,
+ local_point: *point,
+ is_text: false,
+ local_content_box: None,
+ viewport_to_local: moli_layout::LayoutTransform2D::IDENTITY,
+ box_model: mock_box_model(runtime, source),
+ }),
+ ),
+ LayoutQuery::HitTestAll {
+ point,
+ ignore_pointer_events_none: _,
+ } => LayoutQueryAnswer::HitTestAll(
+ mock_hit_test_handle(runtime, document, f64::from(point.x), f64::from(point.y))
+ .map(|source| {
+ vec![LayoutHit {
+ source,
+ fragment: None,
+ local_point: *point,
+ is_text: false,
+ local_content_box: None,
+ viewport_to_local: moli_layout::LayoutTransform2D::IDENTITY,
+ box_model: mock_box_model(runtime, source),
+ }]
+ })
+ .unwrap_or_default(),
+ ),
+ LayoutQuery::CaretPosition { point } => LayoutQueryAnswer::CaretPosition(
+ mock_hit_test_handle(runtime, document, f64::from(point.x), f64::from(point.y))
+ .map(|source| {
+ let model = mock_box_model(runtime, source);
+ LayoutCaretPosition {
+ source,
+ utf16_offset: None,
+ rect: model
+ .map(|model| model.border)
+ .unwrap_or_else(|| quad_from_client_rect(zero_client_rect())),
+ ancestor_boxes: model
+ .map(|model| vec![(source, model)])
+ .unwrap_or_default(),
+ }
+ }),
+ ),
+ LayoutQuery::EventOffset { source, point } => {
+ let rect = compute_mock_client_rect(runtime, *source);
+ LayoutQueryAnswer::EventOffset(Some(LayoutPoint::new(
+ point.x - rect.left as f32,
+ point.y - rect.top as f32,
+ )))
+ }
+ })
+ .collect();
+ LayoutAnswers {
+ answers,
+ metrics: LayoutPassMetrics {
+ reason,
+ elapsed: Duration::ZERO,
+ box_count: 0,
+ fragment_count: 0,
+ paint_operation_count: 0,
+ fallback_count: 1,
+ },
+ }
+}
+
+fn mock_box_model(runtime: &JsContextHost, source: DomHandle) -> Option<LayoutBoxModel> {
+ let rect = mock_layout_client_rect_for_node(runtime, source)?;
+ let quad = quad_from_client_rect(rect);
+ Some(LayoutBoxModel {
+ content: quad,
+ padding: quad,
+ border: quad,
+ margin: quad,
+ })
+}
+
+fn mock_element_metrics(
+ runtime: &JsContextHost,
+ source: DomHandle,
+) -> Option<LayoutElementMetrics<DomHandle>> {
+ let rect = mock_layout_client_rect_for_node(runtime, source)?;
+ let size = LayoutSize::new(rect.width as f32, rect.height as f32);
+ let offset = runtime
+ .dom_host()
+ .node(source)
+ .and_then(Node::as_element)
+ .map(|element| LayoutPoint::new(element.scroll_left() as f32, element.scroll_top() as f32))
+ .unwrap_or(LayoutPoint::ZERO);
+ let quad = quad_from_client_rect(rect);
+ Some(LayoutElementMetrics {
+ offset_parent: compute_mock_offset_parent(runtime, source),
+ offset_position: LayoutPoint::new(rect.left as f32, rect.top as f32),
+ offset_size: size,
+ content_size: size,
+ client_size: size,
+ client_border: LayoutPoint::ZERO,
+ scroll_size: size,
+ scroll_offset: offset,
+ minimum_scroll_offset: LayoutPoint::ZERO,
+ maximum_scroll_offset: LayoutPoint::ZERO,
+ scrollport: quad,
+ scrollable_overflow: quad,
+ is_scroll_container: false,
+ allows_user_scroll_x: false,
+ allows_user_scroll_y: false,
+ clips_overflow: false,
+ visible: rect.width > 0.0 && rect.height > 0.0,
+ pointer_events: true,
+ })
+}
+
+fn mock_scroll_into_view_geometry(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ source: DomHandle,
+) -> Option<LayoutScrollIntoViewGeometry<DomHandle>> {
+ let target_rect = mock_layout_client_rect_for_node(runtime, source)?;
+ let root = runtime
+ .dom_host()
+ .dom()
+ .document_element_handle_for_document(document);
+ let scroll_containers = root
+ .filter(|root| *root != source)
+ .and_then(|root| {
+ mock_element_metrics(runtime, root).map(|metrics| LayoutScrollContainerMetrics {
+ source: root,
+ metrics,
+ })
+ })
+ .into_iter()
+ .collect();
+ Some(LayoutScrollIntoViewGeometry {
+ target_rects: vec![quad_from_client_rect(target_rect)],
+ scroll_containers,
+ })
+}
+
+fn mock_intersection_geometry(
+ runtime: &JsContextHost,
+ document: DomHandle,
+ target: DomHandle,
+ root: Option<DomHandle>,
+) -> Option<LayoutIntersectionGeometry> {
+ let target_rect = mock_layout_client_rect_for_node(runtime, target)?;
+ let viewport = runtime.layout_viewport_for_document(document);
+ let root_rect = root
+ .and_then(|root| mock_layout_client_rect_for_node(runtime, root))
+ .map(quad_from_client_rect)
+ .unwrap_or_else(|| {
+ moli_layout::LayoutTransform2D::IDENTITY.map_rect(moli_layout::LayoutRect::new(
+ 0.0,
+ 0.0,
+ viewport.css_width as f32,
+ viewport.css_height as f32,
+ ))
+ });
+ let root_is_layout_ancestor = root.is_none_or(|root| {
+ let mut current = Some(target);
+ while let Some(candidate) = current {
+ if candidate == root {
+ return true;
+ }
+ current = runtime.dom_host().parent_node(candidate);
+ }
+ false
+ });
+ Some(LayoutIntersectionGeometry {
+ target_rects: vec![quad_from_client_rect(target_rect)],
+ root_rect,
+ ancestor_clips: Vec::new(),
+ target_has_layout: true,
+ target_visible: target_rect.width > 0.0 && target_rect.height > 0.0,
+ root_clips_overflow: false,
+ root_is_layout_ancestor,
+ })
+}
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 7441ca7f7..4041e04ae 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/provider.rs
@@ -1,76 +1,16 @@
-use std::{collections::HashSet, time::Duration};
+use std::collections::HashSet;
use moli_layout::{
LayoutAnswers, LayoutBoxModel, LayoutCaretPosition, LayoutDocumentMetrics,
- LayoutElementMetrics, LayoutError, LayoutFlushReason, LayoutHit, LayoutIntersectionGeometry,
- LayoutPassMetrics, LayoutPoint, LayoutQuad, LayoutQuery, LayoutQueryAnswer, LayoutQueryBatch,
- LayoutScrollContainerMetrics, LayoutScrollIntoViewGeometry, LayoutScrollbarHit, LayoutSize,
- LayoutTransform2D, LayoutViewport,
+ LayoutElementMetrics, LayoutError, LayoutFlushReason, LayoutHit, LayoutPoint, LayoutQuery,
+ LayoutQueryAnswer, LayoutQueryBatch, LayoutScrollIntoViewGeometry,
};
-use super::layout::{
- ClientRect, compute_mock_client_rect, compute_mock_offset_parent,
- compute_mock_scroll_adjusted_client_rect, mock_hit_test_handle,
- mock_layout_client_rect_for_node, zero_client_rect,
+use super::client_rect::{ClientRect, client_rect_from_quad, union_client_rect, zero_client_rect};
+use super::mock::{
+ answer_queries as answer_mock_queries, compute_mock_scroll_adjusted_client_rect,
};
-use crate::{document_runtime::DomHandle, dom::native::Node, native_bridge::JsContextHost};
-
-const HIT_TEST_CHILD_FRAME_DEPTH_LIMIT: usize = 16;
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub(crate) struct InputHit {
- pub(crate) handle: DomHandle,
- /// Converts a root-frame input position into the viewport of `handle`'s
- /// owner frame. Keeping the affine map lets boundary and capture events
- /// convert a new root position into a previously targeted child frame.
- pub(crate) root_to_frame: LayoutTransform2D,
-}
-
-#[derive(Clone, Copy)]
-struct FrameHitTest {
- document: DomHandle,
- viewport: LayoutViewport,
- point: LayoutPoint,
- root_to_frame: LayoutTransform2D,
-}
-
-impl FrameHitTest {
- fn root(runtime: &JsContextHost, document: DomHandle, point: LayoutPoint) -> Self {
- Self {
- document,
- viewport: runtime.layout_viewport_for_document(document),
- point,
- root_to_frame: LayoutTransform2D::IDENTITY,
- }
- }
-
- /// Blink performs the equivalent conversion through LocalFrameView when
- /// an input hit crosses an embedded-content boundary.
- fn child(
- self,
- runtime: &JsContextHost,
- frame: DomHandle,
- hit: LayoutHit<DomHandle>,
- ) -> Option<Self> {
- let document = runtime.child_browsing_context_document_handle(frame)?;
- let content_box = hit.local_content_box?;
- if !content_box.contains(hit.local_point) {
- return None;
- }
- let frame_to_child = LayoutTransform2D::translation(-content_box.x, -content_box.y)
- .concatenate(hit.viewport_to_local);
- Some(Self {
- document,
- viewport: LayoutViewport::new(
- css_viewport_dimension(content_box.width),
- css_viewport_dimension(content_box.height),
- self.viewport.device_pixel_ratio,
- ),
- point: frame_to_child.map_point(self.point),
- root_to_frame: frame_to_child.concatenate(self.root_to_frame),
- })
- }
-}
+use crate::{document_runtime::DomHandle, native_bridge::JsContextHost};
pub(crate) fn observable_geometry_batch(
runtime: &JsContextHost,
@@ -317,59 +257,6 @@ pub(crate) fn observable_scroll_into_view_geometry(
}
}
-fn observable_hit_test(
- runtime: &JsContextHost,
- document: DomHandle,
- point: LayoutPoint,
- ignore_pointer_events_none: bool,
- reason: LayoutFlushReason,
-) -> Result<Option<LayoutHit<DomHandle>>, LayoutError> {
- let answers = observable_geometry_batch(
- runtime,
- document,
- reason,
- &LayoutQueryBatch::new(vec![LayoutQuery::HitTest {
- point,
- ignore_pointer_events_none,
- }]),
- )?;
- match answers.answers.into_iter().next() {
- Some(LayoutQueryAnswer::HitTest(hit)) => Ok(hit),
- _ => Err(provider_contract_error("hit test")),
- }
-}
-
-fn observable_hit_test_in_viewport(
- runtime: &JsContextHost,
- document: DomHandle,
- viewport: LayoutViewport,
- point: LayoutPoint,
- ignore_pointer_events_none: bool,
-) -> Result<Option<LayoutHit<DomHandle>>, LayoutError> {
- if !runtime.layout_policy().uses_real_layout() {
- return observable_hit_test(
- runtime,
- document,
- point,
- ignore_pointer_events_none,
- LayoutFlushReason::HitTest,
- );
- }
- let answers = runtime.answer_layout_at_viewport(
- document,
- LayoutFlushReason::HitTest,
- viewport,
- &LayoutQueryBatch::new(vec![LayoutQuery::HitTest {
- point,
- ignore_pointer_events_none,
- }]),
- )?;
- match answers.answers.into_iter().next() {
- Some(LayoutQueryAnswer::HitTest(hit)) => Ok(hit),
- _ => Err(provider_contract_error("viewport-scoped hit test")),
- }
-}
-
pub(crate) fn observable_caret_position(
runtime: &JsContextHost,
document: DomHandle,
@@ -401,162 +288,6 @@ pub(crate) fn observable_caret_position(
}
}
-pub(crate) fn observable_input_hit_test(
- runtime: &JsContextHost,
- document: DomHandle,
- point: LayoutPoint,
-) -> Result<Option<InputHit>, LayoutError> {
- input_hit_test(runtime, document, point, false)
-}
-
-pub(crate) fn observable_scrollbar_hit_test(
- runtime: &JsContextHost,
- document: DomHandle,
- point: LayoutPoint,
-) -> Result<Option<LayoutScrollbarHit<DomHandle>>, LayoutError> {
- if !runtime.layout_policy().uses_real_layout() {
- return Ok(None);
- }
- scrollbar_hit_test_in_frame(runtime, FrameHitTest::root(runtime, document, point), 0)
-}
-
-pub(crate) fn observable_deep_hit_test(
- runtime: &JsContextHost,
- document: DomHandle,
- point: LayoutPoint,
- ignore_pointer_events_none: bool,
-) -> Result<Option<DomHandle>, LayoutError> {
- Ok(input_hit_test(runtime, document, point, ignore_pointer_events_none)?.map(|hit| hit.handle))
-}
-
-fn input_hit_test(
- runtime: &JsContextHost,
- document: DomHandle,
- point: LayoutPoint,
- ignore_pointer_events_none: bool,
-) -> Result<Option<InputHit>, LayoutError> {
- input_hit_test_in_frame(
- runtime,
- FrameHitTest::root(runtime, document, point),
- ignore_pointer_events_none,
- 0,
- )
-}
-
-fn input_hit_test_in_frame(
- runtime: &JsContextHost,
- frame: FrameHitTest,
- ignore_pointer_events_none: bool,
- depth: usize,
-) -> Result<Option<InputHit>, LayoutError> {
- let Some((layout_hit, target)) = live_hit_in_frame(runtime, frame, ignore_pointer_events_none)?
- else {
- return Ok(None);
- };
- let target_hit = InputHit {
- handle: target,
- root_to_frame: frame.root_to_frame,
- };
- if depth >= HIT_TEST_CHILD_FRAME_DEPTH_LIMIT {
- return Ok(Some(target_hit));
- }
- let Some(child) = frame.child(runtime, target, layout_hit) else {
- return Ok(Some(target_hit));
- };
- Ok(
- input_hit_test_in_frame(runtime, child, ignore_pointer_events_none, depth + 1)?
- .or(Some(target_hit)),
- )
-}
-
-fn scrollbar_hit_test_in_frame(
- runtime: &JsContextHost,
- frame: FrameHitTest,
- depth: usize,
-) -> Result<Option<LayoutScrollbarHit<DomHandle>>, LayoutError> {
- // Publish a current tree through the same exact-viewport hit-test
- // boundary used for DOM input. Scrollbar geometry intentionally remains a
- // frozen-tree control query because it is user-agent chrome, not a DOM
- // target.
- let live_hit = live_hit_in_frame(runtime, frame, false)?;
- if let Some(mut hit) = runtime
- .with_latest_layout_tree_for_document(frame.document, |tree| {
- tree.scrollbar_hit_test(frame.point)
- })
- .flatten()
- {
- hit.viewport_to_local = hit.viewport_to_local.concatenate(frame.root_to_frame);
- return Ok(Some(hit));
- }
- if depth >= HIT_TEST_CHILD_FRAME_DEPTH_LIMIT {
- return Ok(None);
- }
- let Some((layout_hit, target)) = live_hit else {
- return Ok(None);
- };
- let Some(child) = frame.child(runtime, target, layout_hit) else {
- return Ok(None);
- };
- scrollbar_hit_test_in_frame(runtime, child, depth + 1)
-}
-
-fn live_hit_in_frame(
- runtime: &JsContextHost,
- frame: FrameHitTest,
- ignore_pointer_events_none: bool,
-) -> Result<Option<(LayoutHit<DomHandle>, DomHandle)>, LayoutError> {
- let first_hit = observable_hit_test_in_viewport(
- runtime,
- frame.document,
- frame.viewport,
- frame.point,
- ignore_pointer_events_none,
- )?;
- let live_first_hit = first_hit.and_then(|hit| {
- let target = element_for_hit_source(runtime, hit.source)?;
- runtime
- .dom_host()
- .is_connected(target)
- .then_some((hit, target))
- });
- // A latest-layout snapshot may still contain a text fragment whose DOM
- // node was replaced after the snapshot was published. Walk the sampled
- // paint stack only on that stale-source path until it identifies a
- // currently connected element. This live DOM check neither refreshes nor
- // invalidates layout; the common case retains the single-hit fast path.
- if live_first_hit.is_some() || first_hit.is_none() {
- return Ok(live_first_hit);
- }
- let hits = observable_hit_test_all_in_viewport(
- runtime,
- frame.document,
- frame.viewport,
- frame.point,
- ignore_pointer_events_none,
- )?;
- Ok(hits.into_iter().find_map(|hit| {
- let target = element_for_hit_source(runtime, hit.source)?;
- runtime
- .dom_host()
- .is_connected(target)
- .then_some((hit, target))
- }))
-}
-
-fn element_for_hit_source(runtime: &JsContextHost, mut source: DomHandle) -> Option<DomHandle> {
- loop {
- let node = runtime.dom_host().node(source)?;
- if node.is_element() {
- return Some(source);
- }
- let parent = node.parent_node()?;
- if runtime.dom_host().is_shadow_root(parent) {
- return runtime.dom_host().shadow_root_host(parent);
- }
- source = parent;
- }
-}
-
pub(crate) fn observable_hit_test_all(
runtime: &JsContextHost,
document: DomHandle,
@@ -586,336 +317,7 @@ pub(crate) fn observable_hit_test_all(
}
}
-fn observable_hit_test_all_in_viewport(
- runtime: &JsContextHost,
- document: DomHandle,
- viewport: LayoutViewport,
- point: LayoutPoint,
- ignore_pointer_events_none: bool,
-) -> Result<Vec<LayoutHit<DomHandle>>, LayoutError> {
- if !runtime.layout_policy().uses_real_layout() {
- return observable_hit_test_all(
- runtime,
- document,
- point,
- ignore_pointer_events_none,
- LayoutFlushReason::HitTest,
- )
- .map(|(_, hits)| hits);
- }
- let answers = runtime.answer_layout_at_viewport(
- document,
- LayoutFlushReason::HitTest,
- viewport,
- &LayoutQueryBatch::new(vec![LayoutQuery::HitTestAll {
- point,
- ignore_pointer_events_none,
- }]),
- )?;
- match answers.answers.into_iter().next() {
- Some(LayoutQueryAnswer::HitTestAll(hits)) => Ok(hits),
- _ => Err(provider_contract_error("viewport-scoped complete hit test")),
- }
-}
-
-fn css_viewport_dimension(value: f32) -> u32 {
- if !value.is_finite() {
- return 0;
- }
- value.round().clamp(0.0, u32::MAX as f32) as u32
-}
-
-fn answer_mock_queries(
- runtime: &JsContextHost,
- document: DomHandle,
- reason: LayoutFlushReason,
- batch: &LayoutQueryBatch<DomHandle>,
-) -> LayoutAnswers<DomHandle> {
- let viewport = runtime.layout_viewport_for_document(document);
- let answers = batch
- .queries
- .iter()
- .map(|query| match query {
- LayoutQuery::DocumentMetrics => {
- let viewport_scroll = runtime
- .dom_host()
- .dom()
- .document_element_handle_for_document(document)
- .and_then(|root| runtime.dom_host().node(root))
- .and_then(Node::as_element)
- .map(|element| {
- LayoutPoint::new(element.scroll_left() as f32, element.scroll_top() as f32)
- })
- .unwrap_or(LayoutPoint::ZERO);
- LayoutQueryAnswer::DocumentMetrics(LayoutDocumentMetrics {
- viewport,
- viewport_scroll,
- content_size: LayoutSize::new(
- viewport.css_width as f32,
- viewport.css_height as f32,
- ),
- })
- }
- LayoutQuery::BoxModel { source } => {
- LayoutQueryAnswer::BoxModel(mock_box_model(runtime, *source))
- }
- LayoutQuery::ClientRects { source } => LayoutQueryAnswer::ClientRects(
- mock_layout_client_rect_for_node(runtime, *source)
- .map(quad_from_client_rect)
- .into_iter()
- .collect(),
- ),
- LayoutQuery::ContentQuads { source } => LayoutQueryAnswer::ContentQuads(
- mock_layout_client_rect_for_node(runtime, *source)
- .map(quad_from_client_rect)
- .into_iter()
- .collect(),
- ),
- LayoutQuery::TextRangeRects { source, .. } => LayoutQueryAnswer::TextRangeRects(
- mock_layout_client_rect_for_node(runtime, *source)
- .map(quad_from_client_rect)
- .into_iter()
- .collect(),
- ),
- LayoutQuery::ElementMetrics { source } => {
- LayoutQueryAnswer::ElementMetrics(mock_element_metrics(runtime, *source))
- }
- LayoutQuery::ScrollIntoViewGeometry { source } => {
- LayoutQueryAnswer::ScrollIntoViewGeometry(mock_scroll_into_view_geometry(
- runtime, document, *source,
- ))
- }
- LayoutQuery::IntersectionGeometry { target, root } => {
- LayoutQueryAnswer::IntersectionGeometry(mock_intersection_geometry(
- runtime, document, *target, *root,
- ))
- }
- LayoutQuery::HitTest {
- point,
- ignore_pointer_events_none: _,
- } => LayoutQueryAnswer::HitTest(
- mock_hit_test_handle(runtime, document, f64::from(point.x), f64::from(point.y))
- .map(|source| LayoutHit {
- source,
- fragment: None,
- local_point: *point,
- is_text: false,
- local_content_box: None,
- viewport_to_local: moli_layout::LayoutTransform2D::IDENTITY,
- box_model: mock_box_model(runtime, source),
- }),
- ),
- LayoutQuery::HitTestAll {
- point,
- ignore_pointer_events_none: _,
- } => LayoutQueryAnswer::HitTestAll(
- mock_hit_test_handle(runtime, document, f64::from(point.x), f64::from(point.y))
- .map(|source| {
- vec![LayoutHit {
- source,
- fragment: None,
- local_point: *point,
- is_text: false,
- local_content_box: None,
- viewport_to_local: moli_layout::LayoutTransform2D::IDENTITY,
- box_model: mock_box_model(runtime, source),
- }]
- })
- .unwrap_or_default(),
- ),
- LayoutQuery::CaretPosition { point } => LayoutQueryAnswer::CaretPosition(
- mock_hit_test_handle(runtime, document, f64::from(point.x), f64::from(point.y))
- .map(|source| {
- let model = mock_box_model(runtime, source);
- LayoutCaretPosition {
- source,
- utf16_offset: None,
- rect: model
- .map(|model| model.border)
- .unwrap_or_else(|| quad_from_client_rect(zero_client_rect())),
- ancestor_boxes: model
- .map(|model| vec![(source, model)])
- .unwrap_or_default(),
- }
- }),
- ),
- LayoutQuery::EventOffset { source, point } => {
- let rect = compute_mock_client_rect(runtime, *source);
- LayoutQueryAnswer::EventOffset(Some(LayoutPoint::new(
- point.x - rect.left as f32,
- point.y - rect.top as f32,
- )))
- }
- })
- .collect();
- LayoutAnswers {
- answers,
- metrics: LayoutPassMetrics {
- reason,
- elapsed: Duration::ZERO,
- box_count: 0,
- fragment_count: 0,
- paint_operation_count: 0,
- fallback_count: 1,
- },
- }
-}
-
-fn mock_box_model(runtime: &JsContextHost, source: DomHandle) -> Option<LayoutBoxModel> {
- let rect = mock_layout_client_rect_for_node(runtime, source)?;
- let quad = quad_from_client_rect(rect);
- Some(LayoutBoxModel {
- content: quad,
- padding: quad,
- border: quad,
- margin: quad,
- })
-}
-
-fn mock_element_metrics(
- runtime: &JsContextHost,
- source: DomHandle,
-) -> Option<LayoutElementMetrics<DomHandle>> {
- let rect = mock_layout_client_rect_for_node(runtime, source)?;
- let size = LayoutSize::new(rect.width as f32, rect.height as f32);
- let offset = runtime
- .dom_host()
- .node(source)
- .and_then(Node::as_element)
- .map(|element| LayoutPoint::new(element.scroll_left() as f32, element.scroll_top() as f32))
- .unwrap_or(LayoutPoint::ZERO);
- let quad = quad_from_client_rect(rect);
- Some(LayoutElementMetrics {
- offset_parent: compute_mock_offset_parent(runtime, source),
- offset_position: LayoutPoint::new(rect.left as f32, rect.top as f32),
- offset_size: size,
- content_size: size,
- client_size: size,
- client_border: LayoutPoint::ZERO,
- scroll_size: size,
- scroll_offset: offset,
- minimum_scroll_offset: LayoutPoint::ZERO,
- maximum_scroll_offset: LayoutPoint::ZERO,
- scrollport: quad,
- scrollable_overflow: quad,
- is_scroll_container: false,
- allows_user_scroll_x: false,
- allows_user_scroll_y: false,
- clips_overflow: false,
- visible: rect.width > 0.0 && rect.height > 0.0,
- pointer_events: true,
- })
-}
-
-fn mock_scroll_into_view_geometry(
- runtime: &JsContextHost,
- document: DomHandle,
- source: DomHandle,
-) -> Option<LayoutScrollIntoViewGeometry<DomHandle>> {
- let target_rect = mock_layout_client_rect_for_node(runtime, source)?;
- let root = runtime
- .dom_host()
- .dom()
- .document_element_handle_for_document(document);
- let scroll_containers = root
- .filter(|root| *root != source)
- .and_then(|root| {
- mock_element_metrics(runtime, root).map(|metrics| LayoutScrollContainerMetrics {
- source: root,
- metrics,
- })
- })
- .into_iter()
- .collect();
- Some(LayoutScrollIntoViewGeometry {
- target_rects: vec![quad_from_client_rect(target_rect)],
- scroll_containers,
- })
-}
-
-fn mock_intersection_geometry(
- runtime: &JsContextHost,
- document: DomHandle,
- target: DomHandle,
- root: Option<DomHandle>,
-) -> Option<LayoutIntersectionGeometry> {
- let target_rect = mock_layout_client_rect_for_node(runtime, target)?;
- let viewport = runtime.layout_viewport_for_document(document);
- let root_rect = root
- .and_then(|root| mock_layout_client_rect_for_node(runtime, root))
- .map(quad_from_client_rect)
- .unwrap_or_else(|| {
- moli_layout::LayoutTransform2D::IDENTITY.map_rect(moli_layout::LayoutRect::new(
- 0.0,
- 0.0,
- viewport.css_width as f32,
- viewport.css_height as f32,
- ))
- });
- let root_is_layout_ancestor = root.is_none_or(|root| {
- let mut current = Some(target);
- while let Some(candidate) = current {
- if candidate == root {
- return true;
- }
- current = runtime.dom_host().parent_node(candidate);
- }
- false
- });
- Some(LayoutIntersectionGeometry {
- target_rects: vec![quad_from_client_rect(target_rect)],
- root_rect,
- ancestor_clips: Vec::new(),
- target_has_layout: true,
- target_visible: target_rect.width > 0.0 && target_rect.height > 0.0,
- root_clips_overflow: false,
- root_is_layout_ancestor,
- })
-}
-
-fn quad_from_client_rect(rect: ClientRect) -> LayoutQuad {
- let left = rect.left as f32;
- let top = rect.top as f32;
- let right = rect.right as f32;
- let bottom = rect.bottom as f32;
- LayoutQuad {
- points: [
- LayoutPoint::new(left, top),
- LayoutPoint::new(right, top),
- LayoutPoint::new(right, bottom),
- LayoutPoint::new(left, bottom),
- ],
- }
-}
-
-fn client_rect_from_quad(quad: LayoutQuad) -> ClientRect {
- let rect = quad.bounding_rect();
- ClientRect {
- left: f64::from(rect.x),
- top: f64::from(rect.y),
- right: f64::from(rect.right()),
- bottom: f64::from(rect.bottom()),
- width: f64::from(rect.width),
- height: f64::from(rect.height),
- }
-}
-
-fn union_client_rect(left: ClientRect, right: ClientRect) -> ClientRect {
- let min_x = left.left.min(right.left);
- let min_y = left.top.min(right.top);
- let max_x = left.right.max(right.right);
- let max_y = left.bottom.max(right.bottom);
- ClientRect {
- left: min_x,
- top: min_y,
- right: max_x,
- bottom: max_y,
- width: (max_x - min_x).max(0.0),
- height: (max_y - min_y).max(0.0),
- }
-}
-
-fn provider_contract_error(answer: &str) -> LayoutError {
+pub(super) fn provider_contract_error(answer: &str) -> LayoutError {
LayoutError::source_contract(
"renderer geometry provider",
format!("returned a mismatched {answer} answer"),