[CSS Grid Layout] Update named grid lines syntax to the last version of the specs

Source/core/css/CSSParser-in.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 4740 matching lines @@
     if (!isForwardSlashOperator(m_valueList->current()))
         return false;
 
     if (!m_valueList->next())
         return false;
 
     property = parseGridPosition();
     return true;
 }
 
+static inline bool isOpenParenthesisOperator(CSSParserValue* value)
+{
+    return value->unit == CSSParserValue::Operator && value->iValue == '(';
+}
+
+void CSSParser::parseGridLineNames(CSSParserValueList* parserValueList, CSSValueList& valueList)
+{
+    ASSERT(isOpenParenthesisOperator(parserValueList->current()));
+    parserValueList->next(); // skip '('
+
+    while (parserValueList->current() && parserValueList->current()->unit == CSSPrimitiveValue::CSS_IDENT) {
+        RefPtr<CSSPrimitiveValue> name = createPrimitiveStringValue(parserValueList->current());
+        valueList.append(name);
+        parserValueList->next();
+    }
+
+    ASSERT(parserValueList->current()->unit == CSSParserValue::Operator && parserValueList->current()->iValue == ')');
+    parserValueList->next(); // skip ')'
+}
+
 bool CSSParser::parseGridTrackList(CSSPropertyID propId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueNone) {
         if (m_valueList->next())
             return false;
 
         addProperty(propId, cssValuePool().createIdentifierValue(value->id), important);
         return true;
     }
 
     RefPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
-    // Handle leading <string>*.
-    while (m_valueList->current() && m_valueList->current()->unit == CSSPrimitiveValue::CSS_STRING) {
-        RefPtr<CSSPrimitiveValue> name = createPrimitiveStringValue(m_valueList->current());
-        values->append(name);
-        m_valueList->next();
-    }
+    // Handle leading  <ident>*.
+    value = m_valueList->current();
+    if (value && isOpenParenthesisOperator(value))
+        parseGridLineNames(m_valueList.get(), *values);
 
     bool seenTrackSizeOrRepeatFunction = false;
     while (CSSParserValue* currentValue = m_valueList->current()) {
         if (currentValue->unit == CSSParserValue::Function && equalIgnoringCase(currentValue->function->name, "repeat(")) {
             if (!parseGridTrackRepeatFunction(*values))
                 return false;
             seenTrackSizeOrRepeatFunction = true;
         } else {
             RefPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
             if (!value)
                 return false;
             values->append(value);
             seenTrackSizeOrRepeatFunction = true;
         }
-
-        // This will handle the trailing <string>* in the grammar.
-        while (m_valueList->current() && m_valueList->current()->unit == CSSPrimitiveValue::CSS_STRING) {
-            RefPtr<CSSPrimitiveValue> name = createPrimitiveStringValue(m_valueList->current());
-            values->append(name);
-            m_valueList->next();
-        }
+        // This will handle the trailing <ident>* in the grammar.
+        value = m_valueList->current();
+        if (value && isOpenParenthesisOperator(value))
+            parseGridLineNames(m_valueList.get(), *values);
     }
 
     // We should have found a <track-size> or else it is not a valid <track-list>
     if (!seenTrackSizeOrRepeatFunction)
         return false;
 
     addProperty(propId, values.release(), important);
     return true;
 }
 
 bool CSSParser::parseGridTrackRepeatFunction(CSSValueList& list)
 {
     CSSParserValueList* arguments = m_valueList->current()->function->args.get();
     if (!arguments || arguments->size() < 3 || !validUnit(arguments->valueAt(0), FPositiveInteger) || !isComma(arguments->valueAt(1)))
         return false;
 
     ASSERT_WITH_SECURITY_IMPLICATION(arguments->valueAt(0)->fValue > 0);
     size_t repetitions = arguments->valueAt(0)->fValue;
     RefPtr<CSSValueList> repeatedValues = CSSValueList::createSpaceSeparated();
     arguments->next(); // Skip the repetition count.
     arguments->next(); // Skip the comma.
 
-    // Handle leading <string>*.
-    while (arguments->current() && arguments->current()->unit == CSSPrimitiveValue::CSS_STRING) {
-        RefPtr<CSSPrimitiveValue> name = createPrimitiveStringValue(arguments->current());
-        repeatedValues->append(name);
-        arguments->next();
-    }
+    // Handle leading <ident>*.
+    CSSParserValue* currentValue = arguments->current();
+    if (currentValue && isOpenParenthesisOperator(currentValue))
+        parseGridLineNames(arguments, *repeatedValues);
 
     while (CSSParserValue* argumentValue = arguments->current()) {
         RefPtr<CSSValue> trackSize = parseGridTrackSize(*arguments);
         if (!trackSize)
             return false;
 
         repeatedValues->append(trackSize);
 
-        // This takes care of any trailing <string>* in the grammar.
-        while (arguments->current() && arguments->current()->unit == CSSPrimitiveValue::CSS_STRING) {
-            RefPtr<CSSPrimitiveValue> name = createPrimitiveStringValue(arguments->current());
-            repeatedValues->append(name);
-            arguments->next();
-        }
+        // This takes care of any trailing <ident>* in the grammar.
+        currentValue = arguments->current();
+        if (currentValue && isOpenParenthesisOperator(currentValue))
+            parseGridLineNames(arguments, *repeatedValues);
     }
 
     for (size_t i = 0; i < repetitions; ++i) {
         for (size_t j = 0; j < repeatedValues->length(); ++j)
             list.append(repeatedValues->itemWithoutBoundsCheck(j));
     }
 
     // parseGridTrackSize iterated over the repeat arguments, move to the next value.
     m_valueList->next();
     return true;
@@ skipping 7117 matching lines @@
 {
     // The tokenizer checks for the construct of an+b.
     // However, since the {ident} rule precedes the {nth} rule, some of those
     // tokens are identified as string literal. Furthermore we need to accept
     // "odd" and "even" which does not match to an+b.
     return equalIgnoringCase(token, "odd") || equalIgnoringCase(token, "even")
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 }