[LayoutNG] Refactor main-loop of block layout algorithm.

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ng/ng_block_layout_algorithm.h"
 
 #include "core/layout/ng/inline/ng_inline_node.h"
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_child_iterator.h"
 #include "core/layout/ng/ng_constraint_space.h"
@@ skipping 220 matching lines @@
     MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
                                  &container_builder_);
     DCHECK_EQ(curr_margin_strut_, NGMarginStrut());
     DCHECK_EQ(container_builder_.BfcOffset().value(), NGLogicalOffset());
     curr_bfc_offset_ = {};
   }
 
   curr_bfc_offset_.block_offset += content_size_;
 
   while (child) {
-    // TODO(ikilpatrick): Refactor the inside of this loop.
-    if (child->IsBlock()) {
-      EPosition position = child->Style().GetPosition();
-      if (position == EPosition::kAbsolute || position == EPosition::kFixed) {
-        NGLogicalOffset offset = {border_and_padding_.inline_start,
-                                  content_size_};
-
-        // We only include the margin strut in the OOF static-position if we
-        // know we aren't going to be a zero-block-size fragment.
-        if (container_builder_.BfcOffset())
-          offset.block_offset += curr_margin_strut_.Sum();
-
-        container_builder_.AddOutOfFlowChildCandidate(ToNGBlockNode(child),
-                                                      offset);
-        NGBlockChildIterator::Entry entry = child_iterator.NextChild();
-        child = entry.node;
-        child_break_token = entry.token;
-        continue;
-      }
-    }
-
-    NGLogicalOffset child_bfc_offset = PrepareChildLayout(child);
-
-    if (child->IsFloating()) {
-      FinishFloatChildLayout(child->Style(), ToNGBlockNode(child),
-                             ToNGBlockBreakToken(child_break_token));
+    if (child->IsOutOfFlowPositioned()) {
+      DCHECK(!child_break_token);
+      HandleOutOfFlowPositioned(ToNGBlockNode(child));
+    } else if (child->IsFloating()) {
+      HandleFloating(ToNGBlockNode(child),
+                     ToNGBlockBreakToken(child_break_token));
     } else {
+      NGLogicalOffset child_bfc_offset = PrepareChildLayout(child);
       RefPtr<NGConstraintSpace> child_space =
           CreateConstraintSpaceForChild(child_bfc_offset, *child);
       RefPtr<NGLayoutResult> layout_result =
           child->Layout(child_space.Get(), child_break_token);
       FinishChildLayout(*child_space, child, layout_result.Get());
     }
 
     entry = child_iterator.NextChild();
     child = entry.node;
     child_break_token = entry.token;
@@ skipping 46 matching lines @@
   // We only finalize for fragmentation if the fragment has a BFC offset. This
   // may occur with a zero block size fragment. We need to know the BFC offset
   // to determine where the fragmentation line is relative to us.
   if (container_builder_.BfcOffset() &&
       ConstraintSpace().HasBlockFragmentation())
     FinalizeForFragmentation();
 
   return container_builder_.ToBoxFragment();
 }
 
+void NGBlockLayoutAlgorithm::HandleOutOfFlowPositioned(NGBlockNode* child) {
+  NGLogicalOffset offset = {border_and_padding_.inline_start, content_size_};
+
+  // We only include the margin strut in the OOF static-position if we know we
+  // aren't going to be a zero-block-size fragment.
+  if (container_builder_.BfcOffset())
+    offset.block_offset += curr_margin_strut_.Sum();
+
+  container_builder_.AddOutOfFlowChildCandidate(child, offset);
+}
+
+void NGBlockLayoutAlgorithm::HandleFloating(NGBlockNode* child,
+                                            NGBlockBreakToken* token) {
+  // TODO(ikilpatrick): Pass in BFC offset from previous in-flow child.
+  curr_bfc_offset_ = container_builder_.BfcOffset()
+                         ? container_builder_.BfcOffset().value()
+                         : ConstraintSpace().BfcOffset();
+  curr_bfc_offset_.block_offset += content_size_;
+
+  // Calculate margins in the BFC's writing mode.
+  curr_child_margins_ = CalculateMargins(child);
+
+  NGLogicalOffset origin_offset = constraint_space_->BfcOffset();
+  origin_offset.inline_offset += border_and_padding_.inline_start;
+  RefPtr<NGUnpositionedFloat> unpositioned_float = NGUnpositionedFloat::Create(
+      child_available_size_, child_percentage_size_, origin_offset,
+      constraint_space_->BfcOffset(), curr_child_margins_, child, token);
+  container_builder_.AddUnpositionedFloat(unpositioned_float);
+
+  // If there is a break token for a float we must be resuming layout, we must
+  // always know our position in the BFC.
+  DCHECK(!token || container_builder_.BfcOffset());
+
+  // No need to postpone the positioning if we know the correct offset.
+  if (container_builder_.BfcOffset()) {
+    NGLogicalOffset origin_point = curr_bfc_offset_;
+    // Adjust origin point to the margins of the last child.
+    // Example: <div style="margin-bottom: 20px"><float></div>
+    //          <div style="margin-bottom: 30px"></div>
+    origin_point.block_offset += curr_margin_strut_.Sum();
+    PositionPendingFloats(origin_point.block_offset, &container_builder_,
+                          MutableConstraintSpace());
+  }
+}
+
 NGLogicalOffset NGBlockLayoutAlgorithm::PrepareChildLayout(
     NGLayoutInputNode* child) {
   DCHECK(child);
+  DCHECK(!child->IsFloating());
 
+  // TODO(ikilpatrick): Pass in BFC offset from previous in-flow child.
   curr_bfc_offset_ = container_builder_.BfcOffset()
                          ? container_builder_.BfcOffset().value()
                          : ConstraintSpace().BfcOffset();
   curr_bfc_offset_.block_offset += content_size_;
 
   // Calculate margins in parent's writing mode.
   curr_child_margins_ = CalculateMargins(child);
 
   bool should_position_pending_floats =
-      !child->IsFloating() &&
       !IsNewFormattingContextForBlockLevelChild(Style(), *child) &&
       ClearanceMayAffectLayout(ConstraintSpace(),
                                container_builder_.UnpositionedFloats(),
                                child->Style());
 
   // Children which may clear a float need to force all the pending floats to
   // be positioned before layout. This also resolves the fragment's bfc offset.
   if (should_position_pending_floats) {
     LayoutUnit origin_point_block_offset =
         curr_bfc_offset_.block_offset + curr_margin_strut_.Sum();
     MaybeUpdateFragmentBfcOffset(
         ConstraintSpace(),
         {curr_bfc_offset_.inline_offset, origin_point_block_offset},
         &container_builder_);
     PositionPendingFloats(origin_point_block_offset, &container_builder_,
                           MutableConstraintSpace());
   }
 
-  bool is_inflow = child->IsInline() || !child->IsFloating();
+  NGLogicalOffset child_bfc_offset = curr_bfc_offset_;
+  child_bfc_offset.inline_offset +=
+      {border_and_padding_.inline_start + curr_child_margins_.inline_start};
 
-  NGLogicalOffset child_bfc_offset = curr_bfc_offset_;
-  child_bfc_offset.inline_offset += border_and_padding_.inline_start;
-  // Only inflow children (e.g. not floats) are included in the child's margin
-  // strut as they do not participate in margin collapsing.
-  if (is_inflow) {
-    child_bfc_offset.inline_offset += curr_child_margins_.inline_start;
-    // Append the current margin strut with child's block start margin.
-    // Non empty border/padding, and new FC use cases are handled inside of the
-    // child's layout.
-    if (!IsNewFormattingContextForBlockLevelChild(Style(), *child))
-      curr_margin_strut_.Append(curr_child_margins_.block_start);
-  }
+  // Append the current margin strut with child's block start margin.
+  // Non empty border/padding, and new FC use cases are handled inside of the
+  // child's layout.
+  if (!IsNewFormattingContextForBlockLevelChild(Style(), *child))
+    curr_margin_strut_.Append(curr_child_margins_.block_start);
 
   // TODO(crbug.com/716930): We should also collapse margins below once we
   // remove LayoutInline splitting.
 
   // Should collapse margins if our child is a legacy block.
   if (IsLegacyBlock(*child)) {
     curr_bfc_offset_ +=
         {border_and_padding_.inline_start + curr_child_margins_.inline_start,
          curr_margin_strut_.Sum()};
     MaybeUpdateFragmentBfcOffset(ConstraintSpace(), curr_bfc_offset_,
@@ skipping 132 matching lines @@
       &container_builder_, MutableConstraintSpace());
   return curr_bfc_offset_;
 }
 
 NGLogicalOffset NGBlockLayoutAlgorithm::PositionLegacy(
     const NGConstraintSpace& child_space) {
   AdjustToClearance(child_space.ClearanceOffset(), &curr_bfc_offset_);
   return curr_bfc_offset_;
 }
 
-void NGBlockLayoutAlgorithm::FinishFloatChildLayout(
-    const ComputedStyle& child_style,
-    NGBlockNode* child,
-    NGBlockBreakToken* token) {
-  NGLogicalOffset origin_offset = constraint_space_->BfcOffset();
-  origin_offset.inline_offset += border_and_padding_.inline_start;
-  RefPtr<NGUnpositionedFloat> unpositioned_float = NGUnpositionedFloat::Create(
-      child_available_size_, child_percentage_size_, origin_offset,
-      constraint_space_->BfcOffset(), curr_child_margins_, child, token);
-  container_builder_.AddUnpositionedFloat(unpositioned_float);
-
-  // If there is a break token for a float we must be resuming layout, we must
-  // always know our position in the BFC.
-  DCHECK(!token || container_builder_.BfcOffset());
-
-  // No need to postpone the positioning if we know the correct offset.
-  if (container_builder_.BfcOffset()) {
-    NGLogicalOffset origin_point = curr_bfc_offset_;
-    // Adjust origin point to the margins of the last child.
-    // Example: <div style="margin-bottom: 20px"><float></div>
-    //          <div style="margin-bottom: 30px"></div>
-    origin_point.block_offset += curr_margin_strut_.Sum();
-    PositionPendingFloats(origin_point.block_offset, &container_builder_,
-                          MutableConstraintSpace());
-  }
-}
-
 void NGBlockLayoutAlgorithm::FinalizeForFragmentation() {
   LayoutUnit used_block_size =
       BreakToken() ? BreakToken()->UsedBlockSize() : LayoutUnit();
   LayoutUnit block_size = ComputeBlockSizeForFragment(
       ConstraintSpace(), Style(), used_block_size + content_size_);
 
   block_size -= used_block_size;
   DCHECK_GE(block_size, LayoutUnit())
       << "Adding and subtracting the used_block_size shouldn't leave the "
          "block_size for this fragment smaller than zero.";
@@ skipping 57 matching lines @@
 RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
     const NGLogicalOffset& child_bfc_offset,
     const NGLayoutInputNode& child) {
   NGConstraintSpaceBuilder space_builder(MutableConstraintSpace());
   space_builder.SetAvailableSize(child_available_size_)
       .SetPercentageResolutionSize(child_percentage_size_);
 
   const ComputedStyle& child_style = child.Style();
   bool is_new_bfc = IsNewFormattingContextForBlockLevelChild(Style(), child);
   space_builder.SetIsNewFormattingContext(is_new_bfc)
-      .SetBfcOffset(child_bfc_offset);
-
-  // Float's margins are not included in child's space because:
-  // 1) Floats do not participate in margins collapsing.
-  // 2) Floats margins are used separately to calculate floating exclusions.
-  space_builder.SetMarginStrut(child.IsFloating() ? NGMarginStrut()
-                                                  : curr_margin_strut_);
+      .SetBfcOffset(child_bfc_offset)
+      .SetMarginStrut(curr_margin_strut_);
 
   if (!is_new_bfc) {
     space_builder.SetUnpositionedFloats(
         container_builder_.MutableUnpositionedFloats());
   }
 
   if (child.IsInline()) {
     // TODO(kojii): Setup space_builder appropriately for inline child.
     space_builder.SetClearanceOffset(ConstraintSpace().ClearanceOffset());
     return space_builder.ToConstraintSpace(
@@ skipping 15 matching lines @@
     if (is_new_bfc) {
       space_available -= child_bfc_offset.block_offset;
     }
   }
   space_builder.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder.ToConstraintSpace(
       FromPlatformWritingMode(child_style.GetWritingMode()));
 }
 }  // namespace blink