Changeset 197400 in webkit


Ignore:
Timestamp:
Mar 1, 2016 8:54:19 AM (8 years ago)
Author:
Manuel Rego Casasnovas
Message:

[css-grid] Get rid of GridResolvedPosition
https://bugs.webkit.org/show_bug.cgi?id=154818

Reviewed by Darin Adler.

GridResolvedPosition was a small class just wrapping a unsigned.
In the future it should actually wrap an integer,
as we want to support implicit tracks before the explicit grid.

The class itself is not providing any benefit,
so we can get rid of it and store directly 2 unsigned in GridSpan.

This will make simpler future changes related to this task.

We keep the class just as a utility for the methods
that deal with the positions resolution.
But it should be renamed in a follow-up patch.

No new tests, no change of behavior.

  • css/CSSGridTemplateAreasValue.cpp:

(WebCore::stringForPosition):

  • css/CSSParser.cpp:

(WebCore::CSSParser::parseGridTemplateAreasRow):

  • css/StyleBuilderConverter.h:

(WebCore::StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea):

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
(WebCore::RenderGrid::findFlexFactorUnitSize):
(WebCore::RenderGrid::spanningItemCrossesFlexibleSizedTracks):
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForItems):
(WebCore::RenderGrid::insertItemIntoGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::gridAreaBreadthForChild):
(WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
(WebCore::RenderGrid::columnAxisOffsetForChild):
(WebCore::RenderGrid::rowAxisOffsetForChild):

  • rendering/style/GridCoordinate.h:

(WebCore::GridSpan::definiteGridSpan):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::resolvedInitialPosition):
(WebCore::GridSpan::resolvedFinalPosition):
(WebCore::GridSpan::GridSpanIterator::GridSpanIterator):
(WebCore::GridSpan::GridSpanIterator::operator*):
(WebCore::GridSpan::GridSpanIterator::operator++):
(WebCore::GridSpan::GridSpanIterator::operator!=):
(WebCore::GridSpan::begin):
(WebCore::GridSpan::end):
(WebCore::GridSpan::GridSpan):

  • rendering/style/GridResolvedPosition.cpp:

