[LayoutNG] Move remaining ng_units structs to their own files

third_party/WebKit/Source/core/layout/ng/ng_length_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_length_utils.h"
 
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LayoutUnit.h"
 #include "platform/Length.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 // TODO(layout-ng):
 // - replaced calculations
 // - Take scrollbars into account
 
-bool NeedMinAndMaxContentSizes(const NGConstraintSpace& constraint_space,
-                               const ComputedStyle& style) {
+bool NeedMinMaxContentSize(const NGConstraintSpace& constraint_space,
+                           const ComputedStyle& style) {
   // This check is technically too broad (fill-available does not need intrinsic
   // size computation) but that's a rare case and only affects performance, not
   // correctness.
   return constraint_space.IsShrinkToFit() ||
          style.logicalWidth().isIntrinsic() ||
          style.logicalMinWidth().isIntrinsic() ||
          style.logicalMaxWidth().isIntrinsic();
 }
 
-bool NeedMinAndMaxContentSizesForContentContribution(
-    const ComputedStyle& style) {
+bool NeedMinMaxContentSizeForContentContribution(const ComputedStyle& style) {
   return style.logicalWidth().isIntrinsicOrAuto() ||
          style.logicalMinWidth().isIntrinsic() ||
          style.logicalMaxWidth().isIntrinsic();
 }
 
 LayoutUnit ResolveInlineLength(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
-    const WTF::Optional<MinAndMaxContentSizes>& min_and_max,
+    const WTF::Optional<MinMaxContentSize>& min_and_max,
     const Length& length,
     LengthResolveType type) {
   DCHECK(!length.isMaxSizeNone());
   DCHECK_GE(constraint_space.AvailableSize().inline_size, LayoutUnit());
   DCHECK_GE(constraint_space.PercentageResolutionSize().inline_size,
             LayoutUnit());
 
   if (type == LengthResolveType::kMinSize && length.isAuto())
     return LayoutUnit();
 
@@ skipping 124 matching lines @@
     case DeviceHeight:
     case ExtendToZoom:
       NOTREACHED() << "These should only be used for viewport definitions";
     case MaxSizeNone:
     default:
       NOTREACHED();
       return border_and_padding.BlockSum();
   }
 }
 
-MinAndMaxContentSizes ComputeMinAndMaxContentContribution(
+MinMaxContentSize ComputeMinAndMaxContentContribution(
     const ComputedStyle& style,
-    const WTF::Optional<MinAndMaxContentSizes>& min_and_max) {
+    const WTF::Optional<MinMaxContentSize>& min_and_max) {
   // Synthesize a zero-sized constraint space for passing to
   // ResolveInlineLength.
   NGWritingMode writing_mode = FromPlatformWritingMode(style.getWritingMode());
   NGConstraintSpaceBuilder builder(writing_mode);
   builder.SetInitialContainingBlockSize(
       NGPhysicalSize{LayoutUnit(), LayoutUnit()});
   NGConstraintSpace* space = builder.ToConstraintSpace(writing_mode);
 
-  MinAndMaxContentSizes computed_sizes;
+  MinMaxContentSize computed_sizes;
   Length inline_size = style.logicalWidth();
   if (inline_size.isAuto()) {
     CHECK(min_and_max.has_value());
     NGBoxStrut border_and_padding =
         ComputeBorders(*space, style) + ComputePadding(*space, style);
     computed_sizes.min_content =
         min_and_max->min_content + border_and_padding.InlineSum();
     computed_sizes.max_content =
         min_and_max->max_content + border_and_padding.InlineSum();
   } else {
@@ skipping 19 matching lines @@
   NGBoxStrut margins =
       ComputeMargins(*space, style, writing_mode, style.direction());
   computed_sizes.min_content += margins.InlineSum();
   computed_sizes.max_content += margins.InlineSum();
   return computed_sizes;
 }
 
 LayoutUnit ComputeInlineSizeForFragment(
     const NGConstraintSpace& space,
     const ComputedStyle& style,
-    const WTF::Optional<MinAndMaxContentSizes>& min_and_max) {
+    const WTF::Optional<MinMaxContentSize>& min_and_max) {
   if (space.IsFixedSizeInline())
     return space.AvailableSize().inline_size;
 
   Length logicalWidth = style.logicalWidth();
   if (logicalWidth.isAuto() && space.IsShrinkToFit())
     logicalWidth = Length(FitContent);
 
   LayoutUnit extent = ResolveInlineLength(
       space, style, min_and_max, logicalWidth, LengthResolveType::kContentSize);
 
@@ skipping 80 matching lines @@
   if (style.hasNormalColumnGap())
     return LayoutUnit(style.getFontDescription().computedPixelSize());
   return LayoutUnit(style.columnGap());
 }
 
 NGBoxStrut ComputeMargins(const NGConstraintSpace& constraint_space,
                           const ComputedStyle& style,
                           const NGWritingMode writing_mode,
                           const TextDirection direction) {
   // We don't need these for margin computations
-  MinAndMaxContentSizes empty_sizes;
+  MinMaxContentSize empty_sizes;
   // Margins always get computed relative to the inline size:
   // https://www.w3.org/TR/CSS2/box.html#value-def-margin-width
   NGPhysicalBoxStrut physical_dim;
   physical_dim.left = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginLeft(),
       LengthResolveType::kMarginBorderPaddingSize);
   physical_dim.right = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.marginRight(),
       LengthResolveType::kMarginBorderPaddingSize);
   physical_dim.top = ResolveInlineLength(
@@ skipping 21 matching lines @@
 }
 
 NGBoxStrut ComputePadding(const NGConstraintSpace& constraint_space,
                           const ComputedStyle& style) {
   // If we are producing an anonymous fragment (e.g. a column) we shouldn't
   // have any padding.
   if (constraint_space.IsAnonymous())
     return NGBoxStrut();
 
   // We don't need these for padding computations
-  MinAndMaxContentSizes empty_sizes;
+  MinMaxContentSize empty_sizes;
   // Padding always gets computed relative to the inline size:
   // https://www.w3.org/TR/CSS2/box.html#value-def-padding-width
   NGBoxStrut padding;
   padding.inline_start = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.paddingStart(),
       LengthResolveType::kMarginBorderPaddingSize);
   padding.inline_end = ResolveInlineLength(
       constraint_space, style, empty_sizes, style.paddingEnd(),
       LengthResolveType::kMarginBorderPaddingSize);
   padding.block_start = ResolveInlineLength(
@@ skipping 29 matching lines @@
                              Optional<LayoutUnit> min,
                              Optional<LayoutUnit> max) {
   if (max && length > max.value())
     length = max.value();
   if (min && length < min.value())
     length = min.value();
   return length;
 }
 
 }  // namespace blink