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

third_party/WebKit/Source/core/layout/ng/ng_absolute_utils.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_absolute_utils.h"
 
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LengthFunctions.h"
@@ skipping 10 matching lines @@
 
 bool AbsoluteVerticalNeedsEstimate(const ComputedStyle& style) {
   Length height = style.height();
   return height.isIntrinsic() ||
          (height.isAuto() && (style.top().isAuto() || style.bottom().isAuto()));
 }
 
 LayoutUnit ResolveWidth(const Length& width,
                         const NGConstraintSpace& space,
                         const ComputedStyle& style,
-                        const Optional<MinMaxContentSize>& child_minmax,
+                        const Optional<MinAndMaxContentSizes>& child_minmax,
                         LengthResolveType resolve_type) {
   if (space.WritingMode() == kHorizontalTopBottom)
     return ResolveInlineLength(space, style, child_minmax, width, resolve_type);
   LayoutUnit computed_width =
       child_minmax.has_value() ? child_minmax->max_content : LayoutUnit();
   return ResolveBlockLength(space, style, style.width(), computed_width,
                             resolve_type);
 }
 
 LayoutUnit ResolveHeight(const Length& height,
                          const NGConstraintSpace& space,
                          const ComputedStyle& style,
-                         const Optional<MinMaxContentSize>& child_minmax,
+                         const Optional<MinAndMaxContentSizes>& child_minmax,
                          LengthResolveType resolve_type) {
   if (space.WritingMode() != kHorizontalTopBottom)
     return ResolveInlineLength(space, style, child_minmax, height,
                                resolve_type);
   LayoutUnit computed_height =
       child_minmax.has_value() ? child_minmax->max_content : LayoutUnit();
   return ResolveBlockLength(space, style, height, computed_height,
                             resolve_type);
 }
 
 // Implement absolute horizontal size resolution algorithm.
 // https://www.w3.org/TR/css-position-3/#abs-non-replaced-width
-void ComputeAbsoluteHorizontal(const NGConstraintSpace& space,
-                               const ComputedStyle& style,
-                               const Optional<LayoutUnit>& incoming_width,
-                               const NGStaticPosition& static_position,
-                               const Optional<MinMaxContentSize>& child_minmax,
-                               NGAbsolutePhysicalPosition* position) {
+void ComputeAbsoluteHorizontal(
+    const NGConstraintSpace& space,
+    const ComputedStyle& style,
+    const Optional<LayoutUnit>& incoming_width,
+    const NGStaticPosition& static_position,
+    const Optional<MinAndMaxContentSizes>& child_minmax,
+    NGAbsolutePhysicalPosition* position) {
   NGLogicalSize percentage_logical = space.PercentageResolutionSize();
   NGPhysicalSize percentage_physical =
       percentage_logical.ConvertToPhysical(space.WritingMode());
   LayoutUnit border_left(style.borderLeftWidth());
   LayoutUnit border_right(style.borderRightWidth());
   LayoutUnit padding_left =
       valueForLength(style.paddingLeft(), percentage_logical.inline_size);
   LayoutUnit padding_right =
       valueForLength(style.paddingRight(), percentage_logical.inline_size);
   Optional<LayoutUnit> margin_left;
@@ skipping 134 matching lines @@
   // Negative widths are not allowed.
   width = std::max(*width, border_padding);
 
   position->inset.left = *left + *margin_left;
   position->inset.right = *right + *margin_right;
   position->size.width = *width;
 }
 
 // Implements absolute vertical size resolution algorithm.
 // https://www.w3.org/TR/css-position-3/#abs-non-replaced-height
-void ComputeAbsoluteVertical(const NGConstraintSpace& space,
-                             const ComputedStyle& style,
-                             const Optional<LayoutUnit>& incoming_height,
-                             const NGStaticPosition& static_position,
-                             const Optional<MinMaxContentSize>& child_minmax,
-                             NGAbsolutePhysicalPosition* position) {
+void ComputeAbsoluteVertical(
+    const NGConstraintSpace& space,
+    const ComputedStyle& style,
+    const Optional<LayoutUnit>& incoming_height,
+    const NGStaticPosition& static_position,
+    const Optional<MinAndMaxContentSizes>& child_minmax,
+    NGAbsolutePhysicalPosition* position) {
   NGLogicalSize percentage_logical = space.PercentageResolutionSize();
   NGPhysicalSize percentage_physical =
       percentage_logical.ConvertToPhysical(space.WritingMode());
 
   LayoutUnit border_top(style.borderTopWidth());
   LayoutUnit border_bottom(style.borderBottomWidth());
   LayoutUnit padding_top =
       valueForLength(style.paddingTop(), percentage_logical.inline_size);
   LayoutUnit padding_bottom =
       valueForLength(style.paddingBottom(), percentage_logical.inline_size);
@@ skipping 141 matching lines @@
   if (style.isHorizontalWritingMode())
     return AbsoluteHorizontalNeedsEstimate(style);
   else
     return AbsoluteVerticalNeedsEstimate(style);
 }
 
 NGAbsolutePhysicalPosition ComputePartialAbsoluteWithChildInlineSize(
     const NGConstraintSpace& space,
     const ComputedStyle& style,
     const NGStaticPosition& static_position,
-    const Optional<MinMaxContentSize>& child_minmax) {
+    const Optional<MinAndMaxContentSizes>& child_minmax) {
   NGAbsolutePhysicalPosition position;
   if (style.isHorizontalWritingMode()) {
     Optional<LayoutUnit> width;
     if (!style.width().isAuto()) {
       width = ResolveWidth(style.width(), space, style, child_minmax,
                            LengthResolveType::kContentSize);
     }
     ComputeAbsoluteHorizontal(space, style, width, static_position,
                               child_minmax, &position);
   } else {
@@ skipping 11 matching lines @@
 void ComputeFullAbsoluteWithChildBlockSize(
     const NGConstraintSpace& space,
     const ComputedStyle& style,
     const NGStaticPosition& static_position,
     const Optional<LayoutUnit>& child_block_size,
     NGAbsolutePhysicalPosition* position) {
   // After partial size has been computed, child block size is either
   // unknown, or fully computed, there is no minmax.
   // To express this, a 'fixed' minmax is created where
   // min and max are the same.
-  Optional<MinMaxContentSize> child_minmax;
+  Optional<MinAndMaxContentSizes> child_minmax;
   if (child_block_size.has_value()) {
-    child_minmax = MinMaxContentSize{*child_block_size, *child_block_size};
+    child_minmax = MinAndMaxContentSizes{*child_block_size, *child_block_size};
   }
   if (style.isHorizontalWritingMode()) {
     Optional<LayoutUnit> height;
     if (!style.height().isAuto()) {
       height = ResolveHeight(style.height(), space, style, child_minmax,
                              LengthResolveType::kContentSize);
     }
     ComputeAbsoluteVertical(space, style, height, static_position, child_minmax,
                             position);
   } else {
     Optional<LayoutUnit> width;
     if (!style.width().isAuto()) {
       width = ResolveWidth(style.width(), space, style, child_minmax,
                            LengthResolveType::kContentSize);
     }
     ComputeAbsoluteHorizontal(space, style, width, static_position,
                               child_minmax, position);
   }
 }
 
 }  // namespace blink