[css-grid] Move the track sizing algorithm to its own class

third_party/WebKit/Source/core/layout/GridTrackSizingAlgorithm.cpp

Index: third_party/WebKit/Source/core/layout/GridTrackSizingAlgorithm.cpp
diff --git a/third_party/WebKit/Source/core/layout/GridTrackSizingAlgorithm.cpp b/third_party/WebKit/Source/core/layout/GridTrackSizingAlgorithm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a755fb936648f286ab7eefe3020a2209937c30bc
--- /dev/null
+++ b/third_party/WebKit/Source/core/layout/GridTrackSizingAlgorithm.cpp
@@ -0,0 +1,1445 @@
+#include "core/layout/GridTrackSizingAlgorithm.h"
+
+#include "core/layout/Grid.h"
+#include "core/layout/LayoutGrid.h"
+#include "platform/LengthFunctions.h"
+
+namespace blink {
+
+class GridSizingData;
+
+LayoutUnit GridTrack::baseSize() const {
+  DCHECK(isGrowthLimitBiggerThanBaseSize());
+  return m_baseSize;
+}
+
+LayoutUnit GridTrack::growthLimit() const {
+  DCHECK(isGrowthLimitBiggerThanBaseSize());
+  DCHECK(!m_growthLimitCap || m_growthLimitCap.value() >= m_growthLimit ||
+         m_baseSize >= m_growthLimitCap.value());
+  return m_growthLimit;
+}
+
+void GridTrack::setBaseSize(LayoutUnit baseSize) {
+  m_baseSize = baseSize;
+  ensureGrowthLimitIsBiggerThanBaseSize();
+}
+
+void GridTrack::setGrowthLimit(LayoutUnit growthLimit) {
+  m_growthLimit =
+      growthLimit == infinity
+          ? growthLimit
+          : std::min(growthLimit, m_growthLimitCap.value_or(growthLimit));
+  ensureGrowthLimitIsBiggerThanBaseSize();
+}
+
+void GridTrack::setPlannedSize(const LayoutUnit& plannedSize) {
+  DCHECK(plannedSize >= 0 || plannedSize == infinity);
+  m_plannedSize = plannedSize;
+}
+
+void GridTrack::setSizeDuringDistribution(
+    const LayoutUnit& sizeDuringDistribution) {
+  DCHECK_GE(sizeDuringDistribution, 0);
+  DCHECK(growthLimitIsInfinite() || growthLimit() >= sizeDuringDistribution);
+  m_sizeDuringDistribution = sizeDuringDistribution;
+}
+
+void GridTrack::growSizeDuringDistribution(
+    const LayoutUnit& sizeDuringDistribution) {
+  DCHECK_GE(sizeDuringDistribution, 0);
+  m_sizeDuringDistribution += sizeDuringDistribution;
+}
+
+void GridTrack::setGrowthLimitCap(Optional<LayoutUnit> growthLimitCap) {
+  DCHECK(!growthLimitCap || *growthLimitCap >= 0);
+  m_growthLimitCap = growthLimitCap;
+}
+
+bool GridTrack::isGrowthLimitBiggerThanBaseSize() const {
+  return growthLimitIsInfinite() || m_growthLimit >= m_baseSize;

[Manuel Rego, 2017/01/30 11:00:45]

Again oneliner method here and not in the header.

[svillar, 2017/01/30 11:28:29]

Again it isn't a one liner with the new coding style.

+}
+
+void GridTrack::ensureGrowthLimitIsBiggerThanBaseSize() {
+  if (m_growthLimit != infinity && m_growthLimit < m_baseSize)
+    m_growthLimit = m_baseSize;
+}
+
+class IndefiniteSizeStrategy final : public GridTrackSizingAlgorithmStrategy {
+ public:
+  IndefiniteSizeStrategy(GridTrackSizingAlgorithm& algorithm)
+      : GridTrackSizingAlgorithmStrategy(algorithm) {}
+
+ private:
+  LayoutUnit minContentForChild(LayoutBox& child) override;

[Manuel Rego, 2017/01/30 11:00:45]

Name of the argument not needed here, and in the next definitions.
The same happens for DefiniteSizeStrategy class.

[svillar, 2017/01/30 11:28:29]

Acknowledged.

+  LayoutUnit maxContentForChild(LayoutBox& child) const override;
+  LayoutUnit minSizeForChild(LayoutBox& child) override;
+  void maximizeTracks(Vector<GridTrack>&, LayoutUnit& freeSpace) override;
+  double findUsedFlexFraction(Vector<size_t>& flexibleSizedTracksIndex,
+                              GridTrackSizingDirection,
+                              LayoutUnit freeSpace) const override;
+  bool recomputeUsedFlexFractionIfNeeded(
+      Vector<size_t>& flexibleSizedTracksIndex,
+      double& flexFraction,
+      Vector<LayoutUnit>& increments,
+      LayoutUnit& totalGrowth) const override;
+};
+
+class DefiniteSizeStrategy final : public GridTrackSizingAlgorithmStrategy {
+ public:
+  DefiniteSizeStrategy(GridTrackSizingAlgorithm& algorithm)
+      : GridTrackSizingAlgorithmStrategy(algorithm) {}
+
+ private:
+  LayoutUnit minContentForChild(LayoutBox& child) override;
+  LayoutUnit maxContentForChild(LayoutBox& child) const override;
+  LayoutUnit minSizeForChild(LayoutBox& child) override;
+  void maximizeTracks(Vector<GridTrack>&, LayoutUnit& freeSpace) override;
+  double findUsedFlexFraction(Vector<size_t>& flexibleSizedTracksIndex,
+                              GridTrackSizingDirection,
+                              LayoutUnit freeSpace) const override;
+  bool recomputeUsedFlexFractionIfNeeded(
+      Vector<size_t>& flexibleSizedTracksIndex,
+      double& flexFraction,
+      Vector<LayoutUnit>& increments,
+      LayoutUnit& totalGrowth) const override {
+    return false;
+  }
+};
+
+// FIXME(ALGO): repeated in LayoutGrid

[Manuel Rego, 2017/01/30 11:00:45]

What's this comment? It should be something like "TODO(svillar): ...."

+static LayoutUnit computeMarginLogicalSizeForChild(MarginDirection forDirection,
+                                                   const LayoutGrid* grid,
+                                                   const LayoutBox& child) {
+  if (!child.styleRef().hasMargin())
+    return LayoutUnit();
+
+  bool isRowAxis = forDirection == InlineDirection;
+  LayoutUnit marginStart;
+  LayoutUnit marginEnd;
+  LayoutUnit logicalSize =
+      isRowAxis ? child.logicalWidth() : child.logicalHeight();
+  Length marginStartLength = isRowAxis ? child.styleRef().marginStart()
+                                       : child.styleRef().marginBefore();
+  Length marginEndLength =
+      isRowAxis ? child.styleRef().marginEnd() : child.styleRef().marginAfter();
+  child.computeMarginsForDirection(
+      forDirection, grid, child.containingBlockLogicalWidthForContent(),
+      logicalSize, marginStart, marginEnd, marginStartLength, marginEndLength);
+
+  return marginStart + marginEnd;
+}
+
+static bool hasOverrideContainingBlockContentSizeForChild(
+    const LayoutBox& child,
+    GridTrackSizingDirection direction) {
+  return direction == ForColumns
+             ? child.hasOverrideContainingBlockLogicalWidth()
+             : child.hasOverrideContainingBlockLogicalHeight();
+}
+
+static LayoutUnit overrideContainingBlockContentSizeForChild(
+    const LayoutBox& child,
+    GridTrackSizingDirection direction) {
+  return direction == ForColumns
+             ? child.overrideContainingBlockContentLogicalWidth()
+             : child.overrideContainingBlockContentLogicalHeight();
+}
+
+static bool shouldClearOverrideContainingBlockContentSizeForChild(
+    const LayoutBox& child,
+    GridTrackSizingDirection direction) {
+  if (direction == ForColumns) {
+    return child.hasRelativeLogicalWidth() ||
+           child.styleRef().logicalWidth().isIntrinsicOrAuto();
+  }
+  return child.hasRelativeLogicalHeight() ||
+         child.styleRef().logicalHeight().isIntrinsicOrAuto();
+}
+
+static void setOverrideContainingBlockContentSizeForChild(
+    LayoutBox& child,
+    GridTrackSizingDirection direction,
+    LayoutUnit size) {
+  if (direction == ForColumns)
+    child.setOverrideContainingBlockContentLogicalWidth(size);
+  else
+    child.setOverrideContainingBlockContentLogicalHeight(size);
+}
+
+static GridTrackSizingDirection flowAwareDirectionForChild(
+    const LayoutGrid* layoutGrid,
+    const LayoutBox& child,
+    GridTrackSizingDirection direction) {
+  return child.isHorizontalWritingMode() ==
+                 layoutGrid->isHorizontalWritingMode()
+             ? direction
+             : (direction == ForColumns ? ForRows : ForColumns);
+}
+
+LayoutUnit GridTrackSizingAlgorithm::assumedRowsSizeForOrthogonalChild(
+    const LayoutBox& child) const {
+  // DCHECK(isOrthogonalChild(child));

[Manuel Rego, 2017/01/30 11:00:45]

Why is this commented out here?
Shouldn't we need to add a TODO or remove it or something?

+  const GridSpan& span = m_grid.gridItemSpan(child, ForRows);
+  LayoutUnit gridAreaSize;
+  bool gridAreaIsIndefinite = false;
+  LayoutUnit containingBlockAvailableSize =
+      m_layoutGrid->containingBlockLogicalHeightForContent(
+          ExcludeMarginBorderPadding);
+  for (auto trackPosition : span) {
+    GridLength maxTrackSize =
+        gridTrackSize(ForRows, trackPosition).maxTrackBreadth();
+    if (maxTrackSize.isContentSized() || maxTrackSize.isFlex()) {
+      gridAreaIsIndefinite = true;
+    } else {
+      gridAreaSize +=
+          valueForLength(maxTrackSize.length(), containingBlockAvailableSize);
+    }
+  }
+
+  gridAreaSize += m_layoutGrid->guttersSize(
+      m_grid, ForRows, span.startLine(), span.integerSpan(), m_sizingOperation);
+
+  return gridAreaIsIndefinite
+             ? std::max(child.maxPreferredLogicalWidth(), gridAreaSize)
+             : gridAreaSize;
+}
+
+LayoutUnit GridTrackSizingAlgorithm::gridAreaBreadthForChild(
+    const LayoutBox& child,
+    GridTrackSizingDirection direction) {
+  if (direction == ForRows && m_sizingState == ColumnSizingFirstIteration)
+    return assumedRowsSizeForOrthogonalChild(child);
+
+  Vector<GridTrack>& allTracks = tracks(direction);
+  const GridSpan& span = m_grid.gridItemSpan(child, direction);
+  LayoutUnit gridAreaBreadth;
+  for (const auto& trackPosition : span)
+    gridAreaBreadth += allTracks[trackPosition].baseSize();
+
+  gridAreaBreadth +=
+      m_layoutGrid->guttersSize(m_grid, direction, span.startLine(),
+                                span.integerSpan(), m_sizingOperation);
+
+  return gridAreaBreadth;
+}
+
+bool GridTrackSizingAlgorithmStrategy::
+    updateOverrideContainingBlockContentSizeForChild(
+        LayoutBox& child,
+        GridTrackSizingDirection direction) const {
+  LayoutUnit overrideSize =
+      m_algorithm.gridAreaBreadthForChild(child, direction);
+  if (hasOverrideContainingBlockContentSizeForChild(child, direction) &&
+      overrideContainingBlockContentSizeForChild(child, direction) ==
+          overrideSize)
+    return false;
+
+  setOverrideContainingBlockContentSizeForChild(child, direction, overrideSize);
+  return true;
+}
+
+LayoutUnit GridTrackSizingAlgorithmStrategy::logicalHeightForChild(
+    LayoutBox& child) const {
+  GridTrackSizingDirection childBlockDirection =
+      flowAwareDirectionForChild(layoutGrid(), child, ForRows);
+
+  // If |child| has a relative logical height, we shouldn't let it override its
+  // intrinsic height, which is what we are interested in here. Thus we need to
+  // set the block-axis override size to -1 (no possible resolution).
+  if (shouldClearOverrideContainingBlockContentSizeForChild(child, ForRows)) {
+    setOverrideContainingBlockContentSizeForChild(child, childBlockDirection,
+                                                  LayoutUnit(-1));
+    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+  }
+
+  // We need to clear the stretched height to properly compute logical height
+  // during layout.
+  if (child.needsLayout())
+    child.clearOverrideLogicalContentHeight();
+
+  child.layoutIfNeeded();
+  return child.logicalHeight() + child.marginLogicalHeight();
+}
+
+DISABLE_CFI_PERF
+LayoutUnit DefiniteSizeStrategy::minContentForChild(LayoutBox& child) {

[Manuel Rego, 2017/01/30 11:00:45]

Wow this DefiniteSizeStrategy::minContentForChild vs
IndefiniteSizeStrategy::minContentForChild
seem very similar to me.
Cannot they share some logic?

Also before this patch we only have one minContentForChild().

[svillar, 2017/01/30 11:28:29]

Yes they're pretty similar, we could refactor part of the logic in the parent
class if you think it's better.
That's the whole point of having strategies, to separate the code for indefinite
and definite size computations.

+  GridTrackSizingDirection childInlineDirection =
+      flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
+  if (direction() == childInlineDirection) {
+    // If |child| has a relative logical width, we shouldn't let it override its
+    // intrinsic width, which is what we are interested in here. Thus we need to
+    // set the inline-axis override size to -1 (no possible resolution).
+    if (shouldClearOverrideContainingBlockContentSizeForChild(child,
+                                                              ForColumns)) {
+      setOverrideContainingBlockContentSizeForChild(child, childInlineDirection,
+                                                    LayoutUnit(-1));
+    }
+
+    LayoutUnit marginLogicalWidth =
+        child.needsLayout() ? computeMarginLogicalSizeForChild(
+                                  InlineDirection, layoutGrid(), child)
+                            : child.marginLogicalWidth();
+    return child.minPreferredLogicalWidth() + marginLogicalWidth;
+  }
+
+  if (updateOverrideContainingBlockContentSizeForChild(child,
+                                                       childInlineDirection))
+    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+  return logicalHeightForChild(child);
+}
+
+DISABLE_CFI_PERF
+LayoutUnit DefiniteSizeStrategy::maxContentForChild(LayoutBox& child) const {
+  GridTrackSizingDirection childInlineDirection =
+      flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
+  if (direction() == childInlineDirection) {
+    // If |child| has a relative logical width, we shouldn't let it override its
+    // intrinsic width, which is what we are interested in here. Thus we need to
+    // set the inline-axis override size to -1 (no possible resolution).
+    if (shouldClearOverrideContainingBlockContentSizeForChild(child,
+                                                              ForColumns)) {
+      setOverrideContainingBlockContentSizeForChild(child, childInlineDirection,
+                                                    LayoutUnit(-1));
+    }
+
+    // FIXME: It's unclear if we should return the intrinsic width or the
+    // preferred width.
+    // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
+    LayoutUnit marginLogicalWidth =
+        child.needsLayout() ? computeMarginLogicalSizeForChild(
+                                  InlineDirection, layoutGrid(), child)
+                            : child.marginLogicalWidth();
+    return child.maxPreferredLogicalWidth() + marginLogicalWidth;
+  }
+
+  if (updateOverrideContainingBlockContentSizeForChild(child,
+                                                       childInlineDirection))
+    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+  return logicalHeightForChild(child);
+}
+
+LayoutUnit DefiniteSizeStrategy::minSizeForChild(LayoutBox& child) {
+  GridTrackSizingDirection childInlineDirection =
+      flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
+  bool isRowAxis = direction() == childInlineDirection;
+  const Length& childSize = isRowAxis ? child.styleRef().logicalWidth()
+                                      : child.styleRef().logicalHeight();
+  const Length& childMinSize = isRowAxis ? child.styleRef().logicalMinWidth()
+                                         : child.styleRef().logicalMinHeight();
+  bool overflowIsVisible =
+      isRowAxis
+          ? child.styleRef().overflowInlineDirection() == EOverflow::Visible
+          : child.styleRef().overflowBlockDirection() == EOverflow::Visible;
+  if (!childSize.isAuto() || (childMinSize.isAuto() && overflowIsVisible))
+    return minContentForChild(child);
+
+  bool overrideSizeHasChanged =
+      updateOverrideContainingBlockContentSizeForChild(child,
+                                                       childInlineDirection);
+  if (isRowAxis) {
+    LayoutUnit marginLogicalWidth =
+        computeMarginLogicalSizeForChild(InlineDirection, layoutGrid(), child);
+    return child.computeLogicalWidthUsing(
+               MinSize, childMinSize,
+               overrideContainingBlockContentSizeForChild(child,
+                                                          childInlineDirection),
+               layoutGrid()) +
+           marginLogicalWidth;
+  }
+
+  if (overrideSizeHasChanged)
+    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+  child.layoutIfNeeded();
+  return child.computeLogicalHeightUsing(MinSize, childMinSize,
+                                         child.intrinsicLogicalHeight()) +
+         child.marginLogicalHeight() + child.scrollbarLogicalHeight();
+}
+
+void DefiniteSizeStrategy::maximizeTracks(Vector<GridTrack>& tracks,
+                                          LayoutUnit& freeSpace) {
+  size_t tracksSize = tracks.size();
+  Vector<GridTrack*> tracksForDistribution(tracksSize);
+  for (size_t i = 0; i < tracksSize; ++i) {
+    tracksForDistribution[i] = tracks.data() + i;
+    tracksForDistribution[i]->setPlannedSize(
+        tracksForDistribution[i]->baseSize());
+  }
+
+  distributeSpaceToTracks(tracksForDistribution, freeSpace);
+
+  for (auto* track : tracksForDistribution)
+    track->setBaseSize(track->plannedSize());
+}
+
+double DefiniteSizeStrategy::findUsedFlexFraction(
+    Vector<size_t>& flexibleSizedTracksIndex,
+    GridTrackSizingDirection direction,
+    LayoutUnit freeSpace) const {
+  GridSpan allTracksSpan = GridSpan::translatedDefiniteGridSpan(
+      0, m_algorithm.tracks(direction).size());
+  return findFrUnitSize(allTracksSpan, freeSpace);
+}
+
+DISABLE_CFI_PERF
+LayoutUnit IndefiniteSizeStrategy::minContentForChild(LayoutBox& child) {
+  GridTrackSizingDirection childInlineDirection =
+      flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
+  if (direction() == childInlineDirection) {
+    // If |child| has a relative logical width, we shouldn't let it override its
+    // intrinsic width, which is what we are interested in here. Thus we need to
+    // set the inline-axis override size to -1 (no possible resolution).
+    if (shouldClearOverrideContainingBlockContentSizeForChild(child,
+                                                              ForColumns)) {
+      setOverrideContainingBlockContentSizeForChild(child, childInlineDirection,
+                                                    LayoutUnit(-1));
+    }
+
+    // FIXME: It's unclear if we should return the intrinsic width or the
+    // preferred width.
+    // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
+    LayoutUnit marginLogicalWidth =
+        child.needsLayout() ? computeMarginLogicalSizeForChild(
+                                  InlineDirection, layoutGrid(), child)
+                            : child.marginLogicalWidth();
+    return child.minPreferredLogicalWidth() + marginLogicalWidth;
+  }
+
+  // All orthogonal flow boxes were already laid out during an early layout
+  // phase performed in FrameView::performLayout.
+  // It's true that grid track sizing was not completed at that time and it may
+  // afffect the final height of a grid item, but since it's forbidden to
+  // perform a layout during intrinsic width computation, we have to use that
+  // computed height for now.
+  if (direction() == ForColumns) {
+    // TODO(ALGO)
+    // DCHECK(isOrthogonalChild(child));
+    return child.logicalHeight() + child.marginLogicalHeight();
+  }
+
+  if (updateOverrideContainingBlockContentSizeForChild(child,
+                                                       childInlineDirection))
+    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+  return logicalHeightForChild(child);
+}
+
+DISABLE_CFI_PERF
+LayoutUnit IndefiniteSizeStrategy::maxContentForChild(LayoutBox& child) const {
+  GridTrackSizingDirection childInlineDirection =
+      flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
+  if (direction() == childInlineDirection) {
+    // If |child| has a relative logical width, we shouldn't let it override its
+    // intrinsic width, which is what we are interested in here. Thus we need to
+    // set the inline-axis override size to -1 (no possible resolution).
+    if (shouldClearOverrideContainingBlockContentSizeForChild(child,
+                                                              ForColumns)) {
+      setOverrideContainingBlockContentSizeForChild(child, childInlineDirection,
+                                                    LayoutUnit(-1));
+    }
+
+    // FIXME: It's unclear if we should return the intrinsic width or the
+    // preferred width.
+    // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
+    LayoutUnit marginLogicalWidth =
+        child.needsLayout() ? computeMarginLogicalSizeForChild(
+                                  InlineDirection, layoutGrid(), child)
+                            : child.marginLogicalWidth();
+    return child.maxPreferredLogicalWidth() + marginLogicalWidth;
+  }
+
+  // All orthogonal flow boxes were already laid out during an early layout
+  // phase performed in FrameView::performLayout.
+  // It's true that grid track sizing was not completed at that time and it may
+  // afffect the final height of a grid item, but since it's forbidden to
+  // perform a layout during intrinsic width computation, we have to use that
+  // computed height for now.
+  if (direction() == ForColumns) {
+    // TODO(ALGO)

[Manuel Rego, 2017/01/30 11:00:45]

Again a weird TODO here.

+    // DCHECK(isOrthogonalChild(child));
+    return child.logicalHeight() + child.marginLogicalHeight();
+  }
+
+  if (updateOverrideContainingBlockContentSizeForChild(child,
+                                                       childInlineDirection))
+    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+  return logicalHeightForChild(child);
+}
+
+LayoutUnit IndefiniteSizeStrategy::minSizeForChild(LayoutBox& child) {
+  GridTrackSizingDirection childInlineDirection =
+      flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
+  bool isRowAxis = direction() == childInlineDirection;
+  const Length& childSize = isRowAxis ? child.styleRef().logicalWidth()
+                                      : child.styleRef().logicalHeight();
+  const Length& childMinSize = isRowAxis ? child.styleRef().logicalMinWidth()
+                                         : child.styleRef().logicalMinHeight();
+  bool overflowIsVisible =
+      isRowAxis
+          ? child.styleRef().overflowInlineDirection() == EOverflow::Visible
+          : child.styleRef().overflowBlockDirection() == EOverflow::Visible;
+  if (!childSize.isAuto() || (childMinSize.isAuto() && overflowIsVisible))
+    return minContentForChild(child);
+
+  bool overrideSizeHasChanged =
+      updateOverrideContainingBlockContentSizeForChild(child,
+                                                       childInlineDirection);
+  if (isRowAxis) {
+    // TODO(ALGO): marginIntrinsicLogicalWidthForChild is protected for

[Manuel Rego, 2017/01/30 11:00:45]

You shouldn't use "ALGO", use "svillar" instead.
Also missing dot at the end of comment.

[svillar, 2017/01/30 11:28:29]

Yeah, I used those for tracking while refactoring the code. I'll remove them
all.

+    // LayoutObjects
+    LayoutUnit marginLogicalWidth = LayoutUnit();
+    // layoutGrid()->marginIntrinsicLogicalWidthForChild(child);
+    return child.computeLogicalWidthUsing(
+               MinSize, childMinSize,
+               overrideContainingBlockContentSizeForChild(child,
+                                                          childInlineDirection),
+               layoutGrid()) +
+           marginLogicalWidth;
+  }
+
+  if (overrideSizeHasChanged && direction() != ForColumns)
+    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+  child.layoutIfNeeded();
+  return child.computeLogicalHeightUsing(MinSize, childMinSize,
+                                         child.intrinsicLogicalHeight()) +
+         child.marginLogicalHeight() + child.scrollbarLogicalHeight();
+}
+
+void IndefiniteSizeStrategy::maximizeTracks(Vector<GridTrack>& tracks,
+                                            LayoutUnit&) {
+  for (auto& track : tracks)
+    track.setBaseSize(track.growthLimit());
+}
+
+static inline double normalizedFlexFraction(const GridTrack& track,
+                                            double flexFactor) {
+  return track.baseSize() / std::max<double>(1, flexFactor);
+}
+
+double IndefiniteSizeStrategy::findUsedFlexFraction(
+    Vector<size_t>& flexibleSizedTracksIndex,
+    GridTrackSizingDirection direction,
+    LayoutUnit freeSpace) const {
+  auto allTracks = m_algorithm.tracks(direction);
+
+  double flexFraction = 0;
+  for (const auto& trackIndex : flexibleSizedTracksIndex) {
+    // FIXME(svillar): we pass TrackSizing to gridTrackSize() because it does
+    // not really matter as we know
+    // the track is a flex sized track. It'd be nice not to have to do that.
+    flexFraction = std::max(
+        flexFraction,
+        normalizedFlexFraction(
+            allTracks[trackIndex],
+            m_algorithm.gridTrackSize(direction, trackIndex, TrackSizing)
+                .maxTrackBreadth()
+                .flex()));
+  }
+
+  const Grid& grid = m_algorithm.grid();
+  if (!grid.hasGridItems())
+    return flexFraction;
+
+  for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
+    GridIterator iterator(grid, direction, flexibleSizedTracksIndex[i]);
+    while (LayoutBox* gridItem = iterator.nextGridItem()) {
+      const GridSpan& span = grid.gridItemSpan(*gridItem, direction);
+
+      // Do not include already processed items.
+      if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
+        continue;
+
+      flexFraction = std::max(
+          flexFraction, findFrUnitSize(span, maxContentForChild(*gridItem)));
+    }
+  }
+
+  return flexFraction;
+}
+
+bool IndefiniteSizeStrategy::recomputeUsedFlexFractionIfNeeded(
+    Vector<size_t>& flexibleSizedTracksIndex,
+    double& flexFraction,
+    Vector<LayoutUnit>& increments,
+    LayoutUnit& totalGrowth) const {
+  if (direction() == ForColumns)
+    return false;
+
+  const LayoutGrid* layoutGrid = this->layoutGrid();
+  LayoutUnit minSize = layoutGrid->computeContentLogicalHeight(
+      MinSize, layoutGrid->styleRef().logicalMinHeight(), LayoutUnit(-1));
+  LayoutUnit maxSize = layoutGrid->computeContentLogicalHeight(
+      MaxSize, layoutGrid->styleRef().logicalMaxHeight(), LayoutUnit(-1));
+
+  // Redo the flex fraction computation using min|max-height as definite
+  // available space in case the total height is smaller than min-height or
+  // larger than max-height.
+  LayoutUnit rowsSize = totalGrowth + computeTrackBasedSize();
+  bool checkMinSize = minSize && rowsSize < minSize;
+  bool checkMaxSize = maxSize != -1 && rowsSize > maxSize;
+  if (!checkMinSize && !checkMaxSize)
+    return false;
+
+  LayoutUnit freeSpace = checkMaxSize ? maxSize : LayoutUnit(-1);
+  const Grid& grid = m_algorithm.grid();
+  freeSpace = std::max(freeSpace, minSize) -
+              layoutGrid->guttersSize(grid, ForRows, 0, grid.numTracks(ForRows),
+                                      IntrinsicSizeComputation);
+
+  size_t numberOfTracks = m_algorithm.tracks(direction()).size();
+  flexFraction = findFrUnitSize(
+      GridSpan::translatedDefiniteGridSpan(0, numberOfTracks), freeSpace);
+  return true;
+}
+
+// The GridTrackSizingAlgorithm
+//
+Vector<GridTrack>& GridTrackSizingAlgorithm::tracks(
+    GridTrackSizingDirection direction) {
+  return direction == ForColumns ? m_columns : m_rows;
+}
+
+const Vector<GridTrack>& GridTrackSizingAlgorithm::tracks(
+    GridTrackSizingDirection direction) const {
+  return direction == ForColumns ? m_columns : m_rows;
+}
+
+void GridTrackSizingAlgorithm::setup(GridTrackSizingDirection direction,
+                                     size_t numTracks,
+                                     SizingOperation sizingOperation,
+                                     LayoutUnit availableSpace,
+                                     LayoutUnit freeSpace) {
+  DCHECK(m_needsSetup);
+  m_direction = direction;
+  m_availableSpace = availableSpace;
+
+  m_sizingOperation = sizingOperation;
+  switch (m_sizingOperation) {
+    case IntrinsicSizeComputation:
+      m_strategy = WTF::makeUnique<IndefiniteSizeStrategy>(*this);
+      break;
+    case TrackSizing:
+      m_strategy = WTF::makeUnique<DefiniteSizeStrategy>(*this);
+      break;
+  }
+
+  m_contentSizedTracksIndex.shrink(0);
+  m_flexibleSizedTracksIndex.shrink(0);
+
+  this->freeSpace(direction) = freeSpace;
+  tracks(direction).resize(numTracks);
+
+  m_needsSetup = false;
+}
+
+GridTrackSize GridTrackSizingAlgorithm::rawGridTrackSize(
+    GridTrackSizingDirection direction,
+    size_t translatedIndex) const {
+  bool isRowAxis = direction == ForColumns;
+  const Vector<GridTrackSize>& trackStyles =
+      isRowAxis ? m_layoutGrid->styleRef().gridTemplateColumns()
+                : m_layoutGrid->styleRef().gridTemplateRows();
+  const Vector<GridTrackSize>& autoRepeatTrackStyles =
+      isRowAxis ? m_layoutGrid->styleRef().gridAutoRepeatColumns()
+                : m_layoutGrid->styleRef().gridAutoRepeatRows();
+  const Vector<GridTrackSize>& autoTrackStyles =
+      isRowAxis ? m_layoutGrid->styleRef().gridAutoColumns()
+                : m_layoutGrid->styleRef().gridAutoRows();
+  size_t insertionPoint =
+      isRowAxis ? m_layoutGrid->styleRef().gridAutoRepeatColumnsInsertionPoint()
+                : m_layoutGrid->styleRef().gridAutoRepeatRowsInsertionPoint();
+  size_t autoRepeatTracksCount = m_grid.autoRepeatTracks(direction);
+
+  // We should not use GridPositionsResolver::explicitGridXXXCount() for this
+  // because the explicit grid might be larger than the number of tracks in
+  // grid-template-rows|columns (if grid-template-areas is specified for
+  // example).
+  size_t explicitTracksCount = trackStyles.size() + autoRepeatTracksCount;
+
+  int untranslatedIndexAsInt =
+      translatedIndex + m_grid.smallestTrackStart(direction);
+  size_t autoTrackStylesSize = autoTrackStyles.size();
+  if (untranslatedIndexAsInt < 0) {
+    int index = untranslatedIndexAsInt % static_cast<int>(autoTrackStylesSize);
+    // We need to traspose the index because the first negative implicit line
+    // will get the last defined auto track and so on.
+    index += index ? autoTrackStylesSize : 0;
+    return autoTrackStyles[index];
+  }
+
+  size_t untranslatedIndex = static_cast<size_t>(untranslatedIndexAsInt);
+  if (untranslatedIndex >= explicitTracksCount) {
+    return autoTrackStyles[(untranslatedIndex - explicitTracksCount) %
+                           autoTrackStylesSize];
+  }
+
+  if (LIKELY(!autoRepeatTracksCount) || untranslatedIndex < insertionPoint)
+    return trackStyles[untranslatedIndex];
+
+  if (untranslatedIndex < (insertionPoint + autoRepeatTracksCount)) {
+    size_t autoRepeatLocalIndex = untranslatedIndexAsInt - insertionPoint;
+    return autoRepeatTrackStyles[autoRepeatLocalIndex %
+                                 autoRepeatTrackStyles.size()];
+  }
+
+  return trackStyles[untranslatedIndex - autoRepeatTracksCount];
+}
+
+GridTrackSize GridTrackSizingAlgorithm::gridTrackSize(
+    GridTrackSizingDirection direction,
+    size_t translatedIndex) const {
+  return gridTrackSize(direction, translatedIndex, m_sizingOperation);
+}
+
+GridTrackSize GridTrackSizingAlgorithm::gridTrackSize(
+    GridTrackSizingDirection direction,
+    size_t translatedIndex,
+    SizingOperation sizingOperation) const {
+  // Collapse empty auto repeat tracks if auto-fit.
+  if (m_grid.hasAutoRepeatEmptyTracks(direction) &&
+      m_grid.isEmptyAutoRepeatTrack(direction, translatedIndex))
+    return {Length(Fixed), LengthTrackSizing};
+
+  const GridTrackSize& trackSize = rawGridTrackSize(direction, translatedIndex);
+  if (trackSize.isFitContent())
+    return trackSize;
+
+  GridLength minTrackBreadth = trackSize.minTrackBreadth();
+  GridLength maxTrackBreadth = trackSize.maxTrackBreadth();
+  // If the logical width/height of the grid container is indefinite, percentage
+  // values are treated as <auto>.
+  if (minTrackBreadth.hasPercentage() || maxTrackBreadth.hasPercentage()) {
+    // For the inline axis this only happens when we're computing the intrinsic
+    // sizes (AvailableSpaceIndefinite).
+    if ((sizingOperation == IntrinsicSizeComputation) ||
+        (direction == ForRows &&
+         !m_layoutGrid->cachedHasDefiniteLogicalHeight())) {
+      if (minTrackBreadth.hasPercentage())
+        minTrackBreadth = Length(Auto);
+      if (maxTrackBreadth.hasPercentage())
+        maxTrackBreadth = Length(Auto);
+    }
+  }
+
+  // Flex sizes are invalid as a min sizing function. However we still can have
+  // a flexible |minTrackBreadth| if the track had a flex size directly (e.g.
+  // "1fr"), the spec says that in this case it implies an automatic minimum.
+  if (minTrackBreadth.isFlex())
+    minTrackBreadth = Length(Auto);
+
+  return GridTrackSize(minTrackBreadth, maxTrackBreadth);
+}
+
+LayoutUnit GridTrackSizingAlgorithm::initialBaseSize(
+    const GridTrackSize& trackSize) const {
+  const GridLength& gridLength = trackSize.minTrackBreadth();
+  if (gridLength.isFlex())
+    return LayoutUnit();
+
+  const Length& trackLength = gridLength.length();
+  if (trackLength.isSpecified())
+    return valueForLength(trackLength, m_availableSpace.clampNegativeToZero());
+
+  DCHECK(trackLength.isMinContent() || trackLength.isAuto() ||
+         trackLength.isMaxContent());
+  return LayoutUnit();
+}
+
+LayoutUnit GridTrackSizingAlgorithm::initialGrowthLimit(
+    const GridTrackSize& trackSize,
+    LayoutUnit baseSize) const {
+  const GridLength& gridLength = trackSize.maxTrackBreadth();
+  if (gridLength.isFlex())
+    return baseSize;
+
+  const Length& trackLength = gridLength.length();
+  if (trackLength.isSpecified())
+    return valueForLength(trackLength, m_availableSpace.clampNegativeToZero());
+
+  DCHECK(trackLength.isMinContent() || trackLength.isAuto() ||
+         trackLength.isMaxContent());
+  return LayoutUnit(infinity);
+}
+
+void GridTrackSizingAlgorithm::initializeTrackSizes() {
+  DCHECK(m_contentSizedTracksIndex.isEmpty());
+  DCHECK(m_flexibleSizedTracksIndex.isEmpty());
+  Vector<GridTrack>& trackList = tracks(m_direction);
+  bool hasDefiniteFreeSpace = m_sizingOperation == TrackSizing;
+  size_t numTracks = trackList.size();
+  for (size_t i = 0; i < numTracks; ++i) {
+    GridTrackSize trackSize = gridTrackSize(m_direction, i);
+    GridTrack& track = trackList[i];
+    track.setBaseSize(initialBaseSize(trackSize));
+    track.setGrowthLimit(initialGrowthLimit(trackSize, track.baseSize()));
+    track.setInfinitelyGrowable(false);
+
+    if (trackSize.isFitContent()) {
+      GridLength gridLength = trackSize.fitContentTrackBreadth();
+      if (!gridLength.hasPercentage() || hasDefiniteFreeSpace) {
+        track.setGrowthLimitCap(valueForLength(
+            gridLength.length(), m_availableSpace.clampNegativeToZero()));
+      }
+    }
+
+    if (trackSize.isContentSized())
+      m_contentSizedTracksIndex.append(i);
+    if (trackSize.maxTrackBreadth().isFlex())
+      m_flexibleSizedTracksIndex.append(i);
+  }
+}
+
+void GridTrackSizingAlgorithm::sizeTrackToFitNonSpanningItem(
+    const GridSpan& span,
+    LayoutBox& gridItem,
+    GridTrack& track) {
+  const size_t trackPosition = span.startLine();
+  GridTrackSize trackSize = gridTrackSize(m_direction, trackPosition);
+
+  if (trackSize.hasMinContentMinTrackBreadth()) {
+    track.setBaseSize(
+        std::max(track.baseSize(), m_strategy->minContentForChild(gridItem)));
+  } else if (trackSize.hasMaxContentMinTrackBreadth()) {
+    track.setBaseSize(
+        std::max(track.baseSize(), m_strategy->maxContentForChild(gridItem)));
+  } else if (trackSize.hasAutoMinTrackBreadth()) {
+    track.setBaseSize(
+        std::max(track.baseSize(), m_strategy->minSizeForChild(gridItem)));
+  }
+
+  if (trackSize.hasMinContentMaxTrackBreadth()) {
+    track.setGrowthLimit(std::max(track.growthLimit(),
+                                  m_strategy->minContentForChild(gridItem)));
+  } else if (trackSize.hasMaxContentOrAutoMaxTrackBreadth()) {
+    LayoutUnit growthLimit = m_strategy->maxContentForChild(gridItem);
+    if (trackSize.isFitContent()) {
+      growthLimit =
+          std::min(growthLimit,
+                   valueForLength(trackSize.fitContentTrackBreadth().length(),
+                                  m_availableSpace));
+    }
+    track.setGrowthLimit(std::max(track.growthLimit(), growthLimit));
+  }
+}
+
+bool GridTrackSizingAlgorithm::spanningItemCrossesFlexibleSizedTracks(
+    const GridSpan& span) const {
+  for (const auto& trackPosition : span) {
+    const GridTrackSize& trackSize = gridTrackSize(m_direction, trackPosition);
+    if (trackSize.minTrackBreadth().isFlex() ||
+        trackSize.maxTrackBreadth().isFlex())
+      return true;
+  }
+
+  return false;
+}
+
+// We're basically using a class instead of a std::pair because of accessing
+// gridItem() or getGridSpan() is much more self-explanatory that using .first
+// or .second members in the pair. Having a std::pair<LayoutBox*, size_t>
+// does not work either because we still need the GridSpan so we'd have to add
+// an extra hash lookup for each item at the beginning of
+// LayoutGrid::increaseSizesToAccommodateSpanningItems().
+class GridItemWithSpan {
+ public:
+  GridItemWithSpan(LayoutBox& gridItem, const GridSpan& gridSpan)
+      : m_gridItem(&gridItem), m_gridSpan(gridSpan) {}
+
+  LayoutBox& gridItem() const { return *m_gridItem; }
+  GridSpan getGridSpan() const { return m_gridSpan; }
+
+  bool operator<(const GridItemWithSpan other) const {
+    return m_gridSpan.integerSpan() < other.m_gridSpan.integerSpan();
+  }
+
+ private:
+  LayoutBox* m_gridItem;
+  GridSpan m_gridSpan;
+};
+
+struct GridItemsSpanGroupRange {
+  Vector<GridItemWithSpan>::iterator rangeStart;
+  Vector<GridItemWithSpan>::iterator rangeEnd;
+};
+
+enum TrackSizeRestriction {
+  AllowInfinity,
+  ForbidInfinity,
+};
+
+static LayoutUnit trackSizeForTrackSizeComputationPhase(
+    TrackSizeComputationPhase phase,
+    const GridTrack& track,
+    TrackSizeRestriction restriction) {
+  switch (phase) {
+    case ResolveIntrinsicMinimums:
+    case ResolveContentBasedMinimums:
+    case ResolveMaxContentMinimums:
+    case MaximizeTracks:
+      return track.baseSize();
+    case ResolveIntrinsicMaximums:
+    case ResolveMaxContentMaximums:
+      const LayoutUnit& growthLimit = track.growthLimit();
+      if (restriction == AllowInfinity)
+        return growthLimit;
+      return growthLimit == infinity ? track.baseSize() : growthLimit;
+  }
+
+  NOTREACHED();
+  return track.baseSize();
+}
+
+static bool shouldProcessTrackForTrackSizeComputationPhase(
+    TrackSizeComputationPhase phase,
+    const GridTrackSize& trackSize) {
+  switch (phase) {
+    case ResolveIntrinsicMinimums:
+      return trackSize.hasIntrinsicMinTrackBreadth();
+    case ResolveContentBasedMinimums:
+      return trackSize.hasMinOrMaxContentMinTrackBreadth();
+    case ResolveMaxContentMinimums:
+      return trackSize.hasMaxContentMinTrackBreadth();
+    case ResolveIntrinsicMaximums:
+      return trackSize.hasIntrinsicMaxTrackBreadth();
+    case ResolveMaxContentMaximums:
+      return trackSize.hasMaxContentOrAutoMaxTrackBreadth();
+    case MaximizeTracks:
+      NOTREACHED();
+      return false;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+static bool trackShouldGrowBeyondGrowthLimitsForTrackSizeComputationPhase(
+    TrackSizeComputationPhase phase,
+    const GridTrackSize& trackSize) {
+  switch (phase) {
+    case ResolveIntrinsicMinimums:
+    case ResolveContentBasedMinimums:
+      return trackSize
+          .hasAutoOrMinContentMinTrackBreadthAndIntrinsicMaxTrackBreadth();
+    case ResolveMaxContentMinimums:
+      return trackSize
+          .hasMaxContentMinTrackBreadthAndMaxContentMaxTrackBreadth();
+    case ResolveIntrinsicMaximums:
+    case ResolveMaxContentMaximums:
+      return true;
+    case MaximizeTracks:
+      NOTREACHED();
+      return false;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+static void markAsInfinitelyGrowableForTrackSizeComputationPhase(
+    TrackSizeComputationPhase phase,
+    GridTrack& track) {
+  switch (phase) {
+    case ResolveIntrinsicMinimums:
+    case ResolveContentBasedMinimums:
+    case ResolveMaxContentMinimums:
+      return;
+    case ResolveIntrinsicMaximums:
+      if (trackSizeForTrackSizeComputationPhase(phase, track, AllowInfinity) ==
+              infinity &&
+          track.plannedSize() != infinity)
+        track.setInfinitelyGrowable(true);
+      return;
+    case ResolveMaxContentMaximums:
+      if (track.infinitelyGrowable())
+        track.setInfinitelyGrowable(false);
+      return;
+    case MaximizeTracks:
+      NOTREACHED();
+      return;
+  }
+
+  NOTREACHED();
+}
+
+static void updateTrackSizeForTrackSizeComputationPhase(
+    TrackSizeComputationPhase phase,
+    GridTrack& track) {
+  switch (phase) {
+    case ResolveIntrinsicMinimums:
+    case ResolveContentBasedMinimums:
+    case ResolveMaxContentMinimums:
+      track.setBaseSize(track.plannedSize());
+      return;
+    case ResolveIntrinsicMaximums:
+    case ResolveMaxContentMaximums:
+      track.setGrowthLimit(track.plannedSize());
+      return;
+    case MaximizeTracks:
+      NOTREACHED();
+      return;
+  }
+
+  NOTREACHED();
+}
+
+LayoutUnit GridTrackSizingAlgorithm::itemSizeForTrackSizeComputationPhase(
+    TrackSizeComputationPhase phase,
+    LayoutBox& gridItem) const {
+  switch (phase) {
+    case ResolveIntrinsicMinimums:
+    case ResolveIntrinsicMaximums:
+      return m_strategy->minSizeForChild(gridItem);
+    case ResolveContentBasedMinimums:
+      return m_strategy->minContentForChild(gridItem);
+    case ResolveMaxContentMinimums:
+    case ResolveMaxContentMaximums:
+      return m_strategy->maxContentForChild(gridItem);
+    case MaximizeTracks:
+      NOTREACHED();
+      return LayoutUnit();
+  }
+
+  NOTREACHED();
+  return LayoutUnit();
+}
+
+static bool sortByGridTrackGrowthPotential(const GridTrack* track1,
+                                           const GridTrack* track2) {
+  // This check ensures that we respect the irreflexivity property of the strict
+  // weak ordering required by std::sort(forall x: NOT x < x).
+  bool track1HasInfiniteGrowthPotentialWithoutCap =
+      track1->infiniteGrowthPotential() && !track1->growthLimitCap();
+  bool track2HasInfiniteGrowthPotentialWithoutCap =
+      track2->infiniteGrowthPotential() && !track2->growthLimitCap();
+
+  if (track1HasInfiniteGrowthPotentialWithoutCap &&
+      track2HasInfiniteGrowthPotentialWithoutCap)
+    return false;
+
+  if (track1HasInfiniteGrowthPotentialWithoutCap ||
+      track2HasInfiniteGrowthPotentialWithoutCap)
+    return track2HasInfiniteGrowthPotentialWithoutCap;
+
+  LayoutUnit track1Limit =
+      track1->growthLimitCap().value_or(track1->growthLimit());
+  LayoutUnit track2Limit =
+      track2->growthLimitCap().value_or(track2->growthLimit());
+  return (track1Limit - track1->baseSize()) <
+         (track2Limit - track2->baseSize());
+}
+
+static void clampGrowthShareIfNeeded(TrackSizeComputationPhase phase,
+                                     const GridTrack& track,
+                                     LayoutUnit& growthShare) {
+  if (phase != ResolveMaxContentMaximums || !track.growthLimitCap())
+    return;
+
+  LayoutUnit distanceToCap =
+      track.growthLimitCap().value() - track.sizeDuringDistribution();
+  if (distanceToCap <= 0)
+    return;
+
+  growthShare = std::min(growthShare, distanceToCap);
+}
+
+template <TrackSizeComputationPhase phase>
+void GridTrackSizingAlgorithm::distributeSpaceToTracks(
+    Vector<GridTrack*>& tracks,
+    Vector<GridTrack*>* growBeyondGrowthLimitsTracks,
+    LayoutUnit& availableLogicalSpace) const {
+  DCHECK_GE(availableLogicalSpace, 0);
+
+  for (auto* track : tracks) {
+    track->setSizeDuringDistribution(
+        trackSizeForTrackSizeComputationPhase(phase, *track, ForbidInfinity));
+  }
+
+  if (availableLogicalSpace > 0) {
+    std::sort(tracks.begin(), tracks.end(), sortByGridTrackGrowthPotential);
+
+    size_t tracksSize = tracks.size();
+    for (size_t i = 0; i < tracksSize; ++i) {
+      GridTrack& track = *tracks[i];
+      LayoutUnit availableLogicalSpaceShare =
+          availableLogicalSpace / (tracksSize - i);
+      const LayoutUnit& trackBreadth =
+          trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
+      LayoutUnit growthShare =
+          track.infiniteGrowthPotential()
+              ? availableLogicalSpaceShare
+              : std::min(availableLogicalSpaceShare,
+                         track.growthLimit() - trackBreadth);
+      clampGrowthShareIfNeeded(phase, track, growthShare);
+      DCHECK_GE(growthShare, 0) << "We must never shrink any grid track or "
+                                   "else we can't guarantee we abide by our "
+                                   "min-sizing function.";
+      track.growSizeDuringDistribution(growthShare);
+      availableLogicalSpace -= growthShare;
+    }
+  }
+
+  if (availableLogicalSpace > 0 && growBeyondGrowthLimitsTracks) {
+    // We need to sort them because there might be tracks with growth limit caps
+    // (like the ones with fit-content()) which cannot indefinitely grow over
+    // the limits.
+    if (phase == ResolveMaxContentMaximums) {
+      std::sort(growBeyondGrowthLimitsTracks->begin(),
+                growBeyondGrowthLimitsTracks->end(),
+                sortByGridTrackGrowthPotential);
+    }
+
+    size_t tracksGrowingAboveMaxBreadthSize =
+        growBeyondGrowthLimitsTracks->size();
+    for (size_t i = 0; i < tracksGrowingAboveMaxBreadthSize; ++i) {
+      GridTrack* track = growBeyondGrowthLimitsTracks->at(i);
+      LayoutUnit growthShare =
+          availableLogicalSpace / (tracksGrowingAboveMaxBreadthSize - i);
+      clampGrowthShareIfNeeded(phase, *track, growthShare);
+      DCHECK_GE(growthShare, 0) << "We must never shrink any grid track or "
+                                   "else we can't guarantee we abide by our "
+                                   "min-sizing function.";
+      track->growSizeDuringDistribution(growthShare);
+      availableLogicalSpace -= growthShare;
+    }
+  }
+
+  for (auto* track : tracks) {
+    track->setPlannedSize(
+        track->plannedSize() == infinity
+            ? track->sizeDuringDistribution()
+            : std::max(track->plannedSize(), track->sizeDuringDistribution()));
+  }
+}
+
+template <TrackSizeComputationPhase phase>
+void GridTrackSizingAlgorithm::increaseSizesToAccommodateSpanningItems(
+    const GridItemsSpanGroupRange& gridItemsWithSpan) {
+  Vector<GridTrack>& allTracks = tracks(m_direction);
+  for (const auto& trackIndex : m_contentSizedTracksIndex) {
+    GridTrack& track = allTracks[trackIndex];
+    track.setPlannedSize(
+        trackSizeForTrackSizeComputationPhase(phase, track, AllowInfinity));
+  }
+
+  Vector<GridTrack*> growBeyondGrowthLimitsTracks;
+  Vector<GridTrack*> filteredTracks;
+  for (auto it = gridItemsWithSpan.rangeStart; it != gridItemsWithSpan.rangeEnd;
+       ++it) {
+    GridItemWithSpan& gridItemWithSpan = *it;
+    DCHECK_GT(gridItemWithSpan.getGridSpan().integerSpan(), 1u);
+    const GridSpan& itemSpan = gridItemWithSpan.getGridSpan();
+
+    growBeyondGrowthLimitsTracks.shrink(0);
+    filteredTracks.shrink(0);
+    LayoutUnit spanningTracksSize;
+    for (const auto& trackPosition : itemSpan) {
+      GridTrackSize trackSize = gridTrackSize(m_direction, trackPosition);
+      GridTrack& track = tracks(m_direction)[trackPosition];
+      spanningTracksSize +=
+          trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
+      if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
+        continue;
+
+      filteredTracks.append(&track);
+
+      if (trackShouldGrowBeyondGrowthLimitsForTrackSizeComputationPhase(
+              phase, trackSize))
+        growBeyondGrowthLimitsTracks.append(&track);
+    }
+
+    if (filteredTracks.isEmpty())
+      continue;
+
+    spanningTracksSize +=
+        m_layoutGrid->guttersSize(m_grid, m_direction, itemSpan.startLine(),
+                                  itemSpan.integerSpan(), m_sizingOperation);
+
+    LayoutUnit extraSpace = itemSizeForTrackSizeComputationPhase(
+                                phase, gridItemWithSpan.gridItem()) -
+                            spanningTracksSize;
+    extraSpace = extraSpace.clampNegativeToZero();
+    auto& tracksToGrowBeyondGrowthLimits =
+        growBeyondGrowthLimitsTracks.isEmpty() ? filteredTracks
+                                               : growBeyondGrowthLimitsTracks;
+    distributeSpaceToTracks<phase>(filteredTracks,
+                                   &tracksToGrowBeyondGrowthLimits, extraSpace);
+  }
+
+  for (const auto& trackIndex : m_contentSizedTracksIndex) {
+    GridTrack& track = allTracks[trackIndex];
+    markAsInfinitelyGrowableForTrackSizeComputationPhase(phase, track);
+    updateTrackSizeForTrackSizeComputationPhase(phase, track);
+  }
+}
+
+void GridTrackSizingAlgorithm::resolveIntrinsicTrackSizes() {
+  Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
+  if (m_grid.hasGridItems()) {
+    HashSet<LayoutBox*> itemsSet;
+    for (const auto& trackIndex : m_contentSizedTracksIndex) {
+      GridIterator iterator(m_grid, m_direction, trackIndex);
+      GridTrack& track = tracks(m_direction)[trackIndex];
+      while (LayoutBox* gridItem = iterator.nextGridItem()) {
+        if (itemsSet.add(gridItem).isNewEntry) {
+          const GridSpan& span = m_grid.gridItemSpan(*gridItem, m_direction);
+          if (span.integerSpan() == 1) {
+            sizeTrackToFitNonSpanningItem(span, *gridItem, track);
+          } else if (!spanningItemCrossesFlexibleSizedTracks(span)) {
+            itemsSortedByIncreasingSpan.append(
+                GridItemWithSpan(*gridItem, span));
+          }
+        }
+      }
+    }
+    std::sort(itemsSortedByIncreasingSpan.begin(),
+              itemsSortedByIncreasingSpan.end());
+  }
+
+  auto it = itemsSortedByIncreasingSpan.begin();
+  auto end = itemsSortedByIncreasingSpan.end();
+  while (it != end) {
+    GridItemsSpanGroupRange spanGroupRange = {it,
+                                              std::upper_bound(it, end, *it)};
+    increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMinimums>(
+        spanGroupRange);
+    increaseSizesToAccommodateSpanningItems<ResolveContentBasedMinimums>(
+        spanGroupRange);
+    increaseSizesToAccommodateSpanningItems<ResolveMaxContentMinimums>(
+        spanGroupRange);
+    increaseSizesToAccommodateSpanningItems<ResolveIntrinsicMaximums>(
+        spanGroupRange);
+    increaseSizesToAccommodateSpanningItems<ResolveMaxContentMaximums>(
+        spanGroupRange);
+    it = spanGroupRange.rangeEnd;
+  }
+
+  for (const auto& trackIndex : m_contentSizedTracksIndex) {
+    GridTrack& track = tracks(m_direction)[trackIndex];
+    if (track.growthLimit() == infinity)
+      track.setGrowthLimit(track.baseSize());
+  }
+}
+
+void GridTrackSizingAlgorithm::computeGridContainerIntrinsicSizes() {
+  m_minContentSize = m_maxContentSize = LayoutUnit();
+
+  Vector<GridTrack>& allTracks = tracks(m_direction);
+  for (auto& track : allTracks) {
+    DCHECK(!track.infiniteGrowthPotential());
+    m_minContentSize += track.baseSize();
+    m_maxContentSize += track.growthLimit();
+    // The growth limit caps must be cleared now in order to properly sort
+    // tracks by growth potential on an eventual "Maximize Tracks".
+    track.setGrowthLimitCap(WTF::nullopt);
+  }
+}
+
+LayoutUnit GridTrackSizingAlgorithm::computeTrackBasedSize() const {
+  LayoutUnit size;
+
+  const Vector<GridTrack>& allTracks = tracks(m_direction);
+  for (auto& track : allTracks)
+    size += track.baseSize();
+
+  size += m_layoutGrid->guttersSize(m_grid, m_direction, 0, allTracks.size(),
+                                    m_sizingOperation);
+
+  return size;
+}
+
+double GridTrackSizingAlgorithm::findFrUnitSize(
+    const GridSpan& tracksSpan,
+    LayoutUnit leftOverSpace) const {
+  if (leftOverSpace <= 0)
+    return 0;
+
+  const Vector<GridTrack>& allTracks = tracks(m_direction);
+  double flexFactorSum = 0;
+  Vector<size_t, 8> flexibleTracksIndexes;
+  for (const auto& trackIndex : tracksSpan) {
+    GridTrackSize trackSize = gridTrackSize(m_direction, trackIndex);
+    if (!trackSize.maxTrackBreadth().isFlex()) {
+      leftOverSpace -= allTracks[trackIndex].baseSize();
+    } else {
+      flexibleTracksIndexes.append(trackIndex);
+      flexFactorSum += trackSize.maxTrackBreadth().flex();
+    }
+  }
+
+  // The function is not called if we don't have <flex> grid tracks
+  DCHECK(!flexibleTracksIndexes.isEmpty());
+
+  return computeFlexFactorUnitSize(allTracks, flexFactorSum, leftOverSpace,
+                                   flexibleTracksIndexes);
+}
+
+double GridTrackSizingAlgorithm::computeFlexFactorUnitSize(
+    const Vector<GridTrack>& tracks,
+    double flexFactorSum,
+    LayoutUnit& leftOverSpace,
+    const Vector<size_t, 8>& flexibleTracksIndexes,
+    std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const {
+  // We want to avoid the effect of flex factors sum below 1 making the factor
+  // unit size to grow exponentially.
+  double hypotheticalFactorUnitSize =
+      leftOverSpace / std::max<double>(1, flexFactorSum);
+
+  // product of the hypothetical "flex factor unit" and any flexible track's
+  // "flex factor" must be grater than such track's "base size".
+  std::unique_ptr<TrackIndexSet> additionalTracksToTreatAsInflexible =
+      std::move(tracksToTreatAsInflexible);
+  bool validFlexFactorUnit = true;
+  for (auto index : flexibleTracksIndexes) {
+    if (additionalTracksToTreatAsInflexible &&
+        additionalTracksToTreatAsInflexible->contains(index))
+      continue;
+    LayoutUnit baseSize = tracks[index].baseSize();
+    double flexFactor =
+        gridTrackSize(m_direction, index).maxTrackBreadth().flex();
+    // treating all such tracks as inflexible.
+    if (baseSize > hypotheticalFactorUnitSize * flexFactor) {
+      leftOverSpace -= baseSize;
+      flexFactorSum -= flexFactor;
+      if (!additionalTracksToTreatAsInflexible)
+        additionalTracksToTreatAsInflexible = WTF::makeUnique<TrackIndexSet>();
+      additionalTracksToTreatAsInflexible->add(index);
+      validFlexFactorUnit = false;
+    }
+  }
+  if (!validFlexFactorUnit) {
+    return computeFlexFactorUnitSize(
+        tracks, flexFactorSum, leftOverSpace, flexibleTracksIndexes,
+        std::move(additionalTracksToTreatAsInflexible));
+  }
+  return hypotheticalFactorUnitSize;
+}
+
+void GridTrackSizingAlgorithm::computeFlexSizedTracksGrowth(
+    double flexFraction,
+    Vector<LayoutUnit>& increments,
+    LayoutUnit& totalGrowth) const {
+  size_t numFlexTracks = m_flexibleSizedTracksIndex.size();
+  DCHECK_EQ(increments.size(), numFlexTracks);
+  const Vector<GridTrack>& allTracks = tracks(m_direction);
+  for (size_t i = 0; i < numFlexTracks; ++i) {
+    size_t trackIndex = m_flexibleSizedTracksIndex[i];
+    auto trackSize = gridTrackSize(m_direction, trackIndex);
+    DCHECK(trackSize.maxTrackBreadth().isFlex());
+    LayoutUnit oldBaseSize = allTracks[trackIndex].baseSize();
+    LayoutUnit newBaseSize =
+        std::max(oldBaseSize,
+                 LayoutUnit(flexFraction * trackSize.maxTrackBreadth().flex()));
+    increments[i] = newBaseSize - oldBaseSize;
+    totalGrowth += increments[i];
+  }
+}
+
+void GridTrackSizingAlgorithm::stretchFlexibleTracks(LayoutUnit freeSpace) {
+  double flexFraction = m_strategy->findUsedFlexFraction(
+      m_flexibleSizedTracksIndex, m_direction, freeSpace);
+
+  LayoutUnit totalGrowth;
+  Vector<LayoutUnit> increments;
+  increments.grow(m_flexibleSizedTracksIndex.size());
+  computeFlexSizedTracksGrowth(flexFraction, increments, totalGrowth);
+
+  if (m_strategy->recomputeUsedFlexFractionIfNeeded(
+          m_flexibleSizedTracksIndex, flexFraction, increments, totalGrowth)) {
+    totalGrowth = LayoutUnit(0);
+    computeFlexSizedTracksGrowth(flexFraction, increments, totalGrowth);
+  }
+
+  size_t i = 0;
+  Vector<GridTrack>& allTracks = tracks(m_direction);
+  for (auto trackIndex : m_flexibleSizedTracksIndex) {
+    auto& track = allTracks[trackIndex];
+    if (LayoutUnit increment = increments[i++])
+      track.setBaseSize(track.baseSize() + increment);
+  }
+  this->freeSpace(m_direction) -= totalGrowth;
+  m_maxContentSize += totalGrowth;
+}
+
+void GridTrackSizingAlgorithm::advanceNextState() {
+  switch (m_sizingState) {
+    case ColumnSizingFirstIteration:
+      m_sizingState = RowSizingFirstIteration;
+      return;
+    case RowSizingFirstIteration:
+      m_sizingState = ColumnSizingSecondIteration;
+      return;
+    case ColumnSizingSecondIteration:
+      m_sizingState = RowSizingSecondIteration;
+      return;
+    case RowSizingSecondIteration:
+      m_sizingState = ColumnSizingFirstIteration;
+      return;
+  }
+  NOTREACHED();
+  m_sizingState = ColumnSizingFirstIteration;
+}
+
+bool GridTrackSizingAlgorithm::isValidTransition() const {
+  switch (m_sizingState) {
+    case ColumnSizingFirstIteration:
+    case ColumnSizingSecondIteration:
+      return m_direction == ForColumns;
+    case RowSizingFirstIteration:
+    case RowSizingSecondIteration:
+      return m_direction == ForRows;
+  }
+  NOTREACHED();
+  return false;
+}
+
+// Described in https://drafts.csswg.org/css-grid/#algo-track-sizing
+void GridTrackSizingAlgorithm::run() {
+  GridTrackSizingAlgorithmMachineState machineState(*this);
+
+  // Step 1.
+  LayoutUnit initialFreeSpace = freeSpace(m_direction);
+  initializeTrackSizes();
+
+  // Step 2.
+  if (!m_contentSizedTracksIndex.isEmpty())
+    resolveIntrinsicTrackSizes();
+
+  // This is not exactly a step of the track sizing algorithm, but we use the
+  // track sizes computed
+  // up to this moment (before maximization) to calculate the grid container
+  // intrinsic sizes.
+  computeGridContainerIntrinsicSizes();
+  freeSpace(m_direction) -= m_minContentSize;
+
+  if (m_sizingOperation == TrackSizing && freeSpace(m_direction) <= 0)
+    return;
+
+  // Step 3.
+  m_strategy->maximizeTracks(tracks(m_direction), freeSpace(m_direction));
+
+  if (m_flexibleSizedTracksIndex.isEmpty())
+    return;
+
+  // Step 4.
+  stretchFlexibleTracks(initialFreeSpace);
+}
+
+void GridTrackSizingAlgorithm::reset() {
+  m_sizingState = ColumnSizingFirstIteration;
+  m_columns.shrink(0);
+  m_rows.shrink(0);
+  m_contentSizedTracksIndex.shrink(0);
+  m_flexibleSizedTracksIndex.shrink(0);
+}
+
+#if DCHECK_IS_ON()
+bool GridTrackSizingAlgorithm::tracksAreWiderThanMinTrackBreadth() const {
+  const Vector<GridTrack>& allTracks = tracks(m_direction);
+  for (size_t i = 0; i < allTracks.size(); ++i) {
+    GridTrackSize trackSize = gridTrackSize(m_direction, i);
+    if (initialBaseSize(trackSize) > allTracks[i].baseSize())
+      return false;
+  }
+  return true;
+}
+#endif
+}