Split out String, URI and CustomIdent from CSSPrimitiveValue

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 241 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<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
+inline PassRefPtrWillBeRawPtr<CSSStringValue> CSSPropertyParser::createPrimitiveStringValue(CSSParserValue* value)
 {
-    ASSERT(value->unit() == CSSPrimitiveValue::UnitType::String || value->m_unit == CSSParserValue::Identifier);
-    return cssValuePool().createValue(value->string, CSSPrimitiveValue::UnitType::String);
+    ASSERT(value->m_unit == CSSParserValue::String || value->m_unit == CSSParserValue::Identifier);
+    return CSSStringValue::create(value->string);
 }
 
-inline PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
+inline PassRefPtrWillBeRawPtr<CSSCustomIdentValue> CSSPropertyParser::createPrimitiveCustomIdentValue(CSSParserValue* value)
 {
-    ASSERT(value->unit() == CSSPrimitiveValue::UnitType::String || value->m_unit == CSSParserValue::Identifier);
-    return cssValuePool().createValue(value->string, CSSPrimitiveValue::UnitType::CustomIdentifier);
+    ASSERT(value->m_unit == CSSParserValue::String || value->m_unit == CSSParserValue::Identifier);
+    return CSSCustomIdentValue::create(value->string);
 }
 
 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 243 matching lines @@
         // Grammar defined by CSS3 UI and modified by CSS4 images:
         // [ [<image> [<x> <y>]?,]*
         // [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
         // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | ew-resize |
         // ns-resize | nesw-resize | nwse-resize | col-resize | row-resize | text | wait | help |
         // vertical-text | cell | context-menu | alias | copy | no-drop | not-allowed | all-scroll |
         // zoom-in | zoom-out | -webkit-grab | -webkit-grabbing | -webkit-zoom-in | -webkit-zoom-out ] ] | inherit
         RefPtrWillBeRawPtr<CSSValueList> list = nullptr;
         while (value) {
             RefPtrWillBeRawPtr<CSSValue> image = nullptr;
-            if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
+            if (value->m_unit == CSSParserValue::URI) {
                 String uri = value->string;
                 if (!uri.isNull())
                     image = createCSSImageValueWithReferrer(uri, completeURL(uri));
             } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueWebkitImageSet) {
                 image = parseImageSet(m_valueList);
                 if (!image)
                     break;
             } else
                 break;
 
@@ skipping 108 matching lines @@
     }
     case CSSPropertyObjectPosition:
         parsedValue = parsePosition(m_valueList);
         break;
     case CSSPropertyListStyleImage:     // <uri> | none | inherit
     case CSSPropertyBorderImageSource:
     case CSSPropertyWebkitMaskBoxImageSource:
         if (id == CSSValueNone) {
             parsedValue = cssValuePool().createIdentifierValue(CSSValueNone);
             m_valueList->next();
-        } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
+        } else if (value->m_unit == CSSParserValue::URI) {
             parsedValue = createCSSImageValueWithReferrer(value->string, completeURL(value->string));
             m_valueList->next();
         } else if (isGeneratedImageValue(value)) {
             if (parseGeneratedImage(m_valueList, parsedValue))
                 m_valueList->next();
             else
                 return false;
         } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueWebkitImageSet) {
             parsedValue = parseImageSet(m_valueList);
             if (!parsedValue)
@@ skipping 575 matching lines @@
         break;
 
     case CSSPropertyWebkitFontSizeDelta: // <length>
         validPrimitive = validUnit(value, FLength | FUnitlessQuirk);
         break;
 
     case CSSPropertyWebkitHyphenateCharacter:
     case CSSPropertyWebkitLocale:
         if (id == CSSValueAuto) {
             validPrimitive = true;
-        } else if (value->unit() == CSSPrimitiveValue::UnitType::String) {
+        } else if (value->m_unit == CSSParserValue::String) {
             parsedValue = createPrimitiveStringValue(value);
             m_valueList->next();
         }
         break;
 
     // End Apple-specific properties
 
     case CSSPropertyWebkitAppRegion:
         if (id >= CSSValueDrag && id <= CSSValueNoDrag)
             validPrimitive = true;
@@ skipping 115 matching lines @@
         if (id == CSSValueNormal)
             validPrimitive = true;
         else
             return parseFontVariantLigatures(important);
         break;
     case CSSPropertyWebkitClipPath:
         if (id == CSSValueNone) {
             validPrimitive = true;
         } else if (value->m_unit == CSSParserValue::Function) {
             parsedValue = parseBasicShape();
-        } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
-            parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::UnitType::URI);
+        } else if (value->m_unit == CSSParserValue::URI) {
+            parsedValue = CSSURIValue::create(value->string);
             addProperty(propId, parsedValue.release(), important);
             return true;
         }
         break;
     case CSSPropertyShapeOutside:
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseShapeProperty(propId);
         break;
