Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsnew file mode 100644index 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()+ );+ }+}