Attachment #241420 for bug #133359

View Details Raw Unified Return to Bug 133359

| Differences between



2014-10-27  Javier Fernandez  <jfernandez@igalia.com>

        [CSS Grid Layout] Upgrade align-self and align-items parsing to CSS 3
        https://bugs.webkit.org/show_bug.cgi?id=133359

        Reviewed by David Hyatt.

        Broaden justify-self's parsing name as a preparation of migrating
        align-self, align-items and justify-items to the CSS 3 Alignment syntax.

        The current naming was too tied to justify-self and needs to
        be broadened. This will reduce the follow-up implementations'
        patches.

        Upgrade align-self and align-items parsing to CSS 3

        This change migrates the 2 properties to the CSS 3 Alignment
        parsing. The new parsing is identical to how we parse
        'justify-self'. The 2 properties need to be migrated together
        as they are used in tandem in CSSComputedStyleDeclaration.

        This change also removes EAlignItems as it is now unused.

        Tests: css3/parse-align-items.html
               css3/parse-align-self.html

        * css/CSSComputedStyleDeclaration.cpp:
        (WebCore::valueForItemPositionWithOverflowAlignment): Added. Builds the CSSValue for the for the alignment properties.
        (WebCore::ComputedStyleExtractor::propertyValue):
        * css/CSSParser.cpp:
        (WebCore::isKeywordPropertyID): Removed align-items and align-self from the list.
        (WebCore::isValidKeywordPropertyAndValue): Removed align-items and align-self from the list.
        (WebCore::CSSParser::parseValue): Added align-items and align-self to the list and call to the generic parsing fuction for the alignment properties.
        (WebCore::isBaselinePositionKeyword): Utility function added to identify Baseline keyword values.
        (WebCore::CSSParser::parseItemPositionOverflowPosition): Generic parsing fuction for the alignment properties.
        (WebCore::CSSParser::parseJustifySelf): Deleted.
        * css/CSSParser.h:
        * css/CSSPrimitiveValueMappings.h:
        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue): Refactoring some mapping functions.
       (WebCore::CSSPrimitiveValue::operator ItemPosition): Added. Replace the old EAlignItems enumeration.
        (WebCore::CSSPrimitiveValue::operator OverflowAlignment): Added.
        (WebCore::CSSPrimitiveValue::operator EAlignItems): Deleted.
        (WebCore::CSSPrimitiveValue::operator EJustifySelf): Deleted.
        (WebCore::CSSPrimitiveValue::operator EJustifySelfOverflowAlignment): Deleted.
        * css/CSSPropertyNames.in:
        * css/CSSValueKeywords.in:
        * css/StyleResolver.cpp:
        (WebCore::StyleResolver::adjustRenderStyle): Added a new adjustment to resolve the "auto" vale on the alignment properties.
        (WebCore::StyleResolver::adjustStyleForAlignment): Added. Function to resolve the "auto" vale on the alignment properties. 
        (WebCore::StyleResolver::applyProperty):
        (WebCore::isDisplayFlexibleBox): Deleted. Moved to the RenderStyle.
        (WebCore::isDisplayGridBox): Deleted. Moved to the RenderStyle.
        (WebCore::isDisplayFlexibleOrGridBox): Deleted. Moved to the RenderStyle.
        * css/StyleResolver.h:
        * rendering/RenderBox.cpp:
        (WebCore::flexItemHasStretchAlignment): Adapted to the new ItemPosition enum.
        * rendering/RenderFlexibleBox.cpp:
        (WebCore::RenderFlexibleBox::firstLineBaseline): Adapted to the new ItemPosition enum.
        (WebCore::resolveAlignment): Consider also that align-items could be "auto", since it's the default now.
        (WebCore::RenderFlexibleBox::styleDidChange): Adapted to the new ItemPosition enum.
        (WebCore::RenderFlexibleBox::alignmentForChild): Adapted to the new ItemPosition enum.
        (WebCore::RenderFlexibleBox::needToStretchChild): Adapted to the new ItemPosition enum.
        (WebCore::RenderFlexibleBox::layoutAndPlaceChildren): Adapted to the new ItemPosition enum.
        (WebCore::RenderFlexibleBox::alignChildren): Adapted to the new ItemPosition enum.
        * rendering/RenderFlexibleBox.h:
        * rendering/RenderFullScreen.cpp:
        (WebCore::createFullScreenStyle): Adapted to the new ItemPosition enum.
        * rendering/RenderMenuList.cpp:
        (WebCore::RenderMenuList::adjustInnerStyle): Adapted to the new ItemPosition enum.
        * rendering/mathml/RenderMathMLRoot.cpp:
        (WebCore::RenderMathMLRoot::updateStyle): Adapted to the new ItemPosition enum.
        * rendering/mathml/RenderMathMLScripts.cpp:
        (WebCore::RenderMathMLScripts::fixAnonymousStyleForSubSupPair): Adapted to the new ItemPosition enum.
        (WebCore::RenderMathMLScripts::fixAnonymousStyles): Adapted to the new ItemPosition enum.
        * rendering/style/RenderStyle.h: Adapted to the new ItemPosition enum.
        * rendering/style/RenderStyleConstants.h: Adapted to the new ItemPosition enum.
        * rendering/style/StyleRareNonInheritedData.cpp: Adapted to the new ItemPosition enum.
        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData): Adapted to the new ItemPosition enum.
        (WebCore::StyleRareNonInheritedData::operator==): Adapted to the new ItemPosition enum.
        * rendering/style/StyleRareNonInheritedData.h: Adapted to the new ItemPosition enum.
        * style/StyleResolveTree.cpp:
        (WebCore::Style::determineChange): Changes in the alignItems property will cause a Detach.

2014-10-26  Benjamin Poulain  <benjamin@webkit.org>

        Images with usemap should not have a link state



    CSSPropertyFlexDirection,
    CSSPropertyFlexWrap,
    CSSPropertyJustifyContent,
    CSSPropertyJustifySelf,
    CSSPropertyWebkitFilter,
    CSSPropertyWebkitFontKerning,
    CSSPropertyWebkitFontSmoothing,

}
#endif

static PassRefPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment)
{
    RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
    result->append(cssValuePool().createValue(itemPosition));
    if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
        result->append(cssValuePool().createValue(overflowAlignment));
    return result.release();
}

PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const
{
    Node* styledNode = this->styledNode();

        case CSSPropertyAlignContent:
            return cssValuePool().createValue(style->alignContent());
        case CSSPropertyAlignItems:
            return valueForItemPositionWithOverflowAlignment(style->alignItems(), style->alignItemsOverflowAlignment());
        case CSSPropertyAlignSelf: {
            ItemPosition alignSelf = style->alignSelf();
            OverflowAlignment overflow = style->alignSelfOverflowAlignment();
            if (alignSelf == ItemPositionAuto) {
                Node* parent = styledNode->parentNode();
                if (parent && parent->computedStyle()) {
                    alignSelf = parent->computedStyle()->alignItems();
                    overflow = parent->computedStyle()->alignItemsOverflowAlignment();
                }
            }
            return valueForItemPositionWithOverflowAlignment(alignSelf, overflow);
        }
        case CSSPropertyFlex:
            return getCSSPropertyValuesForShorthandProperties(flexShorthand());
        case CSSPropertyFlexBasis:

            return cssValuePool().createValue(style->flexWrap());
        case CSSPropertyJustifyContent:
            return cssValuePool().createValue(style->justifyContent());
        case CSSPropertyJustifySelf:
            return valueForItemPositionWithOverflowAlignment(style->justifySelf(), style->justifySelfOverflowAlignment());
            result->append(CSSPrimitiveValue::create(style->justifySelf()));
            if (style->justifySelf() >= JustifySelfCenter && style->justifySelfOverflowAlignment() != JustifySelfOverflowAlignmentDefault)
                result->append(CSSPrimitiveValue::create(style->justifySelfOverflowAlignment()));
            return result.release();
        }
        case CSSPropertyOrder:
            return cssValuePool().createValue(style->order(), CSSPrimitiveValue::CSS_NUMBER);
        case CSSPropertyFloat:



        if (valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround || valueID == CSSValueStretch)
            return true;
        break;
#if !ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyAlignItems:
        // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.
        if (valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch)

        if (valueID == CSSValueAuto || valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch)
            return true;
        break;
#endif
    case CSSPropertyFlexDirection:
        if (valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse)
            return true;

        if (valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround)
            return true;
        break;
#if !ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyJustifySelf:
        if (valueID == CSSValueAuto || valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch)
            return true;
        break;
#endif
    case CSSPropertyWebkitFontKerning:
        if (valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone)
            return true;

    case CSSPropertyWebkitColumnFill:
    case CSSPropertyWebkitColumnRuleStyle:
    case CSSPropertyAlignContent:
#if !ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyAlignItems:
    case CSSPropertyAlignSelf:
#endif
    case CSSPropertyFlexDirection:
    case CSSPropertyFlexWrap:
    case CSSPropertyJustifyContent:

        }
        return false;
    }
    case CSSPropertyWebkitJustifySelf:
        return parseJustifySelf(propId, important);
#if ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyJustifySelf:
        return parseItemPositionOverflowPosition(propId, important);
    case CSSPropertyWebkitGridAutoColumns:
    case CSSPropertyWebkitGridAutoRows:
        parsedValue = parseGridTrackSize(*m_valueList);

        parsedValue = parseImageResolution();
        break;
#endif
#if ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyAlignSelf:
        return parseItemPositionOverflowPosition(propId, important);

    case CSSPropertyAlignItems:
        return parseItemPositionOverflowPosition(propId, important);
#endif
    case CSSPropertyBorderBottomStyle:
    case CSSPropertyBorderCollapse:
    case CSSPropertyBorderLeftStyle:

    case CSSPropertyWebkitColumnFill:
    case CSSPropertyWebkitColumnRuleStyle:
    case CSSPropertyAlignContent:
#if !ENABLE(CSS_GRID_LAYOUT)
    case CSSPropertyAlignItems:
    case CSSPropertyAlignSelf:
    case CSSPropertyJustifySelf:
#endif
    case CSSPropertyFlexDirection:
    case CSSPropertyFlexWrap:
    case CSSPropertyJustifyContent:

    lval = WTF::move(list);
}

static inline bool isBaselinePositionKeyword(CSSValueID id)
{
    return id == CSSValueBaseline || id == CSSValueLastBaseline;
}

static bool isItemPositionKeyword(CSSValueID id)
{
    return id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter

        || id == CSSValueFlexEnd || id == CSSValueLeft || id == CSSValueRight;
}

bool CSSParser::parseItemPositionOverflowPosition(CSSPropertyID propId, bool important)
{
    // auto | baseline | stretch | [<item-position> && <overflow-position>? ]
    // <item-position> = center | start | end | self-start | self-end | flex-start | flex-end | left | right;


    CSSParserValue* value = m_valueList->current();

    if (value->id == CSSValueAuto || value->id == CSSValueStretch || isBaselinePositionKeyword(value->id)) {
        if (m_valueList->next())
            return false;


Lines 177-183 public: a/Source/WebCore/css/CSSParser.h_sec1
- a/Source/WebCore/css/CSSParser.h -1 / +1 lines
177		177
178	bool parseClipShape(CSSPropertyID, bool important);	178	bool parseClipShape(CSSPropertyID, bool important);
179		179
180	bool parseJustifySelf(CSSPropertyID, bool important);	180	bool parseItemPositionOverflowPosition(CSSPropertyID, bool important);
181		181
182	#if ENABLE(CSS_SHAPES)	182	#if ENABLE(CSS_SHAPES)
183	PassRefPtr<CSSValue> parseShapeProperty(CSSPropertyID);	183	PassRefPtr<CSSValue> parseShapeProperty(CSSPropertyID);



    return SHOW;
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignItems e)
    : CSSValue(PrimitiveClass)
{
    m_primitiveUnitType = CSS_VALUE_ID;
    switch (e) {
    case AlignAuto:
        m_value.valueID = CSSValueAuto;
        break;
    case AlignFlexStart:
        m_value.valueID = CSSValueFlexStart;
        break;
    case AlignFlexEnd:
        m_value.valueID = CSSValueFlexEnd;
        break;
    case AlignCenter:
        m_value.valueID = CSSValueCenter;
        break;
    case AlignStretch:
        m_value.valueID = CSSValueStretch;
        break;
    case AlignBaseline:
        m_value.valueID = CSSValueBaseline;
        break;
    }
}

template<> inline CSSPrimitiveValue::operator EAlignItems() const
{
    ASSERT(isValueID());

    switch (m_value.valueID) {
    case CSSValueAuto:
        return AlignAuto;
    case CSSValueFlexStart:
        return AlignFlexStart;
    case CSSValueFlexEnd:
        return AlignFlexEnd;
    case CSSValueCenter:
        return AlignCenter;
    case CSSValueStretch:
        return AlignStretch;
    case CSSValueBaseline:
        return AlignBaseline;
    default:
        break;
    }

    ASSERT_NOT_REACHED();
    return AlignFlexStart;
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e)
    : CSSValue(PrimitiveClass)
{

    return BoxMissing;
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
    : CSSValue(PrimitiveClass)
{
    m_primitiveUnitType = CSS_VALUE_ID;
    switch (itemPosition) {
    case ItemPositionAuto:
        m_value.valueID = CSSValueAuto;
        break;
    case ItemPositionStretch:
        m_value.valueID = CSSValueStretch;
        break;
    case ItemPositionBaseline:
        m_value.valueID = CSSValueBaseline;
        break;
    case ItemPositionLastBaseline:
        m_value.valueID = CSSValueLastBaseline;
        break;
    case ItemPositionCenter:
        m_value.valueID = CSSValueCenter;
        break;
    case ItemPositionStart:
        m_value.valueID = CSSValueStart;
        break;
    case ItemPositionEnd:
        m_value.valueID = CSSValueEnd;
        break;
    case ItemPositionSelfStart:
        m_value.valueID = CSSValueSelfStart;
        break;
    case ItemPositionSelfEnd:
        m_value.valueID = CSSValueSelfEnd;
        break;
    case ItemPositionFlexStart:
        m_value.valueID = CSSValueFlexStart;
        break;
    case ItemPositionFlexEnd:
        m_value.valueID = CSSValueFlexEnd;
        break;
    case ItemPositionLeft:
        m_value.valueID = CSSValueLeft;
        break;
    case ItemPositionRight:
        m_value.valueID = CSSValueRight;
        break;
    default:
        m_value.valueID = CSSValueAuto;
        break;
    }
}

template<> inline CSSPrimitiveValue::operator ItemPosition() const
{
    switch (m_value.valueID) {
    case CSSValueAuto:
        return ItemPositionAuto;
    case CSSValueStretch:
        return ItemPositionStretch;
    case CSSValueBaseline:
        return ItemPositionBaseline;
    case CSSValueLastBaseline:
        return ItemPositionLastBaseline;
    case CSSValueCenter:
        return ItemPositionCenter;
    case CSSValueStart:
        return ItemPositionStart;
    case CSSValueEnd:
        return ItemPositionEnd;
    case CSSValueSelfStart:
        return ItemPositionSelfStart;
    case CSSValueSelfEnd:
        return ItemPositionSelfEnd;
    case CSSValueFlexStart:
        return ItemPositionFlexStart;
    case CSSValueFlexEnd:
        return ItemPositionFlexEnd;
    case CSSValueLeft:
        return ItemPositionLeft;
    case CSSValueRight:
        return ItemPositionRight;
    default:
        break;
    }
    ASSERT_NOT_REACHED();
    return ItemPositionAuto;
}

template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
    : CSSValue(PrimitiveClass)
{
    m_primitiveUnitType = CSS_VALUE_ID;
    switch (overflowAlignment) {
    case OverflowAlignmentDefault:
        m_value.valueID = CSSValueDefault;
        break;
    case OverflowAlignmentTrue:
        m_value.valueID = CSSValueTrue;
        break;
    case OverflowAlignmentSafe:
        m_value.valueID = CSSValueSafe;
        break;
    }
}

template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
{
    switch (m_value.valueID) {
    case CSSValueTrue:
        return OverflowAlignmentTrue;
    case CSSValueSafe:
        return OverflowAlignmentSafe;
    default:
        break;
    }
    ASSERT_NOT_REACHED();
    return OverflowAlignmentTrue;
}





-webkit-filter
align-content [NewStyleBuilder]
-webkit-align-content = align-content
align-items
-webkit-align-items = align-items
align-self
-webkit-align-self = align-self
flex
-webkit-flex = flex

-webkit-flex-wrap = flex-wrap
justify-content [NewStyleBuilder]
-webkit-justify-content = justify-content
justify-self
-webkit-justify-self = justify-self
-webkit-font-size-delta
#if defined(ENABLE_CSS_GRID_LAYOUT) && ENABLE_CSS_GRID_LAYOUT
-webkit-grid



// flex-end
// center
// baseline
last-baseline
// stretch

// CSS_PROP_JUSTIFY_CONTENT

// auto
// stretch
// baseline
// last-baseline
// center
// start
// end



        || style.isFloating() || style.hasOutOfFlowPosition();
}

static bool isDisplayFlexibleBox(EDisplay display)
{
    return display == FLEX || display == INLINE_FLEX;
}

static inline bool isDisplayGridBox(EDisplay display)
{
#if ENABLE(CSS_GRID_LAYOUT)
    return display == GRID || display == INLINE_GRID;
#else
    UNUSED_PARAM(display);
    return false;
#endif
}

static bool isDisplayFlexibleOrGridBox(EDisplay display)
{
    return isDisplayFlexibleBox(display) || isDisplayGridBox(display);
}

#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
static bool isScrollableOverflow(EOverflow overflow)
{

        if (style.writingMode() != TopToBottomWritingMode && (style.display() == BOX || style.display() == INLINE_BOX))
            style.setWritingMode(TopToBottomWritingMode);

        if (parentStyle.isDisplayFlexibleOrGridBox()) {
            style.setFloating(NoFloat);
            style.setDisplay(equivalentBlockDisplay(style.display(), style.isFloating(), !document().inQuirksMode()));
        }
    }

    // Make sure our z-index value is only applied if the object is positioned.
    if (style.position() == StaticPosition && !parentStyle.isDisplayFlexibleOrGridBox())
        style.setHasAutoZIndex();

    // Auto z-index becomes 0 for the root element and transparent objects. This prevents

        if ((e->hasTagName(SVGNames::foreignObjectTag) || e->hasTagName(SVGNames::textTag)) && style.isDisplayInlineType())
            style.setDisplay(BLOCK);
    }

    // CSS Box Alignment specification requires to resolve "auto" (inital/default) values.
    adjustStyleForAlignment(style);
}

void StyleResolver::adjustStyleForAlignment(RenderStyle& style)
{
    // The 'auto' keyword computes to:
    //  - 'stretch' for flex containers and grid containers,
    //  - 'start' for everything else. (to be resolved later, during the layout)
    if (style.alignItems() == ItemPositionAuto) {
        if (style.isDisplayFlexibleOrGridBox())
            style.setAlignItems(ItemPositionStretch);
        else
            style.setAlignItems(ItemPositionStart);
    }

    // The 'auto' keyword computes to 'stretch' on absolutely-positioned elements,
    // and to the computed value of align-items on the parent (minus
    // any 'legacy' keywords) on all other boxes (to be resolved during the layout).
    if (style.alignSelf() == ItemPositionAuto) {
        if ((style.position() == AbsolutePosition))
            style.setAlignSelf(ItemPositionStretch);
    }
}

bool StyleResolver::checkRegionStyle(Element* regionElement)

        return;
    }
#endif /* ENABLE(CSS_GRID_LAYOUT) */
    case CSSPropertyAlignSelf: {
        if (isInherit) {
            state.style()->setAlignSelf(state.parentStyle()->alignSelf());
            state.style()->setAlignSelfOverflowAlignment(state.parentStyle()->alignSelfOverflowAlignment());
            return;
        }
        if (isInitial) {
            state.style()->setAlignSelf(RenderStyle::initialAlignSelf());
            state.style()->setAlignSelfOverflowAlignment(RenderStyle::initialAlignSelfOverflowAlignment());
            return;
        }
        if (Pair* pairValue = primitiveValue->getPairValue()) {
            state.style()->setAlignSelf(*pairValue->first());
            state.style()->setAlignSelfOverflowAlignment(*pairValue->second());
        } else
            state.style()->setAlignSelf(*primitiveValue);
        return;
    }

    case CSSPropertyAlignItems: {
        if (isInherit) {
            state.style()->setAlignItems(state.parentStyle()->alignItems());
            state.style()->setAlignItemsOverflowAlignment(state.parentStyle()->alignItemsOverflowAlignment());
            return;
        }
        if (isInitial) {
            state.style()->setAlignItems(RenderStyle::initialAlignItems());
            state.style()->setAlignItemsOverflowAlignment(RenderStyle::initialAlignItemsOverflowAlignment());
            return;
        }
        if (Pair* pairValue = primitiveValue->getPairValue()) {
            state.style()->setAlignItems(*pairValue->first());
            state.style()->setAlignItemsOverflowAlignment(*pairValue->second());
        } else
            state.style()->setAlignItems(*primitiveValue);
        return;
    }
    case CSSPropertyJustifySelf: {
        if (isInherit) {
            state.style()->setJustifySelf(state.parentStyle()->justifySelf());
            state.style()->setJustifySelfOverflowAlignment(state.parentStyle()->justifySelfOverflowAlignment());
            return;
        }
        if (isInitial) {
            state.style()->setJustifySelf(RenderStyle::initialJustifySelf());
            state.style()->setJustifySelfOverflowAlignment(RenderStyle::initialJustifySelfOverflowAlignment());
            return;
        }
        if (Pair* pairValue = primitiveValue->getPairValue()) {
            state.style()->setJustifySelf(*pairValue->first());
            state.style()->setJustifySelfOverflowAlignment(*pairValue->second());
        } else
            state.style()->setJustifySelf(*primitiveValue);
        return;
    }
#if ENABLE(CSS_SCROLL_SNAP)
    case CSSPropertyWebkitScrollSnapType:
        HANDLE_INHERIT_AND_INITIAL(scrollSnapType, ScrollSnapType);

    case CSSPropertyWebkitCursorVisibility:
#endif
    case CSSPropertyAlignContent:
    case CSSPropertyAlignItems:
    case CSSPropertyAlignSelf:
    case CSSPropertyFlexBasis:
    case CSSPropertyFlexDirection:
    case CSSPropertyFlexGrow:

Lines 296-301 private: a/Source/WebCore/css/StyleResolver.h_sec1
- a/Source/WebCore/css/StyleResolver.h +1 lines
296	#endif	296	#endif
297		297
298	void adjustRenderStyle(RenderStyle& styleToAdjust, const RenderStyle& parentStyle, Element*);	298	void adjustRenderStyle(RenderStyle& styleToAdjust, const RenderStyle& parentStyle, Element*);
		299	void adjustStyleForAlignment(RenderStyle& styleToAdjust);
299	#if ENABLE(CSS_GRID_LAYOUT)	300	#if ENABLE(CSS_GRID_LAYOUT)
300	std::unique_ptr<GridPosition> adjustNamedGridItemPosition(const NamedGridAreaMap&, const NamedGridLinesMap&, const GridPosition&, GridPositionSide) const;	301	std::unique_ptr<GridPosition> adjustNamedGridItemPosition(const NamedGridAreaMap&, const NamedGridLinesMap&, const GridPosition&, GridPositionSide) const;
301	#endif	302	#endif

Lines 2422-2428 LayoutUnit RenderBox::computeLogicalWidthInRegionUsing(SizeType widthType, Lengt a/Source/WebCore/rendering/RenderBox.cpp_sec1
- a/Source/WebCore/rendering/RenderBox.cpp -1 / +1 lines
2422	static bool flexItemHasStretchAlignment(const RenderBox& flexitem)	2422	static bool flexItemHasStretchAlignment(const RenderBox& flexitem)
2423	{	2423	{
2424	auto parent = flexitem.parent();	2424	auto parent = flexitem.parent();
2425	return flexitem.style().alignSelf() == AlignStretch \|\| (flexitem.style().alignSelf() == AlignAuto && parent->style().alignItems() == AlignStretch);	2425	return flexitem.style().alignSelf() == ItemPositionStretch \|\| (flexitem.style().alignSelf() == ItemPositionAuto && parent->style().alignItems() == ItemPositionStretch);
2426	}	2426	}
2427		2427
2428	static bool isStretchingColumnFlexItem(const RenderBox& flexitem)	2428	static bool isStretchingColumnFlexItem(const RenderBox& flexitem)



#include "RenderFlexibleBox.h"

#include "LayoutRepainter.h"
#include "NotImplemented.h"
#include "RenderLayer.h"
#include "RenderView.h"
#include <limits>

    for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
        if (child->isOutOfFlowPositioned())
            continue;
        if (alignmentForChild(*child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(*child)) {
            baselineChild = child;
            break;
        }

    return synthesizedBaselineFromContentBox(*this, direction) + marginAscent;
}

static ItemPosition resolveAlignment(const RenderStyle* parentStyle, const RenderStyle* childStyle)
{
    ItemPosition align = childStyle->alignSelf();
    if (align == ItemPositionAuto)
        align = (parentStyle->alignItems() == ItemPositionAuto) ? ItemPositionStretch : parentStyle->alignItems();
    return align;
}


{
    RenderBlock::styleDidChange(diff, oldStyle);

    if (oldStyle && oldStyle->alignItems() == ItemPositionStretch && diff == StyleDifferenceLayout) {
        // Flex items that were previously stretching need to be relayed out so we can compute new available cross axis space.
        // This is only necessary for stretching since other alignment values don't change the size of the box.
        for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
            ItemPosition previousAlignment = resolveAlignment(oldStyle, &child->style());
            if (previousAlignment == ItemPositionStretch && previousAlignment != resolveAlignment(&style(), &child->style()))
                child->setChildNeedsLayout(MarkOnlyThis);
        }
    }

    }
}

