[FlexNG] Lazily calculate the MinMaxSize and IntrinsicBlockSize for flex-items.

This patch introduces variants of:
Resolve{Main,Min,Max}{Inline,Block}Length

With a callback function to provide the MinMaxSize, or IntrinsicBlockSize
as needed.

This in instead of logic used by other algorithms via. NeedMinMaxSize
et. al.

There are pros/cons to this approach:
Pro - Much more precise (and easier to maintain) calls to
      NGBlockNode::ComputeMinMaxSize and NGBlockNode::Layout.
Con - Duplicate logic for Resolve*Length.

I tried moving Resolve*InlineLength to all being callback based but some
other refactoring needs to occur first (mainly an additional ng cache).

An alternate version of this patch would be either:
1) A NeedsMinMaxSize / NeedsIntrinsicBlockSize similar to other callers
   of these functions.
2) Adding the branch before the Resolve*Length calls to check if we
   need to provide the appropriate argument.

Bug: 845235
Change-Id: I8e26e0171adc60a7e3d244af3cb21e119b2653f1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2027075Reviewed-by: Morten Stenshorne <mstensho@chromium.org>
Reviewed-by: David Grogan <dgrogan@chromium.org>
Commit-Queue: Ian Kilpatrick <ikilpatrick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#738379}

third_party/blink/renderer/core/layout/ng/ng_flex_layout_algorithm.cc

@@ -353,7 +353,6 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
 
     const ComputedStyle& child_style = child.Style();
     NGConstraintSpace flex_basis_space = BuildSpaceForFlexBasis(child);
-    NGConstraintSpace child_space = BuildSpaceForIntrinsicBlockSize(child);
 
     NGBoxStrut border_padding_in_child_writing_mode =
         ComputeBorders(flex_basis_space, child) +
@@ -370,20 +369,29 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
         is_horizontal_flow_ ? physical_border_padding.VerticalSum()
                             : physical_border_padding.HorizontalSum();
 
-    // TODO(dgrogan): Don't layout every time, just when you need to.
-    // Use ChildHasIntrinsicMainAxisSize as a guide.
-    scoped_refptr<const NGLayoutResult> layout_result =
-        child.Layout(child_space, /* break_token */ nullptr);
-
-    // We want the child's min/max size in its writing mode, not ours. We'll
-    // only ever use it if the child's inline axis is our main axis.
-    //
-    // Always calculate the min/max sizes after a layout in order to corrrectly
-    // account for any scrollbars.
-    MinMaxSizeInput input(
-        /* percentage_resolution_block_size */ content_box_size_.block_size);
-    MinMaxSize intrinsic_sizes_border_box = child.ComputeMinMaxSize(
-        child_style.GetWritingMode(), input, &child_space);
+    base::Optional<LayoutUnit> intrinsic_block_size;
+    auto IntrinsicBlockSizeFunc = [&]() -> LayoutUnit {
+      if (!intrinsic_block_size) {
+        NGConstraintSpace child_space = BuildSpaceForIntrinsicBlockSize(child);
+        intrinsic_block_size =
+            child.Layout(child_space, /* break_token */ nullptr)
+                ->IntrinsicBlockSize();
+      }
+      return *intrinsic_block_size;
+    };
+
+    base::Optional<MinMaxSize> min_max_size;
+    auto MinMaxSizeFunc = [&]() -> MinMaxSize {
+      if (!min_max_size) {
+        // We want the child's min/max size in its writing mode, not ours.
+        // We'll only ever use it if the child's inline axis is our main axis.
+        NGConstraintSpace child_space = BuildSpaceForIntrinsicBlockSize(child);
+        min_max_size = child.ComputeMinMaxSize(
+            child_style.GetWritingMode(),
+            MinMaxSizeInput(content_box_size_.block_size), &child_space);
+      }
+      return *min_max_size;
+    };
 
     LayoutUnit flex_base_border_box;
     const Length& specified_length_in_main_axis =
