[LayoutNG] Switch NGConstraintSpace to being RefCounted.

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/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_block_child_iterator.h"
 #include "core/layout/ng/ng_box_fragment.h"
@@ skipping 169 matching lines @@
   inline_offset -= from_offset.inline_offset;
 
   return NGLogicalOffset(inline_offset, block_offset);
 }
 
 // Calculates the relative position from {@code from_offset} of the
 // floating object that is requested to be positioned from {@code origin_point}.
 NGLogicalOffset PositionFloat(const NGLogicalOffset& origin_point,
                               const NGLogicalOffset& from_offset,
                               NGFloatingObject* floating_object) {
-  NGConstraintSpace* float_space = floating_object->space;
+  NGConstraintSpace* float_space = floating_object->space.get();
   DCHECK(floating_object->fragment) << "Fragment cannot be null here";
 
   // TODO(ikilpatrick): The writing mode switching here looks wrong.
   NGBoxFragment float_fragment(
       float_space->WritingMode(),
       toNGPhysicalBoxFragment(floating_object->fragment.get()));
 
   // Find a layout opportunity that will fit our float.
-  const NGLayoutOpportunity opportunity =
-      FindLayoutOpportunityForFragment(floating_object->space, float_fragment,
-                                       origin_point, floating_object->margins);
+  const NGLayoutOpportunity opportunity = FindLayoutOpportunityForFragment(
+      float_space, float_fragment, origin_point, floating_object->margins);
   DCHECK(!opportunity.IsEmpty()) << "Opportunity is empty but it shouldn't be";
 
   // Calculate the float offset if needed.
   LayoutUnit float_offset;
   if (floating_object->exclusion_type == NGExclusion::kFloatRight) {
     LayoutUnit float_margin_box_inline_size =
         float_fragment.InlineSize() + floating_object->margins.InlineSum();
     float_offset = opportunity.size.inline_size - float_margin_box_inline_size;
   }
 
@@ skipping 22 matching lines @@
 
 // Positions pending floats stored on the fragment builder starting from
 // {@code origin_point_block_offset}.
 void PositionPendingFloats(const LayoutUnit origin_point_block_offset,
                            const NGConstraintSpace& new_parent_space,
                            NGFragmentBuilder* builder) {
   DCHECK(builder->BfcOffset()) << "Parent BFC offset should be known here";
   LayoutUnit bfc_block_offset = builder->BfcOffset().value().block_offset;
 
   for (auto& floating_object : builder->UnpositionedFloats()) {
-    Member<NGConstraintSpace> float_space = floating_object->space;
-    Member<const NGConstraintSpace> original_parent_space =
-        floating_object->original_parent_space;
+    NGConstraintSpace* float_space = floating_object->space.get();
+    const NGConstraintSpace* original_parent_space =
+        floating_object->original_parent_space.get();
 
     NGLogicalOffset origin_point = {float_space->BfcOffset().inline_offset,
                                     origin_point_block_offset};
     NGLogicalOffset from_offset = {
         original_parent_space->BfcOffset().inline_offset, bfc_block_offset};
 
     NGLogicalOffset float_fragment_offset =
         PositionFloat(origin_point, from_offset, floating_object);
     builder->AddFloatingObject(floating_object, float_fragment_offset);
     UpdateFloatingObjectLeftOffset(new_parent_space, floating_object,
@@ skipping 192 matching lines @@
       if (position == EPosition::kAbsolute || position == EPosition::kFixed) {
         builder_.AddOutOfFlowChildCandidate(current_block_child,
                                             GetChildSpaceOffset());
         NGBlockChildIterator::Entry entry = child_iterator.NextChild();
         child = entry.node;
         child_break_token = entry.token;
         continue;
       }
     }
 
-    NGConstraintSpace* child_space = CreateConstraintSpaceForChild(child);
+    RefPtr<NGConstraintSpace> child_space =
+        CreateConstraintSpaceForChild(child);
 
     if (child->Type() == NGLayoutInputNode::kLegacyInline) {
-      LayoutInlineChildren(toNGInlineNode(child), child_space);
+      LayoutInlineChildren(toNGInlineNode(child), child_space.get());
       break;
     }
 
     RefPtr<NGLayoutResult> layout_result =
-        child->Layout(child_space, child_break_token);
+        child->Layout(child_space.get(), child_break_token);
 
-    FinishChildLayout(child, child_space, layout_result);
+    FinishChildLayout(child, child_space.get(), layout_result);
 
     entry = child_iterator.NextChild();
     child = entry.node;
     child_break_token = entry.token;
 
     if (IsOutOfSpace(ConstraintSpace(), content_size_))
       break;
   }
 
   // Margins collapsing:
@@ skipping 199 matching lines @@
   LayoutUnit child_inline_size =
       ComputeInlineSizeForFragment(space, child_style, sizes);
   NGBoxStrut margins = ComputeMargins(space, child_style, space.WritingMode(),
                                       space.Direction());
   if (!child_style.isFloating()) {
     ApplyAutoMargins(space, child_style, child_inline_size, &margins);
   }
   return margins;
 }
 
-NGConstraintSpace* NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
+RefPtr<NGConstraintSpace> NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
     NGLayoutInputNode* child) {
   DCHECK(child);
 
   if (child->Type() == NGLayoutInputNode::kLegacyInline) {
     // TODO(kojii): Setup space_builder_ appropriately for inline child.
 
     // Margins collapsing: Inline block.
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     UpdateFragmentBfcOffset(curr_bfc_offset_);
     PositionPendingFloats(curr_bfc_offset_.block_offset, ConstraintSpace(),
@@ skipping 67 matching lines @@
       DCHECK(builder_.BfcOffset());
       space_available -= curr_bfc_offset_.block_offset;
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.getWritingMode()));
 }
 }  // namespace blink