Revert "[css-flexbox] Move ComputeLineItemsPosition to FlexLine"

This reverts r490644 (commit 65b35725).
Caused certain websites (such as permission.site) to not render at all.

Bug: 750553, 750546
Change-Id: I4233a2e16b8145e5a486e45b6c585ad54b0f4f7d
Tbr: cbiesinger@chromium.org
Reviewed-on: https://chromium-review.googlesource.com/593608
Commit-Queue: Emil A Eklund <eae@chromium.org>
Reviewed-by: Emil A Eklund <eae@chromium.org>
Cr-Commit-Position: refs/heads/master@{#490748}

third_party/WebKit/Source/core/layout/FlexibleBoxAlgorithm.cpp

@@ -122,22 +122,6 @@ ItemPosition FlexItem::Alignment() const {
                                                 box->StyleRef());
 }
 
-void FlexItem::UpdateAutoMarginsInMainAxis(LayoutUnit auto_margin_offset) {
-  DCHECK_GE(auto_margin_offset, LayoutUnit());
-
-  if (algorithm->IsHorizontalFlow()) {
-    if (box->Style()->MarginLeft().IsAuto())
-      box->SetMarginLeft(auto_margin_offset);
-    if (box->Style()->MarginRight().IsAuto())
-      box->SetMarginRight(auto_margin_offset);
-  } else {
-    if (box->Style()->MarginTop().IsAuto())
-      box->SetMarginTop(auto_margin_offset);
-    if (box->Style()->MarginBottom().IsAuto())
-      box->SetMarginBottom(auto_margin_offset);
-  }
-}
-
 void FlexLine::FreezeViolations(Vector<FlexItem*>& violations) {
   for (size_t i = 0; i < violations.size(); ++i) {
     DCHECK(!violations[i]->frozen) << i;
@@ -281,82 +265,6 @@ LayoutUnit FlexLine::ApplyMainAxisAutoMarginAdjustment() {
   return size_of_auto_margin;
 }
 
-void FlexLine::ComputeLineItemsPosition(LayoutUnit main_axis_offset,
-                                        LayoutUnit& cross_axis_offset) {
-  // Recalculate the remaining free space. The adjustment for flex factors
-  // between 0..1 means we can't just use remainingFreeSpace here.
-  remaining_free_space = container_main_inner_size;
-  for (size_t i = 0; i < line_items.size(); ++i) {
-    FlexItem& flex_item = line_items[i];
-    DCHECK(!flex_item.box->IsOutOfFlowPositioned());
-    remaining_free_space -= flex_item.FlexedMarginBoxSize();
-  }
-
-  const StyleContentAlignmentData justify_content =
-      FlexLayoutAlgorithm::ResolvedJustifyContent(*algorithm->Style());
-
-  LayoutUnit auto_margin_offset = ApplyMainAxisAutoMarginAdjustment();
-  const LayoutUnit available_free_space = remaining_free_space;
-  main_axis_offset += FlexLayoutAlgorithm::InitialContentPositionOffset(
-      available_free_space, justify_content, line_items.size());
-  LayoutUnit max_descent;  // Used when align-items: baseline.
-  LayoutUnit max_child_cross_axis_extent;
-  bool should_flip_main_axis = !algorithm->Style()->IsColumnFlexDirection() &&
-                               !algorithm->IsLeftToRightFlow();
-  for (size_t i = 0; i < line_items.size(); ++i) {
-    FlexItem& flex_item = line_items[i];
-
-    DCHECK(!flex_item.box->IsOutOfFlowPositioned());
-
-    flex_item.UpdateAutoMarginsInMainAxis(auto_margin_offset);
-
-    LayoutUnit child_cross_axis_margin_box_extent;
-    if (flex_item.Alignment() == kItemPositionBaseline &&
-        !flex_item.HasAutoMarginsInCrossAxis()) {
-      LayoutUnit ascent = flex_item.MarginBoxAscent();
-      LayoutUnit descent =
-          (flex_item.CrossAxisMarginExtent() + flex_item.cross_axis_size) -
-          ascent;
-
-      max_ascent = std::max(max_ascent, ascent);
-      max_descent = std::max(max_descent, descent);
-
-      child_cross_axis_margin_box_extent = max_ascent + max_descent;
-    } else {
-      child_cross_axis_margin_box_extent =
-          flex_item.cross_axis_size + flex_item.CrossAxisMarginExtent();
-    }
-    max_child_cross_axis_extent = std::max(max_child_cross_axis_extent,
-                                           child_cross_axis_margin_box_extent);
-
-    main_axis_offset += flex_item.FlowAwareMarginStart();
-
-    LayoutUnit child_main_extent = flex_item.FlexedBorderBoxSize();
-    // In an RTL column situation, this will apply the margin-right/margin-end
-    // on the left. This will be fixed later in flipForRightToLeftColumn.
-    flex_item.desired_location = LayoutPoint(
-        should_flip_main_axis
-            ? container_logical_width - main_axis_offset - child_main_extent
-            : main_axis_offset,
-        cross_axis_offset + flex_item.FlowAwareMarginBefore());
-    main_axis_offset += child_main_extent + flex_item.FlowAwareMarginEnd();
-
-    if (i != line_items.size() - 1) {
-      // The last item does not get extra space added.
-      main_axis_offset +=
-          FlexLayoutAlgorithm::ContentDistributionSpaceBetweenChildren(
-              available_free_space, justify_content, line_items.size());
-    }
-  }
-
-  main_axis_extent = main_axis_offset;
-
-  this->cross_axis_offset = cross_axis_offset;
-  cross_axis_extent = max_child_cross_axis_extent;
-
-  cross_axis_offset += max_child_cross_axis_extent;
-}
-
 FlexLayoutAlgorithm::FlexLayoutAlgorithm(const ComputedStyle* style,
                                          LayoutUnit line_break_length,
                                          Vector<FlexItem>& all_items)
@@ -522,43 +430,4 @@ ItemPosition FlexLayoutAlgorithm::AlignmentForChild(
   return align;
 }
 
-LayoutUnit FlexLayoutAlgorithm::InitialContentPositionOffset(
-    LayoutUnit available_free_space,
-    const StyleContentAlignmentData& data,
-    unsigned number_of_items) {
-  if (data.GetPosition() == kContentPositionFlexEnd)
-    return available_free_space;
-  if (data.GetPosition() == kContentPositionCenter)
-    return available_free_space / 2;
-  if (data.Distribution() == kContentDistributionSpaceAround) {
-    if (available_free_space > 0 && number_of_items)
-      return available_free_space / (2 * number_of_items);
-
-    return available_free_space / 2;
-  }
-  if (data.Distribution() == kContentDistributionSpaceEvenly) {
-    if (available_free_space > 0 && number_of_items)
-      return available_free_space / (number_of_items + 1);
-    // Fallback to 'center'
-    return available_free_space / 2;
-  }
-  return LayoutUnit();
-}
-
-LayoutUnit FlexLayoutAlgorithm::ContentDistributionSpaceBetweenChildren(
-    LayoutUnit available_free_space,
-    const StyleContentAlignmentData& data,
-    unsigned number_of_items) {
-  if (available_free_space > 0 && number_of_items > 1) {
-    if (data.Distribution() == kContentDistributionSpaceBetween)
-      return available_free_space / (number_of_items - 1);
-    if (data.Distribution() == kContentDistributionSpaceAround ||
-        data.Distribution() == kContentDistributionStretch)
-      return available_free_space / number_of_items;
-    if (data.Distribution() == kContentDistributionSpaceEvenly)
-      return available_free_space / (number_of_items + 1);
-  }
-  return LayoutUnit();
-}
-
 }  // namespace blink

third_party/WebKit/Source/core/layout/FlexibleBoxAlgorithm.h

@@ -103,8 +103,6 @@ class FlexItem {
 
   bool HasAutoMarginsInCrossAxis() const;
 
-  void UpdateAutoMarginsInMainAxis(LayoutUnit auto_margin_offset);
-
   FlexLayoutAlgorithm* algorithm;
   LayoutBox* box;
   const LayoutUnit flex_base_content_size;
@@ -165,14 +163,6 @@ class FlexLine {
   // remaining_free_space unchanged.
   LayoutUnit ApplyMainAxisAutoMarginAdjustment();
 
-  // Computes & sets desired_position on the FlexItems on this line.
-  // Before calling this function, the items need to be laid out with
-  // flexed_content_size set as the override main axis size, and
-  // cross_axis_size needs to be set correctly on each flex item (to the size
-  // the item has without stretching).
-  void ComputeLineItemsPosition(LayoutUnit main_axis_offset,
-                                LayoutUnit& cross_axis_offset);
-
   FlexLayoutAlgorithm* algorithm;
   Vector<FlexItem> line_items;
   const LayoutUnit container_logical_width;
@@ -203,29 +193,6 @@ class FlexLine {
   LayoutUnit max_ascent;
 };
 
-// This class implements the CSS Flexbox layout algorithm:
-//   https://drafts.csswg.org/css-flexbox/
-//
-// Expected usage is as follows:
-//    Vector<FlexItem> flex_items;
-//    for (each child) {
-//       flex_items.emplace_back(...caller must compute these values...)
-//     }
-//     LayoutUnit cross_axis_offset = border + padding;
-//     FlexLayoutAlgorithm algorithm(Style(), MainAxisLength(), flex_items);
-//     while ((FlexLine* line = algorithm.ComputenextLine(LogicalWidth()))) {
-//       // Compute main axis size, using sum_hypothetical_main_size if
-//       // indefinite
-//       line->SetContainerMainInnerSize(MainAxisSize(
-//           line->sum_hypothetical_main_size));
-//        line->FreezeInflexibleItems();
-//        while (!current_line->ResolveFlexibleLengths()) { continue; }
-//        // Now, lay out the items, forcing their main axis size to
-//        // item.flexed_content_size
-//        LayoutUnit main_axis_offset = border + padding + scrollbar;
-//        line->ComputeLineItemsPosition(main_axis_offset, cross_axis_offset);
-//     }
-//     // The final position of each flex item is in item.desired_location
 class FlexLayoutAlgorithm {
   WTF_MAKE_NONCOPYABLE(FlexLayoutAlgorithm);
 
@@ -255,15 +222,6 @@ class FlexLayoutAlgorithm {
   static ItemPosition AlignmentForChild(const ComputedStyle& flexbox_style,
                                         const ComputedStyle& child_style);
 
-  static LayoutUnit InitialContentPositionOffset(
-      LayoutUnit available_free_space,
-      const StyleContentAlignmentData&,
-      unsigned number_of_items);
-  static LayoutUnit ContentDistributionSpaceBetweenChildren(
-      LayoutUnit available_free_space,
-      const StyleContentAlignmentData&,
-      unsigned number_of_items);
-
  private:
   bool IsMultiline() const { return style_->FlexWrap() != EFlexWrap::kNowrap; }
 

third_party/WebKit/Source/core/layout/LayoutFlexibleBox.cpp

@@ -895,12 +895,8 @@ void LayoutFlexibleBox::LayoutFlexItems(bool relayout_children,
                                              : HorizontalScrollbarHeight();
     }
 
-    current_line->ComputeLineItemsPosition(main_axis_offset, cross_axis_offset);
+    ComputeLineItemsPosition(cross_axis_offset, current_line, main_axis_offset);
     ApplyLineItemsPosition(current_line);
-    if (number_of_in_flow_children_on_first_line_ == -1) {
-      number_of_in_flow_children_on_first_line_ =
-          current_line->line_items.size();
-    }
   }
   if (HasLineIfEmpty()) {
     // Even if ComputeNextFlexLine returns true, the flexbox might not have
@@ -916,6 +912,24 @@ void LayoutFlexibleBox::LayoutFlexItems(bool relayout_children,
   RepositionLogicalHeightDependentFlexItems(flex_algorithm.FlexLines());
 }
 
+void LayoutFlexibleBox::UpdateAutoMarginsInMainAxis(
+    LayoutBox& child,
+    LayoutUnit auto_margin_offset) {
+  DCHECK_GE(auto_margin_offset, LayoutUnit());
+
+  if (IsHorizontalFlow()) {
+    if (child.Style()->MarginLeft().IsAuto())
+      child.SetMarginLeft(auto_margin_offset);
+    if (child.Style()->MarginRight().IsAuto())
+      child.SetMarginRight(auto_margin_offset);
+  } else {
+    if (child.Style()->MarginTop().IsAuto())
+      child.SetMarginTop(auto_margin_offset);
+    if (child.Style()->MarginBottom().IsAuto())
+      child.SetMarginBottom(auto_margin_offset);
+  }
+}
+
 bool LayoutFlexibleBox::HasAutoMarginsInCrossAxis(
     const LayoutBox& child) const {
   if (IsHorizontalFlow())
@@ -1190,6 +1204,45 @@ FlexItem LayoutFlexibleBox::ConstructFlexItem(LayoutBox& child,
                   margin);
 }
 
+static LayoutUnit InitialContentPositionOffset(
+    LayoutUnit available_free_space,
+    const StyleContentAlignmentData& data,
+    unsigned number_of_items) {
+  if (data.GetPosition() == kContentPositionFlexEnd)
+    return available_free_space;
+  if (data.GetPosition() == kContentPositionCenter)
+    return available_free_space / 2;
+  if (data.Distribution() == kContentDistributionSpaceAround) {
+    if (available_free_space > 0 && number_of_items)
+      return available_free_space / (2 * number_of_items);
+
+    return available_free_space / 2;
+  }
+  if (data.Distribution() == kContentDistributionSpaceEvenly) {
+    if (available_free_space > 0 && number_of_items)
+      return available_free_space / (number_of_items + 1);
+    // Fallback to 'center'
+    return available_free_space / 2;
+  }
+  return LayoutUnit();
+}
+
+static LayoutUnit ContentDistributionSpaceBetweenChildren(
+    LayoutUnit available_free_space,
+    const StyleContentAlignmentData& data,
+    unsigned number_of_items) {
+  if (available_free_space > 0 && number_of_items > 1) {
+    if (data.Distribution() == kContentDistributionSpaceBetween)
+      return available_free_space / (number_of_items - 1);
+    if (data.Distribution() == kContentDistributionSpaceAround ||
+        data.Distribution() == kContentDistributionStretch)
+      return available_free_space / number_of_items;
+    if (data.Distribution() == kContentDistributionSpaceEvenly)
+      return available_free_space / (number_of_items + 1);
+  }
+  return LayoutUnit();
+}
+
 static LayoutUnit AlignmentOffset(LayoutUnit available_free_space,
                                   ItemPosition position,
                                   LayoutUnit ascent,
@@ -1252,7 +1305,7 @@ LayoutUnit LayoutFlexibleBox::StaticMainAxisPositionForPositionedChild(
       MainAxisContentExtent(ContentLogicalHeight()) -
       MainAxisExtentForChild(child);
 
-  LayoutUnit offset = FlexLayoutAlgorithm::InitialContentPositionOffset(
+  LayoutUnit offset = InitialContentPositionOffset(
       available_space, FlexLayoutAlgorithm::ResolvedJustifyContent(StyleRef()),
       1);
   if (StyleRef().FlexDirection() == EFlexDirection::kRowReverse ||
@@ -1442,8 +1495,91 @@ void LayoutFlexibleBox::LayoutLineItems(FlexLine* current_line,
       relaid_out_children_.insert(child);
     child->LayoutIfNeeded();
 
-    flex_item.cross_axis_size = CrossAxisIntrinsicExtentForChild(*child);
+    flex_item.cross_axis_size = CrossAxisExtentForChild(*child);
+  }
+}
+
+DISABLE_CFI_PERF
+void LayoutFlexibleBox::ComputeLineItemsPosition(LayoutUnit& cross_axis_offset,
+                                                 FlexLine* current_line,
+                                                 LayoutUnit main_axis_offset) {
+  // Recalculate the remaining free space. The adjustment for flex factors
+  // between 0..1 means we can't just use remainingFreeSpace here.
+  current_line->remaining_free_space = current_line->container_main_inner_size;
+  for (size_t i = 0; i < current_line->line_items.size(); ++i) {
+    FlexItem& flex_item = current_line->line_items[i];
+    DCHECK(!flex_item.box->IsOutOfFlowPositioned());
+    current_line->remaining_free_space -= flex_item.FlexedMarginBoxSize();
+  }
+
+  const StyleContentAlignmentData justify_content =
+      FlexLayoutAlgorithm::ResolvedJustifyContent(StyleRef());
+
+  LayoutUnit auto_margin_offset =
+      current_line->ApplyMainAxisAutoMarginAdjustment();
+  const LayoutUnit available_free_space = current_line->remaining_free_space;
+  main_axis_offset += InitialContentPositionOffset(
+      available_free_space, justify_content, current_line->line_items.size());
+  LayoutUnit max_descent;  // Used when align-items: baseline.
+  LayoutUnit max_child_cross_axis_extent;
+  bool should_flip_main_axis = !IsColumnFlow() && !IsLeftToRightFlow();
+  for (size_t i = 0; i < current_line->line_items.size(); ++i) {
+    FlexItem& flex_item = current_line->line_items[i];
+    LayoutBox* child = flex_item.box;
+
+    DCHECK(!flex_item.box->IsOutOfFlowPositioned());
+
+    UpdateAutoMarginsInMainAxis(*child, auto_margin_offset);
+
+    LayoutUnit child_cross_axis_margin_box_extent;
+    if (flex_item.Alignment() == kItemPositionBaseline &&
+        !flex_item.HasAutoMarginsInCrossAxis()) {
+      LayoutUnit ascent = flex_item.MarginBoxAscent();
+      LayoutUnit descent =
+          (flex_item.CrossAxisMarginExtent() + flex_item.cross_axis_size) -
+          ascent;
+
+      current_line->max_ascent = std::max(current_line->max_ascent, ascent);
+      max_descent = std::max(max_descent, descent);
+
+      child_cross_axis_margin_box_extent =
+          current_line->max_ascent + max_descent;
+    } else {
+      child_cross_axis_margin_box_extent =
+          CrossAxisIntrinsicExtentForChild(*child) +
+          flex_item.CrossAxisMarginExtent();
+    }
+    max_child_cross_axis_extent = std::max(max_child_cross_axis_extent,
+                                           child_cross_axis_margin_box_extent);
+
+    main_axis_offset += flex_item.FlowAwareMarginStart();
+
+    LayoutUnit child_main_extent = flex_item.FlexedBorderBoxSize();
+    // In an RTL column situation, this will apply the margin-right/margin-end
+    // on the left. This will be fixed later in flipForRightToLeftColumn.
+    flex_item.desired_location = LayoutPoint(
+        should_flip_main_axis ? current_line->container_logical_width -
+                                    main_axis_offset - child_main_extent
+                              : main_axis_offset,
+        cross_axis_offset + flex_item.FlowAwareMarginBefore());
+    main_axis_offset += child_main_extent + flex_item.FlowAwareMarginEnd();
+
+    if (i != current_line->line_items.size() - 1) {
+      // The last item does not get extra space added.
+      main_axis_offset += ContentDistributionSpaceBetweenChildren(
+          available_free_space, justify_content,
+          current_line->line_items.size());
+    }
   }
+
+  current_line->main_axis_extent = main_axis_offset;
+
+  if (number_of_in_flow_children_on_first_line_ == -1)
+    number_of_in_flow_children_on_first_line_ = current_line->line_items.size();
+  current_line->cross_axis_offset = cross_axis_offset;
+  current_line->cross_axis_extent = max_child_cross_axis_extent;
+
+  cross_axis_offset += max_child_cross_axis_extent;
 }
 
 void LayoutFlexibleBox::ApplyLineItemsPosition(FlexLine* current_line) {
@@ -1491,7 +1627,7 @@ void LayoutFlexibleBox::LayoutColumnReverse(Vector<FlexItem>& children,
   // layout anything since we're just moving the children to a new position.
   LayoutUnit main_axis_offset =
       LogicalHeight() - FlowAwareBorderEnd() - FlowAwarePaddingEnd();
-  main_axis_offset -= FlexLayoutAlgorithm::InitialContentPositionOffset(
+  main_axis_offset -= InitialContentPositionOffset(
       available_free_space, justify_content, children.size());
   main_axis_offset -= IsHorizontalFlow() ? VerticalScrollbarWidth()
                                          : HorizontalScrollbarHeight();
@@ -1512,9 +1648,8 @@ void LayoutFlexibleBox::LayoutColumnReverse(Vector<FlexItem>& children,
 
     main_axis_offset -= flex_item.FlowAwareMarginStart();
 
-    main_axis_offset -=
-        FlexLayoutAlgorithm::ContentDistributionSpaceBetweenChildren(
-            available_free_space, justify_content, children.size());
+    main_axis_offset -= ContentDistributionSpaceBetweenChildren(
+        available_free_space, justify_content, children.size());
   }
 }
 
@@ -1540,7 +1675,7 @@ void LayoutFlexibleBox::AlignFlexLines(Vector<FlexLine>& line_contexts) {
 
   LayoutUnit line_offset;
   if (line_contexts.size() > 1) {
-    line_offset = FlexLayoutAlgorithm::InitialContentPositionOffset(
+    line_offset = InitialContentPositionOffset(
         available_cross_axis_space, align_content, line_contexts.size());
   }
   for (unsigned line_number = 0; line_number < line_contexts.size();
@@ -1559,7 +1694,7 @@ void LayoutFlexibleBox::AlignFlexLines(Vector<FlexLine>& line_contexts) {
           available_cross_axis_space /
           static_cast<unsigned>(line_contexts.size());
 
-    line_offset += FlexLayoutAlgorithm::ContentDistributionSpaceBetweenChildren(
+    line_offset += ContentDistributionSpaceBetweenChildren(
         available_cross_axis_space, align_content, line_contexts.size());
   }
 }

third_party/WebKit/Source/core/layout/LayoutFlexibleBox.h

@@ -156,6 +156,8 @@ class CORE_EXPORT LayoutFlexibleBox : public LayoutBlock {
   void LayoutFlexItems(bool relayout_children, SubtreeLayoutScope&);
   LayoutUnit AutoMarginOffsetInMainAxis(const Vector<FlexItem>&,
                                         LayoutUnit& available_free_space);
+  void UpdateAutoMarginsInMainAxis(LayoutBox& child,
+                                   LayoutUnit auto_margin_offset);
   bool HasAutoMarginsInCrossAxis(const LayoutBox& child) const;
   bool UpdateAutoMarginsInCrossAxis(LayoutBox& child,
                                     LayoutUnit available_alignment_space);
@@ -179,6 +181,9 @@ class CORE_EXPORT LayoutFlexibleBox : public LayoutBlock {
                                               LayoutUnit child_preferred_size);
   void PrepareChildForPositionedLayout(LayoutBox& child);
   void LayoutLineItems(FlexLine*, bool relayout_children, SubtreeLayoutScope&);
+  void ComputeLineItemsPosition(LayoutUnit& cross_axis_offset,
+                                FlexLine*,
+                                LayoutUnit main_axis_offset);
   void ApplyLineItemsPosition(FlexLine*);
   void LayoutColumnReverse(Vector<FlexItem>&,
                            LayoutUnit cross_axis_offset,