[LayoutNG] Pass border_padding into flex-item size calculation calls.

This passes border_padding of the flex-item into the size calculation
calls, instead of border_scrollbar_padding.

Additionally this removes two GetLayoutBox() calls (used to determine)
the scrollbars from within NGFlexLayoutAlgorithm::Layout.

Bug: 845235
Change-Id: Ifddca6db7e25b4c2d8851ffbcbce71b2740cd9e7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1752549Reviewed-by: David Grogan <dgrogan@chromium.org>
Reviewed-by: Christian Biesinger <cbiesinger@chromium.org>
Commit-Queue: Ian Kilpatrick <ikilpatrick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#686643}

third_party/blink/renderer/core/layout/flexible_box_algorithm.cc

@@ -39,7 +39,7 @@ namespace blink {
 FlexItem::FlexItem(LayoutBox* box,
                    LayoutUnit flex_base_content_size,
                    MinMaxSize min_max_sizes,
-                   LayoutUnit main_axis_border_and_padding,
+                   LayoutUnit main_axis_border_padding,
                    LayoutUnit main_axis_margin)
     : algorithm(nullptr),
       line_number(0),
@@ -48,7 +48,7 @@ FlexItem::FlexItem(LayoutBox* box,
       min_max_sizes(min_max_sizes),
       hypothetical_main_content_size(
           min_max_sizes.ClampSizeToMinAndMax(flex_base_content_size)),
-      main_axis_border_and_padding(main_axis_border_and_padding),
+      main_axis_border_padding(main_axis_border_padding),
       main_axis_margin(main_axis_margin),
       frozen(false),
       ng_input_node(/* LayoutBox* */ nullptr) {

third_party/blink/renderer/core/layout/flexible_box_algorithm.h

@@ -77,26 +77,24 @@ class FlexItem {
   FlexItem(LayoutBox*,
            LayoutUnit flex_base_content_size,
            MinMaxSize min_max_sizes,
-           LayoutUnit main_axis_border_and_padding,
+           LayoutUnit main_axis_border_padding,
            LayoutUnit main_axis_margin);
 
   LayoutUnit HypotheticalMainAxisMarginBoxSize() const {
-    return hypothetical_main_content_size + main_axis_border_and_padding +
+    return hypothetical_main_content_size + main_axis_border_padding +
            main_axis_margin;
   }
 
   LayoutUnit FlexBaseMarginBoxSize() const {
-    return flex_base_content_size + main_axis_border_and_padding +
-           main_axis_margin;
+    return flex_base_content_size + main_axis_border_padding + main_axis_margin;
   }
 
   LayoutUnit FlexedBorderBoxSize() const {
-    return flexed_content_size + main_axis_border_and_padding;
+    return flexed_content_size + main_axis_border_padding;
   }
 
   LayoutUnit FlexedMarginBoxSize() const {
-    return flexed_content_size + main_axis_border_and_padding +
-           main_axis_margin;
+    return flexed_content_size + main_axis_border_padding + main_axis_margin;
   }
 
   LayoutUnit ClampSizeToMinAndMax(LayoutUnit size) const {
@@ -132,7 +130,7 @@ class FlexItem {
   const LayoutUnit flex_base_content_size;
   const MinMaxSize min_max_sizes;
   const LayoutUnit hypothetical_main_content_size;
-  const LayoutUnit main_axis_border_and_padding;
+  const LayoutUnit main_axis_border_padding;
   const LayoutUnit main_axis_margin;
   LayoutUnit flexed_content_size;
 

third_party/blink/renderer/core/layout/layout_flexible_box.cc

@@ -1495,7 +1495,7 @@ void LayoutFlexibleBox::LayoutLineItems(FlexLine* current_line,
     // But it turns out that tables ignore the override size, and so we have
     // to re-check the size so that we place the flex item correctly.
     flex_item.flexed_content_size =
-        MainAxisExtentForChild(*child) - flex_item.main_axis_border_and_padding;
+        MainAxisExtentForChild(*child) - flex_item.main_axis_border_padding;
     flex_item.cross_axis_size = CrossAxisUnstretchedExtentForChild(*child);
   }
 }

third_party/blink/renderer/core/layout/ng/ng_flex_layout_algorithm.cc

@@ -167,21 +167,26 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
             .SetPercentageResolutionSize(content_box_size_)
             .ToConstraintSpace();
 
-    NGBoxStrut border_scrollbar_padding_in_child_writing_mode =
+    NGBoxStrut border_padding_in_child_writing_mode =
         ComputeBorders(child_space, child) +
-        ComputeScrollbars(child_space, child) +
         ComputePadding(child_space, child_style);
+    NGBoxStrut border_scrollbar_padding_in_child_writing_mode =
+        border_padding_in_child_writing_mode +
+        ComputeScrollbars(child_space, child);
+
     NGPhysicalBoxStrut physical_border_padding(
+        border_padding_in_child_writing_mode.ConvertToPhysical(
+            child_style.GetWritingMode(), child_style.Direction()));
+    NGPhysicalBoxStrut physical_border_scrollbar_padding(
         border_scrollbar_padding_in_child_writing_mode.ConvertToPhysical(
             child_style.GetWritingMode(), child_style.Direction()));
-    LayoutUnit main_axis_border_scrollbar_padding =
+
+    LayoutUnit main_axis_border_padding =
         is_horizontal_flow_ ? physical_border_padding.HorizontalSum()
                             : physical_border_padding.VerticalSum();
-    LayoutUnit main_axis_border_and_padding =
-        main_axis_border_scrollbar_padding -
-        (is_horizontal_flow_
-             ? child.GetLayoutBox()->VerticalScrollbarWidth()
-             : child.GetLayoutBox()->HorizontalScrollbarHeight());
+    LayoutUnit main_axis_border_scrollbar_padding =
+        is_horizontal_flow_ ? physical_border_scrollbar_padding.HorizontalSum()
+                            : physical_border_scrollbar_padding.VerticalSum();
 
     // We want the child's min/max size in its writing mode, not ours. We'll
     // only ever use it if the child's inline axis is our main axis.
@@ -220,16 +225,14 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
 
       if (MainAxisIsInlineAxis(child)) {
         flex_base_border_box = ResolveMainInlineLength(
-            child_space, child_style,
-            border_scrollbar_padding_in_child_writing_mode,
+            child_space, child_style, border_padding_in_child_writing_mode,
             intrinsic_sizes_border_box, length_to_resolve);
       } else {
         // Flex container's main axis is in child's block direction. Child's
         // flex basis is in child's block direction.
         flex_base_border_box = ResolveMainBlockLength(
-            child_space, child_style,
-            border_scrollbar_padding_in_child_writing_mode, length_to_resolve,
-            fragment_in_child_writing_mode.BlockSize(),
+            child_space, child_style, border_padding_in_child_writing_mode,
+            length_to_resolve, fragment_in_child_writing_mode.BlockSize(),
             LengthResolvePhase::kLayout);
       }
     }
@@ -239,7 +242,7 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
     // Blink's FlexibleBoxAlgorithm expects it to be content + scrollbar widths,
     // but no padding or border.
     LayoutUnit flex_base_content_size =
-        flex_base_border_box - main_axis_border_and_padding;
+        flex_base_border_box - main_axis_border_padding;
 
     NGPhysicalBoxStrut physical_child_margins =
         ComputePhysicalMargins(child_space, child_style);
@@ -254,14 +257,12 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
                                                   : child.Style().MaxHeight();
     if (MainAxisIsInlineAxis(child)) {
       min_max_sizes_in_main_axis_direction.max_size = ResolveMaxInlineLength(
-          child_space, child_style,
-          border_scrollbar_padding_in_child_writing_mode,
+          child_space, child_style, border_padding_in_child_writing_mode,
           intrinsic_sizes_border_box, max_property_in_main_axis,
           LengthResolvePhase::kLayout);
     } else {
       min_max_sizes_in_main_axis_direction.max_size = ResolveMaxBlockLength(
-          child_space, child_style,
-          border_scrollbar_padding_in_child_writing_mode,
+          child_space, child_style, border_padding_in_child_writing_mode,
           max_property_in_main_axis, fragment_in_child_writing_mode.BlockSize(),
           LengthResolvePhase::kLayout);
     }
@@ -290,8 +291,7 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
             // resolved specified_length_in_main_axis in the flex basis
             // calculation. Reuse that if possible.
             specified_size_suggestion = ResolveMainInlineLength(
-                child_space, child_style,
-                border_scrollbar_padding_in_child_writing_mode,
+                child_space, child_style, border_padding_in_child_writing_mode,
                 intrinsic_sizes_border_box, specified_length_in_main_axis);
           }
         } else if (!specified_length_in_main_axis.IsAuto() &&
@@ -299,8 +299,7 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
                                             specified_length_in_main_axis,
                                             LengthResolvePhase::kLayout)) {
           specified_size_suggestion = ResolveMainBlockLength(
-              child_space, child_style,
-              border_scrollbar_padding_in_child_writing_mode,
+              child_space, child_style, border_padding_in_child_writing_mode,
               specified_length_in_main_axis,
               layout_result->IntrinsicBlockSize(), LengthResolvePhase::kLayout);
           DCHECK_NE(specified_size_suggestion, kIndefiniteSize);
@@ -317,18 +316,17 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
       }
     } else if (MainAxisIsInlineAxis(child)) {
       min_max_sizes_in_main_axis_direction.min_size =
-          ResolveMinInlineLength(child_space, child_style,
-                                 border_scrollbar_padding_in_child_writing_mode,
-                                 intrinsic_sizes_border_box, min,
-                                 LengthResolvePhase::kLayout) -
+          ResolveMinInlineLength(
+              child_space, child_style, border_padding_in_child_writing_mode,
+              intrinsic_sizes_border_box, min, LengthResolvePhase::kLayout) -
           main_axis_border_scrollbar_padding;
       // TODO(dgrogan): No tests changed status as result of subtracting
       // main_axis_border_scrollbar_padding. It may be untested.
     } else {
       min_max_sizes_in_main_axis_direction.min_size =
           ResolveMinBlockLength(child_space, child_style,
-                                border_scrollbar_padding_in_child_writing_mode,
-                                min, fragment_in_child_writing_mode.BlockSize(),
+                                border_padding_in_child_writing_mode, min,
+                                fragment_in_child_writing_mode.BlockSize(),
                                 LengthResolvePhase::kLayout) -
           main_axis_border_scrollbar_padding;
       // TODO(dgrogan): Same as above WRT subtracting
@@ -338,7 +336,7 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
     algorithm_
         ->emplace_back(child.GetLayoutBox(), flex_base_content_size,
                        min_max_sizes_in_main_axis_direction,
-                       main_axis_border_and_padding, main_axis_margin)
+                       main_axis_border_padding, main_axis_margin)
         .ng_input_node = child;
   }
 }
