Fix serialization of content property to always quote

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 302 matching lines @@
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
     }
 
     ASSERT((value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
         || (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_CHS)
         || (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX)
         || (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM));
     return cssValuePool().createValue(value->fValue, static_cast<CSSPrimitiveValue::UnitType>(value->unit));
 }
 
-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
+inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value, CSSPrimitiveValue::UnitType type)
 {
-    ASSERT(value->unit == CSSPrimitiveValue::CSS_STRING || value->unit == CSSPrimitiveValue::CSS_IDENT);
-    return cssValuePool().createValue(value->string, CSSPrimitiveValue::CSS_STRING);
+    ASSERT(value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT || value->unit == CSSPrimitiveValue::CSS_IDENT);

[Timothy Loh, 2015/03/03 23:20:15]

I guess this check should stay as CSS_STRING || CSS_IDENT, and we'll create
these with either CSS_STRING or CSS_CUSTOM_IDENT types.

+    return cssValuePool().createValue(value->string, type);
 }
 
 inline PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::createCSSImageValueWithReferrer(const String& rawValue, const KURL& url)
 {
     RefPtrWillBeRawPtr<CSSValue> imageValue = CSSImageValue::create(rawValue, url);
     toCSSImageValue(imageValue.get())->setReferrer(m_context.referrer());
     return imageValue;
 }
 
 static inline bool isComma(CSSParserValue* value)
@@ skipping 41 matching lines @@
     int id = value->id;
     if (id == CSSValueIntrinsic || id == CSSValueMinIntrinsic || id == CSSValueWebkitMinContent || id == CSSValueWebkitMaxContent || id == CSSValueWebkitFillAvailable || id == CSSValueWebkitFitContent)
         return true;
     return !id && validUnit(value, FLength | FPercent | FNonNeg | unitless);
 }
 
 inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseValidPrimitive(CSSValueID identifier, CSSParserValue* value)
 {
     if (identifier)
         return cssValuePool().createIdentifierValue(identifier);
-    if (value->unit == CSSPrimitiveValue::CSS_STRING)
+    if (value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT)
         return createPrimitiveStringValue(value);
     if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSPrimitiveValue::CSS_TURN && value->unit <= CSSPrimitiveValue::CSS_CHS)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSParserValue::Q_EMS)
@@ skipping 117 matching lines @@
         else
             overflowXValue = m_parsedProperties.last().value();
         addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
         return true;
     }
 
     case CSSPropertyTextAlign:
         // left | right | center | justify | -webkit-left | -webkit-right | -webkit-center | -webkit-match-parent
         // | start | end | <string> | inherit | -webkit-auto (converted to start)
         if ((id >= CSSValueWebkitAuto && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd
-            || value->unit == CSSPrimitiveValue::CSS_STRING)
+            || value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT)
             validPrimitive = true;
         break;
 
     case CSSPropertyFontWeight:  { // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit
         if (m_valueList->size() != 1)
             return false;
         return parseFontWeight(important);
     }
 
     case CSSPropertyBorderSpacing: {
@@ skipping 785 matching lines @@
         // 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 && (value->unit == CSSPrimitiveValue::CSS_PERCENTAGE || value->fValue) && validUnit(value, FInteger | FPercent | FNonNeg));
         break;
 
     case CSSPropertyWebkitFontSizeDelta: // <length>
         validPrimitive = validUnit(value, FLength | FUnitlessQuirk);
         break;
 
     case CSSPropertyWebkitHighlight:
-        if (id == CSSValueNone || value->unit == CSSPrimitiveValue::CSS_STRING)
+        if (id == CSSValueNone || value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT)
             validPrimitive = true;
         break;
 
     case CSSPropertyWebkitHyphenateCharacter:
-        if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
+        if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT)
             validPrimitive = true;
         break;
 
     case CSSPropertyWebkitLocale:
-        if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_STRING)
+        if (id == CSSValueAuto || value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT)
             validPrimitive = true;
         break;
 
     // End Apple-specific properties
 
     case CSSPropertyWebkitAppRegion:
         if (id >= CSSValueDrag && id <= CSSValueNoDrag)
             validPrimitive = true;
         break;
 
