Move some grid related longhands into CSSPropertyParser

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSCalculationValue.h"
@@ skipping 3535 matching lines @@
     RefPtrWillBeRawPtr<CSSValue> result = nullptr;
     do {
         RefPtrWillBeRawPtr<CSSValue> value = consumeBackgroundComponent(unresolvedProperty, range, context);
         if (!value)
             return nullptr;
         addBackgroundValue(result, value);
     } while (consumeCommaIncludingWhitespace(range));
     return result.release();
 }
 
+static bool isItemPositionKeyword(CSSValueID id)
+{
+    return id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter
+        || id == CSSValueSelfStart || id == CSSValueSelfEnd || id == CSSValueFlexStart
+        || id == CSSValueFlexEnd || id == CSSValueLeft || id == CSSValueRight;
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeItemPositionOverflowPosition(CSSParserTokenRange& range)
+{
+    if (identMatches<CSSValueAuto, CSSValueStretch, CSSValueBaseline, CSSValueLastBaseline>(range.peek().id()))
+        return consumeIdent(range);
+
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> position = nullptr;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> overflowAlignmentKeyword = nullptr;
+    if (isItemPositionKeyword(range.peek().id())) {

[Timothy Loh, 2016/03/10 00:12:14]

Isn't this almost the same as the regular pattern ? Seems like we should just do
it like normal. Also maybe a good idea to match the terms in the current spec?

overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
selfPosition = consumeSelfPositionKeyword(range);
if (!selfPosition)
    return false;
if (!overflowPosition)
    overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
...

[jfernandez, 2016/03/10 14:11:02]

The only special thing we do here is to take care about the order we consume the
different keywords. Specs defines the syntax <overflow-position> &&
<self-position>, so they can be defined in any order. 

 Also maybe a good idea to match the terms in the current spec?
Totally agree about the names; it as <item-position> at the time we implemented
that parsing logic.

+        position = consumeIdent(range);
+        overflowAlignmentKeyword = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
+    } else if (identMatches<CSSValueUnsafe, CSSValueSafe>(range.peek().id())) {
+        overflowAlignmentKeyword = consumeIdent(range);
+        if (isItemPositionKeyword(range.peek().id()))
+            position = consumeIdent(range);
+    }
+    if (!position)
+        return nullptr;
+    if (overflowAlignmentKeyword)
+        return CSSValuePair::create(position, overflowAlignmentKeyword, CSSValuePair::DropIdenticalValues);
+    return position.release();
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> consumeJustifyItems(CSSParserTokenRange& range)
+{
+    CSSParserTokenRange rangeCopy = range;
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> legacy = consumeIdent<CSSValueLegacy>(rangeCopy);
+    RefPtrWillBeRawPtr<CSSPrimitiveValue> positionKeyword = consumeIdent<CSSValueCenter, CSSValueLeft, CSSValueRight>(rangeCopy);
+    if (!legacy)
+        legacy = consumeIdent<CSSValueLegacy>(rangeCopy);
+    if (legacy && positionKeyword) {
+        range = rangeCopy;
+        return CSSValuePair::create(legacy.release(), positionKeyword.release(), CSSValuePair::DropIdenticalValues);
+    }
+    return consumeItemPositionOverflowPosition(range);
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID unresolvedProperty)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
     if (CSSParserFastPaths::isKeywordPropertyID(property)) {
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(property, m_range.peek().id()))
             return nullptr;
         return consumeIdent(m_range);
     }
     switch (property) {
     case CSSPropertyWillChange:
@@ skipping 334 matching lines @@
     case CSSPropertyWebkitMaskComposite:
     case CSSPropertyWebkitMaskImage:
     case CSSPropertyWebkitMaskOrigin:
     case CSSPropertyWebkitMaskPositionX:
     case CSSPropertyWebkitMaskPositionY:
     case CSSPropertyWebkitMaskSize:
         return consumeCommaSeparatedBackgroundComponent(unresolvedProperty, m_range, m_context);
     case CSSPropertyWebkitMaskRepeatX:
     case CSSPropertyWebkitMaskRepeatY:
         return nullptr;
+    case CSSPropertyJustifySelf:
+    case CSSPropertyAlignSelf:
+    case CSSPropertyAlignItems:
+        ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+        return consumeItemPositionOverflowPosition(m_range);
+    case CSSPropertyJustifyItems:
+        ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
+        return consumeJustifyItems(m_range);
     default:
         CSSParserValueList valueList(m_range);
         if (valueList.size()) {
             m_valueList = &valueList;
             if (RefPtrWillBeRawPtr<CSSValue> result = legacyParseValue(unresolvedProperty)) {
                 while (!m_range.atEnd())
                     m_range.consume();
                 return result.release();
             }
         }
@@ skipping 914 matching lines @@
         m_currentShorthand = oldShorthand;
         CSSParserValueList valueList(m_range);
         if (!valueList.size())
             return false;
         m_valueList = &valueList;
         return legacyParseShorthand(unresolvedProperty, important);
     }
 }
 
 } // namespace blink