@@ -383,15 +381,15 @@ scoped_refptr<const NGLayoutResult> NGFlexLayoutAlgorithm::Layout() {
       LogicalSize available_size;
       if (is_column_) {
         available_size.inline_size = content_box_size_.inline_size;
-        available_size.block_size = flex_item.flexed_content_size +
-                                    flex_item.main_axis_border_and_padding;
+        available_size.block_size =
+            flex_item.flexed_content_size + flex_item.main_axis_border_padding;
         space_builder.SetIsFixedBlockSize(true);
         // TODO(dgrogan): Set IsFixedBlockSizeIndefinite if neither the item's
         // nor container's main size is definite. (The latter being exception 2
         // from https://drafts.csswg.org/css-flexbox/#definite-sizes )
       } else {
-        available_size.inline_size = flex_item.flexed_content_size +
-                                     flex_item.main_axis_border_and_padding;
+        available_size.inline_size =
+            flex_item.flexed_content_size + flex_item.main_axis_border_padding;
         available_size.block_size = content_box_size_.block_size;
         space_builder.SetIsFixedInlineSize(true);
       }
@@ -468,9 +466,9 @@ void NGFlexLayoutAlgorithm::GiveLinesAndItemsFinalPositionAndSize() {
         SetOrthogonalFallbackInlineSizeIfNeeded(
             Style(), flex_item.ng_input_node, &space_builder);
 
-        LogicalSize available_size(flex_item.flexed_content_size +
-                                       flex_item.main_axis_border_and_padding,
-                                   flex_item.cross_axis_size);
+        LogicalSize available_size(
+            flex_item.flexed_content_size + flex_item.main_axis_border_padding,
+            flex_item.cross_axis_size);
         if (is_column_) {
           available_size.Transpose();
           // TODO(dgrogan): Set IsFixedBlockSizeIndefinite if neither the item's

third_party/blink/web_tests/TestExpectations

@@ -2001,7 +2001,6 @@ crbug.com/336604 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/fle
 crbug.com/336604 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/flexbox_visibility-collapse.html [ Failure ]
 crbug.com/591099 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/flexbox_wrap-reverse.html [ Failure ]
 crbug.com/467127 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/negative-margins-001.html [ Failure ]
-crbug.com/972227 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/overflow-auto-001.html [ Failure ]
 crbug.com/591099 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/order_value.html [ Failure ]
 crbug.com/591099 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/overflow-top-left.html [ Failure ]
 crbug.com/467127 virtual/layout_ng_experimental/external/wpt/css/css-flexbox/percentage-heights-003.html [ Failure ]