[LayoutNG] Remove space_builder_ member from block 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 84 matching lines @@
   const auto& floating_objects = container_builder->UnpositionedFloats();
   container_builder->MutablePositionedFloats().AppendVector(PositionFloats(
       origin_block_offset, container_builder->BfcOffset().value().block_offset,
       floating_objects, space));
   container_builder->MutableUnpositionedFloats().clear();
 }
 
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(NGBlockNode* node,
                                                NGConstraintSpace* space,
                                                NGBlockBreakToken* break_token)
-    : NGLayoutAlgorithm(node, space, break_token),
-      space_builder_(constraint_space_) {}
+    : NGLayoutAlgorithm(node, space, break_token) {}
 
 Optional<MinMaxContentSize> NGBlockLayoutAlgorithm::ComputeMinMaxContentSize()
     const {
   MinMaxContentSize sizes;
 
   // Size-contained elements don't consider their contents for intrinsic sizing.
   if (Style().ContainsSize())
     return sizes;
 
   // TODO: handle floats & orthogonal children.
@@ skipping 51 matching lines @@
 
   // Our calculated block-axis size may be indefinite at this point.
   // If so, just leave the size as NGSizeIndefinite instead of subtracting
   // borders and padding.
   NGLogicalSize adjusted_size(size);
   if (size.block_size == NGSizeIndefinite)
     adjusted_size.inline_size -= border_and_padding_.InlineSum();
   else
     adjusted_size -= border_and_padding_;
 
-  space_builder_.SetAvailableSize(adjusted_size)
-      .SetPercentageResolutionSize(adjusted_size);
+  child_available_size_ = adjusted_size;
+  child_percentage_size_ = adjusted_size;
 
   container_builder_.SetDirection(constraint_space_->Direction());
   container_builder_.SetWritingMode(constraint_space_->WritingMode());
   container_builder_.SetSize(size);
   container_builder_.MutableUnpositionedFloats() =
       constraint_space_->UnpositionedFloats();
 
   NGBlockChildIterator child_iterator(Node()->FirstChild(), BreakToken());
   NGBlockChildIterator::Entry entry = child_iterator.NextChild();
   NGLayoutInputNode* child = entry.node;
@@ skipping 44 matching lines @@
                                                       offset);
         NGBlockChildIterator::Entry entry = child_iterator.NextChild();
         child = entry.node;
         child_break_token = entry.token;
         continue;
       }
     }
 
     NGLogicalOffset child_bfc_offset = PrepareChildLayout(child);
     RefPtr<NGConstraintSpace> child_space =
-        CreateConstraintSpaceForChild(child_bfc_offset, child);
+        CreateConstraintSpaceForChild(child_bfc_offset, *child);
     RefPtr<NGLayoutResult> layout_result =
         child->Layout(child_space.Get(), child_break_token);
 
     if (child->IsFloating())
       FinishFloatChildLayout(child->Style(), *child_space, layout_result.Get());
     else
       FinishChildLayout(*child_space, child, layout_result.Get());
 
     entry = child_iterator.NextChild();
     child = entry.node;
@@ skipping 52 matching lines @@
 NGLogicalOffset NGBlockLayoutAlgorithm::PrepareChildLayout(
     NGLayoutInputNode* child) {
   DCHECK(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, *space_builder_.ToConstraintSpace(
-                 FromPlatformWritingMode(Style().GetWritingMode())));
+  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.
@@ skipping 223 matching lines @@
     container_builder_.SetBlockSize(space_left);
     container_builder_.SetBlockOverflow(space_left);
     return;
   }
 
   // The end of the block fits in the current fragmentainer.
   container_builder_.SetBlockSize(block_size);
   container_builder_.SetBlockOverflow(content_size_);
 }
 
-NGBoxStrut NGBlockLayoutAlgorithm::CalculateMargins(
-    NGLayoutInputNode* child,
-    const NGConstraintSpace& space) {
+NGBoxStrut NGBlockLayoutAlgorithm::CalculateMargins(NGLayoutInputNode* child) {
   DCHECK(child);
   if (child->IsInline())
     return {};
   const ComputedStyle& child_style = child->Style();
 
-  WTF::Optional<MinMaxContentSize> sizes;
-  if (NeedMinMaxContentSize(space, child_style))
-    sizes = child->ComputeMinMaxContentSize();
+  RefPtr<NGConstraintSpace> space =
+      NGConstraintSpaceBuilder(MutableConstraintSpace())
+          .SetAvailableSize(child_available_size_)
+          .SetPercentageResolutionSize(child_percentage_size_)
+          .ToConstraintSpace(ConstraintSpace().WritingMode());
 
-  LayoutUnit child_inline_size =
-      ComputeInlineSizeForFragment(space, child_style, sizes);
-  NGBoxStrut margins = ComputeMargins(space, child_style, space.WritingMode(),
-                                      space.Direction());
+  NGBoxStrut margins = ComputeMargins(*space, child_style, space->WritingMode(),
+                                      space->Direction());
+
+  // TODO(ikilpatrick): Move the auto margins calculation for different writing
+  // modes to post-layout.
   if (!child->IsFloating()) {
-    ApplyAutoMargins(space, child_style, child_inline_size, &margins);
+    WTF::Optional<MinMaxContentSize> sizes;
+    if (NeedMinMaxContentSize(*space, child_style))
+      sizes = child->ComputeMinMaxContentSize();
+
+    LayoutUnit child_inline_size =
+        ComputeInlineSizeForFragment(*space, child_style, sizes);
+    ApplyAutoMargins(*space, child_style, child_inline_size, &margins);
   }
   return margins;
 }
 
 RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
     const NGLogicalOffset& child_bfc_offset,
-    NGLayoutInputNode* child) {
-  DCHECK(child);
+    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)
+  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_);
+  space_builder.SetMarginStrut(child.IsFloating() ? NGMarginStrut()
+                                                  : curr_margin_strut_);
 
   if (!is_new_bfc) {
-    space_builder_.SetUnpositionedFloats(
+    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(
+  if (child.IsInline()) {
+    // TODO(kojii): Setup space_builder appropriately for inline child.
+    space_builder.SetClearanceOffset(ConstraintSpace().ClearanceOffset());
+    return space_builder.ToConstraintSpace(
         FromPlatformWritingMode(Style().GetWritingMode()));
   }
 
-  space_builder_
+  space_builder
       .SetClearanceOffset(
           GetClearanceOffset(constraint_space_->Exclusions(), child_style))
       .SetIsShrinkToFit(ShouldShrinkToFit(Style(), child_style))
       .SetTextDirection(child_style.Direction());
 
   LayoutUnit space_available;
   if (constraint_space_->HasBlockFragmentation()) {
     space_available = ConstraintSpace().FragmentainerSpaceAvailable();
     // If a block establishes a new formatting context we must know our
     // position in the formatting context, and are able to adjust the
     // fragmentation line.
     if (is_new_bfc) {
       space_available -= child_bfc_offset.block_offset;
     }
   }
-  space_builder_.SetFragmentainerSpaceAvailable(space_available);
+  space_builder.SetFragmentainerSpaceAvailable(space_available);
 
-  return space_builder_.ToConstraintSpace(
+  return space_builder.ToConstraintSpace(
       FromPlatformWritingMode(child_style.GetWritingMode()));
 }
 }  // namespace blink