From 811c08c5a524769b07267180fc50171f9a985fb1 Mon Sep 17 00:00:00 2001
From: Martin Robinson <mrobinson@igalia.com>
Date: Mon, 23 Mar 2020 10:04:41 +0100
Subject: [PATCH] layout_2020: Use the containing block more when calculating
 scrolling overflow

When calculating scrolling overflow calculation we cannot currently use
the actual containing block in all cases. This change increases the
amount that we do use the containing block.
---
 .../display_list/stacking_context.rs          |  3 +-
 components/layout_2020/flow/root.rs           |  2 +-
 components/layout_2020/fragments.rs           | 31 ++++++++++++-------
 3 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/components/layout_2020/display_list/stacking_context.rs b/components/layout_2020/display_list/stacking_context.rs
index 87a170f499e06..408f1554b2279 100644
--- a/components/layout_2020/display_list/stacking_context.rs
+++ b/components/layout_2020/display_list/stacking_context.rs
@@ -580,7 +580,8 @@ impl BoxFragment {
             builder.current_space_and_clip = builder.wr.define_scroll_frame(
                 &original_scroll_and_clip_info,
                 Some(external_id),
-                self.scrollable_overflow().to_webrender(),
+                self.scrollable_overflow(&containing_block_info.rect)
+                    .to_webrender(),
                 padding_rect,
                 vec![], // complex_clips
                 None,   // image_mask
diff --git a/components/layout_2020/flow/root.rs b/components/layout_2020/flow/root.rs
index 6a8be578630ea..15fb3d9f1ae22 100644
--- a/components/layout_2020/flow/root.rs
+++ b/components/layout_2020/flow/root.rs
@@ -163,7 +163,7 @@ impl BoxTreeRoot {
                 .fragments
                 .iter()
                 .fold(PhysicalRect::zero(), |acc, child| {
-                    let child_overflow = child.scrollable_overflow();
+                    let child_overflow = child.scrollable_overflow(&physical_containing_block);
 
                     // https://drafts.csswg.org/css-overflow/#scrolling-direction
                     // We want to clip scrollable overflow on box-start and inline-start
diff --git a/components/layout_2020/fragments.rs b/components/layout_2020/fragments.rs
index 3be702bbf844f..8c09c9ffb9a18 100644
--- a/components/layout_2020/fragments.rs
+++ b/components/layout_2020/fragments.rs
@@ -132,10 +132,10 @@ impl Fragment {
         }
     }
 
-    pub fn scrollable_overflow(&self) -> PhysicalRect<Length> {
-        // FIXME(mrobinson, bug 25564): We should be using the containing block
-        // here to properly convert scrollable overflow to physical geometry.
-        let containing_block = PhysicalRect::zero();
+    pub fn scrollable_overflow(
+        &self,
+        containing_block: &PhysicalRect<Length>,
+    ) -> PhysicalRect<Length> {
         match self {
             Fragment::Box(fragment) => fragment.scrollable_overflow_for_parent(&containing_block),
             Fragment::AbsoluteOrFixedPositioned(_) => PhysicalRect::zero(),
@@ -182,11 +182,14 @@ impl AnonymousFragment {
     }
 
     pub fn new(rect: Rect<Length>, children: Vec<Fragment>, mode: WritingMode) -> Self {
+        // FIXME(mrobinson, bug 25564): We should be using the containing block
+        // here to properly convert scrollable overflow to physical geometry.
+        let containing_block = PhysicalRect::zero();
         let content_origin = rect.start_corner.to_physical(mode);
         let scrollable_overflow = children.iter().fold(PhysicalRect::zero(), |acc, child| {
             acc.union(
                 &child
-                    .scrollable_overflow()
+                    .scrollable_overflow(&containing_block)
                     .translate(content_origin.to_vector()),
             )
         });
@@ -226,9 +229,12 @@ impl BoxFragment {
         block_margins_collapsed_with_children: CollapsedBlockMargins,
         hoisted_fragment_id: Option<HoistedFragmentId>,
     ) -> BoxFragment {
+        // FIXME(mrobinson, bug 25564): We should be using the containing block
+        // here to properly convert scrollable overflow to physical geometry.
+        let containing_block = PhysicalRect::zero();
         let scrollable_overflow_from_children =
             children.iter().fold(PhysicalRect::zero(), |acc, child| {
-                acc.union(&child.scrollable_overflow())
+                acc.union(&child.scrollable_overflow(&containing_block))
             });
         BoxFragment {
             tag,
@@ -245,12 +251,13 @@ impl BoxFragment {
         }
     }
 
-    pub fn scrollable_overflow(&self) -> PhysicalRect<Length> {
-        // FIXME(mrobinson, bug 25564): We should be using the containing block
-        // here to properly convert scrollable overflow to physical geometry.
+    pub fn scrollable_overflow(
+        &self,
+        containing_block: &PhysicalRect<Length>,
+    ) -> PhysicalRect<Length> {
         let physical_padding_rect = self
             .padding_rect()
-            .to_physical(self.style.writing_mode, &PhysicalRect::zero());
+            .to_physical(self.style.writing_mode, containing_block);
 
         let content_origin = self
             .content_rect
@@ -284,7 +291,7 @@ impl BoxFragment {
             self.content_rect,
             self.padding_rect(),
             self.border_rect(),
-            self.scrollable_overflow(),
+            self.scrollable_overflow(&PhysicalRect::zero()),
             self.style.get_box().overflow_x,
             self.style.get_box().overflow_y,
             self.style,
@@ -313,7 +320,7 @@ impl BoxFragment {
 
         // 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 scrollable_overflow = self.scrollable_overflow(&containing_block);
         let bottom_right = PhysicalPoint::new(
             overflow.max_x().max(scrollable_overflow.max_x()),
             overflow.max_y().max(scrollable_overflow.max_y()),