[TableNG] Apply min-intrinsic size constraint to content contribution.

Previously the code within NGTableLayoutAlgorithm::ComputeMinMaxSizes
was doing (some) the job of ComputeMinAndMaxContentContributionInternal.

This patch removes some of that logic (only leaving the "infinite"
quirk), and changing ComputeMinAndMaxContentContributionInternal to
always make NG tables respect the "min-intrinsic" table inline-size.

Bug: 958381
Change-Id: I9d1b35f281378f199a3758a20304a12f27c3e10e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2561745Reviewed-by: Aleks Totic <atotic@chromium.org>
Commit-Queue: Ian Kilpatrick <ikilpatrick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#831955}

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

@@ -264,7 +264,8 @@ MinMaxSizesResult ComputeMinAndMaxContentContributionInternal(
     const NGBlockNode& child,
     const MinMaxSizesFunc& min_max_sizes_func) {
   const ComputedStyle& style = child.Style();
-  WritingMode child_writing_mode = style.GetWritingMode();
+  const WritingMode child_writing_mode = style.GetWritingMode();
+
   // Synthesize a zero-sized constraint space for resolving sizes against.
   NGConstraintSpace space =
       NGConstraintSpaceBuilder(child_writing_mode, style.GetWritingDirection(),
@@ -330,6 +331,13 @@ MinMaxSizesResult ComputeMinAndMaxContentContributionInternal(
   }
   result.sizes.Encompass(min);
 
+  // Tables need to apply one final constraint. They are never allowed to go
+  // below their min-intrinsic size (even if they have an inline-size, etc).
+  if (child.IsNGTable()) {
+    result.sizes.Encompass(
+        min_max_sizes_func(MinMaxSizesType::kIntrinsic).sizes.min_size);
+  }
+
   return result;
 }
 
@@ -358,7 +366,7 @@ MinMaxSizesResult ComputeMinAndMaxContentContribution(
   if (IsParallelWritingMode(parent_writing_mode, child_writing_mode)) {
     // Tables are special; even if a width is specified, they may end up being
     // sized different. So we just always let the table code handle this.
-    if (child.IsTable())
+    if (child.IsTable() && !child.IsNGTable())
       return child.ComputeMinMaxSizes(parent_writing_mode, input, nullptr);
 
     // Replaced elements may size themselves using aspect ratios and block

third_party/blink/renderer/core/layout/ng/table/ng_table_layout_algorithm.cc

@@ -39,9 +39,10 @@ bool ShouldIgnorePercentagesForMinMax(const LayoutBox& table) {
   return false;
 }
 
-// Another MinMax variant of ShouldIgnorePercentagesForMinMax
-// This one is only for flexbox/grid. CSS size should be ignored.
-bool ShouldIgnoreCssSizesForMinMax(const LayoutBlock& table) {
+// Another MinMax variant of |ShouldIgnorePercentagesForMinMax|.
+// This one is only for flexbox/grid. Fixed table-layout "infinite" max-size
+// should not be applied.
+bool ShouldIgnoreInfiniteMaxSizeForMinMax(const LayoutBlock& table) {
   return false;
 }
 
@@ -76,31 +77,6 @@ LayoutUnit ComputeUndistributableTableSpace(
          inline_space_count * inline_border_spacing;
 }
 
-void ComputeTableCssInlineSizes(
-    const ComputedStyle& table_style,
-    const NGConstraintSpace& constraint_space,
-    const NGBoxStrut& table_border_padding,
-    const MinMaxSizes& grid_min_max,
-    LayoutUnit* table_css_min_inline_size,
-    base::Optional<LayoutUnit>* table_css_inline_size) {
-  const Length& table_min_length = table_style.LogicalMinWidth();
-  *table_css_min_inline_size =
-      table_min_length.IsSpecified()
-          ? ResolveMinInlineLength<base::Optional<MinMaxSizes>>(
-                constraint_space, table_style, table_border_padding,
-                base::nullopt, table_min_length, LengthResolvePhase::kLayout)
-          : LayoutUnit();
-
-  // Compute standard "used width of a table".
-  const Length& table_length = table_style.LogicalWidth();
-  if (!table_length.IsAuto()) {
-    *table_css_inline_size =
-        ResolveMainInlineLength<base::Optional<MinMaxSizes>>(
-            constraint_space, table_style, table_border_padding, grid_min_max,
-            table_length);
-  }
-}
-
 // Empty table sizes have been a source of many inconsistencies
 // between browsers.
 LayoutUnit ComputeEmptyTableInlineSize(
@@ -545,7 +521,6 @@ MinMaxSizesResult NGTableLayoutAlgorithm::ComputeMinMaxSizes(
     text_autosizer.emplace(layout_table);
 
   const LogicalSize border_spacing = Style().TableBorderSpacing();
-  const auto table_writing_direction = Style().GetWritingDirection();
   NGTableGroupedChildren grouped_children(Node());
   const scoped_refptr<const NGTableBorders> table_borders =
       Node().GetTableBorders();
@@ -570,58 +545,11 @@ MinMaxSizesResult NGTableLayoutAlgorithm::ComputeMinMaxSizes(
       std::max(grid_min_max.min_size, caption_constraint.min_size),
       std::max(grid_min_max.max_size, caption_constraint.min_size)};
 
-  if (ShouldIgnoreCssSizesForMinMax(*layout_table)) {
-    return MinMaxSizesResult{min_max,
-                             /* depends_on_percentage_block_size */ false};
-  }
-
-  NGConstraintSpaceBuilder min_space_builder(
-      ConstraintSpace(), table_writing_direction, /* is_new_fc */ true);
-  min_space_builder.SetAvailableSize({LayoutUnit(), kIndefiniteSize});
-  LayoutUnit min_measure_table_css_min_inline_size;
-  base::Optional<LayoutUnit> min_measure_table_css_inline_size;
-
-  ComputeTableCssInlineSizes(Style(), min_space_builder.ToConstraintSpace(),
-                             border_padding, grid_min_max,
-                             &min_measure_table_css_min_inline_size,
-                             &min_measure_table_css_inline_size);
-
-  // Table min/max sizes are unusual in how the specified sizes affects them.
-  // If table_css_inline_size is defined:
-  //   min_max_sizes is std::max(
-  //     table_css_inline_size,
-  //     grid_min_max.min_size,
-  //     caption_constraint.min_size)
-  //  (min_size and max_size are the same value).
-  //
-  // If table_css_inline_size is not defined:
-  //   min_max_sizes.min_size is std::max(
-  //     grid_min_max.min_size, caption_constraint.min_size)
-  //   min_max_sizes.max_size is std::max(
-  //     grid_min_max.max_size, caption_constraint.min_size)
-  if (min_measure_table_css_inline_size) {
-    NGConstraintSpaceBuilder max_space_builder(
-        ConstraintSpace(), table_writing_direction, /* is_new_fc */ true);
-    max_space_builder.SetAvailableSize(
-        {grid_min_max.max_size, kIndefiniteSize});
-    LayoutUnit max_measure_table_css_min_inline_size;
-    base::Optional<LayoutUnit> max_measure_table_css_inline_size;
-    ComputeTableCssInlineSizes(Style(), max_space_builder.ToConstraintSpace(),
-                               border_padding, grid_min_max,
-                               &max_measure_table_css_min_inline_size,
-                               &max_measure_table_css_inline_size);
-    // Compute minimum.
-    min_max.min_size =
-        std::max({min_max.min_size, min_measure_table_css_min_inline_size,
-                  *min_measure_table_css_inline_size});
-    // Compute maximum.
-    min_max.max_size =
-        std::max({max_measure_table_css_min_inline_size,
-                  *max_measure_table_css_inline_size, grid_min_max.min_size,
-                  caption_constraint.min_size});
+  if (!ShouldIgnoreInfiniteMaxSizeForMinMax(*layout_table)) {
     if (is_fixed_layout && Style().LogicalWidth().IsPercentOrCalc())
       min_max.max_size = NGTableTypes::kTableMaxInlineSize;
   }
+
   DCHECK_LE(min_max.min_size, min_max.max_size);
   return MinMaxSizesResult{min_max,
                            /* depends_on_percentage_block_size */ false};