ItemPosition RenderFlexibleBox::alignmentForChild(RenderBox& child) const
{
    ItemPosition align = resolveAlignment(&style(), &child.style());

    if (align == ItemPositionBaseline && hasOrthogonalFlow(child))
        align = ItemPositionFlexStart;

    if (style().flexWrap() == FlexWrapReverse) {
        if (align == ItemPositionFlexStart)
            align = ItemPositionFlexEnd;
        else if (align == ItemPositionFlexEnd)
            align = ItemPositionFlexStart;
    }

    return align;


bool RenderFlexibleBox::needToStretchChild(RenderBox& child)
{
    if (alignmentForChild(child) != ItemPositionStretch)
        return false;

    Length crossAxisLength = isHorizontalFlow() ? child.style().height() : child.style().width();

        updateAutoMarginsInMainAxis(child, autoMarginOffset);

        LayoutUnit childCrossAxisMarginBoxExtent;
        if (alignmentForChild(child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(child)) {
            LayoutUnit ascent = marginBoxAscentForChild(child);
            LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;


                continue;

            switch (alignmentForChild(*child)) {
            case ItemPositionAuto:
                ASSERT_NOT_REACHED();
                break;
            case ItemPositionStart:
                // FIXME: https://webkit.org/b/135460 - The extended grammar is not supported
                // yet for FlexibleBox.
                // Defaulting to Stretch for now, as it what most of FlexBox based renders
                // expect as default.
                notImplemented();
            case ItemPositionStretch: {
                applyStretchAlignmentToChild(*child, lineCrossAxisExtent);
                // Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.
                if (style().flexWrap() == FlexWrapReverse)
                    adjustAlignmentForChild(*child, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child));
                break;
            }
            case ItemPositionFlexStart:
                break;
            case ItemPositionFlexEnd:
                adjustAlignmentForChild(*child, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child));
                break;
            case ItemPositionCenter:
                adjustAlignmentForChild(*child, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child) / 2);
                break;
            case ItemPositionBaseline: {
                // FIXME: If we get here in columns, we want the use the descent, except we currently can't get the ascent/descent of orthogonal children.
                // https://bugs.webkit.org/show_bug.cgi?id=98076
                LayoutUnit ascent = marginBoxAscentForChild(*child);

                    minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child) - startOffset);
                break;
            }
            case ItemPositionLastBaseline:
            case ItemPositionSelfStart:
            case ItemPositionSelfEnd:
            case ItemPositionEnd:
            case ItemPositionLeft:
            case ItemPositionRight:
                // FIXME: https://webkit.org/b/135460 - The extended grammar is not supported
                // yet for FlexibleBox.
                notImplemented();
            default:
                ASSERT_NOT_REACHED();
                break;
            }
        }
        minMarginAfterBaselines.append(minMarginAfterBaseline);

        LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
        for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
            ASSERT(child);
            if (alignmentForChild(*child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(*child) && minMarginAfterBaseline)
                adjustAlignmentForChild(*child, minMarginAfterBaseline);
        }
    }

Lines 118-124 private: a/Source/WebCore/rendering/RenderFlexibleBox.h_sec1
- a/Source/WebCore/rendering/RenderFlexibleBox.h -1 / +1 lines
118	// FIXME: Supporting layout deltas.	118	// FIXME: Supporting layout deltas.
119	void setFlowAwareLocationForChild(RenderBox& child, const LayoutPoint&);	119	void setFlowAwareLocationForChild(RenderBox& child, const LayoutPoint&);
120	void adjustAlignmentForChild(RenderBox& child, LayoutUnit);	120	void adjustAlignmentForChild(RenderBox& child, LayoutUnit);
121	EAlignItems alignmentForChild(RenderBox& child) const;	121	ItemPosition alignmentForChild(RenderBox& child) const;
122	LayoutUnit mainAxisBorderAndPaddingExtentForChild(RenderBox& child) const;	122	LayoutUnit mainAxisBorderAndPaddingExtentForChild(RenderBox& child) const;
123	LayoutUnit mainAxisScrollbarExtentForChild(RenderBox& child) const;	123	LayoutUnit mainAxisScrollbarExtentForChild(RenderBox& child) const;
124	LayoutUnit preferredMainAxisContentExtentForChild(RenderBox& child, bool hasInfiniteLineLength);	124	LayoutUnit preferredMainAxisContentExtentForChild(RenderBox& child, bool hasInfiniteLineLength);

Lines 90-96 static PassRef<RenderStyle> createFullScreenStyle() a/Source/WebCore/rendering/RenderFullScreen.cpp_sec1
- a/Source/WebCore/rendering/RenderFullScreen.cpp -1 / +1 lines
90		90
91	fullscreenStyle.get().setDisplay(FLEX);	91	fullscreenStyle.get().setDisplay(FLEX);
92	fullscreenStyle.get().setJustifyContent(JustifyCenter);	92	fullscreenStyle.get().setJustifyContent(JustifyCenter);
93	fullscreenStyle.get().setAlignItems(AlignCenter);	93	fullscreenStyle.get().setAlignItems(ItemPositionCenter);
94	fullscreenStyle.get().setFlexDirection(FlowColumn);	94	fullscreenStyle.get().setFlexDirection(FlowColumn);
95		95
96	fullscreenStyle.get().setPosition(FixedPosition);	96	fullscreenStyle.get().setPosition(FixedPosition);



    // Use margin:auto instead of align-items:center to get safe centering, i.e.
    // when the content overflows, treat it the same as align-items: flex-start.
    // But we only do that for the cases where html.css would otherwise use center.
    if (style().alignItems() == ItemPositionCenter) {
        innerStyle.setMarginTop(Length());
        innerStyle.setMarginBottom(Length());
        innerStyle.setAlignSelf(ItemPositionFlexStart);
    }

    innerStyle.setPaddingLeft(Length(theme().popupInternalPaddingLeft(style()), Fixed));



    auto base = baseWrapper();
    auto baseStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
    baseStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
    baseStyle.get().setAlignItems(ItemPositionBaseline);
    base->setStyle(WTF::move(baseStyle));
    base->setNeedsLayoutAndPrefWidthsRecalc();


        indexStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
        indexStyle.get().setMarginStart(Length(kernBeforeDegree, Fixed));
        indexStyle.get().setMarginEnd(Length(kernAfterDegree, Fixed));
        indexStyle.get().setAlignItems(ItemPositionBaseline);
        index->setStyle(WTF::move(indexStyle));
        index->setNeedsLayoutAndPrefWidthsRecalc();
    }



    // The MathML specification does not specify vertical alignment of scripts.
    // Let's right align prescripts and left align postscripts.
    // See http://lists.w3.org/Archives/Public/www-math/2012Aug/0006.html
    scriptsStyle.setAlignItems(isPostScript ? ItemPositionFlexStart : ItemPositionFlexEnd);

    // We set the order property so that the prescripts are drawn before the base.
    scriptsStyle.setOrder(isPostScript ? 0 : -1);

{
    // We set the base wrapper's style so that baseHeight in layout() will be an unstretched height.
    ASSERT(m_baseWrapper && m_baseWrapper->style().hasOneRef());
    m_baseWrapper->style().setAlignSelf(ItemPositionFlexStart);

    // This sets the style for postscript pairs.
    RenderObject* subSupPair = m_baseWrapper;

            RenderStyle& scriptsStyle = subSupPair->style();
            scriptsStyle.setFlexDirection(FlowRow);
            scriptsStyle.setJustifyContent(JustifyFlexStart);
            scriptsStyle.setAlignItems(ItemPositionCenter);
            scriptsStyle.setOrder(0);
            scriptsStyle.setFontSize(style().fontSize());
        }

Lines 894-908 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec1
- a/Source/WebCore/rendering/style/RenderStyle.h -12 / +39 lines
894	float flexShrink() const { return rareNonInheritedData->m_flexibleBox->m_flexShrink; }	894	float flexShrink() const { return rareNonInheritedData->m_flexibleBox->m_flexShrink; }
895	const Length& flexBasis() const { return rareNonInheritedData->m_flexibleBox->m_flexBasis; }	895	const Length& flexBasis() const { return rareNonInheritedData->m_flexibleBox->m_flexBasis; }
896	EAlignContent alignContent() const { return static_cast<EAlignContent>(rareNonInheritedData->m_alignContent); }	896	EAlignContent alignContent() const { return static_cast<EAlignContent>(rareNonInheritedData->m_alignContent); }
897	EAlignItems alignItems() const { return static_cast<EAlignItems>(rareNonInheritedData->m_alignItems); }	897	ItemPosition alignItems() const { return static_cast<ItemPosition>(rareNonInheritedData->m_alignItems); }
898	EAlignItems alignSelf() const { return static_cast<EAlignItems>(rareNonInheritedData->m_alignSelf); }	898	OverflowAlignment alignItemsOverflowAlignment() const { return static_cast<OverflowAlignment>(rareNonInheritedData->m_alignItemsOverflowAlignment); }
		899	ItemPosition alignSelf() const { return static_cast<ItemPosition>(rareNonInheritedData->m_alignSelf); }
		900	OverflowAlignment alignSelfOverflowAlignment() const { return static_cast<OverflowAlignment>(rareNonInheritedData->m_alignSelfOverflowAlignment); }
899	EFlexDirection flexDirection() const { return static_cast<EFlexDirection>(rareNonInheritedData->m_flexibleBox->m_flexDirection); }	901	EFlexDirection flexDirection() const { return static_cast<EFlexDirection>(rareNonInheritedData->m_flexibleBox->m_flexDirection); }
900	bool isColumnFlexDirection() const { return flexDirection() == FlowColumn \|\| flexDirection() == FlowColumnReverse; }	902	bool isColumnFlexDirection() const { return flexDirection() == FlowColumn \|\| flexDirection() == FlowColumnReverse; }
901	bool isReverseFlexDirection() const { return flexDirection() == FlowRowReverse \|\| flexDirection() == FlowColumnReverse; }	903	bool isReverseFlexDirection() const { return flexDirection() == FlowRowReverse \|\| flexDirection() == FlowColumnReverse; }
902	EFlexWrap flexWrap() const { return static_cast<EFlexWrap>(rareNonInheritedData->m_flexibleBox->m_flexWrap); }	904	EFlexWrap flexWrap() const { return static_cast<EFlexWrap>(rareNonInheritedData->m_flexibleBox->m_flexWrap); }
903	EJustifyContent justifyContent() const { return static_cast<EJustifyContent>(rareNonInheritedData->m_justifyContent); }	905	EJustifyContent justifyContent() const { return static_cast<EJustifyContent>(rareNonInheritedData->m_justifyContent); }
904	EJustifySelf justifySelf() const { return static_cast<EJustifySelf>(rareNonInheritedData->m_justifySelf); }	906	ItemPosition justifySelf() const { return static_cast<ItemPosition>(rareNonInheritedData->m_justifySelf); }
905	EJustifySelfOverflowAlignment justifySelfOverflowAlignment() const { return static_cast<EJustifySelfOverflowAlignment>(rareNonInheritedData->m_justifySelfOverflowAlignment); }	907	OverflowAlignment justifySelfOverflowAlignment() const { return static_cast<OverflowAlignment>(rareNonInheritedData->m_justifySelfOverflowAlignment); }
906		908
907	#if ENABLE(CSS_GRID_LAYOUT)	909	#if ENABLE(CSS_GRID_LAYOUT)
908	const Vector<GridTrackSize>& gridColumns() const { return rareNonInheritedData->m_grid->m_gridColumns; }	910	const Vector<GridTrackSize>& gridColumns() const { return rareNonInheritedData->m_grid->m_gridColumns; }
Lines 1458-1470 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec2
1458	void setFlexBasis(Length length) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexBasis, WTF::move(length)); }	1460	void setFlexBasis(Length length) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexBasis, WTF::move(length)); }
1459	void setOrder(int o) { SET_VAR(rareNonInheritedData, m_order, o); }	1461	void setOrder(int o) { SET_VAR(rareNonInheritedData, m_order, o); }
1460	void setAlignContent(EAlignContent p) { SET_VAR(rareNonInheritedData, m_alignContent, p); }	1462	void setAlignContent(EAlignContent p) { SET_VAR(rareNonInheritedData, m_alignContent, p); }
1461	void setAlignItems(EAlignItems a) { SET_VAR(rareNonInheritedData, m_alignItems, a); }	1463	void setAlignItems(ItemPosition a) { SET_VAR(rareNonInheritedData, m_alignItems, a); }
1462	void setAlignSelf(EAlignItems a) { SET_VAR(rareNonInheritedData, m_alignSelf, a); }	1464	void setAlignItemsOverflowAlignment(OverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_alignItemsOverflowAlignment, overflowAlignment); }
		1465	void setAlignSelf(ItemPosition a) { SET_VAR(rareNonInheritedData, m_alignSelf, a); }
		1466	void setAlignSelfOverflowAlignment(OverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_alignSelfOverflowAlignment, overflowAlignment); }
1463	void setFlexDirection(EFlexDirection direction) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexDirection, direction); }	1467	void setFlexDirection(EFlexDirection direction) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexDirection, direction); }
1464	void setFlexWrap(EFlexWrap w) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexWrap, w); }	1468	void setFlexWrap(EFlexWrap w) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexWrap, w); }
1465	void setJustifyContent(EJustifyContent p) { SET_VAR(rareNonInheritedData, m_justifyContent, p); }	1469	void setJustifyContent(EJustifyContent p) { SET_VAR(rareNonInheritedData, m_justifyContent, p); }
1466	void setJustifySelf(EJustifySelf p) { SET_VAR(rareNonInheritedData, m_justifySelf, p); }	1470	void setJustifySelf(ItemPosition p) { SET_VAR(rareNonInheritedData, m_justifySelf, p); }
1467	void setJustifySelfOverflowAlignment(EJustifySelfOverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_justifySelfOverflowAlignment, overflowAlignment); }	1471	void setJustifySelfOverflowAlignment(OverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_justifySelfOverflowAlignment, overflowAlignment); }
1468	#if ENABLE(CSS_GRID_LAYOUT)	1472	#if ENABLE(CSS_GRID_LAYOUT)
1469	void setGridAutoColumns(const GridTrackSize& length) { SET_VAR(rareNonInheritedData.access()->m_grid, m_gridAutoColumns, length); }	1473	void setGridAutoColumns(const GridTrackSize& length) { SET_VAR(rareNonInheritedData.access()->m_grid, m_gridAutoColumns, length); }
1470	void setGridAutoRows(const GridTrackSize& length) { SET_VAR(rareNonInheritedData.access()->m_grid, m_gridAutoRows, length); }	1474	void setGridAutoRows(const GridTrackSize& length) { SET_VAR(rareNonInheritedData.access()->m_grid, m_gridAutoRows, length); }
Lines 1740-1745 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec3
1740	bool isDisplayReplacedType() const { return isDisplayReplacedType(display()); }	1744	bool isDisplayReplacedType() const { return isDisplayReplacedType(display()); }
1741	bool isDisplayInlineType() const { return isDisplayInlineType(display()); }	1745	bool isDisplayInlineType() const { return isDisplayInlineType(display()); }
1742	bool isOriginalDisplayInlineType() const { return isDisplayInlineType(originalDisplay()); }	1746	bool isOriginalDisplayInlineType() const { return isDisplayInlineType(originalDisplay()); }
		1747	bool isDisplayFlexibleOrGridBox() const { return isDisplayFlexibleOrGridBox(display()); }
1743	bool isDisplayRegionType() const	1748	bool isDisplayRegionType() const
1744	{	1749	{
1745	return display() == BLOCK \|\| display() == INLINE_BLOCK	1750	return display() == BLOCK \|\| display() == INLINE_BLOCK
Lines 1863-1875 public: a/Source/WebCore/rendering/style/RenderStyle.h_sec4
1863	static Length initialFlexBasis() { return Length(Auto); }	1868	static Length initialFlexBasis() { return Length(Auto); }
1864	static int initialOrder() { return 0; }	1869	static int initialOrder() { return 0; }
1865	static EAlignContent initialAlignContent() { return AlignContentStretch; }	1870	static EAlignContent initialAlignContent() { return AlignContentStretch; }
1866	static EAlignItems initialAlignItems() { return AlignStretch; }	1871	static ItemPosition initialAlignItems() { return ItemPositionAuto; }
1867	static EAlignItems initialAlignSelf() { return AlignAuto; }	1872	static OverflowAlignment initialAlignItemsOverflowAlignment() { return OverflowAlignmentDefault; }
		1873	static ItemPosition initialAlignSelf() { return ItemPositionAuto; }
		1874	static OverflowAlignment initialAlignSelfOverflowAlignment() { return OverflowAlignmentDefault; }
1868	static EFlexDirection initialFlexDirection() { return FlowRow; }	1875	static EFlexDirection initialFlexDirection() { return FlowRow; }
1869	static EFlexWrap initialFlexWrap() { return FlexNoWrap; }	1876	static EFlexWrap initialFlexWrap() { return FlexNoWrap; }
1870	static EJustifyContent initialJustifyContent() { return JustifyFlexStart; }	1877	static EJustifyContent initialJustifyContent() { return JustifyFlexStart; }
1871	static EJustifySelf initialJustifySelf() { return JustifySelfAuto; }	1878	static ItemPosition initialJustifySelf() { return ItemPositionAuto; }
1872	static EJustifySelfOverflowAlignment initialJustifySelfOverflowAlignment() { return JustifySelfOverflowAlignmentDefault; }	1879	static OverflowAlignment initialJustifySelfOverflowAlignment() { return OverflowAlignmentDefault; }
1873	static int initialMarqueeLoopCount() { return -1; }	1880	static int initialMarqueeLoopCount() { return -1; }
1874	static int initialMarqueeSpeed() { return 85; }	1881	static int initialMarqueeSpeed() { return 85; }
1875	static Length initialMarqueeIncrement() { return Length(6, Fixed); }	1882	static Length initialMarqueeIncrement() { return Length(6, Fixed); }
Lines 2052-2057 private: a/Source/WebCore/rendering/style/RenderStyle.h_sec5
2052	return display == INLINE \|\| isDisplayReplacedType(display);	2059	return display == INLINE \|\| isDisplayReplacedType(display);
2053	}	2060	}
2054		2061
		2062	bool isDisplayFlexibleBox(EDisplay display) const
		2063	{
		2064	return display == FLEX \|\| display == INLINE_FLEX;
		2065	}
		2066
		2067	bool isDisplayGridBox(EDisplay display) const
		2068	{
		2069	#if ENABLE(CSS_GRID_LAYOUT)
		2070	return display == GRID \|\| display == INLINE_GRID;
		2071	#else
		2072	UNUSED_PARAM(display);
		2073	return false;
		2074	#endif
		2075	}
		2076
		2077	bool isDisplayFlexibleOrGridBox(EDisplay display) const
		2078	{
		2079	return isDisplayFlexibleBox(display) \|\| isDisplayGridBox(display);
		2080	}
		2081
2055	// Color accessors are all private to make sure callers use visitedDependentColor instead to access them.	2082	// Color accessors are all private to make sure callers use visitedDependentColor instead to access them.
2056	Color invalidColor() const { static Color invalid; return invalid; }	2083	Color invalidColor() const { static Color invalid; return invalid; }
2057	Color borderLeftColor() const { return surround->border.left().color(); }	2084	Color borderLeftColor() const { return surround->border.left().color(); }



// CSS3 Flexbox Properties

enum EAlignContent { AlignContentFlexStart, AlignContentFlexEnd, AlignContentCenter, AlignContentSpaceBetween, AlignContentSpaceAround, AlignContentStretch };
enum EAlignItems { AlignAuto, AlignFlexStart, AlignFlexEnd, AlignCenter, AlignStretch, AlignBaseline };
enum EFlexDirection { FlowRow, FlowRowReverse, FlowColumn, FlowColumnReverse };
enum EFlexWrap { FlexNoWrap, FlexWrap, FlexWrapReverse };
enum EJustifyContent { JustifyFlexStart, JustifyFlexEnd, JustifyCenter, JustifySpaceBetween, JustifySpaceAround };
enum ItemPosition {ItemPositionAuto, ItemPositionStretch, ItemPositionBaseline, ItemPositionLastBaseline, ItemPositionCenter, ItemPositionStart, ItemPositionEnd, ItemPositionSelfStart, ItemPositionSelfEnd, ItemPositionFlexStart, ItemPositionFlexEnd, ItemPositionLeft, ItemPositionRight};
enum OverflowAlignment {OverflowAlignmentDefault, OverflowAlignmentTrue, OverflowAlignmentSafe};


enum ETextSecurity {



    , m_backfaceVisibility(RenderStyle::initialBackfaceVisibility())
    , m_alignContent(RenderStyle::initialAlignContent())
    , m_alignItems(RenderStyle::initialAlignItems())
    , m_alignItemsOverflowAlignment(RenderStyle::initialAlignItemsOverflowAlignment())
    , m_alignSelf(RenderStyle::initialAlignSelf())
    , m_alignSelfOverflowAlignment(RenderStyle::initialAlignSelfOverflowAlignment())
    , m_justifyContent(RenderStyle::initialJustifyContent())
    , m_justifySelf(RenderStyle::initialJustifySelf())
    , m_justifySelfOverflowAlignment(RenderStyle::initialJustifySelfOverflowAlignment())

    , m_backfaceVisibility(o.m_backfaceVisibility)
    , m_alignContent(o.m_alignContent)
    , m_alignItems(o.m_alignItems)
    , m_alignItemsOverflowAlignment(o.m_alignItemsOverflowAlignment)
    , m_alignSelf(o.m_alignSelf)
    , m_alignSelfOverflowAlignment(o.m_alignSelfOverflowAlignment)
    , m_justifyContent(o.m_justifyContent)
    , m_justifySelf(o.m_justifySelf)
    , m_justifySelfOverflowAlignment(o.m_justifySelfOverflowAlignment)