@@ -396,9 +404,9 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
     // we should interpret it as flex-basis:content.
     if (flex_basis.IsAuto() && specified_length_in_main_axis.IsAuto()) {
       if (MainAxisIsInlineAxis(child))
-        flex_base_border_box = intrinsic_sizes_border_box.max_size;
+        flex_base_border_box = MinMaxSizeFunc().max_size;
       else
-        flex_base_border_box = layout_result->IntrinsicBlockSize();
+        flex_base_border_box = IntrinsicBlockSizeFunc();
     } else {
       // TODO(dgrogan): Check for definiteness.
       // This block covers case A in
@@ -410,13 +418,13 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
       if (MainAxisIsInlineAxis(child)) {
         flex_base_border_box = ResolveMainInlineLength(
             flex_basis_space, child_style, border_padding_in_child_writing_mode,
-            intrinsic_sizes_border_box, length_to_resolve);
+            MinMaxSizeFunc, length_to_resolve);
       } else {
         // Flex container's main axis is in child's block direction. Child's
         // flex basis is in child's block direction.
         flex_base_border_box = ResolveMainBlockLength(
             flex_basis_space, child_style, border_padding_in_child_writing_mode,
-            length_to_resolve, layout_result->IntrinsicBlockSize(),
+            length_to_resolve, IntrinsicBlockSizeFunc,
             LengthResolvePhase::kLayout);
       }
     }
@@ -444,28 +452,28 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
     if (MainAxisIsInlineAxis(child)) {
       min_max_sizes_in_main_axis_direction.max_size = ResolveMaxInlineLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          intrinsic_sizes_border_box, max_property_in_main_axis,
+          MinMaxSizeFunc, max_property_in_main_axis,
           LengthResolvePhase::kLayout);
       min_max_sizes_in_cross_axis_direction.max_size = ResolveMaxBlockLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          max_property_in_cross_axis, layout_result->IntrinsicBlockSize(),
+          max_property_in_cross_axis, IntrinsicBlockSizeFunc,
           LengthResolvePhase::kLayout);
       min_max_sizes_in_cross_axis_direction.min_size = ResolveMinBlockLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          min_property_in_cross_axis, layout_result->IntrinsicBlockSize(),
+          min_property_in_cross_axis, IntrinsicBlockSizeFunc,
           LengthResolvePhase::kLayout);
     } else {
       min_max_sizes_in_main_axis_direction.max_size = ResolveMaxBlockLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          max_property_in_main_axis, layout_result->IntrinsicBlockSize(),
+          max_property_in_main_axis, IntrinsicBlockSizeFunc,
           LengthResolvePhase::kLayout);
       min_max_sizes_in_cross_axis_direction.max_size = ResolveMaxInlineLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          intrinsic_sizes_border_box, max_property_in_cross_axis,
+          MinMaxSizeFunc, max_property_in_cross_axis,
           LengthResolvePhase::kLayout);
       min_max_sizes_in_cross_axis_direction.min_size = ResolveMinInlineLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          intrinsic_sizes_border_box, min_property_in_cross_axis,
+          MinMaxSizeFunc, min_property_in_cross_axis,
           LengthResolvePhase::kLayout);
     }
 
@@ -486,9 +494,9 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
           // TODO(dgrogan): Do the aspect ratio parts of
           // https://www.w3.org/TR/css-flexbox-1/#min-size-auto
 
-          LayoutUnit content_size_suggestion =
-              MainAxisIsInlineAxis(child) ? intrinsic_sizes_border_box.min_size
-                                          : layout_result->IntrinsicBlockSize();
+          LayoutUnit content_size_suggestion = MainAxisIsInlineAxis(child)
+                                                   ? MinMaxSizeFunc().min_size
+                                                   : IntrinsicBlockSizeFunc();
           content_size_suggestion =
               std::min(content_size_suggestion,
                        min_max_sizes_in_main_axis_direction.max_size);
