[css-grid] Use Optional to represent indefinite lengths

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

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 266 matching lines @@
                                          borderAndPaddingLogicalHeight() +
                                          scrollbarLogicalHeight();
     setLogicalHeight(trackBasedLogicalHeight);
 
     LayoutUnit oldClientAfterEdge = clientLogicalBottom();
     updateLogicalHeight();
 
     // 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
     // items with a relative size (percentages) can resolve it before
     // determining its baseline. However, we only set item's grid area
     // (via override sizes) as part of the content-sized tracks sizing
     // logic. Hence, items located at fixed or flexible tracks can't
     // resolve correctly their size at this stage, which may lead to
     // an incorrect computation of their shared context's baseline.
     computeBaselineAlignmentContext();
@@ skipping 130 matching lines @@
   maxLogicalWidth += scrollbarWidth;
 }
 
 void LayoutGrid::computeTrackSizesForIndefiniteSize(
     GridTrackSizingAlgorithm& algo,
     GridTrackSizingDirection direction,
     Grid& grid,
     LayoutUnit& minIntrinsicSize,
     LayoutUnit& maxIntrinsicSize) const {
   algo.setup(direction, numTracks(direction, grid), IntrinsicSizeComputation,
-             LayoutUnit(), LayoutUnit());
+             WTF::nullopt, WTF::nullopt);
   algo.run();
 
   minIntrinsicSize = algo.minContentSize();
   maxIntrinsicSize = algo.maxContentSize();
 
   size_t numberOfTracks = algo.tracks(direction).size();
   LayoutUnit totalGuttersSize =
       guttersSize(grid, direction, 0, numberOfTracks, IntrinsicSizeComputation);
   minIntrinsicSize += totalGuttersSize;
   maxIntrinsicSize += totalGuttersSize;
@@ skipping 589 matching lines @@
 }
 
 static const StyleContentAlignmentData& contentAlignmentNormalBehavior() {
   static const StyleContentAlignmentData normalBehavior = {
       ContentPositionNormal, ContentDistributionStretch};
   return normalBehavior;
 }
 
 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) ||
       (direction == ForRows &&
        styleRef().resolvedAlignContentDistribution(
            contentAlignmentNormalBehavior()) != ContentDistributionStretch))
     return;
 
   // Spec defines auto-sized tracks as the ones with an 'auto' max-sizing
   // function.
   Vector<GridTrack>& allTracks = m_trackSizingAlgorithm.tracks(direction);
   Vector<unsigned> autoSizedTracksIndex;
   for (unsigned i = 0; i < allTracks.size(); ++i) {
     const GridTrackSize& trackSize =
         m_trackSizingAlgorithm.gridTrackSize(direction, i, TrackSizing);
     if (trackSize.hasAutoMaxTrackBreadth())
       autoSizedTracksIndex.push_back(i);
   }
 
   unsigned numberOfAutoSizedTracks = autoSizedTracksIndex.size();
   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() {
   populateGridPositionsForDirection(ForColumns);
   populateGridPositionsForDirection(ForRows);
   m_gridItemsOverflowingGridArea.resize(0);
 
   for (LayoutBox* child = firstChildBox(); child;
        child = child->nextSiblingBox()) {
     if (child->isOutOfFlowPositioned()) {
@@ skipping 246 matching lines @@
   // offset) are sensible to the inline-axis flow direction. However, column
   // lines positions are 'direction' unaware. This simplification allows us to
   // use the same indexes to identify the columns independently on the
   // inline-axis direction.
   bool isRowAxis = direction == ForColumns;
   auto& tracks = m_trackSizingAlgorithm.tracks(direction);
   size_t numberOfTracks = tracks.size();
   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 =
       isRowAxis ? borderAndPaddingLogicalLeft() : borderAndPaddingBefore();
   positions[0] = borderAndPadding + offset.positionOffset;
   const Grid& grid = m_trackSizingAlgorithm.grid();
   if (numberOfLines > 1) {
     // If we have collapsed tracks we just ignore gaps here and add them later
     // as we might not compute the gap between two consecutive tracks without
     // examining the surrounding ones.
@@ skipping 964 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink