Changeset 192054 in webkit


Ignore:
Timestamp:
Nov 5, 2015 1:30:30 AM (8 years ago)
Author:
Manuel Rego Casasnovas
Message:

[css-grid] Support positioned grid children
​https://bugs.webkit.org/show_bug.cgi?id=150837

Reviewed by Darin Adler.

Source/WebCore:

According to the spec positioned grid children have
a special behavior described at:
​https://drafts.csswg.org/css-grid/#abspos

The idea is that for positioned children the containing block will
correspond to the padding edges of the grid container, unless the
grid placement properties are defined.
This not only affects to positioned grid items (direct children) but
also to any descendant where the containing block is the grid container.

In order to manage this special behavior, the patch is overriding
RenderBlock::layoutPositionedObject() to calculate the position and size
depending on the grid-placement properties.

RenderBox class has some changes to calculate the containing block width
and height for positioned objects (using the override value). And also
to compute their static position.

Finally, the positioned items are not taken into account in all the
different grid methods, in order that they do not interfere the layout
of the grid as stated in the spec.

Tests: fast/css-grid-layout/absolute-positioning-grid-container-containing-block.html

fast/css-grid-layout/absolute-positioning-grid-container-parent.html
fast/css-grid-layout/grid-positioned-items-background.html
fast/css-grid-layout/grid-positioned-items-implicit-grid-line.html
fast/css-grid-layout/grid-positioned-items-implicit-grid.html
fast/css-grid-layout/grid-positioned-items-unknown-named-grid-line.html
fast/css-grid-layout/grid-sizing-positioned-items.html
fast/css-grid-layout/positioned-grid-items-should-not-create-implicit-tracks.html
fast/css-grid-layout/positioned-grid-items-should-not-take-up-space.html

  • rendering/OrderIterator.cpp:

(WebCore::OrderIterator::next): Fix method to avoid issues if no items
are added to the iterator.

  • rendering/RenderBlock.h: Mark layoutPositionedObject() as virtual.
  • rendering/RenderBox.cpp: Add new maps for inline/block extra offsets.

(WebCore::RenderBox::~RenderBox): Clear the new maps.
(WebCore::RenderBox::extraInlineOffset): Extra offset that we need to
apply to positioned grid children due to the grid placement properties.
(WebCore::RenderBox::extraBlockOffset): Ditto.
(WebCore::RenderBox::setExtraInlineOffset):
(WebCore::RenderBox::setExtraBlockOffset):
(WebCore::RenderBox::clearExtraInlineAndBlockOffests):
(WebCore::RenderBox::containingBlockLogicalWidthForPositioned): Use the
override containing block if any.
(WebCore::RenderBox::containingBlockLogicalHeightForPositioned): Ditto.
(WebCore::RenderBox::computePositionedLogicalWidth): Add the extra
offset if it's a positioned element.
(WebCore::RenderBox::computePositionedLogicalHeight): Ditto.

  • rendering/RenderBox.h:

(WebCore::RenderBox::scrollbarLogicalWidth): Add utility method.

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::layoutBlock): Clear grid after layout positioned
objects instead of at the end of layoutGridItems().
(WebCore::RenderGrid::placeItemsOnGrid): Ignore positioned items.
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator): Ditto.
(WebCore::RenderGrid::layoutGridItems): Ditto.
(WebCore::RenderGrid::prepareChildForPositionedLayout): Set static
position for positioned items.
(WebCore::RenderGrid::layoutPositionedObject): Calculate position and
size for positioned children.
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild): Calculate
extra offset and breadth for positioned children.

  • rendering/RenderGrid.h:
  • rendering/style/GridResolvedPosition.cpp:

(WebCore::GridResolvedPosition::isNonExistentNamedLineOrArea): Make it a
public static method.
(WebCore::GridUnresolvedSpan::adjustGridPositionsFromStyle): Fix calls
to isNonExistentNamedLineOrArea().
(WebCore::resolveGridPositionFromStyle): Ditto.

  • rendering/style/GridResolvedPosition.h: Make

isNonExistentNamedLineOrArea() public.

