[css-grid] Use Optional to represent indefinite lengths

Blink has been using LayoutUnit(-1) to represent indefinite sizes or more in
general, sizes that cannot be resolved. That's unfortunate because it forces
us to use that magic number and also because negative LayoutUnits are valid
outcomes of some operations.

In our particular case, that was forcing us to check the SizingOperation
argument in the GridTrackSizingAlgorithm to know whether the passed
available and free sizes where actually indefinite or not. Actually that was
not totally correct as this was based on the assumption that we were doing
intrinsic size computations (preferred widths) whenever the sizes where
indefinite which is not correct for all the cases (it's true for widths but
a height:auto grid container would have indefinite height and require
indefinite size computations).

This does not require any additional tests as we are not changing any
behaviour. It's a step forward in the process of decoupling the concepts of
definite/indefinite sizes and intrinsicSize/layout operations.

Review-Url: https://codereview.chromium.org/2808453002
Cr-Commit-Position: refs/heads/master@{#462881}

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

@@ -84,8 +84,8 @@ class GridTrackSizingAlgorithm final {
   void setup(GridTrackSizingDirection,
              size_t numTracks,
              SizingOperation,
-             LayoutUnit availableSpace,
-             LayoutUnit freeSpace);
+             Optional<LayoutUnit> availableSpace,
+             Optional<LayoutUnit> freeSpace);
   void run();
   void reset();
 
@@ -100,7 +100,8 @@ class GridTrackSizingAlgorithm final {
   Vector<GridTrack>& tracks(GridTrackSizingDirection);
   const Vector<GridTrack>& tracks(GridTrackSizingDirection) const;
 
-  LayoutUnit& freeSpace(GridTrackSizingDirection);
+  Optional<LayoutUnit> freeSpace(GridTrackSizingDirection);
+  void setFreeSpace(GridTrackSizingDirection, Optional<LayoutUnit>);
 
 #if DCHECK_IS_ON()
   bool tracksAreWiderThanMinTrackBreadth() const;
@@ -164,7 +165,7 @@ class GridTrackSizingAlgorithm final {
   // method at thise level.
   void initializeTrackSizes();
   void resolveIntrinsicTrackSizes();
-  void stretchFlexibleTracks(LayoutUnit freeSpace);
+  void stretchFlexibleTracks(Optional<LayoutUnit> freeSpace);
 
   // State machine.
   void advanceNextState();
@@ -172,10 +173,10 @@ class GridTrackSizingAlgorithm final {
 
   // Data.
   bool m_needsSetup{true};
-  LayoutUnit m_availableSpace;
+  Optional<LayoutUnit> m_availableSpace;
 
-  LayoutUnit m_freeSpaceColumns;
-  LayoutUnit m_freeSpaceRows;
+  Optional<LayoutUnit> m_freeSpaceColumns;
+  Optional<LayoutUnit> m_freeSpaceRows;
 
   // We need to keep both alive in order to properly size grids with orthogonal
   // writing modes.
@@ -231,10 +232,12 @@ class GridTrackSizingAlgorithmStrategy {
   LayoutUnit maxContentForChild(LayoutBox&) const;
   LayoutUnit minSizeForChild(LayoutBox&) const;
 
-  virtual void maximizeTracks(Vector<GridTrack>&, LayoutUnit& freeSpace) = 0;
-  virtual double findUsedFlexFraction(Vector<size_t>& flexibleSizedTracksIndex,
-                                      GridTrackSizingDirection,
-                                      LayoutUnit initialFreeSpace) const = 0;
+  virtual void maximizeTracks(Vector<GridTrack>&,
+                              Optional<LayoutUnit>& freeSpace) = 0;
+  virtual double findUsedFlexFraction(
+      Vector<size_t>& flexibleSizedTracksIndex,
+      GridTrackSizingDirection,
+      Optional<LayoutUnit> initialFreeSpace) const = 0;
   virtual bool recomputeUsedFlexFractionIfNeeded(
       Vector<size_t>& flexibleSizedTracksIndex,
       double& flexFraction,

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

@@ -284,8 +284,8 @@ void LayoutGrid::layoutBlock(bool relayoutChildren) {
     // Once grid's indefinite height is resolved, we can compute the
     // available free space for Content Alignment.
     if (!cachedHasDefiniteLogicalHeight()) {
-      m_trackSizingAlgorithm.freeSpace(ForRows) =
-          logicalHeight() - trackBasedLogicalHeight;
+      m_trackSizingAlgorithm.setFreeSpace(
+          ForRows, logicalHeight() - trackBasedLogicalHeight);
     }
 
     // TODO (lajava): We need to compute baselines after step 2 so
@@ -436,7 +436,7 @@ void LayoutGrid::computeTrackSizesForIndefiniteSize(
     LayoutUnit& minIntrinsicSize,
     LayoutUnit& maxIntrinsicSize) const {
   algo.setup(direction, numTracks(direction, grid), IntrinsicSizeComputation,
-             LayoutUnit(), LayoutUnit());
+             WTF::nullopt, WTF::nullopt);
   algo.run();
 
   minIntrinsicSize = algo.minContentSize();
@@ -1046,8 +1046,8 @@ static const StyleContentAlignmentData& contentAlignmentNormalBehavior() {
 
 void LayoutGrid::applyStretchAlignmentToTracksIfNeeded(
     GridTrackSizingDirection direction) {
-  LayoutUnit& availableSpace = m_trackSizingAlgorithm.freeSpace(direction);
-  if (availableSpace <= 0 ||
+  Optional<LayoutUnit> freeSpace = m_trackSizingAlgorithm.freeSpace(direction);
+  if (!freeSpace || freeSpace.value() <= 0 ||
       (direction == ForColumns &&
        styleRef().resolvedJustifyContentDistribution(
            contentAlignmentNormalBehavior()) != ContentDistributionStretch) ||
@@ -1071,14 +1071,13 @@ void LayoutGrid::applyStretchAlignmentToTracksIfNeeded(
   if (numberOfAutoSizedTracks < 1)
     return;
 
-  LayoutUnit sizeToIncrease = availableSpace / numberOfAutoSizedTracks;
+  LayoutUnit sizeToIncrease = freeSpace.value() / numberOfAutoSizedTracks;
   for (const auto& trackIndex : autoSizedTracksIndex) {
     GridTrack* track = allTracks.data() + trackIndex;
     LayoutUnit baseSize = track->baseSize() + sizeToIncrease;
     track->setBaseSize(baseSize);
   }
-
-  availableSpace = LayoutUnit();
+  m_trackSizingAlgorithm.setFreeSpace(direction, LayoutUnit());
 }
 
 void LayoutGrid::layoutGridItems() {
@@ -1345,7 +1344,8 @@ void LayoutGrid::populateGridPositionsForDirection(
   size_t numberOfLines = numberOfTracks + 1;
   size_t lastLine = numberOfLines - 1;
   ContentAlignmentData offset = computeContentPositionAndDistributionOffset(
-      direction, m_trackSizingAlgorithm.freeSpace(direction), numberOfTracks);
+      direction, m_trackSizingAlgorithm.freeSpace(direction).value(),
+      numberOfTracks);
   auto& positions = isRowAxis ? m_columnPositions : m_rowPositions;
   positions.resize(numberOfLines);
   auto borderAndPadding =