[layoutng] Add a function to compute the min- and max-content contribution

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_base.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LayoutUnit.h"
 #include "platform/Length.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 // TODO(layout-ng):
 // - positioned and/or replaced calculations
 // - Take scrollbars into account
 
 bool NeedMinAndMaxContentSizes(const ComputedStyle& style) {
   // TODO(layout-ng): In the future we may pass a shrink-to-fit flag through the
   // constraint space; if so, this function needs to take a constraint space
   // as well to take that into account.
   // 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 style.logicalWidth().isIntrinsic() ||
          style.logicalMinWidth().isIntrinsic() ||
          style.logicalMaxWidth().isIntrinsic();
 }
 
+bool NeedMinAndMaxContentSizesForContentContribution(
+    const ComputedStyle& style) {
+  return NeedMinAndMaxContentSizes(style) || style.logicalWidth().isAuto();
+}
+
 LayoutUnit ResolveInlineLength(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     const WTF::Optional<MinAndMaxContentSizes>& min_and_max,
     const Length& length,
     LengthResolveType type) {
   // TODO(layout-ng): Handle min/max/fit-content
   DCHECK(!length.isMaxSizeNone());
   DCHECK_GE(constraint_space.AvailableSize().inline_size, LayoutUnit());
 
@@ skipping 127 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(
+    const ComputedStyle& style,
+    const WTF::Optional<MinAndMaxContentSizes>& min_and_max) {
+  // Synthesize a zero-sized constraint space for passing to
+  // ResolveInlineLength.
+  NGWritingMode writing_mode = FromPlatformWritingMode(style.getWritingMode());
+  NGConstraintSpaceBuilder builder(writing_mode);
+  NGConstraintSpace* space = builder.ToConstraintSpace();
+
+  MinAndMaxContentSizes computed_sizes;
+  Length inline_size = style.logicalWidth();
+  if (inline_size.isAuto()) {
+    CHECK(min_and_max.has_value());
+    NGBoxStrut border_and_padding =
+        ComputeBorders(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 {
+    computed_sizes.min_content = computed_sizes.max_content =
+        ResolveInlineLength(*space, style, min_and_max, inline_size,
+                            LengthResolveType::kContentSize);
+  }
+
+  Length max_length = style.logicalMaxWidth();
+  if (!max_length.isMaxSizeNone()) {
+    LayoutUnit max = ResolveInlineLength(*space, style, min_and_max, max_length,
+                                         LengthResolveType::kMaxSize);
+    computed_sizes.min_content = std::min(computed_sizes.min_content, max);
+    computed_sizes.max_content = std::min(computed_sizes.max_content, max);
+  }
+
+  LayoutUnit min =
+      ResolveInlineLength(*space, style, min_and_max, style.logicalMinWidth(),
+                          LengthResolveType::kMinSize);
+  computed_sizes.min_content = std::max(computed_sizes.min_content, min);
+  computed_sizes.max_content = std::max(computed_sizes.max_content, min);
+
+  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) {
   if (space.IsFixedSizeInline())
     return space.AvailableSize().inline_size;
 
   LayoutUnit extent =
       ResolveInlineLength(space, style, min_and_max, style.logicalWidth(),
                           LengthResolveType::kContentSize);
@@ skipping 158 matching lines @@
     margins->inline_start = available_space / 2;
     margins->inline_end = available_space - margins->inline_start;
   } else if (style.marginStart().isAuto()) {
     margins->inline_start = available_space;
   } else if (style.marginEnd().isAuto()) {
     margins->inline_end = available_space;
   }
 }
 
 }  // namespace blink