Make NGFragment to own NGPhysicalFragment

third_party/WebKit/Source/core/layout/ng/ng_box.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_box.h"
 
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/ng/layout_ng_block_flow.h"
 #include "core/layout/ng/ng_block_layout_algorithm.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_direction.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_writing_mode.h"
 
 namespace blink {
 NGBox::NGBox(LayoutObject* layout_object)
     : layout_box_(toLayoutBox(layout_object)) {
   DCHECK(layout_box_);
 }
 
 NGBox::NGBox(ComputedStyle* style) : layout_box_(nullptr), style_(style) {
   DCHECK(style_);
 }
 
-bool NGBox::Layout(const NGConstraintSpace* constraint_space,
-                   NGFragment** out) {
+bool NGBox::Layout(const NGConstraintSpace* constraint_space) {
   if (layout_box_ && layout_box_->isOutOfFlowPositioned())
     layout_box_->containingBlock()->insertPositionedObject(layout_box_);
+
+  NGPhysicalFragment* physical_fragment = nullptr;
   // We can either use the new layout code to do the layout and then copy the
   // resulting size to the LayoutObject, or use the old layout code and
   // synthesize a fragment.
   if (CanUseNewLayout()) {
     if (!algorithm_)
       algorithm_ = new NGBlockLayoutAlgorithm(Style(), FirstChild());
     // Change the coordinate system of the constraint space.
-    NGConstraintSpace* child_constraint_space = new NGConstraintSpace(
+    NGConstraintSpace child_constraint_space(
         FromPlatformWritingMode(Style()->getWritingMode()),
         FromPlatformDirection(Style()->direction()), constraint_space);
 
-    NGPhysicalFragment* fragment = nullptr;
-    if (!algorithm_->Layout(child_constraint_space, &fragment))
+    if (!algorithm_->Layout(child_constraint_space, &physical_fragment))
       return false;
-    fragment_ = fragment;
 
     if (layout_box_) {
-      layout_box_->setWidth(fragment_->Width());
-      layout_box_->setHeight(fragment_->Height());
+      layout_box_->setWidth(physical_fragment->Width());
+      layout_box_->setHeight(physical_fragment->Height());
       NGBoxStrut border_and_padding =
           computeBorders(*Style()) +
           computePadding(*constraint_space, *Style());
       LayoutUnit intrinsic_logical_height =
           layout_box_->style()->isHorizontalWritingMode()
-              ? fragment_->HeightOverflow()
-              : fragment_->WidthOverflow();
+              ? physical_fragment->HeightOverflow()
+              : physical_fragment->WidthOverflow();
       intrinsic_logical_height -= border_and_padding.BlockSum();
       layout_box_->setIntrinsicContentLogicalHeight(intrinsic_logical_height);
 
       // Ensure the position of the children are copied across to the
       // LayoutObject tree.
       for (NGBox* box = FirstChild(); box; box = box->NextSibling()) {
-        if (box->fragment_)
+        if (box->Fragment())
           box->PositionUpdated();
       }
 
       if (layout_box_->isLayoutBlock())
         toLayoutBlock(layout_box_)->layoutPositionedObjects(true);
       layout_box_->clearNeedsLayout();
       if (layout_box_->isLayoutBlockFlow()) {
         toLayoutBlockFlow(layout_box_)->updateIsSelfCollapsing();
       }
     }
@@ skipping 15 matching lines @@
     // overflow)
     NGFragmentBuilder builder(NGPhysicalFragmentBase::FragmentBox);
     builder.SetInlineSize(layout_box_->logicalWidth())
         .SetBlockSize(layout_box_->logicalHeight())
         .SetDirection(
             FromPlatformDirection(layout_box_->styleRef().direction()))
         .SetWritingMode(
             FromPlatformWritingMode(layout_box_->styleRef().getWritingMode()))
         .SetInlineOverflow(overflow.width())
         .SetBlockOverflow(overflow.height());
-    fragment_ = builder.ToFragment();
+    physical_fragment = builder.ToFragment();
   }
-  *out = new NGFragment(constraint_space->WritingMode(),
-                        FromPlatformDirection(Style()->direction()),
-                        fragment_.get());
+  fragment_ = new NGFragment(constraint_space->WritingMode(),
+                             FromPlatformDirection(Style()->direction()),
+                             physical_fragment);
   // Reset algorithm for future use
   algorithm_ = nullptr;
   return true;
 }
 
 const ComputedStyle* NGBox::Style() const {
   if (style_)
     return style_.get();
   DCHECK(layout_box_);
   return layout_box_->style();
@@ skipping 20 matching lines @@
 
 void NGBox::SetNextSibling(NGBox* sibling) {
   next_sibling_ = sibling;
 }
 
 void NGBox::SetFirstChild(NGBox* child) {
   first_child_ = child;
 }
 
 void NGBox::PositionUpdated() {
-  if (layout_box_) {
-    layout_box_->setX(fragment_->LeftOffset());
-    layout_box_->setY(fragment_->TopOffset());
+  if (layout_box_ && fragment_->PhysicalFragment()) {

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

Can PhysicalFragment() ever be null?

+    layout_box_->setX(fragment_->PhysicalFragment()->LeftOffset());
+    layout_box_->setY(fragment_->PhysicalFragment()->TopOffset());
   }
 }
 
 bool NGBox::CanUseNewLayout() {
   if (!layout_box_)
     return true;
   if (!layout_box_->isLayoutBlockFlow())
     return false;
   const LayoutBlockFlow* block_flow = toLayoutBlockFlow(layout_box_);
   return !block_flow->childrenInline() || !block_flow->firstChild();
 }
 }  // namespace blink