Changeset 196691 in webkit


Ignore:
Timestamp:
Feb 17, 2016 3:45:30 AM (8 years ago)
Author:
Manuel Rego Casasnovas
Message:

[css-grid] GridSpan refactoring
​https://bugs.webkit.org/show_bug.cgi?id=153868

Reviewed by Sergio Villar Senin.

Add new enum to know if a GridSpan is definite or indefinite.
That way we don't need GridUnresolvedSpan class (which is removed).
We can always have two GridSpans in GridCoordinate,
if the position is "auto" the GridSpan will be marked as indefinite.
This will allow in a follow-up patch to avoid repeated calls
to methods that resolve positions.

Most operations in GridSpan are restricted to definite GridSpans (access
to positions, iterator, etc.). For indefinite GridSpans we only need to
know that they're indefinite, we shouldn't use the rest of the data.

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::GridIterator::nextEmptyGridArea):
(WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
(WebCore::RenderGrid::insertItemIntoGrid):
(WebCore::RenderGrid::placeItemsOnGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
(WebCore::RenderGrid::columnAxisOffsetForChild):
(WebCore::RenderGrid::rowAxisOffsetForChild):
(WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Deleted.
(WebCore::RenderGrid::autoPlacementMinorAxisDirection): Deleted.
(WebCore::RenderGrid::populateGridPositions): Deleted.

  • rendering/style/GridCoordinate.h:

(WebCore::GridSpan::definiteGridSpan):
(WebCore::GridSpan::indefiniteGridSpan):
(WebCore::GridSpan::operator==):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::resolvedInitialPosition):
(WebCore::GridSpan::resolvedFinalPosition):
(WebCore::GridSpan::begin):
(WebCore::GridSpan::end):
(WebCore::GridSpan::isDefinite):
(WebCore::GridSpan::GridSpan):
(WebCore::GridCoordinate::GridCoordinate):

  • rendering/style/GridResolvedPosition.cpp:

(WebCore::initialPositionSide):
(WebCore::finalPositionSide):
(WebCore::adjustGridPositionsFromStyle):
(WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
(WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
(WebCore::implicitNamedGridLineForSide): Deleted.
(WebCore::GridResolvedPosition::isNonExistentNamedLineOrArea): Deleted.
(WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
(WebCore::resolveGridPositionFromStyle): Deleted.

  • rendering/style/GridResolvedPosition.h:

(WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
(WebCore::GridResolvedPosition::operator*): Deleted.
(WebCore::GridResolvedPosition::operator++): Deleted.
(WebCore::GridResolvedPosition::operator==): Deleted.

Location:
trunk/Source/WebCore
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r196690 r196691  
     12016-02-17  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] GridSpan refactoring
     4        https://bugs.webkit.org/show_bug.cgi?id=153868
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        Add new enum to know if a GridSpan is definite or indefinite.
     9        That way we don't need GridUnresolvedSpan class (which is removed).
     10        We can always have two GridSpans in GridCoordinate,
     11        if the position is "auto" the GridSpan will be marked as indefinite.
     12        This will allow in a follow-up patch to avoid repeated calls
     13        to methods that resolve positions.
     14
     15        Most operations in GridSpan are restricted to definite GridSpans (access
     16        to positions, iterator, etc.). For indefinite GridSpans we only need to
     17        know that they're indefinite, we shouldn't use the rest of the data.
     18
     19        No new tests, no change of behavior.
     20
     21        * css/CSSGridTemplateAreasValue.cpp:
     22        (WebCore::stringForPosition):
     23        * css/CSSParser.cpp:
     24        (WebCore::CSSParser::parseGridTemplateAreasRow):
     25        * css/StyleBuilderConverter.h:
     26        (WebCore::StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea):
     27        * rendering/RenderGrid.cpp:
     28        (WebCore::RenderGrid::GridIterator::nextEmptyGridArea):
     29        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     30        (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
     31        (WebCore::RenderGrid::insertItemIntoGrid):
     32        (WebCore::RenderGrid::placeItemsOnGrid):
     33        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
     34        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
     35        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
     36        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
     37        (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
     38        (WebCore::RenderGrid::columnAxisOffsetForChild):
     39        (WebCore::RenderGrid::rowAxisOffsetForChild):
     40        (WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Deleted.
     41        (WebCore::RenderGrid::autoPlacementMinorAxisDirection): Deleted.
     42        (WebCore::RenderGrid::populateGridPositions): Deleted.
     43        * rendering/style/GridCoordinate.h:
     44        (WebCore::GridSpan::definiteGridSpan):
     45        (WebCore::GridSpan::indefiniteGridSpan):
     46        (WebCore::GridSpan::operator==):
     47        (WebCore::GridSpan::integerSpan):
     48        (WebCore::GridSpan::resolvedInitialPosition):
     49        (WebCore::GridSpan::resolvedFinalPosition):
     50        (WebCore::GridSpan::begin):
     51        (WebCore::GridSpan::end):
     52        (WebCore::GridSpan::isDefinite):
     53        (WebCore::GridSpan::GridSpan):
     54        (WebCore::GridCoordinate::GridCoordinate):
     55        * rendering/style/GridResolvedPosition.cpp:
     56        (WebCore::initialPositionSide):
     57        (WebCore::finalPositionSide):
     58        (WebCore::adjustGridPositionsFromStyle):
     59        (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
     60        (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
     61        (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
     62        (WebCore::resolveGridPositionAgainstOppositePosition):
     63        (WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
     64        (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
     65        (WebCore::implicitNamedGridLineForSide): Deleted.
     66        (WebCore::GridResolvedPosition::isNonExistentNamedLineOrArea): Deleted.
     67        (WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
     68        (WebCore::resolveGridPositionFromStyle): Deleted.
     69        * rendering/style/GridResolvedPosition.h:
     70        (WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
     71        (WebCore::GridResolvedPosition::operator*): Deleted.
     72        (WebCore::GridResolvedPosition::operator++): Deleted.
     73        (WebCore::GridResolvedPosition::operator==): Deleted.
     74
    1752016-02-17  Chris Dumez  <cdumez@apple.com>
    276

  • trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp

    r195808 r196691  
    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().toInt() && row < coordinate.rows.resolvedFinalPosition().toInt())
    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().toInt() && column < coordinate.columns.resolvedFinalPosition().toInt() && candidates.contains(it.key))
    6565            return it.key;
    6666    }

  • trunk/Source/WebCore/css/CSSParser.cpp

    r196075 r196691  
    62186218        auto gridAreaIterator = gridAreaMap.find(gridAreaName);
    62196219        if (gridAreaIterator == gridAreaMap.end())
    6220             gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount + 1), GridSpan(currentColumn, lookAheadColumn)));
     6220            gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan::definiteGridSpan(rowCount, rowCount + 1), GridSpan::definiteGridSpan(currentColumn, lookAheadColumn)));
    62216221        else {
    62226222            GridCoordinate& gridCoordinate = gridAreaIterator->value;
    … …  
    62246224            // The following checks test that the grid area is a single filled-in rectangle.
    62256225            // 1. The new row is adjacent to the previously parsed row.
    6226             if (rowCount != gridCoordinate.rows.resolvedFinalPosition.toInt())
     6226            if (rowCount != gridCoordinate.rows.resolvedFinalPosition().toInt())
    62276227                return false;
    62286228
    62296229            // 2. The new area starts at the same position as the previously parsed area.
    6230             if (currentColumn != gridCoordinate.columns.resolvedInitialPosition.toInt())
     6230            if (currentColumn != gridCoordinate.columns.resolvedInitialPosition().toInt())
    62316231                return false;
    62326232
    62336233            // 3. The new area ends at the same position as the previously parsed area.
    6234             if (lookAheadColumn != gridCoordinate.columns.resolvedFinalPosition.toInt())
     6234            if (lookAheadColumn != gridCoordinate.columns.resolvedFinalPosition().toInt())
    62356235                return false;
    62366236
    6237             ++gridCoordinate.rows.resolvedFinalPosition;
     6237            gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition().next());
    62386238        }
    62396239        currentColumn = lookAheadColumn - 1;

  • trunk/Source/WebCore/css/StyleBuilderConverter.h

    r196075 r196691  
    887887        {
    888888            auto& startVector = namedGridLines.add(area.key + "-start", Vector<unsigned>()).iterator->value;
    889             startVector.append(areaSpan.resolvedInitialPosition.toInt());
     889            startVector.append(areaSpan.resolvedInitialPosition().toInt());
    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().toInt());
    895895            std::sort(endVector.begin(), endVector.end());
    896896        }

  • trunk/Source/WebCore/rendering/RenderGrid.cpp

    r195808 r196691  
    191191        for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex) {
    192192            if (isEmptyAreaEnough(rowSpan, columnSpan)) {
    193                 std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan(m_columnIndex, m_columnIndex + columnSpan));
     193                std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan::definiteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::definiteGridSpan(m_columnIndex, m_columnIndex + columnSpan));
    194194                // Advance the iterator to avoid an infinite loop where we would return the same grid area over and over.
    195195                ++varyingTrackIndex;
    … …  
    567567    double flexFraction = 0;
    568568    if (hasDefiniteFreeSpace)
    569         flexFraction = findFlexFactorUnitSize(tracks, GridSpan(0, tracks.size()), direction, initialFreeSpace.value());
     569        flexFraction = findFlexFactorUnitSize(tracks, GridSpan::definiteGridSpan(0, tracks.size()), direction, initialFreeSpace.value());
    570570    else {
    571571        for (const auto& trackIndex : flexibleSizedTracksIndex)
    … …  
    578578
    579579                // Do not include already processed items.
    580                 if (i > 0 && span.resolvedInitialPosition.toInt() <= flexibleSizedTracksIndex[i - 1])
     580                if (i > 0 && span.resolvedInitialPosition().toInt() <= flexibleSizedTracksIndex[i - 1])
    581581                    continue;
    582582
    … …  
    866866void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
    867867{
    868     const GridResolvedPosition trackPosition = span.resolvedInitialPosition;
     868    const GridResolvedPosition trackPosition = span.resolvedInitialPosition();
    869869    GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
    870870
    … …  
    11391139void RenderGrid::insertItemIntoGrid(RenderBox& child, const GridCoordinate& coordinate)
    11401140{
    1141     ensureGridSize(coordinate.rows.resolvedFinalPosition.toInt(), coordinate.columns.resolvedFinalPosition.toInt());
     1141    ensureGridSize(coordinate.rows.resolvedFinalPosition().toInt(), coordinate.columns.resolvedFinalPosition().toInt());
    11421142
    11431143    for (auto& row : coordinate.rows) {
    … …  
    11611161            continue;
    11621162
    1163         auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
    1164         auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
    1165 
    1166         if (unresolvedRowPositions.requiresAutoPlacement() || unresolvedColumnPositions.requiresAutoPlacement()) {
    1167 
     1163        GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
     1164        GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
     1165
     1166        if (!rowPositions.isDefinite() || !columnPositions.isDefinite()) {
    11681167            bool majorAxisDirectionIsForColumns = autoPlacementMajorAxisDirection() == ForColumns;
    1169             if ((majorAxisDirectionIsForColumns && unresolvedColumnPositions.requiresAutoPlacement())
    1170                 || (!majorAxisDirectionIsForColumns && unresolvedRowPositions.requiresAutoPlacement()))
     1168            if ((majorAxisDirectionIsForColumns && !columnPositions.isDefinite())
     1169                || (!majorAxisDirectionIsForColumns && !rowPositions.isDefinite()))
    11711170                autoMajorAxisAutoGridItems.append(child);
    11721171            else
    … …  
    11741173            continue;
    11751174        }
    1176         GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
    1177         GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
    11781175        insertItemIntoGrid(*child, GridCoordinate(rowPositions, columnPositions));
    11791176    }
    … …  
    11981195        populator.collectChild(*child);
    11991196
    1200         auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
    1201         if (!unresolvedRowPositions.requiresAutoPlacement()) {
    1202             GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
    1203             maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition.toInt());
     1197        GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
     1198        if (rowPositions.isDefinite()) {
     1199            maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition().toInt());
    12041200        } else {
    12051201            // Grow the grid for items with a definite row span, getting the largest such span.
    12061202            GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForRows, GridResolvedPosition(0));
    1207             maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition.toInt());
    1208         }
    1209 
    1210         auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
    1211         if (!unresolvedColumnPositions.requiresAutoPlacement()) {
    1212             GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
    1213             maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition.toInt());
     1203            maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition().toInt());
     1204        }
     1205
     1206        GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
     1207        if (columnPositions.isDefinite()) {
     1208            maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition().toInt());
    12141209        } else {
    12151210            // Grow the grid for items with a definite column span, getting the largest such span.
    12161211            GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForColumns, GridResolvedPosition(0));
    1217             maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition.toInt());
     1212            maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition().toInt());
    12181213        }
    12191214    }
    … …  
    12431238
    12441239    for (auto& autoGridItem : autoGridItems) {
    1245         auto unresolvedMajorAxisPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *autoGridItem, autoPlacementMajorAxisDirection());
    1246         ASSERT(!unresolvedMajorAxisPositions.requiresAutoPlacement());
    1247         GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedMajorAxisPositions, style());
     1240        GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *autoGridItem, autoPlacementMajorAxisDirection());
     1241        ASSERT(majorAxisPositions.isDefinite());
    12481242        GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *autoGridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
    1249         unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition.toInt();
    1250 
    1251         GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition.toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
     1243        unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition().toInt();
     1244
     1245        GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition().toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
    12521246        std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisPositions.integerSpan());
    12531247        if (!emptyGridArea)
    … …  
    12561250
    12571251        if (!isGridAutoFlowDense)
    1258             minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition.toInt() : emptyGridArea->columns.resolvedInitialPosition.toInt());
     1252            minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition().toInt() : emptyGridArea->columns.resolvedInitialPosition().toInt());
    12591253    }
    12601254}
    … …  
    12771271void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
    12781272{
    1279     ASSERT(GridResolvedPosition::unresolvedSpanFromStyle(style(), gridItem, autoPlacementMajorAxisDirection()).requiresAutoPlacement());
     1273    ASSERT(!GridResolvedPosition::resolveGridPositionsFromStyle(style(), gridItem, autoPlacementMajorAxisDirection()).isDefinite());
    12801274    GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMajorAxisDirection(), GridResolvedPosition(0));
    12811275
    … …  
    12851279
    12861280    std::unique_ptr<GridCoordinate> emptyGridArea;
    1287     auto unresolvedMinorAxisPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), gridItem, autoPlacementMinorAxisDirection());
    1288     if (!unresolvedMinorAxisPositions.requiresAutoPlacement()) {
    1289         GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedMinorAxisPositions, style());
    1290 
     1281    GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), gridItem, autoPlacementMinorAxisDirection());
     1282    if (minorAxisPositions.isDefinite()) {
    12911283        // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
    1292         if (minorAxisPositions.resolvedInitialPosition.toInt() < minorAxisAutoPlacementCursor)
     1284        if (minorAxisPositions.resolvedInitialPosition().toInt() < minorAxisAutoPlacementCursor)
    12931285            majorAxisAutoPlacementCursor++;
    12941286
    12951287        if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
    1296             GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition.toInt(), majorAxisAutoPlacementCursor);
     1288            GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition().toInt(), majorAxisAutoPlacementCursor);
    12971289            emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisPositions.integerSpan());
    12981290        }
    … …  
    13091301            if (emptyGridArea) {
    13101302                // Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
    1311                 GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition : emptyGridArea->rows.resolvedFinalPosition;
     1303                GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
    13121304                const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
    13131305                if (minorAxisFinalPositionIndex.toInt() <= endOfMinorAxis)
    … …  
    13281320
    13291321    insertItemIntoGrid(gridItem, *emptyGridArea);
    1330     autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition.toInt();
    1331     autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition.toInt();
     1322    autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition().toInt();
     1323    autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition().toInt();
    13321324}
    13331325
    … …  
    14611453    ASSERT(child.isHorizontalWritingMode() == isHorizontalWritingMode());
    14621454
    1463     auto unresolvedPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), child, direction);
    1464     if (unresolvedPositions.requiresAutoPlacement()) {
     1455    GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), child, direction);
     1456    if (!positions.isDefinite()) {
    14651457        offset = LayoutUnit();
    14661458        breadth = (direction == ForColumns) ? clientLogicalWidth() : clientLogicalHeight();
    … …  
    14721464    size_t lastTrackIndex = (direction == ForColumns ? gridColumnCount() : gridRowCount()) - 1;
    14731465
    1474     GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedPositions, style());
    14751466    bool startIsAuto = startPosition.isAuto()
    14761467        || (startPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
    1477         || (positions.resolvedInitialPosition.toInt() > lastTrackIndex);
     1468        || (positions.resolvedInitialPosition().toInt() > lastTrackIndex);
    14781469    bool endIsAuto = endPosition.isAuto()
    14791470        || (endPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
    1480         || (positions.resolvedFinalPosition.prev().toInt() > lastTrackIndex);
     1471        || (positions.resolvedFinalPosition().prev().toInt() > lastTrackIndex);
    14811472
    14821473    GridResolvedPosition firstPosition = GridResolvedPosition(0);
    1483     GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition;
     1474    GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
    14841475    GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
    1485     GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition.prev();
     1476    GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition().prev();
    14861477
    14871478    // Positioned children do not grow the grid, so we need to clamp the positions to avoid ending up outside of it.
    … …  
    15431534    const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
    15441535
    1545     LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition.toInt()];
    1546     LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition.prev().toInt()];
     1536    LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition().toInt()];
     1537    LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition().prev().toInt()];
    15471538
    15481539    // Track Positions vector stores the 'start' grid line of each track, so we have to add last track's baseSize.
    1549     return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition.prev().toInt()].baseSize();
     1540    return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition().prev().toInt()].baseSize();
    15501541}
    15511542
    … …  
    18261817{
    18271818    const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
    1828     unsigned childStartLine = rowsSpan.resolvedInitialPosition.toInt();
     1819    unsigned childStartLine = rowsSpan.resolvedInitialPosition().toInt();
    18291820    LayoutUnit startOfRow = m_rowPositions[childStartLine];
    18301821    LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
    … …  
    18371828    case GridAxisEnd:
    18381829    case GridAxisCenter: {
    1839         unsigned childEndLine = rowsSpan.resolvedFinalPosition.toInt();
     1830        unsigned childEndLine = rowsSpan.resolvedFinalPosition().toInt();
    18401831        LayoutUnit endOfRow = m_rowPositions[childEndLine];
    18411832        // m_rowPositions include gutters so we need to substract them to get the actual end position for a given
    … …  
    18601851{
    18611852    const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
    1862     unsigned childStartLine = columnsSpan.resolvedInitialPosition.toInt();
     1853    unsigned childStartLine = columnsSpan.resolvedInitialPosition().toInt();
    18631854    LayoutUnit startOfColumn = m_columnPositions[childStartLine];
    18641855    LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
    … …  
    18711862    case GridAxisEnd:
    18721863    case GridAxisCenter: {
    1873         unsigned childEndLine = columnsSpan.resolvedFinalPosition.toInt();
     1864        unsigned childEndLine = columnsSpan.resolvedFinalPosition().toInt();
    18741865        LayoutUnit endOfColumn = m_columnPositions[childEndLine];
    18751866        // 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

    r195808 r196691  
    4949class GridSpan {
    5050public:
    51     GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
    52         : resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
    53         , resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
     51
     52    static GridSpan definiteGridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
    5453    {
    55         ASSERT(resolvedInitialPosition < resolvedFinalPosition);
     54        return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
     55    }
     56
     57    static GridSpan indefiniteGridSpan()
     58    {
     59        return GridSpan(0, 1, Indefinite);
    5660    }
    5761
    5862    bool operator==(const GridSpan& o) const
    5963    {
    60         return resolvedInitialPosition == o.resolvedInitialPosition && resolvedFinalPosition == o.resolvedFinalPosition;
     64        return m_type == o.m_type && m_resolvedInitialPosition == o.m_resolvedInitialPosition && m_resolvedFinalPosition == o.m_resolvedFinalPosition;
    6165    }
    6266
    6367    unsigned integerSpan() const
    6468    {
    65         return resolvedFinalPosition.toInt() - resolvedInitialPosition.toInt();
     69        ASSERT(isDefinite());
     70        return m_resolvedFinalPosition.toInt() - m_resolvedInitialPosition.toInt();
    6671    }
    6772
    68     GridResolvedPosition resolvedInitialPosition;
    69     GridResolvedPosition resolvedFinalPosition;
     73    const GridResolvedPosition& resolvedInitialPosition() const
     74    {
     75        ASSERT(isDefinite());
     76        return m_resolvedInitialPosition;
     77    }
     78
     79    const GridResolvedPosition& resolvedFinalPosition() const
     80    {
     81        ASSERT(isDefinite());
     82        return m_resolvedFinalPosition;
     83    }
    7084
    7185    typedef GridResolvedPosition iterator;
    … …  
    7387    iterator begin() const
    7488    {
    75         return resolvedInitialPosition;
     89        ASSERT(isDefinite());
     90        return m_resolvedInitialPosition;
    7691    }
    7792
    7893    iterator end() const
    7994    {
    80         return resolvedFinalPosition;
     95        ASSERT(isDefinite());
     96        return m_resolvedFinalPosition;
    8197    }
     98
     99    bool isDefinite() const
     100    {
     101        return m_type == Definite;
     102    }
     103
     104private:
     105
     106    enum GridSpanType {Definite, Indefinite};
     107
     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))
     111        , m_type(type)
     112    {
     113        ASSERT(resolvedInitialPosition < resolvedFinalPosition);
     114    }
     115
     116    GridResolvedPosition m_resolvedInitialPosition;
     117    GridResolvedPosition m_resolvedFinalPosition;
     118    GridSpanType m_type;
     119
     120
    82121};
    83122
    … …  
    87126    // HashMap requires a default constuctor.
    88127    GridCoordinate()
    89         : columns(0, 1)
    90         , rows(0, 1)
     128        : columns(GridSpan::indefiniteGridSpan())
     129        , rows(GridSpan::indefiniteGridSpan())
    91130    {
    92131    }

  • trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp

    r195808 r196691  
    4949}
    5050
     51static inline GridPositionSide initialPositionSide(GridTrackSizingDirection direction)
     52{
     53    return direction == ForColumns ? ColumnStartSide : RowStartSide;
     54}
     55
     56static inline GridPositionSide finalPositionSide(GridTrackSizingDirection direction)
     57{
     58    return direction == ForColumns ? ColumnEndSide : RowEndSide;
     59}
     60
    5161static const NamedGridLinesMap& gridLinesForSide(const RenderStyle& style, GridPositionSide side)
    5262{
    … …  
    6575}
    6676
    67 bool GridUnresolvedSpan::requiresAutoPlacement() const
    68 {
    69     return m_initialPosition.shouldBeResolvedAgainstOppositePosition() && m_finalPosition.shouldBeResolvedAgainstOppositePosition();
    70 }
    71 
    72 void GridUnresolvedSpan::adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle)
    73 {
    74     ASSERT(isColumnSide(m_initialPositionSide) == isColumnSide(m_finalPositionSide));
     77static void adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, GridPosition& initialPosition, GridPosition& finalPosition)
     78{
     79    bool isForColumns = direction == ForColumns;
     80    initialPosition = isForColumns ? gridItem.style().gridItemColumnStart() : gridItem.style().gridItemRowStart();
     81    finalPosition = isForColumns ? gridItem.style().gridItemColumnEnd() : gridItem.style().gridItemRowEnd();
    7582
    7683    // We must handle the placement error handling code here instead of in the StyleAdjuster because we don't want to
    7784    // overwrite the specified values.
    78     if (m_initialPosition.isSpan() && m_finalPosition.isSpan())
    79         m_finalPosition.setAutoPosition();
     85    if (initialPosition.isSpan() && finalPosition.isSpan())
     86        finalPosition.setAutoPosition();
    8087
    8188    // Try to early detect the case of non existing named grid lines. This way we could assume later that
    8289    // GridResolvedPosition::resolveGrisPositionFromStyle() won't require the autoplacement to run, i.e., it'll always return a
    8390    // valid resolved position.
    84     if (m_initialPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_initialPosition.namedGridLine(), gridContainerStyle, m_initialPositionSide))
    85         m_initialPosition.setAutoPosition();
    86 
    87     if (m_finalPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_finalPosition.namedGridLine(), gridContainerStyle, m_finalPositionSide))
    88         m_finalPosition.setAutoPosition();
     91    if (initialPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(initialPosition.namedGridLine(), gridContainerStyle, initialPositionSide(direction)))
     92        initialPosition.setAutoPosition();
     93
     94    if (finalPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(finalPosition.namedGridLine(), gridContainerStyle, finalPositionSide(direction)))
     95        finalPosition.setAutoPosition();
    8996
    9097    // If the grid item has an automatic position and a grid span for a named line in a given dimension, instead treat the grid span as one.
    91     if (m_initialPosition.isAuto() && m_finalPosition.isSpan() && !m_finalPosition.namedGridLine().isNull())
    92         m_finalPosition.setSpanPosition(1, String());
    93     if (m_finalPosition.isAuto() && m_initialPosition.isSpan() && !m_initialPosition.namedGridLine().isNull())
    94         m_initialPosition.setSpanPosition(1, String());
     98    if (initialPosition.isAuto() && finalPosition.isSpan() && !finalPosition.namedGridLine().isNull())
     99        finalPosition.setSpanPosition(1, String());
     100    if (finalPosition.isAuto() && initialPosition.isSpan() && !initialPosition.namedGridLine().isNull())
     101        initialPosition.setSpanPosition(1, String());
    95102}
    96103
    … …  
    134141{
    135142    if (!resolvedOppositePosition.toInt())
    136         return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     143        return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
    137144
    138145    unsigned firstLineBeforePositionIndex = 0;
    … …  
    146153    if (resolvedGridLinePosition >= resolvedOppositePosition)
    147154        resolvedGridLinePosition = resolvedOppositePosition.prev();
    148     return GridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
     155    return GridSpan::definiteGridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
    149156}
    150157
    … …  
    161168    if (resolvedGridLinePosition <= resolvedOppositePosition)
    162169        resolvedGridLinePosition = resolvedOppositePosition.next();
    163     return GridSpan(resolvedOppositePosition, resolvedGridLinePosition);
     170    return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
    164171}
    165172
    … …  
    178185    if (it == gridLinesNames.end()) {
    179186        if (isStartSide(side) && resolvedOppositePosition.toInt())
    180             return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
    181         return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     187            return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
     188        return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
    182189    }
    183190
    … …  
    192199    if (position.isAuto()) {
    193200        if (isStartSide(side) && resolvedOppositePosition.toInt())
    194             return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
    195         return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     201            return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
     202        return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
    196203    }
    197204
    … …  
    209216    if (isStartSide(side)) {
    210217        if (!resolvedOppositePosition.toInt())
    211             return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     218            return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
    212219
    213220        unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset);
    214         return GridSpan(initialResolvedPosition, resolvedOppositePosition);
    215     }
    216 
    217     return GridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
     221        return GridSpan::definiteGridSpan(initialResolvedPosition, resolvedOppositePosition);
     222    }
     223
     224    return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
    218225}
    219226
    220227GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition)
    221228{
    222     GridUnresolvedSpan unresolvedSpan = unresolvedSpanFromStyle(gridContainerStyle, gridItem, direction);
    223 
     229    GridPosition initialPosition, finalPosition;
     230    adjustGridPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
     231
     232    GridPositionSide finalSide = finalPositionSide(direction);
    224233    // This method will only be used when both positions need to be resolved against the opposite one.
    225     ASSERT(unresolvedSpan.requiresAutoPlacement());
     234    ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition());
    226235
    227236    GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition.next();
    228237
    229     if (unresolvedSpan.initialPosition().isSpan())
    230         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, unresolvedSpan.initialPosition(), unresolvedSpan.finalPositionSide());
    231     if (unresolvedSpan.finalPosition().isSpan())
    232         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
    233 
    234     return GridSpan(resolvedInitialPosition, resolvedFinalPosition);
     238    if (initialPosition.isSpan())
     239        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, initialPosition, finalSide);
     240    if (finalPosition.isSpan())
     241        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, finalPosition, finalSide);
     242
     243    return GridSpan::definiteGridSpan(resolvedInitialPosition, resolvedFinalPosition);
    235244}
    236245
    … …  
    292301}
    293302
    294 GridUnresolvedSpan GridResolvedPosition::unresolvedSpanFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
    295 {
    296     GridPosition initialPosition = (direction == ForColumns) ? gridItem.style().gridItemColumnStart() : gridItem.style().gridItemRowStart();
    297     auto initialPositionSide = (direction == ForColumns) ? ColumnStartSide : RowStartSide;
    298     GridPosition finalPosition = (direction == ForColumns) ? gridItem.style().gridItemColumnEnd() : gridItem.style().gridItemRowEnd();
    299     auto finalPositionSide = (direction == ForColumns) ? ColumnEndSide : RowEndSide;
    300 
    301     GridUnresolvedSpan unresolvedSpan(initialPosition, initialPositionSide, finalPosition, finalPositionSide);
    302     unresolvedSpan.adjustGridPositionsFromStyle(gridContainerStyle);
    303 
    304     return unresolvedSpan;
    305 }
    306 
    307 GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const GridUnresolvedSpan& unresolvedSpan, const RenderStyle& gridContainerStyle)
    308 {
    309     ASSERT(!unresolvedSpan.requiresAutoPlacement());
    310 
    311     // We must create the GridSpan using finalPosition.prev() because GridSpan stores cell indexes and
    312     // an item finishing on the N-th line belongs to the N-1-th cell.
    313 
    314     if (unresolvedSpan.initialPosition().shouldBeResolvedAgainstOppositePosition()) {
     303GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
     304{
     305    GridPosition initialPosition, finalPosition;
     306    adjustGridPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
     307
     308    GridPositionSide initialSide = initialPositionSide(direction);
     309    GridPositionSide finalSide = finalPositionSide(direction);
     310
     311    // We can't get our grid positions without running the auto placement algorithm.
     312    if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition())
     313        return GridSpan::indefiniteGridSpan();
     314
     315    if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
    315316        // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
    316         auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
    317         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
    318     }
    319 
    320     if (unresolvedSpan.finalPosition().shouldBeResolvedAgainstOppositePosition()) {
     317        auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
     318        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
     319    }
     320
     321    if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
    321322        // Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
    322         auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
    323         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
    324     }
    325 
    326     GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
    327     GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
     323        auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
     324        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
     325    }
     326
     327    GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
     328    GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
    328329
    329330    if (resolvedInitialPosition > resolvedFinalPosition)
    … …  
    332333        resolvedFinalPosition = resolvedInitialPosition.next();
    333334
    334     return GridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
     335    return GridSpan::definiteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
    335336}
    336337

  • trunk/Source/WebCore/rendering/style/GridResolvedPosition.h

    r195808 r196691  
    4545    ForColumns,
    4646    ForRows
    47 };
    48 
    49 class GridUnresolvedSpan {
    50 public:
    51     GridUnresolvedSpan(GridPosition initialPosition, GridPositionSide initialPositionSide, GridPosition finalPosition, GridPositionSide finalPositionSide)
    52         : m_initialPosition(initialPosition)
    53         , m_finalPosition(finalPosition)
    54         , m_initialPositionSide(initialPositionSide)
    55         , m_finalPositionSide(finalPositionSide)
    56     {
    57     }
    58 
    59     const GridPosition& initialPosition() const { return m_initialPosition; }
    60     const GridPosition& finalPosition() const { return m_finalPosition; }
    61     GridPositionSide initialPositionSide() const { return m_initialPositionSide; }
    62     GridPositionSide finalPositionSide() const { return m_finalPositionSide; }
    63 
    64     bool requiresAutoPlacement() const;
    65     void adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle);
    66 
    67 private:
    68     GridPosition m_initialPosition;
    69     GridPosition m_finalPosition;
    70     GridPositionSide m_initialPositionSide;
    71     GridPositionSide m_finalPositionSide;
    7247};
    7348
    … …  
    138113
    139114    static GridSpan resolveGridPositionsFromAutoPlacementPosition(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, const GridResolvedPosition&);
    140     static GridSpan resolveGridPositionsFromStyle(const GridUnresolvedSpan&, const RenderStyle&);
    141     static GridUnresolvedSpan unresolvedSpanFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection);
     115    static GridSpan resolveGridPositionsFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection);
    142116    static unsigned explicitGridColumnCount(const RenderStyle&);
    143117    static unsigned explicitGridRowCount(const RenderStyle&);
Note: See TracChangeset for help on using the changeset viewer.