layout: Account for transform in scrollable overflow (#36138)

In the scrollable overflow calcutation, apply CSS transforms to boxes
and scrollable overflow of the descendant. Clip unreachable scrollable
overflow according to it's block start and inline start scrolling
direction. And, renamed `Fragment::scrolling_overflow` to
`Fragment::scrolling_overflow_for_parent` as it was calculating the
scrolling overflow contribution from a child.

Add several WPT tests, testing the transform interaction `rotate`,
`scale`, and `skew` with scrollable overflow. There are several WPT test
that are testing the interaction that not expected from current browsers
implementation according to the spec.

Testing: Existing and new WPT. 
Fixes: #36031

---------

Signed-off-by: stevennovaryo <steven.novaryo@gmail.com>

components/layout/display_list/mod.rs

@@ -39,7 +39,7 @@ use webrender_api::{
 use wr::units::LayoutVector2D;
 
 use crate::context::{LayoutContext, ResolvedImage};
-use crate::display_list::conversions::ToWebRender;
+pub use crate::display_list::conversions::ToWebRender;
 use crate::display_list::stacking_context::StackingContextSection;
 use crate::fragment_tree::{
     BackgroundMode, BoxFragment, Fragment, FragmentFlags, FragmentTree, SpecificLayoutInfo, Tag,
@@ -711,7 +711,12 @@ impl<'a> BuilderForBoxFragment<'a> {
 
     fn build(&mut self, builder: &mut DisplayListBuilder, section: StackingContextSection) {
         if self.is_hit_test_for_scrollable_overflow {
-            self.build_hit_test(builder, self.fragment.scrollable_overflow().to_webrender());
+            self.build_hit_test(
+                builder,
+                self.fragment
+                    .reachable_scrollable_overflow_region()
+                    .to_webrender(),
+            );
             return;
         }
 

components/layout/display_list/stacking_context.rs

@@ -1477,7 +1477,7 @@ impl BoxFragment {
             y: overflow.y.into(),
         };
 
-        let content_rect = self.scrollable_overflow().to_webrender();
+        let content_rect = self.reachable_scrollable_overflow_region().to_webrender();
 
         let scroll_tree_node_id = display_list.define_scroll_frame(
             parent_scroll_node_id,

components/layout/flow/root.rs

@@ -411,7 +411,7 @@ impl BoxTree {
         let scrollable_overflow = root_fragments
             .iter()
             .fold(PhysicalRect::zero(), |acc, child| {
-                let child_overflow = child.scrollable_overflow();
+                let child_overflow = child.scrollable_overflow_for_parent();
 
                 // https://drafts.csswg.org/css-overflow/#scrolling-direction
                 // We want to clip scrollable overflow on box-start and inline-start

components/layout/fragment_tree/box_fragment.rs

@@ -2,11 +2,12 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use app_units::Au;
+use app_units::{Au, MAX_AU, MIN_AU};
 use atomic_refcell::AtomicRefCell;
 use base::print_tree::PrintTree;
 use malloc_size_of_derive::MallocSizeOf;
 use servo_arc::Arc as ServoArc;
+use servo_geometry::f32_rect_to_au_rect;
 use style::Zero;
 use style::computed_values::border_collapse::T as BorderCollapse;
 use style::computed_values::overflow_x::T as ComputedOverflow;
@@ -16,6 +17,7 @@ use style::properties::ComputedValues;
 use style::values::specified::box_::DisplayOutside;
 
 use super::{BaseFragment, BaseFragmentInfo, CollapsedBlockMargins, Fragment};
+use crate::display_list::ToWebRender;
 use crate::formatting_contexts::Baselines;
 use crate::geom::{
     AuOrAuto, LengthPercentageOrAuto, PhysicalPoint, PhysicalRect, PhysicalSides, ToLogical,
@@ -116,7 +118,7 @@ impl BoxFragment {
     ) -> BoxFragment {
         let scrollable_overflow_from_children =
             children.iter().fold(PhysicalRect::zero(), |acc, child| {
-                acc.union(&child.scrollable_overflow())
+                acc.union(&child.scrollable_overflow_for_parent())
             });
 
         BoxFragment {
@@ -267,32 +269,98 @@ impl BoxFragment {
 
     pub fn scrollable_overflow_for_parent(&self) -> PhysicalRect<Au> {
         let mut overflow = self.border_rect();
-        if self.style.establishes_scroll_container(self.base.flags) {
-            return overflow;
+        if !self.style.establishes_scroll_container(self.base.flags) {
+            // https://www.w3.org/TR/css-overflow-3/#scrollable
+            // Only include the scrollable overflow of a child box if it has overflow: visible.
+            let scrollable_overflow = self.scrollable_overflow();
+            let bottom_right = PhysicalPoint::new(
+                overflow.max_x().max(scrollable_overflow.max_x()),
+                overflow.max_y().max(scrollable_overflow.max_y()),
+            );
+
+            let overflow_style = self.style.effective_overflow(self.base.flags);
+            if overflow_style.y == ComputedOverflow::Visible {
+                overflow.origin.y = overflow.origin.y.min(scrollable_overflow.origin.y);
+                overflow.size.height = bottom_right.y - overflow.origin.y;
+            }
+
+            if overflow_style.x == ComputedOverflow::Visible {
+                overflow.origin.x = overflow.origin.x.min(scrollable_overflow.origin.x);
+                overflow.size.width = bottom_right.x - overflow.origin.x;
+            }
         }
 
-        // https://www.w3.org/TR/css-overflow-3/#scrollable
-        // Only include the scrollable overflow of a child box if it has overflow: visible.
-        let scrollable_overflow = self.scrollable_overflow();
-        let bottom_right = PhysicalPoint::new(
-            overflow.max_x().max(scrollable_overflow.max_x()),
-            overflow.max_y().max(scrollable_overflow.max_y()),
-        );
-
-        let overflow_style = self.style.effective_overflow(self.base.flags);
-        if overflow_style.y == ComputedOverflow::Visible {
-            overflow.origin.y = overflow.origin.y.min(scrollable_overflow.origin.y);
-            overflow.size.height = bottom_right.y - overflow.origin.y;
-        }
-
-        if overflow_style.x == ComputedOverflow::Visible {
-            overflow.origin.x = overflow.origin.x.min(scrollable_overflow.origin.x);
-            overflow.size.width = bottom_right.x - overflow.origin.x;
+        // <https://drafts.csswg.org/css-overflow-3/#scrollable-overflow-region>
+        // > ...accounting for transforms by projecting each box onto the plane of
+        // > the element that establishes its 3D rendering context. [CSS3-TRANSFORMS]
+        // Both boxes and its scrollable overflow (if it is included) should be transformed accordingly.
+        //
+        // TODO(stevennovaryo): We are supposed to handle perspective transform and 3d context, but it is yet to happen.
+        if self
+            .style
+            .has_effective_transform_or_perspective(self.base.flags)
+        {
+            if let Some(transform) =
+                self.calculate_transform_matrix(&self.border_rect().to_untyped())
+            {
+                if let Some(transformed_overflow_box) =
+                    transform.outer_transformed_rect(&overflow.to_webrender().to_rect())
+                {
+                    overflow =
+                        f32_rect_to_au_rect(transformed_overflow_box.to_untyped()).cast_unit();
+                }
+            }
         }
 
         overflow
     }
 
+    /// <https://drafts.csswg.org/css-overflow/#unreachable-scrollable-overflow-region>
+    /// > area beyond the scroll origin in either axis is considered the unreachable scrollable overflow region
+    ///
+    /// Return the clipped the scrollable overflow based on its scroll origin, determined by overflow direction.
+    /// For an element, the clip rect is the padding rect and for viewport, it is the initial containing block.
+    pub fn clip_unreachable_scrollable_overflow_region(
+        &self,
+        scrollable_overflow: PhysicalRect<Au>,
+        clipping_rect: PhysicalRect<Au>,
+    ) -> PhysicalRect<Au> {
+        let scrolling_direction = self.style.overflow_direction();
+        let mut scrollable_overflow_box = scrollable_overflow.to_box2d();
+        let mut clipping_box = clipping_rect.to_box2d();
+
+        if scrolling_direction.rightward {
+            clipping_box.max.x = MAX_AU;
+        } else {
+            clipping_box.min.x = MIN_AU;
+        }
+
+        if scrolling_direction.downward {
+            clipping_box.max.y = MAX_AU;
+        } else {
+            clipping_box.min.y = MIN_AU;
+        }
+
+        scrollable_overflow_box = scrollable_overflow_box.intersection_unchecked(&clipping_box);
+
+        match scrollable_overflow_box.is_negative() {
+            true => PhysicalRect::zero(),
+            false => scrollable_overflow_box.to_rect(),
+        }
+    }
+
+    /// <https://drafts.csswg.org/css-overflow/#unreachable-scrollable-overflow-region>
+    /// > area beyond the scroll origin in either axis is considered the unreachable scrollable overflow region
+    ///
+    /// Return the clipped the scrollable overflow based on its scroll origin, determined by overflow direction.
+    /// This will coincides with the scrollport if the fragment is a scroll container.
+    pub fn reachable_scrollable_overflow_region(&self) -> PhysicalRect<Au> {
+        self.clip_unreachable_scrollable_overflow_region(
+            self.scrollable_overflow(),
+            self.padding_rect(),
+        )
+    }
+
     pub(crate) fn calculate_resolved_insets_if_positioned(&self) -> PhysicalSides<AuOrAuto> {
         let position = self.style.get_box().position;
         debug_assert_ne!(

components/layout/fragment_tree/fragment.rs

@@ -170,17 +170,28 @@ impl Fragment {
         }
     }
 
-    pub fn scrolling_area(&self) -> PhysicalRect<Au> {
+    pub fn unclipped_scrolling_area(&self) -> PhysicalRect<Au> {
         match self {
             Fragment::Box(fragment) | Fragment::Float(fragment) => {
                 let fragment = fragment.borrow();
                 fragment.offset_by_containing_block(&fragment.scrollable_overflow())
             },
-            _ => self.scrollable_overflow(),
+            _ => self.scrollable_overflow_for_parent(),
         }
     }
 
-    pub fn scrollable_overflow(&self) -> PhysicalRect<Au> {
+    pub fn scrolling_area(&self) -> PhysicalRect<Au> {
+        match self {
+            Fragment::Box(fragment) | Fragment::Float(fragment) => {
+                let fragment = fragment.borrow();
+                fragment
+                    .offset_by_containing_block(&fragment.reachable_scrollable_overflow_region())
+            },
+            _ => self.scrollable_overflow_for_parent(),
+        }
+    }
+
+    pub fn scrollable_overflow_for_parent(&self) -> PhysicalRect<Au> {
         match self {
             Fragment::Box(fragment) | Fragment::Float(fragment) => {
                 fragment.borrow().scrollable_overflow_for_parent()

components/layout/fragment_tree/fragment_tree.rs

@@ -138,11 +138,26 @@ impl FragmentTree {
             .find_map(|child| child.find(&info, 0, &mut process_func))
     }
 
+    /// <https://drafts.csswg.org/cssom-view/#scrolling-area>
+    ///
+    /// Scrolling area for a viewport that is clipped according to overflow direction of root element.
     pub fn get_scrolling_area_for_viewport(&self) -> PhysicalRect<Au> {
         let mut scroll_area = self.initial_containing_block;
-        for fragment in self.root_fragments.iter() {
-            scroll_area = fragment.scrolling_area().union(&scroll_area);
+        if let Some(root_fragment) = self.root_fragments.first() {
+            for fragment in self.root_fragments.iter() {
+                scroll_area = fragment.unclipped_scrolling_area().union(&scroll_area);
+            }
+            match root_fragment {
+                Fragment::Box(fragment) | Fragment::Float(fragment) => fragment
+                    .borrow()
+                    .clip_unreachable_scrollable_overflow_region(
+                        scroll_area,
+                        self.initial_containing_block,
+                    ),
+                _ => scroll_area,
+            }
+        } else {
+            scroll_area
         }
-        scroll_area
     }
 }

components/layout/fragment_tree/positioning_fragment.rs

@@ -56,7 +56,7 @@ impl PositioningFragment {
         let scrollable_overflow = children.iter().fold(PhysicalRect::zero(), |acc, child| {
             acc.union(
                 &child
-                    .scrollable_overflow()
+                    .scrollable_overflow_for_parent()
                     .translate(content_origin.to_vector()),
             )
         });

components/layout/style_ext.rs

@@ -12,7 +12,7 @@ use style::computed_values::mix_blend_mode::T as ComputedMixBlendMode;
 use style::computed_values::position::T as ComputedPosition;
 use style::computed_values::transform_style::T as ComputedTransformStyle;
 use style::computed_values::unicode_bidi::T as UnicodeBidi;
-use style::logical_geometry::{Direction as AxisDirection, WritingMode};
+use style::logical_geometry::{Direction as AxisDirection, PhysicalSide, WritingMode};
 use style::properties::ComputedValues;
 use style::properties::longhands::backface_visibility::computed_value::T as BackfaceVisiblity;
 use style::properties::longhands::box_sizing::computed_value::T as BoxSizing;
@@ -280,6 +280,16 @@ impl Default for BorderStyleColor {
     }
 }
 
+/// <https://drafts.csswg.org/cssom-view/#overflow-directions>
+/// > A scrolling box of a viewport or element has two overflow directions,
+/// > which are the block-end and inline-end directions for that viewport or element.
+pub(crate) struct OverflowDirection {
+    /// Whether block-end or inline-end direction is [PhysicalSide::Right].
+    pub rightward: bool,
+    /// Whether block-end or inline-end direction is [PhysicalSide::Bottom].
+    pub downward: bool,
+}
+
 pub(crate) trait ComputedValuesExt {
     fn physical_box_offsets(&self) -> PhysicalSides<LengthPercentageOrAuto<'_>>;
     fn box_offsets(&self, writing_mode: WritingMode) -> LogicalSides<LengthPercentageOrAuto<'_>>;
@@ -354,6 +364,7 @@ pub(crate) trait ComputedValuesExt {
         writing_mode: WritingMode,
     ) -> bool;
     fn is_inline_box(&self, fragment_flags: FragmentFlags) -> bool;
+    fn overflow_direction(&self) -> OverflowDirection;
 }
 
 impl ComputedValuesExt for ComputedValues {
@@ -980,6 +991,23 @@ impl ComputedValuesExt for ComputedValues {
         };
         has_percentage(box_offsets.block_start) || has_percentage(box_offsets.block_end)
     }
+
+    // <https://drafts.csswg.org/cssom-view/#overflow-directions>
+    fn overflow_direction(&self) -> OverflowDirection {
+        let inline_end_direction = self.writing_mode.inline_end_physical_side();
+        let block_end_direction = self.writing_mode.block_end_physical_side();
+
+        let rightward = inline_end_direction == PhysicalSide::Right ||
+            block_end_direction == PhysicalSide::Right;
+        let downward = inline_end_direction == PhysicalSide::Bottom ||
+            block_end_direction == PhysicalSide::Bottom;
+
+        // TODO(stevennovaryo): We should consider the flex-container's CSS (e.g. flow-direction: column-reverse).
+        OverflowDirection {
+            rightward,
+            downward,
+        }
+    }
 }
 
 pub(crate) enum LayoutStyle<'a> {