[TableNG] Use ComputeInlineSizeForFragment for the assignable size.

As above. This patch uses the ComputeInlineSizeForFragment within
ComputeAssignableTableInlineSize. This has the effect of correctly
computing the "stretched" inline-size when the table is a grid-item.

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

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

@@ -431,19 +431,16 @@ LayoutUnit ComputeInlineSizeFromAspectRatio(const NGConstraintSpace& space,
                                    style.BoxSizing(), block_size);
 }
 
-LayoutUnit ComputeInlineSizeForFragment(
+namespace {
+
+LayoutUnit ComputeInlineSizeForFragmentInternal(
     const NGConstraintSpace& space,
     NGLayoutInputNode node,
     const NGBoxStrut& border_padding,
-    const MinMaxSizes* override_min_max_sizes_for_test) {
-  if (space.IsFixedInlineSize() || space.IsAnonymous())
-    return space.AvailableSize().inline_size;
-  if (node.IsNGTable())
-    return To<NGTableNode>(node).ComputeTableInlineSize(space, border_padding);
-
+    const MinMaxSizes* override_min_max_sizes) {
   auto MinMaxSizesFunc = [&](MinMaxSizesType type) -> MinMaxSizesResult {
-    if (override_min_max_sizes_for_test)
-      return {*override_min_max_sizes_for_test, false};
+    if (override_min_max_sizes)
+      return {*override_min_max_sizes, false};
 
     MinMaxSizesInput input(space.PercentageResolutionBlockSize(), type);
     return node.ComputeMinMaxSizes(space.GetWritingMode(), input, &space);
@@ -495,6 +492,33 @@ LayoutUnit ComputeInlineSizeForFragment(
   return min_max.ClampSizeToMinAndMax(extent);
 }
 
+}  // namespace
+
+LayoutUnit ComputeInlineSizeForFragment(
+    const NGConstraintSpace& space,
+    NGLayoutInputNode node,
+    const NGBoxStrut& border_padding,
+    const MinMaxSizes* override_min_max_sizes_for_test) {
+  if (space.IsFixedInlineSize() || space.IsAnonymous())
+    return space.AvailableSize().inline_size;
+
+  if (node.IsNGTable())
+    return To<NGTableNode>(node).ComputeTableInlineSize(space, border_padding);
+
+  return ComputeInlineSizeForFragmentInternal(space, node, border_padding,
+                                              override_min_max_sizes_for_test);
+}
+
+LayoutUnit ComputeUsedInlineSizeForTableFragment(
+    const NGConstraintSpace& space,
+    NGLayoutInputNode node,
+    const NGBoxStrut& border_padding,
+    const MinMaxSizes& table_grid_min_max_sizes) {
+  DCHECK(!space.IsFixedInlineSize());
+  return ComputeInlineSizeForFragmentInternal(space, node, border_padding,
+                                              &table_grid_min_max_sizes);
+}
+
 MinMaxSizes ComputeMinMaxBlockSize(
     const NGConstraintSpace& constraint_space,
     const ComputedStyle& style,

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

@@ -370,6 +370,15 @@ CORE_EXPORT LayoutUnit ComputeInlineSizeForFragment(
     const NGBoxStrut& border_padding,
     const MinMaxSizes* override_min_max_sizes_for_test = nullptr);
 
+// Similar to |ComputeInlineSizeForFragment| but for determining the "used"
+// inline-size for a table fragment. See:
+// https://drafts.csswg.org/css-tables-3/#used-width-of-table
+CORE_EXPORT LayoutUnit ComputeUsedInlineSizeForTableFragment(
+    const NGConstraintSpace& space,
+    NGLayoutInputNode node,
+    const NGBoxStrut& border_padding,
+    const MinMaxSizes& table_grid_min_max_sizes);
+
 // Same as ComputeInlineSizeForFragment, but uses height instead of width.
 // |inline_size| is necessary to compute the block size when an aspect ratio
 // is in use.

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

@@ -82,8 +82,7 @@ void ComputeTableCssInlineSizes(
     const NGBoxStrut& table_border_padding,
     const MinMaxSizes& grid_min_max,
     LayoutUnit* table_css_min_inline_size,
-    base::Optional<LayoutUnit>* table_css_inline_size,
-    base::Optional<LayoutUnit>* table_css_max_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()
@@ -95,24 +94,10 @@ void ComputeTableCssInlineSizes(
   // Compute standard "used width of a table".
   const Length& table_length = table_style.LogicalWidth();
   if (!table_length.IsAuto()) {
-    *table_css_inline_size = ResolveMainInlineLength(
-        constraint_space, table_style, table_border_padding,
-        [grid_min_max](MinMaxSizesType) {
-          return MinMaxSizesResult{
-              grid_min_max,
-              /* depends_on_percentage_block_size */ false};
-        },
-        table_length);
-  }
-
-  const Length& table_max_length = table_style.LogicalMaxWidth();
-  if (table_max_length.IsSpecified()) {
-    *table_css_max_inline_size =
-        ResolveMaxInlineLength<base::Optional<MinMaxSizes>>(
-            constraint_space, table_style, table_border_padding, base::nullopt,
-            table_max_length, LengthResolvePhase::kLayout);
-    *table_css_max_inline_size =
-        std::max(**table_css_max_inline_size, *table_css_min_inline_size);
+    *table_css_inline_size =
+        ResolveMainInlineLength<base::Optional<MinMaxSizes>>(
+            constraint_space, table_style, table_border_padding, grid_min_max,
+            table_length);
   }
 }
 
@@ -156,45 +141,26 @@ LayoutUnit ComputeAssignableTableInlineSize(
     return (space.AvailableSize().inline_size - undistributable_space)
         .ClampNegativeToZero();
   }
-  MinMaxSizes grid_min_max = NGTableAlgorithmHelpers::ComputeGridInlineMinMax(
-      column_constraints, undistributable_space, is_fixed_layout,
-      /* containing_block_expects_minmax_without_percentages */ false,
-      /* skip_collapsed_columns */ false);
-
-  LayoutUnit table_css_min_inline_size;
-  base::Optional<LayoutUnit> table_css_inline_size;
-  base::Optional<LayoutUnit> table_css_max_inline_size;
-  ComputeTableCssInlineSizes(table.Style(), space, table_border_padding,
-                             grid_min_max, &table_css_min_inline_size,
-                             &table_css_inline_size,
-                             &table_css_max_inline_size);
-
-  LayoutUnit table_min_inline_size =
-      std::max({table_css_min_inline_size, caption_constraint.min_size,
-                grid_min_max.min_size});
 
-  // Standard: "used width of the table".
-  LayoutUnit used_inline_size_of_the_table;
-  if (table_css_inline_size) {
-    used_inline_size_of_the_table = *table_css_inline_size;
-  } else {
-    NGBoxStrut margins = ComputeMarginsForSelf(space, table.Style());
-    used_inline_size_of_the_table =
-        std::min(grid_min_max.max_size,
-                 (space.AvailableSize().inline_size - margins.InlineSum())
-                     .ClampNegativeToZero());
-  }
-  if (table_css_max_inline_size) {
-    used_inline_size_of_the_table =
-        std::min(used_inline_size_of_the_table, *table_css_max_inline_size);
-  }
-  used_inline_size_of_the_table =
-      std::max(used_inline_size_of_the_table, table_min_inline_size);
+  const MinMaxSizes grid_min_max =
+      NGTableAlgorithmHelpers::ComputeGridInlineMinMax(
+          column_constraints, undistributable_space, is_fixed_layout,
+          /* containing_block_expects_minmax_without_percentages */ false,
+          /* skip_collapsed_columns */ false);
+
+  LayoutUnit used_table_inline_size = ComputeUsedInlineSizeForTableFragment(
+      space, table, table_border_padding, grid_min_max);
+
+  // Don't allow the inline-size to go below the grid, or caption min-size.
+  used_table_inline_size =
+      std::max({used_table_inline_size, caption_constraint.min_size,
+                grid_min_max.min_size});
 
   // Standard: The assignable table width is the "used width of the table"
   // minus the total horizontal border spacing.
-  LayoutUnit assignable_table_inline_size =
-      used_inline_size_of_the_table - undistributable_space;
+  const LayoutUnit assignable_table_inline_size =
+      used_table_inline_size - undistributable_space;
+  DCHECK_GE(assignable_table_inline_size, LayoutUnit());
 
   return assignable_table_inline_size;
 }
@@ -614,12 +580,11 @@ MinMaxSizesResult NGTableLayoutAlgorithm::ComputeMinMaxSizes(
   min_space_builder.SetAvailableSize({LayoutUnit(), kIndefiniteSize});
   LayoutUnit min_measure_table_css_min_inline_size;
   base::Optional<LayoutUnit> min_measure_table_css_inline_size;
-  base::Optional<LayoutUnit> measure_table_css_max_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, &measure_table_css_max_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:
@@ -641,10 +606,10 @@ MinMaxSizesResult NGTableLayoutAlgorithm::ComputeMinMaxSizes(
         {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, &measure_table_css_max_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,