Make NGFragment to own NGPhysicalFragment

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_constraint_space.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_length_utils.h"
@@ skipping 18 matching lines @@
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(
     PassRefPtr<const ComputedStyle> style,
     NGBox* first_child)
     : style_(style),
       first_child_(first_child),
       state_(kStateInit),
       is_fragment_margin_strut_block_start_updated_(false) {
   DCHECK(style_);
 }
 
-bool NGBlockLayoutAlgorithm::Layout(const NGConstraintSpace* constraint_space,
+bool NGBlockLayoutAlgorithm::Layout(const NGConstraintSpace& constraint_space,
                                     NGPhysicalFragment** out) {
   switch (state_) {
     case kStateInit: {
       border_and_padding_ =
-          computeBorders(*style_) + computePadding(*constraint_space, *style_);
+          computeBorders(*style_) + computePadding(constraint_space, *style_);
 
       LayoutUnit inline_size =
-          computeInlineSizeForFragment(*constraint_space, *style_);
+          computeInlineSizeForFragment(constraint_space, *style_);
       LayoutUnit adjusted_inline_size =
           inline_size - border_and_padding_.InlineSum();
       // TODO(layout-ng): For quirks mode, should we pass blockSize instead of
       // -1?
       LayoutUnit block_size = computeBlockSizeForFragment(
-          *constraint_space, *style_, NGSizeIndefinite);
+          constraint_space, *style_, NGSizeIndefinite);
       LayoutUnit adjusted_block_size(block_size);
       // 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.
       if (adjusted_block_size != NGSizeIndefinite)
         adjusted_block_size -= border_and_padding_.BlockSum();
       constraint_space_for_children_ = new NGConstraintSpace(
           FromPlatformWritingMode(style_->getWritingMode()),
-          FromPlatformDirection(style_->direction()), *constraint_space,
+          FromPlatformDirection(style_->direction()), constraint_space,
           NGLogicalSize(adjusted_inline_size, adjusted_block_size));
       content_size_ = border_and_padding_.block_start;
 
       builder_ = new NGFragmentBuilder(NGPhysicalFragmentBase::FragmentBox);
-      builder_->SetDirection(constraint_space->Direction());
-      builder_->SetWritingMode(constraint_space->WritingMode());
+      builder_->SetDirection(constraint_space.Direction());
+      builder_->SetWritingMode(constraint_space.WritingMode());
       builder_->SetInlineSize(inline_size).SetBlockSize(block_size);
       current_child_ = first_child_;
       state_ = kStateChildLayout;
       return false;
     }
     case kStateChildLayout: {
       if (current_child_) {
-        NGFragment* fragment;
-        if (!current_child_->Layout(constraint_space_for_children_, &fragment))
+        if (!current_child_->Layout(constraint_space_for_children_.get()))

[cbiesinger, 2016/09/26 17:17:55]

Why did you remove the out param?

           return false;
+        NGFragment* fragment = current_child_->Fragment();
         NGBoxStrut child_margins = computeMargins(
             *constraint_space_for_children_, *current_child_->Style(),
             constraint_space_for_children_->WritingMode(),
             constraint_space_for_children_->Direction());
 
         LayoutUnit margin_block_start =
-            CollapseMargins(*constraint_space, child_margins, *fragment);
+            CollapseMargins(constraint_space, child_margins, *fragment);
 
         // TODO(layout-ng): Support auto margins
         builder_->AddChild(fragment,
                            NGLogicalOffset(border_and_padding_.inline_start +
                                                child_margins.inline_start,
                                            content_size_ + margin_block_start));
 
         content_size_ += fragment->BlockSize() + margin_block_start;
         max_inline_size_ =
             std::max(max_inline_size_, fragment->InlineSize() +
                                            child_margins.InlineSum() +
                                            border_and_padding_.InlineSum());
         current_child_ = current_child_->NextSibling();
         if (current_child_)
           return false;
       }
       state_ = kStateFinalize;
       return false;
     }
     case kStateFinalize: {
       content_size_ += border_and_padding_.block_end;
       // Recompute the block-axis size now that we know our content size.
-      LayoutUnit block_size = computeBlockSizeForFragment(
-          *constraint_space, *style_, content_size_);
+      LayoutUnit block_size =
+          computeBlockSizeForFragment(constraint_space, *style_, content_size_);
 
       builder_->SetBlockSize(block_size)
           .SetInlineOverflow(max_inline_size_)
           .SetBlockOverflow(content_size_);
       *out = builder_->ToFragment();
       state_ = kStateInit;
       return true;
     }
   };
   NOTREACHED();
@@ skipping 55 matching lines @@
 
 void NGBlockLayoutAlgorithm::UpdateMarginStrut(const NGMarginStrut& from) {
   if (!is_fragment_margin_strut_block_start_updated_) {
     builder_->SetMarginStrutBlockStart(from);
     is_fragment_margin_strut_block_start_updated_ = true;
   }
   builder_->SetMarginStrutBlockEnd(from);
 }
 
 }  // namespace blink