@@ -518,17 +526,16 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
               // calculation. Reuse that if possible.
               specified_size_suggestion = ResolveMainInlineLength(
                   flex_basis_space, child_style,
-                  border_padding_in_child_writing_mode,
-                  intrinsic_sizes_border_box, specified_length_in_main_axis);
+                  border_padding_in_child_writing_mode, MinMaxSizeFunc,
+                  specified_length_in_main_axis);
             }
           } else if (!BlockLengthUnresolvable(flex_basis_space,
                                               specified_length_in_main_axis,
                                               LengthResolvePhase::kLayout)) {
-            specified_size_suggestion =
-                ResolveMainBlockLength(flex_basis_space, child_style,
+            specified_size_suggestion = ResolveMainBlockLength(
+                flex_basis_space, child_style,
                 border_padding_in_child_writing_mode,
-                                       specified_length_in_main_axis,
-                                       layout_result->IntrinsicBlockSize(),
+                specified_length_in_main_axis, IntrinsicBlockSizeFunc,
                 LengthResolvePhase::kLayout);
             DCHECK_NE(specified_size_suggestion, kIndefiniteSize);
           }
@@ -544,12 +551,11 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
     } else if (MainAxisIsInlineAxis(child)) {
       min_max_sizes_in_main_axis_direction.min_size = ResolveMinInlineLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          intrinsic_sizes_border_box, min, LengthResolvePhase::kLayout);
+          MinMaxSizeFunc, min, LengthResolvePhase::kLayout);
     } else {
       min_max_sizes_in_main_axis_direction.min_size = ResolveMinBlockLength(
           flex_basis_space, child_style, border_padding_in_child_writing_mode,
-          min, layout_result->IntrinsicBlockSize(),
-          LengthResolvePhase::kLayout);
+          min, IntrinsicBlockSizeFunc, LengthResolvePhase::kLayout);
     }
     min_max_sizes_in_main_axis_direction -= main_axis_border_padding;
 

third_party/blink/renderer/core/layout/ng/ng_length_utils.cc