@@ skipping 252 matching lines @@
 }
 
 static bool isValidTransitionPropertyList(CSSValueList* value)
 {
     if (value->length() < 2)
         return true;
     for (auto& property : *value) {
         // FIXME: Shorthand parsing shouldn't add initial to the list since it won't round-trip
         if (property->isInitialValue())
             continue;
-        CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(property.get());
-        if (primitiveValue->isValueID() && primitiveValue->getValueID() == CSSValueNone)
+        if (property->isPrimitiveValue() && toCSSPrimitiveValue(*property).isValueID() && toCSSPrimitiveValue(*property).getValueID() == CSSValueNone)
             return false;
     }
     return true;
 }
 
 bool CSSPropertyParser::parseAnimationShorthand(bool useLegacyparsing, bool important)
 {
     const StylePropertyShorthand& animationProperties = animationShorthandForParsing();
     const unsigned numProperties = 8;
 
@@ skipping 375 matching lines @@
 
 // [ <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->unit() == CSSPrimitiveValue::UnitType::URI) {
+        if (val->m_unit == CSSParserValue::URI) {
             // url
             parsedValue = createCSSImageValueWithReferrer(val->string, completeURL(val->string));
         } 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) {
@@ skipping 11 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::UnitType::String) {
+        } else if (val->m_unit == CSSParserValue::String) {
             parsedValue = createPrimitiveStringValue(val);
         }
         if (!parsedValue)
             return nullptr;
         values->append(parsedValue.release());
         m_valueList->next();
     }
 
     return values.release();
 }
@@ skipping 12 matching lines @@
     // 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(CSSPrimitiveValue::create(attrName, CSSPrimitiveValue::UnitType::CustomIdentifier));
