[css-grid] Use Optional to represent indefinite lengths

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

 // 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.
 
 #ifndef GridTrackSizingAlgorithm_h
 #define GridTrackSizingAlgorithm_h
 
 #include "core/style/GridPositionsResolver.h"
 #include "core/style/GridTrackSize.h"
 #include "platform/LayoutUnit.h"
@@ skipping 66 matching lines @@
   GridTrackSizingAlgorithm(const LayoutGrid* layoutGrid, Grid& grid)
       : m_grid(grid),
         m_layoutGrid(layoutGrid),
         m_sizingState(ColumnSizingFirstIteration) {}
 
   // setup() must be run before calling run() as it configures the behaviour of
   // the algorithm.
   void setup(GridTrackSizingDirection,
              size_t numTracks,
              SizingOperation,
-             LayoutUnit availableSpace,
-             LayoutUnit freeSpace);
+             Optional<LayoutUnit> availableSpace,
+             Optional<LayoutUnit> freeSpace);
   void run();
   void reset();
 
   // Required by LayoutGrid. Try to minimize the exposed surface.
   const Grid& grid() const { return m_grid; }
   GridTrackSize gridTrackSize(GridTrackSizingDirection,
                               size_t translatedIndex,
                               SizingOperation) const;
   LayoutUnit minContentSize() const { return m_minContentSize; };
   LayoutUnit maxContentSize() const { return m_maxContentSize; };
 
   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;
   bool isTrackSizingOperation() const {
     return m_sizingOperation == TrackSizing;
   };
 #endif
 
  private:
   GridTrackSize gridTrackSize(GridTrackSizingDirection,
@@ skipping 43 matching lines @@
                                     Vector<LayoutUnit>& increments,
                                     LayoutUnit& totalGrowth) const;
   double findFrUnitSize(const GridSpan& tracksSpan,
                         LayoutUnit leftOverSpace) const;
 
   // Track sizing algorithm steps. Note that the "Maximize Tracks" step is done
   // entirely inside the strategies, that's why we don't need an additional
   // method at thise level.
   void initializeTrackSizes();
   void resolveIntrinsicTrackSizes();
-  void stretchFlexibleTracks(LayoutUnit freeSpace);
+  void stretchFlexibleTracks(Optional<LayoutUnit> freeSpace);
 
   // State machine.
   void advanceNextState();
   bool isValidTransition() const;
 
   // 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.
   Vector<GridTrack> m_columns;
   Vector<GridTrack> m_rows;
   Vector<size_t> m_contentSizedTracksIndex;
   Vector<size_t> m_flexibleSizedTracksIndex;
 
   GridTrackSizingDirection m_direction;
   SizingOperation m_sizingOperation;
@@ skipping 35 matching lines @@
 
 class GridTrackSizingAlgorithmStrategy {
   WTF_MAKE_NONCOPYABLE(GridTrackSizingAlgorithmStrategy);
   USING_FAST_MALLOC(GridTrackSizingAlgorithmStrategy);
 
  public:
   LayoutUnit minContentForChild(LayoutBox&) const;
   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,
       Vector<LayoutUnit>& increments,
       LayoutUnit& totalGrowth) const = 0;
 
  protected:
   GridTrackSizingAlgorithmStrategy(GridTrackSizingAlgorithm& algorithm)
       : m_algorithm(algorithm) {}
 
@@ skipping 18 matching lines @@
                         LayoutUnit leftOverSpace) const;
   void distributeSpaceToTracks(Vector<GridTrack*>& tracks,
                                LayoutUnit& availableLogicalSpace) const;
   const LayoutGrid* layoutGrid() const { return m_algorithm.m_layoutGrid; }
 
   GridTrackSizingAlgorithm& m_algorithm;
 };
 }
 
 #endif  // GridTrackSizingAlgorithm_h