(WebCore::resolveNamedGridLinePositionFromStyle):
(WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
(WebCore::resolveGridPositionFromStyle):
(WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):

  • rendering/style/GridResolvedPosition.h:

(WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
(WebCore::GridResolvedPosition::operator*): Deleted.
(WebCore::GridResolvedPosition::operator++): Deleted.
(WebCore::GridResolvedPosition::operator==): Deleted.
(WebCore::GridResolvedPosition::operator!=): Deleted.
(WebCore::GridResolvedPosition::operator<): Deleted.
(WebCore::GridResolvedPosition::operator>): Deleted.
(WebCore::GridResolvedPosition::operator<=): Deleted.
(WebCore::GridResolvedPosition::operator>=): Deleted.
(WebCore::GridResolvedPosition::toInt): Deleted.
(WebCore::GridResolvedPosition::next): Deleted.
(WebCore::GridResolvedPosition::prev): Deleted.

Location:
trunk/Source/WebCore
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r197399 r197400  
     12016-03-01  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] Get rid of GridResolvedPosition
     4        https://bugs.webkit.org/show_bug.cgi?id=154818
     5
     6        Reviewed by Darin Adler.
     7
     8        GridResolvedPosition was a small class just wrapping a unsigned.
     9        In the future it should actually wrap an integer,
     10        as we want to support implicit tracks before the explicit grid.
     11
     12        The class itself is not providing any benefit,
     13        so we can get rid of it and store directly 2 unsigned in GridSpan.
     14
     15        This will make simpler future changes related to this task.
     16
     17        We keep the class just as a utility for the methods
     18        that deal with the positions resolution.
     19        But it should be renamed in a follow-up patch.
     20
     21        No new tests, no change of behavior.
     22
     23        * css/CSSGridTemplateAreasValue.cpp:
     24        (WebCore::stringForPosition):
     25        * css/CSSParser.cpp:
     26        (WebCore::CSSParser::parseGridTemplateAreasRow):
     27        * css/StyleBuilderConverter.h:
     28        (WebCore::StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea):
     29        * rendering/RenderGrid.cpp:
     30        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     31        (WebCore::RenderGrid::findFlexFactorUnitSize):
     32        (WebCore::RenderGrid::spanningItemCrossesFlexibleSizedTracks):
     33        (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
     34        (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForItems):
     35        (WebCore::RenderGrid::insertItemIntoGrid):
     36        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
     37        (WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
     38        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
     39        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
     40        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
     41        (WebCore::RenderGrid::gridAreaBreadthForChild):
     42        (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
     43        (WebCore::RenderGrid::columnAxisOffsetForChild):
     44        (WebCore::RenderGrid::rowAxisOffsetForChild):
     45        * rendering/style/GridCoordinate.h:
     46        (WebCore::GridSpan::definiteGridSpan):
     47        (WebCore::GridSpan::integerSpan):
     48        (WebCore::GridSpan::resolvedInitialPosition):
     49        (WebCore::GridSpan::resolvedFinalPosition):
     50        (WebCore::GridSpan::GridSpanIterator::GridSpanIterator):
     51        (WebCore::GridSpan::GridSpanIterator::operator*):
     52        (WebCore::GridSpan::GridSpanIterator::operator++):
     53        (WebCore::GridSpan::GridSpanIterator::operator!=):
     54        (WebCore::GridSpan::begin):
     55        (WebCore::GridSpan::end):
     56        (WebCore::GridSpan::GridSpan):
     57        * rendering/style/GridResolvedPosition.cpp:
     58        (WebCore::resolveNamedGridLinePositionFromStyle):
     59        (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
     60        (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
     61        (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
     62        (WebCore::resolveGridPositionAgainstOppositePosition):
     63        (WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
     64        (WebCore::resolveGridPositionFromStyle):
     65        (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
     66        * rendering/style/GridResolvedPosition.h:
     67        (WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
     68        (WebCore::GridResolvedPosition::operator*): Deleted.
     69        (WebCore::GridResolvedPosition::operator++): Deleted.
     70        (WebCore::GridResolvedPosition::operator==): Deleted.
     71        (WebCore::GridResolvedPosition::operator!=): Deleted.
     72        (WebCore::GridResolvedPosition::operator<): Deleted.
     73        (WebCore::GridResolvedPosition::operator>): Deleted.
     74        (WebCore::GridResolvedPosition::operator<=): Deleted.
     75        (WebCore::GridResolvedPosition::operator>=): Deleted.
     76        (WebCore::GridResolvedPosition::toInt): Deleted.
     77        (WebCore::GridResolvedPosition::next): Deleted.
     78        (WebCore::GridResolvedPosition::prev): Deleted.
     79
    1802016-03-01  Andreas Kling  <akling@apple.com>
    281
  • trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp

    r196691 r197400  
    5656    for (const auto& it : gridAreaMap) {
    5757        const GridCoordinate& coordinate = it.value;
    58         if (row >= coordinate.rows.resolvedInitialPosition().toInt() && row < coordinate.rows.resolvedFinalPosition().toInt())
     58        if (row >= coordinate.rows.resolvedInitialPosition() && row < coordinate.rows.resolvedFinalPosition())
    5959            candidates.append(it.key);
    6060    }
     
    6262    for (const auto& it : gridAreaMap) {
    6363        const GridCoordinate& coordinate = it.value;
    64         if (column >= coordinate.columns.resolvedInitialPosition().toInt() && column < coordinate.columns.resolvedFinalPosition().toInt() && candidates.contains(it.key))
     64        if (column >= coordinate.columns.resolvedInitialPosition() && column < coordinate.columns.resolvedFinalPosition() && candidates.contains(it.key))
    6565            return it.key;
    6666    }
  • trunk/Source/WebCore/css/CSSParser.cpp

    r197165 r197400  
    62466246            // The following checks test that the grid area is a single filled-in rectangle.
    62476247            // 1. The new row is adjacent to the previously parsed row.
    6248             if (rowCount != gridCoordinate.rows.resolvedFinalPosition().toInt())
     6248            if (rowCount != gridCoordinate.rows.resolvedFinalPosition())
    62496249                return false;
    62506250
    62516251            // 2. The new area starts at the same position as the previously parsed area.
    6252             if (currentColumn != gridCoordinate.columns.resolvedInitialPosition().toInt())
     6252            if (currentColumn != gridCoordinate.columns.resolvedInitialPosition())
    62536253                return false;
    62546254
    62556255            // 3. The new area ends at the same position as the previously parsed area.
    6256             if (lookAheadColumn != gridCoordinate.columns.resolvedFinalPosition().toInt())
     6256            if (lookAheadColumn != gridCoordinate.columns.resolvedFinalPosition())
    62576257                return false;
    62586258
    6259             gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition().next());
     6259            gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition() + 1);
    62606260        }
    62616261        currentColumn = lookAheadColumn - 1;
  • trunk/Source/WebCore/css/StyleBuilderConverter.h

    r196991 r197400  
    887887        {
    888888            auto& startVector = namedGridLines.add(area.key + "-start", Vector<unsigned>()).iterator->value;
    889             startVector.append(areaSpan.resolvedInitialPosition().toInt());
     889            startVector.append(areaSpan.resolvedInitialPosition());
    890890            std::sort(startVector.begin(), startVector.end());
    891891        }
    892892        {
    893893            auto& endVector = namedGridLines.add(area.key + "-end", Vector<unsigned>()).iterator->value;
    894             endVector.append(areaSpan.resolvedFinalPosition().toInt());
     894            endVector.append(areaSpan.resolvedFinalPosition());
    895895            std::sort(endVector.begin(), endVector.end());
    896896        }
  • trunk/Source/WebCore/rendering/RenderGrid.cpp

    r196983 r197400  
    578578
    579579                // Do not include already processed items.
    580                 if (i > 0 && span.resolvedInitialPosition().toInt() <= flexibleSizedTracksIndex[i - 1])
     580                if (i > 0 && span.resolvedInitialPosition() <= flexibleSizedTracksIndex[i - 1])
    581581                    continue;
    582582
     
    662662    double flexFactorSum = 0;
    663663    Vector<unsigned, 8> flexibleTracksIndexes;
    664     for (const auto& resolvedPosition : tracksSpan) {
    665         unsigned trackIndex = resolvedPosition.toInt();
     664    for (auto trackIndex : tracksSpan) {
    666665        GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
    667666        if (!trackSize.maxTrackBreadth().isFlex())
     
    812811{
    813812    for (auto trackPosition : itemSpan) {
    814         const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition.toInt());
     813        const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition);
    815814        if (trackSize.minTrackBreadth().isFlex() || trackSize.maxTrackBreadth().isFlex())
    816815            return true;
     
    866865void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
    867866{
    868     const GridResolvedPosition trackPosition = span.resolvedInitialPosition();
    869     GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
     867    unsigned trackPosition = span.resolvedInitialPosition();
     868    GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
    870869
    871870    if (trackSize.hasMinContentMinTrackBreadth())
     
    10211020        sizingData.growBeyondGrowthLimitsTracks.shrink(0);
    10221021        LayoutUnit spanningTracksSize;
    1023         for (auto& trackPosition : itemSpan) {
    1024             const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition.toInt());
    1025             GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition.toInt()] : sizingData.rowTracks[trackPosition.toInt()];
     1022        for (auto trackPosition : itemSpan) {
     1023            const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition);
     1024            GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition] : sizingData.rowTracks[trackPosition];
    10261025            spanningTracksSize += trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
    10271026            if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
     
    11401139{
    11411140    ASSERT(coordinate.rows.isDefinite() && coordinate.columns.isDefinite());
    1142     ensureGridSize(coordinate.rows.resolvedFinalPosition().toInt(), coordinate.columns.resolvedFinalPosition().toInt());
    1143 
    1144     for (auto& row : coordinate.rows) {
    1145         for (auto& column : coordinate.columns)
    1146             m_grid[row.toInt()][column.toInt()].append(&child);
     1141    ensureGridSize(coordinate.rows.resolvedFinalPosition(), coordinate.columns.resolvedFinalPosition());
     1142
     1143    for (auto row : coordinate.rows) {
     1144        for (auto column : coordinate.columns)
     1145            m_grid[row][column].append(&child);
    11471146    }
    11481147}
     
    12061205        GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
    12071206        if (rowPositions.isDefinite()) {
    1208             maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition().toInt());
     1207            maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition());
    12091208        } else {
    12101209            // Grow the grid for items with a definite row span, getting the largest such span.
    1211             GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForRows, GridResolvedPosition(0));
    1212             maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition().toInt());
     1210            GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForRows, 0);
     1211            maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition());
    12131212        }
    12141213
    12151214        GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
    12161215        if (columnPositions.isDefinite()) {
    1217             maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition().toInt());
     1216            maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition());
    12181217        } else {
    12191218            // Grow the grid for items with a definite column span, getting the largest such span.
    1220             GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForColumns, GridResolvedPosition(0));
    1221             maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition().toInt());
     1219            GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForColumns, 0);
     1220            maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition());
    12221221        }
    12231222
     
    12341233    GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
    12351234    const unsigned endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
    1236     GridSpan crossDirectionPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, crossDirection, GridResolvedPosition(endOfCrossDirection));
     1235    GridSpan crossDirectionPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, crossDirection, endOfCrossDirection);
    12371236    return std::make_unique<GridCoordinate>(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions);
    12381237}
     
    12521251        ASSERT(majorAxisPositions.isDefinite());
    12531252        ASSERT(!cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isDefinite());
    1254         GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *autoGridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
    1255         unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition().toInt();
    1256 
    1257         GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition().toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
     1253        GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *autoGridItem, autoPlacementMinorAxisDirection(), 0);
     1254        unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition();
     1255
     1256        GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
    12581257        std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisPositions.integerSpan());
    12591258        if (!emptyGridArea)
     
    12641263
    12651264        if (!isGridAutoFlowDense)
    1266             minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition().toInt() : emptyGridArea->columns.resolvedInitialPosition().toInt());
     1265            minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition() : emptyGridArea->columns.resolvedInitialPosition());
    12671266    }
    12681267}
     
    12861285{
    12871286    ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isDefinite());
    1288     GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMajorAxisDirection(), GridResolvedPosition(0));
     1287    GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMajorAxisDirection(), 0);
    12891288
    12901289    const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
     
    12961295    if (minorAxisPositions.isDefinite()) {
    12971296        // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
    1298         if (minorAxisPositions.resolvedInitialPosition().toInt() < minorAxisAutoPlacementCursor)
     1297        if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacementCursor)
    12991298            majorAxisAutoPlacementCursor++;
    13001299
    13011300        if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
    1302             GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition().toInt(), majorAxisAutoPlacementCursor);
     1301            GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition(), majorAxisAutoPlacementCursor);
    13031302            emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisPositions.integerSpan());
    13041303        }
     
    13071306            emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(gridItem, autoPlacementMinorAxisDirection(), minorAxisPositions);
    13081307    } else {
    1309         GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
     1308        GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMinorAxisDirection(), 0);
    13101309
    13111310        for (unsigned majorAxisIndex = majorAxisAutoPlacementCursor; majorAxisIndex < endOfMajorAxis; ++majorAxisIndex) {
     
    13151314            if (emptyGridArea) {
    13161315                // Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
    1317                 GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
     1316                unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
    13181317                const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
    1319                 if (minorAxisFinalPositionIndex.toInt() <= endOfMinorAxis)
     1318                if (minorAxisFinalPositionIndex <= endOfMinorAxis)
    13201319                    break;
    13211320
     
    13351334    m_gridItemCoordinate.set(&gridItem, *emptyGridArea);
    13361335    insertItemIntoGrid(gridItem, *emptyGridArea);
    1337     autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition().toInt();
    1338     autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition().toInt();
     1336    autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition();
     1337    autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition();
    13391338}
    13401339
     
    14811480    bool startIsAuto = startPosition.isAuto()
    14821481        || (startPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
    1483         || (positions.resolvedInitialPosition().toInt() > lastTrackIndex);
     1482        || (positions.resolvedInitialPosition() > lastTrackIndex);
    14841483    bool endIsAuto = endPosition.isAuto()
    14851484        || (endPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
    1486         || (positions.resolvedFinalPosition().prev().toInt() > lastTrackIndex);
    1487 
    1488     GridResolvedPosition firstPosition = GridResolvedPosition(0);
    1489     GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
    1490     GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
    1491     GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition().prev();
     1485        || (positions.resolvedFinalPosition() - 1 > lastTrackIndex);
     1486
     1487    unsigned firstPosition = 0;
     1488    unsigned initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
     1489    unsigned lastPosition = lastTrackIndex;
     1490    unsigned finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition() - 1;
    14921491
    14931492    // Positioned children do not grow the grid, so we need to clamp the positions to avoid ending up outside of it.
    1494     initialPosition = std::min<GridResolvedPosition>(initialPosition, lastPosition);
    1495     finalPosition = std::min<GridResolvedPosition>(finalPosition, lastPosition);
    1496 
    1497     LayoutUnit start = startIsAuto ? LayoutUnit() : (direction == ForColumns) ?  m_columnPositions[initialPosition.toInt()] : m_rowPositions[initialPosition.toInt()];
    1498     LayoutUnit end = endIsAuto ? (direction == ForColumns) ? logicalWidth() : logicalHeight() : (direction == ForColumns) ?  m_columnPositions[finalPosition.next().toInt()] : m_rowPositions[finalPosition.next().toInt()];
     1493    initialPosition = std::min(initialPosition, lastPosition);
     1494    finalPosition = std::min(finalPosition, lastPosition);
     1495
     1496    LayoutUnit start = startIsAuto ? LayoutUnit() : (direction == ForColumns) ?  m_columnPositions[initialPosition] : m_rowPositions[initialPosition];
     1497    LayoutUnit end = endIsAuto ? (direction == ForColumns) ? logicalWidth() : logicalHeight() : (direction == ForColumns) ?  m_columnPositions[finalPosition + 1] : m_rowPositions[finalPosition + 1];
    14991498
    15001499    breadth = end - start;
     
    15381537    const GridSpan& span = cachedGridSpan(child, direction);
    15391538    LayoutUnit gridAreaBreadth = 0;
    1540     for (auto& trackPosition : span)
    1541         gridAreaBreadth += tracks[trackPosition.toInt()].baseSize();
     1539    for (auto trackPosition : span)
     1540        gridAreaBreadth += tracks[trackPosition].baseSize();
    15421541
    15431542    gridAreaBreadth += guttersSize(direction, span.integerSpan());
     
    15541553    const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
    15551554
    1556     LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition().toInt()];
    1557     LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition().prev().toInt()];
     1555    LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition()];
     1556    LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition() - 1];
    15581557
    15591558    // Track Positions vector stores the 'start' grid line of each track, so we have to add last track's baseSize.
    1560     return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition().prev().toInt()].baseSize();
     1559    return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition() - 1].baseSize();
    15611560}
    15621561
     
    18371836{
    18381837    const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
    1839     unsigned childStartLine = rowsSpan.resolvedInitialPosition().toInt();
     1838    unsigned childStartLine = rowsSpan.resolvedInitialPosition();
    18401839    LayoutUnit startOfRow = m_rowPositions[childStartLine];
    18411840    LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
     
    18481847    case GridAxisEnd:
    18491848    case GridAxisCenter: {
    1850         unsigned childEndLine = rowsSpan.resolvedFinalPosition().toInt();
     1849        unsigned childEndLine = rowsSpan.resolvedFinalPosition();
    18511850        LayoutUnit endOfRow = m_rowPositions[childEndLine];
    18521851        // m_rowPositions include gutters so we need to substract them to get the actual end position for a given
     
    18711870{
    18721871    const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
    1873     unsigned childStartLine = columnsSpan.resolvedInitialPosition().toInt();
     1872    unsigned childStartLine = columnsSpan.resolvedInitialPosition();
    18741873    LayoutUnit startOfColumn = m_columnPositions[childStartLine];
    18751874    LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
     
    18821881    case GridAxisEnd:
    18831882    case GridAxisCenter: {
    1884         unsigned childEndLine = columnsSpan.resolvedFinalPosition().toInt();
     1883        unsigned childEndLine = columnsSpan.resolvedFinalPosition();
    18851884        LayoutUnit endOfColumn = m_columnPositions[childEndLine];
    18861885        // m_columnPositions include gutters so we need to substract them to get the actual end position for a given
  • trunk/Source/WebCore/rendering/style/GridCoordinate.h

    r196691 r197400  
    5050public:
    5151
    52     static GridSpan definiteGridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
     52    static GridSpan definiteGridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition)
    5353    {
    5454        return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
     
    6868    {
    6969        ASSERT(isDefinite());
    70         return m_resolvedFinalPosition.toInt() - m_resolvedInitialPosition.toInt();
     70        return m_resolvedFinalPosition - m_resolvedInitialPosition;
    7171    }
    7272
    73     const GridResolvedPosition& resolvedInitialPosition() const
     73    unsigned resolvedInitialPosition() const
    7474    {
    7575        ASSERT(isDefinite());
     
    7777    }
    7878
    79     const GridResolvedPosition& resolvedFinalPosition() const
     79    unsigned resolvedFinalPosition() const
    8080    {
    8181        ASSERT(isDefinite());
     82        ASSERT(m_resolvedFinalPosition);
    8283        return m_resolvedFinalPosition;
    8384    }
    8485
    85     typedef GridResolvedPosition iterator;
     86    struct GridSpanIterator {
     87        GridSpanIterator(unsigned value)
     88            : value(value)
     89        {
     90        }
    8691
    87     iterator begin() const
     92        operator unsigned&() { return value; }
     93        unsigned operator*() const { return value; }
     94
     95        unsigned value;
     96    };
     97
     98    GridSpanIterator begin() const
    8899    {
    89100        ASSERT(isDefinite());
     
    91102    }
    92103
    93     iterator end() const
     104    GridSpanIterator end() const
    94105    {
    95106        ASSERT(isDefinite());
     
    106117    enum GridSpanType {Definite, Indefinite};
    107118
    108     GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition, GridSpanType type)
    109         : m_resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
    110         , m_resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
     119    GridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition, GridSpanType type)
     120        : m_resolvedInitialPosition(std::min(resolvedInitialPosition, kGridMaxTracks - 1))
     121        , m_resolvedFinalPosition(std::min(resolvedFinalPosition, kGridMaxTracks))
    111122        , m_type(type)
    112123    {
     
    114125    }
    115126
    116     GridResolvedPosition m_resolvedInitialPosition;
    117     GridResolvedPosition m_resolvedFinalPosition;
     127    unsigned m_resolvedInitialPosition;
     128    unsigned m_resolvedFinalPosition;
    118129    GridSpanType m_type;
    119130
  • trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp

    r196691 r197400  
    117117}
    118118
    119 static GridResolvedPosition resolveNamedGridLinePositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
     119static unsigned resolveNamedGridLinePositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
    120120{
    121121    ASSERT(!position.namedGridLine().isNull());
     
    138138}
    139139
    140 static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
    141 {
    142     if (!resolvedOppositePosition.toInt())
    143         return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     140static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(unsigned resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
     141{
     142    if (!resolvedOppositePosition)
     143        return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
    144144
    145145    unsigned firstLineBeforePositionIndex = 0;
    146     auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
     146    auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition);
    147147    if (firstLineBeforePosition != gridLines.end())
    148148        firstLineBeforePositionIndex = firstLineBeforePosition - gridLines.begin();
     
    150150    unsigned gridLineIndex = std::max<int>(0, firstLineBeforePositionIndex - position.spanPosition());
    151151
    152     GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]);
     152    unsigned resolvedGridLinePosition = gridLines[gridLineIndex];
    153153    if (resolvedGridLinePosition >= resolvedOppositePosition)
    154         resolvedGridLinePosition = resolvedOppositePosition.prev();
    155     return GridSpan::definiteGridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
    156 }
    157 
    158 static GridSpan resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
     154        resolvedGridLinePosition = resolvedOppositePosition - 1;
     155    return GridSpan::definiteGridSpan(std::min(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
     156}
     157
     158static GridSpan resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(unsigned resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
    159159{
    160160    ASSERT(gridLines.size());
     
    165165
    166166    unsigned gridLineIndex = std::min<unsigned>(gridLines.size() - 1, firstLineAfterOppositePositionIndex + position.spanPosition() - 1);
    167     GridResolvedPosition resolvedGridLinePosition = gridLines[gridLineIndex];
     167    unsigned resolvedGridLinePosition = gridLines[gridLineIndex];
    168168    if (resolvedGridLinePosition <= resolvedOppositePosition)
    169         resolvedGridLinePosition = resolvedOppositePosition.next();
     169        resolvedGridLinePosition = resolvedOppositePosition + 1;
    170170    return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
    171171}
    172172
    173 static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
     173static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, unsigned resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
    174174{
    175175    ASSERT(position.isSpan());
     
    184184    // See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
    185185    if (it == gridLinesNames.end()) {
    186         if (isStartSide(side) && resolvedOppositePosition.toInt())
    187             return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
    188         return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     186        if (isStartSide(side) && resolvedOppositePosition)
     187            return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
     188        return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
    189189    }
    190190
     
    195195}
    196196
    197 static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
     197static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, unsigned resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
    198198{
    199199    if (position.isAuto()) {
    200         if (isStartSide(side) && resolvedOppositePosition.toInt())
    201             return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
    202         return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     200        if (isStartSide(side) && resolvedOppositePosition)
     201            return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
     202        return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
    203203    }
    204204
     
    215215    unsigned positionOffset = position.spanPosition();
    216216    if (isStartSide(side)) {
    217         if (!resolvedOppositePosition.toInt())
    218             return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
    219 
    220         unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset);
     217        if (!resolvedOppositePosition)
     218            return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
     219
     220        unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition - positionOffset);
    221221        return GridSpan::definiteGridSpan(initialResolvedPosition, resolvedOppositePosition);
    222222    }
    223223
    224     return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
    225 }
    226 
    227 GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition)
     224    return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
     225}
     226
     227GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, unsigned resolvedInitialPosition)
    228228{
    229229    GridPosition initialPosition, finalPosition;
     
    234234    ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition());
    235235
    236     GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition.next();
     236    unsigned resolvedFinalPosition = resolvedInitialPosition + 1;
    237237
    238238    if (initialPosition.isSpan())
     
    244244}
    245245
    246 static GridResolvedPosition resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
     246static unsigned resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
    247247{
    248248    switch (position.type()) {
     
    295295        // 'auto' and span depend on the opposite position for resolution (e.g. grid-row: auto / 1 or grid-column: span 3 / "myHeader").
    296296        ASSERT_NOT_REACHED();
    297         return GridResolvedPosition(0);
     297        return 0;
    298298    }
    299299    ASSERT_NOT_REACHED();
    300     return GridResolvedPosition(0);
     300    return 0;
    301301}
    302302
     
    325325    }
    326326
    327     GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
    328     GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
     327    unsigned resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
     328    unsigned resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
    329329
    330330    if (resolvedInitialPosition > resolvedFinalPosition)
    331331        std::swap(resolvedInitialPosition, resolvedFinalPosition);
    332332    else if (resolvedInitialPosition == resolvedFinalPosition)
    333         resolvedFinalPosition = resolvedInitialPosition.next();
     333        resolvedFinalPosition = resolvedInitialPosition + 1;
    334334
    335335    return GridSpan::definiteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
  • trunk/Source/WebCore/rendering/style/GridResolvedPosition.h

    r196691 r197400  
    4747};
    4848
    49 // This class represents a line index into one of the dimensions of the grid array.
    50 // Wraps an unsigned integer just for the purpose of knowing what we manipulate in the grid code.
     49// Class with all the code related to grid items positions resolution.
     50// TODO(rego): Rename class to GridPositionsResolver.
    5151class GridResolvedPosition {
    5252public:
    53     GridResolvedPosition(unsigned position)
    54         : m_integerPosition(position)
    55     {
    56     }
    57 
    58     GridResolvedPosition& operator*()
    59     {
    60         return *this;
    61     }
    62 
    63     GridResolvedPosition& operator++()
    64     {
    65         m_integerPosition++;
    66         return *this;
    67     }
    68 
    69     bool operator==(const GridResolvedPosition& other) const
    70     {
    71         return m_integerPosition == other.m_integerPosition;
    72     }
    73 
    74     bool operator!=(const GridResolvedPosition& other) const
    75     {
    76         return m_integerPosition != other.m_integerPosition;
    77     }
    78 
    79     bool operator<(const GridResolvedPosition& other) const
    80     {
    81         return m_integerPosition < other.m_integerPosition;
    82     }
    83 
    84     bool operator>(const GridResolvedPosition& other) const
    85     {
    86         return m_integerPosition > other.m_integerPosition;
    87     }
    88 
    89     bool operator<=(const GridResolvedPosition& other) const
    90     {
    91         return m_integerPosition <= other.m_integerPosition;
    92     }
    93 
    94     bool operator>=(const GridResolvedPosition& other) const
    95     {
    96         return m_integerPosition >= other.m_integerPosition;
    97     }
    98 
    99     unsigned toInt() const
    100     {
    101         return m_integerPosition;
    102     }
    103 
    104     GridResolvedPosition next() const
    105     {
    106         return GridResolvedPosition(m_integerPosition + 1);
    107     }
    108 
    109     GridResolvedPosition prev() const
    110     {
    111         return m_integerPosition ? m_integerPosition - 1 : 0;
    112     }
    113 
    114     static GridSpan resolveGridPositionsFromAutoPlacementPosition(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, const GridResolvedPosition&);
     53    static GridSpan resolveGridPositionsFromAutoPlacementPosition(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, unsigned);
    11554    static GridSpan resolveGridPositionsFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection);
    11655    static unsigned explicitGridColumnCount(const RenderStyle&);
    11756    static unsigned explicitGridRowCount(const RenderStyle&);
    11857    static bool isNonExistentNamedLineOrArea(const String& lineName, const RenderStyle&, GridPositionSide);
    119 
    120 private:
    121     unsigned m_integerPosition;
    12258};
    12359
Note: See TracChangeset for help on using the changeset viewer.