Changeset 198399 in webkit


Ignore:
Timestamp:
Mar 18, 2016 6:56:40 AM (8 years ago)
Author:
Manuel Rego Casasnovas
Message:

[css-grid] Rename GridSpan properties
​https://bugs.webkit.org/show_bug.cgi?id=155636

Reviewed by Sergio Villar Senin.

GridSpan was using old names initialResolvedPosition and
finalResolvedPosition.
This patch rename them to startLine and endLine.

Some reasons for this refactoring:

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

  • rendering/style/GridArea.h:

(WebCore::GridSpan::untranslatedDefiniteGridSpan):
(WebCore::GridSpan::translatedDefiniteGridSpan):
(WebCore::GridSpan::operator==):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::untranslatedStartLine):
(WebCore::GridSpan::untranslatedEndLine):
(WebCore::GridSpan::startLine):
(WebCore::GridSpan::endLine):
(WebCore::GridSpan::begin):
(WebCore::GridSpan::end):
(WebCore::GridSpan::translate):
(WebCore::GridSpan::GridSpan):
(WebCore::GridSpan::untranslatedResolvedInitialPosition): Deleted.
(WebCore::GridSpan::untranslatedResolvedFinalPosition): Deleted.
(WebCore::GridSpan::resolvedInitialPosition): Deleted.
(WebCore::GridSpan::resolvedFinalPosition): Deleted.

  • rendering/style/GridPositionsResolver.cpp:

(WebCore::definiteGridSpanWithNamedLineSpanAgainstOpposite):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::GridPositionsResolver::resolveGridPositionsFromStyle):

Location:
trunk/Source/WebCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r198398 r198399  
     12016-03-18  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] Rename GridSpan properties
     4        https://bugs.webkit.org/show_bug.cgi?id=155636
     5
     6        Reviewed by Sergio Villar Senin.
     7
     8        GridSpan was using old names initialResolvedPosition and
     9        finalResolvedPosition.
     10        This patch rename them to startLine and endLine.
     11
     12        Some reasons for this refactoring:
     13        - "position" is a vague term not defined in the spec.
     14        - GridSpan is currently storing grid lines. A grid "line" is defined
     15          in the spec: https://drafts.csswg.org/css-grid/#grid-line-concept
     16        - The spec uses the concepts "start" and "end" lines too.
     17
     18        No new tests, no change of behavior.
     19
     20        * css/CSSGridTemplateAreasValue.cpp:
     21        (WebCore::stringForPosition):
     22        * css/CSSParser.cpp:
     23        (WebCore::CSSParser::parseGridTemplateAreasRow):
     24        * css/StyleBuilderConverter.h:
     25        (WebCore::StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea):
     26        * rendering/RenderGrid.cpp:
     27        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     28        (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
     29        (WebCore::RenderGrid::insertItemIntoGrid):
     30        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
     31        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
     32        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
     33        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
     34        (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
     35        (WebCore::RenderGrid::columnAxisOffsetForChild):
     36        (WebCore::RenderGrid::rowAxisOffsetForChild):
     37        * rendering/style/GridArea.h:
     38        (WebCore::GridSpan::untranslatedDefiniteGridSpan):
     39        (WebCore::GridSpan::translatedDefiniteGridSpan):
     40        (WebCore::GridSpan::operator==):
     41        (WebCore::GridSpan::integerSpan):
     42        (WebCore::GridSpan::untranslatedStartLine):
     43        (WebCore::GridSpan::untranslatedEndLine):
     44        (WebCore::GridSpan::startLine):
     45        (WebCore::GridSpan::endLine):
     46        (WebCore::GridSpan::begin):
     47        (WebCore::GridSpan::end):
     48        (WebCore::GridSpan::translate):
     49        (WebCore::GridSpan::GridSpan):
     50        (WebCore::GridSpan::untranslatedResolvedInitialPosition): Deleted.
     51        (WebCore::GridSpan::untranslatedResolvedFinalPosition): Deleted.
     52        (WebCore::GridSpan::resolvedInitialPosition): Deleted.
     53        (WebCore::GridSpan::resolvedFinalPosition): Deleted.
     54        * rendering/style/GridPositionsResolver.cpp:
     55        (WebCore::definiteGridSpanWithNamedLineSpanAgainstOpposite):
     56        (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
     57        (WebCore::resolveGridPositionAgainstOppositePosition):
     58        (WebCore::GridPositionsResolver::resolveGridPositionsFromStyle):
     59
    1602016-03-18  Csaba Osztrogonác  <ossy@webkit.org>
    261

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

    r198210 r198399  
    5656    for (const auto& it : gridAreaMap) {
    5757        const GridArea& area = it.value;
    58         if (row >= area.rows.resolvedInitialPosition() && row < area.rows.resolvedFinalPosition())
     58        if (row >= area.rows.startLine() && row < area.rows.endLine())
    5959            candidates.append(it.key);
    6060    }
    … …  
    6262    for (const auto& it : gridAreaMap) {
    6363        const GridArea& area = it.value;
    64         if (column >= area.columns.resolvedInitialPosition() && column < area.columns.resolvedFinalPosition() && candidates.contains(it.key))
     64        if (column >= area.columns.startLine() && column < area.columns.endLine() && candidates.contains(it.key))
    6565            return it.key;
    6666    }

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

    r198255 r198399  
    62566256            // The following checks test that the grid area is a single filled-in rectangle.
    62576257            // 1. The new row is adjacent to the previously parsed row.
    6258             if (rowCount != gridArea.rows.resolvedFinalPosition())
     6258            if (rowCount != gridArea.rows.endLine())
    62596259                return false;
    62606260
    62616261            // 2. The new area starts at the same position as the previously parsed area.
    6262             if (currentColumn != gridArea.columns.resolvedInitialPosition())
     6262            if (currentColumn != gridArea.columns.startLine())
    62636263                return false;
    62646264
    62656265            // 3. The new area ends at the same position as the previously parsed area.
    6266             if (lookAheadColumn != gridArea.columns.resolvedFinalPosition())
     6266            if (lookAheadColumn != gridArea.columns.endLine())
    62676267                return false;
    62686268
    6269             gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.resolvedInitialPosition(), gridArea.rows.resolvedFinalPosition() + 1);
     6269            gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.startLine(), gridArea.rows.endLine() + 1);
    62706270        }
    62716271        currentColumn = lookAheadColumn - 1;

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

    r197617 r198399  
    940940        {
    941941            auto& startVector = namedGridLines.add(area.key + "-start", Vector<unsigned>()).iterator->value;
    942             startVector.append(areaSpan.resolvedInitialPosition());
     942            startVector.append(areaSpan.startLine());
    943943            std::sort(startVector.begin(), startVector.end());
    944944        }
    945945        {
    946946            auto& endVector = namedGridLines.add(area.key + "-end", Vector<unsigned>()).iterator->value;
    947             endVector.append(areaSpan.resolvedFinalPosition());
     947            endVector.append(areaSpan.endLine());
    948948            std::sort(endVector.begin(), endVector.end());
    949949        }

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

    r198210 r198399  
    579579
    580580                // Do not include already processed items.
    581                 if (i > 0 && span.resolvedInitialPosition() <= flexibleSizedTracksIndex[i - 1])
     581                if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
    582582                    continue;
    583583
    … …  
    869869void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
    870870{
    871     unsigned trackPosition = span.resolvedInitialPosition();
     871    unsigned trackPosition = span.startLine();
    872872    GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
    873873
    … …  
    11431143{
    11441144    ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
    1145     ensureGridSize(area.rows.resolvedFinalPosition(), area.columns.resolvedFinalPosition());
     1145    ensureGridSize(area.rows.endLine(), area.columns.endLine());
    11461146
    11471147    for (auto row : area.rows) {
    … …  
    12151215        GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows);
    12161216        if (!rowPositions.isIndefinite()) {
    1217             m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untranslatedResolvedInitialPosition());
    1218             maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedResolvedFinalPosition());
     1217            m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untranslatedStartLine());
     1218            maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
    12191219        } else {
    12201220            // Grow the grid for items with a definite row span, getting the largest such span.
    … …  
    12251225        GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns);
    12261226        if (!columnPositions.isIndefinite()) {
    1227             m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositions.untranslatedResolvedInitialPosition());
    1228             maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedResolvedFinalPosition());
     1227            m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositions.untranslatedStartLine());
     1228            maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedEndLine());
    12291229        } else {
    12301230            // Grow the grid for items with a definite column span, getting the largest such span.
    … …  
    12651265        ASSERT(cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
    12661266        unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
    1267         unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition();
    1268 
    1269         GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
     1267        unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
     1268
     1269        GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.startLine(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
    12701270        std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisSpanSize);
    12711271        if (!emptyGridArea)
    … …  
    12761276
    12771277        if (!isGridAutoFlowDense)
    1278             minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition() : emptyGridArea->columns.resolvedInitialPosition());
     1278            minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.startLine() : emptyGridArea->columns.startLine());
    12791279    }
    12801280}
    … …  
    13081308    if (minorAxisPositions.isTranslatedDefinite()) {
    13091309        // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
    1310         if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacementCursor)
     1310        if (minorAxisPositions.startLine() < minorAxisAutoPlacementCursor)
    13111311            majorAxisAutoPlacementCursor++;
    13121312
    13131313        if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
    1314             GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition(), majorAxisAutoPlacementCursor);
     1314            GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.startLine(), majorAxisAutoPlacementCursor);
    13151315            emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisSpanSize);
    13161316        }
    … …  
    13271327            if (emptyGridArea) {
    13281328                // Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
    1329                 unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
     1329                unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.endLine() : emptyGridArea->rows.endLine();
    13301330                const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
    13311331                if (minorAxisFinalPositionIndex <= endOfMinorAxis)
    … …  
    13471347    m_gridItemArea.set(&gridItem, *emptyGridArea);
    13481348    insertItemIntoGrid(gridItem, *emptyGridArea);
    1349     autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition();
    1350     autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition();
     1349    autoPlacementCursor.first = emptyGridArea->rows.startLine();
     1350    autoPlacementCursor.second = emptyGridArea->columns.startLine();
    13511351}
    13521352
    … …  
    14961496    // For positioned items we cannot use GridSpan::translate() because we could end up with negative values, as the positioned items do not create implicit tracks per spec.
    14971497    int smallestStart = std::abs(isRowAxis ? m_smallestColumnStart : m_smallestRowStart);
    1498     int resolvedInitialPosition = positions.untranslatedResolvedInitialPosition() + smallestStart;
    1499     int resolvedFinalPosition = positions.untranslatedResolvedFinalPosition() + smallestStart;
     1498    int startLine = positions.untranslatedStartLine() + smallestStart;
     1499    int endLine = positions.untranslatedEndLine() + smallestStart;
    15001500
    15011501    GridPosition startPosition = isRowAxis ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();
    … …  
    15061506    bool startIsAuto = startPosition.isAuto()
    15071507        || (startPosition.isNamedGridArea() && GridPositionsResolver::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
    1508         || (resolvedInitialPosition < firstExplicitLine)
    1509         || (resolvedInitialPosition > lastExplicitLine);
     1508        || (startLine < firstExplicitLine)
     1509        || (startLine > lastExplicitLine);
    15101510    bool endIsAuto = endPosition.isAuto()
    15111511        || (endPosition.isNamedGridArea() && GridPositionsResolver::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
    1512         || (resolvedFinalPosition < firstExplicitLine)
    1513         || (resolvedFinalPosition > lastExplicitLine);
    1514 
    1515     unsigned initialPosition = startIsAuto ? 0 : resolvedInitialPosition;
    1516     unsigned finalPosition = endIsAuto ? lastExplicitLine : resolvedFinalPosition;
     1512        || (endLine < firstExplicitLine)
     1513        || (endLine > lastExplicitLine);
     1514
     1515    unsigned initialPosition = startIsAuto ? 0 : startLine;
     1516    unsigned finalPosition = endIsAuto ? lastExplicitLine : endLine;
    15171517
    15181518    LayoutUnit start = startIsAuto ? LayoutUnit() : isRowAxis ?  m_columnPositions[initialPosition] : m_rowPositions[initialPosition];
    … …  
    15751575    const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
    15761576
    1577     LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition()];
    1578     LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition() - 1];
     1577    LayoutUnit initialTrackPosition = linePositions[span.startLine()];
     1578    LayoutUnit finalTrackPosition = linePositions[span.endLine() - 1];
    15791579
    15801580    // Track Positions vector stores the 'start' grid line of each track, so we have to add last track's baseSize.
    1581     return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition() - 1].baseSize();
     1581    return finalTrackPosition - initialTrackPosition + tracks[span.endLine() - 1].baseSize();
    15821582}
    15831583
    … …  
    18581858{
    18591859    const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
    1860     unsigned childStartLine = rowsSpan.resolvedInitialPosition();
     1860    unsigned childStartLine = rowsSpan.startLine();
    18611861    LayoutUnit startOfRow = m_rowPositions[childStartLine];
    18621862    LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
    … …  
    18691869    case GridAxisEnd:
    18701870    case GridAxisCenter: {
    1871         unsigned childEndLine = rowsSpan.resolvedFinalPosition();
     1871        unsigned childEndLine = rowsSpan.endLine();
    18721872        LayoutUnit endOfRow = m_rowPositions[childEndLine];
    18731873        // m_rowPositions include gutters so we need to substract them to get the actual end position for a given
    … …  
    18921892{
    18931893    const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
    1894     unsigned childStartLine = columnsSpan.resolvedInitialPosition();
     1894    unsigned childStartLine = columnsSpan.startLine();
    18951895    LayoutUnit startOfColumn = m_columnPositions[childStartLine];
    18961896    LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
    … …  
    19031903    case GridAxisEnd:
    19041904    case GridAxisCenter: {
    1905         unsigned childEndLine = columnsSpan.resolvedFinalPosition();
     1905        unsigned childEndLine = columnsSpan.endLine();
    19061906        LayoutUnit endOfColumn = m_columnPositions[childEndLine];
    19071907        // m_columnPositions include gutters so we need to substract them to get the actual end position for a given

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

    r198210 r198399  
    4444const int kGridMaxTracks = 1000000;
    4545
    46 // A span in a single direction (either rows or columns). Note that |resolvedInitialPosition|
    47 // and |resolvedFinalPosition| are grid lines' indexes.
    48 // Iterating over the span shouldn't include |resolvedFinalPosition| to be correct.
     46// A span in a single direction (either rows or columns). Note that |startLine|
     47// and |endLine| are grid lines' indexes.
     48// Despite line numbers in the spec start in "1", the indexes here start in "0".
    4949class GridSpan {
    5050public:
    5151
    52     static GridSpan untranslatedDefiniteGridSpan(int resolvedInitialPosition, int resolvedFinalPosition)
    53     {
    54         return GridSpan(resolvedInitialPosition, resolvedFinalPosition, UntranslatedDefinite);
    55     }
    56 
    57     static GridSpan translatedDefiniteGridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition)
    58     {
    59         return GridSpan(resolvedInitialPosition, resolvedFinalPosition, TranslatedDefinite);
     52    static GridSpan untranslatedDefiniteGridSpan(int startLine, int endLine)
     53    {
     54        return GridSpan(startLine, endLine, UntranslatedDefinite);
     55    }
     56
     57    static GridSpan translatedDefiniteGridSpan(unsigned startLine, unsigned endLine)
     58    {
     59        return GridSpan(startLine, endLine, TranslatedDefinite);
    6060    }
    6161
    … …  
    6767    bool operator==(const GridSpan& o) const
    6868    {
    69         return m_type == o.m_type && m_resolvedInitialPosition == o.m_resolvedInitialPosition && m_resolvedFinalPosition == o.m_resolvedFinalPosition;
     69        return m_type == o.m_type && m_startLine == o.m_startLine && m_endLine == o.m_endLine;
    7070    }
    7171
    … …  
    7373    {
    7474        ASSERT(isTranslatedDefinite());
    75         return m_resolvedFinalPosition - m_resolvedInitialPosition;
    76     }
    77 
    78     int untranslatedResolvedInitialPosition() const
     75        return m_endLine - m_startLine;
     76    }
     77
     78    int untranslatedStartLine() const
    7979    {
    8080        ASSERT(m_type == UntranslatedDefinite);
    81         return m_resolvedInitialPosition;
    82     }
    83 
    84     int untranslatedResolvedFinalPosition() const
     81        return m_startLine;
     82    }
     83
     84    int untranslatedEndLine() const
    8585    {
    8686        ASSERT(m_type == UntranslatedDefinite);
    87         return m_resolvedFinalPosition;
    88     }
    89 
    90     unsigned resolvedInitialPosition() const
    91     {
    92         ASSERT(isTranslatedDefinite());
    93         ASSERT(m_resolvedFinalPosition >= 0);
    94         return m_resolvedInitialPosition;
    95     }
    96 
    97     unsigned resolvedFinalPosition() const
    98     {
    99         ASSERT(isTranslatedDefinite());
    100         ASSERT(m_resolvedFinalPosition > 0);
    101         return m_resolvedFinalPosition;
     87        return m_endLine;
     88    }
     89
     90    unsigned startLine() const
     91    {
     92        ASSERT(isTranslatedDefinite());
     93        ASSERT(m_endLine >= 0);
     94        return m_startLine;
     95    }
     96
     97    unsigned endLine() const
     98    {
     99        ASSERT(isTranslatedDefinite());
     100        ASSERT(m_endLine > 0);
     101        return m_endLine;
    102102    }
    103103
    … …  
    117117    {
    118118        ASSERT(isTranslatedDefinite());
    119         return m_resolvedInitialPosition;
     119        return m_startLine;
    120120    }
    121121
    … …  
    123123    {
    124124        ASSERT(isTranslatedDefinite());
    125         return m_resolvedFinalPosition;
     125        return m_endLine;
    126126    }
    127127
    … …  
    141141
    142142        m_type = TranslatedDefinite;
    143         m_resolvedInitialPosition += offset;
    144         m_resolvedFinalPosition += offset;
    145 
    146         ASSERT(m_resolvedInitialPosition >= 0);
    147         ASSERT(m_resolvedFinalPosition > 0);
     143        m_startLine += offset;
     144        m_endLine += offset;
     145
     146        ASSERT(m_startLine >= 0);
     147        ASSERT(m_endLine > 0);
    148148    }
    149149
    … …  
    152152    enum GridSpanType {UntranslatedDefinite, TranslatedDefinite, Indefinite};
    153153
    154     GridSpan(int resolvedInitialPosition, int resolvedFinalPosition, GridSpanType type)
     154    GridSpan(int startLine, int endLine, GridSpanType type)
    155155        : m_type(type)
    156156    {
    157157#if ENABLE(ASSERT)
    158         ASSERT(resolvedInitialPosition < resolvedFinalPosition);
     158        ASSERT(startLine < endLine);
    159159        if (type == TranslatedDefinite) {
    160             ASSERT(resolvedInitialPosition >= 0);
    161             ASSERT(resolvedFinalPosition > 0);
     160            ASSERT(startLine >= 0);
     161            ASSERT(endLine > 0);
    162162        }
    163163#endif
    164164
    165         m_resolvedInitialPosition = std::max(-kGridMaxTracks, std::min(resolvedInitialPosition, kGridMaxTracks - 1));
    166         m_resolvedFinalPosition = std::max(-kGridMaxTracks + 1, std::min(resolvedFinalPosition, kGridMaxTracks));
    167     }
    168 
    169     int m_resolvedInitialPosition;
    170     int m_resolvedFinalPosition;
     165        m_startLine = std::max(-kGridMaxTracks, std::min(startLine, kGridMaxTracks - 1));
     166        m_endLine = std::max(-kGridMaxTracks + 1, std::min(endLine, kGridMaxTracks));
     167    }
     168
     169    int m_startLine;
     170    int m_endLine;
    171171    GridSpanType m_type;
    172172

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

    r198210 r198399  
    170170}
    171171
    172 static GridSpan definiteGridSpanWithNamedLineSpanAgainstOpposite(int resolvedOppositePosition, const GridPosition& position, GridPositionSide side, const Vector<unsigned>* gridLines, unsigned lastLine)
     172static GridSpan definiteGridSpanWithNamedLineSpanAgainstOpposite(int oppositeLine, const GridPosition& position, GridPositionSide side, const Vector<unsigned>* gridLines, unsigned lastLine)
    173173{
    174174    int start, end;
    175175
    176176    if (side == RowStartSide || side == ColumnStartSide) {
    177         start = lookBackForNamedGridLine(resolvedOppositePosition - 1, position.spanPosition(), gridLines, lastLine);
    178         end = resolvedOppositePosition;
     177        start = lookBackForNamedGridLine(oppositeLine - 1, position.spanPosition(), gridLines, lastLine);
     178        end = oppositeLine;
    179179    } else {
    180         start = resolvedOppositePosition;
    181         end = lookAheadForNamedGridLine(resolvedOppositePosition + 1, position.spanPosition(), gridLines, lastLine);
     180        start = oppositeLine;
     181        end = lookAheadForNamedGridLine(oppositeLine + 1, position.spanPosition(), gridLines, lastLine);
    182182    }
    183183
    … …  
    185185}
    186186
    187 static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
     187static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side)
    188188{
    189189    ASSERT(position.isSpan());
    … …  
    197197    unsigned lastLine = explicitGridSizeForSide(gridContainerStyle, side);
    198198
    199     return definiteGridSpanWithNamedLineSpanAgainstOpposite(resolvedOppositePosition, position, side, gridLines, lastLine);
    200 }
    201 
    202 static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
     199    return definiteGridSpanWithNamedLineSpanAgainstOpposite(oppositeLine, position, side, gridLines, lastLine);
     200}
     201
     202static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side)
    203203{
    204204    if (position.isAuto()) {
    205205        if (isStartSide(side))
    206             return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
    207         return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
     206            return GridSpan::untranslatedDefiniteGridSpan(oppositeLine - 1, oppositeLine);
     207        return GridSpan::untranslatedDefiniteGridSpan(oppositeLine, oppositeLine + 1);
    208208    }
    209209
    … …  
    213213    if (!position.namedGridLine().isNull()) {
    214214        // span 2 'c' -> we need to find the appropriate grid line before / after our opposite position.
    215         return resolveNamedGridLinePositionAgainstOppositePosition(gridContainerStyle, resolvedOppositePosition, position, side);
     215        return resolveNamedGridLinePositionAgainstOppositePosition(gridContainerStyle, oppositeLine, position, side);
    216216    }
    217217
    … …  
    220220    unsigned positionOffset = position.spanPosition();
    221221    if (isStartSide(side))
    222         return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - positionOffset, resolvedOppositePosition);
    223 
    224     return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
     222        return GridSpan::untranslatedDefiniteGridSpan(oppositeLine - positionOffset, oppositeLine);
     223
     224    return GridSpan::untranslatedDefiniteGridSpan(oppositeLine, oppositeLine + positionOffset);
    225225}
    226226
    … …  
    309309    if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
    310310        // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
    311         auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
    312         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
     311        auto endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
     312        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, endLine, initialPosition, initialSide);
    313313    }
    314314
    315315    if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
    316316        // Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
    317         auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
    318         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
    319     }
    320 
    321     int resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
    322     int resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
    323 
    324     if (resolvedInitialPosition > resolvedFinalPosition)
    325         std::swap(resolvedInitialPosition, resolvedFinalPosition);
    326     else if (resolvedInitialPosition == resolvedFinalPosition)
    327         resolvedFinalPosition = resolvedInitialPosition + 1;
    328 
    329     return GridSpan::untranslatedDefiniteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
     317        auto startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
     318        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, startLine, finalPosition, finalSide);
     319    }
     320
     321    int startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
     322    int endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
     323
     324    if (startLine > endLine)
     325        std::swap(startLine, endLine);
     326    else if (startLine == endLine)
     327        endLine = startLine + 1;
     328
     329    return GridSpan::untranslatedDefiniteGridSpan(startLine, std::max(startLine, endLine));
    330330}
    331331
Note: See TracChangeset for help on using the changeset viewer.