Attachment 248930 Details for Bug 133359 – Patch

[patch] Patch

bug-133359-20150318154605.patch (text/plain), 145.92 KB, created by Javier Fernandez on 2015-03-18 07:46:55 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Javier Fernandez

Created: 2015-03-18 07:46:55 PDT

Size: 145.92 KB

patch

obsolete

>Subversion Revision: 181440
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 297f2f5a32c9cb941396e5ae3e0be08b3a0e08a9..a0048fbcf3fe88358b36856f979cb5e35c75fe8e 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,102 @@
>+2015-03-12  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 NOBODY (OOPS!).
>+
>+        From Blink r164817 and r165264 by <jchaffraix@chromium.org>
>+
>+        Broaden justify-self's parsing name
>+
>+        This is in 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::resolveAlignmentAuto): Added. Resolves the "auto" value for the alignment properties.
>+        (WebCore::valueForItemPositionWithOverflowAlignment): Added. Builds the CSSValue for the for the alignment properties.
>+        (WebCore::ComputedStyleExtractor::propertyValue):
>+        * css/CSSParser.cpp:
>+         (WebCore::isValidKeywordPropertyAndValue): Removed align-self, align-items and justify-items.
>+        (WebCore::isKeywordPropertyID): Removed align-self, align-items and justify-items.
>+        (WebCore::isBaselinePositionKeyword): Added. Set of keywords related to baseline value.
>+        (WebCore::CSSParser::parseItemPositionOverflowPosition): Generic parsing fuction for the alignment properties.
>+        (WebCore::CSSParser::parseJustifySelf): Deleted.
>+        (WebCore::CSSParser::parseValue): Added align-items and align-self to the list and call to the generic parsing fuction for the alignment properties.
>+        * css/CSSParser.h:
>+        * css/CSSPrimitiveValueMappings.h:
>+        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue): Added.
>+        (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/StyleBuilderCustom.h:
>+        (WebCore::StyleBuilderCustom::applyInheritAlignSelf): Added.
>+        (WebCore::StyleBuilderCustom::applyInitialAlignSelf): Added.
>+        (WebCore::StyleBuilderCustom::applyValueAlignSelf): Added.
>+        (WebCore::StyleBuilderCustom::applyInheritAlignItems): Added.
>+        (WebCore::StyleBuilderCustom::applyInitialAlignItems): Added.
>+        (WebCore::StyleBuilderCustom::applyValueAlignItems): Added.
>+        (WebCore::StyleBuilderCustom::applyInheritJustifySelf): Added.
>+        (WebCore::StyleBuilderCustom::applyInitialJustifySelf): Added.
>+        (WebCore::StyleBuilderCustom::applyValueJustifySelf): Added.
>+        (WebCore::StyleBuilderCustom::applyValueWebkitJustifySelf): Deleted.
>+        * css/StyleResolver.cpp:
>+        (WebCore::StyleResolver::adjustRenderStyle): isDisplayFlexibleOrGridBox now a RenderStyle function.
>+        (WebCore::isDisplayFlexibleBox): Deleted. Moved to RenderStyle.
>+        (WebCore::isDisplayGridBox): Deleted. Moved to RenderStyle.
>+        (WebCore::isDisplayFlexibleOrGridBox): Deleted. Moved to RenderStyle.
>+        * rendering/RenderBox.cpp:
>+        (WebCore::flexItemHasStretchAlignment): Adapted to the new ItemPostition enum.
>+        * rendering/RenderFlexibleBox.cpp:
>+        (WebCore::RenderFlexibleBox::firstLineBaseline): Adapted to the new ItemPostition enum.
>+        (WebCore::RenderFlexibleBox::styleDidChange): Adapted to the new ItemPostition enum.
>+        (WebCore::RenderFlexibleBox::alignmentForChild): Adapted to the new ItemPostition enum.
>+        (WebCore::RenderFlexibleBox::needToStretchChild): Adapted to the new ItemPostition enum.
>+        (WebCore::RenderFlexibleBox::layoutAndPlaceChildren): Adapted to the new ItemPostition enum.
>+        (WebCore::RenderFlexibleBox::alignChildren): Adapted to the new ItemPostition enum.
>+        (WebCore::resolveAlignment): Deleted. Moved to RenderStyle.
>+        * rendering/RenderFlexibleBox.h:
>+        * rendering/RenderFullScreen.cpp:
>+        (WebCore::createFullScreenStyle): Adapted to the new ItemPostition enum.
>+        * rendering/RenderMenuList.cpp:
>+        (WebCore::RenderMenuList::adjustInnerStyle): Adapted to the new ItemPostition enum.
>+        * rendering/mathml/RenderMathMLRoot.cpp:
>+        (WebCore::RenderMathMLRoot::updateStyle): Adapted to the new ItemPostition enum.
>+        * rendering/mathml/RenderMathMLScripts.cpp:
>+        (WebCore::RenderMathMLScripts::fixAnonymousStyleForSubSupPair): Adapted to the new ItemPostition enum.
>+        (WebCore::RenderMathMLScripts::fixAnonymousStyles): Adapted to the new ItemPostition enum.
>+        * rendering/style/ContentData.h:
>+        * rendering/style/RenderStyle.cpp:
>+        (WebCore::RenderStyle::resolveAlignment): Added.
>+        * rendering/style/RenderStyle.h: Adapted to the new ItemPostition enum.
>+        * rendering/style/RenderStyleConstants.h: Adapted to the new ItemPostition enum.
>+        * rendering/style/StyleRareNonInheritedData.cpp: Adapted to the new ItemPostition enum.
>+        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData): Adapted to the new ItemPostition enum.
>+        (WebCore::StyleRareNonInheritedData::operator==): Adapted to the new ItemPostition enum.
>+        * rendering/style/StyleRareNonInheritedData.h: Adapted to the new ItemPostition enum.
>+        * style/StyleResolveTree.cpp:
>+        (WebCore::Style::determineChange): Changes in the alignItems property cause a Detach.
>+
> 2015-03-12  Csaba OsztrogonÃ¡c  <ossy@webkit.org>
> 
>         Fix the !ENABLE(PICTURE_SIZES) build
>diff --git a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>index bc8f5987ff2b8602eaae69dd382577bbaa82b7b5..1a67eaea8ddaf8372f14d16bf587bcc4676f84a7 100644
>--- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>+++ b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp
>@@ -296,7 +296,7 @@ static const CSSPropertyID computedProperties[] = {
>     CSSPropertyFlexDirection,
>     CSSPropertyFlexWrap,
>     CSSPropertyJustifyContent,
>-    CSSPropertyWebkitJustifySelf,
>+    CSSPropertyJustifySelf,
>     CSSPropertyWebkitFilter,
> #if ENABLE(FILTERS_LEVEL_2)
>     CSSPropertyWebkitBackdropFilter,
>@@ -1655,6 +1655,16 @@ Node* ComputedStyleExtractor::styledNode() const
>     return &element;
> }
> 
>+static ItemPosition resolveAlignmentAuto(ItemPosition position, RenderObject* element)
>+{
>+    if (position != ItemPositionAuto || !element)
>+        return position;
>+
>+    bool isFlexOrGrid = element->style().isDisplayFlexibleOrGridBox();
>+    return isFlexOrGrid ? ItemPositionStretch : ItemPositionStart;
>+}
>+
>+
> PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const
> {
>     return ComputedStyleExtractor(m_node, m_allowVisitedStyle, m_pseudoElementSpecifier).propertyValue(propertyID, updateLayout);
>@@ -1735,6 +1745,15 @@ static Ref<CSSValue> shapePropertyValue(const RenderStyle* style, const ShapeVal
> }
> #endif
> 
>+static PassRefPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment)
>+{
>+    RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
>+    result->append(cssValuePool().createValue(itemPosition));
>+    if (overflowAlignment != OverflowAlignmentDefault)
>+        result->append(cssValuePool().createValue(overflowAlignment));
>+    return result.release();
>+}
>+
> PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const
> {
>     Node* styledNode = this->styledNode();
>@@ -2098,15 +2117,22 @@ PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propert
>         case CSSPropertyAlignContent:
>             return cssValuePool().createValue(style->alignContent());
>         case CSSPropertyAlignItems:
>-            return cssValuePool().createValue(style->alignItems());
>-        case CSSPropertyAlignSelf:
>-            if (style->alignSelf() == AlignAuto) {
>-                Node* parent = styledNode->parentNode();
>-                if (parent && parent->computedStyle())
>-                    return cssValuePool().createValue(parent->computedStyle()->alignItems());
>-                return cssValuePool().createValue(AlignStretch);
>+            return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->alignItems(), renderer), style->alignItemsOverflowAlignment());
>+        case CSSPropertyAlignSelf: {
>+            ItemPosition alignSelf = style->alignSelf();
>+            OverflowAlignment overflow = style->alignSelfOverflowAlignment();
>+            if (alignSelf == ItemPositionAuto) {
>+                if (renderer && !renderer->isOutOfFlowPositioned()) {
>+                    alignSelf = ItemPositionStart;
>+                    RenderBlock* parent = renderer->containingBlock();
>+                    if (parent) {
>+                        alignSelf = resolveAlignmentAuto(parent->style().alignItems(), parent);
>+                        overflow = parent->style().alignItemsOverflowAlignment();
>+                    }
>+                }
>             }
>-            return cssValuePool().createValue(style->alignSelf());
>+            return valueForItemPositionWithOverflowAlignment(alignSelf, overflow);
>+        }
>         case CSSPropertyFlex:
>             return getCSSPropertyValuesForShorthandProperties(flexShorthand());
>         case CSSPropertyFlexBasis:
>@@ -2123,13 +2149,8 @@ PassRefPtr<CSSValue> ComputedStyleExtractor::propertyValue(CSSPropertyID propert
>             return cssValuePool().createValue(style->flexWrap());
>         case CSSPropertyJustifyContent:
>             return cssValuePool().createValue(style->justifyContent());
>-        case CSSPropertyWebkitJustifySelf: {
>-            RefPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
>-            result->append(CSSPrimitiveValue::create(style->justifySelf()));
>-            if (style->justifySelf() >= JustifySelfCenter && style->justifySelfOverflowAlignment() != JustifySelfOverflowAlignmentDefault)
>-                result->append(CSSPrimitiveValue::create(style->justifySelfOverflowAlignment()));
>-            return result.release();
>-        }
>+        case CSSPropertyJustifySelf:
>+            return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->justifySelf(), renderer), style->justifySelfOverflowAlignment());
>         case CSSPropertyOrder:
>             return cssValuePool().createValue(style->order(), CSSPrimitiveValue::CSS_NUMBER);
>         case CSSPropertyFloat:
>diff --git a/Source/WebCore/css/CSSParser.cpp b/Source/WebCore/css/CSSParser.cpp
>index d68a7346da20a6cd0601f8258f546c59b9738d3e..0896c091015f23391657ae3620f26d24a29c3b57 100644
>--- a/Source/WebCore/css/CSSParser.cpp
>+++ b/Source/WebCore/css/CSSParser.cpp
>@@ -878,16 +878,6 @@ static inline bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, int
>         if (valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround || valueID == CSSValueStretch)
>             return true;
>         break;
>-    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)
>-            return true;
>-        break;
>-    case CSSPropertyAlignSelf:
>-        // FIXME: Per CSS alignment, this property should accept the same arguments as 'justify-self' so we should share its parsing code.
>-        if (valueID == CSSValueAuto || valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch)
>-            return true;
>-        break;
>     case CSSPropertyFlexDirection:
>         if (valueID == CSSValueRow || valueID == CSSValueRowReverse || valueID == CSSValueColumn || valueID == CSSValueColumnReverse)
>             return true;
>@@ -901,10 +891,6 @@ static inline bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, int
>         if (valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueSpaceBetween || valueID == CSSValueSpaceAround)
>             return true;
>         break;
>-    case CSSPropertyWebkitJustifySelf:
>-        if (valueID == CSSValueAuto || valueID == CSSValueFlexStart || valueID == CSSValueFlexEnd || valueID == CSSValueCenter || valueID == CSSValueBaseline || valueID == CSSValueStretch)
>-            return true;
>-        break;
>     case CSSPropertyWebkitFontKerning:
>         if (valueID == CSSValueAuto || valueID == CSSValueNormal || valueID == CSSValueNone)
>             return true;
>@@ -1133,8 +1119,6 @@ static inline bool isKeywordPropertyID(CSSPropertyID propertyId)
>     case CSSPropertyColumnFill:
>     case CSSPropertyColumnRuleStyle:
>     case CSSPropertyAlignContent:
>-    case CSSPropertyAlignItems:
>-    case CSSPropertyAlignSelf:
>     case CSSPropertyFlexDirection:
>     case CSSPropertyFlexWrap:
>     case CSSPropertyJustifyContent:
>@@ -2705,8 +2689,8 @@ bool CSSParser::parseValue(CSSPropertyID propId, bool important)
>         }
>         return false;
>     }
>-    case CSSPropertyWebkitJustifySelf:
>-        return parseJustifySelf(propId, important);
>+    case CSSPropertyJustifySelf:
>+        return parseItemPositionOverflowPosition(propId, important);
> #if ENABLE(CSS_GRID_LAYOUT)
>     case CSSPropertyWebkitGridAutoColumns:
>     case CSSPropertyWebkitGridAutoRows:
>@@ -3046,6 +3030,11 @@ bool CSSParser::parseValue(CSSPropertyID propId, bool important)
>         parsedValue = parseImageResolution();
>         break;
> #endif
>+    case CSSPropertyAlignSelf:
>+        return parseItemPositionOverflowPosition(propId, important);
>+
>+    case CSSPropertyAlignItems:
>+        return parseItemPositionOverflowPosition(propId, important);
>     case CSSPropertyBorderBottomStyle:
>     case CSSPropertyBorderCollapse:
>     case CSSPropertyBorderLeftStyle:
>@@ -3107,8 +3096,6 @@ bool CSSParser::parseValue(CSSPropertyID propId, bool important)
>     case CSSPropertyColumnFill:
>     case CSSPropertyColumnRuleStyle:
>     case CSSPropertyAlignContent:
>-    case CSSPropertyAlignItems:
>-    case CSSPropertyAlignSelf:
>     case CSSPropertyFlexDirection:
>     case CSSPropertyFlexWrap:
>     case CSSPropertyJustifyContent:
>@@ -3223,6 +3210,11 @@ void CSSParser::addFillValue(RefPtr<CSSValue>& lval, Ref<CSSValue>&& rval)
>     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
>@@ -3230,7 +3222,7 @@ static bool isItemPositionKeyword(CSSValueID id)
>         || id == CSSValueFlexEnd || id == CSSValueLeft || id == CSSValueRight;
> }
> 
>-bool CSSParser::parseJustifySelf(CSSPropertyID propId, bool important)
>+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;
>@@ -3238,7 +3230,7 @@ bool CSSParser::parseJustifySelf(CSSPropertyID propId, bool important)
> 
>     CSSParserValue* value = m_valueList->current();
> 
>-    if (value->id == CSSValueAuto || value->id == CSSValueBaseline || value->id == CSSValueStretch) {
>+    if (value->id == CSSValueAuto || value->id == CSSValueStretch || isBaselinePositionKeyword(value->id)) {
>         if (m_valueList->next())
>             return false;
> 
>diff --git a/Source/WebCore/css/CSSParser.h b/Source/WebCore/css/CSSParser.h
>index 535d222d494b35934dd24df6e20a3d841943614b..f097246fde55162896464016fe40bd4ee33b2c32 100644
>--- a/Source/WebCore/css/CSSParser.h
>+++ b/Source/WebCore/css/CSSParser.h
>@@ -211,7 +211,7 @@ public:
> 
>     bool parseClipShape(CSSPropertyID, bool important);
> 
>-    bool parseJustifySelf(CSSPropertyID, bool important);
>+    bool parseItemPositionOverflowPosition(CSSPropertyID, bool important);
> 
> #if ENABLE(CSS_SHAPES)
>     PassRefPtr<CSSValue> parseShapeProperty(CSSPropertyID);
>diff --git a/Source/WebCore/css/CSSPrimitiveValueMappings.h b/Source/WebCore/css/CSSPrimitiveValueMappings.h
>index bfb49831b1f8620ed70d88665878fe961895ebfe..58807fcf7889086387597e474de0ca834b5584c3 100644
>--- a/Source/WebCore/css/CSSPrimitiveValueMappings.h
>+++ b/Source/WebCore/css/CSSPrimitiveValueMappings.h
>@@ -1440,57 +1440,6 @@ template<> inline CSSPrimitiveValue::operator EEmptyCell() const
>     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)
> {
>@@ -5125,116 +5074,118 @@ template<> inline CSSPrimitiveValue::operator CSSBoxType() const
>     return BoxMissing;
> }
> 
>-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifySelf justifySelf)
>+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
>     : CSSValue(PrimitiveClass)
> {
>     m_primitiveUnitType = CSS_VALUE_ID;
>-    switch (justifySelf) {
>-    case JustifySelfAuto:
>+    switch (itemPosition) {
>+    case ItemPositionAuto:
>         m_value.valueID = CSSValueAuto;
>         break;
>-    case JustifySelfStretch:
>+    case ItemPositionStretch:
>         m_value.valueID = CSSValueStretch;
>         break;
>-    case JustifySelfBaseline:
>+    case ItemPositionBaseline:
>         m_value.valueID = CSSValueBaseline;
>         break;
>-    case JustifySelfCenter:
>+    case ItemPositionLastBaseline:
>+        m_value.valueID = CSSValueLastBaseline;
>+        break;
>+    case ItemPositionCenter:
>         m_value.valueID = CSSValueCenter;
>         break;
>-    case JustifySelfStart:
>+    case ItemPositionStart:
>         m_value.valueID = CSSValueStart;
>         break;
>-    case JustifySelfEnd:
>+    case ItemPositionEnd:
>         m_value.valueID = CSSValueEnd;
>         break;
>-    case JustifySelfSelfStart:
>+    case ItemPositionSelfStart:
>         m_value.valueID = CSSValueSelfStart;
>         break;
>-    case JustifySelfSelfEnd:
>+    case ItemPositionSelfEnd:
>         m_value.valueID = CSSValueSelfEnd;
>         break;
>-    case JustifySelfFlexStart:
>+    case ItemPositionFlexStart:
>         m_value.valueID = CSSValueFlexStart;
>         break;
>-    case JustifySelfFlexEnd:
>+    case ItemPositionFlexEnd:
>         m_value.valueID = CSSValueFlexEnd;
>         break;
>-    case JustifySelfLeft:
>+    case ItemPositionLeft:
>         m_value.valueID = CSSValueLeft;
>         break;
>-    case JustifySelfRight:
>+    case ItemPositionRight:
>         m_value.valueID = CSSValueRight;
>         break;
>-    default:
>-        m_value.valueID = CSSValueAuto;
>-        break;
>     }
> }
> 
>-template<> inline CSSPrimitiveValue::operator EJustifySelf() const
>+template<> inline CSSPrimitiveValue::operator ItemPosition() const
> {
>     switch (m_value.valueID) {
>     case CSSValueAuto:
>-        return JustifySelfAuto;
>+        return ItemPositionAuto;
>     case CSSValueStretch:
>-        return JustifySelfStretch;
>+        return ItemPositionStretch;
>     case CSSValueBaseline:
>-        return JustifySelfBaseline;
>+        return ItemPositionBaseline;
>+    case CSSValueLastBaseline:
>+        return ItemPositionLastBaseline;
>     case CSSValueCenter:
>-        return JustifySelfCenter;
>+        return ItemPositionCenter;
>     case CSSValueStart:
>-        return JustifySelfStart;
>+        return ItemPositionStart;
>     case CSSValueEnd:
>-        return JustifySelfEnd;
>+        return ItemPositionEnd;
>     case CSSValueSelfStart:
>-        return JustifySelfSelfStart;
>+        return ItemPositionSelfStart;
>     case CSSValueSelfEnd:
>-        return JustifySelfSelfEnd;
>+        return ItemPositionSelfEnd;
>     case CSSValueFlexStart:
>-        return JustifySelfFlexStart;
>+        return ItemPositionFlexStart;
>     case CSSValueFlexEnd:
>-        return JustifySelfFlexEnd;
>+        return ItemPositionFlexEnd;
>     case CSSValueLeft:
>-        return JustifySelfLeft;
>+        return ItemPositionLeft;
>     case CSSValueRight:
>-        return JustifySelfRight;
>+        return ItemPositionRight;
>     default:
>         break;
>     }
>     ASSERT_NOT_REACHED();
>-    return JustifySelfAuto;
>+    return ItemPositionAuto;
> }
> 
>-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifySelfOverflowAlignment overflowAlignment)
>+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
>     : CSSValue(PrimitiveClass)
> {
>     m_primitiveUnitType = CSS_VALUE_ID;
>     switch (overflowAlignment) {
>-    case JustifySelfOverflowAlignmentDefault:
>+    case OverflowAlignmentDefault:
>         m_value.valueID = CSSValueDefault;
>         break;
>-    case JustifySelfOverflowAlignmentTrue:
>+    case OverflowAlignmentTrue:
>         m_value.valueID = CSSValueTrue;
>         break;
>-    case JustifySelfOverflowAlignmentSafe:
>+    case OverflowAlignmentSafe:
>         m_value.valueID = CSSValueSafe;
>         break;
>     }
> }
> 
>-template<> inline CSSPrimitiveValue::operator EJustifySelfOverflowAlignment() const
>+template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
> {
>     switch (m_value.valueID) {
>     case CSSValueTrue:
>-        return JustifySelfOverflowAlignmentTrue;
>+        return OverflowAlignmentTrue;
>     case CSSValueSafe:
>-        return JustifySelfOverflowAlignmentSafe;
>+        return OverflowAlignmentSafe;
>     default:
>         break;
>     }
>     ASSERT_NOT_REACHED();
>-    return JustifySelfOverflowAlignmentTrue;
>+    return OverflowAlignmentTrue;
> }
> 
> 
>diff --git a/Source/WebCore/css/CSSPropertyNames.in b/Source/WebCore/css/CSSPropertyNames.in
>index 121d6375f486addf6d647ce50cbf85b0b941b4d2..ea96ff8aeb523fc2007dd07385dd8a874626e8f5 100644
>--- a/Source/WebCore/css/CSSPropertyNames.in
>+++ b/Source/WebCore/css/CSSPropertyNames.in
>@@ -451,9 +451,9 @@ isolation
> -webkit-filter [ConditionalConverter=FilterOperations]
> align-content
> -webkit-align-content = align-content
>-align-items
>+align-items [Custom=All]
> -webkit-align-items = align-items
>-align-self
>+align-self [Custom=All]
> -webkit-align-self = align-self
> flex [Longhands=flex-grow|flex-shrink|flex-basis]
> -webkit-flex = flex
>@@ -474,7 +474,7 @@ justify-content
> #if defined(ENABLE_FILTERS_LEVEL_2) && ENABLE_FILTERS_LEVEL_2
> -webkit-backdrop-filter [ConditionalConverter=FilterOperations]
> #endif
>--webkit-justify-self [Custom=Value]
>+justify-self [Custom=All]
> -webkit-font-size-delta [SkipBuilder]
> #if defined(ENABLE_CSS_GRID_LAYOUT) && ENABLE_CSS_GRID_LAYOUT
> -webkit-grid [Longhands=-webkit-grid-template-columns|-webkit-grid-template-rows|-webkit-grid-template-areas|-webkit-grid-auto-flow|-webkit-grid-auto-columns|-webkit-grid-auto-rows]
>diff --git a/Source/WebCore/css/CSSValueKeywords.in b/Source/WebCore/css/CSSValueKeywords.in
>index 52d631e215b906b2cb252fd6a51d495a3a16e385..0feba7cd3966d4740f1aabc09fbf46d9c61ee2f8 100644
>--- a/Source/WebCore/css/CSSValueKeywords.in
>+++ b/Source/WebCore/css/CSSValueKeywords.in
>@@ -543,6 +543,7 @@ space-around
> // flex-end
> // center
> // baseline
>+last-baseline
> // stretch
> 
> // CSS_PROP_JUSTIFY_CONTENT
>@@ -556,6 +557,7 @@ space-around
> // auto
> // stretch
> // baseline
>+// last-baseline
> // center
> // start
> // end
>diff --git a/Source/WebCore/css/StyleBuilderCustom.h b/Source/WebCore/css/StyleBuilderCustom.h
>index e2956030411816f3636d249c2636faa37c870646..61b280d064a80881afb832589ada86af2052b1af 100644
>--- a/Source/WebCore/css/StyleBuilderCustom.h
>+++ b/Source/WebCore/css/StyleBuilderCustom.h
>@@ -102,6 +102,9 @@ public:
>     DECLARE_PROPERTY_CUSTOM_HANDLERS(WebkitSvgShadow);
>     DECLARE_PROPERTY_CUSTOM_HANDLERS(WebkitTextEmphasisStyle);
>     DECLARE_PROPERTY_CUSTOM_HANDLERS(Zoom);
>+    DECLARE_PROPERTY_CUSTOM_HANDLERS(JustifySelf);
>+    DECLARE_PROPERTY_CUSTOM_HANDLERS(AlignItems);
>+    DECLARE_PROPERTY_CUSTOM_HANDLERS(AlignSelf);
> 
>     // Custom handling of initial + inherit value setting only.
>     static void applyInitialWebkitMaskImage(StyleResolver&) { }
>@@ -120,7 +123,6 @@ public:
> #if ENABLE(DASHBOARD_SUPPORT)
>     static void applyValueWebkitDashboardRegion(StyleResolver&, CSSValue&);
> #endif
>-    static void applyValueWebkitJustifySelf(StyleResolver&, CSSValue&);
>     static void applyValueWebkitLocale(StyleResolver&, CSSValue&);
>     static void applyValueWebkitTextOrientation(StyleResolver&, CSSValue&);
> #if ENABLE(IOS_TEXT_AUTOSIZING)
>@@ -504,6 +506,78 @@ inline void StyleBuilderCustom::applyValueTextIndent(StyleResolver& styleResolve
> #endif
> }
> 
>+inline void StyleBuilderCustom::applyInheritAlignSelf(StyleResolver& styleResolver)
>+{
>+    styleResolver.style()->setAlignSelf(styleResolver.parentStyle()->alignSelf());
>+    styleResolver.style()->setAlignSelfOverflowAlignment(styleResolver.parentStyle()->alignSelfOverflowAlignment());
>+}
>+
>+inline void StyleBuilderCustom::applyInitialAlignSelf(StyleResolver& styleResolver)
>+{
>+    styleResolver.style()->setAlignSelf(RenderStyle::initialAlignSelf());
>+    styleResolver.style()->setAlignSelfOverflowAlignment(RenderStyle::initialAlignSelfOverflowAlignment());
>+}
>+
>+inline void StyleBuilderCustom::applyValueAlignSelf(StyleResolver& styleResolver, CSSValue& value)
>+{
>+    auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
>+    if (Pair* pairValue = primitiveValue.getPairValue()) {
>+        styleResolver.style()->setAlignSelf(*pairValue->first());
>+        styleResolver.style()->setAlignSelfOverflowAlignment(*pairValue->second());
>+    } else {
>+        styleResolver.style()->setAlignSelf(primitiveValue);
>+        styleResolver.style()->setAlignSelfOverflowAlignment(RenderStyle::initialAlignSelfOverflowAlignment());
>+    }
>+}
>+
>+inline void StyleBuilderCustom::applyInheritAlignItems(StyleResolver& styleResolver)
>+{
>+    styleResolver.style()->setAlignItems(styleResolver.parentStyle()->alignItems());
>+    styleResolver.style()->setAlignItemsOverflowAlignment(styleResolver.parentStyle()->alignItemsOverflowAlignment());
>+}
>+
>+inline void StyleBuilderCustom::applyInitialAlignItems(StyleResolver& styleResolver)
>+{
>+    styleResolver.style()->setAlignItems(RenderStyle::initialAlignItems());
>+    styleResolver.style()->setAlignItemsOverflowAlignment(RenderStyle::initialAlignItemsOverflowAlignment());
>+}
>+
>+inline void StyleBuilderCustom::applyValueAlignItems(StyleResolver& styleResolver, CSSValue& value)
>+{
>+    auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
>+    if (Pair* pairValue = primitiveValue.getPairValue()) {
>+        styleResolver.style()->setAlignItems(*pairValue->first());
>+        styleResolver.style()->setAlignItemsOverflowAlignment(*pairValue->second());
>+    } else {
>+        styleResolver.style()->setAlignItems(primitiveValue);
>+        styleResolver.style()->setAlignItemsOverflowAlignment(RenderStyle::initialAlignItemsOverflowAlignment());
>+    }
>+}
>+
>+inline void StyleBuilderCustom::applyInheritJustifySelf(StyleResolver& styleResolver)
>+{
>+    styleResolver.style()->setJustifySelf(styleResolver.parentStyle()->justifySelf());
>+    styleResolver.style()->setJustifySelfOverflowAlignment(styleResolver.parentStyle()->justifySelfOverflowAlignment());
>+}
>+
>+inline void StyleBuilderCustom::applyInitialJustifySelf(StyleResolver& styleResolver)
>+{
>+    styleResolver.style()->setJustifySelf(RenderStyle::initialJustifySelf());
>+    styleResolver.style()->setJustifySelfOverflowAlignment(RenderStyle::initialJustifySelfOverflowAlignment());
>+}
>+
>+inline void StyleBuilderCustom::applyValueJustifySelf(StyleResolver& styleResolver, CSSValue& value)
>+{
>+    auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
>+    if (Pair* pairValue = primitiveValue.getPairValue()) {
>+        styleResolver.style()->setJustifySelf(*pairValue->first());
>+        styleResolver.style()->setJustifySelfOverflowAlignment(*pairValue->second());
>+    } else {
>+        styleResolver.style()->setJustifySelf(primitiveValue);
>+        styleResolver.style()->setJustifySelfOverflowAlignment(RenderStyle::initialJustifySelfOverflowAlignment());
>+    }
>+}
>+
> enum BorderImageType { BorderImage, WebkitMaskBoxImage };
> enum BorderImageModifierType { Outset, Repeat, Slice, Width };
> template <BorderImageType type, BorderImageModifierType modifier>
>@@ -732,17 +806,6 @@ inline void StyleBuilderCustom::applyValueWebkitTextSizeAdjust(StyleResolver& st
> }
> #endif
> 
>-inline void StyleBuilderCustom::applyValueWebkitJustifySelf(StyleResolver& styleResolver, CSSValue& value)
>-{
>-    auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
>-
>-    if (Pair* pairValue = primitiveValue.getPairValue()) {
>-        styleResolver.style()->setJustifySelf(*pairValue->first());
>-        styleResolver.style()->setJustifySelfOverflowAlignment(*pairValue->second());
>-    } else
>-        styleResolver.style()->setJustifySelf(primitiveValue);
>-}
>-
> template <CSSPropertyID id>
> inline void StyleBuilderCustom::applyTextOrBoxShadowValue(StyleResolver& styleResolver, CSSValue& value)
> {
>diff --git a/Source/WebCore/css/StyleResolver.cpp b/Source/WebCore/css/StyleResolver.cpp
>index 26151890fbaf1e263716de3f32afc74b3a83699e..1b437050e97c752af86cab19fc0d1905dfb53be4 100644
>--- a/Source/WebCore/css/StyleResolver.cpp
>+++ b/Source/WebCore/css/StyleResolver.cpp
>@@ -1115,26 +1115,6 @@ static bool doesNotInheritTextDecoration(const RenderStyle& style, Element* e)
>         || 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)
> {
>@@ -1291,14 +1271,14 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
>         if (style.writingMode() != TopToBottomWritingMode && (style.display() == BOX || style.display() == INLINE_BOX))
>             style.setWritingMode(TopToBottomWritingMode);
> 
>-        if (isDisplayFlexibleOrGridBox(parentStyle.display())) {
>+        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 && !isDisplayFlexibleOrGridBox(parentStyle.display()))
>+    if (style.position() == StaticPosition && !parentStyle.isDisplayFlexibleOrGridBox())
>         style.setHasAutoZIndex();
> 
>     // Auto z-index becomes 0 for the root element and transparent objects. This prevents
>diff --git a/Source/WebCore/mathml/MathMLTextElement.cpp b/Source/WebCore/mathml/MathMLTextElement.cpp
>index 9606dd884076927d2ffcf2603f84a865cb3d5f90..271d692f756165040d4aa4a29b277154a27a388d 100644
>--- a/Source/WebCore/mathml/MathMLTextElement.cpp
>+++ b/Source/WebCore/mathml/MathMLTextElement.cpp
>@@ -86,6 +86,10 @@ RenderPtr<RenderElement> MathMLTextElement::createElementRenderer(Ref<RenderStyl
> 
>     ASSERT(hasTagName(MathMLNames::miTag) || hasTagName(MathMLNames::mnTag) || hasTagName(MathMLNames::msTag) || hasTagName(MathMLNames::mtextTag));
> 
>+    // FIXME: why do we have to set the alignment here ? It seems needed to make the
>+    // style-changed.htmt test to pass, since mathml renders expect Stretch as default.
>+    style.get().setAlignItems(ItemPositionStretch);
>+
>     return createRenderer<RenderMathMLToken>(*this, WTF::move(style));
> }
> 
>diff --git a/Source/WebCore/rendering/RenderBox.cpp b/Source/WebCore/rendering/RenderBox.cpp
>index 9ce44bd7bd091babfd0f4fb5e049d183d92d99e3..e579430f2154a914b3a9abb45ad089d659abdaeb 100644
>--- a/Source/WebCore/rendering/RenderBox.cpp
>+++ b/Source/WebCore/rendering/RenderBox.cpp
>@@ -2444,7 +2444,7 @@ LayoutUnit RenderBox::computeLogicalWidthInRegionUsing(SizeType widthType, Lengt
> static bool flexItemHasStretchAlignment(const RenderBox& flexitem)
> {
>     auto parent = flexitem.parent();
>-    return flexitem.style().alignSelf() == AlignStretch || (flexitem.style().alignSelf() == AlignAuto && parent->style().alignItems() == AlignStretch);
>+    return RenderStyle::resolveAlignment(parent->style(), flexitem.style(), ItemPositionStretch) == ItemPositionStretch;
> }
> 
> static bool isStretchingColumnFlexItem(const RenderBox& flexitem)
>diff --git a/Source/WebCore/rendering/RenderFlexibleBox.cpp b/Source/WebCore/rendering/RenderFlexibleBox.cpp
>index e9139b8079adf0d92d8c4deb99111dd466e78d03..31fa347e057f39a284d53fb83e8b52141b3127b5 100644
>--- a/Source/WebCore/rendering/RenderFlexibleBox.cpp
>+++ b/Source/WebCore/rendering/RenderFlexibleBox.cpp
>@@ -184,7 +184,7 @@ Optional<int> RenderFlexibleBox::firstLineBaseline() const
>     for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
>         if (child->isOutOfFlowPositioned())
>             continue;
>-        if (alignmentForChild(*child) == AlignBaseline && !hasAutoMarginsInCrossAxis(*child)) {
>+        if (alignmentForChild(*child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(*child)) {
>             baselineChild = child;
>             break;
>         }
>@@ -224,24 +224,16 @@ Optional<int> RenderFlexibleBox::inlineBlockBaseline(LineDirectionMode direction
>     return synthesizedBaselineFromContentBox(*this, direction) + marginAscent;
> }
> 
>-static EAlignItems resolveAlignment(const RenderStyle* parentStyle, const RenderStyle* childStyle)
>-{
>-    EAlignItems align = childStyle->alignSelf();
>-    if (align == AlignAuto)
>-        align = parentStyle->alignItems();
>-    return align;
>-}
>-
> void RenderFlexibleBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
> {
>     RenderBlock::styleDidChange(diff, oldStyle);
> 
>-    if (oldStyle && oldStyle->alignItems() == AlignStretch && diff == StyleDifferenceLayout) {
>+    if (oldStyle && (oldStyle->alignItems() == ItemPositionStretch || oldStyle->alignItems() == ItemPositionAuto) && 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()) {
>-            EAlignItems previousAlignment = resolveAlignment(oldStyle, &child->style());
>-            if (previousAlignment == AlignStretch && previousAlignment != resolveAlignment(&style(), &child->style()))
>+            ItemPosition previousAlignment = RenderStyle::resolveAlignment(*oldStyle, child->style(), ItemPositionStretch);
>+            if (previousAlignment == ItemPositionStretch && previousAlignment != RenderStyle::resolveAlignment(style(), child->style(), ItemPositionStretch))
>                 child->setChildNeedsLayout(MarkOnlyThis);
>         }
>     }
>@@ -1018,18 +1010,18 @@ void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox& child, Layout
>     }
> }
> 
>-EAlignItems RenderFlexibleBox::alignmentForChild(RenderBox& child) const
>+ItemPosition RenderFlexibleBox::alignmentForChild(RenderBox& child) const
> {
>-    EAlignItems align = resolveAlignment(&style(), &child.style());
>+    ItemPosition align = RenderStyle::resolveAlignment(style(), child.style(), ItemPositionStretch);
> 
>-    if (align == AlignBaseline && hasOrthogonalFlow(child))
>-        align = AlignFlexStart;
>+    if (align == ItemPositionBaseline && hasOrthogonalFlow(child))
>+        align = ItemPositionFlexStart;
> 
>     if (style().flexWrap() == FlexWrapReverse) {
>-        if (align == AlignFlexStart)
>-            align = AlignFlexEnd;
>-        else if (align == AlignFlexEnd)
>-            align = AlignFlexStart;
>+        if (align == ItemPositionFlexStart)
>+            align = ItemPositionFlexEnd;
>+        else if (align == ItemPositionFlexEnd)
>+            align = ItemPositionFlexStart;
>     }
> 
>     return align;
>@@ -1048,7 +1040,7 @@ size_t RenderFlexibleBox::numberOfInFlowPositionedChildren(const OrderedFlexItem
> 
> bool RenderFlexibleBox::needToStretchChild(RenderBox& child)
> {
>-    if (alignmentForChild(child) != AlignStretch)
>+    if (alignmentForChild(child) != ItemPositionStretch)
>         return false;
> 
>     Length crossAxisLength = isHorizontalFlow() ? child.style().height() : child.style().width();
>@@ -1099,7 +1091,7 @@ void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, cons
>         updateAutoMarginsInMainAxis(child, autoMarginOffset);
> 
>         LayoutUnit childCrossAxisMarginBoxExtent;
>-        if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child)) {
>+        if (alignmentForChild(child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(child)) {
>             LayoutUnit ascent = marginBoxAscentForChild(child);
>             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
> 
>@@ -1260,25 +1252,30 @@ void RenderFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts)
>                 continue;
> 
>             switch (alignmentForChild(*child)) {
>-            case AlignAuto:
>+            case ItemPositionAuto:
>                 ASSERT_NOT_REACHED();
>                 break;
>-            case AlignStretch: {
>+            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.
>+            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 AlignFlexStart:
>+            case ItemPositionFlexStart:
>                 break;
>-            case AlignFlexEnd:
>+            case ItemPositionFlexEnd:
>                 adjustAlignmentForChild(*child, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child));
>                 break;
>-            case AlignCenter:
>+            case ItemPositionCenter:
>                 adjustAlignmentForChild(*child, availableAlignmentSpaceForChild(lineCrossAxisExtent, *child) / 2);
>                 break;
>-            case AlignBaseline: {
>+            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);
>@@ -1289,6 +1286,17 @@ void RenderFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts)
>                     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.
>+            default:
>+                ASSERT_NOT_REACHED();
>+                break;
>             }
>         }
>         minMarginAfterBaselines.append(minMarginAfterBaseline);
>@@ -1304,7 +1312,7 @@ void RenderFlexibleBox::alignChildren(const Vector<LineContext>& lineContexts)
>         LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
>         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = m_orderIterator.next()) {
>             ASSERT(child);
>-            if (alignmentForChild(*child) == AlignBaseline && !hasAutoMarginsInCrossAxis(*child) && minMarginAfterBaseline)
>+            if (alignmentForChild(*child) == ItemPositionBaseline && !hasAutoMarginsInCrossAxis(*child) && minMarginAfterBaseline)
>                 adjustAlignmentForChild(*child, minMarginAfterBaseline);
>         }
>     }
>diff --git a/Source/WebCore/rendering/RenderFlexibleBox.h b/Source/WebCore/rendering/RenderFlexibleBox.h
>index bbbc3ede87084f3213c07d2f9675ee7e0ad0943b..855a6725a48d183cc31c5d0ac59bc8693c4abbc6 100644
>--- a/Source/WebCore/rendering/RenderFlexibleBox.h
>+++ b/Source/WebCore/rendering/RenderFlexibleBox.h
>@@ -118,7 +118,7 @@ private:
>     // FIXME: Supporting layout deltas.
>     void setFlowAwareLocationForChild(RenderBox& child, const LayoutPoint&);
>     void adjustAlignmentForChild(RenderBox& child, LayoutUnit);
>-    EAlignItems alignmentForChild(RenderBox& child) const;
>+    ItemPosition alignmentForChild(RenderBox& child) const;
>     LayoutUnit mainAxisBorderAndPaddingExtentForChild(RenderBox& child) const;
>     LayoutUnit mainAxisScrollbarExtentForChild(RenderBox& child) const;
>     LayoutUnit preferredMainAxisContentExtentForChild(RenderBox& child, bool hasInfiniteLineLength);
>diff --git a/Source/WebCore/rendering/RenderFullScreen.cpp b/Source/WebCore/rendering/RenderFullScreen.cpp
>index 2c3990ef9830dd519b0e178a77f5b6419d1c5f83..fd5eba892d8e2d892e0b3d68c5cc94a609dbad27 100644
>--- a/Source/WebCore/rendering/RenderFullScreen.cpp
>+++ b/Source/WebCore/rendering/RenderFullScreen.cpp
>@@ -90,7 +90,7 @@ static Ref<RenderStyle> createFullScreenStyle()
> 
>     fullscreenStyle.get().setDisplay(FLEX);
>     fullscreenStyle.get().setJustifyContent(JustifyCenter);
>-    fullscreenStyle.get().setAlignItems(AlignCenter);
>+    fullscreenStyle.get().setAlignItems(ItemPositionCenter);
>     fullscreenStyle.get().setFlexDirection(FlowColumn);
>     
>     fullscreenStyle.get().setPosition(FixedPosition);
>diff --git a/Source/WebCore/rendering/RenderMenuList.cpp b/Source/WebCore/rendering/RenderMenuList.cpp
>index 1c8cff61209ea2feb06bf8a56e9a9f87c3d8b16f..45f860c1262db351b3777f0c6f42953e9e36a47a 100644
>--- a/Source/WebCore/rendering/RenderMenuList.cpp
>+++ b/Source/WebCore/rendering/RenderMenuList.cpp
>@@ -118,10 +118,10 @@ void RenderMenuList::adjustInnerStyle()
>     // 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() == AlignCenter) {
>+    if (style().alignItems() == ItemPositionCenter) {
>         innerStyle.setMarginTop(Length());
>         innerStyle.setMarginBottom(Length());
>-        innerStyle.setAlignSelf(AlignFlexStart);
>+        innerStyle.setAlignSelf(ItemPositionFlexStart);
>     }
> 
>     innerStyle.setPaddingLeft(Length(theme().popupInternalPaddingLeft(style()), Fixed));
>diff --git a/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp b/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp
>index 875a6fd7bc148c68dfaa1e0bb499a6c33c942669..3bfc68dc88c5177379d5d91fe1f422542282807e 100644
>--- a/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp
>+++ b/Source/WebCore/rendering/mathml/RenderMathMLRoot.cpp
>@@ -233,7 +233,7 @@ void RenderMathMLRoot::updateStyle()
>     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(AlignBaseline);
>+    baseStyle.get().setAlignItems(ItemPositionBaseline);
>     base->setStyle(WTF::move(baseStyle));
>     base->setNeedsLayoutAndPrefWidthsRecalc();
> 
>@@ -244,7 +244,7 @@ void RenderMathMLRoot::updateStyle()
>         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(AlignBaseline);
>+        indexStyle.get().setAlignItems(ItemPositionBaseline);
>         index->setStyle(WTF::move(indexStyle));
>         index->setNeedsLayoutAndPrefWidthsRecalc();
>     }
>diff --git a/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp b/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp
>index d70b6a9ce2f26fa23c4bfc64160b70b857001538..d8c3bbdff1bf4395f7f52cde87b7055848b1c81f 100644
>--- a/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp
>+++ b/Source/WebCore/rendering/mathml/RenderMathMLScripts.cpp
>@@ -100,7 +100,7 @@ void RenderMathMLScripts::fixAnonymousStyleForSubSupPair(RenderObject* subSupPai
>     // 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 ? AlignFlexStart : AlignFlexEnd);
>+    scriptsStyle.setAlignItems(isPostScript ? ItemPositionFlexStart : ItemPositionFlexEnd);
> 
>     // We set the order property so that the prescripts are drawn before the base.
>     scriptsStyle.setOrder(isPostScript ? 0 : -1);
>@@ -114,7 +114,7 @@ void RenderMathMLScripts::fixAnonymousStyles()
> {
>     // 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(AlignFlexStart);
>+    m_baseWrapper->style().setAlignSelf(ItemPositionFlexStart);
> 
>     // This sets the style for postscript pairs.
>     RenderObject* subSupPair = m_baseWrapper;
>@@ -134,7 +134,7 @@ void RenderMathMLScripts::fixAnonymousStyles()
>             RenderStyle& scriptsStyle = subSupPair->style();
>             scriptsStyle.setFlexDirection(FlowRow);
>             scriptsStyle.setJustifyContent(JustifyFlexStart);
>-            scriptsStyle.setAlignItems(AlignCenter);
>+            scriptsStyle.setAlignItems(ItemPositionCenter);
>             scriptsStyle.setOrder(0);
>             scriptsStyle.setFontSize(style().fontSize());
>         }
>diff --git a/Source/WebCore/rendering/style/ContentData.h b/Source/WebCore/rendering/style/ContentData.h
>index aa47e58a43afc4a114a096ea79bb918d4ad361b8..0aada5b563f879b283929bdfb90a9e2607284a8e 100644
>--- a/Source/WebCore/rendering/style/ContentData.h
>+++ b/Source/WebCore/rendering/style/ContentData.h
>@@ -99,7 +99,10 @@ public:
> private:
>     virtual std::unique_ptr<ContentData> cloneInternal() const override
>     {
>-        return std::make_unique<ImageContentData>(m_image.get());
>+        std::unique_ptr<ContentData> image = std::make_unique<ImageContentData>(m_image.get());
>+        image->setAltText(altText());
>+
>+        return image;
>     }
> 
>     RefPtr<StyleImage> m_image;
>diff --git a/Source/WebCore/rendering/style/RenderStyle.cpp b/Source/WebCore/rendering/style/RenderStyle.cpp
>index 37d40fbed3af347c784a6ab97d6764c89ca6b697..4dfc161e22cd2a2f3946db29b7adebf23ff607ea 100644
>--- a/Source/WebCore/rendering/style/RenderStyle.cpp
>+++ b/Source/WebCore/rendering/style/RenderStyle.cpp
>@@ -171,6 +171,14 @@ ALWAYS_INLINE RenderStyle::RenderStyle(const RenderStyle& o)
> {
> }
> 
>+ItemPosition RenderStyle::resolveAlignment(const RenderStyle& parentStyle, const RenderStyle& childStyle, ItemPosition resolvedAutoPositionForRenderer)
>+{
>+    // The auto keyword computes to the parent's align-items computed value, or to "stretch", if not set or "auto".
>+    if (childStyle.alignSelf() == ItemPositionAuto)
>+        return (parentStyle.alignItems() == ItemPositionAuto) ? resolvedAutoPositionForRenderer : parentStyle.alignItems();
>+    return childStyle.alignSelf();
>+}
>+
> void RenderStyle::inheritFrom(const RenderStyle* inheritParent, IsAtShadowBoundary isAtShadowBoundary)
> {
>     if (isAtShadowBoundary == AtShadowBoundary) {
>diff --git a/Source/WebCore/rendering/style/RenderStyle.h b/Source/WebCore/rendering/style/RenderStyle.h
>index 563b8d9f410552251d8572d60bbda9f841c0d809..686a01a564fba8c62d3c8ded58f6d3888aff2a9e 100644
>--- a/Source/WebCore/rendering/style/RenderStyle.h
>+++ b/Source/WebCore/rendering/style/RenderStyle.h
>@@ -491,6 +491,8 @@ public:
>     // Create a RenderStyle for generated content by inheriting from a pseudo style.
>     static Ref<RenderStyle> createStyleInheritingFromPseudoStyle(const RenderStyle& pseudoStyle);
> 
>+    static ItemPosition resolveAlignment(const RenderStyle& parentStyle, const RenderStyle& childStyle, ItemPosition resolvedAutoPositionForRenderer);
>+
>     enum IsAtShadowBoundary {
>         AtShadowBoundary,
>         NotAtShadowBoundary,
>@@ -905,15 +907,17 @@ public:
>     float flexShrink() const { return rareNonInheritedData->m_flexibleBox->m_flexShrink; }
>     const Length& flexBasis() const { return rareNonInheritedData->m_flexibleBox->m_flexBasis; }
>     EAlignContent alignContent() const { return static_cast<EAlignContent>(rareNonInheritedData->m_alignContent); }
>-    EAlignItems alignItems() const { return static_cast<EAlignItems>(rareNonInheritedData->m_alignItems); }
>-    EAlignItems alignSelf() const { return static_cast<EAlignItems>(rareNonInheritedData->m_alignSelf); }
>+    ItemPosition alignItems() const { return static_cast<ItemPosition>(rareNonInheritedData->m_alignItems); }
>+    OverflowAlignment alignItemsOverflowAlignment() const { return static_cast<OverflowAlignment>(rareNonInheritedData->m_alignItemsOverflowAlignment); }
>+    ItemPosition alignSelf() const { return static_cast<ItemPosition>(rareNonInheritedData->m_alignSelf); }
>+    OverflowAlignment alignSelfOverflowAlignment() const { return static_cast<OverflowAlignment>(rareNonInheritedData->m_alignSelfOverflowAlignment); }
>     EFlexDirection flexDirection() const { return static_cast<EFlexDirection>(rareNonInheritedData->m_flexibleBox->m_flexDirection); }
>     bool isColumnFlexDirection() const { return flexDirection() == FlowColumn || flexDirection() == FlowColumnReverse; }
>     bool isReverseFlexDirection() const { return flexDirection() == FlowRowReverse || flexDirection() == FlowColumnReverse; }
>     EFlexWrap flexWrap() const { return static_cast<EFlexWrap>(rareNonInheritedData->m_flexibleBox->m_flexWrap); }
>     EJustifyContent justifyContent() const { return static_cast<EJustifyContent>(rareNonInheritedData->m_justifyContent); }
>-    EJustifySelf justifySelf() const { return static_cast<EJustifySelf>(rareNonInheritedData->m_justifySelf); }
>-    EJustifySelfOverflowAlignment justifySelfOverflowAlignment() const { return static_cast<EJustifySelfOverflowAlignment>(rareNonInheritedData->m_justifySelfOverflowAlignment); }
>+    ItemPosition justifySelf() const { return static_cast<ItemPosition>(rareNonInheritedData->m_justifySelf); }
>+    OverflowAlignment justifySelfOverflowAlignment() const { return static_cast<OverflowAlignment>(rareNonInheritedData->m_justifySelfOverflowAlignment); }
> 
> #if ENABLE(CSS_GRID_LAYOUT)
>     const Vector<GridTrackSize>& gridColumns() const { return rareNonInheritedData->m_grid->m_gridColumns; }
>@@ -1481,13 +1485,15 @@ public:
>     void setFlexBasis(Length length) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexBasis, WTF::move(length)); }
>     void setOrder(int o) { SET_VAR(rareNonInheritedData, m_order, o); }
>     void setAlignContent(EAlignContent p) { SET_VAR(rareNonInheritedData, m_alignContent, p); }
>-    void setAlignItems(EAlignItems a) { SET_VAR(rareNonInheritedData, m_alignItems, a); }
>-    void setAlignSelf(EAlignItems a) { SET_VAR(rareNonInheritedData, m_alignSelf, a); }
>+    void setAlignItems(ItemPosition a) { SET_VAR(rareNonInheritedData, m_alignItems, a); }
>+    void setAlignItemsOverflowAlignment(OverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_alignItemsOverflowAlignment, overflowAlignment); }
>+    void setAlignSelf(ItemPosition a) { SET_VAR(rareNonInheritedData, m_alignSelf, a); }
>+    void setAlignSelfOverflowAlignment(OverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_alignSelfOverflowAlignment, overflowAlignment); }
>     void setFlexDirection(EFlexDirection direction) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexDirection, direction); }
>     void setFlexWrap(EFlexWrap w) { SET_VAR(rareNonInheritedData.access()->m_flexibleBox, m_flexWrap, w); }
>     void setJustifyContent(EJustifyContent p) { SET_VAR(rareNonInheritedData, m_justifyContent, p); }
>-    void setJustifySelf(EJustifySelf p) { SET_VAR(rareNonInheritedData, m_justifySelf, p); }
>-    void setJustifySelfOverflowAlignment(EJustifySelfOverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_justifySelfOverflowAlignment, overflowAlignment); }
>+    void setJustifySelf(ItemPosition p) { SET_VAR(rareNonInheritedData, m_justifySelf, p); }
>+    void setJustifySelfOverflowAlignment(OverflowAlignment overflowAlignment) { SET_VAR(rareNonInheritedData, m_justifySelfOverflowAlignment, overflowAlignment); }
> #if ENABLE(CSS_GRID_LAYOUT)
>     void setGridAutoColumns(const GridTrackSize& length) { SET_VAR(rareNonInheritedData.access()->m_grid, m_gridAutoColumns, length); }
>     void setGridAutoRows(const GridTrackSize& length) { SET_VAR(rareNonInheritedData.access()->m_grid, m_gridAutoRows, length); }
>@@ -1773,6 +1779,7 @@ public:
>     bool isDisplayReplacedType() const { return isDisplayReplacedType(display()); }
>     bool isDisplayInlineType() const { return isDisplayInlineType(display()); }
>     bool isOriginalDisplayInlineType() const { return isDisplayInlineType(originalDisplay()); }
>+    bool isDisplayFlexibleOrGridBox() const { return isDisplayFlexibleOrGridBox(display()); }
>     bool isDisplayRegionType() const
>     {
>         return display() == BLOCK || display() == INLINE_BLOCK
>@@ -1896,13 +1903,15 @@ public:
>     static Length initialFlexBasis() { return Length(Auto); }
>     static int initialOrder() { return 0; }
>     static EAlignContent initialAlignContent() { return AlignContentStretch; }
>-    static EAlignItems initialAlignItems() { return AlignStretch; }
>-    static EAlignItems initialAlignSelf() { return AlignAuto; }
>+    static ItemPosition initialAlignItems() { return ItemPositionAuto; }
>+    static OverflowAlignment initialAlignItemsOverflowAlignment() { return OverflowAlignmentDefault; }
>+    static ItemPosition initialAlignSelf() { return ItemPositionAuto; }
>+    static OverflowAlignment initialAlignSelfOverflowAlignment() { return OverflowAlignmentDefault; }
>     static EFlexDirection initialFlexDirection() { return FlowRow; }
>     static EFlexWrap initialFlexWrap() { return FlexNoWrap; }
>     static EJustifyContent initialJustifyContent() { return JustifyFlexStart; }
>-    static EJustifySelf initialJustifySelf() { return JustifySelfAuto; }
>-    static EJustifySelfOverflowAlignment initialJustifySelfOverflowAlignment() { return JustifySelfOverflowAlignmentDefault; }
>+    static ItemPosition initialJustifySelf() { return ItemPositionAuto; }
>+    static OverflowAlignment initialJustifySelfOverflowAlignment() { return OverflowAlignmentDefault; }
>     static int initialMarqueeLoopCount() { return -1; }
>     static int initialMarqueeSpeed() { return 85; }
>     static Length initialMarqueeIncrement() { return Length(6, Fixed); }
>@@ -2094,6 +2103,26 @@ private:
>         return display == INLINE || isDisplayReplacedType(display);
>     }
> 
>+    bool isDisplayFlexibleBox(EDisplay display) const
>+    {
>+        return display == FLEX || display == INLINE_FLEX;
>+    }
>+
>+    bool isDisplayGridBox(EDisplay display) const
>+    {
>+#if ENABLE(CSS_GRID_LAYOUT)
>+        return display == GRID || display == INLINE_GRID;
>+#else
>+        UNUSED_PARAM(display);
>+        return false;
>+#endif
>+    }
>+
>+    bool isDisplayFlexibleOrGridBox(EDisplay display) const
>+    {
>+        return isDisplayFlexibleBox(display) || isDisplayGridBox(display);
>+    }
>+
>     // Color accessors are all private to make sure callers use visitedDependentColor instead to access them.
>     static Color invalidColor() { return Color(); }
>     Color borderLeftColor() const { return surround->border.left().color(); }
>diff --git a/Source/WebCore/rendering/style/RenderStyleConstants.h b/Source/WebCore/rendering/style/RenderStyleConstants.h
>index cc9492d607d0eb3f6b12a1c4eafa9af31b715098..e56a68eb49e0a43bc867c7b805996a0116f86aa9 100644
>--- a/Source/WebCore/rendering/style/RenderStyleConstants.h
>+++ b/Source/WebCore/rendering/style/RenderStyleConstants.h
>@@ -245,12 +245,11 @@ enum EBoxDirection { BNORMAL, BREVERSE };
> // 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 EJustifySelf {JustifySelfAuto, JustifySelfStretch, JustifySelfBaseline, JustifySelfCenter, JustifySelfStart, JustifySelfEnd, JustifySelfSelfStart, JustifySelfSelfEnd, JustifySelfFlexStart, JustifySelfFlexEnd, JustifySelfLeft, JustifySelfRight};
>-enum EJustifySelfOverflowAlignment {JustifySelfOverflowAlignmentDefault, JustifySelfOverflowAlignmentTrue, JustifySelfOverflowAlignmentSafe};
>+enum ItemPosition {ItemPositionAuto, ItemPositionStretch, ItemPositionBaseline, ItemPositionLastBaseline, ItemPositionCenter, ItemPositionStart, ItemPositionEnd, ItemPositionSelfStart, ItemPositionSelfEnd, ItemPositionFlexStart, ItemPositionFlexEnd, ItemPositionLeft, ItemPositionRight};
>+enum OverflowAlignment {OverflowAlignmentDefault, OverflowAlignmentTrue, OverflowAlignmentSafe};
> 
> 
> enum ETextSecurity {
>diff --git a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp b/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp
>index 8e7be3e9f5aa76e4876c9473bafd9dd8964e9490..3c99bf3a26edd5e23a6858a1fcbc04b3817795b2 100644
>--- a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp
>+++ b/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp
>@@ -83,7 +83,9 @@ StyleRareNonInheritedData::StyleRareNonInheritedData()
>     , 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())
>@@ -134,6 +136,7 @@ inline StyleRareNonInheritedData::StyleRareNonInheritedData(const StyleRareNonIn
> #endif
>     , m_content(o.m_content ? o.m_content->clone() : nullptr)
>     , m_counterDirectives(o.m_counterDirectives ? clone(*o.m_counterDirectives) : nullptr)
>+    , m_altText(o.m_altText)
>     , m_boxShadow(o.m_boxShadow ? std::make_unique<ShadowData>(*o.m_boxShadow) : nullptr)
>     , m_boxReflect(o.m_boxReflect)
>     , m_animations(o.m_animations ? std::make_unique<AnimationList>(*o.m_animations) : nullptr)
>@@ -170,7 +173,9 @@ inline StyleRareNonInheritedData::StyleRareNonInheritedData(const StyleRareNonIn
>     , 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)
>@@ -265,7 +270,9 @@ bool StyleRareNonInheritedData::operator==(const StyleRareNonInheritedData& o) c
>         && 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
>diff --git a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h b/Source/WebCore/rendering/style/StyleRareNonInheritedData.h
>index 94b884ca8b49b8d70ebc090ea32739493d751b09..61fdc9e3a442af3fd1966277016a3511c98abf7d 100644
>--- a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h
>+++ b/Source/WebCore/rendering/style/StyleRareNonInheritedData.h
>@@ -188,12 +188,14 @@ public:
>     unsigned m_backfaceVisibility : 1; // EBackfaceVisibility
> 
>     unsigned m_alignContent : 3; // EAlignContent
>-    unsigned m_alignItems : 3; // EAlignItems
>-    unsigned m_alignSelf : 3; // EAlignItems
>+    unsigned m_alignItems : 4; // ItemPosition
>+    unsigned m_alignItemsOverflowAlignment : 2; // OverflowAlignment
>+    unsigned m_alignSelf : 4; // ItemPosition
>+    unsigned m_alignSelfOverflowAlignment : 2; // OverflowAlignment
>     unsigned m_justifyContent : 3; // EJustifyContent
> 
>-    unsigned m_justifySelf : 4; // EJustifySelf
>-    unsigned m_justifySelfOverflowAlignment : 2; // EJustifySelfOverflowAlignment
>+    unsigned m_justifySelf : 4; // ItemPosition
>+    unsigned m_justifySelfOverflowAlignment : 2; // OverflowAlignment
> 
>     unsigned userDrag : 2; // EUserDrag
>     unsigned textOverflow : 1; // Whether or not lines that spill out should be truncated with "..."
>diff --git a/Source/WebCore/style/StyleResolveTree.cpp b/Source/WebCore/style/StyleResolveTree.cpp
>index 649cfc6027bf1dc80a20da33be9f9c7e1ec3b928..ef39a1f0c312fb5088f4048e5a6e99574a35cd20 100644
>--- a/Source/WebCore/style/StyleResolveTree.cpp
>+++ b/Source/WebCore/style/StyleResolveTree.cpp
>@@ -121,6 +121,8 @@ Change determineChange(const RenderStyle& s1, const RenderStyle& s2)
>     // a separate render region object.
>     if (s1.hasFlowFrom() && (s1.specifiesColumns() != s2.specifiesColumns()))
>         return Detach;
>+    if (s1.alignItems() != s2.alignItems())
>+        return Detach;
> 
>     if (s1 != s2) {
>         if (s1.inheritedNotEqual(&s2))
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 28860ed8c9ba4c4bb6258a6044d86a40ffdd257e..aea7d1c940d5119d7e6dc16681c506f5a9f97e6c 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,35 @@
>+2015-03-12  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 NOBODY (OOPS!).
>+
>+        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.
>+
>+        * TestExpectations:
>+        * 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:
>+        * fast/css/parse-justify-self-expected.txt:
>+        * fast/css/parse-justify-self.html:
>+        * svg/css/getComputedStyle-basic-expected.txt:
>+
> 2015-03-12  Hunseop Jeong  <hs85.jeong@samsung.com>
> 
>         Unreviewed EFL gardening on 13th Mar.  
>diff --git a/LayoutTests/TestExpectations b/LayoutTests/TestExpectations
>index f400fc1dcf1253179092db8c9e4fd4aa916021e1..110709f55dd510e6a2f7d908cec333724f1bd5b5 100644
>--- a/LayoutTests/TestExpectations
>+++ b/LayoutTests/TestExpectations
>@@ -75,6 +75,10 @@ webkit.org/b/140491 js/class-syntax-super.html [ Failure ]
> # This test verifies dynamic manipulation of the mroot and msqrt elements.
> mathml/roots-removeChild.html [ ImageOnlyFailure ]
> 
>+webkit.org/b/133359 mathml/presentation/style-changed.html [ ImageOnlyFailure ]
>+webkit.org/b/136291 platform/mac/accessibility/webkit-alt-for-css-content.html [ Failure ]
>+webkit.org/b/136291 platform/mac/accessibility/alt-for-css-content.html [ Failure ]
>+
> # This test verifies that a mismatch reftest will fail as intended if both results are same. (introduced in r93187)
> fast/harness/sample-fail-mismatch-reftest.html [ WontFix ImageOnlyFailure ]
> 
>diff --git a/LayoutTests/css3/flexbox/css-properties-expected.txt b/LayoutTests/css3/flexbox/css-properties-expected.txt
>index 16ab20e835c3bc53a381900ded4be99c658945e5..1dd7378e5a41180e5f55aa9464904b043ed5309f 100644
>--- a/LayoutTests/css3/flexbox/css-properties-expected.txt
>+++ b/LayoutTests/css3/flexbox/css-properties-expected.txt
>@@ -29,11 +29,12 @@ PASS window.getComputedStyle(flexbox, null).webkitJustifyContent is "space-betwe
> 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 "stretch"
>-PASS window.getComputedStyle(document.documentElement, null).webkitAlignSelf is "stretch"
>+PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "start"
>+PASS window.getComputedStyle(document.documentElement, null).webkitAlignSelf is "start"
> 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 "stretch"
>+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"
>@@ -45,15 +46,21 @@ PASS window.getComputedStyle(flexbox, null).webkitAlignSelf is "stretch"
> 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 "stretch"
>+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 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"
>@@ -72,8 +79,8 @@ PASS flexbox.style.webkitAlignItems is ""
> 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 "stretch"
>-PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "stretch"
>+PASS window.getComputedStyle(flexbox, null).webkitAlignItems is "auto"
>+PASS window.getComputedStyle(flexitem, null).webkitAlignSelf is "auto"
> PASS window.getComputedStyle(detachedFlexbox, null).webkitAlignSelf is ""
> PASS window.getComputedStyle(detachedFlexItem, null).webkitAlignSelf is ""
> PASS flexbox.style.webkitFlexDirection is ""
>diff --git a/LayoutTests/css3/flexbox/css-properties.html b/LayoutTests/css3/flexbox/css-properties.html
>index d721efc872a3d13a0f75087113079d0a40fcf619..e219e2d1abe4e39b48de5239a3e4207e280e5fc1 100644
>--- a/LayoutTests/css3/flexbox/css-properties.html
>+++ b/LayoutTests/css3/flexbox/css-properties.html
>@@ -78,18 +78,20 @@ flexbox.style.webkitJustifyContent = '';
> 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 'stretch'.
>-shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'stretch');
>-shouldBeEqualToString('window.getComputedStyle(document.documentElement, null).webkitAlignSelf', 'stretch');
>+// 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', 'start');
> 
> 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', 'stretch');
>+shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');
> 
> flexbox.style.webkitAlignSelf = 'flex-start';
> shouldBeEqualToString('flexbox.style.webkitAlignSelf', 'flex-start');
>@@ -113,23 +115,29 @@ shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf',
> 
> flexbox.style.webkitAlignSelf = '';
> shouldBeEqualToString('flexbox.style.webkitAlignSelf', '');
>-shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'stretch');
>+shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignSelf', 'start');
> 
> shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
>-// The initial value is 'stretch'.
>+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', '');
>+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');
> 
>@@ -160,8 +168,8 @@ shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf',
> 
> flexbox.style.display = 'none';
> shouldBeEqualToString('flexbox.style.webkitAlignItems', '');
>-shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'stretch');
>-shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'stretch');
>+shouldBeEqualToString('window.getComputedStyle(flexbox, null).webkitAlignItems', 'auto');
>+shouldBeEqualToString('window.getComputedStyle(flexitem, null).webkitAlignSelf', 'auto');
> flexbox.style.display = '';
> 
> 
>diff --git a/LayoutTests/css3/parse-align-items-expected.txt b/LayoutTests/css3/parse-align-items-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..d5ed30e86ceceb82a86dc1d154f9d043c521ff6e
>--- /dev/null
>+++ b/LayoutTests/css3/parse-align-items-expected.txt
>@@ -0,0 +1,137 @@
>+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
>+
>diff --git a/LayoutTests/css3/parse-align-items.html b/LayoutTests/css3/parse-align-items.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..d6f1dabdceadbe911da24b3f99a584f7100240ee
>--- /dev/null
>+++ b/LayoutTests/css3/parse-align-items.html
>@@ -0,0 +1,270 @@
>+<!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>
>diff --git a/LayoutTests/css3/parse-align-self-expected.txt b/LayoutTests/css3/parse-align-self-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..5b981351c90c0c3dee628f300a31f3cc46ff239b
>--- /dev/null
>+++ b/LayoutTests/css3/parse-align-self-expected.txt
>@@ -0,0 +1,155 @@
>+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 "auto"
>+
>+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 "auto"
>+
>+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 "auto"
>+
>+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
>+
>diff --git a/LayoutTests/css3/parse-align-self.html b/LayoutTests/css3/parse-align-self.html
>new file mode 100644
>index 0000000000000000000000000000000000000000..6480a680b9c5e27c96afdf20163514eb14b524a2
>--- /dev/null
>+++ b/LayoutTests/css3/parse-align-self.html
>@@ -0,0 +1,291 @@
>+<!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", "auto");
>+
>+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", "auto");
>+
>+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", "auto");
>+
>+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>
>diff --git a/LayoutTests/css3/resources/alignment-parsing-utils.js b/LayoutTests/css3/resources/alignment-parsing-utils.js
>new file mode 100644
>index 0000000000000000000000000000000000000000..b97022a88c65762a347e2686428d51a24d38ed82
>--- /dev/null
>+++ b/LayoutTests/css3/resources/alignment-parsing-utils.js
>@@ -0,0 +1,46 @@
>+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);
>+}
>diff --git a/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt b/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt
>index 089f3a9ac126e8af698db866a9210b9d6c458c4e..e41361849c3cbcf85a6cbf59f52e3eb3ea69368f 100644
>--- a/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt
>+++ b/LayoutTests/fast/css/getComputedStyle/computed-style-expected.txt
>@@ -144,11 +144,12 @@ column-rule-width: 0px;
> column-span: none;
> column-width: auto;
> align-content: stretch;
>-align-items: stretch;
>-align-self: stretch;
>+align-items: start;
>+align-self: start;
> flex-direction: row;
> flex-wrap: nowrap;
> justify-content: flex-start;
>+justify-self: start;
> -webkit-font-kerning: auto;
> -webkit-font-smoothing: auto;
> -webkit-font-variant-ligatures: normal;
>diff --git a/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt b/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt
>index a9efff51658cd8c77dda95ff401cdfc269b453e2..6abe328de244c3d6aea35cb2ed17eb1e9a2f5499 100644
>--- a/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt
>+++ b/LayoutTests/fast/css/getComputedStyle/computed-style-without-renderer-expected.txt
>@@ -143,11 +143,12 @@ column-rule-width: 0px
> column-span: none
> column-width: auto
> align-content: stretch
>-align-items: stretch
>-align-self: stretch
>+align-items: start
>+align-self: start
> flex-direction: row
> flex-wrap: nowrap
> justify-content: flex-start
>+justify-self: start
> -webkit-font-kerning: auto
> -webkit-font-smoothing: auto
> -webkit-font-variant-ligatures: normal
>diff --git a/LayoutTests/fast/css/getComputedStyle/resources/property-names.js b/LayoutTests/fast/css/getComputedStyle/resources/property-names.js
>index 4ac0a80db664ce1e01f71c4bbc738ffcb6c0907c..d7e20fe00bf17d11cd1c2b4b1136cada53b4df12 100644
>--- a/LayoutTests/fast/css/getComputedStyle/resources/property-names.js
>+++ b/LayoutTests/fast/css/getComputedStyle/resources/property-names.js
>@@ -65,6 +65,7 @@ var propertiesToTest = {
>     "-webkit-hyphenate-limit-lines": true,
>     "-webkit-hyphens": true,
>     "justify-content": true,
>+    "justify-self": true,
>     "-webkit-line-align": true,
>     "-webkit-line-box-contain": true,
>     "-webkit-line-break": true,
>diff --git a/LayoutTests/fast/css/parse-justify-self-expected.txt b/LayoutTests/fast/css/parse-justify-self-expected.txt
>index 52953fe78bedab24df745473b94283c002483d36..9d7fa817224f1c80f828aa9b61de8893438a8ae3 100644
>--- a/LayoutTests/fast/css/parse-justify-self-expected.txt
>+++ b/LayoutTests/fast/css/parse-justify-self-expected.txt
>@@ -4,58 +4,56 @@ On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE
> 
> 
> Test getting justify-self set through CSS
>-PASS getComputedStyle(justifySelfBaseline, '').getPropertyValue('-webkit-justify-self') is 'baseline'
>-PASS getComputedStyle(justifySelfStretch, '').getPropertyValue('-webkit-justify-self') is 'stretch'
>-PASS getComputedStyle(justifySelfStart, '').getPropertyValue('-webkit-justify-self') is 'start'
>-PASS getComputedStyle(justifySelfEnd, '').getPropertyValue('-webkit-justify-self') is 'end'
>-PASS getComputedStyle(justifySelfCenter, '').getPropertyValue('-webkit-justify-self') is 'center'
>-PASS getComputedStyle(justifySelfSelfEnd, '').getPropertyValue('-webkit-justify-self') is 'self-end'
>-PASS getComputedStyle(justifySelfSelfStart, '').getPropertyValue('-webkit-justify-self') is 'self-start'
>-PASS getComputedStyle(justifySelfLeft, '').getPropertyValue('-webkit-justify-self') is 'left'
>-PASS getComputedStyle(justifySelfRight, '').getPropertyValue('-webkit-justify-self') is 'right'
>-PASS getComputedStyle(justifySelfEndTrue, '').getPropertyValue('-webkit-justify-self') is 'end true'
>-PASS getComputedStyle(justifySelfCenterTrue, '').getPropertyValue('-webkit-justify-self') is 'center true'
>-PASS getComputedStyle(justifySelfSelfEndSafe, '').getPropertyValue('-webkit-justify-self') is 'self-end safe'
>-PASS getComputedStyle(justifySelfSelfStartSafe, '').getPropertyValue('-webkit-justify-self') is 'self-start safe'
>-PASS getComputedStyle(justifySelfRightSafe, '').getPropertyValue('-webkit-justify-self') is 'right safe'
>-PASS getComputedStyle(justifySelfLeftTrue, '').getPropertyValue('-webkit-justify-self') is 'left true'
>+PASS getComputedStyle(justifySelfBaseline, '').getPropertyValue('justify-self') is 'baseline'
>+PASS getComputedStyle(justifySelfStretch, '').getPropertyValue('justify-self') is 'stretch'
>+PASS getComputedStyle(justifySelfStart, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(justifySelfEnd, '').getPropertyValue('justify-self') is 'end'
>+PASS getComputedStyle(justifySelfCenter, '').getPropertyValue('justify-self') is 'center'
>+PASS getComputedStyle(justifySelfSelfEnd, '').getPropertyValue('justify-self') is 'self-end'
>+PASS getComputedStyle(justifySelfSelfStart, '').getPropertyValue('justify-self') is 'self-start'
>+PASS getComputedStyle(justifySelfLeft, '').getPropertyValue('justify-self') is 'left'
>+PASS getComputedStyle(justifySelfRight, '').getPropertyValue('justify-self') is 'right'
>+PASS getComputedStyle(justifySelfEndTrue, '').getPropertyValue('justify-self') is 'end true'
>+PASS getComputedStyle(justifySelfCenterTrue, '').getPropertyValue('justify-self') is 'center true'
>+PASS getComputedStyle(justifySelfSelfEndSafe, '').getPropertyValue('justify-self') is 'self-end safe'
>+PASS getComputedStyle(justifySelfSelfStartSafe, '').getPropertyValue('justify-self') is 'self-start safe'
>+PASS getComputedStyle(justifySelfRightSafe, '').getPropertyValue('justify-self') is 'right safe'
>+PASS getComputedStyle(justifySelfLeftTrue, '').getPropertyValue('justify-self') is 'left true'
> 
> Test initial value of justify-self through JS
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
> 
> Test getting and setting justify-self through JS
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'center'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'start true'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-
>-Test bad combinaisons of justify-self
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'center'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start true'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+
>+Test bad combinations of justify-self
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
> 
> Test the value 'initial'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'center'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'auto'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'center'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'start'
> 
> Test the value 'inherit'
>-PASS getComputedStyle(parentElement, '').getPropertyValue('-webkit-justify-self') is 'end'
>-PASS getComputedStyle(element, '').getPropertyValue('-webkit-justify-self') is 'end'
>+PASS getComputedStyle(parentElement, '').getPropertyValue('justify-self') is 'end'
>+PASS getComputedStyle(element, '').getPropertyValue('justify-self') is 'end'
> PASS successfullyParsed is true
> 
> TEST COMPLETE
>diff --git a/LayoutTests/fast/css/parse-justify-self.html b/LayoutTests/fast/css/parse-justify-self.html
>index 85bed48492604736c8bfe389a7226e781d83cd35..e77c42396855232efa50154f8926b59a7ec79d8c 100644
>--- a/LayoutTests/fast/css/parse-justify-self.html
>+++ b/LayoutTests/fast/css/parse-justify-self.html
>@@ -3,63 +3,63 @@
> <head>
> <style>
> #justifySelfBaseline {
>-    -webkit-justify-self: baseline;
>+    justify-self: baseline;
> }
> 
> #justifySelfStretch {
>-    -webkit-justify-self: stretch;
>+    justify-self: stretch;
> }
> 
> #justifySelfStart {
>-    -webkit-justify-self: start;
>+    justify-self: start;
> }
> 
> #justifySelfEnd {
>-    -webkit-justify-self: end;
>+    justify-self: end;
> }
> 
> #justifySelfCenter {
>-    -webkit-justify-self: center;
>+    justify-self: center;
> }
> 
> #justifySelfSelfStart {
>-    -webkit-justify-self: self-start;
>+    justify-self: self-start;
> }
> 
> #justifySelfSelfEnd {
>-    -webkit-justify-self: self-end;
>+    justify-self: self-end;
> }
> 
> #justifySelfLeft {
>-    -webkit-justify-self: left;
>+    justify-self: left;
> }
> 
> #justifySelfRight {
>-    -webkit-justify-self: right;
>+    justify-self: right;
> }
> 
> #justifySelfEndTrue {
>-    -webkit-justify-self: end true;
>+    justify-self: end true;
> }
> 
> #justifySelfCenterTrue {
>-    -webkit-justify-self: center true;
>+    justify-self: center true;
> }
> 
> #justifySelfSelfEndSafe {
>-    -webkit-justify-self: self-end safe;
>+    justify-self: self-end safe;
> }
> 
> #justifySelfSelfStartSafe {
>-    -webkit-justify-self: self-start safe;
>+    justify-self: self-start safe;
> }
> 
> #justifySelfRightSafe {
>-    -webkit-justify-self: right safe;
>+    justify-self: right safe;
> }
> 
> #justifySelfLeftTrue {
>-    -webkit-justify-self: left true;
>+    justify-self: left true;
> }
> </style>
> <script src="../../resources/js-test.js"></script>
>@@ -86,150 +86,144 @@ description('Test that setting and getting justify-self works as expected');
> 
> debug("Test getting justify-self set through CSS");
> var justifySelfBaseline = document.getElementById("justifySelfBaseline");
>-shouldBe("getComputedStyle(justifySelfBaseline, '').getPropertyValue('-webkit-justify-self')", "'baseline'");
>+shouldBe("getComputedStyle(justifySelfBaseline, '').getPropertyValue('justify-self')", "'baseline'");
> 
> var justifySelfStretch = document.getElementById("justifySelfStretch");
>-shouldBe("getComputedStyle(justifySelfStretch, '').getPropertyValue('-webkit-justify-self')", "'stretch'");
>+shouldBe("getComputedStyle(justifySelfStretch, '').getPropertyValue('justify-self')", "'stretch'");
> 
> var justifySelfStart = document.getElementById("justifySelfStart");
>-shouldBe("getComputedStyle(justifySelfStart, '').getPropertyValue('-webkit-justify-self')", "'start'");
>+shouldBe("getComputedStyle(justifySelfStart, '').getPropertyValue('justify-self')", "'start'");
> 
> var justifySelfEnd = document.getElementById("justifySelfEnd");
>-shouldBe("getComputedStyle(justifySelfEnd, '').getPropertyValue('-webkit-justify-self')", "'end'");
>+shouldBe("getComputedStyle(justifySelfEnd, '').getPropertyValue('justify-self')", "'end'");
> 
> var justifySelfCenter = document.getElementById("justifySelfCenter");
>-shouldBe("getComputedStyle(justifySelfCenter, '').getPropertyValue('-webkit-justify-self')", "'center'");
>+shouldBe("getComputedStyle(justifySelfCenter, '').getPropertyValue('justify-self')", "'center'");
> 
> var justifySelfSelfEnd = document.getElementById("justifySelfSelfEnd");
>-shouldBe("getComputedStyle(justifySelfSelfEnd, '').getPropertyValue('-webkit-justify-self')", "'self-end'");
>+shouldBe("getComputedStyle(justifySelfSelfEnd, '').getPropertyValue('justify-self')", "'self-end'");
> 
> var justifySelfSelfStart = document.getElementById("justifySelfSelfStart");
>-shouldBe("getComputedStyle(justifySelfSelfStart, '').getPropertyValue('-webkit-justify-self')", "'self-start'");
>+shouldBe("getComputedStyle(justifySelfSelfStart, '').getPropertyValue('justify-self')", "'self-start'");
> 
> var justifySelfLeft = document.getElementById("justifySelfLeft");
>-shouldBe("getComputedStyle(justifySelfLeft, '').getPropertyValue('-webkit-justify-self')", "'left'");
>+shouldBe("getComputedStyle(justifySelfLeft, '').getPropertyValue('justify-self')", "'left'");
> 
> var justifySelfRight = document.getElementById("justifySelfRight");
>-shouldBe("getComputedStyle(justifySelfRight, '').getPropertyValue('-webkit-justify-self')", "'right'");
>+shouldBe("getComputedStyle(justifySelfRight, '').getPropertyValue('justify-self')", "'right'");
> 
> var justifySelfEndTrue = document.getElementById("justifySelfEndTrue");
>-shouldBe("getComputedStyle(justifySelfEndTrue, '').getPropertyValue('-webkit-justify-self')", "'end true'");
>+shouldBe("getComputedStyle(justifySelfEndTrue, '').getPropertyValue('justify-self')", "'end true'");
> 
> var justifySelfCenterTrue = document.getElementById("justifySelfCenterTrue");
>-shouldBe("getComputedStyle(justifySelfCenterTrue, '').getPropertyValue('-webkit-justify-self')", "'center true'");
>+shouldBe("getComputedStyle(justifySelfCenterTrue, '').getPropertyValue('justify-self')", "'center true'");
> 
> var justifySelfSelfEndSafe = document.getElementById("justifySelfSelfEndSafe");
>-shouldBe("getComputedStyle(justifySelfSelfEndSafe, '').getPropertyValue('-webkit-justify-self')", "'self-end safe'");
>+shouldBe("getComputedStyle(justifySelfSelfEndSafe, '').getPropertyValue('justify-self')", "'self-end safe'");
> 
> var justifySelfSelfStartSafe = document.getElementById("justifySelfSelfStartSafe");
>-shouldBe("getComputedStyle(justifySelfSelfStartSafe, '').getPropertyValue('-webkit-justify-self')", "'self-start safe'");
>+shouldBe("getComputedStyle(justifySelfSelfStartSafe, '').getPropertyValue('justify-self')", "'self-start safe'");
> 
> var justifySelfRightSafe = document.getElementById("justifySelfRightSafe");
>-shouldBe("getComputedStyle(justifySelfRightSafe, '').getPropertyValue('-webkit-justify-self')", "'right safe'");
>+shouldBe("getComputedStyle(justifySelfRightSafe, '').getPropertyValue('justify-self')", "'right safe'");
> 
> var justifySelfLeftTrue = document.getElementById("justifySelfLeftTrue");
>-shouldBe("getComputedStyle(justifySelfLeftTrue, '').getPropertyValue('-webkit-justify-self')", "'left true'");
>+shouldBe("getComputedStyle(justifySelfLeftTrue, '').getPropertyValue('justify-self')", "'left true'");
> 
> debug("");
> debug("Test initial value of justify-self through JS");
> element = document.createElement("div");
> document.body.appendChild(element);
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
> debug("");
> debug("Test getting and setting justify-self through JS");
> element = document.createElement("div");
> document.body.appendChild(element);
>-element.style.webkitJustifySelf = "center";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'center'");
>+element.style.justifySelf = "center";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'center'");
> 
> element = document.createElement("div");
> document.body.appendChild(element);
>-element.style.webkitJustifySelf = "true start";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'start true'");
>+element.style.justifySelf = "true start";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start true'");
> 
>-element.style.webkitJustifySelf = "auto";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "start";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
> debug("");
>-debug("Test bad combinaisons of justify-self");
>+debug("Test bad combinations of justify-self");
> element = document.createElement("div");
> document.body.appendChild(element);
>-element.style.webkitJustifySelf = "true auto";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "start left";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "auto safe";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "baseline safe";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "auto left";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "baseline center";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "baseline safe";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "stretch true";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "baseline center";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "stretch right";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "stretch true";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "true true";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "stretch right";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "true";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "true true";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "true safe";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "true";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "center start";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "true safe";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "stretch true";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "center start";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "safe stretch";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "stretch true";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "baseline safe";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "safe stretch";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "true baseline";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "baseline safe";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "true safe";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "true baseline";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "true safe left";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "true safe";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "true left safe";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
>-element.style.webkitJustifySelf = "true safe left";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>-
>-element.style.webkitJustifySelf = "true left safe";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>-
>-element.style.webkitJustifySelf = "left safe true safe";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "left safe true safe";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
> debug("");
> debug("Test the value 'initial'");
>-element.style.webkitJustifySelf = "center";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'center'");
>-element.style.webkitJustifySelf = "initial";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'auto'");
>+element.style.justifySelf = "center";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'center'");
>+element.style.justifySelf = "initial";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'start'");
> 
> debug("");
> debug("Test the value 'inherit'");
> parentElement = document.createElement("div");
> document.body.appendChild(parentElement);
>-parentElement.style.webkitJustifySelf = "end";
>-shouldBe("getComputedStyle(parentElement, '').getPropertyValue('-webkit-justify-self')", "'end'");
>+parentElement.style.justifySelf = "end";
>+shouldBe("getComputedStyle(parentElement, '').getPropertyValue('justify-self')", "'end'");
> 
> element = document.createElement("div");
> parentElement.appendChild(element);
>-element.style.webkitJustifySelf = "inherit";
>-shouldBe("getComputedStyle(element, '').getPropertyValue('-webkit-justify-self')", "'end'");
>+element.style.justifySelf = "inherit";
>+shouldBe("getComputedStyle(element, '').getPropertyValue('justify-self')", "'end'");
> </script>
> </body>
> </html>
>diff --git a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt b/LayoutTests/svg/css/getComputedStyle-basic-expected.txt
>index 6587dcee5929cbc8ad92ca7c8ebd470f086a78a9..bdb0edca0a11770d237a68c4ea50e8730d082a98 100644
>--- a/LayoutTests/svg/css/getComputedStyle-basic-expected.txt
>+++ b/LayoutTests/svg/css/getComputedStyle-basic-expected.txt
>@@ -286,16 +286,18 @@ rect: style.getPropertyValue(column-width) : auto
> rect: style.getPropertyCSSValue(column-width) : [object CSSPrimitiveValue]
> rect: style.getPropertyValue(align-content) : stretch
> rect: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]
>-rect: style.getPropertyValue(align-items) : stretch
>-rect: style.getPropertyCSSValue(align-items) : [object CSSPrimitiveValue]
>-rect: style.getPropertyValue(align-self) : stretch
>-rect: style.getPropertyCSSValue(align-self) : [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) : start
>+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
>@@ -798,16 +800,18 @@ g: style.getPropertyValue(column-width) : auto
> g: style.getPropertyCSSValue(column-width) : [object CSSPrimitiveValue]
> g: style.getPropertyValue(align-content) : stretch
> g: style.getPropertyCSSValue(align-content) : [object CSSPrimitiveValue]
>-g: style.getPropertyValue(align-items) : stretch
>-g: style.getPropertyCSSValue(align-items) : [object CSSPrimitiveValue]
>-g: style.getPropertyValue(align-self) : stretch
>-g: style.getPropertyCSSValue(align-self) : [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) : start
>+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

Actions: View | Formatted Diff | Diff

Attachments on bug 133359: 234786 | 234791 | 234793 | 234794 | 234798 | 235769 | 235775 | 235786 | 235793 | 235798 | 235803 | 235903 | 235908 | 235915 | 235920 | 235926 | 235927 | 235928 | 236927 | 236928 | 236929 | 236930 | 237080 | 237085 | 237088 | 237091 | 237224 | 240511 | 241419 | 241420 | 241423 | 241426 | 241479 | 241547 | 241560 | 241591 | 241596 | 241597 | 241615 | 241707 | 241716 | 241718 | 241719 | 241867 | 241872 | 241874 | 241886 | 241889 | 241893 | 248555 | 248558 | 248559 | 248562 | 248563 | 248569 | 248930 | 248934 | 248935 | 248938