        && m_backfaceVisibility == o.m_backfaceVisibility
        && m_alignContent == o.m_alignContent
        && m_alignItems == o.m_alignItems
        && m_alignItemsOverflowAlignment == o.m_alignItemsOverflowAlignment
        && m_alignSelf == o.m_alignSelf
        && m_alignSelfOverflowAlignment == o.m_alignSelfOverflowAlignment
        && m_justifyContent == o.m_justifyContent
        && userDrag == o.userDrag
        && textOverflow == o.textOverflow

Lines 182-193 public: a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h_sec1
- a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h -4 / +6 lines
182	unsigned m_backfaceVisibility : 1; // EBackfaceVisibility	182	unsigned m_backfaceVisibility : 1; // EBackfaceVisibility
183		183
184	unsigned m_alignContent : 3; // EAlignContent	184	unsigned m_alignContent : 3; // EAlignContent
185	unsigned m_alignItems : 3; // EAlignItems	185	unsigned m_alignItems : 4; // ItemPosition
186	unsigned m_alignSelf : 3; // EAlignItems	186	unsigned m_alignItemsOverflowAlignment : 2; // OverflowAlignment
		187	unsigned m_alignSelf : 4; // ItemPosition
		188	unsigned m_alignSelfOverflowAlignment : 2; // OverflowAlignment
187	unsigned m_justifyContent : 3; // EJustifyContent	189	unsigned m_justifyContent : 3; // EJustifyContent
188		190
189	unsigned m_justifySelf : 4; // EJustifySelf	191	unsigned m_justifySelf : 4; // ItemPosition
190	unsigned m_justifySelfOverflowAlignment : 2; // EJustifySelfOverflowAlignment	192	unsigned m_justifySelfOverflowAlignment : 2; // OverflowAlignment
191		193
192	unsigned userDrag : 2; // EUserDrag	194	unsigned userDrag : 2; // EUserDrag
193	unsigned textOverflow : 1; // Whether or not lines that spill out should be truncated with "..."	195	unsigned textOverflow : 1; // Whether or not lines that spill out should be truncated with "..."

Lines 123-128 Change determineChange(const RenderStyle* s1, const RenderStyle* s2) a/Source/WebCore/style/StyleResolveTree.cpp_sec1
- a/Source/WebCore/style/StyleResolveTree.cpp +2 lines
123	// a separate render region object.	123	// a separate render region object.
124	if (s1->hasFlowFrom() && (s1->specifiesColumns() != s2->specifiesColumns()))	124	if (s1->hasFlowFrom() && (s1->specifiesColumns() != s2->specifiesColumns()))
125	return Detach;	125	return Detach;
		126	if (s1->alignItems() != s2->alignItems())
		127	return Detach;
126		128
127	if (s1 != s2) {	129	if (s1 != s2) {
128	if (s1->inheritedNotEqual(s2))	130	if (s1->inheritedNotEqual(s2))



2014-10-27  Javier Fernandez  <jfernandez@igalia.com>

        [CSS Grid Layout] Upgrade align-self and align-items parsing to CSS 3
        https://bugs.webkit.org/show_bug.cgi?id=133359

        Reviewed by David Hyatt.

        From Blink r164817 and r165264 by <jchaffraix@chromium.org>

        Broaden justify-self's parsing name and upgrade align-self and
        align-items parsing to CSS 3.

        * css3/flexbox/css-properties-expected.txt:
        * css3/flexbox/css-properties.html:
        * css3/parse-align-items-expected.txt: Added.
        * css3/parse-align-items.html: Added.
        * css3/parse-align-self-expected.txt: Added.
        * css3/parse-align-self.html: Added.
        * css3/resources/alignment-parsing-utils.js: Added.
        (checkValues):
        (checkBadValues):
        (checkInitialValues):
        (checkInheritValues):
        (checkLegacyValues):
        * fast/css/getComputedStyle/computed-style-expected.txt:
        * fast/css/getComputedStyle/computed-style-without-renderer-expected.txt:
        * fast/css/getComputedStyle/resources/property-names.js:
        * svg/css/getComputedStyle-basic-expected.txt:
        * platform/gtk/TestExpectations: Report new failures and update expectations.

2014-10-26  Benjamin Poulain  <benjamin@webkit.org>

        Images with usemap should not have a link state

Lines 67-72 webkit.org/b/127860 [ Debug ] js/function-apply-aliased.html [ Skip ] a/LayoutTests/TestExpectations_sec1
- a/LayoutTests/TestExpectations +3 lines
67	# This test verifies dynamic manipulation of the mroot and msqrt elements.	67	# This test verifies dynamic manipulation of the mroot and msqrt elements.
68	mathml/roots-removeChild.html [ ImageOnlyFailure ]	68	mathml/roots-removeChild.html [ ImageOnlyFailure ]
69		69
		70	webkit.org/b/133359 mathml/presentation/style-changed.html [ ImageOnlyFailure ]
		71	webkit.org/b/136291 platform/mac/accessibility/webkit-alt-for-css-content.html [ Failure ]
		72
70	# This test verifies that a mismatch reftest will fail as intended if both results are same. (introduced in r93187)	73	# This test verifies that a mismatch reftest will fail as intended if both results are same. (introduced in r93187)
71	fast/harness/sample-fail-mismatch-reftest.html [ WontFix ImageOnlyFailure ]	74	fast/harness/sample-fail-mismatch-reftest.html [ WontFix ImageOnlyFailure ]
72		75



PASS flexbox.style.webkitJustifyContent is ""
PASS window.getComputedStyle(flexbox, null).webkitJustifyContent is "flex-start"
PASS flexbox.style.webkitAlignSelf is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
PASS window.getComputedStyle(document.documentElement, null).webkitAlignSelf is "auto"
PASS flexbox.style.webkitAlignSelf is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
PASS flexbox.style.webkitAlignSelf is "auto"
PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
PASS flexbox.style.webkitAlignSelf is "flex-start"
PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "flex-start"
PASS flexbox.style.webkitAlignSelf is "flex-end"

PASS flexbox.style.webkitAlignSelf is "baseline"
PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "baseline"
PASS flexbox.style.webkitAlignSelf is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
PASS flexbox.style.webkitAlignItems is ""
PASS flexitem.style.webkitAlignSelf is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
PASS flexbox.style.webkitAlignItems is ""
PASS flexitem.style.webkitAlignSelf is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
PASS flexbox.style.webkitAlignItems is "auto"
PASS flexitem.style.webkitAlignSelf is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
PASS flexbox.style.webkitAlignItems is "flex-start"
PASS flexitem.style.webkitAlignSelf is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "flex-start"
PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "flex-start"
PASS flexbox.style.webkitAlignItems is "flex-end"

PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
PASS flexbox.style.webkitAlignItems is ""
PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "start"
PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "start"
PASS window.getComputedStyle(detachedFlexbox, null).webkitAlignSelf is ""
PASS window.getComputedStyle(detachedFlexItem, null).webkitAlignSelf is ""
PASS flexbox.style.webkitFlexDirection is ""



shouldBeEqualToString('flexbox.style.webkitJustifyContent', '');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitJustifyContent', 'flex-start');

flexbox.style.display = '-webkit-flex';

shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
// The initial value is 'auto', which will be resolved depending on parent's style (except for the 'document' element).
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');
shouldBeEqualToString('window.getComputedStyle(document.documentElement, null).webkitAlignSelf', 'auto');

flexbox.style.webkitAlignSelf = 'foo';
shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');

flexbox.style.webkitAlignSelf = 'auto';
shouldBeEqualToString('flexbox.style.webkitAlignSelf', 'auto');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');

flexbox.style.webkitAlignSelf = 'flex-start';
shouldBeEqualToString('flexbox.style.webkitAlignSelf', 'flex-start');


flexbox.style.webkitAlignSelf = '';
shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');

shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
// The initial value is 'auto', which will be resolved to 'stretch' in case of flexbox containers.
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');
shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');

flexbox.style.webkitAlignItems = 'foo';
shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');
shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');

flexbox.style.webkitAlignItems = 'auto';
shouldBeEqualToString('flexbox.style.webkitAlignItems', 'auto');
shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');
shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');

flexbox.style.webkitAlignItems = 'flex-start';
shouldBeEqualToString('flexbox.style.webkitAlignItems', 'flex-start');
shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'flex-start');
shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'flex-start');



flexbox.style.display = 'none';
shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'start');
shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'start');
flexbox.style.display = '';





Test that setting and getting align-items works as expected

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


Test getting align-items set through CSS
PASS getComputedStyle(alignItemsBaseline, '').getPropertyValue('-webkit-align-items') is 'baseline'
PASS getComputedStyle(alignItemsLastBaseline, '').getPropertyValue('-webkit-align-items') is 'last-baseline'
PASS getComputedStyle(alignItemsStretch, '').getPropertyValue('-webkit-align-items') is 'stretch'
PASS getComputedStyle(alignItemsStart, '').getPropertyValue('-webkit-align-items') is 'start'
PASS getComputedStyle(alignItemsEnd, '').getPropertyValue('-webkit-align-items') is 'end'
PASS getComputedStyle(alignItemsCenter, '').getPropertyValue('-webkit-align-items') is 'center'
PASS getComputedStyle(alignItemsSelfEnd, '').getPropertyValue('-webkit-align-items') is 'self-end'
PASS getComputedStyle(alignItemsSelfStart, '').getPropertyValue('-webkit-align-items') is 'self-start'
PASS getComputedStyle(alignItemsLeft, '').getPropertyValue('-webkit-align-items') is 'left'
PASS getComputedStyle(alignItemsRight, '').getPropertyValue('-webkit-align-items') is 'right'
PASS getComputedStyle(alignItemsFlexStart, '').getPropertyValue('-webkit-align-items') is 'flex-start'
PASS getComputedStyle(alignItemsFlexEnd, '').getPropertyValue('-webkit-align-items') is 'flex-end'
PASS getComputedStyle(alignItemsEndTrue, '').getPropertyValue('-webkit-align-items') is 'end true'
PASS getComputedStyle(alignItemsCenterTrue, '').getPropertyValue('-webkit-align-items') is 'center true'
PASS getComputedStyle(alignItemsSelfEndSafe, '').getPropertyValue('-webkit-align-items') is 'self-end safe'
PASS getComputedStyle(alignItemsSelfStartSafe, '').getPropertyValue('-webkit-align-items') is 'self-start safe'
PASS getComputedStyle(alignItemsRightSafe, '').getPropertyValue('-webkit-align-items') is 'right safe'
PASS getComputedStyle(alignItemsLeftTrue, '').getPropertyValue('-webkit-align-items') is 'left true'
PASS getComputedStyle(alignItemsFlexStartTrue, '').getPropertyValue('-webkit-align-items') is 'flex-start true'
PASS getComputedStyle(alignItemsFlexEndSafe, '').getPropertyValue('-webkit-align-items') is 'flex-end safe'

Test initial value of align-items through JS
PASS getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is 'start'

Test getting and setting align-items through JS
PASS element.style.webkitAlignItems is "center"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center"
PASS element.style.webkitAlignItems is "start true"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start true"
PASS element.style.webkitAlignItems is "flex-end safe"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "flex-end safe"
PASS element.style.webkitAlignItems is "right"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "right"
PASS element.style.webkitAlignItems is "center"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center"
PASS element.style.webkitAlignItems is "self-start"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "self-start"
PASS element.style.webkitAlignItems is "auto"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is "auto"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
PASS element.style.webkitAlignItems is "auto"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
PASS element.style.webkitAlignItems is "self-end"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "self-end"

Test bad combinations of align-items
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
PASS element.style.webkitAlignItems is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"

Test the value 'initial'
PASS element.style.webkitAlignItems is "center"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center"
PASS element.style.webkitAlignItems is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"

Test the value 'initial' for grid containers
PASS element.style.webkitAlignItems is "left safe"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
PASS element.style.webkitAlignItems is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"

Test the value 'initial' for flex containers
PASS element.style.webkitAlignItems is "right true"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "right true"
PASS element.style.webkitAlignItems is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"

Test the value 'inherit'
PASS element.style.webkitAlignItems is "end"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "end"
PASS element.style.webkitAlignItems is "inherit"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "end"
PASS element.style.webkitAlignItems is "left safe"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
PASS element.style.webkitAlignItems is "inherit"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
PASS element.style.webkitAlignItems is "center true"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center true"
PASS element.style.webkitAlignItems is "inherit"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center true"
PASS successfullyParsed is true

TEST COMPLETE




<!DOCTYPE html>
<html>
<head>
<style>
#alignItemsBaseline {
    -webkit-align-items: baseline;
}

#alignItemsLastBaseline {
    -webkit-align-items: last-baseline;
}

#alignItemsStretch {
    -webkit-align-items: stretch;
}

#alignItemsStart {
    -webkit-align-items: start;
}

#alignItemsEnd {
    -webkit-align-items: end;
}

#alignItemsCenter {
    -webkit-align-items: center;
}

#alignItemsSelfStart {
    -webkit-align-items: self-start;
}

#alignItemsSelfEnd {
    -webkit-align-items: self-end;
}

#alignItemsLeft {
    -webkit-align-items: left;
}

#alignItemsRight {
    -webkit-align-items: right;
}

#alignItemsFlexStart {
    -webkit-align-items: flex-start;
}

#alignItemsFlexEnd {
    -webkit-align-items: flex-end;
}

#alignItemsEndTrue {
    -webkit-align-items: end true;
}

#alignItemsCenterTrue {
    -webkit-align-items: center true;
}

#alignItemsSelfEndSafe {
    -webkit-align-items: self-end safe;
}

#alignItemsSelfStartSafe {
    -webkit-align-items: self-start safe;
}

#alignItemsRightSafe {
    -webkit-align-items: right safe;
}

#alignItemsLeftTrue {
    -webkit-align-items: left true;
}

#alignItemsFlexStartTrue {
    -webkit-align-items: flex-start true;
}

#alignItemsFlexEndSafe {
    -webkit-align-items: flex-end safe;
}

</style>
<script src="../resources/js-test.js"></script>
</head>
<body>
<div id="alignItemsBaseline"></div>
<div id="alignItemsLastBaseline"></div>
<div id="alignItemsStretch"></div>
<div id="alignItemsStart"></div>
<div id="alignItemsEnd"></div>
<div id="alignItemsCenter"></div>
<div id="alignItemsSelfStart"></div>
<div id="alignItemsSelfEnd"></div>
<div id="alignItemsLeft"></div>
<div id="alignItemsRight"></div>
<div id="alignItemsFlexStart"></div>
<div id="alignItemsFlexEnd"></div>

<div id="alignItemsEndTrue"></div>
<div id="alignItemsCenterTrue"></div>
<div id="alignItemsSelfEndSafe"></div>
<div id="alignItemsSelfStartSafe"></div>
<div id="alignItemsRightSafe"></div>
<div id="alignItemsLeftTrue"></div>
<div id="alignItemsFlexStartTrue"></div>
<div id="alignItemsFlexEndSafe"></div>
<script src="resources/alignment-parsing-utils.js"></script>
<script>
description('Test that setting and getting align-items works as expected');

debug("Test getting align-items set through CSS");
var alignItemsBaseline = document.getElementById("alignItemsBaseline");
shouldBe("getComputedStyle(alignItemsBaseline, '').getPropertyValue('-webkit-align-items')", "'baseline'");

var alignItemsLastBaseline = document.getElementById("alignItemsLastBaseline");
shouldBe("getComputedStyle(alignItemsLastBaseline, '').getPropertyValue('-webkit-align-items')", "'last-baseline'");

var alignItemsStretch = document.getElementById("alignItemsStretch");
shouldBe("getComputedStyle(alignItemsStretch, '').getPropertyValue('-webkit-align-items')", "'stretch'");

var alignItemsStart = document.getElementById("alignItemsStart");
shouldBe("getComputedStyle(alignItemsStart, '').getPropertyValue('-webkit-align-items')", "'start'");

var alignItemsEnd = document.getElementById("alignItemsEnd");
shouldBe("getComputedStyle(alignItemsEnd, '').getPropertyValue('-webkit-align-items')", "'end'");

var alignItemsCenter = document.getElementById("alignItemsCenter");
shouldBe("getComputedStyle(alignItemsCenter, '').getPropertyValue('-webkit-align-items')", "'center'");

var alignItemsSelfEnd = document.getElementById("alignItemsSelfEnd");
shouldBe("getComputedStyle(alignItemsSelfEnd, '').getPropertyValue('-webkit-align-items')", "'self-end'");

var alignItemsSelfStart = document.getElementById("alignItemsSelfStart");
shouldBe("getComputedStyle(alignItemsSelfStart, '').getPropertyValue('-webkit-align-items')", "'self-start'");

var alignItemsLeft = document.getElementById("alignItemsLeft");
shouldBe("getComputedStyle(alignItemsLeft, '').getPropertyValue('-webkit-align-items')", "'left'");

var alignItemsRight = document.getElementById("alignItemsRight");
shouldBe("getComputedStyle(alignItemsRight, '').getPropertyValue('-webkit-align-items')", "'right'");

var alignItemsFlexStart = document.getElementById("alignItemsFlexStart");
shouldBe("getComputedStyle(alignItemsFlexStart, '').getPropertyValue('-webkit-align-items')", "'flex-start'");

var alignItemsFlexEnd = document.getElementById("alignItemsFlexEnd");
shouldBe("getComputedStyle(alignItemsFlexEnd, '').getPropertyValue('-webkit-align-items')", "'flex-end'");

var alignItemsEndTrue = document.getElementById("alignItemsEndTrue");
shouldBe("getComputedStyle(alignItemsEndTrue, '').getPropertyValue('-webkit-align-items')", "'end true'");

var alignItemsCenterTrue = document.getElementById("alignItemsCenterTrue");
shouldBe("getComputedStyle(alignItemsCenterTrue, '').getPropertyValue('-webkit-align-items')", "'center true'");

var alignItemsSelfEndSafe = document.getElementById("alignItemsSelfEndSafe");
shouldBe("getComputedStyle(alignItemsSelfEndSafe, '').getPropertyValue('-webkit-align-items')", "'self-end safe'");

var alignItemsSelfStartSafe = document.getElementById("alignItemsSelfStartSafe");
shouldBe("getComputedStyle(alignItemsSelfStartSafe, '').getPropertyValue('-webkit-align-items')", "'self-start safe'");

var alignItemsRightSafe = document.getElementById("alignItemsRightSafe");
shouldBe("getComputedStyle(alignItemsRightSafe, '').getPropertyValue('-webkit-align-items')", "'right safe'");

var alignItemsLeftTrue = document.getElementById("alignItemsLeftTrue");
shouldBe("getComputedStyle(alignItemsLeftTrue, '').getPropertyValue('-webkit-align-items')", "'left true'");

var alignItemsFlexStartTrue = document.getElementById("alignItemsFlexStartTrue");
shouldBe("getComputedStyle(alignItemsFlexStartTrue, '').getPropertyValue('-webkit-align-items')", "'flex-start true'");

var alignItemsFlexEndSafe = document.getElementById("alignItemsFlexEndSafe");
shouldBe("getComputedStyle(alignItemsFlexEndSafe, '').getPropertyValue('-webkit-align-items')", "'flex-end safe'");

debug("");
debug("Test initial value of align-items through JS");
element = document.createElement("div");
document.body.appendChild(element);
shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-align-items')", "'start'");

debug("");
debug("Test getting and setting align-items through JS");
element = document.createElement("div");
document.body.appendChild(element);
element.style.webkitAlignItems = "center";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "center", "center");

element.style.webkitAlignItems = "true start";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "start true", "start true");

element.style.webkitAlignItems = "flex-end safe";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "flex-end safe", "flex-end safe");

element.style.webkitAlignItems = "right";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "right", "right");

element.style.webkitAlignItems = "center";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "center", "center");

element.style.webkitAlignItems = "self-start";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "self-start", "self-start");

element.style.webkitAlignItems = "auto";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "auto", "start");

element.style.display = "-webkit-flex";
element.style.webkitAlignItems = "auto";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "auto", "stretch");

element.style.display = "-webkit-grid";
element.style.webkitAlignItems = "auto";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "auto", "stretch");

element.style.webkitAlignItems = "self-end";
checkValues(element, "webkitAlignItems", "-webkit-align-items",  "self-end", "self-end");

debug("");
debug("Test bad combinations of align-items");
element = document.createElement("div");
document.body.appendChild(element);

checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true auto");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "auto safe");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "auto left");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "baseline safe");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "baseline center");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch true");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch right");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true true");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true safe");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "center start");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "stretch true");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "safe stretch");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "baseline safe");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true baseline");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true safe left");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "true left safe");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "left safe true safe");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy start");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy end");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy right true");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy auto");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy stretch");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy");
checkBadValues(element, "webkitAlignItems", "-webkit-align-items",  "legacy left right");

debug("");
debug("Test the value 'initial'");
element.style.display = "";
checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "center", "start");

debug("");
debug("Test the value 'initial' for grid containers");
element.style.display = "-webkit-grid";
checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "left safe", "stretch");

debug("");
debug("Test the value 'initial' for flex containers");
element.style.display = "-webkit-flex";
checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "right true", "stretch");

debug("");
debug("Test the value 'inherit'");
checkInheritValues("webkitAlignItems", "-webkit-align-items", "end");
checkInheritValues("webkitAlignItems", "-webkit-align-items", "left safe");
checkInheritValues("webkitAlignItems", "-webkit-align-items", "center true");

</script>
</body>
</html>



Test that setting and getting align-self works as expected

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


Test getting align-self set through CSS
PASS getComputedStyle(alignSelfBaseline, '').getPropertyValue('-webkit-align-self') is 'baseline'
PASS getComputedStyle(alignSelfLastBaseline, '').getPropertyValue('-webkit-align-self') is 'last-baseline'
PASS getComputedStyle(alignSelfStretch, '').getPropertyValue('-webkit-align-self') is 'stretch'
PASS getComputedStyle(alignSelfStart, '').getPropertyValue('-webkit-align-self') is 'start'
PASS getComputedStyle(alignSelfEnd, '').getPropertyValue('-webkit-align-self') is 'end'
PASS getComputedStyle(alignSelfCenter, '').getPropertyValue('-webkit-align-self') is 'center'
PASS getComputedStyle(alignSelfSelfEnd, '').getPropertyValue('-webkit-align-self') is 'self-end'
PASS getComputedStyle(alignSelfSelfStart, '').getPropertyValue('-webkit-align-self') is 'self-start'
PASS getComputedStyle(alignSelfLeft, '').getPropertyValue('-webkit-align-self') is 'left'
PASS getComputedStyle(alignSelfRight, '').getPropertyValue('-webkit-align-self') is 'right'
PASS getComputedStyle(alignSelfFlexStart, '').getPropertyValue('-webkit-align-self') is 'flex-start'
PASS getComputedStyle(alignSelfFlexEnd, '').getPropertyValue('-webkit-align-self') is 'flex-end'
PASS getComputedStyle(alignSelfEndTrue, '').getPropertyValue('-webkit-align-self') is 'end true'
PASS getComputedStyle(alignSelfCenterTrue, '').getPropertyValue('-webkit-align-self') is 'center true'
PASS getComputedStyle(alignSelfSelfEndSafe, '').getPropertyValue('-webkit-align-self') is 'self-end safe'
PASS getComputedStyle(alignSelfSelfStartSafe, '').getPropertyValue('-webkit-align-self') is 'self-start safe'
PASS getComputedStyle(alignSelfRightSafe, '').getPropertyValue('-webkit-align-self') is 'right safe'
PASS getComputedStyle(alignSelfLeftTrue, '').getPropertyValue('-webkit-align-self') is 'left true'
PASS getComputedStyle(alignSelfFlexStartTrue, '').getPropertyValue('-webkit-align-self') is 'flex-start true'
PASS getComputedStyle(alignSelfFlexEndSafe, '').getPropertyValue('-webkit-align-self') is 'flex-end safe'

Test initial value of align-self through JS
PASS getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is 'start'

Test getting and setting align-self through JS
PASS element.style.webkitAlignSelf is "center"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center"
PASS element.style.webkitAlignSelf is "start true"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start true"
PASS element.style.webkitAlignSelf is "flex-end safe"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "flex-end safe"
PASS element.style.webkitAlignSelf is "right"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right"
PASS element.style.webkitAlignSelf is "center"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center"
PASS element.style.webkitAlignSelf is "self-start"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "self-start"
PASS element.style.webkitAlignSelf is "auto"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is "auto"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
PASS element.style.webkitAlignSelf is "auto"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
PASS element.style.webkitAlignSelf is "self-end"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "self-end"

Test bad combinations of align-self
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
PASS element.style.webkitAlignSelf is ""
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"

Test the value 'initial'
PASS element.style.webkitAlignSelf is "center"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center"
PASS element.style.webkitAlignSelf is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"

Test the value 'initial' for grid containers
PASS element.style.webkitAlignSelf is "left safe"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
PASS element.style.webkitAlignSelf is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"

Test the value 'initial' for flex containers
PASS element.style.webkitAlignSelf is "right true"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right true"
PASS element.style.webkitAlignSelf is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"

Test the value 'initial' for positioned elements
PASS element.style.webkitAlignSelf is "left"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left"
PASS element.style.webkitAlignSelf is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"

Test the value 'initial' for positioned elements in grid containers
PASS element.style.webkitAlignSelf is "right"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right"
PASS element.style.webkitAlignSelf is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"

Test the value 'initial' for positioned elements in grid containers
PASS element.style.webkitAlignSelf is "end"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "end"
PASS element.style.webkitAlignSelf is "initial"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"

Test the value 'inherit'
PASS element.style.webkitAlignSelf is "end"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "end"
PASS element.style.webkitAlignSelf is "inherit"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "end"
PASS element.style.webkitAlignSelf is "left safe"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
PASS element.style.webkitAlignSelf is "inherit"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
PASS element.style.webkitAlignSelf is "center true"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center true"
PASS element.style.webkitAlignSelf is "inherit"
PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center true"
PASS successfullyParsed is true

TEST COMPLETE




<!DOCTYPE html>
<html>
<head>
<style>
#alignSelfBaseline {
    -webkit-align-self: baseline;
}

#alignSelfLastBaseline {
    -webkit-align-self: last-baseline;
}

#alignSelfStretch {
    -webkit-align-self: stretch;
}

#alignSelfStart {
    -webkit-align-self: start;
}

#alignSelfEnd {
    -webkit-align-self: end;
}

#alignSelfCenter {
    -webkit-align-self: center;
}

#alignSelfSelfStart {
    -webkit-align-self: self-start;
}

#alignSelfSelfEnd {
    -webkit-align-self: self-end;
}

#alignSelfLeft {
    -webkit-align-self: left;
}

#alignSelfRight {
    -webkit-align-self: right;
}

#alignSelfFlexStart {
    -webkit-align-self: flex-start;
}

#alignSelfFlexEnd {
    -webkit-align-self: flex-end;
}

#alignSelfEndTrue {
    -webkit-align-self: end true;
}

#alignSelfCenterTrue {
    -webkit-align-self: center true;
}

#alignSelfSelfEndSafe {
    -webkit-align-self: self-end safe;
}

#alignSelfSelfStartSafe {
    -webkit-align-self: self-start safe;
}

#alignSelfRightSafe {
    -webkit-align-self: right safe;
}

#alignSelfLeftTrue {
    -webkit-align-self: left true;
}

#alignSelfFlexStartTrue {
    -webkit-align-self: flex-start true;
}

#alignSelfFlexEndSafe {
    -webkit-align-self: flex-end safe;
}
</style>
<script src="../resources/js-test.js"></script>
</head>
<body>
<div id="alignSelfBaseline"></div>
<div id="alignSelfLastBaseline"></div>
<div id="alignSelfStretch"></div>
<div id="alignSelfStart"></div>
<div id="alignSelfEnd"></div>
<div id="alignSelfCenter"></div>
<div id="alignSelfSelfStart"></div>
<div id="alignSelfSelfEnd"></div>
<div id="alignSelfLeft"></div>
<div id="alignSelfRight"></div>
<div id="alignSelfFlexStart"></div>
<div id="alignSelfFlexEnd"></div>

<div id="alignSelfEndTrue"></div>
<div id="alignSelfCenterTrue"></div>
<div id="alignSelfSelfEndSafe"></div>
<div id="alignSelfSelfStartSafe"></div>
<div id="alignSelfRightSafe"></div>
<div id="alignSelfLeftTrue"></div>
<div id="alignSelfFlexStartTrue"></div>
<div id="alignSelfFlexEndSafe"></div>
<script src="resources/alignment-parsing-utils.js"></script>
<script>
description('Test that setting and getting align-self works as expected');

debug("Test getting align-self set through CSS");
var alignSelfBaseline = document.getElementById("alignSelfBaseline");
shouldBe("getComputedStyle(alignSelfBaseline, '').getPropertyValue('-webkit-align-self')", "'baseline'");

var alignSelfLastBaseline = document.getElementById("alignSelfLastBaseline");
shouldBe("getComputedStyle(alignSelfLastBaseline, '').getPropertyValue('-webkit-align-self')", "'last-baseline'");

var alignSelfStretch = document.getElementById("alignSelfStretch");
shouldBe("getComputedStyle(alignSelfStretch, '').getPropertyValue('-webkit-align-self')", "'stretch'");

var alignSelfStart = document.getElementById("alignSelfStart");
shouldBe("getComputedStyle(alignSelfStart, '').getPropertyValue('-webkit-align-self')", "'start'");

