Revert of [LayoutNG] Move remaining ng_units structs to their own files

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/dom/NodeComputedStyle.h"
 #include "core/dom/TagCollection.h"
 #include "core/layout/LayoutTestHelper.h"
 #include "core/layout/ng/layout_ng_block_flow.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_block_node.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_floating_object.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_physical_box_fragment.h"
 #include "core/layout/ng/ng_physical_fragment.h"
+#include "core/layout/ng/ng_units.h"
 #include "core/style/ComputedStyle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 namespace {
 
 using testing::ElementsAre;
 using testing::Pointee;
 
@@ skipping 58 matching lines @@
     NGBlockNode* node = new NGBlockNode(block_flow);
     NGConstraintSpace* space =
         NGConstraintSpace::CreateFromLayoutObject(*block_flow);
 
     RefPtr<NGLayoutResult> result =
         NGBlockLayoutAlgorithm(node, space).Layout();
     return std::make_pair(
         toNGPhysicalBoxFragment(result->PhysicalFragment().get()), space);
   }
 
-  MinMaxContentSize RunComputeMinAndMax(NGBlockNode* first_child) {
+  MinAndMaxContentSizes RunComputeMinAndMax(NGBlockNode* first_child) {
     // The constraint space is not used for min/max computation, but we need
     // it to create the algorithm.
     NGConstraintSpace* space =
         ConstructConstraintSpace(kHorizontalTopBottom, TextDirection::kLtr,
                                  NGLogicalSize(LayoutUnit(), LayoutUnit()));
     NGBlockNode* node = new NGBlockNode(style_.get());
     node->SetFirstChild(first_child);
 
     NGBlockLayoutAlgorithm algorithm(node, space);
-    EXPECT_TRUE(algorithm.ComputeMinMaxContentSize().has_value());
-    return *algorithm.ComputeMinMaxContentSize();
+    EXPECT_TRUE(algorithm.ComputeMinAndMaxContentSizes().has_value());
+    return *algorithm.ComputeMinAndMaxContentSizes();
   }
 
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGBlockLayoutAlgorithmTest, FixedSize) {
   style_->setWidth(Length(30, Fixed));
   style_->setHeight(Length(40, Fixed));
 
   auto* space = ConstructConstraintSpace(
@@ skipping 1174 matching lines @@
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
   first_style->setWidth(Length(kWidthChild1, Fixed));
   NGBlockNode* first_child = new NGBlockNode(first_style.get());
 
   RefPtr<ComputedStyle> second_style = ComputedStyle::create();
   second_style->setWidth(Length(kWidthChild2, Fixed));
   NGBlockNode* second_child = new NGBlockNode(second_style.get());
 
   first_child->SetNextSibling(second_child);
 
-  MinMaxContentSize sizes = RunComputeMinAndMax(first_child);
+  MinAndMaxContentSizes sizes = RunComputeMinAndMax(first_child);
   EXPECT_EQ(kWidthChild2, sizes.min_content);
   EXPECT_EQ(kWidthChild2, sizes.max_content);
 }
 
 // Tests that we correctly handle shrink-to-fit
 TEST_F(NGBlockLayoutAlgorithmTest, ShrinkToFit) {
   const int kWidthChild1 = 20;
   const int kWidthChild2 = 30;
 
   RefPtr<ComputedStyle> first_style = ComputedStyle::create();
@@ skipping 1160 matching lines @@
 
   child = iterator.NextChild();
   EXPECT_EQ(NGPhysicalSize(LayoutUnit(150), LayoutUnit(100)), child->Size());
   EXPECT_EQ(NGPhysicalOffset(LayoutUnit(0), LayoutUnit(40)), child->Offset());
 
   EXPECT_FALSE(iterator.NextChild());
 }
 
 }  // namespace
 }  // namespace blink