[LayoutNG] Move remaining ng_units structs to their own files

third_party/WebKit/Source/core/layout/ng/ng_length_utils_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_length_utils.h"
 
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_physical_box_fragment.h"
-#include "core/layout/ng/ng_units.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/CalculationValue.h"
 #include "platform/LayoutUnit.h"
 #include "platform/Length.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 namespace {
 
@@ skipping 11 matching lines @@
         .SetPercentageResolutionSize(
             NGLogicalSize(LayoutUnit(inline_size), LayoutUnit(block_size)))
         .SetIsFixedSizeInline(fixed_inline)
         .SetIsFixedSizeBlock(fixed_block)
         .ToConstraintSpace(kHorizontalTopBottom);
   }
 
   LayoutUnit ResolveInlineLength(
       const Length& length,
       LengthResolveType type = LengthResolveType::kContentSize,
-      const WTF::Optional<MinAndMaxContentSizes>& sizes = WTF::nullopt) {
+      const WTF::Optional<MinMaxContentSize>& sizes = WTF::nullopt) {
     NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200, 300);
     return ::blink::ResolveInlineLength(*constraintSpace, *style_, sizes,
                                         length, type);
   }
 
   LayoutUnit ResolveBlockLength(
       const Length& length,
       LengthResolveType type = LengthResolveType::kContentSize,
       LayoutUnit contentSize = LayoutUnit()) {
     NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200, 300);
     return ::blink::ResolveBlockLength(*constraintSpace, *style_, length,
                                        contentSize, type);
   }
 
   LayoutUnit ComputeInlineSizeForFragment(
       const NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200,
                                                                           300),