LayoutTests:

  • fast/css-grid-layout/absolute-positioning-grid-container-containing-block-expected.txt: Added.
  • fast/css-grid-layout/absolute-positioning-grid-container-containing-block.html: Added.
  • fast/css-grid-layout/absolute-positioning-grid-container-parent-expected.txt: Added.
  • fast/css-grid-layout/absolute-positioning-grid-container-parent.html: Added.
  • fast/css-grid-layout/grid-positioned-items-background-expected.html: Added.
  • fast/css-grid-layout/grid-positioned-items-background.html: Added.
  • fast/css-grid-layout/grid-positioned-items-implicit-grid-expected.txt: Added.
  • fast/css-grid-layout/grid-positioned-items-implicit-grid-line-expected.txt: Added.
  • fast/css-grid-layout/grid-positioned-items-implicit-grid-line.html: Added.
  • fast/css-grid-layout/grid-positioned-items-implicit-grid.html: Added.
  • fast/css-grid-layout/grid-positioned-items-unknown-named-grid-line-expected.txt: Added.
  • fast/css-grid-layout/grid-positioned-items-unknown-named-grid-line.html: Added.
  • fast/css-grid-layout/grid-sizing-positioned-items-expected.txt: Added.
  • fast/css-grid-layout/grid-sizing-positioned-items.html: Added.
  • fast/css-grid-layout/positioned-grid-items-should-not-create-implicit-tracks-expected.txt: Added.
  • fast/css-grid-layout/positioned-grid-items-should-not-create-implicit-tracks.html: Added.
  • fast/css-grid-layout/positioned-grid-items-should-not-take-up-space-expected.txt: Added.
  • fast/css-grid-layout/positioned-grid-items-should-not-take-up-space.html: Added.
  • fast/css-grid-layout/resources/grid.css: Added some common CSS classes.