+    attrValue->append(CSSCustomIdentValue::create(attrName));
     return attrValue.release();
 }
 
 bool CSSPropertyParser::acceptQuirkyColors(CSSPropertyID propertyId) const
 {
     if (!inQuirksMode())
         return false;
     switch (propertyId) {
     case CSSPropertyBackgroundColor:
     case CSSPropertyBorderBottomColor:
@@ skipping 53 matching lines @@
         return nullptr;
     return cssValuePool().createColorValue(c);
 }
 
 bool CSSPropertyParser::parseFillImage(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value)
 {
     if (valueList->current()->id == CSSValueNone) {
         value = cssValuePool().createIdentifierValue(CSSValueNone);
         return true;
     }
-    if (valueList->current()->unit() == CSSPrimitiveValue::UnitType::URI) {
+    if (valueList->current()->m_unit == CSSParserValue::URI) {
         value = createCSSImageValueWithReferrer(valueList->current()->string, completeURL(valueList->current()->string));
         return true;
     }
 
     if (isGeneratedImageValue(valueList->current()))
         return parseGeneratedImage(valueList, value);
 
     if (valueList->current()->m_unit == CSSParserValue::Function && valueList->current()->function->id == CSSValueWebkitImageSet) {
         value = parseImageSet(m_valueList);
         if (value)
@@ skipping 673 matching lines @@
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseAnimationName(bool allowQuotedName)
 {
     CSSParserValue* value = m_valueList->current();
 
     if (value->id == CSSValueNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     if (value->m_unit == CSSParserValue::Identifier)
         return createPrimitiveCustomIdentValue(value);
 
-    if (allowQuotedName && value->unit() == CSSPrimitiveValue::UnitType::String) {
+    if (allowQuotedName && value->m_unit == CSSParserValue::String) {
         // 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 createPrimitiveCustomIdentValue(value);
     }
 
     return nullptr;
 }
@@ skipping 185 matching lines @@
     return value.id == CSSValueInitial || value.id == CSSValueInherit || value.id == CSSValueUnset || value.id == CSSValueDefault;
 }
 
 static inline bool isValidCustomIdentForGridPositions(const CSSParserValue& value)
 {
     // FIXME: we need a more general solution for <custom-ident> in all properties.
     return value.m_unit == CSSParserValue::Identifier && value.id != CSSValueSpan && value.id != CSSValueAuto && !isCSSWideKeyword(value);
 }
 
 // The function parses [ <integer> || <custom-ident> ] in <grid-line> (which can be stand alone or with 'span').
-bool CSSPropertyParser::parseIntegerOrCustomIdentFromGridPosition(RefPtrWillBeRawPtr<CSSPrimitiveValue>& numericValue, RefPtrWillBeRawPtr<CSSPrimitiveValue>& gridLineName)
+bool CSSPropertyParser::parseIntegerOrCustomIdentFromGridPosition(RefPtrWillBeRawPtr<CSSPrimitiveValue>& numericValue, RefPtrWillBeRawPtr<CSSCustomIdentValue>& gridLineName)
 {
     CSSParserValue* value = m_valueList->current();
     if (validUnit(value, FInteger) && value->fValue) {
         numericValue = createPrimitiveNumericValue(value);
         value = m_valueList->next();
         if (value && isValidCustomIdentForGridPositions(*value)) {
             gridLineName = createPrimitiveCustomIdentValue(m_valueList->current());
             m_valueList->next();
         }
         return true;
@@ skipping 16 matching lines @@
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
 
     CSSParserValue* value = m_valueList->current();
     if (value->id == CSSValueAuto) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueAuto);
     }
 
     RefPtrWillBeRawPtr<CSSPrimitiveValue> numericValue = nullptr;
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> gridLineName = nullptr;
+    RefPtrWillBeRawPtr<CSSCustomIdentValue> gridLineName = nullptr;
     bool hasSeenSpanKeyword = false;
 
     if (parseIntegerOrCustomIdentFromGridPosition(numericValue, gridLineName)) {
         value = m_valueList->current();
         if (value && value->id == CSSValueSpan) {
             hasSeenSpanKeyword = true;
             m_valueList->next();
         }
     } else if (value->id == CSSValueSpan) {
         hasSeenSpanKeyword = true;
@@ skipping 11 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::UnitType::CustomIdentifier);
+        return CSSCustomIdentValue::create(gridLineName->value());
 
     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();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> gridMissingGridPositionValue(CSSValue* value)
 {
-    if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->isCustomIdent())
+    if (value->isCustomIdentValue())
         return value;
 
     return cssValuePool().createIdentifierValue(CSSValueAuto);
 }
 
 bool CSSPropertyParser::parseGridItemPositionShorthand(CSSPropertyID shorthandId, bool important)
 {
     ShorthandScope scope(this, shorthandId);
     const StylePropertyShorthand& shorthand = shorthandForProperty(shorthandId);
     ASSERT(shorthand.length() == 2);
@@ skipping 38 matching lines @@
         // Handle leading <custom-ident>*.
         if (!parseGridLineNames(*m_valueList, *templateRows, trailingIdentWasAdded ? toCSSGridLineNamesValue(templateRows->item(templateRows->length() - 1)) : nullptr))
             return false;
 
         // 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() != CSSPrimitiveValue::UnitType::String) {
+        if (m_valueList->current() && m_valueList->current()->m_unit != CSSParserValue::String) {
             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.
         if (!parseGridLineNames(*m_valueList, *templateRows))
@@ skipping 202 matching lines @@
     if (!lineNames)
         lineNames = CSSGridLineNamesValue::create();
 
     while (CSSParserValue* identValue = inputList.current()) {
         if (isClosingBracket(*identValue))
             break;
 
         if (!isValidCustomIdentForGridPositions(*identValue))
             return false;
 
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> lineName = createPrimitiveCustomIdentValue(identValue);
+        RefPtrWillBeRawPtr<CSSCustomIdentValue> lineName = createPrimitiveCustomIdentValue(identValue);
         lineNames->append(lineName.release());
         inputList.next();
     }
 
     if (!inputList.current() || !isClosingBracket(*inputList.current()))
         return false;
 
     if (!previousNamedAreaTrailingLineNames)
         valueList.append(lineNames.release());
 
@@ skipping 183 matching lines @@
 
     if (!areaName.isEmpty())
         columnNames.append(areaName.toString());
 
     return columnNames;
 }
 
 bool CSSPropertyParser::parseGridTemplateAreasRow(NamedGridAreaMap& gridAreaMap, const size_t rowCount, size_t& columnCount)
 {
     CSSParserValue* currentValue = m_valueList->current();
-    if (!currentValue || currentValue->unit() != CSSPrimitiveValue::UnitType::String)
+    if (!currentValue || currentValue->m_unit != CSSParserValue::String)
         return false;
 
     String gridRowNames = currentValue->string;
     if (gridRowNames.isEmpty() || gridRowNames.containsOnlyWhitespace())
         return false;
 
     Vector<String> columnNames = parseGridTemplateAreasColumnNames(gridRowNames);
     if (!columnCount) {
         columnCount = columnNames.size();
         ASSERT(columnCount);
@@ skipping 111 matching lines @@
 {
     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<CSSPrimitiveValue> identifier = createPrimitiveCustomIdentValue(i);
+    RefPtrWillBeRawPtr<CSSCustomIdentValue> identifier = createPrimitiveCustomIdentValue(i);
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> separator = nullptr;
+    RefPtrWillBeRawPtr<CSSCustomIdentValue> separator = nullptr;
     if (!counters)
-        separator = cssValuePool().createValue(String(), CSSPrimitiveValue::UnitType::CustomIdentifier);
+        separator = CSSCustomIdentValue::create(String());
     else {
         args->next();
         if (!consumeComma(args))
             return nullptr;
 
         i = args->current();
-        if (i->unit() != CSSPrimitiveValue::UnitType::String)
+        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 {
@@ skipping 735 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::UnitType::String || nextValue->m_unit == CSSParserValue::Identifier));
+            (nextValue->m_unit == CSSParserValue::String || nextValue->m_unit == CSSParserValue::Identifier));
 
         if (isCSSWideKeyword(*value) && !inFamily) {
             if (nextValBreaksFont)
                 return nullptr;
             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::UnitType::String) {
+        } else if (value->m_unit == CSSParserValue::String) {
             // Strings never share in a family name.
             inFamily = false;
             familyBuilder.commit();
             list->append(cssValuePool().createFontFamilyValue(value->string));
         } else if (value->m_unit == CSSParserValue::Identifier) {
             if (inFamily)
                 familyBuilder.add(value->string);
             else if (nextValBreaksFont || !nextValIsFontName)
                 list->append(cssValuePool().createFontFamilyValue(value->string));
             else {
@@ skipping 135 matching lines @@
 
     CSSParserValue* value = m_valueList->next();
     if (!value || value->m_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::UnitType::String && args->current()->m_unit != CSSParserValue::Identifier))
+    if (!args || args->size() != 1 || (args->current()->m_unit != CSSParserValue::String && args->current()->m_unit != CSSParserValue::Identifier))
         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::UnitType::String) {
+    if (args->size() == 1 && args->current()->m_unit == CSSParserValue::String) {
         valueList->append(CSSFontFaceSrcValue::createLocal(args->current()->string, shouldCheckContentSecurityPolicy));
     } else if (args->current()->m_unit == CSSParserValue::Identifier) {
         StringBuilder builder;
         for (CSSParserValue* localValue = args->current(); localValue; localValue = args->next()) {
             if (localValue->m_unit != CSSParserValue::Identifier)
                 return false;
             if (!builder.isEmpty())
                 builder.append(' ');
             builder.append(localValue->string);
         }
         valueList->append(CSSFontFaceSrcValue::createLocal(builder.toString(), shouldCheckContentSecurityPolicy));
     } else
         return false;
 
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFontFaceSrc()
 {
     RefPtrWillBeRawPtr<CSSValueList> values(CSSValueList::createCommaSeparated());
 
     while (true) {
         CSSParserValue* value = m_valueList->current();
         if (!value)
             return nullptr;
-        if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
+        if (value->m_unit == CSSParserValue::URI) {
             if (!parseFontFaceSrcURI(values.get()))
                 return nullptr;
         } else if (value->m_unit == CSSParserValue::Function && value->function->id == CSSValueLocal) {
             if (!parseFontFaceSrcLocal(values.get()))
                 return nullptr;
         } else {
             return nullptr;
         }
 
         if (!m_valueList->current())
@@ skipping 535 matching lines @@
 bool CSSPropertyParser::buildBorderImageParseContext(CSSPropertyID propId, BorderImageParseContext& context)
 {
     CSSPropertyParser::ShorthandScope scope(this, propId);
     while (CSSParserValue* val = m_valueList->current()) {
         context.setCanAdvance(false);
 
         if (!context.canAdvance() && context.allowForwardSlashOperator() && isForwardSlashOperator(val))
             context.commitForwardSlashOperator();
 
         if (!context.canAdvance() && context.allowImage()) {
-            if (val->unit() == CSSPrimitiveValue::UnitType::URI) {
+            if (val->m_unit == CSSParserValue::URI) {
                 context.commitImage(createCSSImageValueWithReferrer(val->string, m_context.completeURL(val->string)));
             } else if (isGeneratedImageValue(val)) {
                 RefPtrWillBeRawPtr<CSSValue> value = nullptr;
                 if (parseGeneratedImage(m_valueList, value))
                     context.commitImage(value.release());
                 else
                     return false;
             } else if (val->m_unit == CSSParserValue::Function && val->function->id == CSSValueWebkitImageSet) {
                 RefPtrWillBeRawPtr<CSSValue> value = parseImageSet(m_valueList);
                 if (value)
@@ skipping 380 matching lines @@
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounter(int defaultValue)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->m_unit != CSSParserValue::Identifier)
             return nullptr;
-        RefPtrWillBeRawPtr<CSSPrimitiveValue> counterName = createPrimitiveCustomIdentValue(val);
+        RefPtrWillBeRawPtr<CSSCustomIdentValue> counterName = createPrimitiveCustomIdentValue(val);
         m_valueList->next();
 
         val = m_valueList->current();
         int i = defaultValue;
         if (val && validUnit(val, FInteger)) {
             i = clampTo<int>(val->fValue);
             m_valueList->next();
         }
 
         list->append(CSSValuePair::create(counterName.release(),
@@ skipping 809 matching lines @@
         return nullptr;
 
     CSSParserValueList* functionArgs = valueList->current()->function->args.get();
     if (!functionArgs || !functionArgs->size() || !functionArgs->current())
         return nullptr;
 
     RefPtrWillBeRawPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
 
     while (functionArgs->current()) {
         CSSParserValue* arg = functionArgs->current();
-        if (arg->unit() != CSSPrimitiveValue::UnitType::URI)
+        if (arg->m_unit != CSSParserValue::URI)
             return nullptr;
 
         RefPtrWillBeRawPtr<CSSValue> image = createCSSImageValueWithReferrer(arg->string, completeURL(arg->string));
         imageSet->append(image);
 
         arg = functionArgs->next();
         if (!arg)
             return nullptr;
 
         if (arg->m_unit != CSSParserValue::DimensionList)
@@ skipping 104 matching lines @@
 }
 
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parseFilter()
 {
     if (!m_valueList)
         return nullptr;
 
     // The filter is a list of functional primitives that specify individual operations.
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
-        if (value->unit() != CSSPrimitiveValue::UnitType::URI && (value->m_unit != CSSParserValue::Function || !value->function))
+        if (value->m_unit != CSSParserValue::URI && (value->m_unit != CSSParserValue::Function || !value->function))
             return nullptr;
 
         // See if the specified primitive is one we understand.
-        if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
+        if (value->m_unit == CSSParserValue::URI) {
             RefPtrWillBeRawPtr<CSSFunctionValue> referenceFilterValue = CSSFunctionValue::create(CSSValueUrl);
             referenceFilterValue->append(CSSSVGDocumentValue::create(value->string));
             list->append(referenceFilterValue.release());
         } else {
             CSSValueID filterType = value->function->id;
             unsigned maximumArgumentCount = filterType == CSSValueDropShadow ? 4 : 1;
 
             CSSParserValueList* args = value->function->args.get();
             if (!args || args->size() > maximumArgumentCount)
                 return nullptr;
@@ skipping 159 matching lines @@
         return list.release();
     return nullptr;
 }
 
 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::UnitType::String) {
+        if (value->m_unit == CSSParserValue::String) {
             if (fill || shape)
                 return nullptr;
             m_valueList->next();
             return createPrimitiveStringValue(value);
         }
 
         if (value->id == CSSValueNone) {
             if (fill || shape)
                 return nullptr;
             m_valueList->next();
@@ skipping 66 matching lines @@
     return list.release();
 }
 
 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::UnitType::String)
+    if (value->m_unit != CSSParserValue::String)
         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 329 matching lines @@
         break;
 
     case CSSPropertyClipPath:
     case CSSPropertyFilter:
     case CSSPropertyMarkerStart:
     case CSSPropertyMarkerMid:
     case CSSPropertyMarkerEnd:
     case CSSPropertyMask:
         if (id == CSSValueNone) {
             validPrimitive = true;
-        } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
-            parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::UnitType::URI);
+        } else if (value->m_unit == CSSParserValue::URI) {
+            parsedValue = CSSURIValue::create(value->string);
             if (parsedValue)
                 m_valueList->next();
         }
         break;
 
     case CSSPropertyStrokeMiterlimit: // <miterlimit> | inherit
         validPrimitive = validUnit(value, FNumber | FNonNeg, SVGAttributeMode);
         break;
 
     case CSSPropertyStrokeOpacity: // <opacity-value> | inherit
@@ skipping 20 matching lines @@
             if (parsedValue)
                 m_valueList->next();
         }
         break;
 
     case CSSPropertyFill: // <paint> | inherit
     case CSSPropertyStroke: // <paint> | inherit
         {
             if (id == CSSValueNone) {
                 parsedValue = cssValuePool().createIdentifierValue(id);
-            } else if (value->unit() == CSSPrimitiveValue::UnitType::URI) {
+            } else if (value->m_unit == CSSParserValue::URI) {
                 if (m_valueList->next()) {
                     RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
-                    values->append(CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::UnitType::URI));
+                    values->append(CSSURIValue::create(value->string));
                     if (m_valueList->current()->id == CSSValueNone)
                         parsedValue = cssValuePool().createIdentifierValue(m_valueList->current()->id);
                     else
                         parsedValue = parseColor(m_valueList->current());
                     if (parsedValue) {
                         values->append(parsedValue);
                         parsedValue = values;
                     }
                 }
                 if (!parsedValue)
-                    parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::UnitType::URI);
+                    parsedValue = CSSURIValue::create(value->string);
             } else {
                 parsedValue = parseColor(m_valueList->current());
             }
 
             if (parsedValue)
                 m_valueList->next();
         }
         break;
 
     case CSSPropertyStopColor: // TODO : icccolor
@@ skipping 48 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::UnitType::String)
-            parsedValue = CSSPrimitiveValue::create(value->string, value->unit());
+        else if (value->m_unit == CSSParserValue::String)
+            parsedValue = CSSStringValue::create(value->string);
         else if (value->unit() >= CSSPrimitiveValue::UnitType::Number && value->unit() <= CSSPrimitiveValue::UnitType::Kilohertz)
             parsedValue = CSSPrimitiveValue::create(value->fValue, value->unit());
         else if (value->unit() == CSSPrimitiveValue::UnitType::Rems || value->unit() == CSSPrimitiveValue::UnitType::Chs)
             parsedValue = CSSPrimitiveValue::create(value->fValue, value->unit());
         else if (value->unit() == CSSPrimitiveValue::UnitType::QuirkyEms)
             parsedValue = CSSPrimitiveValue::create(value->fValue, CSSPrimitiveValue::UnitType::QuirkyEms);
         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();
@@ skipping 286 matching lines @@
     // FIXME: Add support for <url>, <basic-shape>, <geometry-box>.
     if (value->m_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::UnitType::String)
+    if (arg->m_unit != CSSParserValue::String)
         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