Revert of [LayoutNG] Remove simple constructors from NGPhysicalConstraintSpace.

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_constraint_space_builder.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 {
 
 NGConstraintSpace* ConstructConstraintSpace(NGWritingMode writing_mode,
                                             NGDirection direction,
-                                            NGLogicalSize size) {
-  NGConstraintSpaceBuilder builder(writing_mode);
-  return new NGConstraintSpace(
-      writing_mode, direction,
-      builder.SetContainerSize(size).ToConstraintSpace());
+                                            NGPhysicalSize size) {
+  return new NGConstraintSpace(writing_mode, direction,
+                               new NGPhysicalConstraintSpace(size));
 }
 
 class NGBlockLayoutAlgorithmTest : public ::testing::Test {
  protected:
   void SetUp() override { style_ = ComputedStyle::create(); }
 
   NGPhysicalFragment* RunBlockLayoutAlgorithm(NGConstraintSpace* space,
                                               NGBox* first_child) {
     NGBlockLayoutAlgorithm algorithm(style_, first_child, space);
     NGPhysicalFragment* frag;
     while (!algorithm.Layout(&frag))
       continue;
     return frag;
   }
 
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGBlockLayoutAlgorithmTest, FixedSize) {
   style_->setWidth(Length(30, Fixed));
   style_->setHeight(Length(40, Fixed));
 
   auto* space = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   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 = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   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 23 matching lines @@
 
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   div2_style->setHeight(Length(kHeight, Fixed));
   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 =
-      ConstructConstraintSpace(HorizontalTopBottom, LeftToRight,
-                               NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
+  auto* space = ConstructConstraintSpace(
+      HorizontalTopBottom, LeftToRight,
+      NGPhysicalSize(LayoutUnit(500), LayoutUnit(500)));
   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 23 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 = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   space->SetIsNewFormattingContext(true);
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   EXPECT_TRUE(frag->MarginStrut().IsEmpty());
   ASSERT_EQ(frag->Children().size(), 1UL);
   const NGPhysicalFragment* div2_fragment =
       static_cast<const NGPhysicalFragment*>(frag->Children()[0].get());
   EXPECT_EQ(NGMarginStrut({LayoutUnit(kDiv2MarginTop)}),
             div2_fragment->MarginStrut());
   EXPECT_EQ(kDiv1MarginTop, div2_fragment->TopOffset());
@@ skipping 54 matching lines @@
 
   div1->SetFirstChild(div2);
   div2->SetNextSibling(div3);
   div1->SetNextSibling(div4);
   div4->SetNextSibling(div5);
   div5->SetFirstChild(div6);
   div6->SetNextSibling(div7);
 
   auto* space = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   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
@@ skipping 28 matching lines @@
   // DIV2
   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 = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   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);
   EXPECT_EQ(NGMarginStrut({LayoutUnit(0), LayoutUnit(kDiv1MarginBottom)}),
@@ skipping 28 matching lines @@
   RefPtr<ComputedStyle> div2_style = ComputedStyle::create();
   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 = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   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)}),
             static_cast<const NGPhysicalFragment*>(frag->Children()[0].get())
@@ skipping 33 matching lines @@
   NGBox* vertical_div = new NGBox(vertical_style.get());
 
   // Horizontal DIV
   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 =
