[css-grid] Wipe SizingOperation out

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 <memory>
 #include "core/layout/LayoutBox.h"
 #include "core/style/GridPositionsResolver.h"
 #include "core/style/GridTrackSize.h"
 #include "platform/LayoutUnit.h"
 #include "platform/wtf/HashSet.h"
 #include "platform/wtf/Optional.h"
 
 namespace blink {
 
 static const int kInfinity = -1;
 
 class Grid;
 class GridTrackSizingAlgorithmStrategy;
 class LayoutGrid;
 
-enum SizingOperation { kTrackSizing, kIntrinsicSizeComputation };
-
 enum TrackSizeComputationPhase {
   kResolveIntrinsicMinimums,
   kResolveContentBasedMinimums,
   kResolveMaxContentMinimums,
   kResolveIntrinsicMaximums,
   kResolveMaxContentMaximums,
   kMaximizeTracks,
 };
 
 class GridTrack {
@@ skipping 43 matching lines @@
  public:
   GridTrackSizingAlgorithm(const LayoutGrid* layout_grid, Grid& grid)
       : grid_(grid),
         layout_grid_(layout_grid),
         sizing_state_(kColumnSizingFirstIteration) {}
 
   // setup() must be run before calling run() as it configures the behaviour of
   // the algorithm.
   void Setup(GridTrackSizingDirection,
              size_t num_tracks,
-             SizingOperation,
              Optional<LayoutUnit> available_space,
              Optional<LayoutUnit> free_space);
   void Run();
   void Reset();
 
   // Required by LayoutGrid. Try to minimize the exposed surface.
   const Grid& GetGrid() const { return grid_; }
   GridTrackSize GetGridTrackSize(GridTrackSizingDirection,
                                  size_t translated_index) const;
   LayoutUnit MinContentSize() const { return min_content_size_; };
@@ skipping 83 matching lines @@
   Optional<LayoutUnit> free_space_rows_;
 
   // We need to keep both alive in order to properly size grids with orthogonal
   // writing modes.
   Vector<GridTrack> columns_;
   Vector<GridTrack> rows_;
   Vector<size_t> content_sized_tracks_index_;
   Vector<size_t> flexible_sized_tracks_index_;
 
   GridTrackSizingDirection direction_;
-  SizingOperation sizing_operation_;
 
   Grid& grid_;
 
   const LayoutGrid* layout_grid_;
   std::unique_ptr<GridTrackSizingAlgorithmStrategy> strategy_;
 
   // The track sizing algorithm is used for both layout and intrinsic size
   // computation. We're normally just interested in intrinsic inline sizes
   // (a.k.a widths in most of the cases) for the computeIntrinsicLogicalWidths()
   // computations. That's why we don't need to keep around different values for
@@ skipping 55 matching lines @@
   virtual void LayoutGridItemForMinSizeComputation(
       LayoutBox&,
       bool override_size_has_changed) const = 0;
 
   LayoutUnit LogicalHeightForChild(LayoutBox&) const;
 
   bool UpdateOverrideContainingBlockContentSizeForChild(
       LayoutBox&,
       GridTrackSizingDirection) const;
   LayoutUnit ComputeTrackBasedSize() const;
+  Optional<LayoutUnit> ExtentForBaselineAlignment(LayoutBox&) const;
+
   GridTrackSizingDirection Direction() const { return algorithm_.direction_; }
   double FindFrUnitSize(const GridSpan& tracks_span,
                         LayoutUnit left_over_space) const;
   void DistributeSpaceToTracks(Vector<GridTrack*>& tracks,
                                LayoutUnit& available_logical_space) const;
   const LayoutGrid* GetLayoutGrid() const { return algorithm_.layout_grid_; }
   Optional<LayoutUnit> AvailableSpace() const {
     return algorithm_.AvailableSpace();
   }
 
@@ skipping 18 matching lines @@
   static GridTrackSizingDirection FlowAwareDirectionForChild(
       const LayoutGrid*,
       const LayoutBox& child,
       GridTrackSizingDirection);
 
   GridTrackSizingAlgorithm& algorithm_;
 };
 }
 
 #endif  // GridTrackSizingAlgorithm_h