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

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.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_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_block_child_iterator.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.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_inline_node.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_line_builder.h"
 #include "core/layout/ng/ng_out_of_flow_layout_part.h"
+#include "core/layout/ng/ng_units.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LengthFunctions.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 namespace {
 
 // Whether child's constraint space should shrink to its intrinsic width.
 // This is needed for buttons, select, input, floats and orthogonal children.
 // See LayoutBox::sizesLogicalWidthToFitContent for the rationale behind this.
@@ skipping 275 matching lines @@
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(
     NGBlockNode* node,
     NGConstraintSpace* constraint_space,
     NGBlockBreakToken* break_token)
     : node_(node),
       constraint_space_(constraint_space),
       break_token_(break_token),
       builder_(WTF::wrapUnique(
           new NGFragmentBuilder(NGPhysicalFragment::kFragmentBox, node))) {}
 
-Optional<MinMaxContentSize> NGBlockLayoutAlgorithm::ComputeMinMaxContentSize()
-    const {
-  MinMaxContentSize sizes;
+Optional<MinAndMaxContentSizes>
+NGBlockLayoutAlgorithm::ComputeMinAndMaxContentSizes() const {
+  MinAndMaxContentSizes sizes;
 
   // Size-contained elements don't consider their contents for intrinsic sizing.
   if (Style().containsSize())
     return sizes;
 
   // TODO: handle floats & orthogonal children.
   for (NGLayoutInputNode* node = node_->FirstChild(); node;
        node = node->NextSibling()) {
-    MinMaxContentSize child_sizes;
+    MinAndMaxContentSizes child_sizes;
     if (node->Type() == NGLayoutInputNode::kLegacyInline) {
       // From |NGBlockLayoutAlgorithm| perspective, we can handle |NGInlineNode|
       // almost the same as |NGBlockNode|, because an |NGInlineNode| includes
       // all inline nodes following |node| and their descendants, and produces
       // an anonymous box that contains all line boxes.
       // |NextSibling| returns the next block sibling, or nullptr, skipping all
       // following inline siblings and descendants.
-      child_sizes = toNGInlineNode(node)->ComputeMinMaxContentSize();
+      child_sizes = toNGInlineNode(node)->ComputeMinAndMaxContentSizes();
     } else {
-      Optional<MinMaxContentSize> child_minmax;
+      Optional<MinAndMaxContentSizes> child_minmax;
       NGBlockNode* block_child = toNGBlockNode(node);
-      if (NeedMinMaxContentSizeForContentContribution(block_child->Style())) {
-        child_minmax = block_child->ComputeMinMaxContentSize();
+      if (NeedMinAndMaxContentSizesForContentContribution(
+              block_child->Style())) {
+        child_minmax = block_child->ComputeMinAndMaxContentSizes();
       }
 
       child_sizes = ComputeMinAndMaxContentContribution(block_child->Style(),
                                                         child_minmax);
     }
 
     sizes.min_content = std::max(sizes.min_content, child_sizes.min_content);
     sizes.max_content = std::max(sizes.max_content, child_sizes.max_content);
   }
 
@@ skipping 19 matching lines @@
     NGLogicalOffset bfc_offset = offset;
     if (ConstraintSpace().ClearanceOffset()) {
       bfc_offset.block_offset = std::max(
           ConstraintSpace().ClearanceOffset().value(), offset.block_offset);
     }
     builder_->SetBfcOffset(bfc_offset);
   }
 }
 
 RefPtr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() {
-  WTF::Optional<MinMaxContentSize> sizes;
-  if (NeedMinMaxContentSize(ConstraintSpace(), Style()))
-    sizes = ComputeMinMaxContentSize();
+  WTF::Optional<MinAndMaxContentSizes> sizes;
+  if (NeedMinAndMaxContentSizes(ConstraintSpace(), Style()))
+    sizes = ComputeMinAndMaxContentSizes();
 
   border_and_padding_ = ComputeBorders(ConstraintSpace(), Style()) +
                         ComputePadding(ConstraintSpace(), Style());
 
   LayoutUnit inline_size =
       ComputeInlineSizeForFragment(ConstraintSpace(), Style(), sizes);
   LayoutUnit adjusted_inline_size =
       inline_size - border_and_padding_.InlineSum();
   // TODO(layout-ng): For quirks mode, should we pass blockSize instead of
   // -1?
@@ skipping 266 matching lines @@
   }
 
   // The end of the block fits in the current fragmentainer.
   builder_->SetBlockSize(block_size);
   builder_->SetBlockOverflow(content_size_);
 }
 
 NGBoxStrut NGBlockLayoutAlgorithm::CalculateMargins(
     const NGConstraintSpace& space,
     const ComputedStyle& style) {
-  WTF::Optional<MinMaxContentSize> sizes;
-  if (NeedMinMaxContentSize(space, style)) {
-    // TODO(ikilpatrick): Change ComputeMinMaxContentSize to return
-    // MinMaxContentSize.
-    sizes = toNGBlockNode(current_child_)->ComputeMinMaxContentSize();
+  WTF::Optional<MinAndMaxContentSizes> sizes;
+  if (NeedMinAndMaxContentSizes(space, style)) {
+    // TODO(ikilpatrick): Change ComputeMinAndMaxContentSizes to return
+    // MinAndMaxContentSizes.
+    sizes = toNGBlockNode(current_child_)->ComputeMinAndMaxContentSizes();
   }
   LayoutUnit child_inline_size =
       ComputeInlineSizeForFragment(space, style, sizes);
   NGBoxStrut margins =
       ComputeMargins(space, style, space.WritingMode(), space.Direction());
   if (!style.isFloating()) {
     ApplyAutoMargins(space, style, child_inline_size, &margins);
   }
   return margins;
 }
@@ skipping 78 matching lines @@
       DCHECK(builder_->BfcOffset());
       space_available -= curr_bfc_offset_.block_offset;
     }
   }
   space_builder_->SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_->ToConstraintSpace(
       FromPlatformWritingMode(current_child_style.getWritingMode()));
 }
 }  // namespace blink