var alignSelfEnd = document.getElementById("alignSelfEnd");
shouldBe("getComputedStyle(alignSelfEnd, '').getPropertyValue('-webkit-align-self')", "'end'");

var alignSelfCenter = document.getElementById("alignSelfCenter");
shouldBe("getComputedStyle(alignSelfCenter, '').getPropertyValue('-webkit-align-self')", "'center'");

var alignSelfSelfEnd = document.getElementById("alignSelfSelfEnd");
shouldBe("getComputedStyle(alignSelfSelfEnd, '').getPropertyValue('-webkit-align-self')", "'self-end'");

var alignSelfSelfStart = document.getElementById("alignSelfSelfStart");
shouldBe("getComputedStyle(alignSelfSelfStart, '').getPropertyValue('-webkit-align-self')", "'self-start'");

var alignSelfLeft = document.getElementById("alignSelfLeft");
shouldBe("getComputedStyle(alignSelfLeft, '').getPropertyValue('-webkit-align-self')", "'left'");

var alignSelfRight = document.getElementById("alignSelfRight");
shouldBe("getComputedStyle(alignSelfRight, '').getPropertyValue('-webkit-align-self')", "'right'");

var alignSelfFlexStart = document.getElementById("alignSelfFlexStart");
shouldBe("getComputedStyle(alignSelfFlexStart, '').getPropertyValue('-webkit-align-self')", "'flex-start'");

var alignSelfFlexEnd = document.getElementById("alignSelfFlexEnd");
shouldBe("getComputedStyle(alignSelfFlexEnd, '').getPropertyValue('-webkit-align-self')", "'flex-end'");

var alignSelfEndTrue = document.getElementById("alignSelfEndTrue");
shouldBe("getComputedStyle(alignSelfEndTrue, '').getPropertyValue('-webkit-align-self')", "'end true'");

var alignSelfCenterTrue = document.getElementById("alignSelfCenterTrue");
shouldBe("getComputedStyle(alignSelfCenterTrue, '').getPropertyValue('-webkit-align-self')", "'center true'");

var alignSelfSelfEndSafe = document.getElementById("alignSelfSelfEndSafe");
shouldBe("getComputedStyle(alignSelfSelfEndSafe, '').getPropertyValue('-webkit-align-self')", "'self-end safe'");

var alignSelfSelfStartSafe = document.getElementById("alignSelfSelfStartSafe");
shouldBe("getComputedStyle(alignSelfSelfStartSafe, '').getPropertyValue('-webkit-align-self')", "'self-start safe'");

var alignSelfRightSafe = document.getElementById("alignSelfRightSafe");
shouldBe("getComputedStyle(alignSelfRightSafe, '').getPropertyValue('-webkit-align-self')", "'right safe'");

var alignSelfLeftTrue = document.getElementById("alignSelfLeftTrue");
shouldBe("getComputedStyle(alignSelfLeftTrue, '').getPropertyValue('-webkit-align-self')", "'left true'");

var alignSelfFlexStartTrue = document.getElementById("alignSelfFlexStartTrue");
shouldBe("getComputedStyle(alignSelfFlexStartTrue, '').getPropertyValue('-webkit-align-self')", "'flex-start true'");

var alignSelfFlexEndSafe = document.getElementById("alignSelfFlexEndSafe");
shouldBe("getComputedStyle(alignSelfFlexEndSafe, '').getPropertyValue('-webkit-align-self')", "'flex-end safe'");

debug("");
debug("Test initial value of align-self through JS");
element = document.createElement("div");
document.body.appendChild(element);
shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-align-self')", "'start'");

debug("");
debug("Test getting and setting align-self through JS");
container = document.createElement("div");
element = document.createElement("div");
container.appendChild(element);
document.body.appendChild(container);
element.style.webkitAlignSelf = "center";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "center", "center");

element.style.webkitAlignSelf = "true start";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "start true", "start true");

element.style.webkitAlignSelf = "flex-end safe";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "flex-end safe", "flex-end safe");

element.style.webkitAlignSelf = "right";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "right", "right");

element.style.webkitAlignSelf = "center";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "center", "center");

element.style.webkitAlignSelf = "self-start";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "self-start", "self-start");

element.style.webkitAlignSelf = "auto";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "auto", "start");

container.style.display = "-webkit-flex";
element.style.webkitAlignSelf = "auto";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "auto", "stretch");

container.style.display = "-webkit-grid";
element.style.webkitAlignSelf = "auto";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "auto", "stretch");

element.style.webkitAlignSelf = "self-end";
checkValues(element, "webkitAlignSelf", "-webkit-align-self",  "self-end", "self-end");

debug("");
debug("Test bad combinations of align-self");
container = document.createElement("div");
element = document.createElement("div");
container.appendChild(element);
document.body.appendChild(container);

checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true auto");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "auto safe");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "auto left");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "baseline safe");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "baseline center");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch true");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch right");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true true");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true safe");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "center start");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "stretch true");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "safe stretch");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "baseline safe");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true baseline");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true safe left");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "true left safe");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "left safe true safe");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy start");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy end");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy right true");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy auto");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy stretch");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy");
checkBadValues(element, "webkitAlignSelf", "-webkit-align-self",  "legacy left right");

debug("");
debug("Test the value 'initial'");
container.style.display = "";
checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "center", "start");

debug("");
debug("Test the value 'initial' for grid containers");
container.style.display = "-webkit-grid";
checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "left safe", "stretch");

debug("");
debug("Test the value 'initial' for flex containers");
container.style.display = "-webkit-flex";
checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "right true", "stretch");

debug("");
debug("Test the value 'initial' for positioned elements");
container.style.display = "";
element.style.position = "absolute";
checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "left", "stretch");

debug("");
debug("Test the value 'initial' for positioned elements in grid containers");
container.style.display = "-webkit-grid";
element.style.position = "absolute";
checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "right", "stretch");

debug("");
debug("Test the value 'initial' for positioned elements in grid containers");
container.style.display = "-webkit-flex";
element.style.position = "absolute";
checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "end", "stretch");

debug("");
debug("Test the value 'inherit'");
checkInheritValues("webkitAlignSelf", "-webkit-align-self", "end");
checkInheritValues("webkitAlignSelf", "-webkit-align-self", "left safe");
checkInheritValues("webkitAlignSelf", "-webkit-align-self", "center true");

</script>
</body>
</html>



function checkValues(element, property, propertyID, value, computedValue)
{
    window.element = element;
    var elementID = element.id || "element";
    shouldBeEqualToString("element.style." + property, value);
    shouldBeEqualToString("window.getComputedStyle(" + elementID + ", '').getPropertyValue('" + propertyID + "')", computedValue);
}

function checkBadValues(element, property, propertyID, value)
{
    element.style[property] = value;
    checkValues(element, property, propertyID, "", "start");
}

function checkInitialValues(element, property, propertyID, value, initial)
{
    element.style[property] = value;
    checkValues(element, property, propertyID, value, value);
    element.style[property] = "initial";
    checkValues(element, property, propertyID, "initial", initial);
}

function checkInheritValues(property, propertyID, value)
{
    var parentElement = document.createElement("div");
    document.body.appendChild(parentElement);
    parentElement.style[property] = value;
    checkValues(parentElement, property, propertyID, value, value);

    var element = document.createElement("div");
    parentElement.appendChild(element);
    element.style[property] = "inherit";
    checkValues(element, property, propertyID, "inherit", value);
}

function checkLegacyValues(property, propertyID, value)
{
    var parentElement = document.createElement("div");
    document.body.appendChild(parentElement);
    parentElement.style[property] = value;
    checkValues(parentElement, property, propertyID, value, value);

    var element = document.createElement("div");
    parentElement.appendChild(element);
    checkValues(element, property, propertyID, "", value);
}



-webkit-column-span: none;
-webkit-column-width: auto;
align-content: stretch;
align-items: start;
align-self: start;
flex-direction: row;
flex-wrap: nowrap;
justify-content: flex-start;
justify-self: auto;
-webkit-font-kerning: auto;
-webkit-font-smoothing: auto;
-webkit-font-variant-ligatures: normal;



-webkit-column-span: none
-webkit-column-width: auto
align-content: stretch
align-items: start
align-self: start
flex-direction: row
flex-wrap: nowrap
justify-content: flex-start
justify-self: auto
-webkit-font-kerning: auto
-webkit-font-smoothing: auto
-webkit-font-variant-ligatures: normal

Lines 65-70 var propertiesToTest = { a/LayoutTests/fast/css/getComputedStyle/resources/property-names.js_sec1
- a/LayoutTests/fast/css/getComputedStyle/resources/property-names.js +1 lines
65	"-webkit-hyphenate-limit-lines": true,	65	"-webkit-hyphenate-limit-lines": true,
66	"-webkit-hyphens": true,	66	"-webkit-hyphens": true,
67	"justify-content": true,	67	"justify-content": true,
		68	"justify-self": true,
68	"-webkit-line-align": true,	69	"-webkit-line-align": true,
69	"-webkit-line-box-contain": true,	70	"-webkit-line-box-contain": true,
70	"-webkit-line-break": true,	71	"-webkit-line-break": true,



rect: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(align-content) : stretch
rect: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(align-items) : start
rect: style.getPropertyCSSValue(align-items) : [object CSSValueList]
rect: style.getPropertyValue(align-self) : start
rect: style.getPropertyCSSValue(align-self) : [object CSSValueList]
rect: style.getPropertyValue(flex-direction) : row
rect: style.getPropertyCSSValue(flex-direction) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(flex-wrap) : nowrap
rect: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(justify-content) : flex-start
rect: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(justify-self) : auto
rect: style.getPropertyCSSValue(justify-self) : [object CSSValueList]
rect: style.getPropertyValue(-webkit-font-kerning) : auto
rect: style.getPropertyCSSValue(-webkit-font-kerning) : [object CSSPrimitiveValue]
rect: style.getPropertyValue(-webkit-font-smoothing) : auto

g: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]
g: style.getPropertyValue(align-content) : stretch
g: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]
g: style.getPropertyValue(align-items) : start
g: style.getPropertyCSSValue(align-items) : [object CSSValueList]
g: style.getPropertyValue(align-self) : start
g: style.getPropertyCSSValue(align-self) : [object CSSValueList]
g: style.getPropertyValue(flex-direction) : row
g: style.getPropertyCSSValue(flex-direction) : [object CSSPrimitiveValue]
g: style.getPropertyValue(flex-wrap) : nowrap
g: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]
g: style.getPropertyValue(justify-content) : flex-start
g: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]
g: style.getPropertyValue(justify-self) : auto
g: style.getPropertyCSSValue(justify-self) : [object CSSValueList]
g: style.getPropertyValue(-webkit-font-kerning) : auto
g: style.getPropertyCSSValue(-webkit-font-kerning) : [object CSSPrimitiveValue]
g: style.getPropertyValue(-webkit-font-smoothing) : auto

Return to Bug 133359

Lines 1428-1484 template<> inline CSSPrimitiveValue::operator EEmptyCell() const a/Source/WebCore/css/CSSPrimitiveValueMappings.h_sec1
- a/Source/WebCore/css/CSSPrimitiveValueMappings.h -90 / +41 lines
1428	return SHOW;	1428	return SHOW;
1429	}	1429	}
1430		1430
1431	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignItems e)
1432	: CSSValue(PrimitiveClass)
1433	{
1434	m_primitiveUnitType = CSS_VALUE_ID;
1435	switch (e) {
1436	case AlignAuto:
1437	m_value.valueID = CSSValueAuto;
1438	break;
1439	case AlignFlexStart:
1440	m_value.valueID = CSSValueFlexStart;
1441	break;
1442	case AlignFlexEnd:
1443	m_value.valueID = CSSValueFlexEnd;
1444	break;
1445	case AlignCenter:
1446	m_value.valueID = CSSValueCenter;
1447	break;
1448	case AlignStretch:
1449	m_value.valueID = CSSValueStretch;
1450	break;
1451	case AlignBaseline:
1452	m_value.valueID = CSSValueBaseline;
1453	break;
1454	}
1455	}
1456
1457	template<> inline CSSPrimitiveValue::operator EAlignItems() const
1458	{
1459	ASSERT(isValueID());
1460
1461	switch (m_value.valueID) {
1462	case CSSValueAuto:
1463	return AlignAuto;
1464	case CSSValueFlexStart:
1465	return AlignFlexStart;
1466	case CSSValueFlexEnd:
1467	return AlignFlexEnd;
1468	case CSSValueCenter:
1469	return AlignCenter;
1470	case CSSValueStretch:
1471	return AlignStretch;
1472	case CSSValueBaseline:
1473	return AlignBaseline;
1474	default:
1475	break;
1476	}
1477
1478	ASSERT_NOT_REACHED();
1479	return AlignFlexStart;
1480	}
1481
1482	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e)	1431	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e)
1483	: CSSValue(PrimitiveClass)	1432	: CSSValue(PrimitiveClass)
1484	{	1433	{
Lines 5082-5197 template<> inline CSSPrimitiveValue::operator CSSBoxType() const a/Source/WebCore/css/CSSPrimitiveValueMappings.h_sec2
5082	return BoxMissing;	5031	return BoxMissing;
5083	}	5032	}
5084		5033
5085	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifySelf justifySelf)	5034	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
5086	: CSSValue(PrimitiveClass)	5035	: CSSValue(PrimitiveClass)
5087	{	5036	{
5088	m_primitiveUnitType = CSS_VALUE_ID;	5037	m_primitiveUnitType = CSS_VALUE_ID;
5089	switch (justifySelf) {	5038	switch (itemPosition) {
5090	case JustifySelfAuto:	5039	case ItemPositionAuto:
5091	m_value.valueID = CSSValueAuto;	5040	m_value.valueID = CSSValueAuto;
5092	break;	5041	break;
5093	case JustifySelfStretch:	5042	case ItemPositionStretch:
5094	m_value.valueID = CSSValueStretch;	5043	m_value.valueID = CSSValueStretch;
5095	break;	5044	break;
5096	case JustifySelfBaseline:	5045	case ItemPositionBaseline:
5097	m_value.valueID = CSSValueBaseline;	5046	m_value.valueID = CSSValueBaseline;
5098	break;	5047	break;
5099	case JustifySelfCenter:	5048	case ItemPositionLastBaseline:
		5049	m_value.valueID = CSSValueLastBaseline;
		5050	break;
		5051	case ItemPositionCenter:
5100	m_value.valueID = CSSValueCenter;	5052	m_value.valueID = CSSValueCenter;
5101	break;	5053	break;
5102	case JustifySelfStart:	5054	case ItemPositionStart:
5103	m_value.valueID = CSSValueStart;	5055	m_value.valueID = CSSValueStart;
5104	break;	5056	break;
5105	case JustifySelfEnd:	5057	case ItemPositionEnd:
5106	m_value.valueID = CSSValueEnd;	5058	m_value.valueID = CSSValueEnd;
5107	break;	5059	break;
5108	case JustifySelfSelfStart:	5060	case ItemPositionSelfStart:
5109	m_value.valueID = CSSValueSelfStart;	5061	m_value.valueID = CSSValueSelfStart;
5110	break;	5062	break;
5111	case JustifySelfSelfEnd:	5063	case ItemPositionSelfEnd:
5112	m_value.valueID = CSSValueSelfEnd;	5064	m_value.valueID = CSSValueSelfEnd;
5113	break;	5065	break;
5114	case JustifySelfFlexStart:	5066	case ItemPositionFlexStart:
5115	m_value.valueID = CSSValueFlexStart;	5067	m_value.valueID = CSSValueFlexStart;
5116	break;	5068	break;
5117	case JustifySelfFlexEnd:	5069	case ItemPositionFlexEnd:
5118	m_value.valueID = CSSValueFlexEnd;	5070	m_value.valueID = CSSValueFlexEnd;
5119	break;	5071	break;
5120	case JustifySelfLeft:	5072	case ItemPositionLeft:
5121	m_value.valueID = CSSValueLeft;	5073	m_value.valueID = CSSValueLeft;
5122	break;	5074	break;
5123	case JustifySelfRight:	5075	case ItemPositionRight:
5124	m_value.valueID = CSSValueRight;	5076	m_value.valueID = CSSValueRight;
5125	break;	5077	break;
5126	default:
5127	m_value.valueID = CSSValueAuto;
5128	break;
5129	}	5078	}
5130	}	5079	}
5131		5080
5132	template<> inline CSSPrimitiveValue::operator EJustifySelf() const	5081	template<> inline CSSPrimitiveValue::operator ItemPosition() const
5133	{	5082	{
5134	switch (m_value.valueID) {	5083	switch (m_value.valueID) {
5135	case CSSValueAuto:	5084	case CSSValueAuto:
5136	return JustifySelfAuto;	5085	return ItemPositionAuto;
5137	case CSSValueStretch:	5086	case CSSValueStretch:
5138	return JustifySelfStretch;	5087	return ItemPositionStretch;
5139	case CSSValueBaseline:	5088	case CSSValueBaseline:
5140	return JustifySelfBaseline;	5089	return ItemPositionBaseline;
		5090	case CSSValueLastBaseline:
		5091	return ItemPositionLastBaseline;
5141	case CSSValueCenter:	5092	case CSSValueCenter:
5142	return JustifySelfCenter;	5093	return ItemPositionCenter;
5143	case CSSValueStart:	5094	case CSSValueStart:
5144	return JustifySelfStart;	5095	return ItemPositionStart;
5145	case CSSValueEnd:	5096	case CSSValueEnd:
5146	return JustifySelfEnd;	5097	return ItemPositionEnd;
5147	case CSSValueSelfStart:	5098	case CSSValueSelfStart:
5148	return JustifySelfSelfStart;	5099	return ItemPositionSelfStart;
5149	case CSSValueSelfEnd:	5100	case CSSValueSelfEnd:
5150	return JustifySelfSelfEnd;	5101	return ItemPositionSelfEnd;
5151	case CSSValueFlexStart:	5102	case CSSValueFlexStart:
5152	return JustifySelfFlexStart;	5103	return ItemPositionFlexStart;
5153	case CSSValueFlexEnd:	5104	case CSSValueFlexEnd:
5154	return JustifySelfFlexEnd;	5105	return ItemPositionFlexEnd;
5155	case CSSValueLeft:	5106	case CSSValueLeft:
5156	return JustifySelfLeft;	5107	return ItemPositionLeft;
5157	case CSSValueRight:	5108	case CSSValueRight:
5158	return JustifySelfRight;	5109	return ItemPositionRight;
5159	default:	5110	default:
5160	break;	5111	break;
5161	}	5112	}
5162	ASSERT_NOT_REACHED();	5113	ASSERT_NOT_REACHED();
5163	return JustifySelfAuto;	5114	return ItemPositionAuto;
5164	}	5115	}
5165		5116
5166	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifySelfOverflowAlignment overflowAlignment)	5117	template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
5167	: CSSValue(PrimitiveClass)	5118	: CSSValue(PrimitiveClass)
5168	{	5119	{
5169	m_primitiveUnitType = CSS_VALUE_ID;	5120	m_primitiveUnitType = CSS_VALUE_ID;
5170	switch (overflowAlignment) {	5121	switch (overflowAlignment) {
5171	case JustifySelfOverflowAlignmentDefault:	5122	case OverflowAlignmentDefault:
5172	m_value.valueID = CSSValueDefault;	5123	m_value.valueID = CSSValueDefault;
5173	break;	5124	break;
5174	case JustifySelfOverflowAlignmentTrue:	5125	case OverflowAlignmentTrue:
5175	m_value.valueID = CSSValueTrue;	5126	m_value.valueID = CSSValueTrue;
5176	break;	5127	break;
5177	case JustifySelfOverflowAlignmentSafe:	5128	case OverflowAlignmentSafe:
5178	m_value.valueID = CSSValueSafe;	5129	m_value.valueID = CSSValueSafe;
5179	break;	5130	break;
5180	}	5131	}
5181	}	5132	}
5182		5133
5183	template<> inline CSSPrimitiveValue::operator EJustifySelfOverflowAlignment() const	5134	template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
5184	{	5135	{
5185	switch (m_value.valueID) {	5136	switch (m_value.valueID) {
5186	case CSSValueTrue:	5137	case CSSValueTrue:
5187	return JustifySelfOverflowAlignmentTrue;	5138	return OverflowAlignmentTrue;
5188	case CSSValueSafe:	5139	case CSSValueSafe:
5189	return JustifySelfOverflowAlignmentSafe;	5140	return OverflowAlignmentSafe;
5190	default:	5141	default:
5191	break;	5142	break;
5192	}	5143	}
5193	ASSERT_NOT_REACHED();	5144	ASSERT_NOT_REACHED();
5194	return JustifySelfOverflowAlignmentTrue;	5145	return OverflowAlignmentTrue;
5195	}	5146	}
5196		5147
5197		5148

Lines 540-545 space-around a/Source/WebCore/css/CSSValueKeywords.in_sec1
- a/Source/WebCore/css/CSSValueKeywords.in +2 lines
540	// flex-end	540	// flex-end
541	// center	541	// center
542	// baseline	542	// baseline
		543	last-baseline
543	// stretch	544	// stretch
544		545
545	// CSS_PROP_JUSTIFY_CONTENT	546	// CSS_PROP_JUSTIFY_CONTENT
Lines 553-558 space-around a/Source/WebCore/css/CSSValueKeywords.in_sec2
553	// auto	554	// auto
554	// stretch	555	// stretch
555	// baseline	556	// baseline
		557	// last-baseline
556	// center	558	// center
557	// start	559	// start
558	// end	560	// end

Lines 1117-1142 static bool doesNotInheritTextDecoration(const RenderStyle& style, Element* e) a/Source/WebCore/css/StyleResolver.cpp_sec1
- a/Source/WebCore/css/StyleResolver.cpp -27 / +74 lines
1117	\|\| style.isFloating() \|\| style.hasOutOfFlowPosition();	1117	\|\| style.isFloating() \|\| style.hasOutOfFlowPosition();
1118	}	1118	}
1119		1119
1120	static bool isDisplayFlexibleBox(EDisplay display)
1121	{
1122	return display == FLEX \|\| display == INLINE_FLEX;
1123	}
1124
1125	static inline bool isDisplayGridBox(EDisplay display)
1126	{
1127	#if ENABLE(CSS_GRID_LAYOUT)
1128	return display == GRID \|\| display == INLINE_GRID;
1129	#else
1130	UNUSED_PARAM(display);
1131	return false;
1132	#endif
1133	}
1134
1135	static bool isDisplayFlexibleOrGridBox(EDisplay display)
1136	{
1137	return isDisplayFlexibleBox(display) \|\| isDisplayGridBox(display);
1138	}
1139
1140	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)	1120	#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
1141	static bool isScrollableOverflow(EOverflow overflow)	1121	static bool isScrollableOverflow(EOverflow overflow)
1142	{	1122	{
Lines 1239-1252 void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par a/Source/WebCore/css/StyleResolver.cpp_sec2
1239	if (style.writingMode() != TopToBottomWritingMode && (style.display() == BOX \|\| style.display() == INLINE_BOX))	1219	if (style.writingMode() != TopToBottomWritingMode && (style.display() == BOX \|\| style.display() == INLINE_BOX))
1240	style.setWritingMode(TopToBottomWritingMode);	1220	style.setWritingMode(TopToBottomWritingMode);
1241		1221
1242	if (isDisplayFlexibleOrGridBox(parentStyle.display())) {	1222	if (parentStyle.isDisplayFlexibleOrGridBox()) {
1243	style.setFloating(NoFloat);	1223	style.setFloating(NoFloat);
1244	style.setDisplay(equivalentBlockDisplay(style.display(), style.isFloating(), !document().inQuirksMode()));	1224	style.setDisplay(equivalentBlockDisplay(style.display(), style.isFloating(), !document().inQuirksMode()));
1245	}	1225	}
1246	}	1226	}
1247		1227
1248	// Make sure our z-index value is only applied if the object is positioned.	1228	// Make sure our z-index value is only applied if the object is positioned.
1249	if (style.position() == StaticPosition && !isDisplayFlexibleOrGridBox(parentStyle.display()))	1229	if (style.position() == StaticPosition && !parentStyle.isDisplayFlexibleOrGridBox())
1250	style.setHasAutoZIndex();	1230	style.setHasAutoZIndex();
1251		1231
1252	// Auto z-index becomes 0 for the root element and transparent objects. This prevents	1232	// Auto z-index becomes 0 for the root element and transparent objects. This prevents
Lines 1370-1375 void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par a/Source/WebCore/css/StyleResolver.cpp_sec3
1370	if ((e->hasTagName(SVGNames::foreignObjectTag) \|\| e->hasTagName(SVGNames::textTag)) && style.isDisplayInlineType())	1350	if ((e->hasTagName(SVGNames::foreignObjectTag) \|\| e->hasTagName(SVGNames::textTag)) && style.isDisplayInlineType())
1371	style.setDisplay(BLOCK);	1351	style.setDisplay(BLOCK);
1372	}	1352	}
		1353
		1354	// CSS Box Alignment specification requires to resolve "auto" (inital/default) values.
		1355	adjustStyleForAlignment(style);
		1356	}
		1357
		1358	void StyleResolver::adjustStyleForAlignment(RenderStyle& style)
		1359	{
		1360	// The 'auto' keyword computes to:
		1361	// - 'stretch' for flex containers and grid containers,
		1362	// - 'start' for everything else. (to be resolved later, during the layout)
		1363	if (style.alignItems() == ItemPositionAuto) {
		1364	if (style.isDisplayFlexibleOrGridBox())
		1365	style.setAlignItems(ItemPositionStretch);
		1366	else
		1367	style.setAlignItems(ItemPositionStart);
		1368	}
		1369
		1370	// The 'auto' keyword computes to 'stretch' on absolutely-positioned elements,
		1371	// and to the computed value of align-items on the parent (minus
		1372	// any 'legacy' keywords) on all other boxes (to be resolved during the layout).
		1373	if (style.alignSelf() == ItemPositionAuto) {
		1374	if ((style.position() == AbsolutePosition))
		1375	style.setAlignSelf(ItemPositionStretch);
		1376	}
1373	}	1377	}
1374		1378
1375	bool StyleResolver::checkRegionStyle(Element* regionElement)	1379	bool StyleResolver::checkRegionStyle(Element* regionElement)
Lines 2885-2900 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/StyleResolver.cpp_sec4
2885	return;	2889	return;
2886	}	2890	}
2887	#endif /* ENABLE(CSS_GRID_LAYOUT) */	2891	#endif /* ENABLE(CSS_GRID_LAYOUT) */
		2892	case CSSPropertyAlignSelf: {
		2893	if (isInherit) {
		2894	state.style()->setAlignSelf(state.parentStyle()->alignSelf());
		2895	state.style()->setAlignSelfOverflowAlignment(state.parentStyle()->alignSelfOverflowAlignment());
		2896	return;
		2897	}
		2898	if (isInitial) {
		2899	state.style()->setAlignSelf(RenderStyle::initialAlignSelf());
		2900	state.style()->setAlignSelfOverflowAlignment(RenderStyle::initialAlignSelfOverflowAlignment());
		2901	return;
		2902	}
		2903	if (Pair* pairValue = primitiveValue->getPairValue()) {
		2904	state.style()->setAlignSelf(*pairValue->first());
		2905	state.style()->setAlignSelfOverflowAlignment(*pairValue->second());
		2906	} else
		2907	state.style()->setAlignSelf(*primitiveValue);
		2908	return;
		2909	}
