Changeset 197850 in webkit


Ignore:
Timestamp:
Mar 9, 2016 2:15:23 AM (8 years ago)
Author:
Manuel Rego Casasnovas
Message:

[css-grid] Initial support for implicit grid before explicit grid
​https://bugs.webkit.org/show_bug.cgi?id=155014

Reviewed by Darin Adler.

Source/WebCore:

Change GridSpan to store int instead of unsigned. This allows us to
resolve positions before the explicit grid with negative values.

This patch adds a new type of GridSpan called "Untranslated".
This type is only used in populateExplicitGridAndOrderIterator().
Where we store the smallest negative position in both axis.

Then the GridSpans are translated into positive values, using the offset
calculated before. This is done in placeItemsOnGrid() and from that
moment the rest of the code uses "Definite" GridSpans, which returns
only positive positions (unsigned instead of int).
This allows us to don't have to modify the rest of the code, as it keeps
using GridSpans as before.

Let's use an example to explain how it works. Imagine that we've a 2
columns grid and 2 items placed like:

  • Item A: grid-column: -5;
  • Item B: grid-column: 1;

Initially we'll use "Unstranslated" GridSpans with the following values:

  • Item A: GridSpan(-2, -1)
  • Item B: GridSpan(0, 1)

Then we'll translate them using the smallest position as offset (-2)
so we've "Definite" GridSpans:

  • Item A: GridSpan(0, 1)
  • Item B: GridSpan(2, 3)

Test: fast/css-grid-layout/implicit-tracks-before-explicit.html

  • css/CSSParser.cpp:

