[layoutng] Split NGLayoutResult out of NGPhysicalFragment

third_party/WebKit/Source/core/layout/ng/ng_out_of_flow_layout_part.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_out_of_flow_layout_part.h"
 
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_node.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
@@ skipping 60 matching lines @@
   while (out_of_flow_candidates.size() > 0) {
     size_t position_index = 0;
 
     for (auto& descendant : out_of_flow_candidates) {
       NGStaticPosition static_position =
           out_of_flow_candidate_positions[position_index++];
 
       if (IsContainingBlockForAbsoluteDescendant(container_style_,
                                                  descendant->Style())) {
         NGLogicalOffset offset;
-        RefPtr<NGPhysicalFragment> physical_fragment =
+        RefPtr<NGLayoutResult> result =
             LayoutDescendant(*descendant, static_position, &offset);
         // TODO(atotic) Need to adjust size of overflow rect per spec.
-        container_builder_->AddChild(std::move(physical_fragment), offset);
+        container_builder_->AddChild(result, offset);

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

std::move needed?

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

Done.

       } else {
         container_builder_->AddOutOfFlowDescendant(descendant, static_position);
       }
     }
     // Sweep any descendants that might have been added.
     // This happens when an absolute container has a fixed child.
     out_of_flow_candidates.clear();
     out_of_flow_candidate_positions.clear();
     container_builder_->GetAndClearOutOfFlowDescendantCandidates(
         &out_of_flow_candidates, &out_of_flow_candidate_positions);
   }
 }
 
-RefPtr<NGPhysicalFragment> NGOutOfFlowLayoutPart::LayoutDescendant(
+RefPtr<NGLayoutResult> NGOutOfFlowLayoutPart::LayoutDescendant(
     NGBlockNode& descendant,
     NGStaticPosition static_position,
     NGLogicalOffset* offset) {
   // Adjust the static_position origin. The static_position coordinate origin is
   // relative to the container's border box, ng_absolute_utils expects it to be
   // relative to the container's padding box.
   static_position.offset -= container_border_physical_offset_;
 
-  RefPtr<NGPhysicalFragment> physical_fragment = nullptr;
+  RefPtr<NGLayoutResult> layout_result = nullptr;
   Optional<MinAndMaxContentSizes> inline_estimate;
   Optional<LayoutUnit> block_estimate;
 
   if (AbsoluteNeedsChildInlineSize(descendant.Style())) {
     inline_estimate = descendant.ComputeMinAndMaxContentSizes();
   }
 
   NGAbsolutePhysicalPosition node_position =
       ComputePartialAbsoluteWithChildInlineSize(
           *container_space_, descendant.Style(), static_position,
           inline_estimate);
 
   if (AbsoluteNeedsChildBlockSize(descendant.Style())) {
-    physical_fragment =
-        GenerateFragment(descendant, block_estimate, node_position);
+    layout_result = GenerateFragment(descendant, block_estimate, node_position);
 
     // TODO(ikilpatrick): the writing mode switching here looks wrong.
-    NGBoxFragment fragment(container_space_->WritingMode(),
-                           toNGPhysicalBoxFragment(physical_fragment.get()));
+    NGBoxFragment fragment(
+        container_space_->WritingMode(),
+        toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get()));
 
     block_estimate = fragment.BlockSize();
   }
 
   ComputeFullAbsoluteWithChildBlockSize(*container_space_, descendant.Style(),
                                         static_position, block_estimate,
                                         &node_position);
 
   // Skip this step if we produced a fragment when estimating the block size.
-  if (!physical_fragment) {
+  if (!layout_result) {
     block_estimate =
         node_position.size.ConvertToLogical(container_space_->WritingMode())
             .block_size;
-    physical_fragment =
-        GenerateFragment(descendant, block_estimate, node_position);
+    layout_result = GenerateFragment(descendant, block_estimate, node_position);
   }
 
   // Compute logical offset, NGAbsolutePhysicalPosition is calculated relative
   // to the padding box so add back the container's borders.
   NGBoxStrut inset = node_position.inset.ConvertToLogical(
       container_space_->WritingMode(), container_space_->Direction());
   offset->inline_offset =
       inset.inline_start + container_border_offset_.inline_offset;
   offset->block_offset =
       inset.block_start + container_border_offset_.block_offset;
 
-  return physical_fragment;
+  return layout_result;
 }
 
-RefPtr<NGPhysicalFragment> NGOutOfFlowLayoutPart::GenerateFragment(
+RefPtr<NGLayoutResult> NGOutOfFlowLayoutPart::GenerateFragment(
     NGBlockNode& descendant,
     const Optional<LayoutUnit>& block_estimate,
     const NGAbsolutePhysicalPosition node_position) {
   // The fragment is generated in one of these two scenarios:
   // 1. To estimate descendant's block size, in this case block_size is
   //    container's available size.
   // 2. To compute final fragment, when block size is known from the absolute
   //    position calculation.
   LayoutUnit inline_size =
       node_position.size.ConvertToLogical(container_space_->WritingMode())
@@ skipping 11 matching lines @@
     builder.SetIsFixedSizeBlock(true);
   builder.SetIsFixedSizeInline(true);
   builder.SetIsNewFormattingContext(true);
   NGConstraintSpace* space =
       builder.ToConstraintSpace(container_space_->WritingMode());
 
   return descendant.Layout(space);
 }
 
 }  // namespace blink