Add property parser code path based on CSSParserTokenRange

Source/core/css/parser/CSSPropertyParser.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 56 matching lines @@
 template <unsigned N>
 static bool equalIgnoringCase(const CSSParserString& a, const char (&b)[N])
 {
     unsigned length = N - 1; // Ignore the trailing null character
     if (a.length() != length)
         return false;
 
     return a.is8Bit() ? WTF::equalIgnoringCase(b, a.characters8(), length) : WTF::equalIgnoringCase(b, a.characters16(), length);
 }
 
-CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList,
+CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList, const CSSParserTokenRange& range,
     const CSSParserContext& context, WillBeHeapVector<CSSProperty, 256>& parsedProperties,
     StyleRule::Type ruleType)
     : m_valueList(valueList)
+    , m_range(range)
     , m_context(context)
     , m_parsedProperties(parsedProperties)
     , m_ruleType(ruleType)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
 {
 }
 
 bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important,
-    CSSParserValueList* valueList, const CSSParserContext& context,
+    const CSSParserTokenRange& range, const CSSParserContext& context,
     WillBeHeapVector<CSSProperty, 256>& parsedProperties, StyleRule::Type ruleType)
 {
     int parsedPropertiesSize = parsedProperties.size();
 
-    CSSPropertyParser parser(valueList, context, parsedProperties, ruleType);
+    CSSParserValueList valueList(range);

[Timothy Loh, 2015/09/04 01:24:40]

Probably OK for now but at some point this needs to happen *after* we call the
new-path parser, since this conversion has a pretty noticeable cost.

+    if (!valueList.size())
+        return false; // Parser error
+    CSSPropertyParser parser(&valueList, range, context, parsedProperties, ruleType);
     CSSPropertyID resolvedProperty = resolveCSSPropertyID(unresolvedProperty);
     bool parseSuccess;
 
     if (ruleType == StyleRule::Viewport) {
         parseSuccess = (RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(context.mode()))
             && parser.parseViewportProperty(resolvedProperty, important);
     } else if (ruleType == StyleRule::FontFace) {
         parseSuccess = parser.parseFontFaceDescriptor(resolvedProperty);
     } else {
         parseSuccess = parser.parseValue(unresolvedProperty, important);
@@ skipping 221 matching lines @@
 
 static bool consumeComma(CSSParserValueList* valueList)
 {
     CSSParserValue* value = valueList->current();
     if (!value || !isComma(value))
         return false;
     valueList->next();
     return true;
 }
 
+static bool consumeCommaIncludingWhitespace(CSSParserTokenRange& valueList)
+{
+    CSSParserToken value = valueList.peek();
+    if (value.type() != CommaToken)
+        return false;
+    valueList.consumeIncludingWhitespace();
+    return true;
+}
+
 static inline bool isForwardSlashOperator(CSSParserValue* value)
 {
     ASSERT(value);
     return value->m_unit == CSSParserValue::Operator && value->iValue == '/';
 }
 
 static bool isGeneratedImageValue(CSSParserValue* val)
 {
     if (val->m_unit != CSSParserValue::Function)
         return false;
@@ skipping 76 matching lines @@
         return;
     }
 
     RefPtrWillBeRawPtr<CSSValue> value = prpValue;
     ShorthandScope scope(this, propId);
     const CSSPropertyID* longhands = shorthand.properties();
     for (unsigned i = 0; i < shorthandLength; ++i)
         addProperty(longhands[i], value, important);
 }
 
+PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseSingleValue(CSSPropertyID propId)
+{
+    m_range.consumeWhitespace();
+    switch (propId) {
+    case CSSPropertyWillChange:
+        return parseWillChange();
+    default:
+        ASSERT_NOT_REACHED();
+    }
+    return nullptr;
+}
+
 bool CSSPropertyParser::parseValue(CSSPropertyID unresolvedProperty, bool important)
 {
     CSSPropertyID propId = resolveCSSPropertyID(unresolvedProperty);
 
     CSSParserValue* value = m_valueList->current();
 
     // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function.
     // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers.
     ASSERT(!m_parsedCalculation);
 
@@ skipping 18 matching lines @@
 
     if (CSSParserFastPaths::isKeywordPropertyID(propId)) {
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))
             return false;
         if (m_valueList->next() && !inShorthand())
             return false;
         addProperty(propId, cssValuePool().createIdentifierValue(id), important);
         return true;
     }
 
