Changeset 195808 in webkit


Ignore:
Timestamp:
Jan 29, 2016 1:22:28 AM (8 years ago)
Author:
Manuel Rego Casasnovas
Message:

[css-grid] Store lines instead of tracks in GridResolvedPosition
​https://bugs.webkit.org/show_bug.cgi?id=153592

Reviewed by Sergio Villar Senin.

Due to the new feature that allows to create implicit tracks before the
explicit ones, we will need to use lines instead of tracks in the
code to be able to implement it properly.

This is just a first simple patch using lines instead of tracks in
GridResolvedPosition. It modifies the code that was using it, as it was
considering that the resolvedFinalPosition was a track index and
not a line index.

So if we've an item positioned like:

grid-column: 2 / 5;
grid-row: 1 / span 2;

Before we were storing this information on the GridSpan:

  • columns:
    • resolvedInitialPosition: 1
    • resolvedFinalPosition: 3
  • rows:
    • resolvedInitialPosition: 0
    • resolvedFinalPosition: 1

And now we're storing:

  • columns:
    • resolvedInitialPosition: 1
    • resolvedFinalPosition: 4
  • rows:
    • resolvedInitialPosition: 0
    • resolvedFinalPosition: 2

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::ensureGridSize):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
(WebCore::RenderGrid::columnAxisOffsetForChild):
(WebCore::RenderGrid::rowAxisOffsetForChild):

  • rendering/RenderGrid.h:
  • rendering/style/GridCoordinate.h:

(WebCore::GridSpan::GridSpan):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::end):
(WebCore::GridCoordinate::GridCoordinate):

  • rendering/style/GridResolvedPosition.cpp:

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

  • rendering/style/GridResolvedPosition.h:
Location:
trunk/Source/WebCore
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r195801 r195808  
     12016-01-29  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] Store lines instead of tracks in GridResolvedPosition
     4        https://bugs.webkit.org/show_bug.cgi?id=153592
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        Due to the new feature that allows to create implicit tracks before the
     9        explicit ones, we will need to use lines instead of tracks in the
     10        code to be able to implement it properly.
     11
     12        This is just a first simple patch using lines instead of tracks in
     13        GridResolvedPosition. It modifies the code that was using it, as it was
     14        considering that the resolvedFinalPosition was a track index and
     15        not a line index.
     16
     17        So if we've an item positioned like:
     18          grid-column: 2 / 5;
     19          grid-row: 1 / span 2;
     20
     21        Before we were storing this information on the GridSpan:
     22        * columns:
     23          * resolvedInitialPosition: 1
     24          * resolvedFinalPosition:  3
     25        * rows:
     26          * resolvedInitialPosition: 0
     27          * resolvedFinalPosition:  1
     28
     29        And now we're storing:
     30        * columns:
     31          * resolvedInitialPosition: 1
     32          * resolvedFinalPosition:  4
     33        * rows:
     34          * resolvedInitialPosition: 0
     35          * resolvedFinalPosition:  2
     36
     37        No new tests, no change of behavior.
     38
     39        * css/CSSGridTemplateAreasValue.cpp:
     40        (WebCore::stringForPosition):
     41        * css/CSSParser.cpp:
     42        (WebCore::CSSParser::parseGridTemplateAreasRow):
     43        * css/StyleBuilderConverter.h:
     44        (WebCore::StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea):
     45        * rendering/RenderGrid.cpp:
     46        (WebCore::RenderGrid::GridIterator::nextEmptyGridArea):
     47        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     48        (WebCore::RenderGrid::ensureGridSize):
     49        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
     50        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
     51        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
     52        (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
     53        (WebCore::RenderGrid::columnAxisOffsetForChild):
     54        (WebCore::RenderGrid::rowAxisOffsetForChild):
     55        * rendering/RenderGrid.h:
     56        * rendering/style/GridCoordinate.h:
     57        (WebCore::GridSpan::GridSpan):
     58        (WebCore::GridSpan::integerSpan):
     59        (WebCore::GridSpan::end):
     60        (WebCore::GridCoordinate::GridCoordinate):
     61        * rendering/style/GridResolvedPosition.cpp:
     62        (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
     63        (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
     64        (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
     65        (WebCore::resolveGridPositionAgainstOppositePosition):
     66        (WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
     67        (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
     68        (WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
     69        * rendering/style/GridResolvedPosition.h:
     70
    1712016-01-28  Brady Eidson  <beidson@apple.com>
    272

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

    r169934 r195808  
    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

    r195743 r195808  
    61966196        // We handle several grid areas with the same name at once to simplify the validation code.
    61976197        unsigned lookAheadColumn;
    6198         for (lookAheadColumn = currentColumn; lookAheadColumn < columnCount - 1; ++lookAheadColumn) {
    6199             if (columnNames[lookAheadColumn + 1] != gridAreaName)
     6198        for (lookAheadColumn = currentColumn + 1; lookAheadColumn < columnCount; ++lookAheadColumn) {
     6199            if (columnNames[lookAheadColumn] != gridAreaName)
    62006200                break;
    62016201        }
    … …  
    62036203        auto gridAreaIterator = gridAreaMap.find(gridAreaName);
    62046204        if (gridAreaIterator == gridAreaMap.end())
    6205             gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount), GridSpan(currentColumn, lookAheadColumn)));
     6205            gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount + 1), GridSpan(currentColumn, lookAheadColumn)));
    62066206        else {
    62076207            GridCoordinate& gridCoordinate = gridAreaIterator->value;
    … …  
    62096209            // The following checks test that the grid area is a single filled-in rectangle.
    62106210            // 1. The new row is adjacent to the previously parsed row.
    6211             if (rowCount != gridCoordinate.rows.resolvedFinalPosition.next().toInt())
     6211            if (rowCount != gridCoordinate.rows.resolvedFinalPosition.toInt())
    62126212                return false;
    62136213
    … …  
    62226222            ++gridCoordinate.rows.resolvedFinalPosition;
    62236223        }
    6224         currentColumn = lookAheadColumn;
     6224        currentColumn = lookAheadColumn - 1;
    62256225    }
    62266226

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

    r195452 r195808  
    881881        {
    882882            auto& endVector = namedGridLines.add(area.key + "-end", Vector<unsigned>()).iterator->value;
    883             endVector.append(areaSpan.resolvedFinalPosition.next().toInt());
     883            endVector.append(areaSpan.resolvedFinalPosition.toInt());
    884884            std::sort(endVector.begin(), endVector.end());
    885885        }

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

    r194496 r195808  
    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 - 1), GridSpan(m_columnIndex, m_columnIndex + columnSpan - 1));
     193                std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan(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() - 1), direction, initialFreeSpace.value());
     569        flexFraction = findFlexFactorUnitSize(tracks, GridSpan(0, tracks.size()), direction, initialFreeSpace.value());
    570570    else {
    571571        for (const auto& trackIndex : flexibleSizedTracksIndex)
    … …  
    11221122#endif
    11231123
    1124 void RenderGrid::ensureGridSize(unsigned maximumRowIndex, unsigned maximumColumnIndex)
     1124void RenderGrid::ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize)
    11251125{
    11261126    const unsigned oldRowCount = gridRowCount();
    1127     if (maximumRowIndex >= oldRowCount) {
    1128         m_grid.grow(maximumRowIndex + 1);
     1127    if (maximumRowSize > oldRowCount) {
     1128        m_grid.grow(maximumRowSize);
    11291129        for (unsigned row = oldRowCount; row < gridRowCount(); ++row)
    11301130            m_grid[row].grow(gridColumnCount());
    11311131    }
    11321132
    1133     if (maximumColumnIndex >= gridColumnCount()) {
     1133    if (maximumColumnSize > gridColumnCount()) {
    11341134        for (unsigned row = 0; row < gridRowCount(); ++row)
    1135             m_grid[row].grow(maximumColumnIndex + 1);
     1135            m_grid[row].grow(maximumColumnSize);
    11361136    }
    11371137}
    … …  
    12011201        if (!unresolvedRowPositions.requiresAutoPlacement()) {
    12021202            GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
    1203             maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition.next().toInt());
     1203            maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition.toInt());
    12041204        } else {
    12051205            // Grow the grid for items with a definite row span, getting the largest such span.
    12061206            GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForRows, GridResolvedPosition(0));
    1207             maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition.next().toInt());
     1207            maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition.toInt());
    12081208        }
    12091209
    … …  
    12111211        if (!unresolvedColumnPositions.requiresAutoPlacement()) {
    12121212            GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
    1213             maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition.next().toInt());
     1213            maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition.toInt());
    12141214        } else {
    12151215            // Grow the grid for items with a definite column span, getting the largest such span.
    12161216            GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForColumns, GridResolvedPosition(0));
    1217             maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition.next().toInt());
     1217            maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition.toInt());
    12181218        }
    12191219    }
    … …  
    13111311                GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition : emptyGridArea->rows.resolvedFinalPosition;
    13121312                const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
    1313                 if (minorAxisFinalPositionIndex.toInt() < endOfMinorAxis)
     1313                if (minorAxisFinalPositionIndex.toInt() <= endOfMinorAxis)
    13141314                    break;
    13151315
    … …  
    14781478    bool endIsAuto = endPosition.isAuto()
    14791479        || (endPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
    1480         || (positions.resolvedFinalPosition.toInt() > lastTrackIndex);
     1480        || (positions.resolvedFinalPosition.prev().toInt() > lastTrackIndex);
    14811481
    14821482    GridResolvedPosition firstPosition = GridResolvedPosition(0);
    14831483    GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition;
    14841484    GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
    1485     GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition;
     1485    GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition.prev();
    14861486
    14871487    // Positioned children do not grow the grid, so we need to clamp the positions to avoid ending up outside of it.
    … …  
    15441544
    15451545    LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition.toInt()];
    1546     LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition.toInt()];
     1546    LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition.prev().toInt()];
    15471547
    15481548    // 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.toInt()].baseSize();
     1549    return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition.prev().toInt()].baseSize();
    15501550}
    15511551
    … …  
    18371837    case GridAxisEnd:
    18381838    case GridAxisCenter: {
    1839         unsigned childEndLine = rowsSpan.resolvedFinalPosition.next().toInt();
     1839        unsigned childEndLine = rowsSpan.resolvedFinalPosition.toInt();
    18401840        LayoutUnit endOfRow = m_rowPositions[childEndLine];
    18411841        // m_rowPositions include gutters so we need to substract them to get the actual end position for a given
    … …  
    18711871    case GridAxisEnd:
    18721872    case GridAxisCenter: {
    1873         unsigned childEndLine = columnsSpan.resolvedFinalPosition.next().toInt();
     1873        unsigned childEndLine = columnsSpan.resolvedFinalPosition.toInt();
    18741874        LayoutUnit endOfColumn = m_columnPositions[childEndLine];
    18751875        // m_columnPositions include gutters so we need to substract them to get the actual end position for a given

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

    r192156 r195808  
    7777    void resolveContentBasedTrackSizingFunctions(GridTrackSizingDirection, GridSizingData&);
    7878
    79     void ensureGridSize(unsigned maximumRowIndex, unsigned maximumColumnIndex);
     79    void ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize);
    8080    void insertItemIntoGrid(RenderBox&, const GridCoordinate&);
    8181    void placeItemsOnGrid();

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

    r176390 r195808  
    4545
    4646// A span in a single direction (either rows or columns). Note that |resolvedInitialPosition|
    47 // and |resolvedFinalPosition| are grid areas' indexes, NOT grid lines'. Iterating over the
    48 // span should include both |resolvedInitialPosition| and |resolvedFinalPosition| to be correct.
     47// and |resolvedFinalPosition| are grid lines' indexes.
     48// Iterating over the span shouldn't include |resolvedFinalPosition| to be correct.
    4949class GridSpan {
    5050public:
    … …  
    5353        , resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
    5454    {
    55         ASSERT(resolvedInitialPosition <= resolvedFinalPosition);
     55        ASSERT(resolvedInitialPosition < resolvedFinalPosition);
    5656    }
    5757
    … …  
    6363    unsigned integerSpan() const
    6464    {
    65         return resolvedFinalPosition.toInt() - resolvedInitialPosition.toInt() + 1;
     65        return resolvedFinalPosition.toInt() - resolvedInitialPosition.toInt();
    6666    }
    6767
    … …  
    7878    iterator end() const
    7979    {
    80         return resolvedFinalPosition.next();
     80        return resolvedFinalPosition;
    8181    }
    8282};
    … …  
    8787    // HashMap requires a default constuctor.
    8888    GridCoordinate()
    89         : columns(0, 0)
    90         , rows(0, 0)
     89        : columns(0, 1)
     90        , rows(0, 1)
    9191    {
    9292    }

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

    r192414 r195808  
    110110}
    111111
    112 static GridResolvedPosition adjustGridPositionForRowEndColumnEndSide(unsigned resolvedPosition)
    113 {
    114     return resolvedPosition ? GridResolvedPosition(resolvedPosition - 1) : GridResolvedPosition(0);
    115 }
    116 
    117112static GridResolvedPosition resolveNamedGridLinePositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
    118113{
    … …  
    136131}
    137132
    138 static inline unsigned firstNamedGridLineBeforePosition(unsigned position, const Vector<unsigned>& gridLines)
    139 {
    140     // The grid line inequality needs to be strict (which doesn't match the after / end case) because |position| is
    141     // already converted to an index in our grid representation (ie one was removed from the grid line to account for
    142     // the side).
     133static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
     134{
     135    if (!resolvedOppositePosition.toInt())
     136        return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     137
    143138    unsigned firstLineBeforePositionIndex = 0;
    144     auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), position);
    145     if (firstLineBeforePosition != gridLines.end()) {
    146         if (*firstLineBeforePosition > position && firstLineBeforePosition != gridLines.begin())
    147             --firstLineBeforePosition;
    148 
     139    auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
     140    if (firstLineBeforePosition != gridLines.end())
    149141        firstLineBeforePositionIndex = firstLineBeforePosition - gridLines.begin();
    150     }
    151     return firstLineBeforePositionIndex;
    152 }
    153 
    154 static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
    155 {
    156     unsigned gridLineIndex = std::max<int>(0, firstNamedGridLineBeforePosition(resolvedOppositePosition.toInt(), gridLines) - position.spanPosition() + 1);
     142
     143    unsigned gridLineIndex = std::max<int>(0, firstLineBeforePositionIndex - position.spanPosition());
     144
    157145    GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]);
     146    if (resolvedGridLinePosition >= resolvedOppositePosition)
     147        resolvedGridLinePosition = resolvedOppositePosition.prev();
    158148    return GridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
    159149}
    … …  
    168158
    169159    unsigned gridLineIndex = std::min<unsigned>(gridLines.size() - 1, firstLineAfterOppositePositionIndex + position.spanPosition() - 1);
    170     GridResolvedPosition resolvedGridLinePosition = adjustGridPositionForRowEndColumnEndSide(gridLines[gridLineIndex]);
    171     if (resolvedGridLinePosition < resolvedOppositePosition)
    172         resolvedGridLinePosition = resolvedOppositePosition;
     160    GridResolvedPosition resolvedGridLinePosition = gridLines[gridLineIndex];
     161    if (resolvedGridLinePosition <= resolvedOppositePosition)
     162        resolvedGridLinePosition = resolvedOppositePosition.next();
    173163    return GridSpan(resolvedOppositePosition, resolvedGridLinePosition);
    174164}
    … …  
    186176    // If there is no named grid line of that name, we resolve the position to 'auto' (which is equivalent to 'span 1' in this case).
    187177    // See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
    188     if (it == gridLinesNames.end())
    189         return GridSpan(resolvedOppositePosition, resolvedOppositePosition);
     178    if (it == gridLinesNames.end()) {
     179        if (isStartSide(side) && resolvedOppositePosition.toInt())
     180            return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
     181        return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     182    }
    190183
    191184    if (side == RowStartSide || side == ColumnStartSide)
    … …  
    197190static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
    198191{
    199     if (position.isAuto())
    200         return GridSpan(resolvedOppositePosition, resolvedOppositePosition);
     192    if (position.isAuto()) {
     193        if (isStartSide(side) && resolvedOppositePosition.toInt())
     194            return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
     195        return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     196    }
    201197
    202198    ASSERT(position.isSpan());
    … …  
    210206    // 'span 1' is contained inside a single grid track regardless of the direction.
    211207    // That's why the CSS span value is one more than the offset we apply.
    212     unsigned positionOffset = position.spanPosition() - 1;
     208    unsigned positionOffset = position.spanPosition();
    213209    if (isStartSide(side)) {
     210        if (!resolvedOppositePosition.toInt())
     211            return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
     212
    214213        unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset);
    215214        return GridSpan(initialResolvedPosition, resolvedOppositePosition);
    … …  
    226225    ASSERT(unresolvedSpan.requiresAutoPlacement());
    227226
    228     GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition;
     227    GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition.next();
    229228
    230229    if (unresolvedSpan.initialPosition().isSpan())
    … …  
    316315        // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
    317316        auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
    318         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition.prev(), unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
     317        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
    319318    }
    320319
    … …  
    330329    if (resolvedInitialPosition > resolvedFinalPosition)
    331330        std::swap(resolvedInitialPosition, resolvedFinalPosition);
    332 
    333     return GridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition.prev()));
     331    else if (resolvedInitialPosition == resolvedFinalPosition)
     332        resolvedFinalPosition = resolvedInitialPosition.next();
     333
     334    return GridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
    334335}
    335336

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

    r192414 r195808  
    7272};
    7373
    74 // This class represents an index into one of the dimensions of the grid array.
     74// This class represents a line index into one of the dimensions of the grid array.
    7575// Wraps an unsigned integer just for the purpose of knowing what we manipulate in the grid code.
    7676class GridResolvedPosition {
Note: See TracChangeset for help on using the changeset viewer.