2888		2910
2889	case CSSPropertyWebkitJustifySelf:	2911	case CSSPropertyAlignItems: {
2890	HANDLE_INHERIT_AND_INITIAL(justifySelf, JustifySelf);	2912	if (isInherit) {
		2913	state.style()->setAlignItems(state.parentStyle()->alignItems());
		2914	state.style()->setAlignItemsOverflowAlignment(state.parentStyle()->alignItemsOverflowAlignment());
		2915	return;
		2916	}
		2917	if (isInitial) {
		2918	state.style()->setAlignItems(RenderStyle::initialAlignItems());
		2919	state.style()->setAlignItemsOverflowAlignment(RenderStyle::initialAlignItemsOverflowAlignment());
		2920	return;
		2921	}
		2922	if (Pair* pairValue = primitiveValue->getPairValue()) {
		2923	state.style()->setAlignItems(*pairValue->first());
		2924	state.style()->setAlignItemsOverflowAlignment(*pairValue->second());
		2925	} else
		2926	state.style()->setAlignItems(*primitiveValue);
		2927	return;
		2928	}
		2929	case CSSPropertyJustifySelf: {
		2930	if (isInherit) {
		2931	state.style()->setJustifySelf(state.parentStyle()->justifySelf());
		2932	state.style()->setJustifySelfOverflowAlignment(state.parentStyle()->justifySelfOverflowAlignment());
		2933	return;
		2934	}
		2935	if (isInitial) {
		2936	state.style()->setJustifySelf(RenderStyle::initialJustifySelf());
		2937	state.style()->setJustifySelfOverflowAlignment(RenderStyle::initialJustifySelfOverflowAlignment());
		2938	return;
		2939	}
2891	if (Pair* pairValue = primitiveValue->getPairValue()) {	2940	if (Pair* pairValue = primitiveValue->getPairValue()) {
2892	state.style()->setJustifySelf(*pairValue->first());	2941	state.style()->setJustifySelf(*pairValue->first());
2893	state.style()->setJustifySelfOverflowAlignment(*pairValue->second());	2942	state.style()->setJustifySelfOverflowAlignment(*pairValue->second());
2894	} else	2943	} else
2895	state.style()->setJustifySelf(*primitiveValue);	2944	state.style()->setJustifySelf(*primitiveValue);
2896	return;	2945	return;
2897		2946	}
2898	#if ENABLE(CSS_SCROLL_SNAP)	2947	#if ENABLE(CSS_SCROLL_SNAP)
2899	case CSSPropertyWebkitScrollSnapType:	2948	case CSSPropertyWebkitScrollSnapType:
2900	HANDLE_INHERIT_AND_INITIAL(scrollSnapType, ScrollSnapType);	2949	HANDLE_INHERIT_AND_INITIAL(scrollSnapType, ScrollSnapType);
Lines 3105-3112 void StyleResolver::applyProperty(CSSPropertyID id, CSSValue* value) a/Source/WebCore/css/StyleResolver.cpp_sec5
3105	case CSSPropertyWebkitCursorVisibility:	3154	case CSSPropertyWebkitCursorVisibility:
3106	#endif	3155	#endif
3107	case CSSPropertyAlignContent:	3156	case CSSPropertyAlignContent:
3108	case CSSPropertyAlignItems:
3109	case CSSPropertyAlignSelf:
3110	case CSSPropertyFlexBasis:	3157	case CSSPropertyFlexBasis:
3111	case CSSPropertyFlexDirection:	3158	case CSSPropertyFlexDirection:
3112	case CSSPropertyFlexGrow:	3159	case CSSPropertyFlexGrow:

Lines 32-37 a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec1
- a/Source/WebCore/rendering/RenderFlexibleBox.cpp -25 / +44 lines
32	#include "RenderFlexibleBox.h"	32	#include "RenderFlexibleBox.h"
33		33
34	#include "LayoutRepainter.h"	34	#include "LayoutRepainter.h"
		35	#include "NotImplemented.h"
35	#include "RenderLayer.h"	36	#include "RenderLayer.h"
36	#include "RenderView.h"	37	#include "RenderView.h"
37	#include <limits>	38	#include <limits>
Lines 186-192 int RenderFlexibleBox::firstLineBaseline() const a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec2
186	for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {	187	for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
187	if (child->isOutOfFlowPositioned())	188	if (child->isOutOfFlowPositioned())
188	continue;	189	continue;
189	if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child)) {	190	if (alignmentForChild(child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(child)) {
190	baselineChild = child;	191	baselineChild = child;
191	break;	192	break;
192	}	193	}
Lines 227-237 int RenderFlexibleBox::inlineBlockBaseline(LineDirectionMode direction) const a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec3
227	return synthesizedBaselineFromContentBox(*this, direction) + marginAscent;	228	return synthesizedBaselineFromContentBox(*this, direction) + marginAscent;
228	}	229	}
229		230
230	static EAlignItems resolveAlignment(const RenderStyle* parentStyle, const RenderStyle* childStyle)	231	static ItemPosition resolveAlignment(const RenderStyle* parentStyle, const RenderStyle* childStyle)
231	{	232	{
232	EAlignItems align = childStyle->alignSelf();	233	ItemPosition align = childStyle->alignSelf();
233	if (align == AlignAuto)	234	if (align == ItemPositionAuto)
234	align = parentStyle->alignItems();	235	align = (parentStyle->alignItems() == ItemPositionAuto) ? ItemPositionStretch : parentStyle->alignItems();
235	return align;	236	return align;
236	}	237	}
237		238
Lines 239-250 void RenderFlexibleBox::styleDidChange(StyleDifference diff, const RenderStyle* a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec4
239	{	240	{
240	RenderBlock::styleDidChange(diff, oldStyle);	241	RenderBlock::styleDidChange(diff, oldStyle);
241		242
242	if (oldStyle && oldStyle->alignItems() == AlignStretch && diff == StyleDifferenceLayout) {	243	if (oldStyle && oldStyle->alignItems() == ItemPositionStretch && diff == StyleDifferenceLayout) {
243	// Flex items that were previously stretching need to be relayed out so we can compute new available cross axis space.	244	// Flex items that were previously stretching need to be relayed out so we can compute new available cross axis space.
244	// This is only necessary for stretching since other alignment values don't change the size of the box.	245	// This is only necessary for stretching since other alignment values don't change the size of the box.
245	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {	246	for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
246	EAlignItems previousAlignment = resolveAlignment(oldStyle, &child->style());	247	ItemPosition previousAlignment = resolveAlignment(oldStyle, &child->style());
247	if (previousAlignment == AlignStretch && previousAlignment != resolveAlignment(&style(), &child->style()))	248	if (previousAlignment == ItemPositionStretch && previousAlignment != resolveAlignment(&style(), &child->style()))
248	child->setChildNeedsLayout(MarkOnlyThis);	249	child->setChildNeedsLayout(MarkOnlyThis);
249	}	250	}
250	}	251	}
Lines 1023-1040 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox& child, Layout a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec5
1023	}	1024	}
1024	}	1025	}
1025		1026
1026	EAlignItems RenderFlexibleBox::alignmentForChild(RenderBox& child) const	1027	ItemPosition RenderFlexibleBox::alignmentForChild(RenderBox& child) const
1027	{	1028	{
1028	EAlignItems align = resolveAlignment(&style(), &child.style());	1029	ItemPosition align = resolveAlignment(&style(), &child.style());
1029		1030
1030	if (align == AlignBaseline && hasOrthogonalFlow(child))	1031	if (align == ItemPositionBaseline && hasOrthogonalFlow(child))
1031	align = AlignFlexStart;	1032	align = ItemPositionFlexStart;
1032		1033
1033	if (style().flexWrap() == FlexWrapReverse) {	1034	if (style().flexWrap() == FlexWrapReverse) {
1034	if (align == AlignFlexStart)	1035	if (align == ItemPositionFlexStart)
1035	align = AlignFlexEnd;	1036	align = ItemPositionFlexEnd;
1036	else if (align == AlignFlexEnd)	1037	else if (align == ItemPositionFlexEnd)
1037	align = AlignFlexStart;	1038	align = ItemPositionFlexStart;
1038	}	1039	}
1039		1040
1040	return align;	1041	return align;
Lines 1053-1059 size_t RenderFlexibleBox::numberOfInFlowPositionedChildren(const OrderedFlexItem a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec6
1053		1054
1054	bool RenderFlexibleBox::needToStretchChild(RenderBox& child)	1055	bool RenderFlexibleBox::needToStretchChild(RenderBox& child)
1055	{	1056	{
1056	if (alignmentForChild(child) != AlignStretch)	1057	if (alignmentForChild(child) != ItemPositionStretch)
1057	return false;	1058	return false;
1058		1059
1059	Length crossAxisLength = isHorizontalFlow() ? child.style().height() : child.style().width();	1060	Length crossAxisLength = isHorizontalFlow() ? child.style().height() : child.style().width();
Lines 1104-1110 void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, cons a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec7
1104	updateAutoMarginsInMainAxis(child, autoMarginOffset);	1105	updateAutoMarginsInMainAxis(child, autoMarginOffset);
1105		1106
1106	LayoutUnit childCrossAxisMarginBoxExtent;	1107	LayoutUnit childCrossAxisMarginBoxExtent;
1107	if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child)) {	1108	if (alignmentForChild(child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(child)) {
1108	LayoutUnit ascent = marginBoxAscentForChild(child);	1109	LayoutUnit ascent = marginBoxAscentForChild(child);
1109	LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;	1110	LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
1110		1111
Lines 1265-1289 void RenderFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts) a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec8
1265	continue;	1266	continue;
1266		1267
1267	switch (alignmentForChild(*child)) {	1268	switch (alignmentForChild(*child)) {
1268	case AlignAuto:	1269	case ItemPositionAuto:
1269	ASSERT_NOT_REACHED();	1270	ASSERT_NOT_REACHED();
1270	break;	1271	break;
1271	case AlignStretch: {	1272	case ItemPositionStart:
		1273	// FIXME: https://webkit.org/b/135460 - The extended grammar is not supported
		1274	// yet for FlexibleBox.
		1275	// Defaulting to Stretch for now, as it what most of FlexBox based renders
		1276	// expect as default.
		1277	notImplemented();
		1278	case ItemPositionStretch: {
1272	applyStretchAlignmentToChild(*child, lineCrossAxisExtent);	1279	applyStretchAlignmentToChild(*child, lineCrossAxisExtent);
1273	// Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.	1280	// Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.
1274	if (style().flexWrap() == FlexWrapReverse)	1281	if (style().flexWrap() == FlexWrapReverse)
1275	adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));	1282	adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1276	break;	1283	break;
1277	}	1284	}
1278	case AlignFlexStart:	1285	case ItemPositionFlexStart:
1279	break;	1286	break;
1280	case AlignFlexEnd:	1287	case ItemPositionFlexEnd:
1281	adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));	1288	adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1282	break;	1289	break;
1283	case AlignCenter:	1290	case ItemPositionCenter:
1284	adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) / 2);	1291	adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) / 2);
1285	break;	1292	break;
1286	case AlignBaseline: {	1293	case ItemPositionBaseline: {
1287	// FIXME: If we get here in columns, we want the use the descent, except we currently can't get the ascent/descent of orthogonal children.	1294	// FIXME: If we get here in columns, we want the use the descent, except we currently can't get the ascent/descent of orthogonal children.
1288	// https://bugs.webkit.org/show_bug.cgi?id=98076	1295	// https://bugs.webkit.org/show_bug.cgi?id=98076
1289	LayoutUnit ascent = marginBoxAscentForChild(*child);	1296	LayoutUnit ascent = marginBoxAscentForChild(*child);
Lines 1294-1299 void RenderFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts) a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec9
1294	minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child) - startOffset);	1301	minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child) - startOffset);
1295	break;	1302	break;
1296	}	1303	}
		1304	case ItemPositionLastBaseline:
		1305	case ItemPositionSelfStart:
		1306	case ItemPositionSelfEnd:
		1307	case ItemPositionEnd:
		1308	case ItemPositionLeft:
		1309	case ItemPositionRight:
		1310	// FIXME: https://webkit.org/b/135460 - The extended grammar is not supported
		1311	// yet for FlexibleBox.
		1312	notImplemented();
		1313	default:
		1314	ASSERT_NOT_REACHED();
		1315	break;
1297	}	1316	}
1298	}	1317	}
1299	minMarginAfterBaselines.append(minMarginAfterBaseline);	1318	minMarginAfterBaselines.append(minMarginAfterBaseline);
Lines 1309-1315 void RenderFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts) a/Source/WebCore/rendering/RenderFlexibleBox.cpp_sec10
1309	LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];	1328	LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
1310	for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next()) {	1329	for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
1311	ASSERT(child);	1330	ASSERT(child);
1312	if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child) && minMarginAfterBaseline)	1331	if (alignmentForChild(child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(child) && minMarginAfterBaseline)
1313	adjustAlignmentForChild(*child, minMarginAfterBaseline);	1332	adjustAlignmentForChild(*child, minMarginAfterBaseline);
1314	}	1333	}
1315	}	1334	}

Lines 233-239 void RenderMathMLRoot::updateStyle() a/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp_sec1
- a/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp -2 / +2 lines
233	auto base = baseWrapper();	233	auto base = baseWrapper();
234	auto baseStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);	234	auto baseStyle = RenderStyle::createAnonymousStyleWithDisplay(&style(), FLEX);
235	baseStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().	235	baseStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
236	baseStyle.get().setAlignItems(AlignBaseline);	236	baseStyle.get().setAlignItems(ItemPositionBaseline);
237	base->setStyle(WTF::move(baseStyle));	237	base->setStyle(WTF::move(baseStyle));
238	base->setNeedsLayoutAndPrefWidthsRecalc();	238	base->setNeedsLayoutAndPrefWidthsRecalc();
239		239
Lines 244-250 void RenderMathMLRoot::updateStyle() a/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp_sec2
244	indexStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().	244	indexStyle.get().setMarginTop(Length(0, Fixed)); // This will be updated in RenderMathMLRoot::layout().
245	indexStyle.get().setMarginStart(Length(kernBeforeDegree, Fixed));	245	indexStyle.get().setMarginStart(Length(kernBeforeDegree, Fixed));
246	indexStyle.get().setMarginEnd(Length(kernAfterDegree, Fixed));	246	indexStyle.get().setMarginEnd(Length(kernAfterDegree, Fixed));
247	indexStyle.get().setAlignItems(AlignBaseline);	247	indexStyle.get().setAlignItems(ItemPositionBaseline);
248	index->setStyle(WTF::move(indexStyle));	248	index->setStyle(WTF::move(indexStyle));
249	index->setNeedsLayoutAndPrefWidthsRecalc();	249	index->setNeedsLayoutAndPrefWidthsRecalc();
250	}	250	}

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +83 lines
		1	2014-10-27 Javier Fernandez <jfernandez@igalia.com>
		2
		3	[CSS Grid Layout] Upgrade align-self and align-items parsing to CSS 3
		4	https://bugs.webkit.org/show_bug.cgi?id=133359
		5
		6	Reviewed by David Hyatt.
		7
		8	Broaden justify-self's parsing name as a preparation of migrating
		9	align-self, align-items and justify-items to the CSS 3 Alignment syntax.
		10
		11	The current naming was too tied to justify-self and needs to
		12	be broadened. This will reduce the follow-up implementations'
		13	patches.
		14
		15	Upgrade align-self and align-items parsing to CSS 3
		16
		17	This change migrates the 2 properties to the CSS 3 Alignment
		18	parsing. The new parsing is identical to how we parse
		19	'justify-self'. The 2 properties need to be migrated together
		20	as they are used in tandem in CSSComputedStyleDeclaration.
		21
		22	This change also removes EAlignItems as it is now unused.
		23
		24	Tests: css3/parse-align-items.html
		25	css3/parse-align-self.html
		26
		27	* css/CSSComputedStyleDeclaration.cpp:
		28	(WebCore::valueForItemPositionWithOverflowAlignment): Added. Builds the CSSValue for the for the alignment properties.
		29	(WebCore::ComputedStyleExtractor::propertyValue):
		30	* css/CSSParser.cpp:
		31	(WebCore::isKeywordPropertyID): Removed align-items and align-self from the list.
		32	(WebCore::isValidKeywordPropertyAndValue): Removed align-items and align-self from the list.
		33	(WebCore::CSSParser::parseValue): Added align-items and align-self to the list and call to the generic parsing fuction for the alignment properties.
		34	(WebCore::isBaselinePositionKeyword): Utility function added to identify Baseline keyword values.
		35	(WebCore::CSSParser::parseItemPositionOverflowPosition): Generic parsing fuction for the alignment properties.
		36	(WebCore::CSSParser::parseJustifySelf): Deleted.
		37	* css/CSSParser.h:
		38	* css/CSSPrimitiveValueMappings.h:
		39	(WebCore::CSSPrimitiveValue::CSSPrimitiveValue): Refactoring some mapping functions.
		40	(WebCore::CSSPrimitiveValue::operator ItemPosition): Added. Replace the old EAlignItems enumeration.
		41	(WebCore::CSSPrimitiveValue::operator OverflowAlignment): Added.
		42	(WebCore::CSSPrimitiveValue::operator EAlignItems): Deleted.
		43	(WebCore::CSSPrimitiveValue::operator EJustifySelf): Deleted.
		44	(WebCore::CSSPrimitiveValue::operator EJustifySelfOverflowAlignment): Deleted.
		45	* css/CSSPropertyNames.in:
		46	* css/CSSValueKeywords.in:
		47	* css/StyleResolver.cpp:
		48	(WebCore::StyleResolver::adjustRenderStyle): Added a new adjustment to resolve the "auto" vale on the alignment properties.
		49	(WebCore::StyleResolver::adjustStyleForAlignment): Added. Function to resolve the "auto" vale on the alignment properties.
		50	(WebCore::StyleResolver::applyProperty):
		51	(WebCore::isDisplayFlexibleBox): Deleted. Moved to the RenderStyle.
		52	(WebCore::isDisplayGridBox): Deleted. Moved to the RenderStyle.
		53	(WebCore::isDisplayFlexibleOrGridBox): Deleted. Moved to the RenderStyle.
		54	* css/StyleResolver.h:
		55	* rendering/RenderBox.cpp:
		56	(WebCore::flexItemHasStretchAlignment): Adapted to the new ItemPosition enum.
		57	* rendering/RenderFlexibleBox.cpp:
		58	(WebCore::RenderFlexibleBox::firstLineBaseline): Adapted to the new ItemPosition enum.
		59	(WebCore::resolveAlignment): Consider also that align-items could be "auto", since it's the default now.
		60	(WebCore::RenderFlexibleBox::styleDidChange): Adapted to the new ItemPosition enum.
		61	(WebCore::RenderFlexibleBox::alignmentForChild): Adapted to the new ItemPosition enum.
		62	(WebCore::RenderFlexibleBox::needToStretchChild): Adapted to the new ItemPosition enum.
		63	(WebCore::RenderFlexibleBox::layoutAndPlaceChildren): Adapted to the new ItemPosition enum.
		64	(WebCore::RenderFlexibleBox::alignChildren): Adapted to the new ItemPosition enum.
65	* rendering/RenderFlexibleBox.h:
66	* rendering/RenderFullScreen.cpp:
67	(WebCore::createFullScreenStyle): Adapted to the new ItemPosition enum.
68	* rendering/RenderMenuList.cpp:
69	(WebCore::RenderMenuList::adjustInnerStyle): Adapted to the new ItemPosition enum.
70	* rendering/mathml/RenderMathMLRoot.cpp:
71	(WebCore::RenderMathMLRoot::updateStyle): Adapted to the new ItemPosition enum.
72	* rendering/mathml/RenderMathMLScripts.cpp:
73	(WebCore::RenderMathMLScripts::fixAnonymousStyleForSubSupPair): Adapted to the new ItemPosition enum.
74	(WebCore::RenderMathMLScripts::fixAnonymousStyles): Adapted to the new ItemPosition enum.
75	* rendering/style/RenderStyle.h: Adapted to the new ItemPosition enum.
76	* rendering/style/RenderStyleConstants.h: Adapted to the new ItemPosition enum.
77	* rendering/style/StyleRareNonInheritedData.cpp: Adapted to the new ItemPosition enum.
78	(WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData): Adapted to the new ItemPosition enum.
79	(WebCore::StyleRareNonInheritedData::operator==): Adapted to the new ItemPosition enum.
80	* rendering/style/StyleRareNonInheritedData.h: Adapted to the new ItemPosition enum.
81	* style/StyleResolveTree.cpp:
82	(WebCore::Style::determineChange): Changes in the alignItems property will cause a Detach.
83
1	2014-10-26 Benjamin Poulain <benjamin@webkit.org>	84	2014-10-26 Benjamin Poulain <benjamin@webkit.org>
2		85
3	Images with usemap should not have a link state	86	Images with usemap should not have a link state

Lines 289-295 static const CSSPropertyID computedProperties[] = { a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec1
- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp -15 / +23 lines
289	CSSPropertyFlexDirection,	289	CSSPropertyFlexDirection,
290	CSSPropertyFlexWrap,	290	CSSPropertyFlexWrap,
291	CSSPropertyJustifyContent,	291	CSSPropertyJustifyContent,
292	CSSPropertyWebkitJustifySelf,	292	CSSPropertyJustifySelf,
293	CSSPropertyWebkitFilter,	293	CSSPropertyWebkitFilter,
294	CSSPropertyWebkitFontKerning,	294	CSSPropertyWebkitFontKerning,
295	CSSPropertyWebkitFontSmoothing,	295	CSSPropertyWebkitFontSmoothing,
Lines 1700-1705 static PassRef<CSSValue> shapePropertyValue(const RenderStyle* style, const Shap a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec2
1700	}	1700	}
1701	#endif	1701	#endif
1702		1702
		1703	static PassRefPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment)
		1704	{
		1705	RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
		1706	result->append(cssValuePool().createValue(itemPosition));
		1707	if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
		1708	result->append(cssValuePool().createValue(overflowAlignment));
		1709	return result.release();
		1710	}
		1711
