[layoutng] Split NGLayoutResult out of NGPhysicalFragment

third_party/WebKit/Source/core/layout/ng/ng_fragment_builder.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_fragment_builder.h"
 
 #include "core/layout/ng/ng_block_node.h"
 #include "core/layout/ng/ng_break_token.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_physical_box_fragment.h"
@@ skipping 34 matching lines @@
   overflow_.inline_size = size;
   return *this;
 }
 
 NGFragmentBuilder& NGFragmentBuilder::SetBlockOverflow(LayoutUnit size) {
   overflow_.block_size = size;
   return *this;
 }
 
 NGFragmentBuilder& NGFragmentBuilder::AddChild(
-    RefPtr<NGPhysicalFragment> child,
+    RefPtr<NGLayoutResult> child,
     const NGLogicalOffset& child_offset) {
   DCHECK_EQ(type_, NGPhysicalFragment::kFragmentBox)
       << "Only box fragments can have children";
 
   // Collect child's out of flow descendants.
   const Vector<NGStaticPosition>& oof_positions = child->OutOfFlowPositions();
   size_t oof_index = 0;
   for (auto& oof_node : child->OutOfFlowDescendants()) {
     NGStaticPosition oof_position = oof_positions[oof_index++];
     out_of_flow_descendant_candidates_.add(oof_node);
     out_of_flow_candidate_placements_.push_back(
         OutOfFlowPlacement{child_offset, oof_position});
   }
 
-  children_.push_back(std::move(child));
+  return AddChild(child->PhysicalFragment(), child_offset);
+}
+
+NGFragmentBuilder& NGFragmentBuilder::AddChild(
+    RefPtr<NGPhysicalFragment> child,
+    const NGLogicalOffset& child_offset) {
+  DCHECK_EQ(type_, NGPhysicalFragment::kFragmentBox)
+      << "Only box fragments can have children";
+
+  children_.push_back(child);

[ikilpatrick, 2017/02/21 22:26:02]

std::move()?

[cbiesinger, 2017/02/22 18:09:00]

Also fixed already

   offsets_.push_back(child_offset);
 
   return *this;
 }
 
 NGFragmentBuilder& NGFragmentBuilder::AddFloatingObject(
     NGFloatingObject* floating_object,
     const NGLogicalOffset& floating_object_offset) {
   positioned_floats_.push_back(floating_object);
   floating_object_offsets_.push_back(floating_object_offset);
@@ skipping 55 matching lines @@
 }
 
 NGFragmentBuilder& NGFragmentBuilder::AddOutOfFlowDescendant(
     NGBlockNode* descendant,
     const NGStaticPosition& position) {
   out_of_flow_descendants_.add(descendant);
   out_of_flow_positions_.push_back(position);
   return *this;
 }
 
-RefPtr<NGPhysicalBoxFragment> NGFragmentBuilder::ToBoxFragment() {
+RefPtr<NGLayoutResult> NGFragmentBuilder::ToBoxFragment() {
   // TODO(layout-ng): Support text fragments
   DCHECK_EQ(type_, NGPhysicalFragment::kFragmentBox);
   DCHECK_EQ(offsets_.size(), children_.size());
 
   auto* break_token = break_token_.get();
   break_token_ = nullptr;
 
   NGPhysicalSize physical_size = size_.ConvertToPhysical(writing_mode_);
 
   for (size_t i = 0; i < children_.size(); ++i) {
     NGPhysicalFragment* child = children_[i].get();
     child->SetOffset(offsets_[i].ConvertToPhysical(
         writing_mode_, direction_, physical_size, child->Size()));
   }
 
   Vector<Persistent<NGFloatingObject>> positioned_floats;
   positioned_floats.reserveCapacity(positioned_floats_.size());
 
   for (size_t i = 0; i < positioned_floats_.size(); ++i) {
     Persistent<NGFloatingObject>& floating_object = positioned_floats_[i];
     NGPhysicalFragment* floating_fragment = floating_object->fragment.get();
     floating_fragment->SetOffset(floating_object_offsets_[i].ConvertToPhysical(
         writing_mode_, direction_, physical_size, floating_fragment->Size()));
     positioned_floats.push_back(floating_object);
   }
 
-  return adoptRef(new NGPhysicalBoxFragment(
+  RefPtr<NGPhysicalBoxFragment> fragment = adoptRef(new NGPhysicalBoxFragment(
       layout_object_, physical_size, overflow_.ConvertToPhysical(writing_mode_),
-      children_, out_of_flow_descendants_, out_of_flow_positions_,
-      unpositioned_floats_, positioned_floats_, bfc_offset_, end_margin_strut_,
+      children_, positioned_floats_, bfc_offset_, end_margin_strut_,
       break_token));
+
+  return adoptRef(
+      new NGLayoutResult(std::move(fragment), out_of_flow_descendants_,
+                         out_of_flow_positions_, unpositioned_floats_));
 }
 
 RefPtr<NGPhysicalTextFragment> NGFragmentBuilder::ToTextFragment(
     NGInlineNode* node,
     unsigned index,
     unsigned start_offset,
     unsigned end_offset) {
   DCHECK_EQ(type_, NGPhysicalFragment::kFragmentText);
   DCHECK(children_.isEmpty());
   DCHECK(offsets_.isEmpty());
 
   Vector<Persistent<NGFloatingObject>> empty_unpositioned_floats;
   Vector<Persistent<NGFloatingObject>> empty_positioned_floats;
 
   return adoptRef(new NGPhysicalTextFragment(
       layout_object_, node, index, start_offset, end_offset,
       size_.ConvertToPhysical(writing_mode_),
-      overflow_.ConvertToPhysical(writing_mode_), out_of_flow_descendants_,
-      out_of_flow_positions_, empty_unpositioned_floats,
-      empty_positioned_floats));
+      overflow_.ConvertToPhysical(writing_mode_)));
 }
 
 }  // namespace blink