[CSS Grid Layout] Adapting align-self, align-items and justify-self to the last CSS 3 spec.

Source/core/css/CSSComputedStyleDeclaration.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ skipping 1540 matching lines @@
         return 0;
     if (m_node->isElementNode()) {
         if (PseudoElement* element = toElement(m_node)->pseudoElement(m_pseudoElementSpecifier))
             return element;
     }
     return m_node.get();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
 {
+    ItemPosition resolvedPosition = itemPosition == ItemPositionAuto ? ItemPositionStart : itemPosition;

[svillar, 2014/07/29 10:40:05]

Maybe we need some ASSERT here? I guess you're assuming that the display: is not
set so we're not talking about a flexbox or a grid.

     RefPtrWillBeRawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
     if (positionType == LegacyPosition)
         result->append(CSSPrimitiveValue::createIdentifier(CSSValueLegacy));
-    result->append(CSSPrimitiveValue::create(itemPosition));
-    if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
+    result->append(CSSPrimitiveValue::create(resolvedPosition));
+    if (resolvedPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(overflowAlignment));
     ASSERT(result->length() <= 2);
     return result.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const
 {
     Node* styledNode = this->styledNode();
     if (!styledNode)
         return nullptr;
@@ skipping 304 matching lines @@
         case CSSPropertyDirection:
             return cssValuePool().createValue(style->direction());
         case CSSPropertyDisplay:
             return cssValuePool().createValue(style->display());
         case CSSPropertyEmptyCells:
             return cssValuePool().createValue(style->emptyCells());
         case CSSPropertyAlignContent:
             return cssValuePool().createValue(style->alignContent());
         case CSSPropertyAlignItems:
             return valueForItemPositionWithOverflowAlignment(style->alignItems(), style->alignItemsOverflowAlignment(), NonLegacyPosition);
-        case CSSPropertyAlignSelf: {
-            ItemPosition alignSelf = style->alignSelf();
-            if (alignSelf == ItemPositionAuto) {
-                Node* parent = styledNode->parentNode();
-                if (parent && parent->computedStyle())
-                    alignSelf = parent->computedStyle()->alignItems();
-                else
-                    alignSelf = ItemPositionStretch;
-            }
-            return valueForItemPositionWithOverflowAlignment(alignSelf, style->alignSelfOverflowAlignment(), NonLegacyPosition);
-        }
+        case CSSPropertyAlignSelf:
+            return valueForItemPositionWithOverflowAlignment(style->alignSelf(), style->alignSelfOverflowAlignment(), NonLegacyPosition);
         case CSSPropertyFlex:
             return valuesForShorthandProperty(flexShorthand());
         case CSSPropertyFlexBasis:
             return zoomAdjustedPixelValueForLength(style->flexBasis(), *style);
         case CSSPropertyFlexDirection:
             return cssValuePool().createValue(style->flexDirection());
         case CSSPropertyFlexFlow:
             return valuesForShorthandProperty(flexFlowShorthand());
         case CSSPropertyFlexGrow:
             return cssValuePool().createValue(style->flexGrow());
@@ skipping 143 matching lines @@
                 return cssValuePool().createIdentifierValue(CSSValueAuto);
             return cssValuePool().createValue(style->hyphenationString(), CSSPrimitiveValue::CSS_STRING);
         case CSSPropertyWebkitBorderFit:
             if (style->borderFit() == BorderFitBorder)
                 return cssValuePool().createIdentifierValue(CSSValueBorder);
             return cssValuePool().createIdentifierValue(CSSValueLines);
         case CSSPropertyImageRendering:
             return CSSPrimitiveValue::create(style->imageRendering());
         case CSSPropertyIsolation:
             return cssValuePool().createValue(style->isolation());
-        case CSSPropertyJustifyItems: {
-            // FIXME: I would like this to be tested; is not possible with a layout test but it
-            // should be possible using a method similar to https://codereview.chromium.org/351973004
-            ItemPosition justifyItems = style->justifyItems();
-            ItemPositionType positionType = style->justifyItemsPositionType();
-            if (justifyItems == ItemPositionAuto) {
-                Node* parent = styledNode->parentNode();
-                // If the inherited value of justify-items includes the legacy keyword, 'auto'
-                // computes to the the inherited value.
-                if (parent && parent->computedStyle() && parent->computedStyle()->justifyItemsPositionType()) {
-                    justifyItems = parent->computedStyle()->justifyItems();
-                    positionType = parent->computedStyle()->justifyItemsPositionType();
-                // Otherwise, auto computes to:
-                } else if (style->isDisplayFlexibleOrGridBox()) {
-                    // 'stretch' for flex containers and grid containers.
-                    justifyItems = ItemPositionStretch;
-                } else {
-                    // 'start' for everything else.
-                    justifyItems = ItemPositionStart;
-                }
-            }
-            return valueForItemPositionWithOverflowAlignment(justifyItems, style->justifyItemsOverflowAlignment(), positionType);
-        }
-        case CSSPropertyJustifySelf: {
-            // FIXME: I would like this to be tested; is not possible with a layout test but it
-            // should be possible using a method similar to https://codereview.chromium.org/351973004
-            ItemPosition justifySelf = style->justifySelf();
-            if (justifySelf == ItemPositionAuto) {
-                // The auto keyword computes to stretch on absolutely-positioned elements,
-                if (style->position() == AbsolutePosition) {
-                    justifySelf = ItemPositionStretch;
-                } else {
-                    // and to the computed value of justify-items on the parent (minus
-                    // any legacy keywords) on all other boxes.
-                    Node* parent = styledNode->parentNode();
-                    if (parent && parent->computedStyle())
-                        justifySelf = parent->computedStyle()->justifyItems();
-                }
-            }
-            return valueForItemPositionWithOverflowAlignment(justifySelf, style->justifySelfOverflowAlignment(), NonLegacyPosition);
-        }
+        case CSSPropertyJustifyItems:
+            return valueForItemPositionWithOverflowAlignment(style->justifyItems(), style->justifyItemsOverflowAlignment(), style->justifyItemsPositionType());
+        case CSSPropertyJustifySelf:
+            return valueForItemPositionWithOverflowAlignment(style->justifySelf(), style->justifySelfOverflowAlignment(), NonLegacyPosition);
         case CSSPropertyLeft:
             return valueForPositionOffset(*style, CSSPropertyLeft, renderer);
         case CSSPropertyLetterSpacing:
             if (!style->letterSpacing())
                 return cssValuePool().createIdentifierValue(CSSValueNormal);
             return zoomAdjustedPixelValue(style->letterSpacing(), *style);
         case CSSPropertyWebkitLineClamp:
             if (style->lineClamp().isNone())
                 return cssValuePool().createIdentifierValue(CSSValueNone);
             return cssValuePool().createValue(style->lineClamp().value(), style->lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
@@ skipping 1014 matching lines @@
     return list.release();
 }
 
 void CSSComputedStyleDeclaration::trace(Visitor* visitor)
 {
     visitor->trace(m_node);
     CSSStyleDeclaration::trace(visitor);
 }
 
 } // namespace blink