1703	PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const	1712	PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const
1704	{	1713	{
1705	Node* styledNode = this->styledNode();	1714	Node* styledNode = this->styledNode();
Lines 2043-2057 PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propert a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec3
2043	case CSSPropertyAlignContent:	2052	case CSSPropertyAlignContent:
2044	return cssValuePool().createValue(style->alignContent());	2053	return cssValuePool().createValue(style->alignContent());
2045	case CSSPropertyAlignItems:	2054	case CSSPropertyAlignItems:
2046	return cssValuePool().createValue(style->alignItems());	2055	return valueForItemPositionWithOverflowAlignment(style->alignItems(), style->alignItemsOverflowAlignment());
2047	case CSSPropertyAlignSelf:	2056	case CSSPropertyAlignSelf: {
2048	if (style->alignSelf() == AlignAuto) {	2057	ItemPosition alignSelf = style->alignSelf();
		2058	OverflowAlignment overflow = style->alignSelfOverflowAlignment();
		2059	if (alignSelf == ItemPositionAuto) {
2049	Node* parent = styledNode->parentNode();	2060	Node* parent = styledNode->parentNode();
2050	if (parent && parent->computedStyle())	2061	if (parent && parent->computedStyle()) {
2051	return cssValuePool().createValue(parent->computedStyle()->alignItems());	2062	alignSelf = parent->computedStyle()->alignItems();
2052	return cssValuePool().createValue(AlignStretch);	2063	overflow = parent->computedStyle()->alignItemsOverflowAlignment();
		2064	}
2053	}	2065	}
2054	return cssValuePool().createValue(style->alignSelf());	2066	return valueForItemPositionWithOverflowAlignment(alignSelf, overflow);
		2067	}
2055	case CSSPropertyFlex:	2068	case CSSPropertyFlex:
2056	return getCSSPropertyValuesForShorthandProperties(flexShorthand());	2069	return getCSSPropertyValuesForShorthandProperties(flexShorthand());
2057	case CSSPropertyFlexBasis:	2070	case CSSPropertyFlexBasis:
Lines 2068-2080 PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propert a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp_sec4
2068	return cssValuePool().createValue(style->flexWrap());	2081	return cssValuePool().createValue(style->flexWrap());
2069	case CSSPropertyJustifyContent:	2082	case CSSPropertyJustifyContent:
2070	return cssValuePool().createValue(style->justifyContent());	2083	return cssValuePool().createValue(style->justifyContent());
2071	case CSSPropertyWebkitJustifySelf: {	2084	case CSSPropertyJustifySelf:
2072	RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();	2085	return valueForItemPositionWithOverflowAlignment(style->justifySelf(), style->justifySelfOverflowAlignment());
2073	result->append(CSSPrimitiveValue::create(style->justifySelf()));
2074	if (style->justifySelf() >= JustifySelfCenter && style->justifySelfOverflowAlignment() != JustifySelfOverflowAlignmentDefault)
2075	result->append(CSSPrimitiveValue::create(style->justifySelfOverflowAlignment()));
2076	return result.release();
2077	}
2078	case CSSPropertyOrder:	2086	case CSSPropertyOrder:
2079	return cssValuePool().createValue(style->order(), CSSPrimitiveValue::CSS_NUMBER);	2087	return cssValuePool().createValue(style->order(), CSSPrimitiveValue::CSS_NUMBER);
2080	case CSSPropertyFloat:	2088	case CSSPropertyFloat:

Lines 865-870 static inline bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, int a/Source/WebCore/css/CSSParser.cpp_sec1
- a/Source/WebCore/css/CSSParser.cpp -5 / +26 lines
865	if (valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueSpaceBetween \|\| valueID == CSSValueSpaceAround \|\| valueID == CSSValueStretch)	865	if (valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueSpaceBetween \|\| valueID == CSSValueSpaceAround \|\| valueID == CSSValueStretch)
866	return true;	866	return true;
867	break;	867	break;
		868	#if !ENABLE(CSS_GRID_LAYOUT)
868	case CSSPropertyAlignItems:	869	case CSSPropertyAlignItems:
869	// FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.	870	// FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.
870	if (valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueBaseline \|\| valueID == CSSValueStretch)	871	if (valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueBaseline \|\| valueID == CSSValueStretch)
Lines 875-880 static inline bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, int a/Source/WebCore/css/CSSParser.cpp_sec2
875	if (valueID == CSSValueAuto \|\| valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueBaseline \|\| valueID == CSSValueStretch)	876	if (valueID == CSSValueAuto \|\| valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueBaseline \|\| valueID == CSSValueStretch)
876	return true;	877	return true;
877	break;	878	break;
		879	#endif
878	case CSSPropertyFlexDirection:	880	case CSSPropertyFlexDirection:
879	if (valueID == CSSValueRow \|\| valueID == CSSValueRowReverse \|\| valueID == CSSValueColumn \|\| valueID == CSSValueColumnReverse)	881	if (valueID == CSSValueRow \|\| valueID == CSSValueRowReverse \|\| valueID == CSSValueColumn \|\| valueID == CSSValueColumnReverse)
880	return true;	882	return true;
Lines 888-897 static inline bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, int a/Source/WebCore/css/CSSParser.cpp_sec3
888	if (valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueSpaceBetween \|\| valueID == CSSValueSpaceAround)	890	if (valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueSpaceBetween \|\| valueID == CSSValueSpaceAround)
889	return true;	891	return true;
890	break;	892	break;
891	case CSSPropertyWebkitJustifySelf:	893	#if !ENABLE(CSS_GRID_LAYOUT)
		894	case CSSPropertyJustifySelf:
892	if (valueID == CSSValueAuto \|\| valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueBaseline \|\| valueID == CSSValueStretch)	895	if (valueID == CSSValueAuto \|\| valueID == CSSValueFlexStart \|\| valueID == CSSValueFlexEnd \|\| valueID == CSSValueCenter \|\| valueID == CSSValueBaseline \|\| valueID == CSSValueStretch)
893	return true;	896	return true;
894	break;	897	break;
		898	#endif
895	case CSSPropertyWebkitFontKerning:	899	case CSSPropertyWebkitFontKerning:
896	if (valueID == CSSValueAuto \|\| valueID == CSSValueNormal \|\| valueID == CSSValueNone)	900	if (valueID == CSSValueAuto \|\| valueID == CSSValueNormal \|\| valueID == CSSValueNone)
897	return true;	901	return true;
Lines 1106-1113 static inline bool isKeywordPropertyID(CSSPropertyID propertyId) a/Source/WebCore/css/CSSParser.cpp_sec4
1106	case CSSPropertyWebkitColumnFill:	1110	case CSSPropertyWebkitColumnFill:
1107	case CSSPropertyWebkitColumnRuleStyle:	1111	case CSSPropertyWebkitColumnRuleStyle:
1108	case CSSPropertyAlignContent:	1112	case CSSPropertyAlignContent:
		1113	#if !ENABLE(CSS_GRID_LAYOUT)
1109	case CSSPropertyAlignItems:	1114	case CSSPropertyAlignItems:
1110	case CSSPropertyAlignSelf:	1115	case CSSPropertyAlignSelf:
		1116	#endif
1111	case CSSPropertyFlexDirection:	1117	case CSSPropertyFlexDirection:
1112	case CSSPropertyFlexWrap:	1118	case CSSPropertyFlexWrap:
1113	case CSSPropertyJustifyContent:	1119	case CSSPropertyJustifyContent:
Lines 2616-2624 bool CSSParser::parseValue(CSSPropertyID propId, bool important) a/Source/WebCore/css/CSSParser.cpp_sec5
2616	}	2622	}
2617	return false;	2623	return false;
2618	}	2624	}
2619	case CSSPropertyWebkitJustifySelf:
2620	return parseJustifySelf(propId, important);
2621	#if ENABLE(CSS_GRID_LAYOUT)	2625	#if ENABLE(CSS_GRID_LAYOUT)
		2626	case CSSPropertyJustifySelf:
		2627	return parseItemPositionOverflowPosition(propId, important);
2622	case CSSPropertyWebkitGridAutoColumns:	2628	case CSSPropertyWebkitGridAutoColumns:
2623	case CSSPropertyWebkitGridAutoRows:	2629	case CSSPropertyWebkitGridAutoRows:
2624	parsedValue = parseGridTrackSize(*m_valueList);	2630	parsedValue = parseGridTrackSize(*m_valueList);
Lines 2952-2957 bool CSSParser::parseValue(CSSPropertyID propId, bool important) a/Source/WebCore/css/CSSParser.cpp_sec6
2952	parsedValue = parseImageResolution();	2958	parsedValue = parseImageResolution();
2953	break;	2959	break;
2954	#endif	2960	#endif
		2961	#if ENABLE(CSS_GRID_LAYOUT)
		2962	case CSSPropertyAlignSelf:
		2963	return parseItemPositionOverflowPosition(propId, important);
		2964
		2965	case CSSPropertyAlignItems:
		2966	return parseItemPositionOverflowPosition(propId, important);
		2967	#endif
2955	case CSSPropertyBorderBottomStyle:	2968	case CSSPropertyBorderBottomStyle:
2956	case CSSPropertyBorderCollapse:	2969	case CSSPropertyBorderCollapse:
2957	case CSSPropertyBorderLeftStyle:	2970	case CSSPropertyBorderLeftStyle:
Lines 3013-3020 bool CSSParser::parseValue(CSSPropertyID propId, bool important) a/Source/WebCore/css/CSSParser.cpp_sec7
3013	case CSSPropertyWebkitColumnFill:	3026	case CSSPropertyWebkitColumnFill:
3014	case CSSPropertyWebkitColumnRuleStyle:	3027	case CSSPropertyWebkitColumnRuleStyle:
3015	case CSSPropertyAlignContent:	3028	case CSSPropertyAlignContent:
		3029	#if !ENABLE(CSS_GRID_LAYOUT)
3016	case CSSPropertyAlignItems:	3030	case CSSPropertyAlignItems:
3017	case CSSPropertyAlignSelf:	3031	case CSSPropertyAlignSelf:
		3032	case CSSPropertyJustifySelf:
		3033	#endif
3018	case CSSPropertyFlexDirection:	3034	case CSSPropertyFlexDirection:
3019	case CSSPropertyFlexWrap:	3035	case CSSPropertyFlexWrap:
3020	case CSSPropertyJustifyContent:	3036	case CSSPropertyJustifyContent:
Lines 3125-3130 void CSSParser::addFillValue(RefPtr<CSSValue>& lval, PassRef<CSSValue> rval) a/Source/WebCore/css/CSSParser.cpp_sec8
3125	lval = WTF::move(list);	3141	lval = WTF::move(list);
3126	}	3142	}
3127		3143
		3144	static inline bool isBaselinePositionKeyword(CSSValueID id)
		3145	{
		3146	return id == CSSValueBaseline \|\| id == CSSValueLastBaseline;
		3147	}
		3148
3128	static bool isItemPositionKeyword(CSSValueID id)	3149	static bool isItemPositionKeyword(CSSValueID id)
3129	{	3150	{
3130	return id == CSSValueStart \|\| id == CSSValueEnd \|\| id == CSSValueCenter	3151	return id == CSSValueStart \|\| id == CSSValueEnd \|\| id == CSSValueCenter
Lines 3132-3138 static bool isItemPositionKeyword(CSSValueID id) a/Source/WebCore/css/CSSParser.cpp_sec9
3132	\|\| id == CSSValueFlexEnd \|\| id == CSSValueLeft \|\| id == CSSValueRight;	3153	\|\| id == CSSValueFlexEnd \|\| id == CSSValueLeft \|\| id == CSSValueRight;
3133	}	3154	}
3134		3155
3135	bool CSSParser::parseJustifySelf(CSSPropertyID propId, bool important)	3156	bool CSSParser::parseItemPositionOverflowPosition(CSSPropertyID propId, bool important)
3136	{	3157	{
3137	// auto \| baseline \| stretch \| [<item-position> && <overflow-position>? ]	3158	// auto \| baseline \| stretch \| [<item-position> && <overflow-position>? ]
3138	// <item-position> = center \| start \| end \| self-start \| self-end \| flex-start \| flex-end \| left \| right;	3159	// <item-position> = center \| start \| end \| self-start \| self-end \| flex-start \| flex-end \| left \| right;
Lines 3140-3146 bool CSSParser::parseJustifySelf(CSSPropertyID propId, bool important) a/Source/WebCore/css/CSSParser.cpp_sec10
3140		3161
3141	CSSParserValue* value = m_valueList->current();	3162	CSSParserValue* value = m_valueList->current();
3142		3163
3143	if (value->id == CSSValueAuto \|\| value->id == CSSValueBaseline \|\| value->id == CSSValueStretch) {	3164	if (value->id == CSSValueAuto \|\| value->id == CSSValueStretch \|\| isBaselinePositionKeyword(value->id)) {
3144	if (m_valueList->next())	3165	if (m_valueList->next())
3145	return false;	3166	return false;
3146		3167

Lines 295-303 isolation [NewStyleBuilder, TypeName=Isolation] a/Source/WebCore/css/CSSPropertyNames.in_sec1
- a/Source/WebCore/css/CSSPropertyNames.in -3 / +4 lines
295	-webkit-filter	295	-webkit-filter
296	align-content [NewStyleBuilder]	296	align-content [NewStyleBuilder]
297	-webkit-align-content = align-content	297	-webkit-align-content = align-content
298	align-items [NewStyleBuilder]	298	align-items
299	-webkit-align-items = align-items	299	-webkit-align-items = align-items
300	align-self [NewStyleBuilder, TypeName=EAlignItems]	300	align-self
301	-webkit-align-self = align-self	301	-webkit-align-self = align-self
302	flex	302	flex
303	-webkit-flex = flex	303	-webkit-flex = flex
Lines 315-321 flex-wrap [NewStyleBuilder] a/Source/WebCore/css/CSSPropertyNames.in_sec2
315	-webkit-flex-wrap = flex-wrap	315	-webkit-flex-wrap = flex-wrap
316	justify-content [NewStyleBuilder]	316	justify-content [NewStyleBuilder]
317	-webkit-justify-content = justify-content	317	-webkit-justify-content = justify-content
318	-webkit-justify-self	318	justify-self
		319	-webkit-justify-self = justify-self
319	-webkit-font-size-delta	320	-webkit-font-size-delta
320	#if defined(ENABLE_CSS_GRID_LAYOUT) && ENABLE_CSS_GRID_LAYOUT	321	#if defined(ENABLE_CSS_GRID_LAYOUT) && ENABLE_CSS_GRID_LAYOUT
321	-webkit-grid	322	-webkit-grid

Lines 119-128 void RenderMenuList::adjustInnerStyle() a/Source/WebCore/rendering/RenderMenuList.cpp_sec1
- a/Source/WebCore/rendering/RenderMenuList.cpp -2 / +2 lines
119	// Use margin:auto instead of align-items:center to get safe centering, i.e.	119	// Use margin:auto instead of align-items:center to get safe centering, i.e.
120	// when the content overflows, treat it the same as align-items: flex-start.	120	// when the content overflows, treat it the same as align-items: flex-start.
121	// But we only do that for the cases where html.css would otherwise use center.	121	// But we only do that for the cases where html.css would otherwise use center.
122	if (style().alignItems() == AlignCenter) {	122	if (style().alignItems() == ItemPositionCenter) {
123	innerStyle.setMarginTop(Length());	123	innerStyle.setMarginTop(Length());
124	innerStyle.setMarginBottom(Length());	124	innerStyle.setMarginBottom(Length());
125	innerStyle.setAlignSelf(AlignFlexStart);	125	innerStyle.setAlignSelf(ItemPositionFlexStart);
126	}	126	}
127		127
128	innerStyle.setPaddingLeft(Length(theme().popupInternalPaddingLeft(style()), Fixed));	128	innerStyle.setPaddingLeft(Length(theme().popupInternalPaddingLeft(style()), Fixed));

Lines 101-107 void RenderMathMLScripts::fixAnonymousStyleForSubSupPair(RenderObject* subSupPai a/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp_sec1
- a/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp -3 / +3 lines
101	// The MathML specification does not specify vertical alignment of scripts.	101	// The MathML specification does not specify vertical alignment of scripts.
102	// Let's right align prescripts and left align postscripts.	102	// Let's right align prescripts and left align postscripts.
103	// See http://lists.w3.org/Archives/Public/www-math/2012Aug/0006.html	103	// See http://lists.w3.org/Archives/Public/www-math/2012Aug/0006.html
104	scriptsStyle.setAlignItems(isPostScript ? AlignFlexStart : AlignFlexEnd);	104	scriptsStyle.setAlignItems(isPostScript ? ItemPositionFlexStart : ItemPositionFlexEnd);
105		105
106	// We set the order property so that the prescripts are drawn before the base.	106	// We set the order property so that the prescripts are drawn before the base.
107	scriptsStyle.setOrder(isPostScript ? 0 : -1);	107	scriptsStyle.setOrder(isPostScript ? 0 : -1);
Lines 115-121 void RenderMathMLScripts::fixAnonymousStyles() a/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp_sec2
115	{	115	{
116	// We set the base wrapper's style so that baseHeight in layout() will be an unstretched height.	116	// We set the base wrapper's style so that baseHeight in layout() will be an unstretched height.
117	ASSERT(m_baseWrapper && m_baseWrapper->style().hasOneRef());	117	ASSERT(m_baseWrapper && m_baseWrapper->style().hasOneRef());
118	m_baseWrapper->style().setAlignSelf(AlignFlexStart);	118	m_baseWrapper->style().setAlignSelf(ItemPositionFlexStart);
119		119
120	// This sets the style for postscript pairs.	120	// This sets the style for postscript pairs.
121	RenderObject* subSupPair = m_baseWrapper;	121	RenderObject* subSupPair = m_baseWrapper;
Lines 135-141 void RenderMathMLScripts::fixAnonymousStyles() a/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp_sec3
135	RenderStyle& scriptsStyle = subSupPair->style();	135	RenderStyle& scriptsStyle = subSupPair->style();
136	scriptsStyle.setFlexDirection(FlowRow);	136	scriptsStyle.setFlexDirection(FlowRow);
137	scriptsStyle.setJustifyContent(JustifyFlexStart);	137	scriptsStyle.setJustifyContent(JustifyFlexStart);
138	scriptsStyle.setAlignItems(AlignCenter);	138	scriptsStyle.setAlignItems(ItemPositionCenter);
139	scriptsStyle.setOrder(0);	139	scriptsStyle.setOrder(0);
140	scriptsStyle.setFontSize(style().fontSize());	140	scriptsStyle.setFontSize(style().fontSize());
141	}	141	}

Lines 181-192 enum EBoxDirection { BNORMAL, BREVERSE }; a/Source/WebCore/rendering/style/RenderStyleConstants.h_sec1
- a/Source/WebCore/rendering/style/RenderStyleConstants.h -3 / +2 lines
181	// CSS3 Flexbox Properties	181	// CSS3 Flexbox Properties
182		182
183	enum EAlignContent { AlignContentFlexStart, AlignContentFlexEnd, AlignContentCenter, AlignContentSpaceBetween, AlignContentSpaceAround, AlignContentStretch };	183	enum EAlignContent { AlignContentFlexStart, AlignContentFlexEnd, AlignContentCenter, AlignContentSpaceBetween, AlignContentSpaceAround, AlignContentStretch };
184	enum EAlignItems { AlignAuto, AlignFlexStart, AlignFlexEnd, AlignCenter, AlignStretch, AlignBaseline };
185	enum EFlexDirection { FlowRow, FlowRowReverse, FlowColumn, FlowColumnReverse };	184	enum EFlexDirection { FlowRow, FlowRowReverse, FlowColumn, FlowColumnReverse };
186	enum EFlexWrap { FlexNoWrap, FlexWrap, FlexWrapReverse };	185	enum EFlexWrap { FlexNoWrap, FlexWrap, FlexWrapReverse };
187	enum EJustifyContent { JustifyFlexStart, JustifyFlexEnd, JustifyCenter, JustifySpaceBetween, JustifySpaceAround };	186	enum EJustifyContent { JustifyFlexStart, JustifyFlexEnd, JustifyCenter, JustifySpaceBetween, JustifySpaceAround };
188	enum EJustifySelf {JustifySelfAuto, JustifySelfStretch, JustifySelfBaseline, JustifySelfCenter, JustifySelfStart, JustifySelfEnd, JustifySelfSelfStart, JustifySelfSelfEnd, JustifySelfFlexStart, JustifySelfFlexEnd, JustifySelfLeft, JustifySelfRight};	187	enum ItemPosition {ItemPositionAuto, ItemPositionStretch, ItemPositionBaseline, ItemPositionLastBaseline, ItemPositionCenter, ItemPositionStart, ItemPositionEnd, ItemPositionSelfStart, ItemPositionSelfEnd, ItemPositionFlexStart, ItemPositionFlexEnd, ItemPositionLeft, ItemPositionRight};
189	enum EJustifySelfOverflowAlignment {JustifySelfOverflowAlignmentDefault, JustifySelfOverflowAlignmentTrue, JustifySelfOverflowAlignmentSafe};	188	enum OverflowAlignment {OverflowAlignmentDefault, OverflowAlignmentTrue, OverflowAlignmentSafe};
190		189
191		190
192	enum ETextSecurity {	191	enum ETextSecurity {

Lines 80-86 StyleRareNonInheritedData::StyleRareNonInheritedData() a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp_sec1
- a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp +6 lines
80	, m_backfaceVisibility(RenderStyle::initialBackfaceVisibility())	80	, m_backfaceVisibility(RenderStyle::initialBackfaceVisibility())
81	, m_alignContent(RenderStyle::initialAlignContent())	81	, m_alignContent(RenderStyle::initialAlignContent())
82	, m_alignItems(RenderStyle::initialAlignItems())	82	, m_alignItems(RenderStyle::initialAlignItems())
		83	, m_alignItemsOverflowAlignment(RenderStyle::initialAlignItemsOverflowAlignment())
83	, m_alignSelf(RenderStyle::initialAlignSelf())	84	, m_alignSelf(RenderStyle::initialAlignSelf())
		85	, m_alignSelfOverflowAlignment(RenderStyle::initialAlignSelfOverflowAlignment())
84	, m_justifyContent(RenderStyle::initialJustifyContent())	86	, m_justifyContent(RenderStyle::initialJustifyContent())
85	, m_justifySelf(RenderStyle::initialJustifySelf())	87	, m_justifySelf(RenderStyle::initialJustifySelf())
86	, m_justifySelfOverflowAlignment(RenderStyle::initialJustifySelfOverflowAlignment())	88	, m_justifySelfOverflowAlignment(RenderStyle::initialJustifySelfOverflowAlignment())
Lines 164-170 inline StyleRareNonInheritedData::StyleRareNonInheritedData(const StyleRareNonIn a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp_sec2
164	, m_backfaceVisibility(o.m_backfaceVisibility)	166	, m_backfaceVisibility(o.m_backfaceVisibility)
165	, m_alignContent(o.m_alignContent)	167	, m_alignContent(o.m_alignContent)
166	, m_alignItems(o.m_alignItems)	168	, m_alignItems(o.m_alignItems)
		169	, m_alignItemsOverflowAlignment(o.m_alignItemsOverflowAlignment)
167	, m_alignSelf(o.m_alignSelf)	170	, m_alignSelf(o.m_alignSelf)
		171	, m_alignSelfOverflowAlignment(o.m_alignSelfOverflowAlignment)
168	, m_justifyContent(o.m_justifyContent)	172	, m_justifyContent(o.m_justifyContent)
169	, m_justifySelf(o.m_justifySelf)	173	, m_justifySelf(o.m_justifySelf)
170	, m_justifySelfOverflowAlignment(o.m_justifySelfOverflowAlignment)	174	, m_justifySelfOverflowAlignment(o.m_justifySelfOverflowAlignment)
Lines 256-262 bool StyleRareNonInheritedData::operator==(const StyleRareNonInheritedData& o) c a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp_sec3
256	&& m_backfaceVisibility == o.m_backfaceVisibility	260	&& m_backfaceVisibility == o.m_backfaceVisibility
257	&& m_alignContent == o.m_alignContent	261	&& m_alignContent == o.m_alignContent
258	&& m_alignItems == o.m_alignItems	262	&& m_alignItems == o.m_alignItems
		263	&& m_alignItemsOverflowAlignment == o.m_alignItemsOverflowAlignment
259	&& m_alignSelf == o.m_alignSelf	264	&& m_alignSelf == o.m_alignSelf
		265	&& m_alignSelfOverflowAlignment == o.m_alignSelfOverflowAlignment
260	&& m_justifyContent == o.m_justifyContent	266	&& m_justifyContent == o.m_justifyContent
261	&& userDrag == o.userDrag	267	&& userDrag == o.userDrag
262	&& textOverflow == o.textOverflow	268	&& textOverflow == o.textOverflow

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +30 lines
		1	2014-10-27 Javier Fernandez <jfernandez@igalia.com>
		2
		3	[CSS Grid Layout] Upgrade align-self and align-items parsing to CSS 3
		4	https://bugs.webkit.org/show_bug.cgi?id=133359
		5
		6	Reviewed by David Hyatt.
		7
		8	From Blink r164817 and r165264 by <jchaffraix@chromium.org>
		9
		10	Broaden justify-self's parsing name and upgrade align-self and
		11	align-items parsing to CSS 3.
		12
		13	* css3/flexbox/css-properties-expected.txt:
		14	* css3/flexbox/css-properties.html:
		15	* css3/parse-align-items-expected.txt: Added.
		16	* css3/parse-align-items.html: Added.
		17	* css3/parse-align-self-expected.txt: Added.
		18	* css3/parse-align-self.html: Added.
		19	* css3/resources/alignment-parsing-utils.js: Added.
		20	(checkValues):
		21	(checkBadValues):
		22	(checkInitialValues):
		23	(checkInheritValues):
		24	(checkLegacyValues):
		25	* fast/css/getComputedStyle/computed-style-expected.txt:
		26	* fast/css/getComputedStyle/computed-style-without-renderer-expected.txt:
		27	* fast/css/getComputedStyle/resources/property-names.js:
		28	* svg/css/getComputedStyle-basic-expected.txt:
		29	* platform/gtk/TestExpectations: Report new failures and update expectations.
		30
1	2014-10-26 Benjamin Poulain <benjamin@webkit.org>	31	2014-10-26 Benjamin Poulain <benjamin@webkit.org>
2		32
3	Images with usemap should not have a link state	33	Images with usemap should not have a link state

Lines 29-39 PASS window.getComputedStyle(flexbox, null).webkitJustifyContent is "space-betwe a/LayoutTests/css3/flexbox/css-properties-expected.txt_sec1
- a/LayoutTests/css3/flexbox/css-properties-expected.txt -7 / +14 lines
29	PASS flexbox.style.webkitJustifyContent is ""	29	PASS flexbox.style.webkitJustifyContent is ""
30	PASS window.getComputedStyle(flexbox, null).webkitJustifyContent is "flex-start"	30	PASS window.getComputedStyle(flexbox, null).webkitJustifyContent is "flex-start"
31	PASS flexbox.style.webkitAlignSelf is ""	31	PASS flexbox.style.webkitAlignSelf is ""
32	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "stretch"	32	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
33	PASS window.getComputedStyle(document.documentElement, null).webkitAlignSelf is "stretch"	33	PASS window.getComputedStyle(document.documentElement, null).webkitAlignSelf is "auto"
34	PASS flexbox.style.webkitAlignSelf is ""	34	PASS flexbox.style.webkitAlignSelf is ""
		35	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
35	PASS flexbox.style.webkitAlignSelf is "auto"	36	PASS flexbox.style.webkitAlignSelf is "auto"
36	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "stretch"	37	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
37	PASS flexbox.style.webkitAlignSelf is "flex-start"	38	PASS flexbox.style.webkitAlignSelf is "flex-start"
38	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "flex-start"	39	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "flex-start"
39	PASS flexbox.style.webkitAlignSelf is "flex-end"	40	PASS flexbox.style.webkitAlignSelf is "flex-end"
Lines 45-59 PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "stretch" a/LayoutTests/css3/flexbox/css-properties-expected.txt_sec2
45	PASS flexbox.style.webkitAlignSelf is "baseline"	46	PASS flexbox.style.webkitAlignSelf is "baseline"
46	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "baseline"	47	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "baseline"
47	PASS flexbox.style.webkitAlignSelf is ""	48	PASS flexbox.style.webkitAlignSelf is ""
48	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "stretch"	49	PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
49	PASS flexbox.style.webkitAlignItems is ""	50	PASS flexbox.style.webkitAlignItems is ""
		51	PASS flexitem.style.webkitAlignSelf is ""
50	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"	52	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
51	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"	53	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
52	PASS flexbox.style.webkitAlignItems is ""	54	PASS flexbox.style.webkitAlignItems is ""
53	PASS flexbox.style.webkitAlignItems is ""	55	PASS flexitem.style.webkitAlignSelf is ""
		56	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
		57	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
		58	PASS flexbox.style.webkitAlignItems is "auto"
		59	PASS flexitem.style.webkitAlignSelf is ""
54	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"	60	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
55	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"	61	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
56	PASS flexbox.style.webkitAlignItems is "flex-start"	62	PASS flexbox.style.webkitAlignItems is "flex-start"
		63	PASS flexitem.style.webkitAlignSelf is ""
57	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "flex-start"	64	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "flex-start"
58	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "flex-start"	65	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "flex-start"
59	PASS flexbox.style.webkitAlignItems is "flex-end"	66	PASS flexbox.style.webkitAlignItems is "flex-end"
Lines 72-79 PASS flexbox.style.webkitAlignItems is "" a/LayoutTests/css3/flexbox/css-properties-expected.txt_sec3
72	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"	79	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"
73	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"	80	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
74	PASS flexbox.style.webkitAlignItems is ""	81	PASS flexbox.style.webkitAlignItems is ""
75	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "stretch"	82	PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "start"
76	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"	83	PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "start"
77	PASS window.getComputedStyle(detachedFlexbox, null).webkitAlignSelf is ""	84	PASS window.getComputedStyle(detachedFlexbox, null).webkitAlignSelf is ""
78	PASS window.getComputedStyle(detachedFlexItem, null).webkitAlignSelf is ""	85	PASS window.getComputedStyle(detachedFlexItem, null).webkitAlignSelf is ""
79	PASS flexbox.style.webkitFlexDirection is ""	86	PASS flexbox.style.webkitFlexDirection is ""

Lines 78-95 flexbox.style.webkitJustifyContent = ''; a/LayoutTests/css3/flexbox/css-properties.html_sec1
- a/LayoutTests/css3/flexbox/css-properties.html -9 / +17 lines
78	shouldBeEqualToString('flexbox.style.webkitJustifyContent', '');	78	shouldBeEqualToString('flexbox.style.webkitJustifyContent', '');
79	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitJustifyContent', 'flex-start');	79	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitJustifyContent', 'flex-start');
80		80
		81	flexbox.style.display = '-webkit-flex';
81		82
82	shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');	83	shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
83	// The initial value is 'stretch'.	84	// The initial value is 'auto', which will be resolved depending on parent's style (except for the 'document' element).
84	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'stretch');	85	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');
85	shouldBeEqualToString('window.getComputedStyle(document.documentElement, null).webkitAlignSelf', 'stretch');	86	shouldBeEqualToString('window.getComputedStyle(document.documentElement, null).webkitAlignSelf', 'auto');
86		87
87	flexbox.style.webkitAlignSelf = 'foo';	88	flexbox.style.webkitAlignSelf = 'foo';
88	shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');	89	shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
		90	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');
89		91
90	flexbox.style.webkitAlignSelf = 'auto';	92	flexbox.style.webkitAlignSelf = 'auto';
91	shouldBeEqualToString('flexbox.style.webkitAlignSelf', 'auto');	93	shouldBeEqualToString('flexbox.style.webkitAlignSelf', 'auto');
92	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'stretch');	94	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');
93		95
94	flexbox.style.webkitAlignSelf = 'flex-start';	96	flexbox.style.webkitAlignSelf = 'flex-start';
95	shouldBeEqualToString('flexbox.style.webkitAlignSelf', 'flex-start');	97	shouldBeEqualToString('flexbox.style.webkitAlignSelf', 'flex-start');
Lines 113-135 shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', a/LayoutTests/css3/flexbox/css-properties.html_sec2
113		115
114	flexbox.style.webkitAlignSelf = '';	116	flexbox.style.webkitAlignSelf = '';
115	shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');	117	shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
116	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'stretch');	118	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');
117		119
118	shouldBeEqualToString('flexbox.style.webkitAlignItems', '');	120	shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
119	// The initial value is 'stretch'.	121	shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
		122	// The initial value is 'auto', which will be resolved to 'stretch' in case of flexbox containers.
120	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');	123	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');
121	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');	124	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');
122		125
123	flexbox.style.webkitAlignItems = 'foo';	126	flexbox.style.webkitAlignItems = 'foo';
124	shouldBeEqualToString('flexbox.style.webkitAlignItems', '');	127	shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
		128	shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
		129	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');
		130	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');
125		131
126	flexbox.style.webkitAlignItems = 'auto';	132	flexbox.style.webkitAlignItems = 'auto';
127	shouldBeEqualToString('flexbox.style.webkitAlignItems', '');	133	shouldBeEqualToString('flexbox.style.webkitAlignItems', 'auto');
		134	shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
128	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');	135	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');
129	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');	136	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');
130		137
131	flexbox.style.webkitAlignItems = 'flex-start';	138	flexbox.style.webkitAlignItems = 'flex-start';
132	shouldBeEqualToString('flexbox.style.webkitAlignItems', 'flex-start');	139	shouldBeEqualToString('flexbox.style.webkitAlignItems', 'flex-start');
		140	shouldBeEqualToString('flexitem.style.webkitAlignSelf', '');
