[layoutng] Split NGLayoutResult out of 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_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_column_mapper.h"
@@ skipping 341 matching lines @@
   LayoutUnit inline_offset =
       border_and_padding_.inline_start + curr_child_margins_.inline_start;
   LayoutUnit block_offset = content_size_;
   if (known_fragment_offset) {
     block_offset = known_fragment_offset.value().block_offset -
                    builder_->BfcOffset().value().block_offset;
   }
   return {inline_offset, block_offset};
 }
 
-RefPtr<NGPhysicalFragment> NGBlockLayoutAlgorithm::Layout() {
+RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() {
   WTF::Optional<MinAndMaxContentSizes> sizes;
   if (NeedMinAndMaxContentSizes(ConstraintSpace(), Style()))
     sizes = ComputeMinAndMaxContentSizes();
 
   border_and_padding_ =
       ComputeBorders(Style()) + ComputePadding(ConstraintSpace(), Style());
 
   LayoutUnit inline_size =
       ComputeInlineSizeForFragment(ConstraintSpace(), Style(), sizes);
   LayoutUnit adjusted_inline_size =
@@ skipping 67 matching lines @@
 
     DCHECK(!ConstraintSpace().HasBlockFragmentation() ||
            SpaceAvailableForCurrentChild() > LayoutUnit());
     space_for_current_child_ = CreateConstraintSpaceForCurrentChild();
 
     if (current_child_->Type() == NGLayoutInputNode::kLegacyInline) {
       LayoutInlineChildren(toNGInlineNode(current_child_));
       continue;
     }
 
-    RefPtr<NGPhysicalFragment> physical_fragment =
+    RefPtr<NGLayoutResult> layout_result =
         current_child_->Layout(space_for_current_child_);
 
-    FinishCurrentChildLayout(toNGPhysicalBoxFragment(physical_fragment.get()));
+    FinishCurrentChildLayout(layout_result);
 
-    if (!ProceedToNextUnfinishedSibling(physical_fragment.get()))
+    if (!ProceedToNextUnfinishedSibling(
+            layout_result->PhysicalFragment().get()))
       break;
   }
 
   // Margins collapsing:
   //   Bottom margins of an in-flow block box doesn't collapse with its last
   //   in-flow block-level child's bottom margin if the box has bottom
   //   border/padding.
   content_size_ += border_and_padding_.block_end;
   if (border_and_padding_.block_end ||
       ConstraintSpace().IsNewFormattingContext()) {
@@ skipping 37 matching lines @@
 void NGBlockLayoutAlgorithm::LayoutInlineChildren(NGInlineNode* current_child) {
   // TODO(kojii): This logic does not handle when children are mix of
   // inline/block. We need to detect the case and setup appropriately; e.g.,
   // constraint space, margin collapsing, next siblings, etc.
   NGLineBuilder line_builder(current_child, space_for_current_child_);
   current_child->LayoutInline(space_for_current_child_, &line_builder);
   // TODO(kojii): The wrapper fragment should not be needed.
   NGFragmentBuilder wrapper_fragment_builder(NGPhysicalFragment::kFragmentBox,
                                              current_child->GetLayoutObject());
   line_builder.CreateFragments(&wrapper_fragment_builder);
-  RefPtr<NGPhysicalBoxFragment> child_fragment =
+  RefPtr<NGLayoutResult> child_result =
       wrapper_fragment_builder.ToBoxFragment();
   line_builder.CopyFragmentDataToLayoutBlockFlow();
-  FinishCurrentChildLayout(child_fragment.get());
+  FinishCurrentChildLayout(child_result);
   current_child_ = nullptr;
 }
 
 void NGBlockLayoutAlgorithm::FinishCurrentChildLayout(
-    RefPtr<NGPhysicalBoxFragment> physical_fragment) {
-  NGBoxFragment fragment(ConstraintSpace().WritingMode(),
-                         physical_fragment.get());
+    RefPtr<NGLayoutResult> layout_result) {
+  NGBoxFragment fragment(
+      ConstraintSpace().WritingMode(),
+      toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get()));
 
-  if (!physical_fragment->UnpositionedFloats().isEmpty())
+  if (!layout_result->UnpositionedFloats().isEmpty())
     DCHECK(!builder_->BfcOffset()) << "Parent BFC offset shouldn't be set here";
   // Pull out unpositioned floats to the current fragment. This may needed if
   // for example the child fragment could not position its floats because it's
   // empty and therefore couldn't determine its position in space.
   builder_->MutableUnpositionedFloats().appendVector(
-      physical_fragment->UnpositionedFloats());
+      layout_result->UnpositionedFloats());
 
   if (current_child_->Type() == NGLayoutInputNode::kLegacyBlock &&
       CurrentChildStyle().isFloating()) {
-    NGFloatingObject* floating_object =
-        new NGFloatingObject(physical_fragment.get(), space_for_current_child_,
-                             constraint_space_, toNGBlockNode(current_child_),
-                             CurrentChildStyle(), curr_child_margins_);
+    NGFloatingObject* floating_object = new NGFloatingObject(
+        layout_result->PhysicalFragment().get(), space_for_current_child_,
+        constraint_space_, toNGBlockNode(current_child_), CurrentChildStyle(),
+        curr_child_margins_);
     builder_->AddUnpositionedFloat(floating_object);
     // No need to postpone the positioning if we know the correct offset.
     if (builder_->BfcOffset()) {
       NGLogicalOffset origin_point = curr_bfc_offset_;
       // Adjust origin point to the margins of the last child.
       // Example: <div style="margin-bottom: 20px"><float></div>
       //          <div style="margin-bottom: 30px"></div>
       origin_point.block_offset += curr_margin_strut_.Sum();
       PositionPendingFloats(origin_point.block_offset, ConstraintSpace(),
                             builder_.get());
@@ skipping 27 matching lines @@
   // Update margin strut.
   curr_margin_strut_ = fragment.EndMarginStrut();
   curr_margin_strut_.Append(curr_child_margins_.block_end);
 
   content_size_ = fragment.BlockSize() + logical_offset.block_offset;
   max_inline_size_ =
       std::max(max_inline_size_, fragment.InlineSize() +
                                      curr_child_margins_.InlineSum() +
                                      border_and_padding_.InlineSum());
 
-  builder_->AddChild(std::move(physical_fragment), logical_offset);
+  builder_->AddChild(layout_result, logical_offset);
 }
 
 bool NGBlockLayoutAlgorithm::ProceedToNextUnfinishedSibling(
     NGPhysicalFragment* child_fragment) {
   DCHECK(current_child_);
   NGBlockNode* finished_child = toNGBlockNode(current_child_);
   current_child_ = current_child_->NextSibling();
   if (!ConstraintSpace().HasBlockFragmentation() && !fragmentainer_mapper_)
     return true;
   // If we're resuming layout after a fragmentainer break, we need to skip
@@ skipping 216 matching lines @@
     curr_bfc_offset_.inline_offset += curr_child_margins_.inline_start;
   }
 
   space_builder_->SetBfcOffset(curr_bfc_offset_);
 
   return space_builder_->ToConstraintSpace(
       FromPlatformWritingMode(current_child_style.getWritingMode()));
 }
 
 }  // namespace blink