-      const MinAndMaxContentSizes& sizes = MinAndMaxContentSizes()) {
+      const MinMaxContentSize& sizes = MinMaxContentSize()) {
     return ::blink::ComputeInlineSizeForFragment(*constraintSpace, *style_,
                                                  sizes);
   }
 
   LayoutUnit ComputeBlockSizeForFragment(
       const NGConstraintSpace* constraintSpace = ConstructConstraintSpace(200,
                                                                           300),
       LayoutUnit contentSize = LayoutUnit()) {
     return ::blink::ComputeBlockSizeForFragment(*constraintSpace, *style_,
                                                 contentSize);
   }
 
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGLengthUtilsTest, testResolveInlineLength) {
   EXPECT_EQ(LayoutUnit(60), ResolveInlineLength(Length(30, Percent)));
   EXPECT_EQ(LayoutUnit(150), ResolveInlineLength(Length(150, Fixed)));
   EXPECT_EQ(LayoutUnit(0),
             ResolveInlineLength(Length(Auto), LengthResolveType::kMinSize));
   EXPECT_EQ(LayoutUnit(200), ResolveInlineLength(Length(Auto)));
   EXPECT_EQ(LayoutUnit(200), ResolveInlineLength(Length(FillAvailable)));
 
   EXPECT_EQ(LayoutUnit(200),
             ResolveInlineLength(Length(Auto), LengthResolveType::kMaxSize));
   EXPECT_EQ(LayoutUnit(200), ResolveInlineLength(Length(FillAvailable),
                                                  LengthResolveType::kMaxSize));
-  MinAndMaxContentSizes sizes;
+  MinMaxContentSize sizes;
   sizes.min_content = LayoutUnit(30);
   sizes.max_content = LayoutUnit(40);
   EXPECT_EQ(LayoutUnit(30),
             ResolveInlineLength(Length(MinContent),
                                 LengthResolveType::kContentSize, sizes));
   EXPECT_EQ(LayoutUnit(40),
             ResolveInlineLength(Length(MaxContent),
                                 LengthResolveType::kContentSize, sizes));
   EXPECT_EQ(LayoutUnit(40),
             ResolveInlineLength(Length(FitContent),
@@ skipping 15 matching lines @@
   EXPECT_EQ(LayoutUnit(300), ResolveBlockLength(Length(FillAvailable)));
 
   EXPECT_EQ(LayoutUnit(0),
             ResolveBlockLength(Length(Auto), LengthResolveType::kContentSize));
   EXPECT_EQ(LayoutUnit(300),
             ResolveBlockLength(Length(FillAvailable),
                                LengthResolveType::kContentSize));
 }
 
 TEST_F(NGLengthUtilsTest, testComputeContentContribution) {
-  MinAndMaxContentSizes sizes;
+  MinMaxContentSize sizes;
   sizes.min_content = LayoutUnit(30);
   sizes.max_content = LayoutUnit(40);
 
-  MinAndMaxContentSizes expected{LayoutUnit(), LayoutUnit()};
+  MinMaxContentSize expected{LayoutUnit(), LayoutUnit()};
   style_->setLogicalWidth(Length(30, Percent));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
   style_->setLogicalWidth(Length(FillAvailable));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
-  expected = MinAndMaxContentSizes{LayoutUnit(150), LayoutUnit(150)};
+  expected = MinMaxContentSize{LayoutUnit(150), LayoutUnit(150)};
   style_->setLogicalWidth(Length(150, Fixed));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
   expected = sizes;
   style_->setLogicalWidth(Length(Auto));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
-  expected = MinAndMaxContentSizes{LayoutUnit(430), LayoutUnit(440)};
+  expected = MinMaxContentSize{LayoutUnit(430), LayoutUnit(440)};
   style_->setPaddingLeft(Length(400, Fixed));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
-  expected = MinAndMaxContentSizes{LayoutUnit(100), LayoutUnit(100)};
+  expected = MinMaxContentSize{LayoutUnit(100), LayoutUnit(100)};
   style_->setPaddingLeft(Length(0, Fixed));
   style_->setLogicalWidth(Length(CalculationValue::create(
       PixelsAndPercent(100, -10), ValueRangeNonNegative)));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
-  expected = MinAndMaxContentSizes{LayoutUnit(30), LayoutUnit(35)};
+  expected = MinMaxContentSize{LayoutUnit(30), LayoutUnit(35)};
   style_->setLogicalWidth(Length(Auto));
   style_->setMaxWidth(Length(35, Fixed));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
-  expected = MinAndMaxContentSizes{LayoutUnit(80), LayoutUnit(80)};
+  expected = MinMaxContentSize{LayoutUnit(80), LayoutUnit(80)};
   style_->setLogicalWidth(Length(50, Fixed));
   style_->setMinWidth(Length(80, Fixed));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
-  expected = MinAndMaxContentSizes{LayoutUnit(150), LayoutUnit(150)};
+  expected = MinMaxContentSize{LayoutUnit(150), LayoutUnit(150)};
   style_ = ComputedStyle::create();
   style_->setLogicalWidth(Length(100, Fixed));
   style_->setPaddingLeft(Length(50, Fixed));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
-  expected = MinAndMaxContentSizes{LayoutUnit(100), LayoutUnit(100)};
+  expected = MinMaxContentSize{LayoutUnit(100), LayoutUnit(100)};
   style_->setBoxSizing(EBoxSizing::kBorderBox);
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
   // Content size should never be below zero, even with box-sizing: border-box
   // and a large padding...
-  expected = MinAndMaxContentSizes{LayoutUnit(400), LayoutUnit(400)};
+  expected = MinMaxContentSize{LayoutUnit(400), LayoutUnit(400)};
   style_->setPaddingLeft(Length(400, Fixed));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 
   expected.min_content = expected.max_content =
       sizes.min_content + LayoutUnit(400);
   style_->setLogicalWidth(Length(MinContent));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
   style_->setLogicalWidth(Length(100, Fixed));
   style_->setMaxWidth(Length(MaxContent));
   // Due to padding and box-sizing, width computes to 400px and max-width to
   // 440px, so the result is 400.
-  expected = MinAndMaxContentSizes{LayoutUnit(400), LayoutUnit(400)};
+  expected = MinMaxContentSize{LayoutUnit(400), LayoutUnit(400)};
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
-  expected = MinAndMaxContentSizes{LayoutUnit(40), LayoutUnit(40)};
+  expected = MinMaxContentSize{LayoutUnit(40), LayoutUnit(40)};
   style_->setPaddingLeft(Length(0, Fixed));
   EXPECT_EQ(expected, ComputeMinAndMaxContentContribution(*style_, sizes));
 }
 
 TEST_F(NGLengthUtilsTest, testComputeInlineSizeForFragment) {
-  MinAndMaxContentSizes sizes;
+  MinMaxContentSize sizes;
   sizes.min_content = LayoutUnit(30);
   sizes.max_content = LayoutUnit(40);
 
   style_->setLogicalWidth(Length(30, Percent));
   EXPECT_EQ(LayoutUnit(60), ComputeInlineSizeForFragment());
 
   style_->setLogicalWidth(Length(150, Fixed));
   EXPECT_EQ(LayoutUnit(150), ComputeInlineSizeForFragment());
 
   style_->setLogicalWidth(Length(Auto));
@@ skipping 282 matching lines @@
   EXPECT_EQ(125, GetUsedColumnWidth(4, 100, 10, 530));
   EXPECT_EQ(4, GetUsedColumnCount(4, 100, 10, 530));
   EXPECT_EQ(100, GetUsedColumnWidth(6, 100, 10, 540));
   EXPECT_EQ(5, GetUsedColumnCount(6, 100, 10, 540));
   EXPECT_EQ(100, GetUsedColumnWidth(0, 100, 10, 540));
   EXPECT_EQ(5, GetUsedColumnCount(0, 100, 10, 540));
 }
 
 }  // namespace
 }  // namespace blink