@@ -115,7 +115,7 @@ LayoutUnit ResolveInlineLengthInternal(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     const NGBoxStrut& border_padding,
-    const base::Optional<MinMaxSize>& min_and_max,
+    const base::Optional<MinMaxSize>& min_max_size,
     const Length& length) {
   DCHECK_GE(constraint_space.AvailableSize().inline_size, LayoutUnit());
   DCHECK_GE(constraint_space.PercentageResolutionInlineSize(), LayoutUnit());
@@ -146,20 +146,20 @@ LayoutUnit ResolveInlineLengthInternal(
     case Length::kMinContent:
     case Length::kMaxContent:
     case Length::kFitContent: {
-      DCHECK(min_and_max.has_value());
+      DCHECK(min_max_size.has_value());
       LayoutUnit available_size = constraint_space.AvailableSize().inline_size;
       LayoutUnit value;
       if (length.IsMinContent()) {
-        value = min_and_max->min_size;
+        value = min_max_size->min_size;
       } else if (length.IsMaxContent() || available_size == LayoutUnit::Max()) {
         // If the available space is infinite, fit-content resolves to
         // max-content. See css-sizing section 2.1.
-        value = min_and_max->max_size;
+        value = min_max_size->max_size;
       } else {
         NGBoxStrut margins = ComputeMarginsForSelf(constraint_space, style);
         LayoutUnit fill_available =
             std::max(LayoutUnit(), available_size - margins.InlineSum());
-        value = min_and_max->ShrinkToFit(fill_available);
+        value = min_max_size->ShrinkToFit(fill_available);
       }
       return value;
     }
@@ -246,7 +246,7 @@ MinMaxSize ComputeMinAndMaxContentContribution(
     WritingMode parent_writing_mode,
     const ComputedStyle& style,
     const NGBoxStrut& border_padding,
-    const base::Optional<MinMaxSize>& min_and_max) {
+    const base::Optional<MinMaxSize>& min_max_size) {
   WritingMode child_writing_mode = style.GetWritingMode();
 
   // Synthesize a zero-sized constraint space for resolving sizes against.
@@ -256,7 +256,7 @@ MinMaxSize ComputeMinAndMaxContentContribution(
           .ToConstraintSpace();
 
   LayoutUnit content_size =
-      min_and_max ? min_and_max->max_size : kIndefiniteSize;
+      min_max_size ? min_max_size->max_size : kIndefiniteSize;
 
   MinMaxSize computed_sizes;
   const Length& inline_size = parent_writing_mode == WritingMode::kHorizontalTb
@@ -264,12 +264,12 @@ MinMaxSize ComputeMinAndMaxContentContribution(
                                   : style.Height();
   if (inline_size.IsAuto() || inline_size.IsPercentOrCalc() ||
       inline_size.IsFillAvailable() || inline_size.IsFitContent()) {
-    CHECK(min_and_max.has_value());
-    computed_sizes = *min_and_max;
+    CHECK(min_max_size.has_value());
+    computed_sizes = *min_max_size;
   } else {
     if (IsParallelWritingMode(parent_writing_mode, child_writing_mode)) {
       computed_sizes = ResolveMainInlineLength(space, style, border_padding,
-                                               min_and_max, inline_size);
+                                               min_max_size, inline_size);
     } else {
       computed_sizes =
           ResolveMainBlockLength(space, style, border_padding, inline_size,
@@ -282,7 +282,7 @@ MinMaxSize ComputeMinAndMaxContentContribution(
                                  : style.MaxHeight();
   LayoutUnit max;
   if (IsParallelWritingMode(parent_writing_mode, child_writing_mode)) {
-    max = ResolveMaxInlineLength(space, style, border_padding, min_and_max,
+    max = ResolveMaxInlineLength(space, style, border_padding, min_max_size,
                                  max_length, LengthResolvePhase::kIntrinsic);
   } else {
     max = ResolveMaxBlockLength(space, style, border_padding, max_length,
@@ -295,7 +295,7 @@ MinMaxSize ComputeMinAndMaxContentContribution(
                                  : style.MinHeight();
   LayoutUnit min;
   if (IsParallelWritingMode(parent_writing_mode, child_writing_mode)) {
-    min = ResolveMinInlineLength(space, style, border_padding, min_and_max,
+    min = ResolveMinInlineLength(space, style, border_padding, min_max_size,
                                  min_length, LengthResolvePhase::kIntrinsic);
   } else {
     min = ResolveMinBlockLength(space, style, border_padding, min_length,
@@ -347,7 +347,7 @@ MinMaxSize ComputeMinAndMaxContentContribution(
     }
   }
 
-  base::Optional<MinMaxSize> minmax;
+  base::Optional<MinMaxSize> min_max_size;
   if (NeedMinMaxSizeForContentContribution(parent_writing_mode, child_style)) {
     // We need to set up a constraint space with correct fallback available
     // inline size in case of orthogonal children.
@@ -358,7 +358,7 @@ MinMaxSize ComputeMinAndMaxContentContribution(
           CreateIndefiniteConstraintSpaceForChild(parent_style, child);
       child_constraint_space = &indefinite_constraint_space;
     }
-    minmax = child.ComputeMinMaxSize(parent_writing_mode, input,
+    min_max_size = child.ComputeMinMaxSize(parent_writing_mode, input,
                                            child_constraint_space);
   }
   // Synthesize a zero-sized constraint space for determining the borders, and
@@ -371,7 +371,7 @@ MinMaxSize ComputeMinAndMaxContentContribution(
       ComputeBorders(space, child) + ComputePadding(space, child_style);
 
   MinMaxSize sizes = ComputeMinAndMaxContentContribution(
-      parent_writing_mode, child_style, border_padding, minmax);
+      parent_writing_mode, child_style, border_padding, min_max_size);
   if (IsParallelWritingMode(parent_writing_mode, child_writing_mode))
     box->SetPreferredLogicalWidthsFromNG(sizes);
   return sizes;
@@ -411,7 +411,7 @@ LayoutUnit ComputeInlineSizeForFragment(
     const NGConstraintSpace& space,
     NGLayoutInputNode node,
     const NGBoxStrut& border_padding,
-    const MinMaxSize* override_minmax_for_test) {
+    const MinMaxSize* override_min_max_size_for_test) {
   if (space.IsFixedInlineSize() || space.IsAnonymous())
     return space.AvailableSize().inline_size;
 
@@ -427,7 +427,7 @@ LayoutUnit ComputeInlineSizeForFragment(
   // the constraints on our own. We also need to discard the cached values if
   // the box has certain properties (e.g. percentage padding) that cause the
   // cached values to be affected by extrinsic sizing.
-  if (!box->PreferredLogicalWidthsDirty() && !override_minmax_for_test &&
+  if (!box->PreferredLogicalWidthsDirty() && !override_min_max_size_for_test &&
       !style.LogicalMinWidth().IsPercentOrCalc() &&
       !style.LogicalMaxWidth().IsPercentOrCalc() &&
       !box->NeedsPreferredWidthsRecalculation()) {
@@ -436,9 +436,9 @@ LayoutUnit ComputeInlineSizeForFragment(
       // to subtract inline margins from the available size. The code in
       // ResolveMainInlineLength knows how to handle that, just call that.
 
-      MinMaxSize min_and_max = {box->MinPreferredLogicalWidth(),
-                                box->MaxPreferredLogicalWidth()};
-      return ResolveMainInlineLength(space, style, border_padding, min_and_max,
+      base::Optional<MinMaxSize> min_max_size = MinMaxSize{
+          box->MinPreferredLogicalWidth(), box->MaxPreferredLogicalWidth()};
+      return ResolveMainInlineLength(space, style, border_padding, min_max_size,
                                      logical_width);
     }
     if (logical_width.IsMinContent())
@@ -447,29 +447,29 @@ LayoutUnit ComputeInlineSizeForFragment(
       return box->MaxPreferredLogicalWidth();
   }
 
-  base::Optional<MinMaxSize> min_and_max;
+  base::Optional<MinMaxSize> min_max_size;
   if (NeedMinMaxSize(space, style)) {
-    if (override_minmax_for_test) {
-      min_and_max = *override_minmax_for_test;
+    if (override_min_max_size_for_test) {
+      min_max_size = *override_min_max_size_for_test;
     } else {
-      min_and_max = node.ComputeMinMaxSize(
+      min_max_size = node.ComputeMinMaxSize(
           space.GetWritingMode(),
           MinMaxSizeInput(space.PercentageResolutionBlockSize()), &space);
       // Cache these computed values
       MinMaxSize contribution = ComputeMinAndMaxContentContribution(
-          style.GetWritingMode(), style, border_padding, min_and_max);
+          style.GetWritingMode(), style, border_padding, min_max_size);
       box->SetPreferredLogicalWidthsFromNG(contribution);
     }
   }
 
   LayoutUnit extent = ResolveMainInlineLength(space, style, border_padding,
-                                              min_and_max, logical_width);
+                                              min_max_size, logical_width);
 
   LayoutUnit max = ResolveMaxInlineLength(space, style, border_padding,
-                                          min_and_max, style.LogicalMaxWidth(),
+                                          min_max_size, style.LogicalMaxWidth(),
                                           LengthResolvePhase::kLayout);
   LayoutUnit min = ResolveMinInlineLength(space, style, border_padding,
-                                          min_and_max, style.LogicalMinWidth(),
+                                          min_max_size, style.LogicalMinWidth(),
                                           LengthResolvePhase::kLayout);
   return ConstrainByMinMax(extent, min, max);
 }
@@ -548,7 +548,7 @@ LayoutUnit ComputeBlockSizeForFragment(
 // Computes size for a replaced element.
 void ComputeReplacedSize(const NGLayoutInputNode& node,
                          const NGConstraintSpace& space,
-                         const base::Optional<MinMaxSize>& child_minmax,
+                         const base::Optional<MinMaxSize>& child_min_max_size,
                          base::Optional<LogicalSize>* out_replaced_size,
                          base::Optional<LogicalSize>* out_aspect_ratio) {
   DCHECK(node.IsReplaced());
@@ -560,10 +560,10 @@ void ComputeReplacedSize(const NGLayoutInputNode& node,
   NGBoxStrut border_padding =
       ComputeBorders(space, node) + ComputePadding(space, style);
   LayoutUnit inline_min = ResolveMinInlineLength(
-      space, style, border_padding, child_minmax, style.LogicalMinWidth(),
+      space, style, border_padding, child_min_max_size, style.LogicalMinWidth(),
       LengthResolvePhase::kLayout);
   LayoutUnit inline_max = ResolveMaxInlineLength(
-      space, style, border_padding, child_minmax, style.LogicalMaxWidth(),
+      space, style, border_padding, child_min_max_size, style.LogicalMaxWidth(),
       LengthResolvePhase::kLayout);
   LayoutUnit block_min = ResolveMinBlockLength(
       space, style, border_padding, style.LogicalMinHeight(),
@@ -576,8 +576,8 @@ void ComputeReplacedSize(const NGLayoutInputNode& node,
   const Length& block_length = style.LogicalHeight();
   base::Optional<LayoutUnit> replaced_inline;
   if (!inline_length.IsAuto()) {
-    replaced_inline = ResolveMainInlineLength(space, style, border_padding,
-                                              child_minmax, inline_length);
+    replaced_inline = ResolveMainInlineLength(
+        space, style, border_padding, child_min_max_size, inline_length);
     replaced_inline =
         ConstrainByMinMax(*replaced_inline, inline_min, inline_max);
   }

third_party/blink/renderer/core/layout/ng/ng_length_utils.h

@@ -97,44 +97,100 @@ CORE_EXPORT LayoutUnit ResolveBlockLengthInternal(
         nullptr);
 
 // Used for resolving min inline lengths, (|ComputedStyle::MinLogicalWidth|).
+template <typename MinMaxSizeFunc>
 inline LayoutUnit ResolveMinInlineLength(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     const NGBoxStrut& border_padding,
-    const base::Optional<MinMaxSize>& min_and_max,
+    const MinMaxSizeFunc& min_max_size_func,
     const Length& length,
     LengthResolvePhase phase) {
   if (LIKELY(length.IsAuto() || InlineLengthUnresolvable(length, phase)))
     return border_padding.InlineSum();
 
+  base::Optional<MinMaxSize> min_max_size;
+  if (length.IsIntrinsic())
+    min_max_size = min_max_size_func();
+
   return ResolveInlineLengthInternal(constraint_space, style, border_padding,
-                                     min_and_max, length);
+                                     min_max_size, length);
+}
+
+template <>
+inline LayoutUnit ResolveMinInlineLength<base::Optional<MinMaxSize>>(
+    const NGConstraintSpace& constraint_space,
+    const ComputedStyle& style,
+    const NGBoxStrut& border_padding,
+    const base::Optional<MinMaxSize>& min_max_size,
+    const Length& length,
+    LengthResolvePhase phase) {
+  if (LIKELY(length.IsAuto() || InlineLengthUnresolvable(length, phase)))
+    return border_padding.InlineSum();
+
+  return ResolveInlineLengthInternal(constraint_space, style, border_padding,
+                                     min_max_size, length);
 }
 
 // Used for resolving max inline lengths, (|ComputedStyle::MaxLogicalWidth|).
+template <typename MinMaxSizeFunc>
 inline LayoutUnit ResolveMaxInlineLength(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     const NGBoxStrut& border_padding,
-    const base::Optional<MinMaxSize>& min_and_max,
+    const MinMaxSizeFunc& min_max_size_func,
+    const Length& length,
+    LengthResolvePhase phase) {
+  if (LIKELY(length.IsNone() || InlineLengthUnresolvable(length, phase)))
+    return LayoutUnit::Max();
+
+  base::Optional<MinMaxSize> min_max_size;
+  if (length.IsIntrinsic())
+    min_max_size = min_max_size_func();
+
+  return ResolveInlineLengthInternal(constraint_space, style, border_padding,
+                                     min_max_size, length);
+}
+
+template <>
+inline LayoutUnit ResolveMaxInlineLength<base::Optional<MinMaxSize>>(
+    const NGConstraintSpace& constraint_space,
+    const ComputedStyle& style,
+    const NGBoxStrut& border_padding,
+    const base::Optional<MinMaxSize>& min_max_size,
     const Length& length,
     LengthResolvePhase phase) {
   if (LIKELY(length.IsNone() || InlineLengthUnresolvable(length, phase)))
     return LayoutUnit::Max();
 
   return ResolveInlineLengthInternal(constraint_space, style, border_padding,
-                                     min_and_max, length);
+                                     min_max_size, length);
 }
 
 // Used for resolving main inline lengths, (|ComputedStyle::LogicalWidth|).
+template <typename MinMaxSizeFunc>
 inline LayoutUnit ResolveMainInlineLength(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,
     const NGBoxStrut& border_padding,
-    const base::Optional<MinMaxSize>& min_and_max,
+    const MinMaxSizeFunc& min_max_size_func,
+    const Length& length) {
+  base::Optional<MinMaxSize> min_max_size;
+  if (length.IsIntrinsic())
+    min_max_size = min_max_size_func();
+
+  return ResolveInlineLengthInternal(constraint_space, style, border_padding,
+                                     min_max_size, length);
+}
+
+template <>
+inline LayoutUnit ResolveMainInlineLength<base::Optional<MinMaxSize>>(
+    const NGConstraintSpace& constraint_space,
+    const ComputedStyle& style,
+    const NGBoxStrut& border_padding,
+    const base::Optional<MinMaxSize>& min_max_size,
     const Length& length) {
   return ResolveInlineLengthInternal(constraint_space, style, border_padding,
-                                     min_and_max, length);
+                                     min_max_size, length);
 }
 
 // Used for resolving min block lengths, (|ComputedStyle::MinLogicalHeight|).
@@ -157,6 +213,30 @@ inline LayoutUnit ResolveMinBlockLength(
       opt_percentage_resolution_block_size_for_min_max);
 }
 
+template <typename IntrinsicBlockSizeFunc>
+inline LayoutUnit ResolveMinBlockLength(
+    const NGConstraintSpace& constraint_space,
+    const ComputedStyle& style,
+    const NGBoxStrut& border_padding,
+    const Length& length,
+    const IntrinsicBlockSizeFunc& intrinsic_block_size_func,
+    LengthResolvePhase phase,
+    const LayoutUnit* opt_percentage_resolution_block_size_for_min_max =
+        nullptr) {
+  if (LIKELY(BlockLengthUnresolvable(
+          constraint_space, length, phase,
+          opt_percentage_resolution_block_size_for_min_max)))
+    return border_padding.BlockSum();
+
+  LayoutUnit intrinsic_block_size = kIndefiniteSize;
+  if (length.IsIntrinsicOrAuto())
+    intrinsic_block_size = intrinsic_block_size_func();
+
+  return ResolveBlockLengthInternal(
+      constraint_space, style, border_padding, length, intrinsic_block_size,
+      phase, opt_percentage_resolution_block_size_for_min_max);
+}
+
 // Used for resolving max block lengths, (|ComputedStyle::MaxLogicalHeight|).
 inline LayoutUnit ResolveMaxBlockLength(
     const NGConstraintSpace& constraint_space,
@@ -177,6 +257,30 @@ inline LayoutUnit ResolveMaxBlockLength(
       opt_percentage_resolution_block_size_for_min_max);
 }
 
+template <typename IntrinsicBlockSizeFunc>
+inline LayoutUnit ResolveMaxBlockLength(
+    const NGConstraintSpace& constraint_space,
+    const ComputedStyle& style,
+    const NGBoxStrut& border_padding,
+    const Length& length,
+    const IntrinsicBlockSizeFunc& intrinsic_block_size_func,
+    LengthResolvePhase phase,
+    const LayoutUnit* opt_percentage_resolution_block_size_for_min_max =
+        nullptr) {
+  if (LIKELY(BlockLengthUnresolvable(
+          constraint_space, length, phase,
+          opt_percentage_resolution_block_size_for_min_max)))
+    return LayoutUnit::Max();
+
+  LayoutUnit intrinsic_block_size = kIndefiniteSize;
+  if (length.IsIntrinsicOrAuto())
+    intrinsic_block_size = intrinsic_block_size_func();
+
+  return ResolveBlockLengthInternal(
+      constraint_space, style, border_padding, length, intrinsic_block_size,
+      phase, opt_percentage_resolution_block_size_for_min_max);
+}
+
 // Used for resolving main block lengths, (|ComputedStyle::LogicalHeight|).
 inline LayoutUnit ResolveMainBlockLength(
     const NGConstraintSpace& constraint_space,
@@ -198,6 +302,31 @@ inline LayoutUnit ResolveMainBlockLength(
       opt_percentage_resolution_block_size_for_min_max);
 }
 
+template <typename IntrinsicBlockSizeFunc>
+inline LayoutUnit ResolveMainBlockLength(
+    const NGConstraintSpace& constraint_space,
+    const ComputedStyle& style,
+    const NGBoxStrut& border_padding,
+    const Length& length,
+    const IntrinsicBlockSizeFunc& intrinsic_block_size_func,
+    LengthResolvePhase phase,
+    const LayoutUnit* opt_percentage_resolution_block_size_for_min_max =
+        nullptr) {
+  if (UNLIKELY((length.IsPercentOrCalc() || length.IsFillAvailable()) &&
+               BlockLengthUnresolvable(
+                   constraint_space, length, phase,
+                   opt_percentage_resolution_block_size_for_min_max)))
+    return intrinsic_block_size_func();
+
+  LayoutUnit intrinsic_block_size = kIndefiniteSize;
+  if (length.IsIntrinsicOrAuto())
+    intrinsic_block_size = intrinsic_block_size_func();
+
+  return ResolveBlockLengthInternal(
+      constraint_space, style, border_padding, length, intrinsic_block_size,
+      phase, opt_percentage_resolution_block_size_for_min_max);
+}
+
 // For the given style and min/max content sizes, computes the min and max
 // content contribution (https://drafts.csswg.org/css-sizing/#contributions).
 // This is similar to ComputeInlineSizeForFragment except that it does not
@@ -241,12 +370,12 @@ MinMaxSize ComputeMinAndMaxContentSizeForOutOfFlow(
 // then constraining the result by the resolved min logical width and max
 // logical width from the ComputedStyle object. Calls Node::ComputeMinMaxSize
 // if needed.
-// |override_minmax_for_test| is provided *solely* for use by unit tests.
+// |override_min_max_size_for_test| is provided *solely* for use by unit tests.
 CORE_EXPORT LayoutUnit ComputeInlineSizeForFragment(
     const NGConstraintSpace&,
     NGLayoutInputNode,
     const NGBoxStrut& border_padding,
-    const MinMaxSize* override_minmax_for_test = nullptr);
+    const MinMaxSize* override_min_max_size_for_test = nullptr);
 
 // Same as ComputeInlineSizeForFragment, but uses height instead of width.
 CORE_EXPORT LayoutUnit