(WebCore::CSSParser::parseGridTemplateAreasRow):

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::GridIterator::nextEmptyGridArea):
(WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
(WebCore::RenderGrid::gridTrackSize):
(WebCore::RenderGrid::insertItemIntoGrid):
(WebCore::RenderGrid::placeItemsOnGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Deleted.
(WebCore::RenderGrid::layoutPositionedObject): Deleted.

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

(WebCore::GridSpan::untranslatedDefiniteGridSpan):
(WebCore::GridSpan::translatedDefiniteGridSpan):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::untranslatedResolvedInitialPosition):
(WebCore::GridSpan::untranslatedResolvedFinalPosition):
(WebCore::GridSpan::resolvedInitialPosition):
(WebCore::GridSpan::resolvedFinalPosition):
(WebCore::GridSpan::begin):
(WebCore::GridSpan::end):
(WebCore::GridSpan::isTranslatedDefinite):
(WebCore::GridSpan::isIndefinite):
(WebCore::GridSpan::translate):
(WebCore::GridSpan::GridSpan):
(WebCore::GridSpan::operator==): Deleted.
(WebCore::GridSpan::GridSpanIterator::GridSpanIterator): Deleted.
(WebCore::GridSpan::GridSpanIterator::operator unsigned&): Deleted.

  • rendering/style/GridResolvedPosition.cpp:

(WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::resolveGridPositionFromStyle):
(WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
(WebCore::GridResolvedPosition::spanSizeForAutoPlacedItem): Deleted.

LayoutTests:

Updated results in current tests and added specific test for this.

  • fast/css-grid-layout/grid-auto-flow-resolution.html:
  • fast/css-grid-layout/grid-item-negative-position-resolution.html:
  • fast/css-grid-layout/grid-item-spanning-resolution.html:
  • fast/css-grid-layout/implicit-tracks-before-explicit-expected.txt: Added.
  • fast/css-grid-layout/implicit-tracks-before-explicit.html: Added.
Location:
trunk
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r197847 r197850  
     12016-03-09  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] Initial support for implicit grid before explicit grid
     4        https://bugs.webkit.org/show_bug.cgi?id=155014
     5
     6        Reviewed by Darin Adler.
     7
     8        Updated results in current tests and added specific test for this.
     9
     10        * fast/css-grid-layout/grid-auto-flow-resolution.html:
     11        * fast/css-grid-layout/grid-item-negative-position-resolution.html:
     12        * fast/css-grid-layout/grid-item-spanning-resolution.html:
     13        * fast/css-grid-layout/implicit-tracks-before-explicit-expected.txt: Added.
     14        * fast/css-grid-layout/implicit-tracks-before-explicit.html: Added.
     15
    1162016-03-09  Myles C. Maxfield  <mmaxfield@apple.com>
    217

  • trunk/LayoutTests/fast/css-grid-layout/grid-auto-flow-resolution.html

    r197503 r197850  
    2424}
    2525
    26 /* These 2 classes forces the grid to be sized after the grid-{column|row}-end, thus end up in the
    27    first row / columns. */
    2826.negativeOverflowingRowFirstColumn {
    2927    -webkit-grid-row: auto / -10;
    … …  
    154152<div class="unconstrainedContainer">
    155153    <div class="grid bigGrid gridAutoFlowColumnSparse justifyContentStart">
    156         <div class="sizedToGridArea negativeOverflowingRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50">XXXXX XXXXX XXXXX</div>
    157         <div class="sizedToGridArea secondRowNegativeOverflowingColumn" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="100">XXXXX XXXXX XXXXX</div>
     154        <div class="sizedToGridArea negativeOverflowingRowFirstColumn" data-offset-x="170" data-offset-y="0" data-expected-width="50" data-expected-height="30">XXXXX XXXXX XXXXX</div>
     155        <div class="sizedToGridArea secondRowNegativeOverflowingColumn" data-offset-x="0" data-offset-y="80" data-expected-width="170" data-expected-height="100">XXXXX XXXXX XXXXX</div>
    158156    </div>
    159157</div>
    … …  
    161159<div class="unconstrainedContainer">
    162160    <div class="grid bigGrid gridAutoFlowRowSparse justifyContentStart">
    163         <div class="sizedToGridArea negativeOverflowingRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50">XXXXX XXXXX XXXXX</div>
    164         <div class="sizedToGridArea secondRowNegativeOverflowingColumn" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="100">XXXXX XXXXX XXXXX</div>
     161        <div class="sizedToGridArea negativeOverflowingRowFirstColumn" data-offset-x="170" data-offset-y="0" data-expected-width="50" data-expected-height="30">XXXXX XXXXX XXXXX</div>
     162        <div class="sizedToGridArea secondRowNegativeOverflowingColumn" data-offset-x="0" data-offset-y="80" data-expected-width="170" data-expected-height="100">XXXXX XXXXX XXXXX</div>
    165163    </div>
    166164</div>

  • trunk/LayoutTests/fast/css-grid-layout/grid-item-negative-position-resolution.html

    r185147 r197850  
    159159
    160160<div style="position: relative">
    161 <div class="grid" data-expected-width="150" data-expected-height="150">
    162     <div class="sizedToGridArea negativeEndPositionStartSpanInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="150"></div>
     161<div class="grid" data-expected-width="150" data-expected-height="750">
     162    <div class="sizedToGridArea negativeEndPositionStartSpanInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="750"></div>
    163163</div>
    164164</div>
    … …  
    171171
    172172<div style="position: relative">
    173 <div class="grid" data-expected-width="150" data-expected-height="150">
    174     <div class="sizedToGridArea negativeNamedGridLineEndPositionStartSpanInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="150"></div>
     173<div class="grid" data-expected-width="150" data-expected-height="750">
     174    <div class="sizedToGridArea negativeNamedGridLineEndPositionStartSpanInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="750"></div>
    175175</div>
    176176</div>
    … …  
    183183
    184184<div style="position: relative">
    185 <div class="grid" data-expected-width="150" data-expected-height="150">
    186     <div class="sizedToGridArea negativeEndPositionStartNegativeInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
     185<div class="grid" data-expected-width="550" data-expected-height="150">
     186    <div class="sizedToGridArea negativeEndPositionStartNegativeInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="450" data-expected-height="50"></div>
    187187</div>
    188188</div>
    … …  
    195195
    196196<div style="position: relative">
    197 <div class="grid" data-expected-width="150" data-expected-height="150">
    198     <div class="sizedToGridArea namedGridLineEndPositionStartNegativeInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
     197<div class="grid" data-expected-width="550" data-expected-height="150">
     198    <div class="sizedToGridArea namedGridLineEndPositionStartNegativeInRowDirection" data-offset-x="0" data-offset-y="0" data-expected-width="450" data-expected-height="50"></div>
    199199</div>
    200200</div>

  • trunk/LayoutTests/fast/css-grid-layout/grid-item-spanning-resolution.html

    r170531 r197850  
    88    width: 400px;
    99    height: 300px;
     10    -webkit-grid-auto-columns: 200px;
     11    -webkit-grid-auto-rows: 250px;
    1012}
    1113
    … …  
    125127<div style="position: relative">
    126128<div class="grid" data-expected-width="400" data-expected-height="300">
    127     <div class="sizedToGridArea negativeOverflowRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="160" data-expected-height="90"></div>
    128 </div>
    129 </div>
    130 
    131 <div style="position: relative">
    132 <div class="grid" data-expected-width="400" data-expected-height="300">
    133     <div class="sizedToGridArea overflowRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="160" data-expected-height="300"></div>
    134 </div>
    135 </div>
    136 
    137 <div style="position: relative">
    138 <div class="grid" data-expected-width="400" data-expected-height="300">
    139     <div class="sizedToGridArea firstRowNegativeOverflowColumn" data-offset-x="0" data-offset-y="0" data-expected-width="160" data-expected-height="90"></div>
    140 </div>
    141 </div>
    142 
    143 <div style="position: relative">
    144 <div class="grid" data-expected-width="400" data-expected-height="300">
    145     <div class="sizedToGridArea firstRowOverflowColumn" data-offset-x="0" data-offset-y="0" data-expected-width="400" data-expected-height="90"></div>
     129    <div class="sizedToGridArea negativeOverflowRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="160" data-expected-height="500"></div>
     130</div>
     131</div>
     132
     133<div style="position: relative">
     134<div class="grid" data-expected-width="400" data-expected-height="300">
     135    <div class="sizedToGridArea overflowRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="160" data-expected-height="800"></div>
     136</div>
     137</div>
     138
     139<div style="position: relative">
     140<div class="grid" data-expected-width="400" data-expected-height="300">
     141    <div class="sizedToGridArea firstRowNegativeOverflowColumn" data-offset-x="0" data-offset-y="0" data-expected-width="400" data-expected-height="90"></div>
     142</div>
     143</div>
     144
     145<div style="position: relative">
     146<div class="grid" data-expected-width="400" data-expected-height="300">
     147    <div class="sizedToGridArea firstRowOverflowColumn" data-offset-x="0" data-offset-y="0" data-expected-width="800" data-expected-height="90"></div>
    146148</div>
    147149</div>
    … …  
    155157<div style="position: relative">
    156158<div class="grid" data-expected-width="400" data-expected-height="300">
    157     <div class="sizedToGridArea autoSecondRowAutoFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="160" data-expected-height="90"></div>
     159    <div class="sizedToGridArea autoSecondRowAutoFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="200" data-expected-height="90"></div>
    158160</div>
    159161</div>
    … …  
    189191<div style="position: relative">
    190192<div class="grid" id="bigGrid" data-expected-width="200" data-expected-height="100">
    191     <div class="sizedToGridArea underflowSpanning" data-offset-x="0" data-offset-y="0" data-expected-width="100" data-expected-height="75"></div>
     193    <div class="sizedToGridArea underflowSpanning" data-offset-x="0" data-offset-y="0" data-expected-width="300" data-expected-height="1325"></div>
    192194</div>
    193195

  • trunk/Source/WebCore/ChangeLog

    r197847 r197850  
     12016-03-09  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] Initial support for implicit grid before explicit grid
     4        https://bugs.webkit.org/show_bug.cgi?id=155014
     5
     6        Reviewed by Darin Adler.
     7
     8        Change GridSpan to store int instead of unsigned. This allows us to
     9        resolve positions before the explicit grid with negative values.
     10
     11        This patch adds a new type of GridSpan called "Untranslated".
     12        This type is only used in populateExplicitGridAndOrderIterator().
     13        Where we store the smallest negative position in both axis.
     14
     15        Then the GridSpans are translated into positive values, using the offset
     16        calculated before. This is done in placeItemsOnGrid() and from that
     17        moment the rest of the code uses "Definite" GridSpans, which returns
     18        only positive positions (unsigned instead of int).
     19        This allows us to don't have to modify the rest of the code, as it keeps
     20        using GridSpans as before.
     21
     22        Let's use an example to explain how it works. Imagine that we've a 2
     23        columns grid and 2 items placed like:
     24        * Item A: grid-column: -5;
     25        * Item B: grid-column: 1;
     26
     27        Initially we'll use "Unstranslated" GridSpans with the following values:
     28        * Item A: GridSpan(-2, -1)
     29        * Item B: GridSpan(0, 1)
     30
     31        Then we'll translate them using the smallest position as offset (-2)
     32        so we've "Definite" GridSpans:
     33        * Item A: GridSpan(0, 1)
     34        * Item B: GridSpan(2, 3)
     35
     36        Test: fast/css-grid-layout/implicit-tracks-before-explicit.html
     37
     38        * css/CSSParser.cpp:
     39        (WebCore::CSSParser::parseGridTemplateAreasRow):
     40        * rendering/RenderGrid.cpp:
     41        (WebCore::RenderGrid::GridIterator::nextEmptyGridArea):
     42        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     43        (WebCore::RenderGrid::gridTrackSize):
     44        (WebCore::RenderGrid::insertItemIntoGrid):
     45        (WebCore::RenderGrid::placeItemsOnGrid):
     46        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
     47        (WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
     48        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
     49        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
     50        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
     51        (WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Deleted.
     52        (WebCore::RenderGrid::layoutPositionedObject): Deleted.
     53        * rendering/RenderGrid.h:
     54        * rendering/style/GridCoordinate.h:
     55        (WebCore::GridSpan::untranslatedDefiniteGridSpan):
     56        (WebCore::GridSpan::translatedDefiniteGridSpan):
     57        (WebCore::GridSpan::integerSpan):
     58        (WebCore::GridSpan::untranslatedResolvedInitialPosition):
     59        (WebCore::GridSpan::untranslatedResolvedFinalPosition):
     60        (WebCore::GridSpan::resolvedInitialPosition):
     61        (WebCore::GridSpan::resolvedFinalPosition):
     62        (WebCore::GridSpan::begin):
     63        (WebCore::GridSpan::end):
     64        (WebCore::GridSpan::isTranslatedDefinite):
     65        (WebCore::GridSpan::isIndefinite):
     66        (WebCore::GridSpan::translate):
     67        (WebCore::GridSpan::GridSpan):
     68        (WebCore::GridSpan::operator==): Deleted.
     69        (WebCore::GridSpan::GridSpanIterator::GridSpanIterator): Deleted.
     70        (WebCore::GridSpan::GridSpanIterator::operator unsigned&): Deleted.
     71        * rendering/style/GridResolvedPosition.cpp:
     72        (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
     73        (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
     74        (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
     75        (WebCore::resolveGridPositionAgainstOppositePosition):
     76        (WebCore::resolveGridPositionFromStyle):
     77        (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
     78        (WebCore::GridResolvedPosition::spanSizeForAutoPlacedItem): Deleted.
     79
    1802016-03-09  Myles C. Maxfield  <mmaxfield@apple.com>
    281

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

    r197617 r197850  
    62506250        auto gridAreaIterator = gridAreaMap.find(gridAreaName);
    62516251        if (gridAreaIterator == gridAreaMap.end())
    6252             gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan::definiteGridSpan(rowCount, rowCount + 1), GridSpan::definiteGridSpan(currentColumn, lookAheadColumn)));
     6252            gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan::translatedDefiniteGridSpan(rowCount, rowCount + 1), GridSpan::translatedDefiniteGridSpan(currentColumn, lookAheadColumn)));
    62536253        else {
    62546254            GridCoordinate& gridCoordinate = gridAreaIterator->value;
    … …  
    62676267                return false;
    62686268
    6269             gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition() + 1);
     6269            gridCoordinate.rows = GridSpan::translatedDefiniteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition() + 1);
    62706270        }
    62716271        currentColumn = lookAheadColumn - 1;

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

    r197509 r197850  
    3535#include "RenderLayer.h"
    3636#include "RenderView.h"
     37#include <cstdlib>
    3738
    3839namespace WebCore {
    … …  
    191192        for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex) {
    192193            if (isEmptyAreaEnough(rowSpan, 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));
     194                std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan::translatedDefiniteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::translatedDefiniteGridSpan(m_columnIndex, m_columnIndex + columnSpan));
    194195                // Advance the iterator to avoid an infinite loop where we would return the same grid area over and over.
    195196                ++varyingTrackIndex;
    … …  
    567568    double flexFraction = 0;
    568569    if (hasDefiniteFreeSpace)
    569         flexFraction = findFlexFactorUnitSize(tracks, GridSpan::definiteGridSpan(0, tracks.size()), direction, initialFreeSpace.value());
     570        flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), direction, initialFreeSpace.value());
    570571    else {
    571572        for (const auto& trackIndex : flexibleSizedTracksIndex)
    … …  
    688689    bool isForColumns = (direction == ForColumns);
    689690    auto& trackStyles =  isForColumns ? style().gridColumns() : style().gridRows();
    690     auto& trackSize = (i >= trackStyles.size()) ? (isForColumns ? style().gridAutoColumns() : style().gridAutoRows()) : trackStyles[i];
     691
     692    auto& autoTrackSize = isForColumns ? style().gridAutoColumns() : style().gridAutoRows();
     693    int translatedIndex = i + (isForColumns ? m_smallestColumnStart : m_smallestRowStart);
     694    auto& trackSize = (translatedIndex < 0 || translatedIndex >= static_cast<int>(trackStyles.size())) ? autoTrackSize : trackStyles[translatedIndex];
    691695
    692696    GridLength minTrackBreadth = trackSize.minTrackBreadth();
    … …  
    11381142void RenderGrid::insertItemIntoGrid(RenderBox& child, const GridCoordinate& coordinate)
    11391143{
    1140     ASSERT(coordinate.rows.isDefinite() && coordinate.columns.isDefinite());
     1144    ASSERT(coordinate.rows.isTranslatedDefinite() && coordinate.columns.isTranslatedDefinite());
    11411145    ensureGridSize(coordinate.rows.resolvedFinalPosition(), coordinate.columns.resolvedFinalPosition());
    11421146
    … …  
    11611165
    11621166        GridCoordinate coordinate = cachedGridCoordinate(*child);
    1163 
    1164         if (!coordinate.rows.isDefinite() || !coordinate.columns.isDefinite()) {
     1167        if (!coordinate.rows.isIndefinite())
     1168            coordinate.rows.translate(std::abs(m_smallestRowStart));
     1169        if (!coordinate.columns.isIndefinite())
     1170            coordinate.columns.translate(std::abs(m_smallestColumnStart));
     1171        m_gridItemCoordinate.set(child, coordinate);
     1172
     1173        if (coordinate.rows.isIndefinite() || coordinate.columns.isIndefinite()) {
    11651174            bool majorAxisDirectionIsForColumns = autoPlacementMajorAxisDirection() == ForColumns;
    1166             if ((majorAxisDirectionIsForColumns && !coordinate.columns.isDefinite())
    1167                 || (!majorAxisDirectionIsForColumns && !coordinate.rows.isDefinite()))
     1175            if ((majorAxisDirectionIsForColumns && coordinate.columns.isIndefinite())
     1176                || (!majorAxisDirectionIsForColumns && coordinate.rows.isIndefinite()))
    11681177                autoMajorAxisAutoGridItems.append(child);
    11691178            else
    … …  
    11861195
    11871196        GridCoordinate coordinate = cachedGridCoordinate(*child);
    1188         ASSERT(coordinate.rows.isDefinite() && coordinate.columns.isDefinite());
     1197        ASSERT(coordinate.rows.isTranslatedDefinite() && coordinate.columns.isTranslatedDefinite());
    11891198    }
    11901199#endif
    … …  
    11941203{
    11951204    OrderIteratorPopulator populator(m_orderIterator);
     1205    m_smallestRowStart = m_smallestColumnStart = 0;
    11961206    unsigned maximumRowIndex = std::max<unsigned>(1, GridResolvedPosition::explicitGridRowCount(style()));
    11971207    unsigned maximumColumnIndex = std::max<unsigned>(1, GridResolvedPosition::explicitGridColumnCount(style()));
    … …  
    12041214
    12051215        GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
    1206         if (rowPositions.isDefinite()) {
    1207             maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition());
     1216        if (!rowPositions.isIndefinite()) {
     1217            m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untranslatedResolvedInitialPosition());
     1218            maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedResolvedFinalPosition());
    12081219        } else {
    12091220            // Grow the grid for items with a definite row span, getting the largest such span.
    … …  
    12131224
    12141225        GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
    1215         if (columnPositions.isDefinite()) {
    1216             maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition());
     1226        if (!columnPositions.isIndefinite()) {
     1227            m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositions.untranslatedResolvedInitialPosition());
     1228            maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedResolvedFinalPosition());
    12171229        } else {
    12181230            // Grow the grid for items with a definite column span, getting the largest such span.
    … …  
    12241236    }
    12251237
    1226     m_grid.grow(maximumRowIndex);
     1238    m_grid.grow(maximumRowIndex + std::abs(m_smallestRowStart));
    12271239    for (auto& column : m_grid)
    1228         column.grow(maximumColumnIndex);
     1240        column.grow(maximumColumnIndex + std::abs(m_smallestColumnStart));
    12291241}
    12301242
    … …  
    12341246    const unsigned endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
    12351247    unsigned crossDirectionSpanSize = GridResolvedPosition::spanSizeForAutoPlacedItem(style(), gridItem, crossDirection);
    1236     GridSpan crossDirectionPositions = GridSpan::definiteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
     1248    GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
    12371249    return std::make_unique<GridCoordinate>(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions);
    12381250}
    … …  
    12501262    for (auto& autoGridItem : autoGridItems) {
    12511263        GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacementMajorAxisDirection());
    1252         ASSERT(majorAxisPositions.isDefinite());
    1253         ASSERT(!cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isDefinite());
     1264        ASSERT(majorAxisPositions.isTranslatedDefinite());
     1265        ASSERT(cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
    12541266        unsigned minorAxisSpanSize = GridResolvedPosition::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
    12551267        unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition();
    … …  
    12851297void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
    12861298{
    1287     ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isDefinite());
     1299    ASSERT(cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
    12881300    unsigned majorAxisSpanSize = GridResolvedPosition::spanSizeForAutoPlacedItem(style(), gridItem, autoPlacementMajorAxisDirection());
    12891301
    … …  
    12941306    std::unique_ptr<GridCoordinate> emptyGridArea;
    12951307    GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
    1296     if (minorAxisPositions.isDefinite()) {
     1308    if (minorAxisPositions.isTranslatedDefinite()) {
    12971309        // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
    12981310        if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacementCursor)
    … …  
    13301342
    13311343        if (!emptyGridArea)
    1332             emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(gridItem, autoPlacementMinorAxisDirection(), GridSpan::definiteGridSpan(0, minorAxisSpanSize));
     1344            emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(gridItem, autoPlacementMinorAxisDirection(), GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
    13331345    }
    13341346
    … …  
    14751487
    14761488    GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), child, direction);
    1477     if (!positions.isDefinite()) {
     1489    if (positions.isIndefinite()) {
    14781490        offset = LayoutUnit();
    14791491        breadth = (direction == ForColumns) ? clientLogicalWidth() : clientLogicalHeight();
    14801492        return;
    14811493    }
     1494    positions.translate(direction == ForColumns ? m_smallestColumnStart : m_smallestRowStart);
    14821495
    14831496    GridPosition startPosition = (direction == ForColumns) ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();

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

    r197563 r197850  
    191191    Optional<LayoutUnit> m_minContentHeight;
    192192    Optional<LayoutUnit> m_maxContentHeight;
     193
     194    int m_smallestColumnStart;
     195    int m_smallestRowStart;
    193196};
    194197

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

    r197400 r197850  
    4242
    4343// Recommended maximum size for both explicit and implicit grids.
    44 const unsigned kGridMaxTracks = 1000000;
     44const int kGridMaxTracks = 1000000;
    4545
    4646// A span in a single direction (either rows or columns). Note that |resolvedInitialPosition|
    … …  
    5050public:
    5151
    52     static GridSpan definiteGridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition)
    53     {
    54         return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
     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);
    5560    }
    5661
    … …  
    6772    unsigned integerSpan() const
    6873    {
    69         ASSERT(isDefinite());
     74        ASSERT(isTranslatedDefinite());
    7075        return m_resolvedFinalPosition - m_resolvedInitialPosition;
    7176    }
    7277
     78    int untranslatedResolvedInitialPosition() const
     79    {
     80        ASSERT(m_type == UntranslatedDefinite);
     81        return m_resolvedInitialPosition;
     82    }
     83
     84    int untranslatedResolvedFinalPosition() const
     85    {
     86        ASSERT(m_type == UntranslatedDefinite);
     87        return m_resolvedFinalPosition;
     88    }
     89
    7390    unsigned resolvedInitialPosition() const
    7491    {
    75         ASSERT(isDefinite());
     92        ASSERT(isTranslatedDefinite());
     93        ASSERT(m_resolvedFinalPosition >= 0);
    7694        return m_resolvedInitialPosition;
    7795    }
    … …  
    7997    unsigned resolvedFinalPosition() const
    8098    {
    81         ASSERT(isDefinite());
    82         ASSERT(m_resolvedFinalPosition);
     99        ASSERT(isTranslatedDefinite());
     100        ASSERT(m_resolvedFinalPosition > 0);
    83101        return m_resolvedFinalPosition;
    84102    }
    … …  
    98116    GridSpanIterator begin() const
    99117    {
    100         ASSERT(isDefinite());
     118        ASSERT(isTranslatedDefinite());
    101119        return m_resolvedInitialPosition;
    102120    }
    … …  
    104122    GridSpanIterator end() const
    105123    {
    106         ASSERT(isDefinite());
     124        ASSERT(isTranslatedDefinite());
    107125        return m_resolvedFinalPosition;
    108126    }
    109127
    110     bool isDefinite() const
    111     {
    112         return m_type == Definite;
     128    bool isTranslatedDefinite() const
     129    {
     130        return m_type == TranslatedDefinite;
     131    }
     132
     133    bool isIndefinite() const
     134    {
     135        return m_type == Indefinite;
     136    }
     137
     138    void translate(unsigned offset)
     139    {
     140        ASSERT(m_type == UntranslatedDefinite);
     141
     142        m_type = TranslatedDefinite;
     143        m_resolvedInitialPosition += offset;
     144        m_resolvedFinalPosition += offset;
     145
     146        ASSERT(m_resolvedInitialPosition >= 0);
     147        ASSERT(m_resolvedFinalPosition > 0);
    113148    }
    114149
    115150private:
    116151
    117     enum GridSpanType {Definite, Indefinite};
    118 
    119     GridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition, GridSpanType type)
    120         : m_resolvedInitialPosition(std::min(resolvedInitialPosition, kGridMaxTracks - 1))
    121         , m_resolvedFinalPosition(std::min(resolvedFinalPosition, kGridMaxTracks))
    122         , m_type(type)
    123     {
     152    enum GridSpanType {UntranslatedDefinite, TranslatedDefinite, Indefinite};
     153
     154    GridSpan(int resolvedInitialPosition, int resolvedFinalPosition, GridSpanType type)
     155        : m_type(type)
     156    {
     157#if ENABLE(ASSERT)
    124158        ASSERT(resolvedInitialPosition < resolvedFinalPosition);
    125     }
    126 
    127     unsigned m_resolvedInitialPosition;
    128     unsigned m_resolvedFinalPosition;
     159        if (type == TranslatedDefinite) {
     160            ASSERT(resolvedInitialPosition >= 0);
     161            ASSERT(resolvedFinalPosition > 0);
     162        }
     163#endif
     164
     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;
    129171    GridSpanType m_type;
    130172

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

    r197501 r197850  
    3636#include "GridCoordinate.h"
    3737#include "RenderBox.h"
     38#include <cstdlib>
    3839
    3940namespace WebCore {
    … …  
    141142{
    142143    if (!resolvedOppositePosition)
    143         return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
     144        return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
    144145
    145146    unsigned firstLineBeforePositionIndex = 0;
    … …  
    153154    if (resolvedGridLinePosition >= resolvedOppositePosition)
    154155        resolvedGridLinePosition = resolvedOppositePosition - 1;
    155     return GridSpan::definiteGridSpan(std::min(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
     156    return GridSpan::untranslatedDefiniteGridSpan(std::min(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
    156157}
    157158
    … …  
    168169    if (resolvedGridLinePosition <= resolvedOppositePosition)
    169170        resolvedGridLinePosition = resolvedOppositePosition + 1;
    170     return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
     171    return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
    171172}
    172173
    … …  
    184185    // See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
    185186    if (it == gridLinesNames.end()) {
    186         if (isStartSide(side) && resolvedOppositePosition)
    187             return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
    188         return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
     187        if (isStartSide(side))
     188            return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
     189        return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
    189190    }
    190191
    … …  
    198199{
    199200    if (position.isAuto()) {
    200         if (isStartSide(side) && resolvedOppositePosition)
    201             return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
    202         return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
     201        if (isStartSide(side))
     202            return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
     203        return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
    203204    }
    204205
    … …  
    214215    // That's why the CSS span value is one more than the offset we apply.
    215216    unsigned positionOffset = position.spanPosition();
    216     if (isStartSide(side)) {
    217         if (!resolvedOppositePosition)
    218             return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
    219 
    220         unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition - positionOffset);
    221         return GridSpan::definiteGridSpan(initialResolvedPosition, resolvedOppositePosition);
    222     }
    223 
    224     return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
     217    if (isStartSide(side))
     218        return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - positionOffset, resolvedOppositePosition);
     219
     220    return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
    225221}
    226222
    … …  
    243239}
    244240
    245 static unsigned resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
     241static int resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
    246242{
    247243    switch (position.type()) {
    … …  
    256252            return position.integerPosition() - 1;
    257253
    258         unsigned resolvedPosition = abs(position.integerPosition()) - 1;
     254        unsigned resolvedPosition = std::abs(position.integerPosition()) - 1;
    259255        const unsigned endOfTrack = explicitGridSizeForSide(gridContainerStyle, side);
    260 
    261         // Per http://lists.w3.org/Archives/Public/www-style/2013Mar/0589.html, we clamp negative value to the first line.
    262         if (endOfTrack < resolvedPosition)
    263             return 0;
    264256
    265257        return endOfTrack - resolvedPosition;
    … …  
    324316    }
    325317
    326     unsigned resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
    327     unsigned resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
     318    int resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
     319    int resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
    328320
    329321    if (resolvedInitialPosition > resolvedFinalPosition)
    … …  
    332324        resolvedFinalPosition = resolvedInitialPosition + 1;
    333325
    334     return GridSpan::definiteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
     326    return GridSpan::untranslatedDefiniteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
    335327}
    336328
Note: See TracChangeset for help on using the changeset viewer.