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 scrolling from CSSOM metrics

ldm0a7223d49089c
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry.rs b/moli-renderer-v8/src/native_bridge/element/geometry.rs
index f20637aed..c24c7e8b4 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry.rs
@@ -4,16 +4,13 @@ mod metrics;
mod mock;
mod provider;
mod rects;
+mod scroll;
+mod scroll_into_view;
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,
- perform_wheel_scroll_default_action, queue_scroll_observable_effects,
- scroll_node_into_view_at_start, scroll_node_into_view_if_needed,
-};
pub(in crate::native_bridge) use metrics::{
node_client_height_getter_function, node_client_left_getter_function,
node_client_top_getter_function, node_client_width_getter_function,
@@ -30,12 +27,18 @@ pub(crate) use mock::{
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_element_metrics,
- observable_event_offset, observable_geometry_batch, observable_hit_test_all,
- observable_scroll_adjusted_client_rect, observable_scroll_into_view_geometry,
+ observable_bounding_client_rect, observable_bounding_client_rects, 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_sources_with_fragments,
};
pub(in crate::native_bridge) use rects::{
node_get_bounding_client_rect_callback, node_get_client_rects_callback,
};
+pub(crate) use scroll::{
+ apply_scroll_observable_effects, perform_scrollbar_scroll_default_action,
+ perform_wheel_scroll_default_action, queue_scroll_observable_effects,
+};
+pub(crate) use scroll_into_view::{
+ scroll_node_into_view_at_start, scroll_node_into_view_if_needed,
+};
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs b/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs
index dfbfec8d3..b72e1545c 100644
--- a/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/metrics.rs
@@ -1,7 +1,4 @@
-use crate::{
- document_runtime::DomHandle, dom::native::Node, native_bridge::JsContextHost, util::v8str,
-};
-use moli_page_types::DomScrollIntoViewRect;
+use crate::{document_runtime::DomHandle, native_bridge::JsContextHost, util::v8str};
use super::super::super::{
document,
@@ -9,9 +6,15 @@ use super::super::super::{
};
use super::super::styles::raw_inline_style_property_value;
use super::super::{queue_revealed_lazy_image_loads, queue_revealed_lazy_media_loads};
-use super::{
- ClientRect, compute_mock_client_rect, observable_box_model, observable_element_metrics,
- observable_scroll_into_view_geometry,
+use super::client_rect::ClientRect;
+use super::mock::compute_mock_client_rect;
+use super::provider::observable_element_metrics;
+use super::scroll::{
+ apply_observable_window_scroll, node_scroll_position, queue_scroll_observable_effects,
+ set_node_scroll_position,
+};
+use super::scroll_into_view::{
+ ScrollIntoViewAlignment, scroll_node_into_view, scroll_node_into_view_if_needed,
};
fn node_scroll_position_value<'s>(
@@ -151,700 +154,6 @@ fn parse_scroll_coordinates(
(x, y)
}
-fn set_node_scroll_position(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- handle: DomHandle,
- left: f64,
- top: f64,
- queue_observable_effects: bool,
-) -> bool {
- let (changed, document) = {
- let runtime = unsafe { &mut *runtime_ptr };
- let document = runtime.dom_host().owner_document_handle(handle);
- let Some(element) = runtime
- .dom_host_mut()
- .node_mut(handle)
- .and_then(|node| node.data_mut().as_element_mut())
- else {
- return false;
- };
- (
- element.set_scroll_left(left) | element.set_scroll_top(top),
- document,
- )
- };
- if changed && queue_observable_effects {
- queue_scroll_observable_effects(scope, runtime_ptr, document, false);
- }
- changed
-}
-
-pub(crate) fn perform_scrollbar_scroll_default_action(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- source: DomHandle,
- axis: moli_layout::LayoutScrollbarAxis,
- target: f64,
-) -> bool {
- let (current_x, current_y) = node_scroll_position(unsafe { &*runtime_ptr }, source);
- let (target_x, target_y) = match axis {
- moli_layout::LayoutScrollbarAxis::Horizontal => (target, current_y),
- moli_layout::LayoutScrollbarAxis::Vertical => (current_x, target),
- };
- let document = unsafe { &*runtime_ptr }
- .dom_host()
- .owner_document_handle(source);
- let is_document_scroller = document.is_some_and(|document| {
- unsafe { &*runtime_ptr }
- .dom_host()
- .dom()
- .document_element_handle_for_document(document)
- == Some(source)
- });
- if is_document_scroller {
- apply_observable_window_scroll(
- scope,
- runtime_ptr,
- source,
- target_x,
- target_y,
- current_x,
- current_y,
- )
- } else {
- set_node_scroll_position(scope, runtime_ptr, source, target_x, target_y, true)
- }
-}
-
-pub(crate) fn queue_scroll_observable_effects(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- document: Option<DomHandle>,
- queue_document_events: bool,
-) {
- if unsafe { &mut *runtime_ptr }.defer_scroll_observable_effects(document, queue_document_events)
- {
- return;
- }
- apply_scroll_observable_effects(
- scope,
- runtime_ptr,
- [crate::native_bridge::PendingScrollObservableEffects::new(
- document,
- queue_document_events,
- )],
- );
-}
-
-pub(crate) fn apply_scroll_observable_effects(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- effects: impl IntoIterator<Item = crate::native_bridge::PendingScrollObservableEffects>,
-) {
- let effects = effects.into_iter().collect::<Vec<_>>();
- if effects.is_empty() {
- return;
- }
- // Native lazy loading deliberately combines the retained pre-scroll
- // projection with live element offsets, so admit those requests before
- // retiring the sampled projection. Observable geometry and author
- // IntersectionObservers, on the other hand, must see a fresh projection.
- for effects in &effects {
- if let Some(document) = effects.document() {
- queue_revealed_lazy_image_loads(scope, runtime_ptr, document);
- }
- }
- queue_revealed_lazy_media_loads(scope, runtime_ptr);
- unsafe { &*runtime_ptr }.invalidate_layout_after_interaction_state_change();
- crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);
- if effects
- .iter()
- .any(|effects| effects.queue_document_events())
- {
- let _ = unsafe { &mut *runtime_ptr }.queue_document_scroll_events(scope);
- }
-}
-
-fn scroll_axis_to_expose(
- target_start: f64,
- target_end: f64,
- current_scroll: f64,
- viewport_extent: f64,
-) -> f64 {
- let viewport_start = current_scroll;
- let viewport_end = current_scroll + viewport_extent;
- let target_contains_viewport = target_start <= viewport_start && target_end >= viewport_end;
- let target_is_fully_visible = target_start >= viewport_start && target_end <= viewport_end;
- if target_contains_viewport || target_is_fully_visible {
- return current_scroll;
- }
-
- let partially_visible = target_end > viewport_start && target_start < viewport_end;
- if partially_visible {
- return if target_start < viewport_start {
- target_start
- } else {
- target_end - viewport_extent
- };
- }
-
- (target_start + target_end - viewport_extent) / 2.0
-}
-
-#[derive(Clone, Copy)]
-enum ScrollIntoViewAlignment {
- Start,
- Center,
- End,
- Nearest,
-}
-
-#[derive(Clone, Copy)]
-struct ScrollIntoViewParams {
- horizontal: ScrollIntoViewAlignment,
- vertical: ScrollIntoViewAlignment,
- center_if_fully_hidden: bool,
-}
-
-const SCROLL_INTO_VIEW_FRAME_DEPTH_LIMIT: usize = 16;
-
-fn resolve_scroll_target(runtime: &JsContextHost, handle: DomHandle) -> Option<DomHandle> {
- let node = runtime.dom_host().node(handle)?;
- if node.is_document() {
- return runtime.dom_host().document_element_handle();
- }
- runtime.dom_host().is_connected(handle).then_some(handle)
-}
-
-fn aligned_scroll_position(
- target_start: f64,
- target_end: f64,
- current_scroll: f64,
- viewport_extent: f64,
- alignment: ScrollIntoViewAlignment,
-) -> f64 {
- match alignment {
- ScrollIntoViewAlignment::Start => target_start,
- ScrollIntoViewAlignment::Center => (target_start + target_end - viewport_extent) / 2.0,
- ScrollIntoViewAlignment::End => target_end - viewport_extent,
- ScrollIntoViewAlignment::Nearest => {
- scroll_axis_to_expose(target_start, target_end, current_scroll, viewport_extent)
- }
- }
-}
-
-fn apply_observable_window_scroll(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- scrolling_element: DomHandle,
- target_x: f64,
- target_y: f64,
- current_x: f64,
- current_y: f64,
-) -> bool {
- let changed = target_x != current_x || target_y != current_y;
- if !changed {
- return false;
- }
- set_node_scroll_position(
- scope,
- runtime_ptr,
- scrolling_element,
- target_x,
- target_y,
- false,
- );
- let endpoint = unsafe { &*runtime_ptr }
- .dom_host()
- .owner_document_handle(scrolling_element)
- .and_then(|document| unsafe { &*runtime_ptr }.window_endpoint_for_document(document));
- if let Some(endpoint) = endpoint {
- unsafe { &mut *runtime_ptr }.scroll_window_endpoint_to(scope, endpoint, target_x, target_y);
- }
- true
-}
-
-fn consume_wheel_axis(
- current: f64,
- minimum: f64,
- maximum: f64,
- remaining: f64,
- allows_user_scroll: bool,
-) -> (f64, f64) {
- if !allows_user_scroll || remaining == 0.0 {
- return (current, remaining);
- }
- let target = (current + remaining).clamp(minimum, maximum);
- (target, remaining - (target - current))
-}
-
-/// Run the uncancelled default action for one pixel-mode WheelEvent.
-///
-/// Each axis starts at the innermost scroll container under the pointer. Any
-/// delta left at that container's boundary continues along the layout ancestor
-/// chain, matching the scroll chaining users expect from a trackpad or wheel.
-pub(crate) fn perform_wheel_scroll_default_action(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- handle: DomHandle,
- delta_x: f64,
- delta_y: f64,
-) -> Result<bool, moli_layout::LayoutError> {
- let mut remaining_x = if delta_x.is_finite() { delta_x } else { 0.0 };
- let mut remaining_y = if delta_y.is_finite() { delta_y } else { 0.0 };
- if remaining_x == 0.0 && remaining_y == 0.0 {
- return Ok(false);
- }
-
- let runtime = unsafe { &*runtime_ptr };
- let Some(target) = resolve_scroll_target(runtime, handle) else {
- return Ok(false);
- };
- let Some(mut geometry) = observable_scroll_into_view_geometry(
- runtime,
- target,
- moli_layout::LayoutFlushReason::SynchronousGeometry,
- )?
- else {
- return Ok(false);
- };
-
- // ScrollIntoView geometry begins at the target's parent. Include the
- // target itself so an empty overflow scroller still responds when its own
- // background is the hit-test result.
- if let Some(metrics) = observable_element_metrics(
- runtime,
- target,
- moli_layout::LayoutFlushReason::SynchronousGeometry,
- )? && metrics.is_scroll_container
- && geometry
- .scroll_containers
- .iter()
- .all(|container| container.source != target)
- {
- geometry.scroll_containers.insert(
- 0,
- moli_layout::LayoutScrollContainerMetrics {
- source: target,
- metrics,
- },
- );
- }
-
- let mut changed = false;
- for container in geometry.scroll_containers {
- if remaining_x == 0.0 && remaining_y == 0.0 {
- break;
- }
- let (current_x, current_y) =
- node_scroll_position(unsafe { &*runtime_ptr }, container.source);
- let (target_x, next_remaining_x) = consume_wheel_axis(
- current_x,
- f64::from(container.metrics.minimum_scroll_offset.x),
- f64::from(container.metrics.maximum_scroll_offset.x),
- remaining_x,
- container.metrics.allows_user_scroll_x,
- );
- let (target_y, next_remaining_y) = consume_wheel_axis(
- current_y,
- f64::from(container.metrics.minimum_scroll_offset.y),
- f64::from(container.metrics.maximum_scroll_offset.y),
- remaining_y,
- container.metrics.allows_user_scroll_y,
- );
- remaining_x = next_remaining_x;
- remaining_y = next_remaining_y;
- if target_x == current_x && target_y == current_y {
- continue;
- }
-
- let container_document = unsafe { &*runtime_ptr }
- .dom_host()
- .owner_document_handle(container.source);
- let is_document_scroller = container_document.is_some_and(|document| {
- unsafe { &*runtime_ptr }
- .dom_host()
- .dom()
- .document_element_handle_for_document(document)
- == Some(container.source)
- });
- if is_document_scroller {
- changed |= apply_observable_window_scroll(
- scope,
- runtime_ptr,
- container.source,
- target_x,
- target_y,
- current_x,
- current_y,
- );
- } else {
- set_node_scroll_position(
- scope,
- runtime_ptr,
- container.source,
- target_x,
- target_y,
- true,
- );
- changed = true;
- }
- }
- Ok(changed)
-}
-
-pub(crate) fn scroll_node_into_view_if_needed(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- handle: DomHandle,
- relative_rect: Option<DomScrollIntoViewRect>,
-) -> Result<Option<bool>, moli_layout::LayoutError> {
- scroll_node_into_view(
- scope,
- runtime_ptr,
- handle,
- relative_rect,
- ScrollIntoViewParams {
- horizontal: ScrollIntoViewAlignment::Nearest,
- vertical: ScrollIntoViewAlignment::Nearest,
- center_if_fully_hidden: true,
- },
- )
-}
-
-fn scroll_node_into_view(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- handle: DomHandle,
- relative_rect: Option<DomScrollIntoViewRect>,
- params: ScrollIntoViewParams,
-) -> Result<Option<bool>, moli_layout::LayoutError> {
- let runtime = unsafe { &*runtime_ptr };
- let Some(target) = resolve_scroll_target(runtime, handle) else {
- return Ok(None);
- };
- let Some(mut geometry) = observable_scroll_into_view_geometry(
- runtime,
- target,
- moli_layout::LayoutFlushReason::SynchronousGeometry,
- )?
- else {
- return Ok(None);
- };
- if let Some(relative) = relative_rect {
- let Some(bounds) = quads_bounding_rect(&geometry.target_rects) else {
- return Ok(None);
- };
- geometry.target_rects =
- vec![
- moli_layout::LayoutTransform2D::IDENTITY.map_rect(moli_layout::LayoutRect::new(
- bounds.x + relative.x() as f32,
- bounds.y + relative.y() as f32,
- relative.width().max(0.0) as f32,
- relative.height().max(0.0) as f32,
- )),
- ];
- }
- if geometry.target_rects.is_empty() {
- return Ok(None);
- }
- perform_bubbling_scroll_into_view(scope, runtime_ptr, target, geometry, params, 0).map(Some)
-}
-
-pub(crate) fn scroll_node_into_view_at_start(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- handle: DomHandle,
-) -> Result<Option<bool>, moli_layout::LayoutError> {
- scroll_node_into_view(
- scope,
- runtime_ptr,
- handle,
- None,
- ScrollIntoViewParams {
- horizontal: ScrollIntoViewAlignment::Nearest,
- vertical: ScrollIntoViewAlignment::Start,
- center_if_fully_hidden: false,
- },
- )
-}
-
-/// Blink's `PerformBubblingScrollIntoView` follows the same shape: scroll the
-/// local containers, convert the resulting target geometry into the parent
-/// frame, then continue with the frame owner.
-fn perform_bubbling_scroll_into_view(
- scope: &mut v8::PinScope<'_, '_>,
- runtime_ptr: *mut JsContextHost,
- target: DomHandle,
- mut geometry: moli_layout::LayoutScrollIntoViewGeometry<DomHandle>,
- params: ScrollIntoViewParams,
- frame_depth: usize,
-) -> Result<bool, moli_layout::LayoutError> {
- let target_document = unsafe { &*runtime_ptr }
- .dom_host()
- .owner_document_handle(target);
- let mut changed = false;
- for container in geometry.scroll_containers {
- let metrics = &container.metrics;
- let Some(target_bounds) = target_bounds_in_scroll_content(&geometry.target_rects, metrics)
- else {
- continue;
- };
- let desired_x = if params.center_if_fully_hidden {
- scroll_axis_to_expose(
- f64::from(target_bounds.x),
- f64::from(target_bounds.right()),
- f64::from(metrics.scroll_offset.x),
- f64::from(metrics.client_size.width),
- )
- } else {
- aligned_scroll_position(
- f64::from(target_bounds.x),
- f64::from(target_bounds.right()),
- f64::from(metrics.scroll_offset.x),
- f64::from(metrics.client_size.width),
- params.horizontal,
- )
- };
- let desired_y = if params.center_if_fully_hidden {
- scroll_axis_to_expose(
- f64::from(target_bounds.y),
- f64::from(target_bounds.bottom()),
- f64::from(metrics.scroll_offset.y),
- f64::from(metrics.client_size.height),
- )
- } else {
- aligned_scroll_position(
- f64::from(target_bounds.y),
- f64::from(target_bounds.bottom()),
- f64::from(metrics.scroll_offset.y),
- f64::from(metrics.client_size.height),
- params.vertical,
- )
- };
- let target_x = desired_x.clamp(
- f64::from(metrics.minimum_scroll_offset.x),
- f64::from(metrics.maximum_scroll_offset.x),
- );
- let target_y = desired_y.clamp(
- f64::from(metrics.minimum_scroll_offset.y),
- f64::from(metrics.maximum_scroll_offset.y),
- );
- let delta_x = target_x - f64::from(metrics.scroll_offset.x);
- let delta_y = target_y - f64::from(metrics.scroll_offset.y);
- if delta_x == 0.0 && delta_y == 0.0 {
- continue;
- }
- let container_document = unsafe { &*runtime_ptr }
- .dom_host()
- .owner_document_handle(container.source);
- let is_document_scroller = container_document.is_some_and(|document| {
- unsafe { &*runtime_ptr }
- .dom_host()
- .dom()
- .document_element_handle_for_document(document)
- == Some(container.source)
- });
- if is_document_scroller {
- changed |= apply_observable_window_scroll(
- scope,
- runtime_ptr,
- container.source,
- target_x,
- target_y,
- f64::from(metrics.scroll_offset.x),
- f64::from(metrics.scroll_offset.y),
- );
- } else {
- set_node_scroll_position(
- scope,
- runtime_ptr,
- container.source,
- target_x,
- target_y,
- true,
- );
- changed = true;
- }
- translate_quads_for_scroll(
- &mut geometry.target_rects,
- metrics.scrollport,
- metrics.client_size,
- delta_x,
- delta_y,
- );
- }
- if frame_depth >= SCROLL_INTO_VIEW_FRAME_DEPTH_LIMIT {
- return Ok(changed);
- }
- let Some(document) = target_document else {
- return Ok(changed);
- };
- let runtime = unsafe { &*runtime_ptr };
- if document == runtime.document_handle() {
- return Ok(changed);
- }
- let Some(frame) = runtime.child_browsing_context_host_for_document_handle(document) else {
- return Ok(changed);
- };
- let Some(frame_content) = observable_box_model(
- runtime,
- frame,
- moli_layout::LayoutFlushReason::SynchronousGeometry,
- )?
- .map(|model| model.content) else {
- return Ok(changed);
- };
- let Some(parent_target_rects) = convert_quads_to_parent_frame(
- &geometry.target_rects,
- runtime.layout_viewport_for_document(document),
- frame_content,
- ) else {
- return Ok(changed);
- };
- let Some(mut parent_geometry) = observable_scroll_into_view_geometry(
- runtime,
- frame,
- moli_layout::LayoutFlushReason::SynchronousGeometry,
- )?
- else {
- return Ok(changed);
- };
- parent_geometry.target_rects = parent_target_rects;
- let parent_params = ScrollIntoViewParams {
- horizontal: ScrollIntoViewAlignment::Nearest,
- vertical: ScrollIntoViewAlignment::Nearest,
- ..params
- };
- changed |= perform_bubbling_scroll_into_view(
- scope,
- runtime_ptr,
- frame,
- parent_geometry,
- parent_params,
- frame_depth + 1,
- )?;
- Ok(changed)
-}
-
-/// Convert a rectangle carried by a child frame into the parent document's
-/// viewport coordinates. This mirrors Blink's cross-frame scroll bubbling:
-/// the target rectangle is converted through the frame owner's content box,
-/// rather than replacing it with the bounds of the whole frame.
-fn convert_quads_to_parent_frame(
- child_quads: &[moli_layout::LayoutQuad],
- child_viewport: moli_layout::LayoutViewport,
- parent_content: moli_layout::LayoutQuad,
-) -> Option<Vec<moli_layout::LayoutQuad>> {
- let width = child_viewport.css_width as f32;
- let height = child_viewport.css_height as f32;
- if width <= 0.0 || height <= 0.0 {
- return None;
- }
- let [origin, x_corner, _, y_corner] = parent_content.points;
- let x_basis = moli_layout::LayoutPoint::new(x_corner.x - origin.x, x_corner.y - origin.y);
- let y_basis = moli_layout::LayoutPoint::new(y_corner.x - origin.x, y_corner.y - origin.y);
- Some(
- child_quads
- .iter()
- .map(|quad| moli_layout::LayoutQuad {
- points: quad.points.map(|point| {
- let u = point.x / width;
- let v = point.y / height;
- moli_layout::LayoutPoint::new(
- origin.x + x_basis.x * u + y_basis.x * v,
- origin.y + x_basis.y * u + y_basis.y * v,
- )
- }),
- })
- .collect(),
- )
-}
-
-fn quads_bounding_rect(quads: &[moli_layout::LayoutQuad]) -> Option<moli_layout::LayoutRect> {
- quads
- .iter()
- .map(|quad| quad.bounding_rect())
- .reduce(moli_layout::LayoutRect::union)
-}
-
-fn target_bounds_in_scroll_content(
- target_quads: &[moli_layout::LayoutQuad],
- metrics: &moli_layout::LayoutElementMetrics<DomHandle>,
-) -> Option<moli_layout::LayoutRect> {
- let mut min_x = f64::INFINITY;
- let mut min_y = f64::INFINITY;
- let mut max_x = f64::NEG_INFINITY;
- let mut max_y = f64::NEG_INFINITY;
- for point in target_quads.iter().flat_map(|quad| quad.points) {
- let local =
- map_viewport_point_to_scrollport(point, metrics.scrollport, metrics.client_size)?;
- let x = local.0 + f64::from(metrics.scroll_offset.x);
- let y = local.1 + f64::from(metrics.scroll_offset.y);
- min_x = min_x.min(x);
- min_y = min_y.min(y);
- max_x = max_x.max(x);
- max_y = max_y.max(y);
- }
- [min_x, min_y, max_x, max_y]
- .into_iter()
- .all(f64::is_finite)
- .then(|| {
- moli_layout::LayoutRect::new(
- min_x as f32,
- min_y as f32,
- (max_x - min_x).max(0.0) as f32,
- (max_y - min_y).max(0.0) as f32,
- )
- })
-}
-
-fn map_viewport_point_to_scrollport(
- point: moli_layout::LayoutPoint,
- scrollport: moli_layout::LayoutQuad,
- size: moli_layout::LayoutSize,
-) -> Option<(f64, f64)> {
- let [origin, x_corner, _, y_corner] = scrollport.points;
- let x_basis = (
- f64::from(x_corner.x - origin.x),
- f64::from(x_corner.y - origin.y),
- );
- let y_basis = (
- f64::from(y_corner.x - origin.x),
- f64::from(y_corner.y - origin.y),
- );
- let relative = (f64::from(point.x - origin.x), f64::from(point.y - origin.y));
- let determinant = x_basis.0 * y_basis.1 - x_basis.1 * y_basis.0;
- if !determinant.is_finite() || determinant.abs() <= f64::EPSILON {
- return None;
- }
- let u = (relative.0 * y_basis.1 - relative.1 * y_basis.0) / determinant;
- let v = (x_basis.0 * relative.1 - x_basis.1 * relative.0) / determinant;
- Some((u * f64::from(size.width), v * f64::from(size.height)))
-}
-
-fn translate_quads_for_scroll(
- quads: &mut [moli_layout::LayoutQuad],
- scrollport: moli_layout::LayoutQuad,
- size: moli_layout::LayoutSize,
- delta_x: f64,
- delta_y: f64,
-) {
- if size.width <= 0.0 || size.height <= 0.0 {
- return;
- }
- let [origin, x_corner, _, y_corner] = scrollport.points;
- let shift_x = f64::from(x_corner.x - origin.x) * delta_x / f64::from(size.width)
- + f64::from(y_corner.x - origin.x) * delta_y / f64::from(size.height);
- let shift_y = f64::from(x_corner.y - origin.y) * delta_x / f64::from(size.width)
- + f64::from(y_corner.y - origin.y) * delta_y / f64::from(size.height);
- for point in quads.iter_mut().flat_map(|quad| quad.points.iter_mut()) {
- point.x -= shift_x as f32;
- point.y -= shift_y as f32;
- }
-}
-
fn scroll_alignment_option(
scope: &mut v8::PinScope<'_, '_>,
options: v8::Local<'_, v8::Object>,
@@ -899,15 +208,6 @@ fn element_scroll_into_view_alignments(
)
}
-fn node_scroll_position(runtime: &JsContextHost, handle: DomHandle) -> (f64, f64) {
- runtime
- .dom_host()
- .node(handle)
- .and_then(Node::as_element)
- .map(|element| (element.scroll_left(), element.scroll_top()))
- .unwrap_or((0.0, 0.0))
-}
-
fn scroll_node_to<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
@@ -1327,17 +627,9 @@ pub(in crate::native_bridge) fn node_scroll_into_view_callback(
) {
if let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object(scope, args.this()) {
let (horizontal, vertical) = element_scroll_into_view_alignments(scope, &args);
- if let Err(error) = scroll_node_into_view(
- scope,
- runtime_ptr,
- handle,
- None,
- ScrollIntoViewParams {
- horizontal,
- vertical,
- center_if_fully_hidden: false,
- },
- ) {
+ if let Err(error) =
+ scroll_node_into_view(scope, runtime_ptr, handle, None, horizontal, vertical)
+ {
throw_scroll_layout_error(scope, "scrollIntoView", error);
}
}
@@ -1372,71 +664,3 @@ fn reveal_lazy_images_for_scroll(
}
queue_revealed_lazy_media_loads(scope, runtime_ptr);
}
-
-#[cfg(test)]
-mod scroll_alignment_tests {
- use super::{convert_quads_to_parent_frame, scroll_axis_to_expose};
-
- #[test]
- fn center_if_needed_returns_the_unclamped_chromium_alignment_position() {
- let viewport = 100.0;
- assert_eq!(scroll_axis_to_expose(20.0, 40.0, 0.0, viewport), 0.0);
- assert_eq!(
- scroll_axis_to_expose(-20.0, 120.0, 0.0, viewport),
- 0.0,
- "a target containing the viewport stays put"
- );
- assert_eq!(scroll_axis_to_expose(-10.0, 20.0, 0.0, viewport), -10.0);
- assert_eq!(scroll_axis_to_expose(90.0, 120.0, 0.0, viewport), 20.0);
- assert_eq!(scroll_axis_to_expose(200.0, 220.0, 0.0, viewport), 160.0);
- assert_eq!(scroll_axis_to_expose(0.0, 20.0, 200.0, viewport), -40.0);
- }
-
- #[test]
- fn child_viewport_rect_maps_through_the_parent_content_quad() {
- let child_quad = moli_layout::LayoutTransform2D::IDENTITY
- .map_rect(moli_layout::LayoutRect::new(50.0, 25.0, 100.0, 50.0));
- let parent_content = moli_layout::LayoutQuad {
- points: [
- moli_layout::LayoutPoint::new(10.0, 20.0),
- moli_layout::LayoutPoint::new(110.0, 40.0),
- moli_layout::LayoutPoint::new(90.0, 100.0),
- moli_layout::LayoutPoint::new(-10.0, 80.0),
- ],
- };
-
- let mapped = convert_quads_to_parent_frame(
- &[child_quad],
- moli_layout::LayoutViewport::new(200, 100, 1.0),
- parent_content,
- )
- .expect("non-empty child viewport should map");
-
- assert_eq!(
- mapped[0].points,
- [
- moli_layout::LayoutPoint::new(30.0, 40.0),
- moli_layout::LayoutPoint::new(80.0, 50.0),
- moli_layout::LayoutPoint::new(70.0, 80.0),
- moli_layout::LayoutPoint::new(20.0, 70.0),
- ]
- );
- }
-
- #[test]
- fn empty_child_viewport_cannot_produce_parent_geometry() {
- let child_quad = moli_layout::LayoutTransform2D::IDENTITY
- .map_rect(moli_layout::LayoutRect::new(0.0, 0.0, 10.0, 10.0));
- let parent_content = moli_layout::LayoutTransform2D::IDENTITY
- .map_rect(moli_layout::LayoutRect::new(0.0, 0.0, 10.0, 10.0));
-
- assert!(
- convert_quads_to_parent_frame(
- &[child_quad],
- moli_layout::LayoutViewport::new(0, 100, 1.0),
- parent_content,
- )
- .is_none()
- );
- }
-}
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/scroll.rs b/moli-renderer-v8/src/native_bridge/element/geometry/scroll.rs
new file mode 100644
index 000000000..0815889d1
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/scroll.rs
@@ -0,0 +1,299 @@
+use crate::{document_runtime::DomHandle, dom::native::Node, native_bridge::JsContextHost};
+
+use super::super::{queue_revealed_lazy_image_loads, queue_revealed_lazy_media_loads};
+use super::provider::{observable_element_metrics, observable_scroll_into_view_geometry};
+
+pub(super) fn node_scroll_position(runtime: &JsContextHost, handle: DomHandle) -> (f64, f64) {
+ runtime
+ .dom_host()
+ .node(handle)
+ .and_then(Node::as_element)
+ .map(|element| (element.scroll_left(), element.scroll_top()))
+ .unwrap_or((0.0, 0.0))
+}
+
+pub(super) fn resolve_scroll_target(
+ runtime: &JsContextHost,
+ handle: DomHandle,
+) -> Option<DomHandle> {
+ let node = runtime.dom_host().node(handle)?;
+ if node.is_document() {
+ return runtime.dom_host().document_element_handle();
+ }
+ runtime.dom_host().is_connected(handle).then_some(handle)
+}
+
+pub(super) fn set_node_scroll_position(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+ left: f64,
+ top: f64,
+ queue_observable_effects: bool,
+) -> bool {
+ let (changed, document) = {
+ let runtime = unsafe { &mut *runtime_ptr };
+ let document = runtime.dom_host().owner_document_handle(handle);
+ let Some(element) = runtime
+ .dom_host_mut()
+ .node_mut(handle)
+ .and_then(|node| node.data_mut().as_element_mut())
+ else {
+ return false;
+ };
+ (
+ element.set_scroll_left(left) | element.set_scroll_top(top),
+ document,
+ )
+ };
+ if changed && queue_observable_effects {
+ queue_scroll_observable_effects(scope, runtime_ptr, document, false);
+ }
+ changed
+}
+
+pub(super) fn apply_observable_window_scroll(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ scrolling_element: DomHandle,
+ target_x: f64,
+ target_y: f64,
+ current_x: f64,
+ current_y: f64,
+) -> bool {
+ let changed = target_x != current_x || target_y != current_y;
+ if !changed {
+ return false;
+ }
+ set_node_scroll_position(
+ scope,
+ runtime_ptr,
+ scrolling_element,
+ target_x,
+ target_y,
+ false,
+ );
+ let endpoint = unsafe { &*runtime_ptr }
+ .dom_host()
+ .owner_document_handle(scrolling_element)
+ .and_then(|document| unsafe { &*runtime_ptr }.window_endpoint_for_document(document));
+ if let Some(endpoint) = endpoint {
+ unsafe { &mut *runtime_ptr }.scroll_window_endpoint_to(scope, endpoint, target_x, target_y);
+ }
+ true
+}
+
+pub(crate) fn perform_scrollbar_scroll_default_action(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ source: DomHandle,
+ axis: moli_layout::LayoutScrollbarAxis,
+ target: f64,
+) -> bool {
+ let (current_x, current_y) = node_scroll_position(unsafe { &*runtime_ptr }, source);
+ let (target_x, target_y) = match axis {
+ moli_layout::LayoutScrollbarAxis::Horizontal => (target, current_y),
+ moli_layout::LayoutScrollbarAxis::Vertical => (current_x, target),
+ };
+ let document = unsafe { &*runtime_ptr }
+ .dom_host()
+ .owner_document_handle(source);
+ let is_document_scroller = document.is_some_and(|document| {
+ unsafe { &*runtime_ptr }
+ .dom_host()
+ .dom()
+ .document_element_handle_for_document(document)
+ == Some(source)
+ });
+ if is_document_scroller {
+ apply_observable_window_scroll(
+ scope,
+ runtime_ptr,
+ source,
+ target_x,
+ target_y,
+ current_x,
+ current_y,
+ )
+ } else {
+ set_node_scroll_position(scope, runtime_ptr, source, target_x, target_y, true)
+ }
+}
+
+pub(crate) fn queue_scroll_observable_effects(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ document: Option<DomHandle>,
+ queue_document_events: bool,
+) {
+ if unsafe { &mut *runtime_ptr }.defer_scroll_observable_effects(document, queue_document_events)
+ {
+ return;
+ }
+ apply_scroll_observable_effects(
+ scope,
+ runtime_ptr,
+ [crate::native_bridge::PendingScrollObservableEffects::new(
+ document,
+ queue_document_events,
+ )],
+ );
+}
+
+pub(crate) fn apply_scroll_observable_effects(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ effects: impl IntoIterator<Item = crate::native_bridge::PendingScrollObservableEffects>,
+) {
+ let effects = effects.into_iter().collect::<Vec<_>>();
+ if effects.is_empty() {
+ return;
+ }
+ // Native lazy loading deliberately combines the retained pre-scroll
+ // projection with live element offsets, so admit those requests before
+ // retiring the sampled projection. Observable geometry and author
+ // IntersectionObservers, on the other hand, must see a fresh projection.
+ for effects in &effects {
+ if let Some(document) = effects.document() {
+ queue_revealed_lazy_image_loads(scope, runtime_ptr, document);
+ }
+ }
+ queue_revealed_lazy_media_loads(scope, runtime_ptr);
+ unsafe { &*runtime_ptr }.invalidate_layout_after_interaction_state_change();
+ crate::observer_runtime::queue_intersection_checks(scope, runtime_ptr);
+ if effects
+ .iter()
+ .any(|effects| effects.queue_document_events())
+ {
+ let _ = unsafe { &mut *runtime_ptr }.queue_document_scroll_events(scope);
+ }
+}
+
+fn consume_wheel_axis(
+ current: f64,
+ minimum: f64,
+ maximum: f64,
+ remaining: f64,
+ allows_user_scroll: bool,
+) -> (f64, f64) {
+ if !allows_user_scroll || remaining == 0.0 {
+ return (current, remaining);
+ }
+ let target = (current + remaining).clamp(minimum, maximum);
+ (target, remaining - (target - current))
+}
+
+/// Run the uncancelled default action for one pixel-mode WheelEvent.
+///
+/// Each axis starts at the innermost scroll container under the pointer. Any
+/// delta left at that container's boundary continues along the layout ancestor
+/// chain, matching the scroll chaining users expect from a trackpad or wheel.
+pub(crate) fn perform_wheel_scroll_default_action(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+ delta_x: f64,
+ delta_y: f64,
+) -> Result<bool, moli_layout::LayoutError> {
+ let mut remaining_x = if delta_x.is_finite() { delta_x } else { 0.0 };
+ let mut remaining_y = if delta_y.is_finite() { delta_y } else { 0.0 };
+ if remaining_x == 0.0 && remaining_y == 0.0 {
+ return Ok(false);
+ }
+
+ let runtime = unsafe { &*runtime_ptr };
+ let Some(target) = resolve_scroll_target(runtime, handle) else {
+ return Ok(false);
+ };
+ let Some(mut geometry) = observable_scroll_into_view_geometry(
+ runtime,
+ target,
+ moli_layout::LayoutFlushReason::SynchronousGeometry,
+ )?
+ else {
+ return Ok(false);
+ };
+
+ // ScrollIntoView geometry begins at the target's parent. Include the
+ // target itself so an empty overflow scroller still responds when its own
+ // background is the hit-test result.
+ if let Some(metrics) = observable_element_metrics(
+ runtime,
+ target,
+ moli_layout::LayoutFlushReason::SynchronousGeometry,
+ )? && metrics.is_scroll_container
+ && geometry
+ .scroll_containers
+ .iter()
+ .all(|container| container.source != target)
+ {
+ geometry.scroll_containers.insert(
+ 0,
+ moli_layout::LayoutScrollContainerMetrics {
+ source: target,
+ metrics,
+ },
+ );
+ }
+
+ let mut changed = false;
+ for container in geometry.scroll_containers {
+ if remaining_x == 0.0 && remaining_y == 0.0 {
+ break;
+ }
+ let (current_x, current_y) =
+ node_scroll_position(unsafe { &*runtime_ptr }, container.source);
+ let (target_x, next_remaining_x) = consume_wheel_axis(
+ current_x,
+ f64::from(container.metrics.minimum_scroll_offset.x),
+ f64::from(container.metrics.maximum_scroll_offset.x),
+ remaining_x,
+ container.metrics.allows_user_scroll_x,
+ );
+ let (target_y, next_remaining_y) = consume_wheel_axis(
+ current_y,
+ f64::from(container.metrics.minimum_scroll_offset.y),
+ f64::from(container.metrics.maximum_scroll_offset.y),
+ remaining_y,
+ container.metrics.allows_user_scroll_y,
+ );
+ remaining_x = next_remaining_x;
+ remaining_y = next_remaining_y;
+ if target_x == current_x && target_y == current_y {
+ continue;
+ }
+
+ let container_document = unsafe { &*runtime_ptr }
+ .dom_host()
+ .owner_document_handle(container.source);
+ let is_document_scroller = container_document.is_some_and(|document| {
+ unsafe { &*runtime_ptr }
+ .dom_host()
+ .dom()
+ .document_element_handle_for_document(document)
+ == Some(container.source)
+ });
+ if is_document_scroller {
+ changed |= apply_observable_window_scroll(
+ scope,
+ runtime_ptr,
+ container.source,
+ target_x,
+ target_y,
+ current_x,
+ current_y,
+ );
+ } else {
+ set_node_scroll_position(
+ scope,
+ runtime_ptr,
+ container.source,
+ target_x,
+ target_y,
+ true,
+ );
+ changed = true;
+ }
+ }
+ Ok(changed)
+}
diff --git a/moli-renderer-v8/src/native_bridge/element/geometry/scroll_into_view.rs b/moli-renderer-v8/src/native_bridge/element/geometry/scroll_into_view.rs
new file mode 100644
index 000000000..bd048f918
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/element/geometry/scroll_into_view.rs
@@ -0,0 +1,508 @@
+use moli_page_types::DomScrollIntoViewRect;
+
+use crate::{document_runtime::DomHandle, native_bridge::JsContextHost};
+
+use super::provider::{observable_box_model, observable_scroll_into_view_geometry};
+use super::scroll::{
+ apply_observable_window_scroll, resolve_scroll_target, set_node_scroll_position,
+};
+
+const CHILD_FRAME_DEPTH_LIMIT: usize = 16;
+
+#[derive(Clone, Copy)]
+pub(super) enum ScrollIntoViewAlignment {
+ Start,
+ Center,
+ End,
+ Nearest,
+}
+
+#[derive(Clone, Copy)]
+struct ScrollIntoViewParams {
+ horizontal: ScrollIntoViewAlignment,
+ vertical: ScrollIntoViewAlignment,
+ center_if_fully_hidden: bool,
+}
+
+fn scroll_axis_to_expose(
+ target_start: f64,
+ target_end: f64,
+ current_scroll: f64,
+ viewport_extent: f64,
+) -> f64 {
+ let viewport_start = current_scroll;
+ let viewport_end = current_scroll + viewport_extent;
+ let target_contains_viewport = target_start <= viewport_start && target_end >= viewport_end;
+ let target_is_fully_visible = target_start >= viewport_start && target_end <= viewport_end;
+ if target_contains_viewport || target_is_fully_visible {
+ return current_scroll;
+ }
+
+ let partially_visible = target_end > viewport_start && target_start < viewport_end;
+ if partially_visible {
+ return if target_start < viewport_start {
+ target_start
+ } else {
+ target_end - viewport_extent
+ };
+ }
+
+ (target_start + target_end - viewport_extent) / 2.0
+}
+
+fn aligned_scroll_position(
+ target_start: f64,
+ target_end: f64,
+ current_scroll: f64,
+ viewport_extent: f64,
+ alignment: ScrollIntoViewAlignment,
+) -> f64 {
+ match alignment {
+ ScrollIntoViewAlignment::Start => target_start,
+ ScrollIntoViewAlignment::Center => (target_start + target_end - viewport_extent) / 2.0,
+ ScrollIntoViewAlignment::End => target_end - viewport_extent,
+ ScrollIntoViewAlignment::Nearest => {
+ scroll_axis_to_expose(target_start, target_end, current_scroll, viewport_extent)
+ }
+ }
+}
+
+pub(crate) fn scroll_node_into_view_if_needed(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+ relative_rect: Option<DomScrollIntoViewRect>,
+) -> Result<Option<bool>, moli_layout::LayoutError> {
+ scroll_node_into_view_with_params(
+ scope,
+ runtime_ptr,
+ handle,
+ relative_rect,
+ ScrollIntoViewParams {
+ horizontal: ScrollIntoViewAlignment::Nearest,
+ vertical: ScrollIntoViewAlignment::Nearest,
+ center_if_fully_hidden: true,
+ },
+ )
+}
+
+pub(super) fn scroll_node_into_view(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+ relative_rect: Option<DomScrollIntoViewRect>,
+ horizontal: ScrollIntoViewAlignment,
+ vertical: ScrollIntoViewAlignment,
+) -> Result<Option<bool>, moli_layout::LayoutError> {
+ scroll_node_into_view_with_params(
+ scope,
+ runtime_ptr,
+ handle,
+ relative_rect,
+ ScrollIntoViewParams {
+ horizontal,
+ vertical,
+ center_if_fully_hidden: false,
+ },
+ )
+}
+
+fn scroll_node_into_view_with_params(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+ relative_rect: Option<DomScrollIntoViewRect>,
+ params: ScrollIntoViewParams,
+) -> Result<Option<bool>, moli_layout::LayoutError> {
+ let runtime = unsafe { &*runtime_ptr };
+ let Some(target) = resolve_scroll_target(runtime, handle) else {
+ return Ok(None);
+ };
+ let Some(mut geometry) = observable_scroll_into_view_geometry(
+ runtime,
+ target,
+ moli_layout::LayoutFlushReason::SynchronousGeometry,
+ )?
+ else {
+ return Ok(None);
+ };
+ if let Some(relative) = relative_rect {
+ let Some(bounds) = quads_bounding_rect(&geometry.target_rects) else {
+ return Ok(None);
+ };
+ geometry.target_rects =
+ vec![
+ moli_layout::LayoutTransform2D::IDENTITY.map_rect(moli_layout::LayoutRect::new(
+ bounds.x + relative.x() as f32,
+ bounds.y + relative.y() as f32,
+ relative.width().max(0.0) as f32,
+ relative.height().max(0.0) as f32,
+ )),
+ ];
+ }
+ if geometry.target_rects.is_empty() {
+ return Ok(None);
+ }
+ perform_bubbling_scroll_into_view(scope, runtime_ptr, target, geometry, params, 0).map(Some)
+}
+
+pub(crate) fn scroll_node_into_view_at_start(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ handle: DomHandle,
+) -> Result<Option<bool>, moli_layout::LayoutError> {
+ scroll_node_into_view_with_params(
+ scope,
+ runtime_ptr,
+ handle,
+ None,
+ ScrollIntoViewParams {
+ horizontal: ScrollIntoViewAlignment::Nearest,
+ vertical: ScrollIntoViewAlignment::Start,
+ center_if_fully_hidden: false,
+ },
+ )
+}
+
+/// Blink's `PerformBubblingScrollIntoView` follows the same shape: scroll the
+/// local containers, convert the resulting target geometry into the parent
+/// frame, then continue with the frame owner.
+fn perform_bubbling_scroll_into_view(
+ scope: &mut v8::PinScope<'_, '_>,
+ runtime_ptr: *mut JsContextHost,
+ target: DomHandle,
+ mut geometry: moli_layout::LayoutScrollIntoViewGeometry<DomHandle>,
+ params: ScrollIntoViewParams,
+ frame_depth: usize,
+) -> Result<bool, moli_layout::LayoutError> {
+ let target_document = unsafe { &*runtime_ptr }
+ .dom_host()
+ .owner_document_handle(target);
+ let mut changed = false;
+ for container in geometry.scroll_containers {
+ let metrics = &container.metrics;
+ let Some(target_bounds) = target_bounds_in_scroll_content(&geometry.target_rects, metrics)
+ else {
+ continue;
+ };
+ let desired_x = if params.center_if_fully_hidden {
+ scroll_axis_to_expose(
+ f64::from(target_bounds.x),
+ f64::from(target_bounds.right()),
+ f64::from(metrics.scroll_offset.x),
+ f64::from(metrics.client_size.width),
+ )
+ } else {
+ aligned_scroll_position(
+ f64::from(target_bounds.x),
+ f64::from(target_bounds.right()),
+ f64::from(metrics.scroll_offset.x),
+ f64::from(metrics.client_size.width),
+ params.horizontal,
+ )
+ };
+ let desired_y = if params.center_if_fully_hidden {
+ scroll_axis_to_expose(
+ f64::from(target_bounds.y),
+ f64::from(target_bounds.bottom()),
+ f64::from(metrics.scroll_offset.y),
+ f64::from(metrics.client_size.height),
+ )
+ } else {
+ aligned_scroll_position(
+ f64::from(target_bounds.y),
+ f64::from(target_bounds.bottom()),
+ f64::from(metrics.scroll_offset.y),
+ f64::from(metrics.client_size.height),
+ params.vertical,
+ )
+ };
+ let target_x = desired_x.clamp(
+ f64::from(metrics.minimum_scroll_offset.x),
+ f64::from(metrics.maximum_scroll_offset.x),
+ );
+ let target_y = desired_y.clamp(
+ f64::from(metrics.minimum_scroll_offset.y),
+ f64::from(metrics.maximum_scroll_offset.y),
+ );
+ let delta_x = target_x - f64::from(metrics.scroll_offset.x);
+ let delta_y = target_y - f64::from(metrics.scroll_offset.y);
+ if delta_x == 0.0 && delta_y == 0.0 {
+ continue;
+ }
+ let container_document = unsafe { &*runtime_ptr }
+ .dom_host()
+ .owner_document_handle(container.source);
+ let is_document_scroller = container_document.is_some_and(|document| {
+ unsafe { &*runtime_ptr }
+ .dom_host()
+ .dom()
+ .document_element_handle_for_document(document)
+ == Some(container.source)
+ });
+ if is_document_scroller {
+ changed |= apply_observable_window_scroll(
+ scope,
+ runtime_ptr,
+ container.source,
+ target_x,
+ target_y,
+ f64::from(metrics.scroll_offset.x),
+ f64::from(metrics.scroll_offset.y),
+ );
+ } else {
+ set_node_scroll_position(
+ scope,
+ runtime_ptr,
+ container.source,
+ target_x,
+ target_y,
+ true,
+ );
+ changed = true;
+ }
+ translate_quads_for_scroll(
+ &mut geometry.target_rects,
+ metrics.scrollport,
+ metrics.client_size,
+ delta_x,
+ delta_y,
+ );
+ }
+ if frame_depth >= CHILD_FRAME_DEPTH_LIMIT {
+ return Ok(changed);
+ }
+ let Some(document) = target_document else {
+ return Ok(changed);
+ };
+ let runtime = unsafe { &*runtime_ptr };
+ if document == runtime.document_handle() {
+ return Ok(changed);
+ }
+ let Some(frame) = runtime.child_browsing_context_host_for_document_handle(document) else {
+ return Ok(changed);
+ };
+ let Some(frame_content) = observable_box_model(
+ runtime,
+ frame,
+ moli_layout::LayoutFlushReason::SynchronousGeometry,
+ )?
+ .map(|model| model.content) else {
+ return Ok(changed);
+ };
+ let Some(parent_target_rects) = convert_quads_to_parent_frame(
+ &geometry.target_rects,
+ runtime.layout_viewport_for_document(document),
+ frame_content,
+ ) else {
+ return Ok(changed);
+ };
+ let Some(mut parent_geometry) = observable_scroll_into_view_geometry(
+ runtime,
+ frame,
+ moli_layout::LayoutFlushReason::SynchronousGeometry,
+ )?
+ else {
+ return Ok(changed);
+ };
+ parent_geometry.target_rects = parent_target_rects;
+ let parent_params = ScrollIntoViewParams {
+ horizontal: ScrollIntoViewAlignment::Nearest,
+ vertical: ScrollIntoViewAlignment::Nearest,
+ ..params
+ };
+ changed |= perform_bubbling_scroll_into_view(
+ scope,
+ runtime_ptr,
+ frame,
+ parent_geometry,
+ parent_params,
+ frame_depth + 1,
+ )?;
+ Ok(changed)
+}
+
+/// Convert a rectangle carried by a child frame into the parent document's
+/// viewport coordinates. This mirrors Blink's cross-frame scroll bubbling:
+/// the target rectangle is converted through the frame owner's content box,
+/// rather than replacing it with the bounds of the whole frame.
+fn convert_quads_to_parent_frame(
+ child_quads: &[moli_layout::LayoutQuad],
+ child_viewport: moli_layout::LayoutViewport,
+ parent_content: moli_layout::LayoutQuad,
+) -> Option<Vec<moli_layout::LayoutQuad>> {
+ let width = child_viewport.css_width as f32;
+ let height = child_viewport.css_height as f32;
+ if width <= 0.0 || height <= 0.0 {
+ return None;
+ }
+ let [origin, x_corner, _, y_corner] = parent_content.points;
+ let x_basis = moli_layout::LayoutPoint::new(x_corner.x - origin.x, x_corner.y - origin.y);
+ let y_basis = moli_layout::LayoutPoint::new(y_corner.x - origin.x, y_corner.y - origin.y);
+ Some(
+ child_quads
+ .iter()
+ .map(|quad| moli_layout::LayoutQuad {
+ points: quad.points.map(|point| {
+ let u = point.x / width;
+ let v = point.y / height;
+ moli_layout::LayoutPoint::new(
+ origin.x + x_basis.x * u + y_basis.x * v,
+ origin.y + x_basis.y * u + y_basis.y * v,
+ )
+ }),
+ })
+ .collect(),
+ )
+}
+
+fn quads_bounding_rect(quads: &[moli_layout::LayoutQuad]) -> Option<moli_layout::LayoutRect> {
+ quads
+ .iter()
+ .map(|quad| quad.bounding_rect())
+ .reduce(moli_layout::LayoutRect::union)
+}
+
+fn target_bounds_in_scroll_content(
+ target_quads: &[moli_layout::LayoutQuad],
+ metrics: &moli_layout::LayoutElementMetrics<DomHandle>,
+) -> Option<moli_layout::LayoutRect> {
+ let mut min_x = f64::INFINITY;
+ let mut min_y = f64::INFINITY;
+ let mut max_x = f64::NEG_INFINITY;
+ let mut max_y = f64::NEG_INFINITY;
+ for point in target_quads.iter().flat_map(|quad| quad.points) {
+ let local =
+ map_viewport_point_to_scrollport(point, metrics.scrollport, metrics.client_size)?;
+ let x = local.0 + f64::from(metrics.scroll_offset.x);
+ let y = local.1 + f64::from(metrics.scroll_offset.y);
+ min_x = min_x.min(x);
+ min_y = min_y.min(y);
+ max_x = max_x.max(x);
+ max_y = max_y.max(y);
+ }
+ [min_x, min_y, max_x, max_y]
+ .into_iter()
+ .all(f64::is_finite)
+ .then(|| {
+ moli_layout::LayoutRect::new(
+ min_x as f32,
+ min_y as f32,
+ (max_x - min_x).max(0.0) as f32,
+ (max_y - min_y).max(0.0) as f32,
+ )
+ })
+}
+
+fn map_viewport_point_to_scrollport(
+ point: moli_layout::LayoutPoint,
+ scrollport: moli_layout::LayoutQuad,
+ size: moli_layout::LayoutSize,
+) -> Option<(f64, f64)> {
+ let [origin, x_corner, _, y_corner] = scrollport.points;
+ let x_basis = (
+ f64::from(x_corner.x - origin.x),
+ f64::from(x_corner.y - origin.y),
+ );
+ let y_basis = (
+ f64::from(y_corner.x - origin.x),
+ f64::from(y_corner.y - origin.y),
+ );
+ let relative = (f64::from(point.x - origin.x), f64::from(point.y - origin.y));
+ let determinant = x_basis.0 * y_basis.1 - x_basis.1 * y_basis.0;
+ if !determinant.is_finite() || determinant.abs() <= f64::EPSILON {
+ return None;
+ }
+ let u = (relative.0 * y_basis.1 - relative.1 * y_basis.0) / determinant;
+ let v = (x_basis.0 * relative.1 - x_basis.1 * relative.0) / determinant;
+ Some((u * f64::from(size.width), v * f64::from(size.height)))
+}
+
+fn translate_quads_for_scroll(
+ quads: &mut [moli_layout::LayoutQuad],
+ scrollport: moli_layout::LayoutQuad,
+ size: moli_layout::LayoutSize,
+ delta_x: f64,
+ delta_y: f64,
+) {
+ if size.width <= 0.0 || size.height <= 0.0 {
+ return;
+ }
+ let [origin, x_corner, _, y_corner] = scrollport.points;
+ let shift_x = f64::from(x_corner.x - origin.x) * delta_x / f64::from(size.width)
+ + f64::from(y_corner.x - origin.x) * delta_y / f64::from(size.height);
+ let shift_y = f64::from(x_corner.y - origin.y) * delta_x / f64::from(size.width)
+ + f64::from(y_corner.y - origin.y) * delta_y / f64::from(size.height);
+ for point in quads.iter_mut().flat_map(|quad| quad.points.iter_mut()) {
+ point.x -= shift_x as f32;
+ point.y -= shift_y as f32;
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::{convert_quads_to_parent_frame, scroll_axis_to_expose};
+
+ #[test]
+ fn center_if_needed_returns_the_unclamped_chromium_alignment_position() {
+ let viewport = 100.0;
+ assert_eq!(scroll_axis_to_expose(20.0, 40.0, 0.0, viewport), 0.0);
+ assert_eq!(
+ scroll_axis_to_expose(-20.0, 120.0, 0.0, viewport),
+ 0.0,
+ "a target containing the viewport stays put"
+ );
+ assert_eq!(scroll_axis_to_expose(-10.0, 20.0, 0.0, viewport), -10.0);
+ assert_eq!(scroll_axis_to_expose(90.0, 120.0, 0.0, viewport), 20.0);
+ assert_eq!(scroll_axis_to_expose(200.0, 220.0, 0.0, viewport), 160.0);
+ assert_eq!(scroll_axis_to_expose(0.0, 20.0, 200.0, viewport), -40.0);
+ }
+
+ #[test]
+ fn child_viewport_rect_maps_through_the_parent_content_quad() {
+ let child_quad = moli_layout::LayoutTransform2D::IDENTITY
+ .map_rect(moli_layout::LayoutRect::new(50.0, 25.0, 100.0, 50.0));
+ let parent_content = moli_layout::LayoutQuad {
+ points: [
+ moli_layout::LayoutPoint::new(10.0, 20.0),
+ moli_layout::LayoutPoint::new(110.0, 40.0),
+ moli_layout::LayoutPoint::new(90.0, 100.0),
+ moli_layout::LayoutPoint::new(-10.0, 80.0),
+ ],
+ };
+
+ let mapped = convert_quads_to_parent_frame(
+ &[child_quad],
+ moli_layout::LayoutViewport::new(200, 100, 1.0),
+ parent_content,
+ )
+ .expect("non-empty child viewport should map");
+
+ assert_eq!(
+ mapped[0].points,
+ [
+ moli_layout::LayoutPoint::new(30.0, 40.0),
+ moli_layout::LayoutPoint::new(80.0, 50.0),
+ moli_layout::LayoutPoint::new(70.0, 80.0),
+ moli_layout::LayoutPoint::new(20.0, 70.0),
+ ]
+ );
+ }
+
+ #[test]
+ fn empty_child_viewport_cannot_produce_parent_geometry() {
+ let child_quad = moli_layout::LayoutTransform2D::IDENTITY
+ .map_rect(moli_layout::LayoutRect::new(0.0, 0.0, 10.0, 10.0));
+ let parent_content = moli_layout::LayoutTransform2D::IDENTITY
+ .map_rect(moli_layout::LayoutRect::new(0.0, 0.0, 10.0, 10.0));
+
+ assert!(
+ convert_quads_to_parent_frame(
+ &[child_quad],
+ moli_layout::LayoutViewport::new(0, 100, 1.0),
+ parent_content,
+ )
+ .is_none()
+ );
+ }
+}