Move rendering/RenderGrid to layout/LayoutGrid

Source/core/layout/LayoutGrid.h

 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef RenderGrid_h
-#define RenderGrid_h
+#ifndef LayoutGrid_h
+#define LayoutGrid_h
 
 #include "core/layout/OrderIterator.h"
 #include "core/layout/style/GridResolvedPosition.h"
 #include "core/rendering/RenderBlock.h"
 
 namespace blink {
 
 struct GridCoordinate;
 struct GridSpan;
 class GridTrack;
 class GridItemWithSpan;
 
-class RenderGrid final : public RenderBlock {
+class LayoutGrid final : public RenderBlock {
 public:
-    RenderGrid(Element*);
-    virtual ~RenderGrid();
+    LayoutGrid(Element*);
+    virtual ~LayoutGrid();
 
     virtual const char* renderName() const override;
 
     virtual void layoutBlock(bool relayoutChildren) override;
 
     virtual bool canCollapseAnonymousBlockChild() const override { return false; }
 
     void dirtyGrid();
 
     const Vector<LayoutUnit>& columnPositions() const { return m_columnPositions; }
     const Vector<LayoutUnit>& rowPositions() const { return m_rowPositions; }
 
     typedef Vector<LayoutBox*, 1> GridCell;
     const GridCell& gridCell(int row, int column) { return m_grid[row][column]; }
     const Vector<LayoutBox*>& itemsOverflowingGridArea() { return m_gridItemsOverflowingGridArea; }
     int paintIndexForGridItem(const LayoutBox* layoutBox) { return m_gridItemsIndexesMap.get(layoutBox); }
 
     bool gridIsDirty() const { return m_gridIsDirty; }
 
     typedef void (GridTrack::* AccumulatorGrowFunction)(LayoutUnit);
 private:
-    virtual bool isOfType(LayoutObjectType type) const override { return type == LayoutObjectRenderGrid || RenderBlock::isOfType(type); }
+    virtual bool isOfType(LayoutObjectType type) const override { return type == LayoutObjectLayoutGrid || RenderBlock::isOfType(type); }
     virtual void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
     virtual void computePreferredLogicalWidths() override;
 
     virtual void addChild(LayoutObject* newChild, LayoutObject* beforeChild = 0) override;
     virtual void removeChild(LayoutObject*) override;
 
     virtual void styleDidChange(StyleDifference, const LayoutStyle*) override;
 
     bool explicitGridDidResize(const LayoutStyle&) const;
     bool namedGridLinesDefinitionDidChange(const LayoutStyle&) const;
@@ skipping 17 matching lines @@
     void placeAutoMajorAxisItemsOnGrid(const Vector<LayoutBox*>&);
     void placeAutoMajorAxisItemOnGrid(LayoutBox&, std::pair<size_t, size_t>& autoPlacementCursor);
     GridTrackSizingDirection autoPlacementMajorAxisDirection() const;
     GridTrackSizingDirection autoPlacementMinorAxisDirection() const;
 
     void layoutGridItems();
     void layoutPositionedObjects(bool relayoutChildren, PositionedLayoutBehavior = DefaultLayout);
     void offsetAndBreadthForPositionedChild(const LayoutBox&, GridTrackSizingDirection, bool startIsAuto, bool endIsAuto, LayoutUnit& offset, LayoutUnit& breadth);
     void populateGridPositions(const GridSizingData&, LayoutUnit availableSpaceForColumns, LayoutUnit availableSpaceForRows);
 
-    typedef LayoutUnit (RenderGrid::* SizingFunction)(LayoutBox&, GridTrackSizingDirection, Vector<GridTrack>&);
+    typedef LayoutUnit (LayoutGrid::* SizingFunction)(LayoutBox&, GridTrackSizingDirection, Vector<GridTrack>&);
     typedef const LayoutUnit& (GridTrack::* AccumulatorGetter)() const;
     typedef bool (GridTrackSize::* FilterFunction)() const;
     void resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection, const GridCoordinate&, LayoutBox& gridItem, GridTrack&, Vector<GridTrack>& columnTracks);
     void resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection, GridSizingData&, GridItemWithSpan&, FilterFunction, SizingFunction, AccumulatorGetter, AccumulatorGrowFunction, FilterFunction growAboveMaxBreadthFilterFunction = nullptr);
     void distributeSpaceToTracks(Vector<GridTrack*>&, const Vector<GridTrack*>* growBeyondGrowthLimitsTracks, AccumulatorGetter, AccumulatorGrowFunction, GridSizingData&, LayoutUnit& availableLogicalSpace);
 
     double computeNormalizedFractionBreadth(Vector<GridTrack>&, const GridSpan& tracksSpan, GridTrackSizingDirection, LayoutUnit availableLogicalSpace) const;
 
     GridTrackSize gridTrackSize(GridTrackSizingDirection, size_t) const;
 
@@ skipping 41 matching lines @@
         return m_grid[0].size();
     }
     size_t gridRowCount() const
     {
         ASSERT(!gridIsDirty());
         return m_grid.size();
     }
 
     bool hasDefiniteLogicalSize(GridTrackSizingDirection) const;
 
-    typedef Vector<Vector<GridCell> > GridRepresentation;
+    typedef Vector<Vector<GridCell>> GridRepresentation;
     GridRepresentation m_grid;
     bool m_gridIsDirty;
     Vector<LayoutUnit> m_rowPositions;
     Vector<LayoutUnit> m_columnPositions;
     HashMap<const LayoutBox*, GridCoordinate> m_gridItemCoordinate;
     OrderIterator m_orderIterator;
     Vector<LayoutBox*> m_gridItemsOverflowingGridArea;
     HashMap<const LayoutBox*, size_t> m_gridItemsIndexesMap;
 };
 
-DEFINE_LAYOUT_OBJECT_TYPE_CASTS(RenderGrid, isRenderGrid());
+DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutGrid, isLayoutGrid());
 
 } // namespace blink
 
-#endif // RenderGrid_h
+#endif // LayoutGrid_h