133	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'flex-start');	141	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'flex-start');
134	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'flex-start');	142	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'flex-start');
135		143
Lines 160-167 shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', a/LayoutTests/css3/flexbox/css-properties.html_sec3
160		168
161	flexbox.style.display = 'none';	169	flexbox.style.display = 'none';
162	shouldBeEqualToString('flexbox.style.webkitAlignItems', '');	170	shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
163	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');	171	shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'start');
164	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');	172	shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'start');
165	flexbox.style.display = '';	173	flexbox.style.display = '';
166		174
167		175

Line 0 a/LayoutTests/css3/parse-align-items-expected.txt_sec1
- a/LayoutTests/css3/parse-align-items-expected.txt +137 lines
		1	Test that setting and getting align-items works as expected
		2
		3	On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
		4
		5
		6	Test getting align-items set through CSS
		7	PASS getComputedStyle(alignItemsBaseline, '').getPropertyValue('-webkit-align-items') is 'baseline'
		8	PASS getComputedStyle(alignItemsLastBaseline, '').getPropertyValue('-webkit-align-items') is 'last-baseline'
		9	PASS getComputedStyle(alignItemsStretch, '').getPropertyValue('-webkit-align-items') is 'stretch'
		10	PASS getComputedStyle(alignItemsStart, '').getPropertyValue('-webkit-align-items') is 'start'
		11	PASS getComputedStyle(alignItemsEnd, '').getPropertyValue('-webkit-align-items') is 'end'
		12	PASS getComputedStyle(alignItemsCenter, '').getPropertyValue('-webkit-align-items') is 'center'
		13	PASS getComputedStyle(alignItemsSelfEnd, '').getPropertyValue('-webkit-align-items') is 'self-end'
		14	PASS getComputedStyle(alignItemsSelfStart, '').getPropertyValue('-webkit-align-items') is 'self-start'
		15	PASS getComputedStyle(alignItemsLeft, '').getPropertyValue('-webkit-align-items') is 'left'
		16	PASS getComputedStyle(alignItemsRight, '').getPropertyValue('-webkit-align-items') is 'right'
		17	PASS getComputedStyle(alignItemsFlexStart, '').getPropertyValue('-webkit-align-items') is 'flex-start'
		18	PASS getComputedStyle(alignItemsFlexEnd, '').getPropertyValue('-webkit-align-items') is 'flex-end'
		19	PASS getComputedStyle(alignItemsEndTrue, '').getPropertyValue('-webkit-align-items') is 'end true'
		20	PASS getComputedStyle(alignItemsCenterTrue, '').getPropertyValue('-webkit-align-items') is 'center true'
		21	PASS getComputedStyle(alignItemsSelfEndSafe, '').getPropertyValue('-webkit-align-items') is 'self-end safe'
		22	PASS getComputedStyle(alignItemsSelfStartSafe, '').getPropertyValue('-webkit-align-items') is 'self-start safe'
		23	PASS getComputedStyle(alignItemsRightSafe, '').getPropertyValue('-webkit-align-items') is 'right safe'
		24	PASS getComputedStyle(alignItemsLeftTrue, '').getPropertyValue('-webkit-align-items') is 'left true'
		25	PASS getComputedStyle(alignItemsFlexStartTrue, '').getPropertyValue('-webkit-align-items') is 'flex-start true'
		26	PASS getComputedStyle(alignItemsFlexEndSafe, '').getPropertyValue('-webkit-align-items') is 'flex-end safe'
		27
		28	Test initial value of align-items through JS
		29	PASS getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is 'start'
		30
		31	Test getting and setting align-items through JS
		32	PASS element.style.webkitAlignItems is "center"
		33	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center"
		34	PASS element.style.webkitAlignItems is "start true"
		35	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start true"
		36	PASS element.style.webkitAlignItems is "flex-end safe"
		37	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "flex-end safe"
		38	PASS element.style.webkitAlignItems is "right"
		39	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "right"
		40	PASS element.style.webkitAlignItems is "center"
		41	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center"
		42	PASS element.style.webkitAlignItems is "self-start"
		43	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "self-start"
		44	PASS element.style.webkitAlignItems is "auto"
		45	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
		46	PASS element.style.webkitAlignItems is "auto"
		47	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
		48	PASS element.style.webkitAlignItems is "auto"
		49	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
		50	PASS element.style.webkitAlignItems is "self-end"
		51	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "self-end"
		52
		53	Test bad combinations of align-items
		54	PASS element.style.webkitAlignItems is ""
		55	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
		56	PASS element.style.webkitAlignItems is ""
		57	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
		58	PASS element.style.webkitAlignItems is ""
		59	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
		60	PASS element.style.webkitAlignItems is ""
		61	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
		62	PASS element.style.webkitAlignItems is ""
		63	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
		64	PASS element.style.webkitAlignItems is ""
65	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
66	PASS element.style.webkitAlignItems is ""
67	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
68	PASS element.style.webkitAlignItems is ""
69	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
70	PASS element.style.webkitAlignItems is ""
71	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
72	PASS element.style.webkitAlignItems is ""
73	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
74	PASS element.style.webkitAlignItems is ""
75	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
76	PASS element.style.webkitAlignItems is ""
77	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
78	PASS element.style.webkitAlignItems is ""
79	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
80	PASS element.style.webkitAlignItems is ""
81	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
82	PASS element.style.webkitAlignItems is ""
83	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
84	PASS element.style.webkitAlignItems is ""
85	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
86	PASS element.style.webkitAlignItems is ""
87	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
88	PASS element.style.webkitAlignItems is ""
89	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
90	PASS element.style.webkitAlignItems is ""
91	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
92	PASS element.style.webkitAlignItems is ""
93	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
94	PASS element.style.webkitAlignItems is ""
95	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
96	PASS element.style.webkitAlignItems is ""
97	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
98	PASS element.style.webkitAlignItems is ""
99	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
100	PASS element.style.webkitAlignItems is ""
101	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
102
103	Test the value 'initial'
104	PASS element.style.webkitAlignItems is "center"
105	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center"
106	PASS element.style.webkitAlignItems is "initial"
107	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "start"
108
109	Test the value 'initial' for grid containers
110	PASS element.style.webkitAlignItems is "left safe"
111	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
112	PASS element.style.webkitAlignItems is "initial"
113	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
114
115	Test the value 'initial' for flex containers
116	PASS element.style.webkitAlignItems is "right true"
117	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "right true"
118	PASS element.style.webkitAlignItems is "initial"
119	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "stretch"
120
121	Test the value 'inherit'
122	PASS element.style.webkitAlignItems is "end"
123	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "end"
124	PASS element.style.webkitAlignItems is "inherit"
125	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "end"
126	PASS element.style.webkitAlignItems is "left safe"
127	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
128	PASS element.style.webkitAlignItems is "inherit"
129	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "left safe"
130	PASS element.style.webkitAlignItems is "center true"
131	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center true"
132	PASS element.style.webkitAlignItems is "inherit"
133	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-items') is "center true"
134	PASS successfullyParsed is true
135
136	TEST COMPLETE
137

Line 0 a/LayoutTests/css3/parse-align-items.html_sec1
- a/LayoutTests/css3/parse-align-items.html +270 lines
		1	<!DOCTYPE html>
		2	<html>
		3	<head>
		4	<style>
		5	#alignItemsBaseline {
		6	-webkit-align-items: baseline;
		7	}
		8
		9	#alignItemsLastBaseline {
		10	-webkit-align-items: last-baseline;
		11	}
		12
		13	#alignItemsStretch {
		14	-webkit-align-items: stretch;
		15	}
		16
		17	#alignItemsStart {
		18	-webkit-align-items: start;
		19	}
		20
		21	#alignItemsEnd {
		22	-webkit-align-items: end;
		23	}
		24
		25	#alignItemsCenter {
		26	-webkit-align-items: center;
		27	}
		28
		29	#alignItemsSelfStart {
		30	-webkit-align-items: self-start;
		31	}
		32
		33	#alignItemsSelfEnd {
		34	-webkit-align-items: self-end;
		35	}
		36
		37	#alignItemsLeft {
		38	-webkit-align-items: left;
		39	}
		40
		41	#alignItemsRight {
		42	-webkit-align-items: right;
		43	}
		44
		45	#alignItemsFlexStart {
		46	-webkit-align-items: flex-start;
		47	}
		48
		49	#alignItemsFlexEnd {
		50	-webkit-align-items: flex-end;
		51	}
		52
		53	#alignItemsEndTrue {
		54	-webkit-align-items: end true;
		55	}
		56
		57	#alignItemsCenterTrue {
		58	-webkit-align-items: center true;
		59	}
		60
		61	#alignItemsSelfEndSafe {
		62	-webkit-align-items: self-end safe;
		63	}
		64
65	#alignItemsSelfStartSafe {
66	-webkit-align-items: self-start safe;
67	}
68
69	#alignItemsRightSafe {
70	-webkit-align-items: right safe;
71	}
72
73	#alignItemsLeftTrue {
74	-webkit-align-items: left true;
75	}
76
77	#alignItemsFlexStartTrue {
78	-webkit-align-items: flex-start true;
79	}
80
81	#alignItemsFlexEndSafe {
82	-webkit-align-items: flex-end safe;
83	}
84
85	</style>
86	<script src="../resources/js-test.js"></script>
87	</head>
88	<body>
89	<div id="alignItemsBaseline"></div>
90	<div id="alignItemsLastBaseline"></div>
91	<div id="alignItemsStretch"></div>
92	<div id="alignItemsStart"></div>
93	<div id="alignItemsEnd"></div>
94	<div id="alignItemsCenter"></div>
95	<div id="alignItemsSelfStart"></div>
96	<div id="alignItemsSelfEnd"></div>
97	<div id="alignItemsLeft"></div>
98	<div id="alignItemsRight"></div>
99	<div id="alignItemsFlexStart"></div>
100	<div id="alignItemsFlexEnd"></div>
101
102	<div id="alignItemsEndTrue"></div>
103	<div id="alignItemsCenterTrue"></div>
104	<div id="alignItemsSelfEndSafe"></div>
105	<div id="alignItemsSelfStartSafe"></div>
106	<div id="alignItemsRightSafe"></div>
107	<div id="alignItemsLeftTrue"></div>
108	<div id="alignItemsFlexStartTrue"></div>
109	<div id="alignItemsFlexEndSafe"></div>
110	<script src="resources/alignment-parsing-utils.js"></script>
111	<script>
112	description('Test that setting and getting align-items works as expected');
113
114	debug("Test getting align-items set through CSS");
115	var alignItemsBaseline = document.getElementById("alignItemsBaseline");
116	shouldBe("getComputedStyle(alignItemsBaseline, '').getPropertyValue('-webkit-align-items')", "'baseline'");
117
118	var alignItemsLastBaseline = document.getElementById("alignItemsLastBaseline");
119	shouldBe("getComputedStyle(alignItemsLastBaseline, '').getPropertyValue('-webkit-align-items')", "'last-baseline'");
120
121	var alignItemsStretch = document.getElementById("alignItemsStretch");
122	shouldBe("getComputedStyle(alignItemsStretch, '').getPropertyValue('-webkit-align-items')", "'stretch'");
123
124	var alignItemsStart = document.getElementById("alignItemsStart");
125	shouldBe("getComputedStyle(alignItemsStart, '').getPropertyValue('-webkit-align-items')", "'start'");
126
127	var alignItemsEnd = document.getElementById("alignItemsEnd");
128	shouldBe("getComputedStyle(alignItemsEnd, '').getPropertyValue('-webkit-align-items')", "'end'");
129
130	var alignItemsCenter = document.getElementById("alignItemsCenter");
131	shouldBe("getComputedStyle(alignItemsCenter, '').getPropertyValue('-webkit-align-items')", "'center'");
132
133	var alignItemsSelfEnd = document.getElementById("alignItemsSelfEnd");
134	shouldBe("getComputedStyle(alignItemsSelfEnd, '').getPropertyValue('-webkit-align-items')", "'self-end'");
135
136	var alignItemsSelfStart = document.getElementById("alignItemsSelfStart");
137	shouldBe("getComputedStyle(alignItemsSelfStart, '').getPropertyValue('-webkit-align-items')", "'self-start'");
138
139	var alignItemsLeft = document.getElementById("alignItemsLeft");
140	shouldBe("getComputedStyle(alignItemsLeft, '').getPropertyValue('-webkit-align-items')", "'left'");
141
142	var alignItemsRight = document.getElementById("alignItemsRight");
143	shouldBe("getComputedStyle(alignItemsRight, '').getPropertyValue('-webkit-align-items')", "'right'");
144
145	var alignItemsFlexStart = document.getElementById("alignItemsFlexStart");
146	shouldBe("getComputedStyle(alignItemsFlexStart, '').getPropertyValue('-webkit-align-items')", "'flex-start'");
147
148	var alignItemsFlexEnd = document.getElementById("alignItemsFlexEnd");
149	shouldBe("getComputedStyle(alignItemsFlexEnd, '').getPropertyValue('-webkit-align-items')", "'flex-end'");
150
151	var alignItemsEndTrue = document.getElementById("alignItemsEndTrue");
152	shouldBe("getComputedStyle(alignItemsEndTrue, '').getPropertyValue('-webkit-align-items')", "'end true'");
153
154	var alignItemsCenterTrue = document.getElementById("alignItemsCenterTrue");
155	shouldBe("getComputedStyle(alignItemsCenterTrue, '').getPropertyValue('-webkit-align-items')", "'center true'");
156
157	var alignItemsSelfEndSafe = document.getElementById("alignItemsSelfEndSafe");
158	shouldBe("getComputedStyle(alignItemsSelfEndSafe, '').getPropertyValue('-webkit-align-items')", "'self-end safe'");
159
160	var alignItemsSelfStartSafe = document.getElementById("alignItemsSelfStartSafe");
161	shouldBe("getComputedStyle(alignItemsSelfStartSafe, '').getPropertyValue('-webkit-align-items')", "'self-start safe'");
162
163	var alignItemsRightSafe = document.getElementById("alignItemsRightSafe");
164	shouldBe("getComputedStyle(alignItemsRightSafe, '').getPropertyValue('-webkit-align-items')", "'right safe'");
165
166	var alignItemsLeftTrue = document.getElementById("alignItemsLeftTrue");
167	shouldBe("getComputedStyle(alignItemsLeftTrue, '').getPropertyValue('-webkit-align-items')", "'left true'");
168
169	var alignItemsFlexStartTrue = document.getElementById("alignItemsFlexStartTrue");
170	shouldBe("getComputedStyle(alignItemsFlexStartTrue, '').getPropertyValue('-webkit-align-items')", "'flex-start true'");
171
172	var alignItemsFlexEndSafe = document.getElementById("alignItemsFlexEndSafe");
173	shouldBe("getComputedStyle(alignItemsFlexEndSafe, '').getPropertyValue('-webkit-align-items')", "'flex-end safe'");
174
175	debug("");
176	debug("Test initial value of align-items through JS");
177	element = document.createElement("div");
178	document.body.appendChild(element);
179	shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-align-items')", "'start'");
180
181	debug("");
182	debug("Test getting and setting align-items through JS");
183	element = document.createElement("div");
184	document.body.appendChild(element);
185	element.style.webkitAlignItems = "center";
186	checkValues(element, "webkitAlignItems", "-webkit-align-items", "center", "center");
187
188	element.style.webkitAlignItems = "true start";
189	checkValues(element, "webkitAlignItems", "-webkit-align-items", "start true", "start true");
190
191	element.style.webkitAlignItems = "flex-end safe";
192	checkValues(element, "webkitAlignItems", "-webkit-align-items", "flex-end safe", "flex-end safe");
193
194	element.style.webkitAlignItems = "right";
195	checkValues(element, "webkitAlignItems", "-webkit-align-items", "right", "right");
196
197	element.style.webkitAlignItems = "center";
198	checkValues(element, "webkitAlignItems", "-webkit-align-items", "center", "center");
199
200	element.style.webkitAlignItems = "self-start";
201	checkValues(element, "webkitAlignItems", "-webkit-align-items", "self-start", "self-start");
202
203	element.style.webkitAlignItems = "auto";
204	checkValues(element, "webkitAlignItems", "-webkit-align-items", "auto", "start");
205
206	element.style.display = "-webkit-flex";
207	element.style.webkitAlignItems = "auto";
208	checkValues(element, "webkitAlignItems", "-webkit-align-items", "auto", "stretch");
209
210	element.style.display = "-webkit-grid";
211	element.style.webkitAlignItems = "auto";
212	checkValues(element, "webkitAlignItems", "-webkit-align-items", "auto", "stretch");
213
214	element.style.webkitAlignItems = "self-end";
215	checkValues(element, "webkitAlignItems", "-webkit-align-items", "self-end", "self-end");
216
217	debug("");
218	debug("Test bad combinations of align-items");
219	element = document.createElement("div");
220	document.body.appendChild(element);
221
222	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "true auto");
223	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "auto safe");
224	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "auto left");
225	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "baseline safe");
226	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "baseline center");
227	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "stretch true");
228	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "stretch right");
229	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "true true");
230	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "true safe");
231	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "center start");
232	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "stretch true");
233	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "safe stretch");
234	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "baseline safe");
235	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "true baseline");
236	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "true safe left");
237	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "true left safe");
238	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "left safe true safe");
239	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "legacy start");
240	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "legacy end");
241	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "legacy right true");
242	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "legacy auto");
243	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "legacy stretch");
244	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "legacy");
245	checkBadValues(element, "webkitAlignItems", "-webkit-align-items", "legacy left right");
246
247	debug("");
248	debug("Test the value 'initial'");
249	element.style.display = "";
250	checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "center", "start");
251
252	debug("");
253	debug("Test the value 'initial' for grid containers");
254	element.style.display = "-webkit-grid";
255	checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "left safe", "stretch");
256
257	debug("");
258	debug("Test the value 'initial' for flex containers");
259	element.style.display = "-webkit-flex";
260	checkInitialValues(element, "webkitAlignItems", "-webkit-align-items", "right true", "stretch");
261
262	debug("");
263	debug("Test the value 'inherit'");
264	checkInheritValues("webkitAlignItems", "-webkit-align-items", "end");
265	checkInheritValues("webkitAlignItems", "-webkit-align-items", "left safe");
266	checkInheritValues("webkitAlignItems", "-webkit-align-items", "center true");
267
268	</script>
269	</body>
270	</html>