@@ skipping 795 matching lines @@
         return None;
     }
 }
 
 // [ <string> <string> ]+ | none, but none is handled in parseValue
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseQuotes()
 {
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createCommaSeparated();
     while (CSSParserValue* val = m_valueList->current()) {
         RefPtrWillBeRawPtr<CSSValue> parsedValue = nullptr;
-        if (val->unit != CSSPrimitiveValue::CSS_STRING)
+        if (val->unit != CSSPrimitiveValue::CSS_CUSTOM_IDENT)
             return nullptr;
-        parsedValue = CSSPrimitiveValue::create(val->string, CSSPrimitiveValue::CSS_STRING);
+        parsedValue = CSSPrimitiveValue::create(val->string, CSSPrimitiveValue::CSS_CUSTOM_IDENT);

[Timothy Loh, 2015/03/03 23:20:15]

CSS_STRING

         values->append(parsedValue.release());
         m_valueList->next();
     }
     if (values->length() && values->length() % 2 == 0)
         return values.release();
     return nullptr;
 }
 
 // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
 // in CSS 2.1 this got somewhat reduced:
@@ skipping 38 matching lines @@
             case CSSValueOpenQuote:
             case CSSValueCloseQuote:
             case CSSValueNoOpenQuote:
             case CSSValueNoCloseQuote:
             case CSSValueNone:
             case CSSValueNormal:
                 parsedValue = cssValuePool().createIdentifierValue(val->id);
             default:
                 break;
             }
