[CSS Grid Layout] Upgrade justify-content parsing to CSS3 Box Alignment 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 1527 matching lines @@
 {
     if (position != ItemPositionAuto)
         return position;
 
     bool isFlexOrGrid = element && element->computedStyle()
         && element->computedStyle()->isDisplayFlexibleOrGridBox();
 
     return isFlexOrGrid ? ItemPositionStretch : ItemPositionStart;
 }
 
+static void resolveAlignmentContentAuto(RenderStyle& style)
+{
+    if (style.justifyContent() != ContentPositionAuto || style.justifyContentDistribution() != ContentDistributionDefault)
+        return;
+
+    // Block Containers: For table cells, the behavior of the 'auto' depends on the computed
+    // value of 'vertical-align', otherwise behaves as 'start'.
+    // Flex Containers: 'auto' computes to 'stretch'.
+    // Grid Containers: 'auto' computes to 'start', and 'stretch' behaves like 'start'.
+    if (style.isDisplayFlexibleBox()) {
+        style.setJustifyContent(ContentPositionFlexStart);
+    } else {
+        style.setJustifyContent(ContentPositionStart);

[Julien - ping for review, 2014/10/28 17:23:04]

Mutating the RenderStyle is not an option AFAICT: we don't want getComputedStyle
to have a potential side effect (apart from the usual style / layout trigger).

A better approach would be to just return the resolved value (per
http://dev.w3.org/csswg/cssom/#resolved-values) for align-content.

[jfernandez, 2014/10/29 11:03:04]

Agree. Actually, this logic is not needed since the computed style is already
resolved by the StyleAdjuster during the cascade.

+    }
+}
+
 static PassRefPtrWillBeRawPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
 {
     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(overflowAlignment));
     ASSERT(result->length() <= 2);
     return result.release();
 }
 
+static PassRefPtrWillBeRawPtr<CSSValueList> valueForContentPositionAndDistributionWithOverflowAlignment(ContentPosition position, OverflowAlignment overflowAlignment, ContentDistributionType distribution)
+{
+    RefPtrWillBeRawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
+    if (distribution != ContentDistributionDefault)
+        result->append(CSSPrimitiveValue::create(distribution));
+    if (distribution == ContentDistributionDefault || position != ContentPositionAuto)
+        result->append(CSSPrimitiveValue::create(position));
+    if ((position >= ContentPositionCenter || distribution != ContentDistributionDefault) && overflowAlignment != OverflowAlignmentDefault)
+        result->append(CSSPrimitiveValue::create(overflowAlignment));
+    ASSERT(result->length() > 0);
+    ASSERT(result->length() <= 3);
+    return result.release();
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropertyID propertyID, EUpdateLayout updateLayout) const
 {
     Node* styledNode = this->styledNode();
     if (!styledNode)
         return nullptr;
     RenderObject* renderer = styledNode->renderer();
     RefPtr<RenderStyle> style;
 
     if (updateLayout) {
         Document& document = styledNode->document();
@@ skipping 267 matching lines @@
             return cssValuePool().createValue(style->flexDirection());
         case CSSPropertyFlexFlow:
             return valuesForShorthandProperty(flexFlowShorthand());
         case CSSPropertyFlexGrow:
             return cssValuePool().createValue(style->flexGrow());
         case CSSPropertyFlexShrink:
             return cssValuePool().createValue(style->flexShrink());
         case CSSPropertyFlexWrap:
             return cssValuePool().createValue(style->flexWrap());
         case CSSPropertyJustifyContent:
-            return cssValuePool().createValue(style->justifyContent());
+            resolveAlignmentContentAuto(*style);
+            return valueForContentPositionAndDistributionWithOverflowAlignment(style->justifyContent(), style->justifyContentOverflowAlignment(), style->justifyContentDistribution());
         case CSSPropertyOrder:
             return cssValuePool().createValue(style->order(), CSSPrimitiveValue::CSS_NUMBER);
         case CSSPropertyFloat:
             if (style->display() != NONE && style->hasOutOfFlowPosition())
                 return cssValuePool().createIdentifierValue(CSSValueNone);
             return cssValuePool().createValue(style->floating());
         case CSSPropertyFont: {
             RefPtrWillBeRawPtr<CSSFontValue> computedFont = CSSFontValue::create();
             computedFont->style = valueForFontStyle(*style);
             computedFont->variant = valueForFontVariant(*style);
@@ skipping 1134 matching lines @@
     return list.release();
 }
 
 void CSSComputedStyleDeclaration::trace(Visitor* visitor)
 {
     visitor->trace(m_node);
     CSSStyleDeclaration::trace(visitor);
 }
 
 } // namespace blink