Location:
trunk
Files:
18 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r192043 r192054  
     12015-11-05  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] Support positioned grid children
     4        https://bugs.webkit.org/show_bug.cgi?id=150837
     5
     6        Reviewed by Darin Adler.
     7
     8        * fast/css-grid-layout/absolute-positioning-grid-container-containing-block-expected.txt: Added.
     9        * fast/css-grid-layout/absolute-positioning-grid-container-containing-block.html: Added.
     10        * fast/css-grid-layout/absolute-positioning-grid-container-parent-expected.txt: Added.
     11        * fast/css-grid-layout/absolute-positioning-grid-container-parent.html: Added.
     12        * fast/css-grid-layout/grid-positioned-items-background-expected.html: Added.
     13        * fast/css-grid-layout/grid-positioned-items-background.html: Added.
     14        * fast/css-grid-layout/grid-positioned-items-implicit-grid-expected.txt: Added.
     15        * fast/css-grid-layout/grid-positioned-items-implicit-grid-line-expected.txt: Added.
     16        * fast/css-grid-layout/grid-positioned-items-implicit-grid-line.html: Added.
     17        * fast/css-grid-layout/grid-positioned-items-implicit-grid.html: Added.
     18        * fast/css-grid-layout/grid-positioned-items-unknown-named-grid-line-expected.txt: Added.
     19        * fast/css-grid-layout/grid-positioned-items-unknown-named-grid-line.html: Added.
     20        * fast/css-grid-layout/grid-sizing-positioned-items-expected.txt: Added.
     21        * fast/css-grid-layout/grid-sizing-positioned-items.html: Added.
     22        * fast/css-grid-layout/positioned-grid-items-should-not-create-implicit-tracks-expected.txt: Added.
     23        * fast/css-grid-layout/positioned-grid-items-should-not-create-implicit-tracks.html: Added.
     24        * fast/css-grid-layout/positioned-grid-items-should-not-take-up-space-expected.txt: Added.
     25        * fast/css-grid-layout/positioned-grid-items-should-not-take-up-space.html: Added.
     26        * fast/css-grid-layout/resources/grid.css: Added some common CSS classes.
     27
    1282015-11-04  Jiewen Tan  <jiewen_tan@apple.com>
    229

  • trunk/LayoutTests/fast/css-grid-layout/resources/grid.css

    r190663 r192054  
    2222}
    2323
     24.onlyFirstRowOnlyFirstColumn {
     25    background-color: blue;
     26    -webkit-grid-column: 1 / 2;
     27    -webkit-grid-row: 1 / 2;
     28}
     29
    2430.firstRowSecondColumn {
    2531    background-color: lime;
    2632    -webkit-grid-column: 2;
    2733    -webkit-grid-row: 1;
     34}
     35
     36.onlyFirstRowOnlySecondColumn {
     37    background-color: lime;
     38    -webkit-grid-column: 2 / 3;
     39    -webkit-grid-row: 1 / 2;
    2840}
    2941
    … …  
    4658}
    4759
     60.onlySecondRowOnlyFirstColumn {
     61    background-color: purple;
     62    -webkit-grid-column: 1 / 2;
     63    -webkit-grid-row: 2 / 3;
     64}
     65
    4866.secondRowSecondColumn {
    4967    background-color: orange;
    5068    -webkit-grid-column: 2;
    5169    -webkit-grid-row: 2;
     70}
     71
     72.onlySecondRowOnlySecondColumn {
     73    background-color: orange;
     74    -webkit-grid-column: 2 / 3;
     75    -webkit-grid-row: 2 / 3;
     76}
     77
     78.endSecondRowEndSecondColumn {
     79    background-color: orange;
     80    -webkit-grid-column-end: 3;
     81    -webkit-grid-row-end: 3;
    5282}
    5383

  • trunk/Source/WebCore/ChangeLog

    r192043 r192054  
     12015-11-05  Manuel Rego Casasnovas  <rego@igalia.com>
     2
     3        [css-grid] Support positioned grid children
     4        https://bugs.webkit.org/show_bug.cgi?id=150837
     5
     6        Reviewed by Darin Adler.
     7
     8        According to the spec positioned grid children have
     9        a special behavior described at:
     10        https://drafts.csswg.org/css-grid/#abspos
     11
     12        The idea is that for positioned children the containing block will
     13        correspond to the padding edges of the grid container, unless the
     14        grid placement properties are defined.
     15        This not only affects to positioned grid items (direct children) but
     16        also to any descendant where the containing block is the grid container.
     17
     18        In order to manage this special behavior, the patch is overriding
     19        RenderBlock::layoutPositionedObject() to calculate the position and size
     20        depending on the grid-placement properties.
     21
     22        RenderBox class has some changes to calculate the containing block width
     23        and height for positioned objects (using the override value). And also
     24        to compute their static position.
     25
     26        Finally, the positioned items are not taken into account in all the
     27        different grid methods, in order that they do not interfere the layout
     28        of the grid as stated in the spec.
     29
     30        Tests: fast/css-grid-layout/absolute-positioning-grid-container-containing-block.html
     31               fast/css-grid-layout/absolute-positioning-grid-container-parent.html
     32               fast/css-grid-layout/grid-positioned-items-background.html
     33               fast/css-grid-layout/grid-positioned-items-implicit-grid-line.html
     34               fast/css-grid-layout/grid-positioned-items-implicit-grid.html
     35               fast/css-grid-layout/grid-positioned-items-unknown-named-grid-line.html
     36               fast/css-grid-layout/grid-sizing-positioned-items.html
     37               fast/css-grid-layout/positioned-grid-items-should-not-create-implicit-tracks.html
     38               fast/css-grid-layout/positioned-grid-items-should-not-take-up-space.html
     39
     40        * rendering/OrderIterator.cpp:
     41        (WebCore::OrderIterator::next): Fix method to avoid issues if no items
     42        are added to the iterator.
     43        * rendering/RenderBlock.h: Mark layoutPositionedObject() as virtual.
     44        * rendering/RenderBox.cpp: Add new maps for inline/block extra offsets.
     45        (WebCore::RenderBox::~RenderBox): Clear the new maps.
     46        (WebCore::RenderBox::extraInlineOffset): Extra offset that we need to
     47        apply to positioned grid children due to the grid placement properties.
     48        (WebCore::RenderBox::extraBlockOffset): Ditto.
     49        (WebCore::RenderBox::setExtraInlineOffset):
     50        (WebCore::RenderBox::setExtraBlockOffset):
     51        (WebCore::RenderBox::clearExtraInlineAndBlockOffests):
     52        (WebCore::RenderBox::containingBlockLogicalWidthForPositioned): Use the
     53        override containing block if any.
     54        (WebCore::RenderBox::containingBlockLogicalHeightForPositioned): Ditto.
     55        (WebCore::RenderBox::computePositionedLogicalWidth): Add the extra
     56        offset if it's a positioned element.
     57        (WebCore::RenderBox::computePositionedLogicalHeight): Ditto.
     58        * rendering/RenderBox.h:
     59        (WebCore::RenderBox::scrollbarLogicalWidth): Add utility method.
     60        * rendering/RenderGrid.cpp:
     61        (WebCore::RenderGrid::layoutBlock): Clear grid after layout positioned
     62        objects instead of at the end of layoutGridItems().
     63        (WebCore::RenderGrid::placeItemsOnGrid): Ignore positioned items.
     64        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator): Ditto.
     65        (WebCore::RenderGrid::layoutGridItems): Ditto.
     66        (WebCore::RenderGrid::prepareChildForPositionedLayout): Set static
     67        position for positioned items.
     68        (WebCore::RenderGrid::layoutPositionedObject): Calculate position and
     69        size for positioned children.
     70        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild): Calculate
     71        extra offset and breadth for positioned children.
     72        * rendering/RenderGrid.h:
     73        * rendering/style/GridResolvedPosition.cpp:
     74        (WebCore::GridResolvedPosition::isNonExistentNamedLineOrArea): Make it a
     75        public static method.
     76        (WebCore::GridUnresolvedSpan::adjustGridPositionsFromStyle): Fix calls
     77        to isNonExistentNamedLineOrArea().
     78        (WebCore::resolveGridPositionFromStyle): Ditto.
     79        * rendering/style/GridResolvedPosition.h: Make
     80        isNonExistentNamedLineOrArea() public.
     81
    1822015-11-04  Jiewen Tan  <jiewen_tan@apple.com>
    283

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

    r169372 r192054  
    6060        }
    6161
     62        if (m_orderIndex != cInvalidIndex)
     63            ++m_orderIndex;
     64        else
     65            m_orderIndex = 0;
     66
    6267        if (m_orderIndex == endIndex)
    6368            return nullptr;
    64 
    65         if (m_orderIndex != cInvalidIndex) {
    66             ++m_orderIndex;
    67             if (m_orderIndex == endIndex)
    68                 return nullptr;
    69         } else
    70             m_orderIndex = 0;
    7169
    7270        m_currentChild = m_containerBox.firstChildBox();

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

    r191610 r192054  
    314314
    315315    void layoutPositionedObjects(bool relayoutChildren, bool fixedPositionObjectsOnly = false);
    316     void layoutPositionedObject(RenderBox&, bool relayoutChildren, bool fixedPositionObjectsOnly);
     316    virtual void layoutPositionedObject(RenderBox&, bool relayoutChildren, bool fixedPositionObjectsOnly);
    317317   
    318318    void markFixedPositionObjectForLayoutIfNeeded(RenderObject& child);

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

    r191915 r192054  
    9696static OverrideOptionalSizeMap* gOverrideContainingBlockLogicalHeightMap = nullptr;
    9797static OverrideOptionalSizeMap* gOverrideContainingBlockLogicalWidthMap = nullptr;
     98static OverrideSizeMap* gExtraInlineOffsetMap = nullptr;
     99static OverrideSizeMap* gExtraBlockOffsetMap = nullptr;
    98100#endif
    99101
    … …  
    142144#if ENABLE(CSS_GRID_LAYOUT)
    143145    clearContainingBlockOverrideSize();
     146    clearExtraInlineAndBlockOffests();
    144147#endif
    145148
    … …  
    11371140    if (gOverrideContainingBlockLogicalHeightMap)
    11381141        gOverrideContainingBlockLogicalHeightMap->remove(this);
     1142}
     1143
     1144LayoutUnit RenderBox::extraInlineOffset() const
     1145{
     1146    return gExtraInlineOffsetMap ? gExtraInlineOffsetMap->get(this) : LayoutUnit();
     1147}
     1148
     1149LayoutUnit RenderBox::extraBlockOffset() const
     1150{
     1151    return gExtraBlockOffsetMap ? gExtraBlockOffsetMap->get(this) : LayoutUnit();
     1152}
     1153
     1154void RenderBox::setExtraInlineOffset(LayoutUnit inlineOffest)
     1155{
     1156    if (!gExtraInlineOffsetMap)
     1157        gExtraInlineOffsetMap = new OverrideSizeMap;
     1158    gExtraInlineOffsetMap->set(this, inlineOffest);
     1159}
     1160
     1161void RenderBox::setExtraBlockOffset(LayoutUnit blockOffest)
     1162{
     1163    if (!gExtraBlockOffsetMap)
     1164        gExtraBlockOffsetMap = new OverrideSizeMap;
     1165    gExtraBlockOffsetMap->set(this, blockOffest);
     1166}
     1167
     1168void RenderBox::clearExtraInlineAndBlockOffests()
     1169{
     1170    if (gExtraInlineOffsetMap)
     1171        gExtraInlineOffsetMap->remove(this);
     1172    if (gExtraBlockOffsetMap)
     1173        gExtraBlockOffsetMap->remove(this);
    11391174}
    11401175#endif // ENABLE(CSS_GRID_LAYOUT)
    … …  
    31713206        return containingBlockLogicalHeightForPositioned(containingBlock, false);
    31723207
     3208#if ENABLE(CSS_GRID_LAYOUT)
     3209    if (hasOverrideContainingBlockLogicalWidth()) {
     3210        if (auto overrideLogicalWidth = overrideContainingBlockContentLogicalWidth())
     3211            return overrideLogicalWidth.value();
     3212    }
     3213#endif
     3214
    31733215    if (is<RenderBox>(*containingBlock)) {
    31743216        bool isFixedPosition = style().position() == FixedPosition;
    … …  
    32333275    if (checkForPerpendicularWritingMode && containingBlock->isHorizontalWritingMode() != isHorizontalWritingMode())
    32343276        return containingBlockLogicalWidthForPositioned(containingBlock, nullptr, false);
     3277
     3278#if ENABLE(CSS_GRID_LAYOUT)
     3279    if (hasOverrideContainingBlockLogicalHeight()) {
     3280        if (auto overrideLogicalHeight = overrideContainingBlockContentLogicalHeight())
     3281            return overrideLogicalHeight.value();
     3282    }
     3283#endif
    32353284
    32363285    if (containingBlock->isBox()) {
    … …  
    34313480        }
    34323481    }
     3482
     3483#if ENABLE(CSS_GRID_LAYOUT)
     3484    if (!style().hasStaticInlinePosition(isHorizontal))
     3485        computedValues.m_position += extraInlineOffset();
     3486#endif
    34333487
    34343488    computedValues.m_extent += bordersPlusPadding;
    … …  
    37513805    }
    37523806
     3807#if ENABLE(CSS_GRID_LAYOUT)
     3808    if (!style().hasStaticBlockPosition(isHorizontalWritingMode()))
     3809        computedValues.m_position += extraBlockOffset();
     3810#endif
     3811
    37533812    // Set final height value.
    37543813    computedValues.m_extent += bordersPlusPadding;

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

    r191234 r192054  
    327327    void clearContainingBlockOverrideSize();
    328328    void clearOverrideContainingBlockContentLogicalHeight();
     329    LayoutUnit extraInlineOffset() const;
     330    LayoutUnit extraBlockOffset() const;
     331    void setExtraInlineOffset(LayoutUnit);
     332    void setExtraBlockOffset(LayoutUnit);
     333    void clearExtraInlineAndBlockOffests();
    329334#endif
    330335
    … …  
    450455    int horizontalScrollbarHeight() const;
    451456    int intrinsicScrollbarLogicalWidth() const;
     457    int scrollbarLogicalWidth() const { return style().isHorizontalWritingMode() ? verticalScrollbarWidth() : horizontalScrollbarHeight(); }
    452458    int scrollbarLogicalHeight() const { return style().isHorizontalWritingMode() ? horizontalScrollbarHeight() : verticalScrollbarWidth(); }
    453459    virtual bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1, Element** stopElement = nullptr, RenderBox* startBox = nullptr, const IntPoint& wheelEventAbsolutePoint = IntPoint());

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

    r191879 r192054  
    323323    layoutPositionedObjects(relayoutChildren || isDocumentElementRenderer());
    324324
     325    clearGrid();
     326
    325327    computeOverflow(oldClientAfterEdge);
    326328    statePusher.pop();
    … …  
    10511053    Vector<RenderBox*> specifiedMajorAxisAutoGridItems;
    10521054    for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
     1055        if (child->isOutOfFlowPositioned())
     1056            continue;
     1057
    10531058        auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
    10541059        auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
    … …  
    10831088
    10841089    for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
     1090        if (child->isOutOfFlowPositioned())
     1091            continue;
     1092
    10851093        populator.collectChild(*child);
    10861094
    … …  
    12871295
    12881296    for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
     1297        if (child->isOutOfFlowPositioned()) {
     1298            prepareChildForPositionedLayout(*child);
     1299            continue;
     1300        }
     1301
    12891302        // Because the grid area cannot be styled, we don't need to adjust
    12901303        // the grid breadth to account for 'box-sizing'.
    … …  
    13371350    }
    13381351    setLogicalHeight(height);
    1339 
    1340     clearGrid();
     1352}
     1353
     1354void RenderGrid::prepareChildForPositionedLayout(RenderBox& child)
     1355{
     1356    ASSERT(child.isOutOfFlowPositioned());
     1357    child.containingBlock()->insertPositionedObject(child);
     1358
     1359    RenderLayer* childLayer = child.layer();
     1360    childLayer->setStaticInlinePosition(borderAndPaddingStart());
     1361    childLayer->setStaticBlockPosition(borderAndPaddingBefore());
     1362}
     1363
     1364void RenderGrid::layoutPositionedObject(RenderBox& child, bool relayoutChildren, bool fixedPositionObjectsOnly)
     1365{
     1366    bool hasOrthogonalWritingMode = child.isHorizontalWritingMode() != isHorizontalWritingMode();
     1367    // FIXME: Properly support orthogonal writing mode.
     1368    if (!hasOrthogonalWritingMode) {
     1369        LayoutUnit columnOffset = LayoutUnit();
     1370        LayoutUnit columnBreadth = LayoutUnit();
     1371        offsetAndBreadthForPositionedChild(child, ForColumns, columnOffset, columnBreadth);
     1372        LayoutUnit rowOffset = LayoutUnit();
     1373        LayoutUnit rowBreadth = LayoutUnit();
     1374        offsetAndBreadthForPositionedChild(child, ForRows, rowOffset, rowBreadth);
     1375
     1376        child.setOverrideContainingBlockContentLogicalWidth(columnBreadth);
     1377        child.setOverrideContainingBlockContentLogicalHeight(rowBreadth);
     1378        child.setExtraInlineOffset(columnOffset);
     1379        child.setExtraBlockOffset(rowOffset);
     1380    }
     1381
     1382    RenderBlock::layoutPositionedObject(child, relayoutChildren, fixedPositionObjectsOnly);
     1383}
     1384
     1385void RenderGrid::offsetAndBreadthForPositionedChild(const RenderBox& child, GridTrackSizingDirection direction, LayoutUnit& offset, LayoutUnit& breadth)
     1386{
     1387    ASSERT(child.isHorizontalWritingMode() == isHorizontalWritingMode());
     1388
     1389    auto unresolvedPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), child, direction);
     1390    if (unresolvedPositions.requiresAutoPlacement()) {
     1391        offset = LayoutUnit();
     1392        breadth = (direction == ForColumns) ? clientLogicalWidth() : clientLogicalHeight();
     1393        return;
     1394    }
     1395
     1396    GridPosition startPosition = (direction == ForColumns) ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();
     1397    GridPosition endPosition = (direction == ForColumns) ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
     1398    size_t lastTrackIndex = (direction == ForColumns ? gridColumnCount() : gridRowCount()) - 1;
     1399
     1400    GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedPositions, style());
     1401    bool startIsAuto = startPosition.isAuto()
     1402        || (startPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
     1403        || (positions.resolvedInitialPosition.toInt() > lastTrackIndex);
     1404    bool endIsAuto = endPosition.isAuto()
     1405        || (endPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
     1406        || (positions.resolvedFinalPosition.toInt() > lastTrackIndex);
     1407
     1408    GridResolvedPosition firstPosition = GridResolvedPosition(0);
     1409    GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition;
     1410    GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
     1411    GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition;
     1412
     1413    // Positioned children do not grow the grid, so we need to clamp the positions to avoid ending up outside of it.
     1414    initialPosition = std::min<GridResolvedPosition>(initialPosition, lastPosition);
     1415    finalPosition = std::min<GridResolvedPosition>(finalPosition, lastPosition);
     1416
     1417    LayoutUnit start = startIsAuto ? LayoutUnit() : (direction == ForColumns) ?  m_columnPositions[initialPosition.toInt()] : m_rowPositions[initialPosition.toInt()];
     1418    LayoutUnit end = endIsAuto ? (direction == ForColumns) ? logicalWidth() : logicalHeight() : (direction == ForColumns) ?  m_columnPositions[finalPosition.next().toInt()] : m_rowPositions[finalPosition.next().toInt()];
     1419
     1420    breadth = end - start;
     1421
     1422    if (startIsAuto)
     1423        breadth -= (direction == ForColumns) ? borderStart() : borderBefore();
     1424    else
     1425        start -= ((direction == ForColumns) ? borderStart() : borderBefore());
     1426
     1427    if (endIsAuto) {
     1428        breadth -= (direction == ForColumns) ? borderEnd() : borderAfter();
     1429        breadth -= scrollbarLogicalWidth();
     1430    }
     1431
     1432    offset = start;
     1433
     1434    if (child.parent() == this && !startIsAuto) {
     1435        // If column/row start is "auto" the static position has been already set in prepareChildForPositionedLayout().
     1436        RenderLayer* childLayer = child.layer();
     1437        if (direction == ForColumns)
     1438            childLayer->setStaticInlinePosition(borderStart() + offset);
     1439        else
     1440            childLayer->setStaticBlockPosition(borderBefore() + offset);
     1441    }
    13411442}
    13421443

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

    r191610 r192054  
    8989
    9090    void layoutGridItems();
     91    void prepareChildForPositionedLayout(RenderBox&);
     92    void layoutPositionedObject(RenderBox&, bool relayoutChildren, bool fixedPositionObjectsOnly) override;
     93    void offsetAndBreadthForPositionedChild(const RenderBox&, GridTrackSizingDirection, LayoutUnit& offset, LayoutUnit& breadth);
    9194    void populateGridPositions(GridSizingData&);
    9295    void clearGrid();

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

    r185059 r192054  
    5959}
    6060
    61 static bool isNonExistentNamedLineOrArea(const String& lineName, const RenderStyle& style, GridPositionSide side)
     61bool GridResolvedPosition::isNonExistentNamedLineOrArea(const String& lineName, const RenderStyle& style, GridPositionSide side)
    6262{
    6363    const NamedGridLinesMap& gridLineNames = gridLinesForSide(style, side);
    … …  
    8282    // GridResolvedPosition::resolveGrisPositionFromStyle() won't require the autoplacement to run, i.e., it'll always return a
    8383    // valid resolved position.
    84     if (m_initialPosition.isNamedGridArea() && isNonExistentNamedLineOrArea(m_initialPosition.namedGridLine(), gridContainerStyle, m_initialPositionSide))
     84    if (m_initialPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_initialPosition.namedGridLine(), gridContainerStyle, m_initialPositionSide))
    8585        m_initialPosition.setAutoPosition();
    8686
    87     if (m_finalPosition.isNamedGridArea() && isNonExistentNamedLineOrArea(m_finalPosition.namedGridLine(), gridContainerStyle, m_finalPositionSide))
     87    if (m_finalPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_finalPosition.namedGridLine(), gridContainerStyle, m_finalPositionSide))
    8888        m_finalPosition.setAutoPosition();
    8989
    … …  
    273273        // line to the grid item's placement.
    274274        String namedGridLine = position.namedGridLine();
    275         ASSERT(!isNonExistentNamedLineOrArea(namedGridLine, gridContainerStyle, side));
     275        ASSERT(!GridResolvedPosition::isNonExistentNamedLineOrArea(namedGridLine, gridContainerStyle, side));
    276276
    277277        const NamedGridLinesMap& gridLineNames = gridLinesForSide(gridContainerStyle, side);

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

    r185059 r192054  
    139139    static unsigned explicitGridColumnCount(const RenderStyle&);
    140140    static unsigned explicitGridRowCount(const RenderStyle&);
     141    static bool isNonExistentNamedLineOrArea(const String& lineName, const RenderStyle&, GridPositionSide);
    141142
    142143private:
Note: See TracChangeset for help on using the changeset viewer.