-        } else if (val->unit == CSSPrimitiveValue::CSS_STRING) {
-            parsedValue = createPrimitiveStringValue(val);
+        } else if (val->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT) {
+            parsedValue = createPrimitiveStringValue(val, CSSPrimitiveValue::CSS_STRING);
         }
         if (!parsedValue)
             break;
         values->append(parsedValue.release());
         m_valueList->next();
     }
 
     if (values->length()) {
         addProperty(propId, values.release(), important);
         m_valueList->next();
@@ skipping 725 matching lines @@
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationName(bool allowQuotedName)
 {
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     if (value->unit == CSSPrimitiveValue::CSS_IDENT)
         return createPrimitiveStringValue(value);
 
-    if (allowQuotedName && value->unit == CSSPrimitiveValue::CSS_STRING) {
+    if (allowQuotedName && value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT) {
         // Legacy support for strings in prefixed animations
         if (m_context.useCounter())
             m_context.useCounter()->count(UseCounter::QuotedAnimationName);
         if (equalIgnoringCase(value->string, "none"))
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return createPrimitiveStringValue(value);
     }
 
     return nullptr;
 }
@@ skipping 275 matching lines @@
     // If we didn't parse anything, this is not a valid grid position.
     if (!hasSeenSpanKeyword && !gridLineName && !numericValue)
         return nullptr;
 
     // Negative numbers are not allowed for span (but are for <integer>).
     if (hasSeenSpanKeyword && numericValue && numericValue->getIntValue() < 0)
         return nullptr;
 
     // For the <custom-ident> case.
     if (gridLineName && !numericValue && !hasSeenSpanKeyword)
-        return cssValuePool().createValue(gridLineName->getStringValue(), CSSPrimitiveValue::CSS_STRING);
+        return cssValuePool().createValue(gridLineName->getStringValue(), CSSPrimitiveValue::CSS_CUSTOM_IDENT);
 
     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
     if (hasSeenSpanKeyword)
         values->append(cssValuePool().createIdentifierValue(CSSValueSpan));
     if (numericValue)
         values->append(numericValue.release());
     if (gridLineName)
         values->append(gridLineName.release());
     ASSERT(values->length());
     return values.release();
@@ skipping 57 matching lines @@
         } else {
             maybeParseGridLineNames(*m_valueList, *templateRows);
         }
 
         // Handle a template-area's row.
         if (!parseGridTemplateAreasRow(gridAreaMap, rowCount, columnCount))
             return false;
         ++rowCount;
 
         // Handle template-rows's track-size.
-        if (m_valueList->current() && m_valueList->current()->unit != CSSParserValue::ValueList && m_valueList->current()->unit != CSSPrimitiveValue::CSS_STRING) {
+        if (m_valueList->current() && m_valueList->current()->unit != CSSParserValue::ValueList && m_valueList->current()->unit != CSSPrimitiveValue::CSS_CUSTOM_IDENT) {
             RefPtrWillBeRawPtr<CSSValue> value = parseGridTrackSize(*m_valueList);
             if (!value)
                 return false;
             templateRows->append(value);
         } else {
             templateRows->append(cssValuePool().createIdentifierValue(CSSValueAuto));
         }
 
         // This will handle the trailing/leading <custom-ident>* in the grammar.
         const CSSParserValue* current = m_valueList->current();
@@ skipping 356 matching lines @@
 
     if (!validUnit(currentValue, FNonNeg | FLength | FPercent))
         return nullptr;
 
     return createPrimitiveNumericValue(currentValue);
 }
 
 bool CSSPropertyParser::parseGridTemplateAreasRow(NamedGridAreaMap& gridAreaMap, const size_t rowCount, size_t& columnCount)
 {
     CSSParserValue* currentValue = m_valueList->current();
-    if (!currentValue || currentValue->unit != CSSPrimitiveValue::CSS_STRING)
+    if (!currentValue || currentValue->unit != CSSPrimitiveValue::CSS_CUSTOM_IDENT)
         return false;
 
     String gridRowNames = currentValue->string;
     if (gridRowNames.isEmpty() || gridRowNames.containsOnlyWhitespace())
         return false;
 
     Vector<String> columnNames;
     gridRowNames.split(' ', columnNames);
 
     if (!columnCount) {
@@ skipping 112 matching lines @@
     if (!counters && numArgs != 1 && numArgs != 3)
         return nullptr;
 
     CSSParserValue* i = args->current();
     if (i->unit != CSSPrimitiveValue::CSS_IDENT)
         return nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> identifier = createPrimitiveStringValue(i);
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> separator = nullptr;
     if (!counters)
-        separator = cssValuePool().createValue(String(), CSSPrimitiveValue::CSS_STRING);
+        separator = cssValuePool().createValue(String(), CSSPrimitiveValue::CSS_CUSTOM_IDENT);
     else {
         args->next();
         if (!consumeComma(args))
             return nullptr;
 
         i = args->current();
-        if (i->unit != CSSPrimitiveValue::CSS_STRING)
+        if (i->unit != CSSPrimitiveValue::CSS_CUSTOM_IDENT)
             return nullptr;
 
         separator = createPrimitiveStringValue(i);
     }
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle = nullptr;
     i = args->next();
     if (!i) // Make the list style default decimal
         listStyle = cssValuePool().createIdentifierValue(CSSValueDecimal);
     else {
@@ skipping 741 matching lines @@
     CSSParserValue* value = m_valueList->current();
 
     FontFamilyValueBuilder familyBuilder(list.get());
     bool inFamily = false;
 
     while (value) {
         CSSParserValue* nextValue = m_valueList->next();
         bool nextValBreaksFont = !nextValue || isComma(nextValue);
         bool nextValIsFontName = nextValue &&
             ((nextValue->id >= CSSValueSerif && nextValue->id <= CSSValueWebkitBody) ||
-            (nextValue->unit == CSSPrimitiveValue::CSS_STRING || nextValue->unit == CSSPrimitiveValue::CSS_IDENT));
+            (nextValue->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT || nextValue->unit == CSSPrimitiveValue::CSS_IDENT));
 
         if (isCSSWideKeyword(*value) && !inFamily) {
             if (nextValBreaksFont)
                 value = m_valueList->next();
             else if (nextValIsFontName)
                 value = nextValue;
             continue;
         }
 
         if (value->id >= CSSValueSerif && value->id <= CSSValueWebkitBody) {
             if (inFamily)
                 familyBuilder.add(value->string);
             else if (nextValBreaksFont || !nextValIsFontName)
                 list->append(cssValuePool().createIdentifierValue(value->id));
             else {
                 familyBuilder.commit();
                 familyBuilder.add(value->string);
                 inFamily = true;
             }
-        } else if (value->unit == CSSPrimitiveValue::CSS_STRING) {
+        } else if (value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT) {
             // Strings never share in a family name.
             inFamily = false;
             familyBuilder.commit();
             list->append(cssValuePool().createFontFamilyValue(value->string));
         } else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
             if (inFamily)
                 familyBuilder.add(value->string);
             else if (nextValBreaksFont || !nextValIsFontName)
                 list->append(cssValuePool().createFontFamilyValue(value->string));
             else {
@@ skipping 134 matching lines @@
 
     CSSParserValue* value = m_valueList->next();
     if (!value || value->unit != CSSParserValue::Function || value->function->id != CSSValueFormat) {
         valueList->append(uriValue.release());
         return true;
     }
 
     // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20111004/ says that format() contains a comma-separated list of strings,
     // but CSSFontFaceSrcValue stores only one format. Allowing one format for now.
     CSSParserValueList* args = value->function->args.get();
-    if (!args || args->size() != 1 || (args->current()->unit != CSSPrimitiveValue::CSS_STRING && args->current()->unit != CSSPrimitiveValue::CSS_IDENT))
+    if (!args || args->size() != 1 || (args->current()->unit != CSSPrimitiveValue::CSS_CUSTOM_IDENT && args->current()->unit != CSSPrimitiveValue::CSS_IDENT))
         return false;
     uriValue->setFormat(args->current()->string);
     valueList->append(uriValue.release());
     m_valueList->next();
     return true;
 }
 
 bool CSSPropertyParser::parseFontFaceSrcLocal(CSSValueList* valueList)
 {
     CSSParserValueList* args = m_valueList->current()->function->args.get();
     if (!args || !args->size())
         return false;
     m_valueList->next();
 
     ContentSecurityPolicyDisposition shouldCheckContentSecurityPolicy = m_context.shouldCheckContentSecurityPolicy();
-    if (args->size() == 1 && args->current()->unit == CSSPrimitiveValue::CSS_STRING)
+    if (args->size() == 1 && args->current()->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT)
         valueList->append(CSSFontFaceSrcValue::createLocal(args->current()->string, shouldCheckContentSecurityPolicy));
     else if (args->current()->unit == CSSPrimitiveValue::CSS_IDENT) {
         StringBuilder builder;
         for (CSSParserValue* localValue = args->current(); localValue; localValue = args->next()) {
             if (localValue->unit != CSSPrimitiveValue::CSS_IDENT)
                 return false;
             if (!builder.isEmpty())
                 builder.append(' ');
             builder.append(localValue->string);
         }
@@ skipping 2657 matching lines @@
 
     return false;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseTextEmphasisStyle()
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> fill = nullptr;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> shape = nullptr;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
-        if (value->unit == CSSPrimitiveValue::CSS_STRING) {
+        if (value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT) {
             if (fill || shape)
                 return nullptr;
             m_valueList->next();
             return createPrimitiveStringValue(value);
         }
 
         if (value->id == CSSValueNone) {
             if (fill || shape)
                 return nullptr;
             m_valueList->next();
@@ skipping 96 matching lines @@
     return CSSLineBoxContainValue::create(lineBoxContain);
 }
 
 bool CSSPropertyParser::parseFontFeatureTag(CSSValueList* settings)
 {
     // Feature tag name consists of 4-letter characters.
     static const unsigned tagNameLength = 4;
 
     CSSParserValue* value = m_valueList->current();
     // Feature tag name comes first
-    if (value->unit != CSSPrimitiveValue::CSS_STRING)
+    if (value->unit != CSSPrimitiveValue::CSS_CUSTOM_IDENT)
         return false;
     if (value->string.length() != tagNameLength)
         return false;
     for (unsigned i = 0; i < tagNameLength; ++i) {
         // Limits the range of characters to 0x20-0x7E, following the tag name rules defiend in the OpenType specification.
         UChar character = value->string[i];
         if (character < 0x20 || character > 0x7E)
             return false;
     }
 
@@ skipping 514 matching lines @@
     default:
         // If you crash here, it's because you added a css property and are not handling it
         // in either this switch statement or the one in CSSPropertyParser::parseValue
         ASSERT_WITH_MESSAGE(0, "unimplemented propertyID: %d", propId);
         return false;
     }
 
     if (validPrimitive) {
         if (id)
             parsedValue = CSSPrimitiveValue::createIdentifier(id);
-        else if (value->unit == CSSPrimitiveValue::CSS_STRING)
+        else if (value->unit == CSSPrimitiveValue::CSS_CUSTOM_IDENT)
             parsedValue = CSSPrimitiveValue::create(value->string, (CSSPrimitiveValue::UnitType) value->unit);
         else if (value->unit >= CSSPrimitiveValue::CSS_NUMBER && value->unit <= CSSPrimitiveValue::CSS_KHZ)
             parsedValue = CSSPrimitiveValue::create(value->fValue, (CSSPrimitiveValue::UnitType) value->unit);
         else if (value->unit >= CSSParserValue::Q_EMS)
             parsedValue = CSSPrimitiveValue::createAllowingMarginQuirk(value->fValue, CSSPrimitiveValue::CSS_EMS);
         if (isCalculation(value)) {
             // FIXME calc() http://webkit.org/b/16662 : actually create a CSSPrimitiveValue here, ie
             // parsedValue = CSSPrimitiveValue::create(m_parsedCalculation.release());
             m_parsedCalculation.release();
             parsedValue = nullptr;
@@ skipping 285 matching lines @@
     // FIXME: Add support for <url>, <basic-shape>, <geometry-box>.
     if (value->unit != CSSParserValue::Function || value->function->id != CSSValuePath)
         return nullptr;
 
     // FIXME: Add support for <fill-rule>.
     CSSParserValueList* functionArgs = value->function->args.get();
     if (!functionArgs || functionArgs->size() != 1 || !functionArgs->current())
         return nullptr;
 
     CSSParserValue* arg = functionArgs->current();
-    if (arg->unit != CSSPrimitiveValue::CSS_STRING)
+    if (arg->unit != CSSPrimitiveValue::CSS_CUSTOM_IDENT)
         return nullptr;
 
     String pathString = arg->string;
     Path path;
     if (!buildPathFromString(pathString, path))
         return nullptr;
 
     m_valueList->next();
     return CSSPathValue::create(pathString);
 }
@@ skipping 16 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink