Attachment #234753 for bug #134057

View Details Raw Unified Return to Bug 134057

| Differences between



2014-07-11  Manuel Rego Casasnovas  <rego@igalia.com>

        [CSS Grid Layout] Update grid-auto-flow to the new syntax
        https://bugs.webkit.org/show_bug.cgi?id=134057

        Reviewed by Sergio Villar Senin.

        In last versions of the spec grid-auto-flow syntax has changed. New
        syntax is:
        [ row | column ] && dense? | stack && [ row | column ]?

        Implemented parsing for new syntax and added/modified test cases in
        current layout tests.

        For the moment, the implementation keeps working in the same way, but
        using "stack" value for grid-auto-flow property instead of "none". This
        should be fixed in a follow-up patch once "stack" is properly
        implemented.

        Also "dense" needs to be reviewed. Right now auto-placement algorithm is
        always "dense" and never "sparse".

        No new tests, update current tests to add new cases.

        * css/CSSComputedStyleDeclaration.cpp:
        (WebCore::ComputedStyleExtractor::propertyValue): Adapt to new syntax.
        * css/CSSParser.cpp:
        (WebCore::isValidKeywordPropertyAndValue): Removed grid-auto-flow as it
        is not a keyword anymore.
        (WebCore::isKeywordPropertyID): Ditto.
        (WebCore::CSSParser::parseValue): Add specific method for parsing
        grid-auto-flow.
        (WebCore::CSSParser::parseGridShorthand): Adapt parsing for
        grid-auto-flow property inside the shorthand.
        (WebCore::isValidGridAutoFlowId): Helper method to check if the CSSValue
        id is a valid keyword for grid-auto-flow property.
        (WebCore::CSSParser::parseGridAutoFlow): Implement new parsing for
        grid-auto-flow.
        * css/CSSParser.h: Method header for grid-auto-flow parsing.
        * css/CSSPrimitiveValueMappings.h:
        (WebCore::CSSPrimitiveValue::operator GridAutoFlow): Deleted.
        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue): Deleted.
        * css/CSSValueKeywords.in: Add new keywords required by grid-auto-flow:
        "dense" and "stack".
        * css/DeprecatedStyleBuilder.cpp:
        (WebCore::DeprecatedStyleBuilder::DeprecatedStyleBuilder): Remove
        default handler as grid-auto-flow is not a keyword now.
        * css/StyleResolver.cpp:
        (WebCore::StyleResolver::applyProperty): Implement particular handler
        for new grid-auto-flow syntax.
        * rendering/RenderGrid.cpp:
        (WebCore::RenderGrid::placeItemsOnGrid): Keep old "none" behavior as
        "stack" behavior for the moment.
        (WebCore::RenderGrid::autoPlacementMajorAxisDirection): Use the new
        helper methods in RenderStyle.
        (WebCore::RenderGrid::autoPlacementMinorAxisDirection): Ditto.
        * rendering/style/GridResolvedPosition.cpp:
        (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle): Again
        keep old "none" behavior for "stack".
        * rendering/style/RenderStyle.h: Add new helper methods to know the
        direction and algorithm of grid-auto-flow property.
        * rendering/style/RenderStyleConstants.h: Redefine GridAutoFlow enum
        using flags for algorithm and direction.
        * rendering/style/StyleGridData.h: Change m_gridAutoFlow type to
        unsigned.

2014-07-10  Brady Eidson  <beidson@apple.com>

        Phone number highlights should always be visible if the mouse hovers over.



            return list.release();
        }
#if ENABLE(CSS_GRID_LAYOUT)
        case CSSPropertyWebkitGridAutoFlow: {
            RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
            ASSERT(style->isGridAutoFlowDirectionRow() || style->isGridAutoFlowDirectionColumn());
            if (style->isGridAutoFlowDirectionRow())
                list->append(cssValuePool().createIdentifierValue(CSSValueRow));
            else
                list->append(cssValuePool().createIdentifierValue(CSSValueColumn));

            if (style->isGridAutoFlowAlgorithmDense())
                list->append(cssValuePool().createIdentifierValue(CSSValueDense));
            else if (style->isGridAutoFlowAlgorithmStack())
                list->append(cssValuePool().createIdentifierValue(CSSValueStack));

            return list.release();
        }

        // Specs mention that getComputedStyle() should return the used value of the property instead of the computed
        // one for grid-definition-{rows|columns} but not for the grid-auto-{rows|columns} as things like



        if (valueID == CSSValueNone || valueID == CSSValueManual || valueID == CSSValueAuto)
            return true;
        break;
#if ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyWebkitGridAutoFlow:
        if (valueID == CSSValueNone || valueID == CSSValueRow || valueID == CSSValueColumn)
            return true;
        break;
#endif
    case CSSPropertyWebkitLineAlign:
        if (valueID == CSSValueNone || valueID == CSSValueEdges)
            return true;

    case CSSPropertyWebkitFontKerning:
    case CSSPropertyWebkitFontSmoothing:
    case CSSPropertyWebkitHyphens:
#if ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyWebkitGridAutoFlow:
#endif
    case CSSPropertyWebkitLineAlign:
    case CSSPropertyWebkitLineBreak:
    case CSSPropertyWebkitLineSnap:

    case CSSPropertyWebkitGridTemplateAreas:
        parsedValue = parseGridTemplateAreas();
        break;
    case CSSPropertyWebkitGridAutoFlow:
        parsedValue = parseGridAutoFlow(*m_valueList);
        break;