+    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
+    if (propId == CSSPropertyWillChange) {
+        parsedValue = parseSingleValue(propId);
+        if (!parsedValue || !m_range.atEnd())
+            return false;
+        addProperty(propId, parsedValue.release(), important);
+        return true;
+    }
+
     bool validPrimitive = false;
     Units unitless = FUnknown;
-    RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
 
     switch (propId) {
     case CSSPropertySize: // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
         parsedValue = parseSize();
         break;
     case CSSPropertyQuotes: // [<string> <string>]+ | none
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseQuotes();
@@ skipping 824 matching lines @@
             validPrimitive = true;
         else
             validPrimitive = validUnit(value, FLength | FNonNeg);
         break;
     case CSSPropertyWebkitColumnSpan: // none | all | 1 (will be dropped in the unprefixed property)
         validPrimitive = id == CSSValueAll || id == CSSValueNone || (value->unit() == CSSPrimitiveValue::UnitType::Number && value->fValue == 1);
         break;
     case CSSPropertyWebkitColumnWidth:         // auto | <length>
         parsedValue = parseColumnWidth();
         break;
-    case CSSPropertyWillChange:
-        parsedValue = parseWillChange();
-        break;
     // End of CSS3 properties
 
     // Apple specific properties.  These will never be standardized and are purely to
     // support custom WebKit-based Apple applications.
     case CSSPropertyWebkitLineClamp:
         // When specifying number of lines, don't allow 0 as a valid value
         // When specifying either type of unit, require non-negative integers
         validPrimitive = (!id && !isCalculation(value) && validUnit(value, FInteger | FPercent | FNonNeg) && (value->unit() == CSSPrimitiveValue::UnitType::Percentage || value->fValue));
         break;
 
@@ skipping 5472 matching lines @@
             break;
 
         // If there are more arguments, they should be after a comma.
         if (!consumeComma(functionArgs))
             return nullptr;
     }
 
     return imageSet.release();
 }
 
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
+{
+    ASSERT(range.peek().type() == IdentToken);
+    return cssValuePool().createIdentifierValue(range.consumeIncludingWhitespace().id());
+}
+
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseWillChange()
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
-    if (m_valueList->current()->id == CSSValueAuto) {
+    if (m_range.peek().id() == CSSValueAuto) {
         // FIXME: This will be read back as an empty string instead of auto
+        m_range.consumeIncludingWhitespace();
         return values.release();
     }
 
     // Every comma-separated list of identifiers is a valid will-change value,
     // unless the list includes an explicitly disallowed identifier.
     while (true) {
-        CSSParserValue* currentValue = m_valueList->current();
-        if (!currentValue || currentValue->m_unit != CSSParserValue::Identifier)
+        if (m_range.peek().type() != IdentToken)
             return nullptr;
-
-        CSSPropertyID unresolvedProperty = unresolvedCSSPropertyID(currentValue->string);
+        CSSPropertyID unresolvedProperty = unresolvedCSSPropertyID(m_range.peek().value());
         if (unresolvedProperty) {
             ASSERT(CSSPropertyMetadata::isEnabledProperty(unresolvedProperty));
             // Now "all" is used by both CSSValue and CSSPropertyValue.
             // Need to return nullptr when currentValue is CSSPropertyAll.
             if (unresolvedProperty == CSSPropertyWillChange || unresolvedProperty == CSSPropertyAll)
                 return nullptr;
             values->append(cssValuePool().createIdentifierValue(unresolvedProperty));
+            m_range.consumeIncludingWhitespace();
         } else {
-            switch (currentValue->id) {
+            switch (m_range.peek().id()) {
             case CSSValueNone:
             case CSSValueAll:
             case CSSValueAuto:
             case CSSValueDefault:
             case CSSValueInitial:
             case CSSValueInherit:
                 return nullptr;
             case CSSValueContents:
             case CSSValueScrollPosition:
-                values->append(cssValuePool().createIdentifierValue(currentValue->id));
+                values->append(consumeIdent(m_range));
                 break;
             default:
+                m_range.consumeIncludingWhitespace();
                 break;
             }
         }
 
-        if (!m_valueList->next())
+        if (m_range.atEnd())
             break;
-        if (!consumeComma(m_valueList))
+        if (!consumeCommaIncludingWhitespace(m_range))
             return nullptr;
     }
 
     return values.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSFunctionValue> CSSPropertyParser::parseBuiltinFilterArguments(CSSParserValueList* args, CSSValueID filterType)
 {
     RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = CSSFunctionValue::create(filterType);
     ASSERT(args);
@@ skipping 1169 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink