[Masonry] Move grid intrinsic minimum logic to helpers

The grid implementation has special logic for intrinsic minimums that
also should apply to masonry [1].

Move this logic to two new helpers:
- CalculateIntrinsicMinimumContribution() that returns the contribution
size to use for a given item.
- ClampIntrinsicMinSize() which clamps the contribution size, if it
was the min content contribution, by the total track size that the
item spans.

This is in preparation for reuse in masonry. This CL should produce
no functional changes.

[1] https://drafts.csswg.org/css-grid/#min-size-auto

Bug: 343257585

Change-Id: I6b13bf9bafb59aa7b7006486aa46fd346304afd0
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7013328
Reviewed-by: Kurt Catti-Schmidt <[email protected]>
Reviewed-by: Ian Kilpatrick <[email protected]>
Commit-Queue: Alison Maher <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1532392}

Author: alisonmaher

third_party/blink/renderer/core/layout/grid/grid_layout_algorithm.cc

@@ -998,120 +998,66 @@ LayoutUnit GridLayoutAlgorithm::ContributionSizeForGridItem(
                                                       : BlockContributionSize();
       break;
     case GridItemContributionType::kForIntrinsicMinimums: {
-      // TODO(ikilpatrick): All of the below is incorrect for replaced elements.
-      const auto& main_length = is_parallel_with_track_direction
-                                    ? item_style.LogicalWidth()
-                                    : item_style.LogicalHeight();
-      const auto& min_length = is_parallel_with_track_direction
-                                   ? item_style.LogicalMinWidth()
-                                   : item_style.LogicalMinHeight();
-
-      // We could be clever is and make this an if-stmt, but each type has
-      // subtle consequences. This forces us in the future when we add a new
-      // length type to consider what the best thing is for grid.
-      switch (main_length.GetType()) {
-        case Length::kAuto:
-        case Length::kFitContent:
-        case Length::kStretch:
-        case Length::kPercent:
-        case Length::kCalculated: {
-          const auto border_padding =
-              ComputeBorders(space, node) + ComputePadding(space, item_style);
-
-          // All of the above lengths are considered 'auto' if we are querying a
-          // minimum contribution. They all require definite track sizes to
-          // determine their final size.
-          //
-          // From https://drafts.csswg.org/css-grid/#min-size-auto:
-          //   To provide a more reasonable default minimum size for grid items,
-          //   the used value of its automatic minimum size in a given axis is
-          //   the content-based minimum size if all of the following are true:
-          //     - it is not a scroll container
-          //     - it spans at least one track in that axis whose min track
-          //     sizing function is 'auto'
-          //     - if it spans more than one track in that axis, none of those
-          //     tracks are flexible
-          //   Otherwise, the automatic minimum size is zero, as usual.
-          //
-          // Start by resolving the cases where |min_length| is non-auto or its
-          // automatic minimum size should be zero.
-          if (!min_length.HasAuto() || item_style.IsScrollContainer() ||
-              !grid_item->IsSpanningAutoMinimumTrack(track_direction) ||
-              (grid_item->IsSpanningFlexibleTrack(track_direction) &&
-               grid_item->SpanSize(track_direction) > 1)) {
-            // TODO(ikilpatrick): This block needs to respect the aspect-ratio,
-            // and apply the transferred min/max sizes when appropriate. We do
-            // this sometimes elsewhere so should unify and simplify this code.
-            if (is_parallel_with_track_direction) {
-              contribution =
-                  ResolveMinInlineLength(space, item_style, border_padding,
-                                         MinMaxSizesFunc, min_length);
-            } else {
-              contribution = ResolveInitialMinBlockLength(
-                  space, item_style, border_padding, min_length);
-            }
-            break;
-          }
-
-          // Resolve the content-based minimum size.
-          contribution = is_parallel_with_track_direction
-                             ? MinContentSize()
-                             : BlockContributionSize();
-
-          auto spanned_tracks_definite_max_size =
-              track_collection.CalculateSetSpanSize(begin_set_index,
-                                                    end_set_index);
-
-          if (spanned_tracks_definite_max_size != kIndefiniteSize) {
-            // Further clamp the minimum size to less than or equal to the
-            // stretch fit into the grid area’s maximum size in that dimension,
-            // as represented by the sum of those grid tracks’ max track sizing
-            // functions plus any intervening fixed gutters.
-            const auto border_padding_sum = is_parallel_with_track_direction
-                                                ? border_padding.InlineSum()
-                                                : border_padding.BlockSum();
-            DCHECK_GE(contribution, baseline_shim + border_padding_sum);
-
-            // The stretch fit into a given size is that size, minus the box’s
-            // computed margins, border, and padding in the given dimension,
-            // flooring at zero so that the inner size is not negative.
-            spanned_tracks_definite_max_size =
-                (spanned_tracks_definite_max_size - baseline_shim - margin_sum -
-                 border_padding_sum)
-                    .ClampNegativeToZero();
-
-            // Add the baseline shim, border, and padding (margins will be added
-            // later) back to the contribution, since we don't want the outer
-            // size of the minimum size to overflow its grid area; these are
-            // already accounted for in the current value of `contribution`.
-            contribution =
-                std::min(contribution, spanned_tracks_definite_max_size +
-                                           baseline_shim + border_padding_sum);
-          }
-          break;
-        }
-        case Length::kMinContent:
-        case Length::kMaxContent:
-        case Length::kFixed: {
-          // All of the above lengths are "definite" (non-auto), and don't need
-          // the special min-size treatment above. (They will all end up being
-          // the specified size).
-          if (is_parallel_with_track_direction) {
-            contribution = main_length.IsMaxContent() ? MaxContentSize()
-                                                      : MinContentSize();
-          } else {
-            contribution = BlockContributionSize();
-          }
-          break;
+      // See https://drafts.csswg.org/css-grid/#min-size-auto for more details
+      // on the special logic applied for intrinsic minimums.
+      //
+      // Per the spec link above, we apply the automatic min when:
+      // - it spans at least one track in that axis whose min track sizing
+      // function is auto.
+      // - if it spans more than one track in that axis, none of those tracks
+      // are flexible.
+      const bool special_spanning_criteria =
+          !grid_item->IsSpanningAutoMinimumTrack(track_direction) ||
+          (grid_item->IsSpanningFlexibleTrack(track_direction) &&
+           grid_item->SpanSize(track_direction) > 1);
+
+      const LayoutUnit min_content_contribution =
+          is_parallel_with_track_direction ? MinContentSize()
+                                           : BlockContributionSize();
+      const LayoutUnit max_content_contribution =
+          is_parallel_with_track_direction ? MaxContentSize()
+                                           : min_content_contribution;
+
+      MinMaxSizesResult subgrid_minmax_sizes;
+      if (grid_item->IsSubgrid()) {
+        const GridSizingSubtree& subgrid_sizing_subtree =
+            sizing_subtree.SubgridSizingSubtree(*grid_item);
+        if (subgrid_sizing_subtree.LayoutData().IsSubgridWithStandaloneAxis(
+                kForColumns)) {
+          subgrid_minmax_sizes = To<GridNode>(node).ComputeSubgridMinMaxSizes(
+              subgrid_sizing_subtree, space);
         }
-        case Length::kMinIntrinsic:
-        case Length::kFlex:
-        case Length::kExtendToZoom:
-        case Length::kDeviceWidth:
-        case Length::kDeviceHeight:
-        case Length::kNone:
-        case Length::kContent:
-          NOTREACHED();
+      }
+
+      bool maybe_clamp = false;
+      contribution = CalculateIntrinsicMinimumContribution(
+          is_parallel_with_track_direction, special_spanning_criteria,
+          min_content_contribution, max_content_contribution, space,
+          subgrid_minmax_sizes, grid_item, maybe_clamp);
+
+      if (!maybe_clamp) {
+        break;
+      }
+
+      // Further clamp the minimum size to less than or equal to the
+      // stretch fit into the grid area’s maximum size in that dimension,
+      // as represented by the sum of those grid tracks’ max track sizing
+      // functions plus any intervening fixed gutters.
+      auto spanned_tracks_definite_max_size =
+          track_collection.CalculateSetSpanSize(begin_set_index, end_set_index);
+      if (spanned_tracks_definite_max_size != kIndefiniteSize) {
+        contribution += margin_sum;
+        const auto border_padding =
+            ComputeBorders(space, node) + ComputePadding(space, item_style);
+        const auto border_padding_sum = is_parallel_with_track_direction
+                                            ? border_padding.InlineSum()
+                                            : border_padding.BlockSum();
+
+        contribution = ClampIntrinsicMinSize(
+            contribution,
+            /*min_clamp_size=*/margin_sum + baseline_shim + border_padding_sum,
+            spanned_tracks_definite_max_size);
+        contribution -= margin_sum;
       }
       break;
     }

third_party/blink/renderer/core/layout/grid/grid_layout_utils.cc

@@ -435,4 +435,114 @@ void AlignmentOffsetForOutOfFlow(AxisEdge inline_axis_edge,
   }
 }
 
+LayoutUnit CalculateIntrinsicMinimumContribution(
+    bool is_parallel_with_track_direction,
+    bool special_spanning_criteria,
+    const LayoutUnit min_content_contribution,
+    const LayoutUnit max_content_contribution,
+    const ConstraintSpace& space,
+    const MinMaxSizesResult& subgrid_minmax_sizes,
+    const GridItemData* grid_item,
+    bool& maybe_clamp) {
+  CHECK(grid_item);
+  const auto& node = grid_item->node;
+  const ComputedStyle& item_style = node.Style();
+  maybe_clamp = false;
+
+  // TODO(ikilpatrick): All of the below is incorrect for replaced elements.
+  const auto& main_length = is_parallel_with_track_direction
+                                ? item_style.LogicalWidth()
+                                : item_style.LogicalHeight();
+  const auto& min_length = is_parallel_with_track_direction
+                               ? item_style.LogicalMinWidth()
+                               : item_style.LogicalMinHeight();
+
+  // We could be clever and make this an if-stmt, but each type has
+  // subtle consequences. This forces us in the future when we add a new
+  // length type to consider what the best thing is for grid.
+  switch (main_length.GetType()) {
+    case Length::kAuto:
+    case Length::kFitContent:
+    case Length::kStretch:
+    case Length::kPercent:
+    case Length::kCalculated: {
+      const auto border_padding =
+          ComputeBorders(space, node) + ComputePadding(space, item_style);
+
+      // All of the above lengths are considered 'auto' if we are querying a
+      // minimum contribution. They all require definite track sizes to
+      // determine their final size.
+      //
+      // From https://drafts.csswg.org/css-grid/#min-size-auto:
+      //   To provide a more reasonable default minimum size for grid items,
+      //   the used value of its automatic minimum size in a given axis is
+      //   the content-based minimum size if all of the following are true:
+      //     - it is not a scroll container
+      //     - it spans at least one track in that axis whose min track
+      //     sizing function is 'auto'
+      //     - if it spans more than one track in that axis, none of those
+      //     tracks are flexible
+      //   Otherwise, the automatic minimum size is zero, as usual.
+      //
+      // Start by resolving the cases where |min_length| is non-auto or its
+      // automatic minimum size should be zero.
+      if (!min_length.HasAuto() || item_style.IsScrollContainer() ||
+          special_spanning_criteria) {
+        // TODO(ikilpatrick): This block needs to respect the aspect-ratio,
+        // and apply the transferred min/max sizes when appropriate. We do
+        // this sometimes elsewhere so should unify and simplify this code.
+        if (is_parallel_with_track_direction) {
+          auto MinMaxSizesFunc = [&](SizeType type) -> MinMaxSizesResult {
+            if (grid_item->IsSubgrid()) {
+              return subgrid_minmax_sizes;
+            }
+            return node.ComputeMinMaxSizes(item_style.GetWritingMode(), type,
+                                           space);
+          };
+          return ResolveMinInlineLength(space, item_style, border_padding,
+                                        MinMaxSizesFunc, min_length);
+        } else {
+          return ResolveInitialMinBlockLength(space, item_style, border_padding,
+                                              min_length);
+        }
+      }
+
+      maybe_clamp = true;
+      return min_content_contribution;
+    }
+    case Length::kMinContent:
+    case Length::kMaxContent:
+    case Length::kFixed: {
+      // All of the above lengths are "definite" (non-auto), and don't need
+      // the special min-size treatment above. (They will all end up being
+      // the specified size).
+      return main_length.IsMaxContent() ? max_content_contribution
+                                        : min_content_contribution;
+    }
+    case Length::kMinIntrinsic:
+    case Length::kFlex:
+    case Length::kExtendToZoom:
+    case Length::kDeviceWidth:
+    case Length::kDeviceHeight:
+    case Length::kNone:
+    case Length::kContent:
+      NOTREACHED();
+  }
+}
+
+LayoutUnit ClampIntrinsicMinSize(LayoutUnit min_content_contribution,
+                                 LayoutUnit min_clamp_size,
+                                 LayoutUnit spanned_tracks_definite_max_size) {
+  CHECK_NE(spanned_tracks_definite_max_size, kIndefiniteSize);
+  DCHECK_GE(min_content_contribution, min_clamp_size);
+
+  // Don't clamp beyond `min_clamp_size`, which usually represents
+  // the sum of border/padding, margins, and the baseline shim for
+  // the associated item.
+  spanned_tracks_definite_max_size =
+      std::max(spanned_tracks_definite_max_size, min_clamp_size);
+
+  return std::min(min_content_contribution, spanned_tracks_definite_max_size);
+}
+
 }  // namespace blink

third_party/blink/renderer/core/layout/grid/grid_layout_utils.h

@@ -22,6 +22,7 @@ struct BoxStrut;
 struct GridItemData;
 struct LogicalOffset;
 struct LogicalSize;
+struct MinMaxSizesResult;
 
 // Update the provided `available_size`, `min_available_size`, and
 // `max_available_size` to their appropriate values.
@@ -66,6 +67,45 @@ void AlignmentOffsetForOutOfFlow(AxisEdge inline_axis_edge,
                                  LogicalStaticPosition::BlockEdge* block_edge,
                                  LogicalOffset* offset);
 
+// Per the Grid spec [1] there is special logic for the contribution size to use
+// for intrinsic minimums. This method returns the contribution size of
+// `grid_item` given the provided variables.
+//
+// When `special_spanning_criteria` is true, always use the automatic minimum
+// size - this usually happens when an item spans at least one track with a min
+// track size of 'auto' or if an item spans more than one non-flexible track.
+// However, in masonry, we don't have this information when initially
+// calculating the virtual item contributions, so masonry needs this var to
+// force this to both true and false to get both potential contributions for use
+// later when more information is known about the tracks a virtual item spans.
+//
+// `min_content_contribution` and `max_content_contribution` are the content
+// based min and maximums for the provided `grid_item` respectively. If the item
+// is a subgrid, `subgrid_minmax_sizes` will be the min/max size result for the
+// subgrid.
+//
+// This method will set `maybe_clamp` to true if the content based contribution
+// was returned and should be considered for clamping. Otherwise, it will be set
+// to false.
+//
+// [1] https://drafts.csswg.org/css-grid/#min-size-auto
+LayoutUnit CalculateIntrinsicMinimumContribution(
+    bool is_parallel_with_track_direction,
+    bool special_spanning_criteria,
+    const LayoutUnit min_content_contribution,
+    const LayoutUnit max_content_contribution,
+    const ConstraintSpace& space,
+    const MinMaxSizesResult& subgrid_minmax_sizes,
+    const GridItemData* grid_item,
+    bool& maybe_clamp);
+
+// Return `min_content_contribution` clamped by
+// `spanned_tracks_definite_max_size` up to `min_clamp_size`. `min_clamp_size`
+// usually represents the sum of border/padding, margins, and the baseline shim.
+LayoutUnit ClampIntrinsicMinSize(LayoutUnit min_content_contribution,
+                                 LayoutUnit min_clamp_size,
+                                 LayoutUnit spanned_tracks_definite_max_size);
+
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_CORE_LAYOUT_GRID_GRID_LAYOUT_UTILS_H_