#endif /* ENABLE(CSS_GRID_LAYOUT) */
    case CSSPropertyWebkitMarginCollapse: {
        if (num == 1) {

    case CSSPropertyWebkitFontKerning:
    case CSSPropertyWebkitFontSmoothing:
    case CSSPropertyWebkitHyphens:
#if ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyWebkitGridAutoFlow:
#endif
    case CSSPropertyWebkitLineAlign:
    case CSSPropertyWebkitLineBreak:
    case CSSPropertyWebkitLineSnap:

    m_valueList->setCurrentIndex(0);

    // 2- <grid-auto-flow> [ <grid-auto-columns> [ / <grid-auto-rows> ]? ]
    if (!parseValue(CSSPropertyWebkitGridAutoFlow, important))
    if (id != CSSValueRow && id != CSSValueColumn && id != CSSValueNone)
        return false;

    RefPtr<CSSValue> autoFlowValue = cssValuePool().createIdentifierValue(id);
    RefPtr<CSSValue> autoColumnsValue;
    RefPtr<CSSValue> autoRowsValue;

    if (m_valueList->current()) {
        autoColumnsValue = parseGridTrackSize(*m_valueList);
        if (!autoColumnsValue)
            return false;

    if (!autoRowsValue)
        autoRowsValue = autoColumnsValue;

    addProperty(CSSPropertyWebkitGridAutoFlow, autoFlowValue.release(), important);
    addProperty(CSSPropertyWebkitGridAutoColumns, autoColumnsValue.release(), important);
    addProperty(CSSPropertyWebkitGridAutoRows, autoRowsValue.release(), important);



    return createPrimitiveNumericValue(currentValue);
}

static inline bool isValidGridAutoFlowId(CSSValueID id)
{
    return (id == CSSValueRow || id == CSSValueColumn || id == CSSValueDense || id == CSSValueStack);
}

PassRefPtr<CSSValue> CSSParser::parseGridAutoFlow(CSSParserValueList& inputList)
{
    // [ row | column ] && dense? | stack && [ row | column ]?
    CSSParserValue* value = inputList.current();
    if (!value)
        return nullptr;

    RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();

    // First parameter.
    CSSValueID firstId = value->id;
    if (!isValidGridAutoFlowId(firstId))
        return nullptr;

    // Second parameter, if any.
    // If second parameter is not valid we should process anyway the first one as we can be inside the "grid" shorthand.
    value = inputList.next();
    if (!value || !isValidGridAutoFlowId(value->id)) {
        if (firstId == CSSValueDense)
            return nullptr;

        if (firstId == CSSValueStack)
            parsedValues->append(cssValuePool().createIdentifierValue(CSSValueRow));

        parsedValues->append(cssValuePool().createIdentifierValue(firstId));
        return parsedValues;
    }

    switch (firstId) {
    case CSSValueRow:
    case CSSValueColumn:
        parsedValues->append(cssValuePool().createIdentifierValue(firstId));
        if (value->id == CSSValueDense || value->id == CSSValueStack) {
            parsedValues->append(cssValuePool().createIdentifierValue(value->id));
            inputList.next();
        }
        break;
    case CSSValueDense:
    case CSSValueStack:
        if (value->id == CSSValueRow || value->id == CSSValueColumn) {
            parsedValues->append(cssValuePool().createIdentifierValue(value->id));
            inputList.next();
        }
        parsedValues->append(cssValuePool().createIdentifierValue(firstId));
        break;
    default:
        ASSERT_NOT_REACHED();
        break;
    }

    return parsedValues;
}
#endif /* ENABLE(CSS_GRID_LAYOUT) */

#if ENABLE(DASHBOARD_SUPPORT)

Lines 176-181 public: a/Source/WebCore/css/CSSParser.h_sec1
- a/Source/WebCore/css/CSSParser.h +1 lines
176	bool parseGridTemplateAreasRow(NamedGridAreaMap&, const unsigned, unsigned&);	176	bool parseGridTemplateAreasRow(NamedGridAreaMap&, const unsigned, unsigned&);
177	PassRefPtr<CSSValue> parseGridTemplateAreas();	177	PassRefPtr<CSSValue> parseGridTemplateAreas();
178	void parseGridLineNames(CSSParserValueList&, CSSValueList&, CSSGridLineNamesValue* = nullptr);	178	void parseGridLineNames(CSSParserValueList&, CSSValueList&, CSSGridLineNamesValue* = nullptr);
		179	PassRefPtr<CSSValue> parseGridAutoFlow(CSSParserValueList&);
179	#endif	180	#endif
180		181
181	bool parseDashboardRegions(CSSPropertyID, bool important);	182	bool parseDashboardRegions(CSSPropertyID, bool important);



    return NormalColumnProgression;
}

#if ENABLE(CSS_GRID_LAYOUT)
template<> inline CSSPrimitiveValue::operator GridAutoFlow() const
{
    ASSERT(isValueID());

    switch (m_value.valueID) {
    case CSSValueNone:
        return AutoFlowNone;
    case CSSValueColumn:
        return AutoFlowColumn;
    case CSSValueRow:
        return AutoFlowRow;
    default:
        break;
    }

    ASSERT_NOT_REACHED();
    return AutoFlowNone;

}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(GridAutoFlow flow)
    : CSSValue(PrimitiveClass)
{
    m_primitiveUnitType = CSS_VALUE_ID;
    switch (flow) {
    case AutoFlowNone:
        m_value.valueID = CSSValueNone;
        break;
    case AutoFlowColumn:
        m_value.valueID = CSSValueColumn;
        break;
    case AutoFlowRow:
        m_value.valueID = CSSValueRow;
        break;
    }
}
#endif /* ENABLE_(CSS_GRID_LAYOUT) */

enum LengthConversion {
    AnyConversion = ~0,
    FixedIntegerConversion = 1 << 0,

Lines 1042-1047 markers a/Source/WebCore/css/CSSValueKeywords.in_sec1
- a/Source/WebCore/css/CSSValueKeywords.in +4 lines
1042	// -webkit-grid-{column-start\|column-end\|row-start\|row-end}	1042	// -webkit-grid-{column-start\|column-end\|row-start\|row-end}
1043	span	1043	span
1044		1044
		1045	// -webkit-grid-auto-flow
		1046	dense
		1047	stack
		1048
1045	#if defined(ENABLE_CSS3_TEXT) && ENABLE_CSS3_TEXT	1049	#if defined(ENABLE_CSS3_TEXT) && ENABLE_CSS3_TEXT
1046	// text-indent	1050	// text-indent
1047	-webkit-each-line	1051	-webkit-each-line



    setPropertyHandler(CSSPropertyWebkitFlexGrow, ApplyPropertyDefault<float, &RenderStyle::flexGrow, float, &RenderStyle::setFlexGrow, float, &RenderStyle::initialFlexGrow>::createHandler());
    setPropertyHandler(CSSPropertyWebkitFlexShrink, ApplyPropertyDefault<float, &RenderStyle::flexShrink, float, &RenderStyle::setFlexShrink, float, &RenderStyle::initialFlexShrink>::createHandler());
    setPropertyHandler(CSSPropertyWebkitFlexWrap, ApplyPropertyDefault<EFlexWrap, &RenderStyle::flexWrap, EFlexWrap, &RenderStyle::setFlexWrap, EFlexWrap, &RenderStyle::initialFlexWrap>::createHandler());
#if ENABLE(CSS_GRID_LAYOUT)
    setPropertyHandler(CSSPropertyWebkitGridAutoFlow, ApplyPropertyDefault<GridAutoFlow, &RenderStyle::gridAutoFlow, GridAutoFlow, &RenderStyle::setGridAutoFlow, GridAutoFlow, &RenderStyle::initialGridAutoFlow>::createHandler());
#endif
    setPropertyHandler(CSSPropertyWebkitJustifyContent, ApplyPropertyDefault<EJustifyContent, &RenderStyle::justifyContent, EJustifyContent, &RenderStyle::setJustifyContent, EJustifyContent, &RenderStyle::initialJustifyContent>::createHandler());
    setPropertyHandler(CSSPropertyWebkitOrder, ApplyPropertyDefault<int, &RenderStyle::order, int, &RenderStyle::setOrder, int, &RenderStyle::initialOrder>::createHandler());
#if ENABLE(CSS_REGIONS)



        state.style()->setNamedGridAreaColumnCount(gridTemplateAreasValue->columnCount());
        return;
    }
    case CSSPropertyWebkitGridAutoFlow: {
        HANDLE_INHERIT_AND_INITIAL(gridAutoFlow, GridAutoFlow);
        if (!value->isValueList())
            return;
        CSSValueList* list = toCSSValueList(value);

        if (!list->length()) {
            state.style()->setGridAutoFlow(RenderStyle::initialGridAutoFlow());
            return;
        }

        CSSPrimitiveValue* first = toCSSPrimitiveValue(list->item(0));
        CSSPrimitiveValue* second = list->length() == 2 ? toCSSPrimitiveValue(list->item(1)) : nullptr;

        GridAutoFlow autoFlow = RenderStyle::initialGridAutoFlow();
        switch (first->getValueID()) {
        case CSSValueRow:
            if (second)
                autoFlow = second->getValueID() == CSSValueDense ? AutoFlowRowDense : AutoFlowStackRow;
            else
                autoFlow = AutoFlowRow;
            break;
        case CSSValueColumn:
            if (second)
                autoFlow = second->getValueID() == CSSValueDense ? AutoFlowColumnDense : AutoFlowStackColumn;
            else
                autoFlow = AutoFlowColumn;
            break;
        default:
            ASSERT_NOT_REACHED();
            break;
        }

        state.style()->setGridAutoFlow(autoFlow);
        return;
    }
#endif /* ENABLE(CSS_GRID_LAYOUT) */
    // These properties are aliased and DeprecatedStyleBuilder already applied the property on the prefixed version.
    case CSSPropertyTransitionDelay:




    Vector<RenderBox*> autoMajorAxisAutoGridItems;
    Vector<RenderBox*> specifiedMajorAxisAutoGridItems;
    GridAutoFlow autoFlow = style().gridAutoFlow();
    for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
        // FIXME: We never re-resolve positions if the grid is grown during auto-placement which may lead auto / <integer>
        // positions to not match the author's intent. The specification is unclear on what should be done in this case.

    ASSERT(gridRowCount() >= style().gridRows().size());
    ASSERT(gridColumnCount() >= style().gridColumns().size());

    // FIXME: Implement properly "stack" value in auto-placement algorithm.
    if (style().isGridAutoFlowAlgorithmStack()) {
        // If we did collect some grid items, they won't be placed thus never laid out.
        ASSERT(!autoMajorAxisAutoGridItems.size());
        ASSERT(!specifiedMajorAxisAutoGridItems.size());


GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const
{
    return style().isGridAutoFlowDirectionColumn() ? ForColumns : ForRows;
    ASSERT(flow != AutoFlowNone);
    return (flow == AutoFlowColumn) ? ForColumns : ForRows;
}

GridTrackSizingDirection RenderGrid::autoPlacementMinorAxisDirection() const
{
    return style().isGridAutoFlowDirectionColumn() ? ForRows : ForColumns;
    ASSERT(flow != AutoFlowNone);
    return (flow == AutoFlowColumn) ? ForRows : ForColumns;
}

void RenderGrid::clearGrid()



    adjustGridPositionsFromStyle(gridContainerStyle, initialPosition, finalPosition, initialPositionSide, finalPositionSide);

    if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition()) {
        // FIXME: Implement properly "stack" value in auto-placement algorithm.
        if (gridContainerStyle.isGridAutoFlowAlgorithmStack())
            return std::make_unique<GridSpan>(0, 0);

        // We can't get our grid positions without running the auto placement algorithm.



enum RubyPosition { RubyPositionBefore, RubyPositionAfter };

#if ENABLE(CSS_GRID_LAYOUT)
static const size_t GridAutoFlowBits = 5;
enum InternalGridAutoFlowAlgorithm {
    InternalAutoFlowAlgorithmSparse = 0x1,
    InternalAutoFlowAlgorithmDense = 0x2,
    InternalAutoFlowAlgorithmStack = 0x4
};

enum InternalGridAutoFlowDirection {
    InternalAutoFlowDirectionRow = 0x8,
    InternalAutoFlowDirectionColumn = 0x10
};

enum GridAutoFlow {
    AutoFlowRow = InternalAutoFlowAlgorithmSparse | InternalAutoFlowDirectionRow,
    AutoFlowColumn = InternalAutoFlowAlgorithmSparse | InternalAutoFlowDirectionColumn,
    AutoFlowRowDense = InternalAutoFlowAlgorithmDense | InternalAutoFlowDirectionRow,
    AutoFlowColumnDense = InternalAutoFlowAlgorithmDense | InternalAutoFlowDirectionColumn,
    AutoFlowStackRow = InternalAutoFlowAlgorithmStack | InternalAutoFlowDirectionRow,
    AutoFlowStackColumn = InternalAutoFlowAlgorithmStack | InternalAutoFlowDirectionColumn
};
#endif

// Reasonable maximum to prevent insane font sizes from causing crashes on some platforms (such as Windows).

Lines 67-73 public: a/Source/WebCore/rendering/style/StyleGridData.h_sec1
- a/Source/WebCore/rendering/style/StyleGridData.h -1 / +1 lines
67	OrderedNamedGridLinesMap m_orderedNamedGridColumnLines;	67	OrderedNamedGridLinesMap m_orderedNamedGridColumnLines;
68	OrderedNamedGridLinesMap m_orderedNamedGridRowLines;	68	OrderedNamedGridLinesMap m_orderedNamedGridRowLines;
69		69
70	GridAutoFlow m_gridAutoFlow;	70	unsigned m_gridAutoFlow : GridAutoFlowBits;
71		71
72	GridTrackSize m_gridAutoRows;	72	GridTrackSize m_gridAutoRows;
73	GridTrackSize m_gridAutoColumns;	73	GridTrackSize m_gridAutoColumns;



2014-07-11  Manuel Rego Casasnovas  <rego@igalia.com>

        [CSS Grid Layout] Update grid-auto-flow to the new syntax
        https://bugs.webkit.org/show_bug.cgi?id=134057

        Reviewed by Sergio Villar Senin.

        Adapted current tests to the new syntax. Keeping old "none" behavior
        using "stack".

        Add new use cases to cover the new syntax to grid-auto-flow-get-set.html
        and grid-shorthand-get-set.html.

        * fast/css-grid-layout/grid-auto-flow-get-set-expected.txt:
        * fast/css-grid-layout/grid-auto-flow-get-set.html:
        * fast/css-grid-layout/grid-auto-flow-resolution.html:
        * fast/css-grid-layout/grid-auto-flow-update-expected.txt:
        * fast/css-grid-layout/grid-auto-flow-update.html:
        * fast/css-grid-layout/grid-item-named-grid-area-resolution.html:
        * fast/css-grid-layout/grid-item-z-index-change-repaint.html:
        * fast/css-grid-layout/grid-item-z-index-stacking-context.html:
        * fast/css-grid-layout/grid-shorthand-get-set-expected.txt:
        * fast/css-grid-layout/grid-shorthand-get-set.html:
        * fast/css-grid-layout/named-grid-lines-with-named-grid-areas-dynamic-get-set.html:
        * fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html:
        * fast/css-grid-layout/resources/grid.css:
        (.gridAutoFlowStack):
        (.gridAutoFlowNone): Deleted.
        * fast/css/getComputedStyle/computed-style-expected.txt:
        * fast/css/getComputedStyle/computed-style-without-renderer-expected.txt:
        * ietestcenter/css3/grid/grid-column-001.htm:
        * ietestcenter/css3/grid/grid-column-002.htm:
        * ietestcenter/css3/grid/grid-column-003.htm:
        * svg/css/getComputedStyle-basic-expected.txt:

2014-07-10  Jinwoo Song  <jinwoo7.song@samsung.com>

        [EFL] Unreviewed EFL gardening.



Test that setting and getting -webkit-grid-auto-flow works as expected

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".


Test getting -webkit-grid-auto-flow set through CSS
PASS window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow') is 'none'
PASS window.getComputedStyle(gridAutoFlowColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'
PASS window.getComputedStyle(gridAutoFlowRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
PASS window.getComputedStyle(gridAutoFlowRowDense, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
PASS window.getComputedStyle(gridAutoFlowDenseColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
PASS window.getComputedStyle(gridAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
PASS window.getComputedStyle(gridAutoFlowStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
PASS window.getComputedStyle(gridAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
PASS window.getComputedStyle(gridAutoFlowStackRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
PASS window.getComputedStyle(gridAutoFlowColumnStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
PASS window.getComputedStyle(gridAutoFlowRowStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
PASS window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowColumns, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowRows, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowDense, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowColumnFoo, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowColumnColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowDenseColumnStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowDenseRowStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowStackRowRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(gridAutoFlowInherit, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'
PASS window.getComputedStyle(gridAutoFlowNoInherit, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'

Test the initial value
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'

Test getting and setting -webkit-grid-auto-flow through JS
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'

Test getting and setting bad values for -webkit-grid-auto-flow through JS
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'

Test setting -webkit-grid-auto-flow to 'initial' through JS
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS successfullyParsed is true

TEST COMPLETE



<head>
<link href="resources/grid.css" rel="stylesheet">
<style>
.gridAutoFlowColumnDense {
    -webkit-grid-auto-flow: column dense;
}
.gridAutoFlowRowDense {
    -webkit-grid-auto-flow: row dense;
}
.gridAutoFlowDenseColumn {
    -webkit-grid-auto-flow: dense column;
}
.gridAutoFlowDenseRow {
    -webkit-grid-auto-flow: dense row;
}
.gridAutoFlowStackColumn {
    -webkit-grid-auto-flow: stack column;
}
.gridAutoFlowStackRow {
    -webkit-grid-auto-flow: stack row;
}
.gridAutoFlowColumnStack {
    -webkit-grid-auto-flow: column stack;
}
.gridAutoFlowRowStack {
    -webkit-grid-auto-flow: row stack;
}
.gridAutoFlowInherit {
    -webkit-grid-auto-flow: inherit;
}
/* Bad values. */
.gridAutoFlowNone {
    -webkit-grid-auto-flow: none;
}
.gridAutoFlowRows {
    -webkit-grid-auto-flow: rows;
}
.gridAutoFlowColumns {
    -webkit-grid-auto-flow: columns;
}
.gridAutoFlowDense {
    -webkit-grid-auto-flow: dense;
}
.gridAutoFlowColumnFoo {
    -webkit-grid-auto-flow: column foo;
}
.gridAutoFlowColumnColumn {
    -webkit-grid-auto-flow: column column;
}
.gridAutoFlowDenseColumnStack {
    -webkit-grid-auto-flow: dense column stack;
}
.gridAutoFlowDenseRowStack {
    -webkit-grid-auto-flow: dense row stack;
}
.gridAutoFlowStackRowRow {
    -webkit-grid-auto-flow: stack row row;
}
</style>
<script src="../../resources/js-test-pre.js"></script>
</head>
<body>
<div class="grid" id="gridInitial"></div>
<div class="grid gridAutoFlowNone" id="gridAutoFlowNone"></div>
<div class="grid gridAutoFlowColumn" id="gridAutoFlowColumn"></div>
<div class="grid gridAutoFlowRow" id="gridAutoFlowRow"></div>
<div class="grid gridAutoFlowColumnDense" id="gridAutoFlowColumnDense"></div>
<div class="grid gridAutoFlowRowDense" id="gridAutoFlowRowDense"></div>
<div class="grid gridAutoFlowDenseColumn" id="gridAutoFlowDenseColumn"></div>
<div class="grid gridAutoFlowDenseRow" id="gridAutoFlowDenseRow"></div>
<div class="grid gridAutoFlowStack" id="gridAutoFlowStack"></div>
<div class="grid gridAutoFlowStackColumn" id="gridAutoFlowStackColumn"></div>
<div class="grid gridAutoFlowStackRow" id="gridAutoFlowStackRow"></div>
<div class="grid gridAutoFlowColumnStack" id="gridAutoFlowColumnStack"></div>
<div class="grid gridAutoFlowRowStack" id="gridAutoFlowRowStack"></div>
<div class="grid gridAutoFlowColumn">
    <div class="grid gridAutoFlowInherit" id="gridAutoFlowInherit"></div>
</div>
<div class="grid gridAutoFlowColumn">
    <div><div class="grid gridAutoFlowInherit" id="gridAutoFlowNoInherit"></div><div>
</div>
<div class="grid gridAutoFlowNone" id="gridAutoFlowNone"></div>
<div class="grid gridAutoFlowColumns" id="gridAutoFlowColumns"></div>
<div class="grid gridAutoFlowRows" id="gridAutoFlowRows"></div>
<div class="grid gridAutoFlowDense" id="gridAutoFlowDense"></div>
<div class="grid gridAutoFlowColumnFoo" id="gridAutoFlowColumnFoo"></div>
<div class="grid gridAutoFlowColumnColumn" id="gridAutoFlowColumnColumn"></div>
<div class="grid gridAutoFlowDenseColumnStack" id="gridAutoFlowDenseColumnStack"></div>
<div class="grid gridAutoFlowDenseRowStack" id="gridAutoFlowDenseRowStack"></div>
<div class="grid gridAutoFlowStackRowRow" id="gridAutoFlowStackRowRow"></div>
<script>
    description('Test that setting and getting -webkit-grid-auto-flow works as expected');

    debug("Test getting -webkit-auto-flow set through CSS");
    var gridAutoFlowNone = document.getElementById("gridAutoFlowNone");
    shouldBe("window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow')", "'none'");

    debug("Test getting -webkit-grid-auto-flow set through CSS");
    var gridAutoFlowColumn = document.getElementById("gridAutoFlowColumn");
    shouldBe("window.getComputedStyle(gridAutoFlowColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");

    var gridAutoFlowRow = document.getElementById("gridAutoFlowRow");
    shouldBe("window.getComputedStyle(gridAutoFlowRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowColumnDense = document.getElementById("gridAutoFlowColumnDense");
    shouldBe("window.getComputedStyle(gridAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");

    var gridAutoFlowRowDense = document.getElementById("gridAutoFlowRowDense");
    shouldBe("window.getComputedStyle(gridAutoFlowRowDense, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");

    var gridAutoFlowDenseColumn = document.getElementById("gridAutoFlowDenseColumn");
    shouldBe("window.getComputedStyle(gridAutoFlowDenseColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");

    var gridAutoFlowDenseRow = document.getElementById("gridAutoFlowDenseRow");
    shouldBe("window.getComputedStyle(gridAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");

    var gridAutoFlowStack = document.getElementById("gridAutoFlowStack");
    shouldBe("window.getComputedStyle(gridAutoFlowStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");

    var gridAutoFlowStackColumn = document.getElementById("gridAutoFlowStackColumn");
    shouldBe("window.getComputedStyle(gridAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");

    var gridAutoFlowStackRow = document.getElementById("gridAutoFlowStackRow");
    shouldBe("window.getComputedStyle(gridAutoFlowStackRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");

    var gridAutoFlowColumnStack = document.getElementById("gridAutoFlowColumnStack");
    shouldBe("window.getComputedStyle(gridAutoFlowColumnStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");

    var gridAutoFlowRowStack = document.getElementById("gridAutoFlowRowStack");
    shouldBe("window.getComputedStyle(gridAutoFlowRowStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");

    var gridAutoFlowNone= document.getElementById("gridAutoFlowNone");
    shouldBe("window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowColumns = document.getElementById("gridAutoFlowColumns");
    shouldBe("window.getComputedStyle(gridAutoFlowColumns, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowRows = document.getElementById("gridAutoFlowRows");
    shouldBe("window.getComputedStyle(gridAutoFlowRows, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowDense = document.getElementById("gridAutoFlowDense");
    shouldBe("window.getComputedStyle(gridAutoFlowDense, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowColumnFoo = document.getElementById("gridAutoFlowColumnFoo");
    shouldBe("window.getComputedStyle(gridAutoFlowColumnFoo, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowColumnColumn = document.getElementById("gridAutoFlowColumnColumn");
    shouldBe("window.getComputedStyle(gridAutoFlowColumnColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowDenseColumnStack = document.getElementById("gridAutoFlowDenseColumnStack");
    shouldBe("window.getComputedStyle(gridAutoFlowDenseColumnStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowDenseRowStack = document.getElementById("gridAutoFlowDenseRowStack");
    shouldBe("window.getComputedStyle(gridAutoFlowDenseRowStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowStackRowRow = document.getElementById("gridAutoFlowStackRowRow");
    shouldBe("window.getComputedStyle(gridAutoFlowStackRowRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    var gridAutoFlowInherit = document.getElementById("gridAutoFlowInherit");
    shouldBe("window.getComputedStyle(gridAutoFlowInherit, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");

    var gridAutoFlowNoInherit = document.getElementById("gridAutoFlowNoInherit");
    shouldBe("window.getComputedStyle(gridAutoFlowNoInherit, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    debug("");
    debug("Test the initial value");
    element = document.createElement("div");
    document.body.appendChild(element);
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    debug("");
    debug("Test getting and setting -webkit-grid-auto-flow through JS");
    element.style.webkitGridAutoFlow = "column";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");
    element.style.webkitGridAutoFlow = "column dense";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");
    element.style.webkitGridAutoFlow = "row dense";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");
    element.style.webkitGridAutoFlow = "dense column";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");
    element.style.webkitGridAutoFlow = "dense row";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");
    element.style.webkitGridAutoFlow = "row";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
    element.style.webkitGridAutoFlow = "stack";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
    element.style.webkitGridAutoFlow = "stack column";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");
    element.style.webkitGridAutoFlow = "stack row";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
    element.style.webkitGridAutoFlow = "column stack";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");
    element.style.webkitGridAutoFlow = "row stack";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");

    debug("");
    debug("Test getting and setting bad values for -webkit-grid-auto-flow through JS");
    element = document.createElement("div");
    document.body.appendChild(element);
    element.style.webkitGridAutoFlow = "noone";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
    element.style.webkitGridAutoFlow = "dense";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
    element.style.webkitGridAutoFlow = "column column";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
    element.style.webkitGridAutoFlow = "dense column stack";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
    element.style.webkitGridAutoFlow = "dense row stack";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
    element.style.webkitGridAutoFlow = "stack row row";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");

    debug("");
    debug("Test setting -webkit-grid-auto-flow to 'initial' through JS");
    // Reusing the value so that we can check that it is set back to its initial value.
    element.style.webkitGridAutoFlow = "initial";
    shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
</script>
<script src="../../resources/js-test-post.js"></script>
</body>

Lines 45-51 a/LayoutTests/fast/css-grid-layout/grid-auto-flow-resolution.html_sec1
- a/LayoutTests/fast/css-grid-layout/grid-auto-flow-resolution.html -1 / +1 lines
45	<p>This test checks that the tracks' auto positions are properly resolved on a static grid.</p>	45	<p>This test checks that the tracks' auto positions are properly resolved on a static grid.</p>
46		46
47	<div class="unconstrainedContainer">	47	<div class="unconstrainedContainer">
48	<div class="grid smallGrid gridAutoFlowNone" id="gridAutoFlowNone">	48	<div class="grid smallGrid gridAutoFlowStack" id="gridAutoFlowStack">
49	<div class="sizedToGridArea autoRowAutoColumn" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50">XXXXX XXXXX XXXXX</div>	49	<div class="sizedToGridArea autoRowAutoColumn" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50">XXXXX XXXXX XXXXX</div>
50	<div class="sizedToGridArea secondRowAutoColumn" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="100">XXXXX XXXXX XXXXX</div>	50	<div class="sizedToGridArea secondRowAutoColumn" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="100">XXXXX XXXXX XXXXX</div>
51	<div class="sizedToGridArea autoRowSecondColumn" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50">XXXXX XXXXX XXXXX</div>	51	<div class="sizedToGridArea autoRowSecondColumn" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50">XXXXX XXXXX XXXXX</div>

Lines 4-6 PASS a/LayoutTests/fast/css-grid-layout/grid-auto-flow-update-expected.txt_sec1
- a/LayoutTests/fast/css-grid-layout/grid-auto-flow-update-expected.txt +1 lines
4	PASS	4	PASS
5	PASS	5	PASS
6	PASS	6	PASS
		7	PASS



{
    checkLayout(".grid");

    testGrid("row", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
    testGrid("column", { 'offsetX': '0', 'offsetY': '50', 'width': '50', 'height': '100' });
    testGrid("stack", { 'offsetX': '0', 'offsetY': '0', 'width': '50', 'height': '50' });
    testGrid("", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
    testGrid("invalid", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
    testGrid("none", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
}
window.addEventListener("load", updateAutoFlow, false);
</script>

<div>This test checks that updating the grid's element's grid-auto-flow property recomputes the grid.</div>
<div style="position: relative">
    <div class="grid">
        <div class="sizedToGridArea autoRowAutoColumn" id="autoItem" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>
        <div class="sizedToGridArea firstRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
    </div>
</div>



<p>This test checks that we resolve named grid areas per the specification.</p>

<div style="position: relative">
    <div class="grid gridWithoutRepeat gridAutoFlowStack">
        <div class="sizedToGridArea gridItemSixthArea" data-offset-x="120" data-offset-y="50" data-expected-width="160" data-expected-height="100"></div>
        <div class="sizedToGridArea gridItemFifthArea" data-offset-x="40" data-offset-y="50" data-expected-width="80" data-expected-height="100"></div>
        <div class="sizedToGridArea gridItemFourthArea" data-offset-x="0" data-offset-y="50" data-expected-width="40" data-expected-height="100"></div>

</div>

<div style="position: relative">
    <div class="grid gridWithRepeat gridAutoFlowStack">
        <!-- fifth and sixth are invalid named grid areas. -->
        <div class="sizedToGridArea gridItemSixthArea" data-offset-x="0" data-offset-y="0" data-expected-width="40" data-expected-height="50"></div>
        <div class="sizedToGridArea gridItemFifthArea" data-offset-x="0" data-offset-y="0" data-expected-width="40" data-expected-height="50"></div>

Lines 7-12 a/LayoutTests/fast/css-grid-layout/grid-item-z-index-change-repaint.html_sec1
- a/LayoutTests/fast/css-grid-layout/grid-item-z-index-change-repaint.html +1 lines
7	-webkit-grid-template-rows: 100px;	7	-webkit-grid-template-rows: 100px;
8	-webkit-grid-template-columns: 200px;	8	-webkit-grid-template-columns: 200px;
9	margin-top: 10px;	9	margin-top: 10px;
		10	-webkit-grid-auto-flow: stack;
10	}	11	}
11	.red {	12	.red {
12	background-color: red;	13	background-color: red;

Lines 7-12 a/LayoutTests/fast/css-grid-layout/grid-item-z-index-stacking-context.html_sec1
- a/LayoutTests/fast/css-grid-layout/grid-item-z-index-stacking-context.html +1 lines
7	-webkit-grid-template-rows: 100px;	7	-webkit-grid-template-rows: 100px;
8	-webkit-grid-template-columns: 200px 200px;	8	-webkit-grid-template-columns: 200px 200px;
9	margin-top: 10px;	9	margin-top: 10px;
		10	-webkit-grid-auto-flow: stack;
10	}	11	}
11	.red {	12	.red {
12	background-color: red;	13	background-color: red;





Test getting the longhand values when shorthand is set through CSS.
PASS window.getComputedStyle(gridWithStack, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithStack, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithStack, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithStack, '').getPropertyValue('-webkit-grid-auto-flow') is "row stack"
PASS window.getComputedStyle(gridWithStack, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithStack, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithTemplate, '').getPropertyValue('-webkit-grid-template-columns') is "15px"
PASS window.getComputedStyle(gridWithTemplate, '').getPropertyValue('-webkit-grid-template-rows') is "10px"
PASS window.getComputedStyle(gridWithTemplate, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithTemplate, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithTemplate, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithTemplate, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithTemplate1, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithTemplate1, '').getPropertyValue('-webkit-grid-template-rows') is "10px"
PASS window.getComputedStyle(gridWithTemplate1, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithTemplate1, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithTemplate1, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithTemplate1, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithTemplateNone, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithTemplateNone, '').getPropertyValue('-webkit-grid-template-rows') is "10px"
PASS window.getComputedStyle(gridWithTemplateNone, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithTemplateNone, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithTemplateNone, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithTemplateNone, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowStackAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStackAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStackAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStackAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-flow') is "row stack"
PASS window.getComputedStyle(gridWithAutoFlowStackAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowStackAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-rows') is "20px"
PASS window.getComputedStyle(gridWithAutoFlowAndColumns, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowAndColumns, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowAndColumns, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowAndColumns, '').getPropertyValue('-webkit-grid-auto-flow') is "column"
PASS window.getComputedStyle(gridWithAutoFlowAndColumns, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowAndColumns, '').getPropertyValue('-webkit-grid-auto-rows') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowStack, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStack, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStack, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStack, '').getPropertyValue('-webkit-grid-auto-flow') is "row stack"
PASS window.getComputedStyle(gridWithAutoFlowStack, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowStack, '').getPropertyValue('-webkit-grid-auto-rows') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-auto-flow') is "column dense"
PASS window.getComputedStyle(gridWithAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-auto-rows') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-auto-flow') is "row dense"
PASS window.getComputedStyle(gridWithAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-auto-rows') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-auto-flow') is "column stack"
PASS window.getComputedStyle(gridWithAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-auto-rows') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowRowStack, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowRowStack, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowRowStack, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowRowStack, '').getPropertyValue('-webkit-grid-auto-flow') is "row stack"
PASS window.getComputedStyle(gridWithAutoFlowRowStack, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowRowStack, '').getPropertyValue('-webkit-grid-auto-rows') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-areas') is "none"

PASS window.getComputedStyle(gridWithAutoFlowAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-columns') is "10px"
PASS window.getComputedStyle(gridWithAutoFlowAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-rows') is "20px"

Test setting wrong values for 'grid' shorthand through CSS (they should resolve to the default: 'row')
PASS window.getComputedStyle(gridWithNone, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithNone, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithNone, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithNone, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithNone, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithNone, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowNoneAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowNoneAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowNoneAndColumnsAndRows, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowNoneAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithAutoFlowNoneAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowNoneAndColumnsAndRows, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowNone, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowNone, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowNone, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithExplicitAndImplicit, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithExplicitAndImplicit, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithExplicitAndImplicit, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithExplicitAndImplicit, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithExplicitAndImplicit, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithExplicitAndImplicit, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithMisplacedNone1, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithMisplacedNone1, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithMisplacedNone1, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithMisplacedNone1, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithMisplacedNone1, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithMisplacedNone1, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithMisplacedNone2, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithMisplacedNone2, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithMisplacedNone2, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithMisplacedNone2, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithMisplacedNone2, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithMisplacedNone2, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithMisplacedDense, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithMisplacedDense, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithMisplacedDense, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithMisplacedDense, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithMisplacedDense, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithMisplacedDense, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithMisplacedStack, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithMisplacedStack, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithMisplacedStack, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithMisplacedStack, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithMisplacedStack, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithMisplacedStack, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithWrongSlash1, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithWrongSlash1, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithWrongSlash1, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithWrongSlash1, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithWrongSlash1, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithWrongSlash1, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithWrongSlash2, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithWrongSlash2, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithWrongSlash2, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithWrongSlash2, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithWrongSlash2, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithWrongSlash2, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithWrongSlash3, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithWrongSlash3, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithWrongSlash3, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithWrongSlash3, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithWrongSlash3, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithWrongSlash3, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowRowAndColumn, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowRowAndColumn, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowRowAndColumn, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowRowAndColumn, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithAutoFlowRowAndColumn, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowRowAndColumn, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithoutAutoFlowAndExtraBreath, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithoutAutoFlowAndExtraBreath, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithoutAutoFlowAndExtraBreath, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithoutAutoFlowAndExtraBreath, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithoutAutoFlowAndExtraBreath, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithoutAutoFlowAndExtraBreath, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowString1, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString1, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString1, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString1, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithAutoFlowString1, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowString1, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowString2, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString2, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString2, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString2, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithAutoFlowString2, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowString2, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowString3, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString3, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString3, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithAutoFlowString3, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithAutoFlowString3, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithAutoFlowString3, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithTemplateAndAutoFlow, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithTemplateAndAutoFlow, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithTemplateAndAutoFlow, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithTemplateAndAutoFlow, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithTemplateAndAutoFlow, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithTemplateAndAutoFlow, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS window.getComputedStyle(gridWithTemplateAndMisplacedString1, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(gridWithTemplateAndMisplacedString1, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(gridWithTemplateAndMisplacedString1, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(gridWithTemplateAndMisplacedString1, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(gridWithTemplateAndMisplacedString1, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(gridWithTemplateAndMisplacedString1, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"


PASS element.style.webkitGridTemplateRows is "20px"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS element.style.webkitGridTemplateAreas is "none"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS element.style.webkitGridAutoFlow is "initial"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS element.style.webkitGridAutoColumns is "initial"

PASS element.style.webkitGridTemplateRows is "(line) 20px"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-areas') is "\"a\""
PASS element.style.webkitGridTemplateAreas is "\"a\""
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS element.style.webkitGridAutoFlow is "initial"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS element.style.webkitGridAutoColumns is "initial"

PASS element.style.webkitGridTemplateRows is "initial"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS element.style.webkitGridTemplateAreas is "initial"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is "row dense"
PASS element.style.webkitGridAutoFlow is "row dense"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-columns') is "20px"
PASS element.style.webkitGridAutoColumns is "20px"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-rows') is "20px"

PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-columns') is "none"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-rows') is "none"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-rows') is "auto"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-columns') is 'none'
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-rows') is 'none'
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-areas') is 'none'
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-columns') is 'auto'
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-rows') is 'auto'


PASS element.style.webkitGridTemplateRows is "none"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-areas') is "none"
PASS element.style.webkitGridTemplateAreas is "none"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is "row"
PASS element.style.webkitGridAutoFlow is "initial"
PASS getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-columns') is "auto"
PASS element.style.webkitGridAutoColumns is "initial"



</script>
<link href="resources/grid.css" rel="stylesheet">
<style>
#gridWithStack {
    -webkit-grid: stack;
}
#gridWithTemplate {
    -webkit-grid: 15px / 10px;

#gridWithTemplate1 {
    -webkit-grid: none / 10px;
}
#gridWithTemplateNone {
    -webkit-grid: none / 10px;
}
#gridWithAutoFlowStackAndColumnsAndRows {
    -webkit-grid: stack 10px / 20px;
}
#gridWithAutoFlowAndColumns {
    -webkit-grid: column 10px;
}
#gridWithAutoFlowStack {
    -webkit-grid: stack 10px;
}
#gridWithAutoFlowColumnDense {
    -webkit-grid: column dense 10px;
}
#gridWithAutoFlowDenseRow {
    -webkit-grid: dense row 10px;
}
#gridWithAutoFlowStackColumn {
    -webkit-grid: stack column 10px;
}
#gridWithAutoFlowRowStack {
    -webkit-grid: row stack 10px;
}
#gridWithAutoFlowAndColumnsAndRows {
    -webkit-grid: column 10px / 20px;


/* Bad values. */

#gridWithNone {
    -webkit-grid: none;
}
#gridWithAutoFlowNoneAndColumnsAndRows {
    -webkit-grid: none 10px / 20px;
}
#gridWithAutoFlowNone {
    -webkit-grid: none 10px;
}
#gridWithExplicitAndImplicit {
    -webkit-grid: 10px / 20px column;
}

#gridWithTemplateAndMisplacedString1 {
    -webkit-grid: 10px / 10px "a";
}
#gridWithMisplacedDense {
    -webkit-grid: dense column dense;
}
#gridWithMisplacedStack {
    -webkit-grid: stack row stack;
}
</style>
<script src="../../resources/js-test.js"></script>
</head>
<body>
<div class="grid" id="gridWithStack"></div>
<div class="grid" id="gridWithTemplate"></div>
<div class="grid" id="gridWithTemplate1"></div>
<div class="grid" id="gridWithAutoFlowStackAndColumnsAndRows"></div>
<div class="grid" id="gridWithAutoFlowAndColumns"></div>
<div class="grid" id="gridWithAutoFlowStack"></div>
<div class="grid" id="gridWithAutoFlowColumnDense"></div>
<div class="grid" id="gridWithAutoFlowDenseRow"></div>
<div class="grid" id="gridWithAutoFlowStackColumn"></div>
<div class="grid" id="gridWithAutoFlowRowStack"></div>
<div class="grid" id="gridWithAutoFlowAndColumnsAndRows"></div>
<div class="grid" id="gridWithNone"></div>
<div class="grid" id="gridWithTemplateNone"></div>
<div class="grid" id="gridWithAutoFlowNoneAndColumnsAndRows"></div>
<div class="grid" id="gridWithAutoFlowNone"></div>
<div class="grid" id="gridWithExplicitAndImplicit"></div>
<div class="grid" id="gridWithMisplacedNone1"></div>
<div class="grid" id="gridWithMisplacedNone2"></div>

<div class="grid" id="gridWithAutoFlowString3"></div>
<div class="grid" id="gridWithTemplateAndAutoFlow"></div>
<div class="grid" id="gridWithTemplateAndMisplacedString1"></div>
<div class="grid" id="gridWithMisplacedDense"></div>
<div class="grid" id="gridWithMisplacedStack"></div>
<script src="resources/grid-shorthand-parsing-utils.js"></script>
<script>
    description("This test checks that the 'grid' shorthand is properly parsed and the longhand properties correctly assigned.");

    debug("Test getting the longhand values when shorthand is set through CSS.");
    testGridDefinitionsValues(document.getElementById("gridWithStack"), "none", "none", "none", "row stack", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithTemplate"), "15px", "10px", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithTemplate1"), "none", "10px", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithTemplateNone"), "none", "10px", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowStackAndColumnsAndRows"), "none", "none", "none", "row stack", "10px", "20px");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowAndColumns"), "none", "none", "none", "column", "10px", "10px");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowStack"), "none", "none", "none", "row stack", "10px", "10px");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowColumnDense"), "none", "none", "none", "column dense", "10px", "10px");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowDenseRow"), "none", "none", "none", "row dense", "10px", "10px");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowStackColumn"), "none", "none", "none", "column stack", "10px", "10px");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowRowStack"), "none", "none", "none", "row stack", "10px", "10px");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowAndColumnsAndRows"), "none", "none", "none", "column", "10px", "20px");

    debug("");
    debug("Test setting wrong values for 'grid' shorthand through CSS (they should resolve to the default: 'row')");
    testGridDefinitionsValues(document.getElementById("gridWithNone"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowNoneAndColumnsAndRows"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowNone"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithExplicitAndImplicit"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithMisplacedNone1"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithMisplacedNone2"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithMisplacedDense"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithMisplacedStack"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithWrongSlash1"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithWrongSlash2"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithWrongSlash3"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowRowAndColumn"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithoutAutoFlowAndExtraBreath"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowString1"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowString2"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithAutoFlowString3"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithTemplateAndAutoFlow"), "none", "none", "none", "row", "auto", "auto");
    testGridDefinitionsValues(document.getElementById("gridWithTemplateAndMisplacedString1"), "none", "none", "none", "row", "auto", "auto");

    debug("");
    debug("Test getting and setting 'grid' shorthand through JS");
    testGridDefinitionsSetJSValues("10px / 20px", "10px", "20px", "none", "row", "auto", "auto", "10px", "20px", "none", "initial", "initial", "initial");
    testGridDefinitionsSetJSValues("10px / (line) 'a' 20px", "10px", "(line) 20px", "\"a\"", "row", "auto", "auto", "10px", "(line) 20px", "\"a\"", "initial", "initial", "initial");
    testGridDefinitionsSetJSValues("row dense 20px", "none", "none", "none", "row dense", "20px", "20px", "initial", "initial", "initial", "row dense", "20px", "20px");
    testGridDefinitionsSetJSValues("column 20px / 10px", "none", "none", "none", "column", "20px", "10px", "initial", "initial", "initial", "column", "20px", "10px");

    debug("");
    debug("Test the initial value");
    var element = document.createElement("div");
    document.body.appendChild(element);
    testGridDefinitionsValues(element, "none", "none", "none", "row", "auto", "auto");
    shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-columns')", "'none'");
    shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-rows')", "'none'");
    shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-grid-template-areas')", "'none'");
    shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
    shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-columns')", "'auto'");
    shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-rows')", "'auto'");

    debug("");
    debug("Test setting grid-template-columns and grid-template-rows back to 'none' through JS");
    testGridDefinitionsSetJSValues("column 10px / 20px", "none", "none", "none", "column", "10px", "20px", "initial", "initial", "initial", "column", "10px", "20px");
    testGridDefinitionsSetJSValues("none", "none", "none", "none", "row", "auto", "auto", "none", "none", "none", "initial", "initial", "initial");

</script>
</body>

Lines 10-15 function testLayout(gridDefinitions, itemsDefinitions) a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-dynamic-get-set.html_sec1
- a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-dynamic-get-set.html +1 lines
10	var gridContainer = document.getElementById("gridContainer");	10	var gridContainer = document.getElementById("gridContainer");
11	var gridElement = document.createElement("div");	11	var gridElement = document.createElement("div");
12	gridElement.className = "grid";	12	gridElement.className = "grid";
		13	gridElement.style.webkitGridAutoFlow = "stack";
13		14
14	for (var key in gridDefinitions) {	15	for (var key in gridDefinitions) {
15	if (key == "rows")	16	if (key == "rows")




<!-- Check positioning using unique grid-line names -->
<div style="position: relative">
  <div class="grid gridUniqueNames gridAutoFlowStack">
    <div class="sizedToGridArea" style="-webkit-grid-column: b;" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-row: e;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-column: b-start;" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>


<!-- Check that without named gridAreas there are no implicit grid-line names defined -->
<div style="position: relative">
  <div class="grid gridUniqueNames gridAutoFlowStack">
    <div class="sizedToGridArea" style="-webkit-grid-column: c-start;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-row: f-start;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-column: c-start; -webkit-grid-row: f-end" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>

</div>

<div style="position: relative">
  <div class="grid gridAreas gridNoLineNames gridAutoFlowStack">
    <div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="150"></div>
    <div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: a;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="150"></div>


<!-- Use explicitly named grid lines if they're defined before the grid area -->
<div style="position: relative">
  <div class="grid gridAreas gridWithNamedLineBeforeGridArea gridAutoFlowStack">
    <div class="sizedToGridArea" style="-webkit-grid-column: d;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="300"></div>
    <div class="sizedToGridArea" style="-webkit-grid-column: c;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>

</div>

<div style="position: relative">
  <div class="grid gridAreas gridWithNamedLineBeforeGridArea gridAutoFlowStack">
    <div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="0" data-offset-y="0" data-expected-width="350" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="300"></div>
    <div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="350" data-expected-height="300"></div>


<!-- Check behavior with areas named *-start or *-end -->
<div style="position: relative">
  <div class="grid gridAreasSpecial gridNoLineNames gridAutoFlowStack">
    <div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
    <div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>



}

/* Grid element flow. */
.gridAutoFlowStack {
    -webkit-grid-auto-flow: stack;
}

.gridAutoFlowColumn {

Lines 153-159 zoom: 1; a/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt_sec1
- a/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt -1 / +1 lines
153	-webkit-font-smoothing: auto;	153	-webkit-font-smoothing: auto;
154	-webkit-font-variant-ligatures: normal;	154	-webkit-font-variant-ligatures: normal;
155	-webkit-grid-auto-columns: auto;	155	-webkit-grid-auto-columns: auto;
156	-webkit-grid-auto-flow: none;	156	-webkit-grid-auto-flow: row;
157	-webkit-grid-auto-rows: auto;	157	-webkit-grid-auto-rows: auto;
158	-webkit-grid-column-end: auto;	158	-webkit-grid-column-end: auto;
159	-webkit-grid-column-start: auto;	159	-webkit-grid-column-start: auto;

Lines 152-158 zoom: 1 a/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt_sec1
- a/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt -1 / +1 lines
152	-webkit-font-smoothing: auto	152	-webkit-font-smoothing: auto
153	-webkit-font-variant-ligatures: normal	153	-webkit-font-variant-ligatures: normal
154	-webkit-grid-auto-columns: auto	154	-webkit-grid-auto-columns: auto
155	-webkit-grid-auto-flow: none	155	-webkit-grid-auto-flow: row
156	-webkit-grid-auto-rows: auto	156	-webkit-grid-auto-rows: auto
157	-webkit-grid-column-end: auto	157	-webkit-grid-column-end: auto
158	-webkit-grid-column-start: auto	158	-webkit-grid-column-start: auto

Lines 54-59 a/LayoutTests/ietestcenter/css3/grid/grid-column-001.htm_sec1
- a/LayoutTests/ietestcenter/css3/grid/grid-column-001.htm +5 lines
54	-o-grid-rows: auto 1fr;	54	-o-grid-rows: auto 1fr;
55	-webkit-grid-defintion-rows: auto 1fr;	55	-webkit-grid-defintion-rows: auto 1fr;
56	grid-rows: auto 1fr;	56	grid-rows: auto 1fr;
		57	-ms-grid-auto-flow: stack;
		58	-moz-grid-auto-flow: stack;
		59	-o-grid-auto-flow: stack;
		60	-webkit-grid-auto-flow: stack;
		61	grid-auto-flow: stack;
57	}	62	}
58	#griditem	63	#griditem
59	{	64	{

Lines 54-59 a/LayoutTests/ietestcenter/css3/grid/grid-column-002.htm_sec1
- a/LayoutTests/ietestcenter/css3/grid/grid-column-002.htm +5 lines
54	-o-grid-rows: auto 1fr;	54	-o-grid-rows: auto 1fr;
55	-webkit-grid-defintion-rows: auto 1fr;	55	-webkit-grid-defintion-rows: auto 1fr;
56	grid-rows: auto 1fr;	56	grid-rows: auto 1fr;
		57	-ms-grid-auto-flow: stack;
		58	-moz-grid-auto-flow: stack;
		59	-o-grid-auto-flow: stack;
		60	-webkit-grid-auto-flow: stack;
		61	grid-auto-flow: stack;
57	}	62	}
58	#griditem	63	#griditem
59	{	64	{

Lines 54-59 a/LayoutTests/ietestcenter/css3/grid/grid-column-003.htm_sec1
- a/LayoutTests/ietestcenter/css3/grid/grid-column-003.htm +5 lines
54	-o-grid-rows: auto 1fr;	54	-o-grid-rows: auto 1fr;
55	-webkit-grid-defintion-rows: auto 1fr;	55	-webkit-grid-defintion-rows: auto 1fr;
56	grid-rows: auto 1fr;	56	grid-rows: auto 1fr;
		57	-ms-grid-auto-flow: stack;
		58	-moz-grid-auto-flow: stack;
		59	-o-grid-auto-flow: stack;
		60	-webkit-grid-auto-flow: stack;
		61	grid-auto-flow: stack;
57	}	62	}
58	#griditem	63	#griditem
59	{	64	{



rect: style.getPropertyCSSValue(-webkit-font-variant-ligatures) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(-webkit-grid-auto-columns) : auto
rect: style.getPropertyCSSValue(-webkit-grid-auto-columns) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(-webkit-grid-auto-flow) : row
rect: style.getPropertyCSSValue(-webkit-grid-auto-flow) : [object CSSValueList]
rect: style.getPropertyValue(-webkit-grid-auto-rows) : auto
rect: style.getPropertyCSSValue(-webkit-grid-auto-rows) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(-webkit-grid-column-end) : auto

g: style.getPropertyCSSValue(-webkit-font-variant-ligatures) : [object CSSPrimitiveValue]
g: style.getPropertyValue(-webkit-grid-auto-columns) : auto
g: style.getPropertyCSSValue(-webkit-grid-auto-columns) : [object CSSPrimitiveValue]
g: style.getPropertyValue(-webkit-grid-auto-flow) : row
g: style.getPropertyCSSValue(-webkit-grid-auto-flow) : [object CSSValueList]
g: style.getPropertyValue(-webkit-grid-auto-rows) : auto
g: style.getPropertyCSSValue(-webkit-grid-auto-rows) : [object CSSPrimitiveValue]
g: style.getPropertyValue(-webkit-grid-column-end) : auto

Return to Bug 134057

Lines 2050-2057 PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propert a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec1
- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp -2 / +15 lines
2050	return list.release();	2050	return list.release();
2051	}	2051	}
2052	#if ENABLE(CSS_GRID_LAYOUT)	2052	#if ENABLE(CSS_GRID_LAYOUT)
2053	case CSSPropertyWebkitGridAutoFlow:	2053	case CSSPropertyWebkitGridAutoFlow: {
2054	return cssValuePool().createValue(style->gridAutoFlow());	2054	RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
		2055	ASSERT(style->isGridAutoFlowDirectionRow() \|\| style->isGridAutoFlowDirectionColumn());
		2056	if (style->isGridAutoFlowDirectionRow())
		2057	list->append(cssValuePool().createIdentifierValue(CSSValueRow));
		2058	else
		2059	list->append(cssValuePool().createIdentifierValue(CSSValueColumn));
		2060
		2061	if (style->isGridAutoFlowAlgorithmDense())
		2062	list->append(cssValuePool().createIdentifierValue(CSSValueDense));
		2063	else if (style->isGridAutoFlowAlgorithmStack())
		2064	list->append(cssValuePool().createIdentifierValue(CSSValueStack));
		2065
		2066	return list.release();
		2067	}
2055		2068
2056	// Specs mention that getComputedStyle() should return the used value of the property instead of the computed	2069	// Specs mention that getComputedStyle() should return the used value of the property instead of the computed
2057	// one for grid-definition-{rows\|columns} but not for the grid-auto-{rows\|columns} as things like	2070	// one for grid-definition-{rows\|columns} but not for the grid-auto-{rows\|columns} as things like

Lines 883-894 static inline bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, int a/Source/WebCore/css/CSSParser.cpp_sec1
- a/Source/WebCore/css/CSSParser.cpp -17 / +63 lines
883	if (valueID == CSSValueNone \|\| valueID == CSSValueManual \|\| valueID == CSSValueAuto)	883	if (valueID == CSSValueNone \|\| valueID == CSSValueManual \|\| valueID == CSSValueAuto)
884	return true;	884	return true;
885	break;	885	break;
886	#if ENABLE(CSS_GRID_LAYOUT)
887	case CSSPropertyWebkitGridAutoFlow:
888	if (valueID == CSSValueNone \|\| valueID == CSSValueRow \|\| valueID == CSSValueColumn)
889	return true;
890	break;
891	#endif
892	case CSSPropertyWebkitLineAlign:	886	case CSSPropertyWebkitLineAlign:
893	if (valueID == CSSValueNone \|\| valueID == CSSValueEdges)	887	if (valueID == CSSValueNone \|\| valueID == CSSValueEdges)
894	return true;	888	return true;
Lines 1096-1104 static inline bool isKeywordPropertyID(CSSPropertyID propertyId) a/Source/WebCore/css/CSSParser.cpp_sec2
1096	case CSSPropertyWebkitFontKerning:	1090	case CSSPropertyWebkitFontKerning:
1097	case CSSPropertyWebkitFontSmoothing:	1091	case CSSPropertyWebkitFontSmoothing:
1098	case CSSPropertyWebkitHyphens:	1092	case CSSPropertyWebkitHyphens:
1099	#if ENABLE(CSS_GRID_LAYOUT)
1100	case CSSPropertyWebkitGridAutoFlow:
1101	#endif
1102	case CSSPropertyWebkitLineAlign:	1093	case CSSPropertyWebkitLineAlign:
1103	case CSSPropertyWebkitLineBreak:	1094	case CSSPropertyWebkitLineBreak:
1104	case CSSPropertyWebkitLineSnap:	1095	case CSSPropertyWebkitLineSnap:
Lines 2610-2615 bool CSSParser::parseValue(CSSPropertyID propId, bool important) a/Source/WebCore/css/CSSParser.cpp_sec3
2610	case CSSPropertyWebkitGridTemplateAreas:	2601	case CSSPropertyWebkitGridTemplateAreas:
2611	parsedValue = parseGridTemplateAreas();	2602	parsedValue = parseGridTemplateAreas();
2612	break;	2603	break;
		2604	case CSSPropertyWebkitGridAutoFlow:
		2605	parsedValue = parseGridAutoFlow(*m_valueList);
		2606	break;
2613	#endif /* ENABLE(CSS_GRID_LAYOUT) */	2607	#endif /* ENABLE(CSS_GRID_LAYOUT) */
2614	case CSSPropertyWebkitMarginCollapse: {	2608	case CSSPropertyWebkitMarginCollapse: {
2615	if (num == 1) {	2609	if (num == 1) {
Lines 2988-2996 bool CSSParser::parseValue(CSSPropertyID propId, bool important) a/Source/WebCore/css/CSSParser.cpp_sec4
2988	case CSSPropertyWebkitFontKerning:	2982	case CSSPropertyWebkitFontKerning:
2989	case CSSPropertyWebkitFontSmoothing:	2983	case CSSPropertyWebkitFontSmoothing:
2990	case CSSPropertyWebkitHyphens:	2984	case CSSPropertyWebkitHyphens:
2991	#if ENABLE(CSS_GRID_LAYOUT)
2992	case CSSPropertyWebkitGridAutoFlow:
2993	#endif
2994	case CSSPropertyWebkitLineAlign:	2985	case CSSPropertyWebkitLineAlign:
2995	case CSSPropertyWebkitLineBreak:	2986	case CSSPropertyWebkitLineBreak:
2996	case CSSPropertyWebkitLineSnap:	2987	case CSSPropertyWebkitLineSnap:
Lines 4925-4939 bool CSSParser::parseGridShorthand(bool important) a/Source/WebCore/css/CSSParser.cpp_sec5
4925	m_valueList->setCurrentIndex(0);	4916	m_valueList->setCurrentIndex(0);
4926		4917
4927	// 2- <grid-auto-flow> [ <grid-auto-columns> [ / <grid-auto-rows> ]? ]	4918	// 2- <grid-auto-flow> [ <grid-auto-columns> [ / <grid-auto-rows> ]? ]
4928	CSSValueID id = m_valueList->current()->id;	4919	if (!parseValue(CSSPropertyWebkitGridAutoFlow, important))
4929	if (id != CSSValueRow && id != CSSValueColumn && id != CSSValueNone)
4930	return false;	4920	return false;
4931		4921
4932	RefPtr<CSSValue> autoFlowValue = cssValuePool().createIdentifierValue(id);
4933	RefPtr<CSSValue> autoColumnsValue;	4922	RefPtr<CSSValue> autoColumnsValue;
4934	RefPtr<CSSValue> autoRowsValue;	4923	RefPtr<CSSValue> autoRowsValue;
4935		4924
4936	if (m_valueList->next()) {	4925	if (m_valueList->current()) {
4937	autoColumnsValue = parseGridTrackSize(*m_valueList);	4926	autoColumnsValue = parseGridTrackSize(*m_valueList);
4938	if (!autoColumnsValue)	4927	if (!autoColumnsValue)
4939	return false;	4928	return false;
Lines 4956-4962 bool CSSParser::parseGridShorthand(bool important) a/Source/WebCore/css/CSSParser.cpp_sec6
4956	if (!autoRowsValue)	4945	if (!autoRowsValue)
4957	autoRowsValue = autoColumnsValue;	4946	autoRowsValue = autoColumnsValue;
4958		4947
4959	addProperty(CSSPropertyWebkitGridAutoFlow, autoFlowValue.release(), important);
4960	addProperty(CSSPropertyWebkitGridAutoColumns, autoColumnsValue.release(), important);	4948	addProperty(CSSPropertyWebkitGridAutoColumns, autoColumnsValue.release(), important);
4961	addProperty(CSSPropertyWebkitGridAutoRows, autoRowsValue.release(), important);	4949	addProperty(CSSPropertyWebkitGridAutoRows, autoRowsValue.release(), important);
4962		4950
Lines 5181-5186 PassRefPtr<CSSPrimitiveValue> CSSParser::parseGridBreadth(CSSParserValue* curren a/Source/WebCore/css/CSSParser.cpp_sec7
5181		5169
5182	return createPrimitiveNumericValue(currentValue);	5170	return createPrimitiveNumericValue(currentValue);
5183	}	5171	}
		5172
		5173	static inline bool isValidGridAutoFlowId(CSSValueID id)
		5174	{
		5175	return (id == CSSValueRow \|\| id == CSSValueColumn \|\| id == CSSValueDense \|\| id == CSSValueStack);
		5176	}
		5177
		5178	PassRefPtr<CSSValue> CSSParser::parseGridAutoFlow(CSSParserValueList& inputList)
		5179	{
		5180	// [ row \| column ] && dense? \| stack && [ row \| column ]?
		5181	CSSParserValue* value = inputList.current();
		5182	if (!value)
		5183	return nullptr;
		5184
		5185	RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
		5186
		5187	// First parameter.
		5188	CSSValueID firstId = value->id;
		5189	if (!isValidGridAutoFlowId(firstId))
		5190	return nullptr;
		5191
		5192	// Second parameter, if any.
		5193	// If second parameter is not valid we should process anyway the first one as we can be inside the "grid" shorthand.
		5194	value = inputList.next();
		5195	if (!value \|\| !isValidGridAutoFlowId(value->id)) {
		5196	if (firstId == CSSValueDense)
		5197	return nullptr;
		5198
		5199	if (firstId == CSSValueStack)
		5200	parsedValues->append(cssValuePool().createIdentifierValue(CSSValueRow));
		5201
		5202	parsedValues->append(cssValuePool().createIdentifierValue(firstId));
		5203	return parsedValues;
		5204	}
		5205
		5206	switch (firstId) {
		5207	case CSSValueRow:
		5208	case CSSValueColumn:
		5209	parsedValues->append(cssValuePool().createIdentifierValue(firstId));
		5210	if (value->id == CSSValueDense \|\| value->id == CSSValueStack) {
		5211	parsedValues->append(cssValuePool().createIdentifierValue(value->id));
		5212	inputList.next();
		5213	}
		5214	break;
		5215	case CSSValueDense:
		5216	case CSSValueStack:
		5217	if (value->id == CSSValueRow \|\| value->id == CSSValueColumn) {
		5218	parsedValues->append(cssValuePool().createIdentifierValue(value->id));
		5219	inputList.next();
		5220	}
		5221	parsedValues->append(cssValuePool().createIdentifierValue(firstId));
		5222	break;
		5223	default:
		5224	ASSERT_NOT_REACHED();
		5225	break;
		5226	}
		5227
		5228	return parsedValues;
		5229	}
5184	#endif /* ENABLE(CSS_GRID_LAYOUT) */	5230	#endif /* ENABLE(CSS_GRID_LAYOUT) */
5185		5231
5186	#if ENABLE(DASHBOARD_SUPPORT)	5232	#if ENABLE(DASHBOARD_SUPPORT)

Lines 4574-4618 template<> inline CSSPrimitiveValue::operator ColumnProgression() const a/Source/WebCore/css/CSSPrimitiveValueMappings.h_sec1
- a/Source/WebCore/css/CSSPrimitiveValueMappings.h -39 lines
4574	return NormalColumnProgression;	4574	return NormalColumnProgression;
4575	}	4575	}
4576		4576
4577	#if ENABLE(CSS_GRID_LAYOUT)
4578	template<> inline CSSPrimitiveValue::operator GridAutoFlow() const
4579	{
4580	ASSERT(isValueID());
4581
4582	switch (m_value.valueID) {
4583	case CSSValueNone:
4584	return AutoFlowNone;
4585	case CSSValueColumn:
4586	return AutoFlowColumn;
4587	case CSSValueRow:
4588	return AutoFlowRow;
4589	default:
4590	break;
4591	}
4592
4593	ASSERT_NOT_REACHED();
4594	return AutoFlowNone;
4595
4596	}
4597
4598	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(GridAutoFlow flow)
4599	: CSSValue(PrimitiveClass)
4600	{
4601	m_primitiveUnitType = CSS_VALUE_ID;
4602	switch (flow) {
4603	case AutoFlowNone:
4604	m_value.valueID = CSSValueNone;
4605	break;
4606	case AutoFlowColumn:
4607	m_value.valueID = CSSValueColumn;
4608	break;
4609	case AutoFlowRow:
4610	m_value.valueID = CSSValueRow;
4611	break;
4612	}
4613	}
4614	#endif /* ENABLE_(CSS_GRID_LAYOUT) */
4615
4616	enum LengthConversion {	4577	enum LengthConversion {
4617	AnyConversion = ~0,	4578	AnyConversion = ~0,
4618	FixedIntegerConversion = 1 << 0,	4579	FixedIntegerConversion = 1 << 0,

Lines 2501-2509 DeprecatedStyleBuilder::DeprecatedStyleBuilder() a/Source/WebCore/css/DeprecatedStyleBuilder.cpp_sec1
- a/Source/WebCore/css/DeprecatedStyleBuilder.cpp -3 lines
2501	setPropertyHandler(CSSPropertyWebkitFlexGrow, ApplyPropertyDefault<float, &RenderStyle::flexGrow, float, &RenderStyle::setFlexGrow, float, &RenderStyle::initialFlexGrow>::createHandler());	2501	setPropertyHandler(CSSPropertyWebkitFlexGrow, ApplyPropertyDefault<float, &RenderStyle::flexGrow, float, &RenderStyle::setFlexGrow, float, &RenderStyle::initialFlexGrow>::createHandler());
2502	setPropertyHandler(CSSPropertyWebkitFlexShrink, ApplyPropertyDefault<float, &RenderStyle::flexShrink, float, &RenderStyle::setFlexShrink, float, &RenderStyle::initialFlexShrink>::createHandler());	2502	setPropertyHandler(CSSPropertyWebkitFlexShrink, ApplyPropertyDefault<float, &RenderStyle::flexShrink, float, &RenderStyle::setFlexShrink, float, &RenderStyle::initialFlexShrink>::createHandler());
2503	setPropertyHandler(CSSPropertyWebkitFlexWrap, ApplyPropertyDefault<EFlexWrap, &RenderStyle::flexWrap, EFlexWrap, &RenderStyle::setFlexWrap, EFlexWrap, &RenderStyle::initialFlexWrap>::createHandler());	2503	setPropertyHandler(CSSPropertyWebkitFlexWrap, ApplyPropertyDefault<EFlexWrap, &RenderStyle::flexWrap, EFlexWrap, &RenderStyle::setFlexWrap, EFlexWrap, &RenderStyle::initialFlexWrap>::createHandler());
2504	#if ENABLE(CSS_GRID_LAYOUT)
2505	setPropertyHandler(CSSPropertyWebkitGridAutoFlow, ApplyPropertyDefault<GridAutoFlow, &RenderStyle::gridAutoFlow, GridAutoFlow, &RenderStyle::setGridAutoFlow, GridAutoFlow, &RenderStyle::initialGridAutoFlow>::createHandler());
2506	#endif
2507	setPropertyHandler(CSSPropertyWebkitJustifyContent, ApplyPropertyDefault<EJustifyContent, &RenderStyle::justifyContent, EJustifyContent, &RenderStyle::setJustifyContent, EJustifyContent, &RenderStyle::initialJustifyContent>::createHandler());	2504	setPropertyHandler(CSSPropertyWebkitJustifyContent, ApplyPropertyDefault<EJustifyContent, &RenderStyle::justifyContent, EJustifyContent, &RenderStyle::setJustifyContent, EJustifyContent, &RenderStyle::initialJustifyContent>::createHandler());
2508	setPropertyHandler(CSSPropertyWebkitOrder, ApplyPropertyDefault<int, &RenderStyle::order, int, &RenderStyle::setOrder, int, &RenderStyle::initialOrder>::createHandler());	2505	setPropertyHandler(CSSPropertyWebkitOrder, ApplyPropertyDefault<int, &RenderStyle::order, int, &RenderStyle::setOrder, int, &RenderStyle::initialOrder>::createHandler());
2509	#if ENABLE(CSS_REGIONS)	2506	#if ENABLE(CSS_REGIONS)

Lines 2790-2795 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/StyleResolver.cpp_sec1
- a/Source/WebCore/css/StyleResolver.cpp +36 lines
2790	state.style()->setNamedGridAreaColumnCount(gridTemplateAreasValue->columnCount());	2790	state.style()->setNamedGridAreaColumnCount(gridTemplateAreasValue->columnCount());
2791	return;	2791	return;
2792	}	2792	}
		2793	case CSSPropertyWebkitGridAutoFlow: {
		2794	HANDLE_INHERIT_AND_INITIAL(gridAutoFlow, GridAutoFlow);
		2795	if (!value->isValueList())
		2796	return;
		2797	CSSValueList* list = toCSSValueList(value);
		2798
		2799	if (!list->length()) {
		2800	state.style()->setGridAutoFlow(RenderStyle::initialGridAutoFlow());
		2801	return;
		2802	}
		2803
		2804	CSSPrimitiveValue* first = toCSSPrimitiveValue(list->item(0));
		2805	CSSPrimitiveValue* second = list->length() == 2 ? toCSSPrimitiveValue(list->item(1)) : nullptr;
		2806
		2807	GridAutoFlow autoFlow = RenderStyle::initialGridAutoFlow();
		2808	switch (first->getValueID()) {
		2809	case CSSValueRow:
		2810	if (second)
		2811	autoFlow = second->getValueID() == CSSValueDense ? AutoFlowRowDense : AutoFlowStackRow;
		2812	else
		2813	autoFlow = AutoFlowRow;
		2814	break;
		2815	case CSSValueColumn:
		2816	if (second)
		2817	autoFlow = second->getValueID() == CSSValueDense ? AutoFlowColumnDense : AutoFlowStackColumn;
		2818	else
		2819	autoFlow = AutoFlowColumn;
		2820	break;
		2821	default:
		2822	ASSERT_NOT_REACHED();
		2823	break;
		2824	}
		2825
		2826	state.style()->setGridAutoFlow(autoFlow);
		2827	return;
		2828	}
2793	#endif /* ENABLE(CSS_GRID_LAYOUT) */	2829	#endif /* ENABLE(CSS_GRID_LAYOUT) */
2794	// These properties are aliased and DeprecatedStyleBuilder already applied the property on the prefixed version.	2830	// These properties are aliased and DeprecatedStyleBuilder already applied the property on the prefixed version.
2795	case CSSPropertyTransitionDelay:	2831	case CSSPropertyTransitionDelay:

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +66 lines
		1	2014-07-11 Manuel Rego Casasnovas <rego@igalia.com>
		2
		3	[CSS Grid Layout] Update grid-auto-flow to the new syntax
		4	https://bugs.webkit.org/show_bug.cgi?id=134057
		5
		6	Reviewed by Sergio Villar Senin.
		7
		8	In last versions of the spec grid-auto-flow syntax has changed. New
		9	syntax is:
		10	[ row \| column ] && dense? \| stack && [ row \| column ]?
		11
		12	Implemented parsing for new syntax and added/modified test cases in
		13	current layout tests.
		14
		15	For the moment, the implementation keeps working in the same way, but
		16	using "stack" value for grid-auto-flow property instead of "none". This
		17	should be fixed in a follow-up patch once "stack" is properly
		18	implemented.
		19
		20	Also "dense" needs to be reviewed. Right now auto-placement algorithm is
		21	always "dense" and never "sparse".
		22
		23	No new tests, update current tests to add new cases.
		24
		25	* css/CSSComputedStyleDeclaration.cpp:
		26	(WebCore::ComputedStyleExtractor::propertyValue): Adapt to new syntax.
		27	* css/CSSParser.cpp:
		28	(WebCore::isValidKeywordPropertyAndValue): Removed grid-auto-flow as it
		29	is not a keyword anymore.
		30	(WebCore::isKeywordPropertyID): Ditto.
		31	(WebCore::CSSParser::parseValue): Add specific method for parsing
		32	grid-auto-flow.
		33	(WebCore::CSSParser::parseGridShorthand): Adapt parsing for
		34	grid-auto-flow property inside the shorthand.
		35	(WebCore::isValidGridAutoFlowId): Helper method to check if the CSSValue
		36	id is a valid keyword for grid-auto-flow property.
		37	(WebCore::CSSParser::parseGridAutoFlow): Implement new parsing for
		38	grid-auto-flow.
		39	* css/CSSParser.h: Method header for grid-auto-flow parsing.
		40	* css/CSSPrimitiveValueMappings.h:
		41	(WebCore::CSSPrimitiveValue::operator GridAutoFlow): Deleted.
		42	(WebCore::CSSPrimitiveValue::CSSPrimitiveValue): Deleted.
		43	* css/CSSValueKeywords.in: Add new keywords required by grid-auto-flow:
		44	"dense" and "stack".
		45	* css/DeprecatedStyleBuilder.cpp:
		46	(WebCore::DeprecatedStyleBuilder::DeprecatedStyleBuilder): Remove
		47	default handler as grid-auto-flow is not a keyword now.
		48	* css/StyleResolver.cpp:
		49	(WebCore::StyleResolver::applyProperty): Implement particular handler
		50	for new grid-auto-flow syntax.
		51	* rendering/RenderGrid.cpp:
		52	(WebCore::RenderGrid::placeItemsOnGrid): Keep old "none" behavior as
		53	"stack" behavior for the moment.
		54	(WebCore::RenderGrid::autoPlacementMajorAxisDirection): Use the new
		55	helper methods in RenderStyle.
		56	(WebCore::RenderGrid::autoPlacementMinorAxisDirection): Ditto.
		57	* rendering/style/GridResolvedPosition.cpp:
		58	(WebCore::GridResolvedPosition::resolveGridPositionsFromStyle): Again
		59	keep old "none" behavior for "stack".
		60	* rendering/style/RenderStyle.h: Add new helper methods to know the
		61	direction and algorithm of grid-auto-flow property.
		62	* rendering/style/RenderStyleConstants.h: Redefine GridAutoFlow enum
		63	using flags for algorithm and direction.
		64	* rendering/style/StyleGridData.h: Change m_gridAutoFlow type to
65	unsigned.
66
1	2014-07-10 Brady Eidson <beidson@apple.com>	67	2014-07-10 Brady Eidson <beidson@apple.com>
2		68
3	Phone number highlights should always be visible if the mouse hovers over.	69	Phone number highlights should always be visible if the mouse hovers over.

Lines 665-671 void RenderGrid::placeItemsOnGrid() a/Source/WebCore/rendering/RenderGrid.cpp_sec1
- a/Source/WebCore/rendering/RenderGrid.cpp -8 / +4 lines
665		665
666	Vector<RenderBox*> autoMajorAxisAutoGridItems;	666	Vector<RenderBox*> autoMajorAxisAutoGridItems;
667	Vector<RenderBox*> specifiedMajorAxisAutoGridItems;	667	Vector<RenderBox*> specifiedMajorAxisAutoGridItems;
668	GridAutoFlow autoFlow = style().gridAutoFlow();
669	for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {	668	for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
670	// FIXME: We never re-resolve positions if the grid is grown during auto-placement which may lead auto / <integer>	669	// FIXME: We never re-resolve positions if the grid is grown during auto-placement which may lead auto / <integer>
671	// positions to not match the author's intent. The specification is unclear on what should be done in this case.	670	// positions to not match the author's intent. The specification is unclear on what should be done in this case.
Lines 685-691 void RenderGrid::placeItemsOnGrid() a/Source/WebCore/rendering/RenderGrid.cpp_sec2
685	ASSERT(gridRowCount() >= style().gridRows().size());	684	ASSERT(gridRowCount() >= style().gridRows().size());
686	ASSERT(gridColumnCount() >= style().gridColumns().size());	685	ASSERT(gridColumnCount() >= style().gridColumns().size());
687		686
688	if (autoFlow == AutoFlowNone) {	687	// FIXME: Implement properly "stack" value in auto-placement algorithm.
		688	if (style().isGridAutoFlowAlgorithmStack()) {
689	// If we did collect some grid items, they won't be placed thus never laid out.	689	// If we did collect some grid items, they won't be placed thus never laid out.
690	ASSERT(!autoMajorAxisAutoGridItems.size());	690	ASSERT(!autoMajorAxisAutoGridItems.size());
691	ASSERT(!specifiedMajorAxisAutoGridItems.size());	691	ASSERT(!specifiedMajorAxisAutoGridItems.size());
Lines 801-816 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem) a/Source/WebCore/rendering/RenderGrid.cpp_sec3
801		801
802	GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const	802	GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const
803	{	803	{
804	GridAutoFlow flow = style().gridAutoFlow();	804	return style().isGridAutoFlowDirectionColumn() ? ForColumns : ForRows;
805	ASSERT(flow != AutoFlowNone);
806	return (flow == AutoFlowColumn) ? ForColumns : ForRows;
807	}	805	}
808		806
809	GridTrackSizingDirection RenderGrid::autoPlacementMinorAxisDirection() const	807	GridTrackSizingDirection RenderGrid::autoPlacementMinorAxisDirection() const
810	{	808	{
811	GridAutoFlow flow = style().gridAutoFlow();	809	return style().isGridAutoFlowDirectionColumn() ? ForRows : ForColumns;
812	ASSERT(flow != AutoFlowNone);
813	return (flow == AutoFlowColumn) ? ForRows : ForColumns;
814	}	810	}
815		811
816	void RenderGrid::clearGrid()	812	void RenderGrid::clearGrid()

Lines 126-132 std::unique_ptr<GridSpan> GridResolvedPosition::resolveGridPositionsFromStyle(co a/Source/WebCore/rendering/style/GridResolvedPosition.cpp_sec1
- a/Source/WebCore/rendering/style/GridResolvedPosition.cpp -1 / +2 lines
126	adjustGridPositionsFromStyle(gridContainerStyle, initialPosition, finalPosition, initialPositionSide, finalPositionSide);	126	adjustGridPositionsFromStyle(gridContainerStyle, initialPosition, finalPosition, initialPositionSide, finalPositionSide);
127		127
128	if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition()) {	128	if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition()) {
129	if (gridContainerStyle.gridAutoFlow() == AutoFlowNone)	129	// FIXME: Implement properly "stack" value in auto-placement algorithm.
		130	if (gridContainerStyle.isGridAutoFlowAlgorithmStack())
130	return std::make_unique<GridSpan>(0, 0);	131	return std::make_unique<GridSpan>(0, 0);
131		132
132	// We can't get our grid positions without running the auto placement algorithm.	133	// We can't get our grid positions without running the auto placement algorithm.

Lines 925-931 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec1
- a/Source/WebCore/rendering/style/RenderStyle.h -2 / +7 lines
925	const NamedGridAreaMap& namedGridArea() const { return rareNonInheritedData->m_grid->m_namedGridArea; }	925	const NamedGridAreaMap& namedGridArea() const { return rareNonInheritedData->m_grid->m_namedGridArea; }
926	size_t namedGridAreaRowCount() const { return rareNonInheritedData->m_grid->m_namedGridAreaRowCount; }	926	size_t namedGridAreaRowCount() const { return rareNonInheritedData->m_grid->m_namedGridAreaRowCount; }
927	size_t namedGridAreaColumnCount() const { return rareNonInheritedData->m_grid->m_namedGridAreaColumnCount; }	927	size_t namedGridAreaColumnCount() const { return rareNonInheritedData->m_grid->m_namedGridAreaColumnCount; }
928	GridAutoFlow gridAutoFlow() const { return rareNonInheritedData->m_grid->m_gridAutoFlow; }	928	GridAutoFlow gridAutoFlow() const { return static_cast<GridAutoFlow>(rareNonInheritedData->m_grid->m_gridAutoFlow); }
		929	bool isGridAutoFlowDirectionRow() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowDirectionRow); }
		930	bool isGridAutoFlowDirectionColumn() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowDirectionColumn); }
		931	bool isGridAutoFlowAlgorithmSparse() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowAlgorithmSparse); }
		932	bool isGridAutoFlowAlgorithmDense() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowAlgorithmDense); }
		933	bool isGridAutoFlowAlgorithmStack() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowAlgorithmStack); }
929	const GridTrackSize& gridAutoColumns() const { return rareNonInheritedData->m_grid->m_gridAutoColumns; }	934	const GridTrackSize& gridAutoColumns() const { return rareNonInheritedData->m_grid->m_gridAutoColumns; }
930	const GridTrackSize& gridAutoRows() const { return rareNonInheritedData->m_grid->m_gridAutoRows; }	935	const GridTrackSize& gridAutoRows() const { return rareNonInheritedData->m_grid->m_gridAutoRows; }
931		936
Lines 1885-1891 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec2
1885	static Vector<GridTrackSize> initialGridColumns() { return Vector<GridTrackSize>(); }	1890	static Vector<GridTrackSize> initialGridColumns() { return Vector<GridTrackSize>(); }
1886	static Vector<GridTrackSize> initialGridRows() { return Vector<GridTrackSize>(); }	1891	static Vector<GridTrackSize> initialGridRows() { return Vector<GridTrackSize>(); }
1887		1892
1888	static GridAutoFlow initialGridAutoFlow() { return AutoFlowNone; }	1893	static GridAutoFlow initialGridAutoFlow() { return AutoFlowRow; }
1889		1894
1890	static GridTrackSize initialGridAutoColumns() { return GridTrackSize(Auto); }	1895	static GridTrackSize initialGridAutoColumns() { return GridTrackSize(Auto); }
1891	static GridTrackSize initialGridAutoRows() { return GridTrackSize(Auto); }	1896	static GridTrackSize initialGridAutoRows() { return GridTrackSize(Auto); }

Lines 537-543 enum LineAlign { LineAlignNone, LineAlignEdges }; a/Source/WebCore/rendering/style/RenderStyleConstants.h_sec1
- a/Source/WebCore/rendering/style/RenderStyleConstants.h -1 / +20 lines
537	enum RubyPosition { RubyPositionBefore, RubyPositionAfter };	537	enum RubyPosition { RubyPositionBefore, RubyPositionAfter };
538		538
539	#if ENABLE(CSS_GRID_LAYOUT)	539	#if ENABLE(CSS_GRID_LAYOUT)
540	enum GridAutoFlow { AutoFlowNone, AutoFlowColumn, AutoFlowRow };	540	static const size_t GridAutoFlowBits = 5;
		541	enum InternalGridAutoFlowAlgorithm {
		542	InternalAutoFlowAlgorithmSparse = 0x1,
		543	InternalAutoFlowAlgorithmDense = 0x2,
		544	InternalAutoFlowAlgorithmStack = 0x4
		545	};
		546
		547	enum InternalGridAutoFlowDirection {
		548	InternalAutoFlowDirectionRow = 0x8,
		549	InternalAutoFlowDirectionColumn = 0x10
		550	};
		551
		552	enum GridAutoFlow {
		553	AutoFlowRow = InternalAutoFlowAlgorithmSparse \| InternalAutoFlowDirectionRow,
		554	AutoFlowColumn = InternalAutoFlowAlgorithmSparse \| InternalAutoFlowDirectionColumn,
		555	AutoFlowRowDense = InternalAutoFlowAlgorithmDense \| InternalAutoFlowDirectionRow,
		556	AutoFlowColumnDense = InternalAutoFlowAlgorithmDense \| InternalAutoFlowDirectionColumn,
		557	AutoFlowStackRow = InternalAutoFlowAlgorithmStack \| InternalAutoFlowDirectionRow,
		558	AutoFlowStackColumn = InternalAutoFlowAlgorithmStack \| InternalAutoFlowDirectionColumn
		559	};
541	#endif	560	#endif
542		561
543	// Reasonable maximum to prevent insane font sizes from causing crashes on some platforms (such as Windows).	562	// Reasonable maximum to prevent insane font sizes from causing crashes on some platforms (such as Windows).

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +35 lines
		1	2014-07-11 Manuel Rego Casasnovas <rego@igalia.com>
		2
		3	[CSS Grid Layout] Update grid-auto-flow to the new syntax
		4	https://bugs.webkit.org/show_bug.cgi?id=134057
		5
		6	Reviewed by Sergio Villar Senin.
		7
		8	Adapted current tests to the new syntax. Keeping old "none" behavior
		9	using "stack".
		10
		11	Add new use cases to cover the new syntax to grid-auto-flow-get-set.html
		12	and grid-shorthand-get-set.html.
		13
		14	* fast/css-grid-layout/grid-auto-flow-get-set-expected.txt:
		15	* fast/css-grid-layout/grid-auto-flow-get-set.html:
		16	* fast/css-grid-layout/grid-auto-flow-resolution.html:
		17	* fast/css-grid-layout/grid-auto-flow-update-expected.txt:
		18	* fast/css-grid-layout/grid-auto-flow-update.html:
		19	* fast/css-grid-layout/grid-item-named-grid-area-resolution.html:
		20	* fast/css-grid-layout/grid-item-z-index-change-repaint.html:
		21	* fast/css-grid-layout/grid-item-z-index-stacking-context.html:
		22	* fast/css-grid-layout/grid-shorthand-get-set-expected.txt:
		23	* fast/css-grid-layout/grid-shorthand-get-set.html:
		24	* fast/css-grid-layout/named-grid-lines-with-named-grid-areas-dynamic-get-set.html:
		25	* fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html:
		26	* fast/css-grid-layout/resources/grid.css:
		27	(.gridAutoFlowStack):
		28	(.gridAutoFlowNone): Deleted.
		29	* fast/css/getComputedStyle/computed-style-expected.txt:
		30	* fast/css/getComputedStyle/computed-style-without-renderer-expected.txt:
		31	* ietestcenter/css3/grid/grid-column-001.htm:
		32	* ietestcenter/css3/grid/grid-column-002.htm:
		33	* ietestcenter/css3/grid/grid-column-003.htm:
		34	* svg/css/getComputedStyle-basic-expected.txt:
		35
1	2014-07-10 Jinwoo Song <jinwoo7.song@samsung.com>	36	2014-07-10 Jinwoo Song <jinwoo7.song@samsung.com>
2		37
3	[EFL] Unreviewed EFL gardening.	38	[EFL] Unreviewed EFL gardening.

Lines 1-29 a/LayoutTests/fast/css-grid-layout/grid-auto-flow-get-set-expected.txt_sec1
- a/LayoutTests/fast/css-grid-layout/grid-auto-flow-get-set-expected.txt -8 / +37 lines
1	Test that setting and getting grid-auto-flow works as expected	1	Test that setting and getting -webkit-grid-auto-flow works as expected
2		2
3	On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".	3	On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
4		4
5		5
6	Test getting -webkit-auto-flow set through CSS	6	Test getting -webkit-grid-auto-flow set through CSS
7	PASS window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow') is 'none'
8	PASS window.getComputedStyle(gridAutoFlowColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'	7	PASS window.getComputedStyle(gridAutoFlowColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'
9	PASS window.getComputedStyle(gridAutoFlowRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'	8	PASS window.getComputedStyle(gridAutoFlowRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
10	PASS window.getComputedStyle(gridAutoFlowColumns, '').getPropertyValue('-webkit-grid-auto-flow') is 'none'	9	PASS window.getComputedStyle(gridAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
11	PASS window.getComputedStyle(gridAutoFlowRows, '').getPropertyValue('-webkit-grid-auto-flow') is 'none'	10	PASS window.getComputedStyle(gridAutoFlowRowDense, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
		11	PASS window.getComputedStyle(gridAutoFlowDenseColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
		12	PASS window.getComputedStyle(gridAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
		13	PASS window.getComputedStyle(gridAutoFlowStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
		14	PASS window.getComputedStyle(gridAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
		15	PASS window.getComputedStyle(gridAutoFlowStackRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
		16	PASS window.getComputedStyle(gridAutoFlowColumnStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
		17	PASS window.getComputedStyle(gridAutoFlowRowStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
		18	PASS window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		19	PASS window.getComputedStyle(gridAutoFlowColumns, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		20	PASS window.getComputedStyle(gridAutoFlowRows, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		21	PASS window.getComputedStyle(gridAutoFlowDense, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		22	PASS window.getComputedStyle(gridAutoFlowColumnFoo, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		23	PASS window.getComputedStyle(gridAutoFlowColumnColumn, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		24	PASS window.getComputedStyle(gridAutoFlowDenseColumnStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		25	PASS window.getComputedStyle(gridAutoFlowDenseRowStack, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		26	PASS window.getComputedStyle(gridAutoFlowStackRowRow, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
12	PASS window.getComputedStyle(gridAutoFlowInherit, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'	27	PASS window.getComputedStyle(gridAutoFlowInherit, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'
13	PASS window.getComputedStyle(gridAutoFlowNoInherit, '').getPropertyValue('-webkit-grid-auto-flow') is 'none'	28	PASS window.getComputedStyle(gridAutoFlowNoInherit, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
14		29
15	Test the initial value	30	Test the initial value
16	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'none'	31	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
17		32
18	Test getting and setting -webkit-grid-auto-flow through JS	33	Test getting and setting -webkit-grid-auto-flow through JS
19	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'	34	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column'
		35	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
		36	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
		37	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column dense'
		38	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row dense'
20	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'	39	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		40	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
		41	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
		42	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
		43	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'column stack'
		44	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row stack'
21		45
22	Test getting and setting bad values for -webkit-grid-auto-flow through JS	46	Test getting and setting bad values for -webkit-grid-auto-flow through JS
23	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'	47	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		48	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		49	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		50	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		51	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
		52	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
24		53
25	Test setting -webkit-grid-auto-flow to 'initial' through JS	54	Test setting -webkit-grid-auto-flow to 'initial' through JS
26	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'none'	55	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow') is 'row'
27	PASS successfullyParsed is true	56	PASS successfullyParsed is true
28		57
29	TEST COMPLETE	58	TEST COMPLETE

Lines 3-85 a/LayoutTests/fast/css-grid-layout/grid-auto-flow-get-set.html_sec1
- a/LayoutTests/fast/css-grid-layout/grid-auto-flow-get-set.html -14 / +146 lines
3	<head>	3	<head>
4	<link href="resources/grid.css" rel="stylesheet">	4	<link href="resources/grid.css" rel="stylesheet">
5	<style>	5	<style>
		6	.gridAutoFlowColumnDense {
		7	-webkit-grid-auto-flow: column dense;
		8	}
		9	.gridAutoFlowRowDense {
		10	-webkit-grid-auto-flow: row dense;
		11	}
		12	.gridAutoFlowDenseColumn {
		13	-webkit-grid-auto-flow: dense column;
		14	}
		15	.gridAutoFlowDenseRow {
		16	-webkit-grid-auto-flow: dense row;
		17	}
		18	.gridAutoFlowStackColumn {
		19	-webkit-grid-auto-flow: stack column;
		20	}
		21	.gridAutoFlowStackRow {
		22	-webkit-grid-auto-flow: stack row;
		23	}
		24	.gridAutoFlowColumnStack {
		25	-webkit-grid-auto-flow: column stack;
		26	}
		27	.gridAutoFlowRowStack {
		28	-webkit-grid-auto-flow: row stack;
		29	}
6	.gridAutoFlowInherit {	30	.gridAutoFlowInherit {
7	-webkit-grid-auto-flow: inherit;	31	-webkit-grid-auto-flow: inherit;
8	}	32	}
9	/* Bad values. */	33	/* Bad values. */
		34	.gridAutoFlowNone {
		35	-webkit-grid-auto-flow: none;
		36	}
10	.gridAutoFlowRows {	37	.gridAutoFlowRows {
11	-webkit-grid-auto-flow: rows;	38	-webkit-grid-auto-flow: rows;
12	}	39	}
13	.gridAutoFlowColumns {	40	.gridAutoFlowColumns {
14	-webkit-grid-auto-flow: columns;	41	-webkit-grid-auto-flow: columns;
15	}	42	}
		43	.gridAutoFlowDense {
		44	-webkit-grid-auto-flow: dense;
		45	}
		46	.gridAutoFlowColumnFoo {
		47	-webkit-grid-auto-flow: column foo;
		48	}
		49	.gridAutoFlowColumnColumn {
		50	-webkit-grid-auto-flow: column column;
		51	}
		52	.gridAutoFlowDenseColumnStack {
		53	-webkit-grid-auto-flow: dense column stack;
		54	}
		55	.gridAutoFlowDenseRowStack {
		56	-webkit-grid-auto-flow: dense row stack;
		57	}
		58	.gridAutoFlowStackRowRow {
		59	-webkit-grid-auto-flow: stack row row;
		60	}
16	</style>	61	</style>
17	<script src="../../resources/js-test-pre.js"></script>	62	<script src="../../resources/js-test-pre.js"></script>
18	</head>	63	</head>
19	<body>	64	<body>
20	<div class="grid" id="gridInitial"></div>	65	<div class="grid" id="gridInitial"></div>
21	<div class="grid gridAutoFlowNone" id="gridAutoFlowNone"></div>
22	<div class="grid gridAutoFlowColumn" id="gridAutoFlowColumn"></div>	66	<div class="grid gridAutoFlowColumn" id="gridAutoFlowColumn"></div>
23	<div class="grid gridAutoFlowRow" id="gridAutoFlowRow"></div>	67	<div class="grid gridAutoFlowRow" id="gridAutoFlowRow"></div>
		68	<div class="grid gridAutoFlowColumnDense" id="gridAutoFlowColumnDense"></div>
		69	<div class="grid gridAutoFlowRowDense" id="gridAutoFlowRowDense"></div>
		70	<div class="grid gridAutoFlowDenseColumn" id="gridAutoFlowDenseColumn"></div>
		71	<div class="grid gridAutoFlowDenseRow" id="gridAutoFlowDenseRow"></div>
		72	<div class="grid gridAutoFlowStack" id="gridAutoFlowStack"></div>
		73	<div class="grid gridAutoFlowStackColumn" id="gridAutoFlowStackColumn"></div>
		74	<div class="grid gridAutoFlowStackRow" id="gridAutoFlowStackRow"></div>
		75	<div class="grid gridAutoFlowColumnStack" id="gridAutoFlowColumnStack"></div>
		76	<div class="grid gridAutoFlowRowStack" id="gridAutoFlowRowStack"></div>
24	<div class="grid gridAutoFlowColumn">	77	<div class="grid gridAutoFlowColumn">
25	<div class="grid gridAutoFlowInherit" id="gridAutoFlowInherit"></div>	78	<div class="grid gridAutoFlowInherit" id="gridAutoFlowInherit"></div>
26	</div>	79	</div>
27	<div class="grid gridAutoFlowColumn">	80	<div class="grid gridAutoFlowColumn">
28	<div><div class="grid gridAutoFlowInherit" id="gridAutoFlowNoInherit"></div><div>	81	<div><div class="grid gridAutoFlowInherit" id="gridAutoFlowNoInherit"></div><div>
29	</div>	82	</div>
		83	<div class="grid gridAutoFlowNone" id="gridAutoFlowNone"></div>
30	<div class="grid gridAutoFlowColumns" id="gridAutoFlowColumns"></div>	84	<div class="grid gridAutoFlowColumns" id="gridAutoFlowColumns"></div>
31	<div class="grid gridAutoFlowRows" id="gridAutoFlowRows"></div>	85	<div class="grid gridAutoFlowRows" id="gridAutoFlowRows"></div>
		86	<div class="grid gridAutoFlowDense" id="gridAutoFlowDense"></div>
		87	<div class="grid gridAutoFlowColumnFoo" id="gridAutoFlowColumnFoo"></div>
		88	<div class="grid gridAutoFlowColumnColumn" id="gridAutoFlowColumnColumn"></div>
		89	<div class="grid gridAutoFlowDenseColumnStack" id="gridAutoFlowDenseColumnStack"></div>
		90	<div class="grid gridAutoFlowDenseRowStack" id="gridAutoFlowDenseRowStack"></div>
		91	<div class="grid gridAutoFlowStackRowRow" id="gridAutoFlowStackRowRow"></div>
32	<script>	92	<script>
33	description('Test that setting and getting grid-auto-flow works as expected');	93	description('Test that setting and getting -webkit-grid-auto-flow works as expected');
34
35	debug("Test getting -webkit-auto-flow set through CSS");
36	var gridAutoFlowNone = document.getElementById("gridAutoFlowNone");
37	shouldBe("window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow')", "'none'");
38		94
		95	debug("Test getting -webkit-grid-auto-flow set through CSS");
39	var gridAutoFlowColumn = document.getElementById("gridAutoFlowColumn");	96	var gridAutoFlowColumn = document.getElementById("gridAutoFlowColumn");
40	shouldBe("window.getComputedStyle(gridAutoFlowColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");	97	shouldBe("window.getComputedStyle(gridAutoFlowColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");
41		98
42	var gridAutoFlowRow = document.getElementById("gridAutoFlowRow");	99	var gridAutoFlowRow = document.getElementById("gridAutoFlowRow");
43	shouldBe("window.getComputedStyle(gridAutoFlowRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");	100	shouldBe("window.getComputedStyle(gridAutoFlowRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
44		101
		102	var gridAutoFlowColumnDense = document.getElementById("gridAutoFlowColumnDense");
		103	shouldBe("window.getComputedStyle(gridAutoFlowColumnDense, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");
		104
		105	var gridAutoFlowRowDense = document.getElementById("gridAutoFlowRowDense");
		106	shouldBe("window.getComputedStyle(gridAutoFlowRowDense, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");
		107
		108	var gridAutoFlowDenseColumn = document.getElementById("gridAutoFlowDenseColumn");
		109	shouldBe("window.getComputedStyle(gridAutoFlowDenseColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");
		110
		111	var gridAutoFlowDenseRow = document.getElementById("gridAutoFlowDenseRow");
		112	shouldBe("window.getComputedStyle(gridAutoFlowDenseRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");
		113
		114	var gridAutoFlowStack = document.getElementById("gridAutoFlowStack");
		115	shouldBe("window.getComputedStyle(gridAutoFlowStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
		116
		117	var gridAutoFlowStackColumn = document.getElementById("gridAutoFlowStackColumn");
		118	shouldBe("window.getComputedStyle(gridAutoFlowStackColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");
		119
		120	var gridAutoFlowStackRow = document.getElementById("gridAutoFlowStackRow");
		121	shouldBe("window.getComputedStyle(gridAutoFlowStackRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
		122
		123	var gridAutoFlowColumnStack = document.getElementById("gridAutoFlowColumnStack");
		124	shouldBe("window.getComputedStyle(gridAutoFlowColumnStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");
		125
		126	var gridAutoFlowRowStack = document.getElementById("gridAutoFlowRowStack");
		127	shouldBe("window.getComputedStyle(gridAutoFlowRowStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
		128
		129	var gridAutoFlowNone= document.getElementById("gridAutoFlowNone");
		130	shouldBe("window.getComputedStyle(gridAutoFlowNone, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		131
45	var gridAutoFlowColumns = document.getElementById("gridAutoFlowColumns");	132	var gridAutoFlowColumns = document.getElementById("gridAutoFlowColumns");
46	shouldBe("window.getComputedStyle(gridAutoFlowColumns, '').getPropertyValue('-webkit-grid-auto-flow')", "'none'");	133	shouldBe("window.getComputedStyle(gridAutoFlowColumns, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
47		134
48	var gridAutoFlowRows = document.getElementById("gridAutoFlowRows");	135	var gridAutoFlowRows = document.getElementById("gridAutoFlowRows");
49	shouldBe("window.getComputedStyle(gridAutoFlowRows, '').getPropertyValue('-webkit-grid-auto-flow')", "'none'");	136	shouldBe("window.getComputedStyle(gridAutoFlowRows, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		137
		138	var gridAutoFlowDense = document.getElementById("gridAutoFlowDense");
		139	shouldBe("window.getComputedStyle(gridAutoFlowDense, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		140
		141	var gridAutoFlowColumnFoo = document.getElementById("gridAutoFlowColumnFoo");
		142	shouldBe("window.getComputedStyle(gridAutoFlowColumnFoo, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		143
		144	var gridAutoFlowColumnColumn = document.getElementById("gridAutoFlowColumnColumn");
		145	shouldBe("window.getComputedStyle(gridAutoFlowColumnColumn, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		146
		147	var gridAutoFlowDenseColumnStack = document.getElementById("gridAutoFlowDenseColumnStack");
		148	shouldBe("window.getComputedStyle(gridAutoFlowDenseColumnStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		149
		150	var gridAutoFlowDenseRowStack = document.getElementById("gridAutoFlowDenseRowStack");
		151	shouldBe("window.getComputedStyle(gridAutoFlowDenseRowStack, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		152
		153	var gridAutoFlowStackRowRow = document.getElementById("gridAutoFlowStackRowRow");
		154	shouldBe("window.getComputedStyle(gridAutoFlowStackRowRow, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
50		155
51	var gridAutoFlowInherit = document.getElementById("gridAutoFlowInherit");	156	var gridAutoFlowInherit = document.getElementById("gridAutoFlowInherit");
52	shouldBe("window.getComputedStyle(gridAutoFlowInherit, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");	157	shouldBe("window.getComputedStyle(gridAutoFlowInherit, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");
53		158
54	var gridAutoFlowNoInherit = document.getElementById("gridAutoFlowNoInherit");	159	var gridAutoFlowNoInherit = document.getElementById("gridAutoFlowNoInherit");
55	shouldBe("window.getComputedStyle(gridAutoFlowNoInherit, '').getPropertyValue('-webkit-grid-auto-flow')", "'none'");	160	shouldBe("window.getComputedStyle(gridAutoFlowNoInherit, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
56		161
57	debug("");	162	debug("");
58	debug("Test the initial value");	163	debug("Test the initial value");
59	element = document.createElement("div");	164	element = document.createElement("div");
60	document.body.appendChild(element);	165	document.body.appendChild(element);
61	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'none'");	166	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
62		167
63	debug("");	168	debug("");
64	debug("Test getting and setting -webkit-grid-auto-flow through JS");	169	debug("Test getting and setting -webkit-grid-auto-flow through JS");
65	element.style.webkitGridAutoFlow = "column";	170	element.style.webkitGridAutoFlow = "column";
66	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");	171	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column'");
67		172	element.style.webkitGridAutoFlow = "column dense";
68	element = document.createElement("div");	173	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");
69	document.body.appendChild(element);	174	element.style.webkitGridAutoFlow = "row dense";
		175	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");
		176	element.style.webkitGridAutoFlow = "dense column";
		177	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column dense'");
		178	element.style.webkitGridAutoFlow = "dense row";
		179	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row dense'");
70	element.style.webkitGridAutoFlow = "row";	180	element.style.webkitGridAutoFlow = "row";
71	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");	181	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		182	element.style.webkitGridAutoFlow = "stack";
		183	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
		184	element.style.webkitGridAutoFlow = "stack column";
		185	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");
		186	element.style.webkitGridAutoFlow = "stack row";
		187	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
		188	element.style.webkitGridAutoFlow = "column stack";
		189	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'column stack'");
		190	element.style.webkitGridAutoFlow = "row stack";
		191	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row stack'");
72		192
73	debug("");	193	debug("");
74	debug("Test getting and setting bad values for -webkit-grid-auto-flow through JS");	194	debug("Test getting and setting bad values for -webkit-grid-auto-flow through JS");
		195	element = document.createElement("div");
		196	document.body.appendChild(element);
75	element.style.webkitGridAutoFlow = "noone";	197	element.style.webkitGridAutoFlow = "noone";
76	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");	198	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		199	element.style.webkitGridAutoFlow = "dense";
		200	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		201	element.style.webkitGridAutoFlow = "column column";
		202	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		203	element.style.webkitGridAutoFlow = "dense column stack";
		204	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		205	element.style.webkitGridAutoFlow = "dense row stack";
		206	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
		207	element.style.webkitGridAutoFlow = "stack row row";
		208	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
77		209
78	debug("");	210	debug("");
79	debug("Test setting -webkit-grid-auto-flow to 'initial' through JS");	211	debug("Test setting -webkit-grid-auto-flow to 'initial' through JS");
80	// Reusing the value so that we can check that it is set back to its initial value.	212	// Reusing the value so that we can check that it is set back to its initial value.
81	element.style.webkitGridAutoFlow = "initial";	213	element.style.webkitGridAutoFlow = "initial";
82	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'none'");	214	shouldBe("window.getComputedStyle(element, '').getPropertyValue('-webkit-grid-auto-flow')", "'row'");
83	</script>	215	</script>
84	<script src="../../resources/js-test-post.js"></script>	216	<script src="../../resources/js-test-post.js"></script>
85	</body>	217	</body>

Lines 25-34 function updateAutoFlow() a/LayoutTests/fast/css-grid-layout/grid-auto-flow-update.html_sec1
- a/LayoutTests/fast/css-grid-layout/grid-auto-flow-update.html -4 / +5 lines
25	{	25	{
26	checkLayout(".grid");	26	checkLayout(".grid");
27		27
28	testGrid("row", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
29	testGrid("column", { 'offsetX': '0', 'offsetY': '50', 'width': '50', 'height': '100' });	28	testGrid("column", { 'offsetX': '0', 'offsetY': '50', 'width': '50', 'height': '100' });
30	testGrid("invalid", { 'offsetX': '0', 'offsetY': '50', 'width': '50', 'height': '100' });	29	testGrid("stack", { 'offsetX': '0', 'offsetY': '0', 'width': '50', 'height': '50' });
31	testGrid("none", { 'offsetX': '0', 'offsetY': '0', 'width': '50', 'height': '50' });	30	testGrid("", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
		31	testGrid("invalid", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
		32	testGrid("none", { 'offsetX': '50', 'offsetY': '0', 'width': '100', 'height': '50' });
32	}	33	}
33	window.addEventListener("load", updateAutoFlow, false);	34	window.addEventListener("load", updateAutoFlow, false);
34	</script>	35	</script>
Lines 36-42 window.addEventListener("load", updateAutoFlow, false); a/LayoutTests/fast/css-grid-layout/grid-auto-flow-update.html_sec2
36	<div>This test checks that updating the grid's element's grid-auto-flow property recomputes the grid.</div>	37	<div>This test checks that updating the grid's element's grid-auto-flow property recomputes the grid.</div>
37	<div style="position: relative">	38	<div style="position: relative">
38	<div class="grid">	39	<div class="grid">
39	<div class="sizedToGridArea autoRowAutoColumn" id="autoItem" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	40	<div class="sizedToGridArea autoRowAutoColumn" id="autoItem" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>
40	<div class="sizedToGridArea firstRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	41	<div class="sizedToGridArea firstRowFirstColumn" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
41	</div>	42	</div>
42	</div>	43	</div>

Lines 59-65 a/LayoutTests/fast/css-grid-layout/grid-item-named-grid-area-resolution.html_sec1
- a/LayoutTests/fast/css-grid-layout/grid-item-named-grid-area-resolution.html -2 / +2 lines
59	<p>This test checks that we resolve named grid areas per the specification.</p>	59	<p>This test checks that we resolve named grid areas per the specification.</p>
60		60
61	<div style="position: relative">	61	<div style="position: relative">
62	<div class="grid gridWithoutRepeat">	62	<div class="grid gridWithoutRepeat gridAutoFlowStack">
63	<div class="sizedToGridArea gridItemSixthArea" data-offset-x="120" data-offset-y="50" data-expected-width="160" data-expected-height="100"></div>	63	<div class="sizedToGridArea gridItemSixthArea" data-offset-x="120" data-offset-y="50" data-expected-width="160" data-expected-height="100"></div>
64	<div class="sizedToGridArea gridItemFifthArea" data-offset-x="40" data-offset-y="50" data-expected-width="80" data-expected-height="100"></div>	64	<div class="sizedToGridArea gridItemFifthArea" data-offset-x="40" data-offset-y="50" data-expected-width="80" data-expected-height="100"></div>
65	<div class="sizedToGridArea gridItemFourthArea" data-offset-x="0" data-offset-y="50" data-expected-width="40" data-expected-height="100"></div>	65	<div class="sizedToGridArea gridItemFourthArea" data-offset-x="0" data-offset-y="50" data-expected-width="40" data-expected-height="100"></div>
Lines 73-79 a/LayoutTests/fast/css-grid-layout/grid-item-named-grid-area-resolution.html_sec2
73	</div>	73	</div>
74		74
75	<div style="position: relative">	75	<div style="position: relative">
76	<div class="grid gridWithRepeat">	76	<div class="grid gridWithRepeat gridAutoFlowStack">
77	<!-- fifth and sixth are invalid named grid areas. -->	77	<!-- fifth and sixth are invalid named grid areas. -->
78	<div class="sizedToGridArea gridItemSixthArea" data-offset-x="0" data-offset-y="0" data-expected-width="40" data-expected-height="50"></div>	78	<div class="sizedToGridArea gridItemSixthArea" data-offset-x="0" data-offset-y="0" data-expected-width="40" data-expected-height="50"></div>
79	<div class="sizedToGridArea gridItemFifthArea" data-offset-x="0" data-offset-y="0" data-expected-width="40" data-expected-height="50"></div>	79	<div class="sizedToGridArea gridItemFifthArea" data-offset-x="0" data-offset-y="0" data-expected-width="40" data-expected-height="50"></div>

Lines 60-66 a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html_sec1
- a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html -6 / +6 lines
60		60
61	<!-- Check positioning using unique grid-line names -->	61	<!-- Check positioning using unique grid-line names -->
62	<div style="position: relative">	62	<div style="position: relative">
63	<div class="grid gridUniqueNames">	63	<div class="grid gridUniqueNames gridAutoFlowStack">
64	<div class="sizedToGridArea" style="-webkit-grid-column: b;" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>	64	<div class="sizedToGridArea" style="-webkit-grid-column: b;" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>
65	<div class="sizedToGridArea" style="-webkit-grid-row: e;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	65	<div class="sizedToGridArea" style="-webkit-grid-row: e;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
66	<div class="sizedToGridArea" style="-webkit-grid-column: b-start;" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>	66	<div class="sizedToGridArea" style="-webkit-grid-column: b-start;" data-offset-x="50" data-offset-y="0" data-expected-width="100" data-expected-height="50"></div>
Lines 88-94 a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html_sec2
88		88
89	<!-- Check that without named gridAreas there are no implicit grid-line names defined -->	89	<!-- Check that without named gridAreas there are no implicit grid-line names defined -->
90	<div style="position: relative">	90	<div style="position: relative">
91	<div class="grid gridUniqueNames">	91	<div class="grid gridUniqueNames gridAutoFlowStack">
92	<div class="sizedToGridArea" style="-webkit-grid-column: c-start;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	92	<div class="sizedToGridArea" style="-webkit-grid-column: c-start;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
93	<div class="sizedToGridArea" style="-webkit-grid-row: f-start;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	93	<div class="sizedToGridArea" style="-webkit-grid-row: f-start;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
94	<div class="sizedToGridArea" style="-webkit-grid-column: c-start; -webkit-grid-row: f-end" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	94	<div class="sizedToGridArea" style="-webkit-grid-column: c-start; -webkit-grid-row: f-end" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
Lines 116-122 a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html_sec3
116	</div>	116	</div>
117		117
118	<div style="position: relative">	118	<div style="position: relative">
119	<div class="grid gridAreas gridNoLineNames">	119	<div class="grid gridAreas gridNoLineNames gridAutoFlowStack">
120	<div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="50"></div>	120	<div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="50"></div>
121	<div class="sizedToGridArea" style="-webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="150"></div>	121	<div class="sizedToGridArea" style="-webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="150"></div>
122	<div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: a;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="150"></div>	122	<div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: a;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="150"></div>
Lines 150-156 a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html_sec4
150		150
151	<!-- Use explicitly named grid lines if they're defined before the grid area -->	151	<!-- Use explicitly named grid lines if they're defined before the grid area -->
152	<div style="position: relative">	152	<div style="position: relative">
153	<div class="grid gridAreas gridWithNamedLineBeforeGridArea">	153	<div class="grid gridAreas gridWithNamedLineBeforeGridArea gridAutoFlowStack">
154	<div class="sizedToGridArea" style="-webkit-grid-column: d;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="50"></div>	154	<div class="sizedToGridArea" style="-webkit-grid-column: d;" data-offset-x="50" data-offset-y="0" data-expected-width="300" data-expected-height="50"></div>
155	<div class="sizedToGridArea" style="-webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="300"></div>	155	<div class="sizedToGridArea" style="-webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="300"></div>
156	<div class="sizedToGridArea" style="-webkit-grid-column: c;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	156	<div class="sizedToGridArea" style="-webkit-grid-column: c;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
Lines 166-172 a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html_sec5
166	</div>	166	</div>
167		167
168	<div style="position: relative">	168	<div style="position: relative">
169	<div class="grid gridAreas gridWithNamedLineBeforeGridArea">	169	<div class="grid gridAreas gridWithNamedLineBeforeGridArea gridAutoFlowStack">
170	<div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="0" data-offset-y="0" data-expected-width="350" data-expected-height="50"></div>	170	<div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="0" data-offset-y="0" data-expected-width="350" data-expected-height="50"></div>
171	<div class="sizedToGridArea" style="-webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="300"></div>	171	<div class="sizedToGridArea" style="-webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="50" data-expected-height="300"></div>
172	<div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="350" data-expected-height="300"></div>	172	<div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: d;" data-offset-x="0" data-offset-y="50" data-expected-width="350" data-expected-height="300"></div>
Lines 204-210 a/LayoutTests/fast/css-grid-layout/named-grid-lines-with-named-grid-areas-resolution.html_sec6
204		204
205	<!-- Check behavior with areas named -start or -end -->	205	<!-- Check behavior with areas named -start or -end -->
206	<div style="position: relative">	206	<div style="position: relative">
207	<div class="grid gridAreasSpecial gridNoLineNames">	207	<div class="grid gridAreasSpecial gridNoLineNames gridAutoFlowStack">
208	<div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	208	<div class="sizedToGridArea" style="-webkit-grid-column: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
209	<div class="sizedToGridArea" style="-webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	209	<div class="sizedToGridArea" style="-webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>
210	<div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>	210	<div class="sizedToGridArea" style="-webkit-grid-column: a; -webkit-grid-row: a;" data-offset-x="0" data-offset-y="0" data-expected-width="50" data-expected-height="50"></div>

Lines 123-130 a/LayoutTests/fast/css-grid-layout/resources/grid.css_sec1
- a/LayoutTests/fast/css-grid-layout/resources/grid.css -2 / +2 lines
123	}	123	}
124		124
125	/* Grid element flow. */	125	/* Grid element flow. */
126	.gridAutoFlowNone {	126	.gridAutoFlowStack {
127	-webkit-grid-auto-flow: none;	127	-webkit-grid-auto-flow: stack;
128	}	128	}
129		129
130	.gridAutoFlowColumn {	130	.gridAutoFlowColumn {

Lines 304-311 rect: style.getPropertyValue(-webkit-font-variant-ligatures) : normal a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt_sec1
- a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt -4 / +4 lines
304	rect: style.getPropertyCSSValue(-webkit-font-variant-ligatures) : [object CSSPrimitiveValue]	304	rect: style.getPropertyCSSValue(-webkit-font-variant-ligatures) : [object CSSPrimitiveValue]
305	rect: style.getPropertyValue(-webkit-grid-auto-columns) : auto	305	rect: style.getPropertyValue(-webkit-grid-auto-columns) : auto
306	rect: style.getPropertyCSSValue(-webkit-grid-auto-columns) : [object CSSPrimitiveValue]	306	rect: style.getPropertyCSSValue(-webkit-grid-auto-columns) : [object CSSPrimitiveValue]
307	rect: style.getPropertyValue(-webkit-grid-auto-flow) : none	307	rect: style.getPropertyValue(-webkit-grid-auto-flow) : row
308	rect: style.getPropertyCSSValue(-webkit-grid-auto-flow) : [object CSSPrimitiveValue]	308	rect: style.getPropertyCSSValue(-webkit-grid-auto-flow) : [object CSSValueList]
309	rect: style.getPropertyValue(-webkit-grid-auto-rows) : auto	309	rect: style.getPropertyValue(-webkit-grid-auto-rows) : auto
310	rect: style.getPropertyCSSValue(-webkit-grid-auto-rows) : [object CSSPrimitiveValue]	310	rect: style.getPropertyCSSValue(-webkit-grid-auto-rows) : [object CSSPrimitiveValue]
311	rect: style.getPropertyValue(-webkit-grid-column-end) : auto	311	rect: style.getPropertyValue(-webkit-grid-column-end) : auto
Lines 816-823 g: style.getPropertyValue(-webkit-font-variant-ligatures) : normal a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt_sec2
816	g: style.getPropertyCSSValue(-webkit-font-variant-ligatures) : [object CSSPrimitiveValue]	816	g: style.getPropertyCSSValue(-webkit-font-variant-ligatures) : [object CSSPrimitiveValue]
817	g: style.getPropertyValue(-webkit-grid-auto-columns) : auto	817	g: style.getPropertyValue(-webkit-grid-auto-columns) : auto
818	g: style.getPropertyCSSValue(-webkit-grid-auto-columns) : [object CSSPrimitiveValue]	818	g: style.getPropertyCSSValue(-webkit-grid-auto-columns) : [object CSSPrimitiveValue]
819	g: style.getPropertyValue(-webkit-grid-auto-flow) : none	819	g: style.getPropertyValue(-webkit-grid-auto-flow) : row
820	g: style.getPropertyCSSValue(-webkit-grid-auto-flow) : [object CSSPrimitiveValue]	820	g: style.getPropertyCSSValue(-webkit-grid-auto-flow) : [object CSSValueList]
821	g: style.getPropertyValue(-webkit-grid-auto-rows) : auto	821	g: style.getPropertyValue(-webkit-grid-auto-rows) : auto
822	g: style.getPropertyCSSValue(-webkit-grid-auto-rows) : [object CSSPrimitiveValue]	822	g: style.getPropertyCSSValue(-webkit-grid-auto-rows) : [object CSSPrimitiveValue]
823	g: style.getPropertyValue(-webkit-grid-column-end) : auto	823	g: style.getPropertyValue(-webkit-grid-column-end) : auto