Line 0 a/LayoutTests/css3/parse-align-self-expected.txt_sec1
- a/LayoutTests/css3/parse-align-self-expected.txt +155 lines
		1	Test that setting and getting align-self works as expected
		2
		3	On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
		4
		5
		6	Test getting align-self set through CSS
		7	PASS getComputedStyle(alignSelfBaseline, '').getPropertyValue('-webkit-align-self') is 'baseline'
		8	PASS getComputedStyle(alignSelfLastBaseline, '').getPropertyValue('-webkit-align-self') is 'last-baseline'
		9	PASS getComputedStyle(alignSelfStretch, '').getPropertyValue('-webkit-align-self') is 'stretch'
		10	PASS getComputedStyle(alignSelfStart, '').getPropertyValue('-webkit-align-self') is 'start'
		11	PASS getComputedStyle(alignSelfEnd, '').getPropertyValue('-webkit-align-self') is 'end'
		12	PASS getComputedStyle(alignSelfCenter, '').getPropertyValue('-webkit-align-self') is 'center'
		13	PASS getComputedStyle(alignSelfSelfEnd, '').getPropertyValue('-webkit-align-self') is 'self-end'
		14	PASS getComputedStyle(alignSelfSelfStart, '').getPropertyValue('-webkit-align-self') is 'self-start'
		15	PASS getComputedStyle(alignSelfLeft, '').getPropertyValue('-webkit-align-self') is 'left'
		16	PASS getComputedStyle(alignSelfRight, '').getPropertyValue('-webkit-align-self') is 'right'
		17	PASS getComputedStyle(alignSelfFlexStart, '').getPropertyValue('-webkit-align-self') is 'flex-start'
		18	PASS getComputedStyle(alignSelfFlexEnd, '').getPropertyValue('-webkit-align-self') is 'flex-end'
		19	PASS getComputedStyle(alignSelfEndTrue, '').getPropertyValue('-webkit-align-self') is 'end true'
		20	PASS getComputedStyle(alignSelfCenterTrue, '').getPropertyValue('-webkit-align-self') is 'center true'
		21	PASS getComputedStyle(alignSelfSelfEndSafe, '').getPropertyValue('-webkit-align-self') is 'self-end safe'
		22	PASS getComputedStyle(alignSelfSelfStartSafe, '').getPropertyValue('-webkit-align-self') is 'self-start safe'
		23	PASS getComputedStyle(alignSelfRightSafe, '').getPropertyValue('-webkit-align-self') is 'right safe'
		24	PASS getComputedStyle(alignSelfLeftTrue, '').getPropertyValue('-webkit-align-self') is 'left true'
		25	PASS getComputedStyle(alignSelfFlexStartTrue, '').getPropertyValue('-webkit-align-self') is 'flex-start true'
		26	PASS getComputedStyle(alignSelfFlexEndSafe, '').getPropertyValue('-webkit-align-self') is 'flex-end safe'
		27
		28	Test initial value of align-self through JS
		29	PASS getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is 'start'
		30
		31	Test getting and setting align-self through JS
		32	PASS element.style.webkitAlignSelf is "center"
		33	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center"
		34	PASS element.style.webkitAlignSelf is "start true"
		35	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start true"
		36	PASS element.style.webkitAlignSelf is "flex-end safe"
		37	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "flex-end safe"
		38	PASS element.style.webkitAlignSelf is "right"
		39	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right"
		40	PASS element.style.webkitAlignSelf is "center"
		41	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center"
		42	PASS element.style.webkitAlignSelf is "self-start"
		43	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "self-start"
		44	PASS element.style.webkitAlignSelf is "auto"
		45	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
		46	PASS element.style.webkitAlignSelf is "auto"
		47	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
		48	PASS element.style.webkitAlignSelf is "auto"
		49	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
		50	PASS element.style.webkitAlignSelf is "self-end"
		51	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "self-end"
		52
		53	Test bad combinations of align-self
		54	PASS element.style.webkitAlignSelf is ""
		55	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
		56	PASS element.style.webkitAlignSelf is ""
		57	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
		58	PASS element.style.webkitAlignSelf is ""
		59	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
		60	PASS element.style.webkitAlignSelf is ""
		61	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
		62	PASS element.style.webkitAlignSelf is ""
		63	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
		64	PASS element.style.webkitAlignSelf is ""
65	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
66	PASS element.style.webkitAlignSelf is ""
67	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
68	PASS element.style.webkitAlignSelf is ""
69	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
70	PASS element.style.webkitAlignSelf is ""
71	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
72	PASS element.style.webkitAlignSelf is ""
73	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
74	PASS element.style.webkitAlignSelf is ""
75	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
76	PASS element.style.webkitAlignSelf is ""
77	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
78	PASS element.style.webkitAlignSelf is ""
79	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
80	PASS element.style.webkitAlignSelf is ""
81	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
82	PASS element.style.webkitAlignSelf is ""
83	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
84	PASS element.style.webkitAlignSelf is ""
85	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
86	PASS element.style.webkitAlignSelf is ""
87	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
88	PASS element.style.webkitAlignSelf is ""
89	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
90	PASS element.style.webkitAlignSelf is ""
91	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
92	PASS element.style.webkitAlignSelf is ""
93	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
94	PASS element.style.webkitAlignSelf is ""
95	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
96	PASS element.style.webkitAlignSelf is ""
97	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
98	PASS element.style.webkitAlignSelf is ""
99	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
100	PASS element.style.webkitAlignSelf is ""
101	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
102
103	Test the value 'initial'
104	PASS element.style.webkitAlignSelf is "center"
105	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center"
106	PASS element.style.webkitAlignSelf is "initial"
107	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "start"
108
109	Test the value 'initial' for grid containers
110	PASS element.style.webkitAlignSelf is "left safe"
111	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
112	PASS element.style.webkitAlignSelf is "initial"
113	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
114
115	Test the value 'initial' for flex containers
116	PASS element.style.webkitAlignSelf is "right true"
117	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right true"
118	PASS element.style.webkitAlignSelf is "initial"
119	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
120
121	Test the value 'initial' for positioned elements
122	PASS element.style.webkitAlignSelf is "left"
123	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left"
124	PASS element.style.webkitAlignSelf is "initial"
125	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
126
127	Test the value 'initial' for positioned elements in grid containers
128	PASS element.style.webkitAlignSelf is "right"
129	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "right"
130	PASS element.style.webkitAlignSelf is "initial"
131	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
132
133	Test the value 'initial' for positioned elements in grid containers
134	PASS element.style.webkitAlignSelf is "end"
135	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "end"
136	PASS element.style.webkitAlignSelf is "initial"
137	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "stretch"
138
139	Test the value 'inherit'
140	PASS element.style.webkitAlignSelf is "end"
141	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "end"
142	PASS element.style.webkitAlignSelf is "inherit"
143	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "end"
144	PASS element.style.webkitAlignSelf is "left safe"
145	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
146	PASS element.style.webkitAlignSelf is "inherit"
147	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "left safe"
148	PASS element.style.webkitAlignSelf is "center true"
149	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center true"
150	PASS element.style.webkitAlignSelf is "inherit"
151	PASS window.getComputedStyle(element, '').getPropertyValue('-webkit-align-self') is "center true"
152	PASS successfullyParsed is true
153
154	TEST COMPLETE
155

Line 0 a/LayoutTests/css3/parse-align-self.html_sec1
- a/LayoutTests/css3/parse-align-self.html +291 lines
		1	<!DOCTYPE html>
		2	<html>
		3	<head>
		4	<style>
		5	#alignSelfBaseline {
		6	-webkit-align-self: baseline;
		7	}
		8
		9	#alignSelfLastBaseline {
		10	-webkit-align-self: last-baseline;
		11	}
		12
		13	#alignSelfStretch {
		14	-webkit-align-self: stretch;
		15	}
		16
		17	#alignSelfStart {
		18	-webkit-align-self: start;
		19	}
		20
		21	#alignSelfEnd {
		22	-webkit-align-self: end;
		23	}
		24
		25	#alignSelfCenter {
		26	-webkit-align-self: center;
		27	}
		28
		29	#alignSelfSelfStart {
		30	-webkit-align-self: self-start;
		31	}
		32
		33	#alignSelfSelfEnd {
		34	-webkit-align-self: self-end;
		35	}
		36
		37	#alignSelfLeft {
		38	-webkit-align-self: left;
		39	}
		40
		41	#alignSelfRight {
		42	-webkit-align-self: right;
		43	}
		44
		45	#alignSelfFlexStart {
		46	-webkit-align-self: flex-start;
		47	}
		48
		49	#alignSelfFlexEnd {
		50	-webkit-align-self: flex-end;
		51	}
		52
		53	#alignSelfEndTrue {
		54	-webkit-align-self: end true;
		55	}
		56
		57	#alignSelfCenterTrue {
		58	-webkit-align-self: center true;
		59	}
		60
		61	#alignSelfSelfEndSafe {
		62	-webkit-align-self: self-end safe;
		63	}
		64
65	#alignSelfSelfStartSafe {
66	-webkit-align-self: self-start safe;
67	}
68
69	#alignSelfRightSafe {
70	-webkit-align-self: right safe;
71	}
72
73	#alignSelfLeftTrue {
74	-webkit-align-self: left true;
75	}
76
77	#alignSelfFlexStartTrue {
78	-webkit-align-self: flex-start true;
79	}
80
81	#alignSelfFlexEndSafe {
82	-webkit-align-self: flex-end safe;
83	}
84	</style>
85	<script src="../resources/js-test.js"></script>
86	</head>
87	<body>
88	<div id="alignSelfBaseline"></div>
89	<div id="alignSelfLastBaseline"></div>
90	<div id="alignSelfStretch"></div>
91	<div id="alignSelfStart"></div>
92	<div id="alignSelfEnd"></div>
93	<div id="alignSelfCenter"></div>
94	<div id="alignSelfSelfStart"></div>
95	<div id="alignSelfSelfEnd"></div>
96	<div id="alignSelfLeft"></div>
97	<div id="alignSelfRight"></div>
98	<div id="alignSelfFlexStart"></div>
99	<div id="alignSelfFlexEnd"></div>
100
101	<div id="alignSelfEndTrue"></div>
102	<div id="alignSelfCenterTrue"></div>
103	<div id="alignSelfSelfEndSafe"></div>
104	<div id="alignSelfSelfStartSafe"></div>
105	<div id="alignSelfRightSafe"></div>
106	<div id="alignSelfLeftTrue"></div>
107	<div id="alignSelfFlexStartTrue"></div>
108	<div id="alignSelfFlexEndSafe"></div>
109	<script src="resources/alignment-parsing-utils.js"></script>
110	<script>
111	description('Test that setting and getting align-self works as expected');
112
113	debug("Test getting align-self set through CSS");
114	var alignSelfBaseline = document.getElementById("alignSelfBaseline");
115	shouldBe("getComputedStyle(alignSelfBaseline, '').getPropertyValue('-webkit-align-self')", "'baseline'");
116
117	var alignSelfLastBaseline = document.getElementById("alignSelfLastBaseline");
118	shouldBe("getComputedStyle(alignSelfLastBaseline, '').getPropertyValue('-webkit-align-self')", "'last-baseline'");
119
120	var alignSelfStretch = document.getElementById("alignSelfStretch");
121	shouldBe("getComputedStyle(alignSelfStretch, '').getPropertyValue('-webkit-align-self')", "'stretch'");
122
123	var alignSelfStart = document.getElementById("alignSelfStart");
124	shouldBe("getComputedStyle(alignSelfStart, '').getPropertyValue('-webkit-align-self')", "'start'");
125
126	var alignSelfEnd = document.getElementById("alignSelfEnd");
127	shouldBe("getComputedStyle(alignSelfEnd, '').getPropertyValue('-webkit-align-self')", "'end'");
128
129	var alignSelfCenter = document.getElementById("alignSelfCenter");
130	shouldBe("getComputedStyle(alignSelfCenter, '').getPropertyValue('-webkit-align-self')", "'center'");
131
132	var alignSelfSelfEnd = document.getElementById("alignSelfSelfEnd");
133	shouldBe("getComputedStyle(alignSelfSelfEnd, '').getPropertyValue('-webkit-align-self')", "'self-end'");
134
135	var alignSelfSelfStart = document.getElementById("alignSelfSelfStart");
136	shouldBe("getComputedStyle(alignSelfSelfStart, '').getPropertyValue('-webkit-align-self')", "'self-start'");
137
138	var alignSelfLeft = document.getElementById("alignSelfLeft");
139	shouldBe("getComputedStyle(alignSelfLeft, '').getPropertyValue('-webkit-align-self')", "'left'");
140
141	var alignSelfRight = document.getElementById("alignSelfRight");
142	shouldBe("getComputedStyle(alignSelfRight, '').getPropertyValue('-webkit-align-self')", "'right'");
143
144	var alignSelfFlexStart = document.getElementById("alignSelfFlexStart");
145	shouldBe("getComputedStyle(alignSelfFlexStart, '').getPropertyValue('-webkit-align-self')", "'flex-start'");
146
147	var alignSelfFlexEnd = document.getElementById("alignSelfFlexEnd");
148	shouldBe("getComputedStyle(alignSelfFlexEnd, '').getPropertyValue('-webkit-align-self')", "'flex-end'");
149
150	var alignSelfEndTrue = document.getElementById("alignSelfEndTrue");
151	shouldBe("getComputedStyle(alignSelfEndTrue, '').getPropertyValue('-webkit-align-self')", "'end true'");
152
153	var alignSelfCenterTrue = document.getElementById("alignSelfCenterTrue");
154	shouldBe("getComputedStyle(alignSelfCenterTrue, '').getPropertyValue('-webkit-align-self')", "'center true'");
155
156	var alignSelfSelfEndSafe = document.getElementById("alignSelfSelfEndSafe");
157	shouldBe("getComputedStyle(alignSelfSelfEndSafe, '').getPropertyValue('-webkit-align-self')", "'self-end safe'");
158
159	var alignSelfSelfStartSafe = document.getElementById("alignSelfSelfStartSafe");
160	shouldBe("getComputedStyle(alignSelfSelfStartSafe, '').getPropertyValue('-webkit-align-self')", "'self-start safe'");
161
162	var alignSelfRightSafe = document.getElementById("alignSelfRightSafe");
163	shouldBe("getComputedStyle(alignSelfRightSafe, '').getPropertyValue('-webkit-align-self')", "'right safe'");
164
165	var alignSelfLeftTrue = document.getElementById("alignSelfLeftTrue");
166	shouldBe("getComputedStyle(alignSelfLeftTrue, '').getPropertyValue('-webkit-align-self')", "'left true'");
167
168	var alignSelfFlexStartTrue = document.getElementById("alignSelfFlexStartTrue");
169	shouldBe("getComputedStyle(alignSelfFlexStartTrue, '').getPropertyValue('-webkit-align-self')", "'flex-start true'");
170
171	var alignSelfFlexEndSafe = document.getElementById("alignSelfFlexEndSafe");
172	shouldBe("getComputedStyle(alignSelfFlexEndSafe, '').getPropertyValue('-webkit-align-self')", "'flex-end safe'");
173
174	debug("");
175	debug("Test initial value of align-self through JS");
176	element = document.createElement("div");
177	document.body.appendChild(element);
178	shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-align-self')", "'start'");
179
180	debug("");
181	debug("Test getting and setting align-self through JS");
182	container = document.createElement("div");
183	element = document.createElement("div");
184	container.appendChild(element);
185	document.body.appendChild(container);
186	element.style.webkitAlignSelf = "center";
187	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "center", "center");
188
189	element.style.webkitAlignSelf = "true start";
190	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "start true", "start true");
191
192	element.style.webkitAlignSelf = "flex-end safe";
193	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "flex-end safe", "flex-end safe");
194
195	element.style.webkitAlignSelf = "right";
196	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "right", "right");
197
198	element.style.webkitAlignSelf = "center";
199	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "center", "center");
200
201	element.style.webkitAlignSelf = "self-start";
202	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "self-start", "self-start");
203
204	element.style.webkitAlignSelf = "auto";
205	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "auto", "start");
206
207	container.style.display = "-webkit-flex";
208	element.style.webkitAlignSelf = "auto";
209	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "auto", "stretch");
210
211	container.style.display = "-webkit-grid";
212	element.style.webkitAlignSelf = "auto";
213	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "auto", "stretch");
214
215	element.style.webkitAlignSelf = "self-end";
216	checkValues(element, "webkitAlignSelf", "-webkit-align-self", "self-end", "self-end");
217
218	debug("");
219	debug("Test bad combinations of align-self");
220	container = document.createElement("div");
221	element = document.createElement("div");
222	container.appendChild(element);
223	document.body.appendChild(container);
224
225	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "true auto");
226	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "auto safe");
227	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "auto left");
228	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "baseline safe");
229	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "baseline center");
230	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "stretch true");
231	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "stretch right");
232	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "true true");
233	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "true safe");
234	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "center start");
235	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "stretch true");
236	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "safe stretch");
237	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "baseline safe");
238	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "true baseline");
239	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "true safe left");
240	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "true left safe");
241	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "left safe true safe");
242	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "legacy start");
243	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "legacy end");
244	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "legacy right true");
245	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "legacy auto");
246	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "legacy stretch");
247	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "legacy");
248	checkBadValues(element, "webkitAlignSelf", "-webkit-align-self", "legacy left right");
249
250	debug("");
251	debug("Test the value 'initial'");
252	container.style.display = "";
253	checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "center", "start");
254
255	debug("");
256	debug("Test the value 'initial' for grid containers");
257	container.style.display = "-webkit-grid";
258	checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "left safe", "stretch");
259
260	debug("");
261	debug("Test the value 'initial' for flex containers");
262	container.style.display = "-webkit-flex";
263	checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "right true", "stretch");
264
265	debug("");
266	debug("Test the value 'initial' for positioned elements");
267	container.style.display = "";
268	element.style.position = "absolute";
269	checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "left", "stretch");
270
271	debug("");
272	debug("Test the value 'initial' for positioned elements in grid containers");
273	container.style.display = "-webkit-grid";
274	element.style.position = "absolute";
275	checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "right", "stretch");
276
277	debug("");
278	debug("Test the value 'initial' for positioned elements in grid containers");
279	container.style.display = "-webkit-flex";
280	element.style.position = "absolute";
281	checkInitialValues(element, "webkitAlignSelf", "-webkit-align-self", "end", "stretch");
282
283	debug("");
284	debug("Test the value 'inherit'");
285	checkInheritValues("webkitAlignSelf", "-webkit-align-self", "end");
286	checkInheritValues("webkitAlignSelf", "-webkit-align-self", "left safe");
287	checkInheritValues("webkitAlignSelf", "-webkit-align-self", "center true");
288
289	</script>
290	</body>
291	</html>

Line 0 a/LayoutTests/css3/resources/alignment-parsing-utils.js_sec1
- a/LayoutTests/css3/resources/alignment-parsing-utils.js +46 lines
	1	function checkValues(element, property, propertyID, value, computedValue)
	2	{
	3	window.element = element;
	4	var elementID = element.id \|\| "element";
	5	shouldBeEqualToString("element.style." + property, value);
	6	shouldBeEqualToString("window.getComputedStyle(" + elementID + ", '').getPropertyValue('" + propertyID + "')", computedValue);
	7	}
	8
	9	function checkBadValues(element, property, propertyID, value)
	10	{
	11	element.style[property] = value;
	12	checkValues(element, property, propertyID, "", "start");
	13	}
	14
	15	function checkInitialValues(element, property, propertyID, value, initial)
	16	{
	17	element.style[property] = value;
	18	checkValues(element, property, propertyID, value, value);
	19	element.style[property] = "initial";
	20	checkValues(element, property, propertyID, "initial", initial);
	21	}
	22
	23	function checkInheritValues(property, propertyID, value)
	24	{
	25	var parentElement = document.createElement("div");
	26	document.body.appendChild(parentElement);
	27	parentElement.style[property] = value;
	28	checkValues(parentElement, property, propertyID, value, value);
	29
	30	var element = document.createElement("div");
	31	parentElement.appendChild(element);
	32	element.style[property] = "inherit";
	33	checkValues(element, property, propertyID, "inherit", value);
	34	}
	35
	36	function checkLegacyValues(property, propertyID, value)
	37	{
	38	var parentElement = document.createElement("div");
	39	document.body.appendChild(parentElement);
	40	parentElement.style[property] = value;
	41	checkValues(parentElement, property, propertyID, value, value);
	42
	43	var element = document.createElement("div");
	44	parentElement.appendChild(element);
	45	checkValues(element, property, propertyID, "", value);
	46	}

Lines 144-154 zoom: 1; a/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt_sec1
- a/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt -2 / +3 lines
144	-webkit-column-span: none;	144	-webkit-column-span: none;
145	-webkit-column-width: auto;	145	-webkit-column-width: auto;
146	align-content: stretch;	146	align-content: stretch;
147	align-items: stretch;	147	align-items: start;
148	align-self: stretch;	148	align-self: start;
149	flex-direction: row;	149	flex-direction: row;
150	flex-wrap: nowrap;	150	flex-wrap: nowrap;
151	justify-content: flex-start;	151	justify-content: flex-start;
		152	justify-self: auto;
152	-webkit-font-kerning: auto;	153	-webkit-font-kerning: auto;
153	-webkit-font-smoothing: auto;	154	-webkit-font-smoothing: auto;
154	-webkit-font-variant-ligatures: normal;	155	-webkit-font-variant-ligatures: normal;

Lines 143-153 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 -2 / +3 lines
143	-webkit-column-span: none	143	-webkit-column-span: none
144	-webkit-column-width: auto	144	-webkit-column-width: auto
145	align-content: stretch	145	align-content: stretch
146	align-items: stretch	146	align-items: start
147	align-self: stretch	147	align-self: start
148	flex-direction: row	148	flex-direction: row
149	flex-wrap: nowrap	149	flex-wrap: nowrap
150	justify-content: flex-start	150	justify-content: flex-start
		151	justify-self: auto
151	-webkit-font-kerning: auto	152	-webkit-font-kerning: auto
152	-webkit-font-smoothing: auto	153	-webkit-font-smoothing: auto
153	-webkit-font-variant-ligatures: normal	154	-webkit-font-variant-ligatures: normal

Lines 286-301 rect: style.getPropertyValue(-webkit-column-width) : auto a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt_sec1
- a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt -8 / +12 lines
286	rect: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]	286	rect: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]
287	rect: style.getPropertyValue(align-content) : stretch	287	rect: style.getPropertyValue(align-content) : stretch
288	rect: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]	288	rect: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]
289	rect: style.getPropertyValue(align-items) : stretch	289	rect: style.getPropertyValue(align-items) : start
290	rect: style.getPropertyCSSValue(align-items) : [object CSSPrimitiveValue]	290	rect: style.getPropertyCSSValue(align-items) : [object CSSValueList]
291	rect: style.getPropertyValue(align-self) : stretch	291	rect: style.getPropertyValue(align-self) : start
292	rect: style.getPropertyCSSValue(align-self) : [object CSSPrimitiveValue]	292	rect: style.getPropertyCSSValue(align-self) : [object CSSValueList]
293	rect: style.getPropertyValue(flex-direction) : row	293	rect: style.getPropertyValue(flex-direction) : row
294	rect: style.getPropertyCSSValue(flex-direction) : [object CSSPrimitiveValue]	294	rect: style.getPropertyCSSValue(flex-direction) : [object CSSPrimitiveValue]
295	rect: style.getPropertyValue(flex-wrap) : nowrap	295	rect: style.getPropertyValue(flex-wrap) : nowrap
296	rect: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]	296	rect: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]
297	rect: style.getPropertyValue(justify-content) : flex-start	297	rect: style.getPropertyValue(justify-content) : flex-start
298	rect: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]	298	rect: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]
		299	rect: style.getPropertyValue(justify-self) : auto
		300	rect: style.getPropertyCSSValue(justify-self) : [object CSSValueList]
299	rect: style.getPropertyValue(-webkit-font-kerning) : auto	301	rect: style.getPropertyValue(-webkit-font-kerning) : auto
300	rect: style.getPropertyCSSValue(-webkit-font-kerning) : [object CSSPrimitiveValue]	302	rect: style.getPropertyCSSValue(-webkit-font-kerning) : [object CSSPrimitiveValue]
301	rect: style.getPropertyValue(-webkit-font-smoothing) : auto	303	rect: style.getPropertyValue(-webkit-font-smoothing) : auto
Lines 798-813 g: style.getPropertyValue(-webkit-column-width) : auto a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt_sec2
798	g: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]	800	g: style.getPropertyCSSValue(-webkit-column-width) : [object CSSPrimitiveValue]
799	g: style.getPropertyValue(align-content) : stretch	801	g: style.getPropertyValue(align-content) : stretch
800	g: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]	802	g: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]
801	g: style.getPropertyValue(align-items) : stretch	803	g: style.getPropertyValue(align-items) : start
802	g: style.getPropertyCSSValue(align-items) : [object CSSPrimitiveValue]	804	g: style.getPropertyCSSValue(align-items) : [object CSSValueList]
803	g: style.getPropertyValue(align-self) : stretch	805	g: style.getPropertyValue(align-self) : start
804	g: style.getPropertyCSSValue(align-self) : [object CSSPrimitiveValue]	806	g: style.getPropertyCSSValue(align-self) : [object CSSValueList]
805	g: style.getPropertyValue(flex-direction) : row	807	g: style.getPropertyValue(flex-direction) : row
806	g: style.getPropertyCSSValue(flex-direction) : [object CSSPrimitiveValue]	808	g: style.getPropertyCSSValue(flex-direction) : [object CSSPrimitiveValue]
807	g: style.getPropertyValue(flex-wrap) : nowrap	809	g: style.getPropertyValue(flex-wrap) : nowrap
808	g: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]	810	g: style.getPropertyCSSValue(flex-wrap) : [object CSSPrimitiveValue]
809	g: style.getPropertyValue(justify-content) : flex-start	811	g: style.getPropertyValue(justify-content) : flex-start
810	g: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]	812	g: style.getPropertyCSSValue(justify-content) : [object CSSPrimitiveValue]
		813	g: style.getPropertyValue(justify-self) : auto
		814	g: style.getPropertyCSSValue(justify-self) : [object CSSValueList]
811	g: style.getPropertyValue(-webkit-font-kerning) : auto	815	g: style.getPropertyValue(-webkit-font-kerning) : auto
812	g: style.getPropertyCSSValue(-webkit-font-kerning) : [object CSSPrimitiveValue]	816	g: style.getPropertyCSSValue(-webkit-font-kerning) : [object CSSPrimitiveValue]
813	g: style.getPropertyValue(-webkit-font-smoothing) : auto	817	g: style.getPropertyValue(-webkit-font-smoothing) : auto