Make NGFragment to own NGPhysicalFragment

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm_test.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_box.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_physical_fragment.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_units.h"
 #include "core/style/ComputedStyle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 namespace {
 
 class NGBlockLayoutAlgorithmTest : public ::testing::Test {
  protected:
   void SetUp() override { style_ = ComputedStyle::create(); }
 
   NGPhysicalFragment* RunBlockLayoutAlgorithm(const NGConstraintSpace* space,
                                               NGBox* first_child) {
     NGBlockLayoutAlgorithm algorithm(style_, first_child);
     NGPhysicalFragment* frag;
-    while (!algorithm.Layout(space, &frag))
+    while (!algorithm.Layout(*space, &frag))
       continue;
     return frag;
   }
 
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGBlockLayoutAlgorithmTest, FixedSize) {
   style_->setWidth(Length(30, Fixed));
   style_->setHeight(Length(40, Fixed));
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, nullptr);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, nullptr));
 
   EXPECT_EQ(LayoutUnit(30), frag->Width());
   EXPECT_EQ(LayoutUnit(40), frag->Height());
 }
 
 // Verifies that two children are laid out with the correct size and position.
 TEST_F(NGBlockLayoutAlgorithmTest, LayoutBlockChildren) {
   const int kWidth = 30;
   const int kHeight1 = 20;
   const int kHeight2 = 30;
   const int kMarginTop = 5;
   const int kMarginBottom = 20;
   style_->setWidth(Length(kWidth, Fixed));
 
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
   first_style->setHeight(Length(kHeight1, Fixed));
   NGBox* first_child = new NGBox(first_style.get());
 
   RefPtr<ComputedStyle> second_style = ComputedStyle::create();
   second_style->setHeight(Length(kHeight2, Fixed));
   second_style->setMarginTop(Length(kMarginTop, Fixed));
   second_style->setMarginBottom(Length(kMarginBottom, Fixed));
   NGBox* second_child = new NGBox(second_style.get());
 
   first_child->SetNextSibling(second_child);
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, first_child));
 
   EXPECT_EQ(LayoutUnit(kWidth), frag->Width());
   EXPECT_EQ(LayoutUnit(kHeight1 + kHeight2 + kMarginTop), frag->Height());
   EXPECT_EQ(NGPhysicalFragmentBase::FragmentBox, frag->Type());
   ASSERT_EQ(frag->Children().size(), 2UL);
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(kHeight1, child->Height());
   EXPECT_EQ(0, child->TopOffset());
 
@@ skipping 25 matching lines @@
   div2_style->setWidth(Length(kWidth, Fixed));
   div1_style->setWritingMode(TopToBottomWritingMode);
   div2_style->setMarginLeft(Length(kMarginLeft, Fixed));
   NGBox* div2 = new NGBox(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, div1));
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   // DIV2
   child = static_cast<const NGPhysicalFragment*>(child)->Children()[0];
 
   EXPECT_EQ(kHeight, child->Height());
   EXPECT_EQ(0, child->TopOffset());
   EXPECT_EQ(kMarginLeft, child->LeftOffset());
 }
 
@@ skipping 22 matching lines @@
   // DIV2
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setMarginTop(Length(kDiv2MarginTop, Fixed));
   NGBox* div2 = new NGBox(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, div1));
 
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv1MarginTop)}), frag->MarginStrut());
   ASSERT_EQ(frag->Children().size(), 1UL);
   const NGPhysicalFragmentBase* div2_fragment = frag->Children()[0];
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv2MarginTop)}),
             div2_fragment->MarginStrut());
   EXPECT_EQ(kDiv1MarginTop, div2_fragment->TopOffset());
 }
 
 // Verifies the collapsing margins case for the next pair:
@@ skipping 52 matching lines @@
   div1->SetFirstChild(div2);
   div2->SetNextSibling(div3);
   div1->SetNextSibling(div4);
   div4->SetNextSibling(div5);
   div5->SetFirstChild(div6);
   div6->SetNextSibling(div7);
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, div1));
 
   ASSERT_EQ(frag->Children().size(), 3UL);
 
   // DIV1
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(kHeight, child->Height());
   EXPECT_EQ(0, child->TopOffset());
 
   // DIV5
   child = frag->Children()[2];
@@ skipping 28 matching lines @@
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setHeight(Length(kHeight, Fixed));
   div2_style->setMarginBottom(Length(kDiv2MarginBottom, Fixed));
   NGBox* div2 = new NGBox(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, div1));
 
   // Verify that margins are collapsed.
   EXPECT_EQ(NGMarginStrut({LayoutUnit(0), LayoutUnit(kDiv2MarginBottom)}),
             frag->MarginStrut());
 
   // Verify that margins are NOT collapsed.
   div1_style->setHeight(Length(kHeight, Fixed));
-  frag = RunBlockLayoutAlgorithm(space, div1);
+  frag.reset(RunBlockLayoutAlgorithm(space, div1));
   EXPECT_EQ(NGMarginStrut({LayoutUnit(0), LayoutUnit(kDiv1MarginBottom)}),
             frag->MarginStrut());
 }
 
 // Verifies that 2 adjoining margins are not collapsed if there is padding or
 // border that separates them.
 //
 // Test case's HTML representation:
 // <div style="margin: 30px 0px; padding: 20px 0px;">    <!-- DIV1 -->
 //   <div style="margin: 200px 0px; height: 50px;"/>     <!-- DIV2 -->
@@ skipping 20 matching lines @@
   div2_style->setHeight(Length(kHeight, Fixed));
   div2_style->setMarginTop(Length(kDiv2Margin, Fixed));
   div2_style->setMarginBottom(Length(kDiv2Margin, Fixed));
   NGBox* div2 = new NGBox(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, div1));
 
   // Verify that margins do NOT collapse.
-  frag = RunBlockLayoutAlgorithm(space, div1);
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv1Margin), LayoutUnit(kDiv1Margin)}),
             frag->MarginStrut());
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv2Margin), LayoutUnit(kDiv2Margin)}),
             frag->Children()[0]->MarginStrut());
 
   // Reset padding and verify that margins DO collapse.
   div1_style->setPaddingTop(Length(0, Fixed));
   div1_style->setPaddingBottom(Length(0, Fixed));
-  frag = RunBlockLayoutAlgorithm(space, div1);
+  frag.reset(RunBlockLayoutAlgorithm(space, div1));
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv2Margin), LayoutUnit(kDiv2Margin)}),
             frag->MarginStrut());
 }
 
 // Verifies that margins of 2 adjoining blocks with different writing modes
 // get collapsed.
 //
 // Test case's HTML representation:
 //   <div style="writing-mode: vertical-lr;">
 //     <div style="margin-right: 60px; width: 60px;">vertical</div>
@@ skipping 20 matching lines @@
   RefPtr<ComputedStyle> horizontal_style = ComputedStyle::create();
   horizontal_style->setMarginLeft(Length(kHorizontalDivMarginLeft, Fixed));
   horizontal_style->setWritingMode(TopToBottomWritingMode);
   NGBox* horizontal_div = new NGBox(horizontal_style.get());
 
   vertical_div->SetNextSibling(horizontal_div);
 
   auto* space =
       new NGConstraintSpace(VerticalLeftRight, LeftToRight,
                             NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, vertical_div);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, vertical_div));
 
   ASSERT_EQ(frag->Children().size(), 2UL);
   const NGPhysicalFragmentBase* child = frag->Children()[1];
   // Horizontal div
   EXPECT_EQ(0, child->TopOffset());
   EXPECT_EQ(kVerticalDivWidth + kHorizontalDivMarginLeft, child->LeftOffset());
 }
 
 // Verifies that a box's size includes its borders and padding, and that
 // children are positioned inside the content box.
@@ skipping 39 matching lines @@
   NGBox* div1 = new NGBox(div1_style.get());
 
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   NGBox* div2 = new NGBox(div2_style.get());
 
   div1->SetFirstChild(div2);
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(1000), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, div1));
 
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   // div1
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(kBorderLeft + kPaddingLeft + kWidth + kPaddingRight + kBorderRight,
             child->Width());
   EXPECT_EQ(kBorderTop + kPaddingTop + kHeight + kPaddingBottom + kBorderBottom,
             child->Height());
 
@@ skipping 13 matching lines @@
   style_->setWidth(Length(kWidth, Fixed));
   style_->setPaddingLeft(Length(kPaddingLeft, Fixed));
 
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
   first_style->setWidth(Length(40, Percent));
   NGBox* first_child = new NGBox(first_style.get());
 
   auto* space =
       new NGConstraintSpace(HorizontalTopBottom, LeftToRight,
                             NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
-  NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
+  std::unique_ptr<NGPhysicalFragment> frag(
+      RunBlockLayoutAlgorithm(space, first_child));
 
   EXPECT_EQ(frag->Width(), LayoutUnit(kWidth + kPaddingLeft));
   EXPECT_EQ(frag->Type(), NGPhysicalFragmentBase::FragmentBox);
   ASSERT_EQ(frag->Children().size(), 1UL);
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(child->Width(), LayoutUnit(12));
 }
 }  // namespace
 }  // namespace blink