Move content property into CSSPropertyParser

third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.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 13 matching lines @@
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
 #include "core/css/CSSContentDistributionValue.h"
-#include "core/css/CSSCounterValue.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSProperty.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/CSSReflectValue.h"
@@ skipping 188 matching lines @@
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
     }
 
     ASSERT((value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)
         || (value->unit() >= CSSPrimitiveValue::UnitType::Turns && value->unit() <= CSSPrimitiveValue::UnitType::Chs)
         || (value->unit() >= CSSPrimitiveValue::UnitType::ViewportWidth && value->unit() <= CSSPrimitiveValue::UnitType::ViewportMax)
         || (value->unit() >= CSSPrimitiveValue::UnitType::DotsPerPixel && value->unit() <= CSSPrimitiveValue::UnitType::DotsPerCentimeter));
     return cssValuePool().createValue(value->fValue, value->unit());
 }
 
-inline PassRefPtrWillBeRawPtr<CSSStringValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
-{
-    ASSERT(value->m_unit == CSSParserValue::String || value->m_unit == CSSParserValue::Identifier);
-    return CSSStringValue::create(value->string);
-}
-
 inline PassRefPtrWillBeRawPtr<CSSCustomIdentValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
 {
     ASSERT(value->m_unit == CSSParserValue::String || value->m_unit == CSSParserValue::Identifier);
     return CSSCustomIdentValue::create(value->string);
 }
 
 static inline bool isComma(CSSParserValue* value)
 {
     ASSERT(value);
     return value->m_unit == CSSParserValue::Operator && value->iValue == ',';
@@ skipping 70 matching lines @@
             return false;
         addProperty(propId, cssValuePool().createIdentifierValue(id), important);
         return true;
     }
 
     bool validPrimitive = false;
     Units unitless = FUnknown;
     RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
 
     switch (propId) {
-    case CSSPropertyContent:              // [ <string> | <uri> | <counter> | attr(X) | open-quote |
-        // close-quote | no-open-quote | no-close-quote ]+ | inherit
-        parsedValue = parseContent();
-        break;
-
-    /* Start of supported CSS properties with validation. This is needed for parseShorthand to work
-     * correctly and allows optimization in blink::applyRule(..)
-     */
-
     case CSSPropertyBackgroundColor: // <color> | inherit
     case CSSPropertyBorderTopColor: // <color> | inherit
     case CSSPropertyBorderRightColor:
     case CSSPropertyBorderBottomColor:
     case CSSPropertyBorderLeftColor:
         parsedValue = parseColor(m_valueList->current(), inQuirksMode() && (!inShorthand() || m_currentShorthand == CSSPropertyBorderColor));
         if (parsedValue)
             m_valueList->next();
         break;
 
@@ skipping 536 matching lines @@
     case CSSPropertyCy:
     case CSSPropertyX:
     case CSSPropertyY:
     case CSSPropertyR:
     case CSSPropertyRx:
     case CSSPropertyRy:
     case CSSPropertyScale:
     case CSSPropertyTranslate:
     case CSSPropertyCursor:
     case CSSPropertyTransformOrigin:
+    case CSSPropertyContent:
         validPrimitive = false;
         break;
 
     case CSSPropertyScrollSnapPointsX:
     case CSSPropertyScrollSnapPointsY:
         parsedValue = parseScrollSnapPoints();
         break;
     case CSSPropertyScrollSnapCoordinate:
         parsedValue = parseScrollSnapCoordinate();
         break;
@@ skipping 336 matching lines @@
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseScrollSnapCoordinate()
 {
     if (m_valueList->current()->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     return parsePositionList(m_valueList);
 }
 
-// [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
-// in CSS 2.1 this got somewhat reduced:
-// [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
-PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseContent()
-{
-    RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
-
-    while (CSSParserValue* val = m_valueList->current()) {
-        RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
-        if (val->m_unit == CSSParserValue::URI) {
-            // url
-            parsedValue = createCSSImageValueWithReferrer(val->string, m_context);
-        } else if (val->m_unit == CSSParserValue::Function) {
-            // attr(X) | counter(X [,Y]) | counters(X, Y, [,Z]) | -webkit-gradient(...)
-            CSSParserValueList* args = val->function->args.get();
-            if (!args)
-                return nullptr;
-            if (val->function->id == CSSValueAttr) {
-                parsedValue = parseAttr(args);
-            } else if (val->function->id == CSSValueCounter) {
-                parsedValue = parseCounterContent(args, false);
-            } else if (val->function->id == CSSValueCounters) {
-                parsedValue = parseCounterContent(args, true);
-            } else if (val->function->id == CSSValueWebkitImageSet) {
-                parsedValue = parseImageSet(m_valueList);
-            } else if (CSSPropertyParser::isGeneratedImage(val->function->id)) {
-                if (!parseGeneratedImage(m_valueList, parsedValue))
-                    return nullptr;
-            }
-        } else if (val->m_unit == CSSParserValue::Identifier) {
-            switch (val->id) {
-            case CSSValueOpenQuote:
-            case CSSValueCloseQuote:
-            case CSSValueNoOpenQuote:
-            case CSSValueNoCloseQuote:
-            case CSSValueNone:
-            case CSSValueNormal:
-                parsedValue = cssValuePool().createIdentifierValue(val->id);
-            default:
-                break;
-            }
-        } else if (val->m_unit == CSSParserValue::String) {
-            parsedValue = createPrimitiveStringValue(val);
-        }
-        if (!parsedValue)
-            return nullptr;
-        values->append(parsedValue.release());
-        m_valueList->next();
-    }
-
-    return values.release();
-}
-
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAttr(CSSParserValueList* args)
-{
-    if (args->size() != 1)
-        return nullptr;
-
-    CSSParserValue* a = args->current();
-
-    if (a->m_unit != CSSParserValue::Identifier)
-        return nullptr;
-
-    String attrName = a->string;
-    // CSS allows identifiers with "-" at the start, like "-webkit-mask-image".
-    // But HTML attribute names can't have those characters, and we should not
-    // even parse them inside attr().
-    if (attrName[0] == '-')
-        return nullptr;
-
-    if (m_context.isHTMLDocument())
-        attrName = attrName.lower();
-
-    RefPtrWillBeRawPtr<CSSFunctionValue> attrValue = CSSFunctionValue::create(CSSValueAttr);
-    attrValue->append(CSSCustomIdentValue::create(attrName));
-    return attrValue.release();
-}
-
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseColor(const CSSParserValue* value, bool acceptQuirkyColors)
 {
     CSSValueID id = value->id;
     if (isColorKeyword(id)) {
         if (!isValueAllowedInMode(id, m_context.mode()))
             return nullptr;
         if (id == CSSValueWebkitText && m_context.useCounter())
             m_context.useCounter()->count(UseCounter::WebkitTextInColorProperty);
         return cssValuePool().createIdentifierValue(id);
     }
@@ skipping 1382 matching lines @@
         default:
             return parsedValues;
         }
         parsedValues->append(cssValuePool().createIdentifierValue(value->id));
         list.next();
     }
 
     return parsedValues;
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounterContent(CSSParserValueList* args, bool counters)
-{
-    unsigned numArgs = args->size();
-    if (counters && numArgs != 3 && numArgs != 5)
-        return nullptr;
-    if (!counters && numArgs != 1 && numArgs != 3)
-        return nullptr;
-
-    CSSParserValue* i = args->current();
-    if (i->m_unit != CSSParserValue::Identifier)
-        return nullptr;
-    RefPtrWillBeRawPtr<CSSCustomIdentValue> identifier = createPrimitiveCustomIdentValue(i);
-
-    RefPtrWillBeRawPtr<CSSCustomIdentValue> separator = nullptr;
-    if (!counters)
-        separator = CSSCustomIdentValue::create(String());
-    else {
-        args->next();
-        if (!consumeComma(args))
-            return nullptr;
-
-        i = args->current();
-        if (i->m_unit != CSSParserValue::String)
-            return nullptr;
-
-        separator = createPrimitiveCustomIdentValue(i);
-    }
-
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle = nullptr;
-    i = args->next();
-    if (!i) // Make the list style default decimal
-        listStyle = cssValuePool().createIdentifierValue(CSSValueDecimal);
-    else {
-        if (!consumeComma(args))
-            return nullptr;
-
-        i = args->current();
-        if (i->m_unit != CSSParserValue::Identifier)
-            return nullptr;
-
-        CSSValueID listStyleID = CSSValueInvalid;
-        if (i->id == CSSValueNone || (i->id >= CSSValueDisc && i->id <= CSSValueKatakanaIroha))
-            listStyleID = i->id;
-        else
-            return nullptr;
-
-        listStyle = cssValuePool().createIdentifierValue(listStyleID);
-    }
-
-    return CSSCounterValue::create(identifier.release(), listStyle.release(), separator.release());
-}
-
 static void completeBorderRadii(RefPtrWillBeRawPtr<CSSPrimitiveValue> radii[4])
 {
     if (radii[3])
         return;
     if (!radii[2]) {
         if (!radii[1])
             radii[1] = radii[0];
         radii[2] = radii[0];
     }
     radii[3] = radii[1];
@@ skipping 2124 matching lines @@
     ASSERT(!m_parsedCalculation);
     m_parsedCalculation = CSSCalcValue::create(args, range);
 
     if (!m_parsedCalculation)
         return false;
 
     return true;
 }
 
 } // namespace blink