[css-grid] Use Optional to represent indefinite lengths

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

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/GridTrackSizingAlgorithm.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/Grid.h"
 #include "core/layout/LayoutGrid.h"
 #include "platform/LengthFunctions.h"
@@ skipping 70 matching lines @@
   IndefiniteSizeStrategy(GridTrackSizingAlgorithm& algorithm)
       : GridTrackSizingAlgorithmStrategy(algorithm) {}
 
  private:
   LayoutUnit minLogicalWidthForChild(LayoutBox&,
                                      Length childMinSize,
                                      GridTrackSizingDirection) const override;
   void layoutGridItemForMinSizeComputation(
       LayoutBox&,
       bool overrideSizeHasChanged) const override;
-  void maximizeTracks(Vector<GridTrack>&, LayoutUnit& freeSpace) override;
+  void maximizeTracks(Vector<GridTrack>&,
+                      Optional<LayoutUnit>& freeSpace) override;
   double findUsedFlexFraction(Vector<size_t>& flexibleSizedTracksIndex,
                               GridTrackSizingDirection,
-                              LayoutUnit freeSpace) const override;
+                              Optional<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 minLogicalWidthForChild(LayoutBox&,
                                      Length childMinSize,
                                      GridTrackSizingDirection) const override;
   void layoutGridItemForMinSizeComputation(
       LayoutBox&,
       bool overrideSizeHasChanged) const override;
-  void maximizeTracks(Vector<GridTrack>&, LayoutUnit& freeSpace) override;
+  void maximizeTracks(Vector<GridTrack>&,
+                      Optional<LayoutUnit>& freeSpace) override;
   double findUsedFlexFraction(Vector<size_t>& flexibleSizedTracksIndex,
                               GridTrackSizingDirection,
-                              LayoutUnit freeSpace) const override;
+                              Optional<LayoutUnit> freeSpace) const override;
   bool recomputeUsedFlexFractionIfNeeded(
       Vector<size_t>& flexibleSizedTracksIndex,
       double& flexFraction,
       Vector<LayoutUnit>& increments,
       LayoutUnit& totalGrowth) const override {
     return false;
   }
 };
 
 // TODO(svillar): Repeated in LayoutGrid.
@@ skipping 311 matching lines @@
 
 void DefiniteSizeStrategy::layoutGridItemForMinSizeComputation(
     LayoutBox& child,
     bool overrideSizeHasChanged) const {
   if (overrideSizeHasChanged)
     setGridItemNeedsLayout(child);
   child.layoutIfNeeded();
 }
 
 void DefiniteSizeStrategy::maximizeTracks(Vector<GridTrack>& tracks,
-                                          LayoutUnit& freeSpace) {
+                                          Optional<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);
+  DCHECK(freeSpace);
+  distributeSpaceToTracks(tracksForDistribution, freeSpace.value());
 
   for (auto* track : tracksForDistribution)
     track->setBaseSize(track->plannedSize());
 }
 
 double DefiniteSizeStrategy::findUsedFlexFraction(
     Vector<size_t>& flexibleSizedTracksIndex,
     GridTrackSizingDirection direction,
-    LayoutUnit freeSpace) const {
+    Optional<LayoutUnit> freeSpace) const {
   GridSpan allTracksSpan = GridSpan::translatedDefiniteGridSpan(
       0, m_algorithm.tracks(direction).size());
-  return findFrUnitSize(allTracksSpan, freeSpace);
+  DCHECK(freeSpace);
+  return findFrUnitSize(allTracksSpan, freeSpace.value());
 }
 
 LayoutUnit IndefiniteSizeStrategy::minLogicalWidthForChild(
     LayoutBox& child,
     Length childMinSize,
     GridTrackSizingDirection childInlineDirection) const {
   // TODO(svillar): we should use marginIntrinsicLogicalWidthForChild() instead
   // but it is protected for LayoutObjects. Apparently none of the current tests
   // fail, so we need a test case for this too.
   LayoutUnit marginLogicalWidth = LayoutUnit();
   return child.computeLogicalWidthUsing(
              MinSize, childMinSize, overrideContainingBlockContentSizeForChild(
                                         child, childInlineDirection),
              layoutGrid()) +
          marginLogicalWidth;
 }
 
 void IndefiniteSizeStrategy::layoutGridItemForMinSizeComputation(
     LayoutBox& child,
     bool overrideSizeHasChanged) const {
   if (overrideSizeHasChanged && direction() != ForColumns)
     setGridItemNeedsLayout(child);
   child.layoutIfNeeded();
 }
 
 void IndefiniteSizeStrategy::maximizeTracks(Vector<GridTrack>& tracks,
-                                            LayoutUnit&) {
+                                            Optional<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 {
+    Optional<LayoutUnit>) const {
   auto allTracks = m_algorithm.tracks(direction);
 
   double flexFraction = 0;
   for (const auto& trackIndex : flexibleSizedTracksIndex) {
     // TODO(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(
@@ skipping 52 matching lines @@
   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;
 }
 
-LayoutUnit& GridTrackSizingAlgorithm::freeSpace(
+Optional<LayoutUnit> GridTrackSizingAlgorithm::freeSpace(
     GridTrackSizingDirection direction) {
   return direction == ForRows ? m_freeSpaceRows : m_freeSpaceColumns;
 }
 
 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::setFreeSpace(GridTrackSizingDirection direction,
+                                            Optional<LayoutUnit> freeSpace) {
+  if (direction == ForColumns)
+    m_freeSpaceColumns = freeSpace;
+  else
+    m_freeSpaceRows = freeSpace;
+}
+
 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();
@@ skipping 86 matching lines @@
 }
 
 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());
+    return valueForLength(trackLength, m_availableSpace.value_or(LayoutUnit()));
 
   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());
+    return valueForLength(trackLength, m_availableSpace.value_or(LayoutUnit()));
 
   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;
+  bool hasDefiniteFreeSpace = !!m_availableSpace;
   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()));
+            gridLength.length(), m_availableSpace.value_or(LayoutUnit())));
       }
     }
 
     if (trackSize.isContentSized())
       m_contentSizedTracksIndex.push_back(i);
     if (trackSize.maxTrackBreadth().isFlex())
       m_flexibleSizedTracksIndex.push_back(i);
   }
 }
 
@@ skipping 17 matching lines @@
 
   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));
+                                  m_availableSpace.value_or(LayoutUnit())));
     }
     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() ||
@@ skipping 496 matching lines @@
     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) {
+void GridTrackSizingAlgorithm::stretchFlexibleTracks(
+    Optional<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;
+  if (this->freeSpace(m_direction)) {
+    setFreeSpace(m_direction,
+                 this->freeSpace(m_direction).value() - totalGrowth);
+  }
   m_maxContentSize += totalGrowth;
 }
 
 void GridTrackSizingAlgorithm::advanceNextState() {
   switch (m_sizingState) {
     case ColumnSizingFirstIteration:
       m_sizingState = RowSizingFirstIteration;
       return;
     case RowSizingFirstIteration:
       m_sizingState = ColumnSizingSecondIteration;
@@ skipping 18 matching lines @@
     case RowSizingSecondIteration:
       return m_direction == ForRows;
   }
   NOTREACHED();
   return false;
 }
 
 void GridTrackSizingAlgorithm::setup(GridTrackSizingDirection direction,
                                      size_t numTracks,
                                      SizingOperation sizingOperation,
-                                     LayoutUnit availableSpace,
-                                     LayoutUnit freeSpace) {
+                                     Optional<LayoutUnit> availableSpace,
+                                     Optional<LayoutUnit> freeSpace) {
   DCHECK(m_needsSetup);
+  DCHECK_EQ(!!availableSpace, !!freeSpace);
   m_direction = direction;
-  m_availableSpace = availableSpace;
+  m_availableSpace = availableSpace
+                         ? availableSpace.value().clampNegativeToZero()
+                         : 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;
-  }
+
+  if (availableSpace)
+    m_strategy = WTF::makeUnique<DefiniteSizeStrategy>(*this);
+  else
+    m_strategy = WTF::makeUnique<IndefiniteSizeStrategy>(*this);
 
   m_contentSizedTracksIndex.shrink(0);
   m_flexibleSizedTracksIndex.shrink(0);
 
-  this->freeSpace(direction) = freeSpace;
+  setFreeSpace(direction, freeSpace);
   tracks(direction).resize(numTracks);
 
   m_needsSetup = false;
 }
 
 // Described in https://drafts.csswg.org/css-grid/#algo-track-sizing
 void GridTrackSizingAlgorithm::run() {
   StateMachine stateMachine(*this);
 
   // Step 1.
-  LayoutUnit initialFreeSpace = freeSpace(m_direction);
+  Optional<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;
+  if (freeSpace(m_direction)) {
+    LayoutUnit updatedFreeSpace =
+        freeSpace(m_direction).value() - m_minContentSize;
+    setFreeSpace(m_direction, updatedFreeSpace);
+    if (updatedFreeSpace <= 0)
+      return;
+  }
 
   // Step 3.
-  m_strategy->maximizeTracks(tracks(m_direction), freeSpace(m_direction));
+  m_strategy->maximizeTracks(tracks(m_direction), m_direction == ForColumns
+                                                      ? m_freeSpaceColumns
+                                                      : m_freeSpaceRows);
 
   if (m_flexibleSizedTracksIndex.isEmpty())
     return;
 
   // Step 4.
   stretchFlexibleTracks(initialFreeSpace);
 }
 
 void GridTrackSizingAlgorithm::reset() {
   m_sizingState = ColumnSizingFirstIteration;
@@ skipping 21 matching lines @@
   DCHECK(m_algorithm.isValidTransition());
   DCHECK(!m_algorithm.m_needsSetup);
 }
 
 GridTrackSizingAlgorithm::StateMachine::~StateMachine() {
   m_algorithm.advanceNextState();
   m_algorithm.m_needsSetup = true;
 }
 
 }  // namespace blink