-      ConstructConstraintSpace(VerticalLeftRight, LeftToRight,
-                               NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
+  auto* space = ConstructConstraintSpace(
+      VerticalLeftRight, LeftToRight,
+      NGPhysicalSize(LayoutUnit(500), LayoutUnit(500)));
   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 the margin strut of a child with a different writing mode does
@@ skipping 35 matching lines @@
 
   // DIV3
   RefPtr<ComputedStyle> div3_style = ComputedStyle::create();
   div3_style->setHeight(Length(kHeight, Fixed));
   div3_style->setMarginTop(Length(kMarginTop, Fixed));
   NGBox* div3 = new NGBox(div3_style.get());
 
   div1->SetFirstChild(div2);
   div1->SetNextSibling(div3);
 
-  auto* space =
-      ConstructConstraintSpace(HorizontalTopBottom, LeftToRight,
-                               NGLogicalSize(LayoutUnit(500), LayoutUnit(500)));
+  auto* space = ConstructConstraintSpace(
+      HorizontalTopBottom, LeftToRight,
+      NGPhysicalSize(LayoutUnit(500), LayoutUnit(500)));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
 
   ASSERT_EQ(frag->Children().size(), 2UL);
 
   const NGPhysicalFragmentBase* child1 = frag->Children()[0];
   EXPECT_EQ(0, child1->TopOffset());
   EXPECT_EQ(kHeight, child1->Height());
 
   const NGPhysicalFragmentBase* child2 = frag->Children()[1];
   EXPECT_EQ(kHeight + std::max(kMarginBottom, kMarginTop), child2->TopOffset());
@@ skipping 42 matching lines @@
   div1_style->setPaddingLeft(Length(kPaddingLeft, Fixed));
   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 = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(1000), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(1000), NGSizeIndefinite));
   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 @@
   const int kWidth = 30;
   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 = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   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));
 }
 
 // A very simple auto margin case. We rely on the tests in ng_length_utils_test
 // for the more complex cases; just make sure we handle auto at all here.
 TEST_F(NGBlockLayoutAlgorithmTest, AutoMargin) {
   const int kPaddingLeft = 10;
   const int kWidth = 30;
   style_->setWidth(Length(kWidth, Fixed));
   style_->setPaddingLeft(Length(kPaddingLeft, Fixed));
 
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
   const int kChildWidth = 10;
   first_style->setWidth(Length(kChildWidth, Fixed));
   first_style->setMarginLeft(Length(Auto));
   first_style->setMarginRight(Length(Auto));
   NGBox* first_child = new NGBox(first_style.get());
 
   auto* space = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
+      NGPhysicalSize(LayoutUnit(100), NGSizeIndefinite));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, first_child);
 
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->Width());
   EXPECT_EQ(NGPhysicalFragmentBase::FragmentBox, frag->Type());
   EXPECT_EQ(LayoutUnit(kWidth + kPaddingLeft), frag->WidthOverflow());
   ASSERT_EQ(1UL, frag->Children().size());
 
   const NGPhysicalFragmentBase* child = frag->Children()[0];
   EXPECT_EQ(LayoutUnit(kChildWidth), child->Width());
   EXPECT_EQ(LayoutUnit(kPaddingLeft + 10), child->LeftOffset());
@@ skipping 48 matching lines @@
   div3_style->setHeight(Length(kDiv3Size, Fixed));
   div3_style->setMarginLeft(Length(kDiv3LeftMargin, Fixed));
   div3_style->setFloating(EFloat::Left);
   NGBox* div3 = new NGBox(div3_style.get());
 
   div1->SetNextSibling(div2);
   div2->SetNextSibling(div3);
 
   auto* space = ConstructConstraintSpace(
       HorizontalTopBottom, LeftToRight,
-      NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
+      NGPhysicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   NGPhysicalFragment* frag = RunBlockLayoutAlgorithm(space, div1);
   ASSERT_EQ(frag->Children().size(), 3UL);
 
   // DIV1
   const NGPhysicalFragmentBase* child1 = frag->Children()[0];
   EXPECT_EQ(kDiv1TopMargin, child1->TopOffset());
   EXPECT_EQ(0, child1->LeftOffset());
 
   // DIV2
   const NGPhysicalFragmentBase* child2 = frag->Children()[1];
   EXPECT_EQ(0, child2->TopOffset());
   EXPECT_EQ(kParentSize - kDiv2Size, child2->LeftOffset());
 
   // DIV3
   const NGPhysicalFragmentBase* child3 = frag->Children()[2];
   EXPECT_EQ(kDiv2Size, child3->TopOffset());
   EXPECT_EQ(kDiv3LeftMargin, child3->LeftOffset());
 }
 }  // namespace
 }  // namespace blink