Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #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/CSSCursorImageValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSFontFamilyValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridAutoRepeatValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSGridTemplateAreasValue.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSInheritedValue.h"
 #include "core/css/CSSInitialValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPendingSubstitutionValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSStringValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
@@ skipping 422 matching lines @@
         default:
             return ParseResult::UnknownValue;
         }
         m_result->append(*consumeIdent(range));
         return ParseResult::ConsumedValue;
     }
 
     CSSValue* finalizeValue()
     {
         if (!m_result->length())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+            return CSSIdentifierValue::create(CSSValueNormal);
         return m_result.release();
     }
 
 private:
     bool m_sawCommonLigaturesValue;
     bool m_sawDiscretionaryLigaturesValue;
     bool m_sawHistoricalLigaturesValue;
     bool m_sawContextualLigaturesValue;
     Member<CSSValueList> m_result;
 };
 
 static CSSValue* consumeFontVariantLigatures(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueNormal || range.peek().id() == CSSValueNone)
         return consumeIdent(range);
 
     FontVariantLigaturesParser ligaturesParser;
     do {
         if (ligaturesParser.consumeLigature(range) !=
             FontVariantLigaturesParser::ParseResult::ConsumedValue)
             return nullptr;
     } while (!range.atEnd());
 
     return ligaturesParser.finalizeValue();
 }
 
-static CSSPrimitiveValue* consumeFontVariantCaps(CSSParserTokenRange& range)
+static CSSIdentifierValue* consumeFontVariantCaps(CSSParserTokenRange& range)
 {
     return consumeIdent<CSSValueNormal, CSSValueSmallCaps, CSSValueAllSmallCaps,
         CSSValuePetiteCaps, CSSValueAllPetiteCaps,
         CSSValueUnicase, CSSValueTitlingCaps>(range);
 }
 
 class FontVariantNumericParser {
     STACK_ALLOCATED();
 
 public:
@@ skipping 48 matching lines @@
         default:
             return ParseResult::UnknownValue;
         }
         m_result->append(*consumeIdent(range));
         return ParseResult::ConsumedValue;
     }
 
     CSSValue* finalizeValue()
     {
         if (!m_result->length())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+            return CSSIdentifierValue::create(CSSValueNormal);
         return m_result.release();
     }
 
 
 private:
     bool m_sawNumericFigureValue;
     bool m_sawNumericSpacingValue;
     bool m_sawNumericFractionValue;
     bool m_sawOrdinalValue;
     bool m_sawSlashedZeroValue;
     Member<CSSValueList> m_result;
 };
 
 static CSSValue* consumeFontVariantNumeric(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueNormal)
         return consumeIdent(range);
 
     FontVariantNumericParser numericParser;
     do {
         if (numericParser.consumeNumeric(range) !=
             FontVariantNumericParser::ParseResult::ConsumedValue)
             return nullptr;
     } while (!range.atEnd());
 
     return numericParser.finalizeValue();
 }
 
-static CSSPrimitiveValue* consumeFontVariantCSS21(CSSParserTokenRange& range)
+static CSSIdentifierValue* consumeFontVariantCSS21(CSSParserTokenRange& range)
 {
     return consumeIdent<CSSValueNormal, CSSValueSmallCaps>(range);
 }
 
 static CSSValue* consumeFontVariantList(CSSParserTokenRange& range)
 {
     CSSValueList* values = CSSValueList::createCommaSeparated();
     do {
         if (range.peek().id() == CSSValueAll) {
             // FIXME: CSSPropertyParser::parseFontVariant() implements
             // the old css3 draft:
             // http://www.w3.org/TR/2002/WD-css3-webfonts-20020802/#font-variant
             // 'all' is only allowed in @font-face and with no other values.
             if (values->length())
                 return nullptr;
             return consumeIdent(range);
         }
-        CSSPrimitiveValue* fontVariant = consumeFontVariantCSS21(range);
+        CSSIdentifierValue* fontVariant = consumeFontVariantCSS21(range);
         if (fontVariant)
             values->append(*fontVariant);
     } while (consumeCommaIncludingWhitespace(range));
 
     if (values->length())
         return values;
 
     return nullptr;
 }
 
-static CSSPrimitiveValue* consumeFontWeight(CSSParserTokenRange& range)
+static CSSIdentifierValue* consumeFontWeight(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.peek();
     if (token.id() >= CSSValueNormal && token.id() <= CSSValueLighter)
         return consumeIdent(range);
     if (token.type() != NumberToken || token.numericValueType() != IntegerValueType)
         return nullptr;
     int weight = static_cast<int>(token.numericValue());
     if ((weight % 100) || weight < 100 || weight > 900)
         return nullptr;
     range.consumeIncludingWhitespace();
-    return CSSPrimitiveValue::createIdentifier(static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1));
+    return CSSIdentifierValue::create(static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1));
 }
 
 static String concatenateFamilyName(CSSParserTokenRange& range)
 {
     StringBuilder builder;
     bool addedSpace = false;
     const CSSParserToken& firstToken = range.peek();
     while (range.peek().type() == IdentToken) {
         if (!builder.isEmpty()) {
             builder.append(' ');
@@ skipping 67 matching lines @@
     return consumePercent(range, ValueRangeNonNegative);
 }
 
 static CSSValue* consumeFontSize(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless = UnitlessQuirk::Forbid)
 {
     if (range.peek().id() >= CSSValueXxSmall && range.peek().id() <= CSSValueLarger)
         return consumeIdent(range);
     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, unitless);
 }
 
-static CSSPrimitiveValue* consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static CSSValue* consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     if (range.peek().id() == CSSValueNormal)
         return consumeIdent(range);
 
     CSSPrimitiveValue* lineHeight = consumeNumber(range, ValueRangeNonNegative);
     if (lineHeight)
         return lineHeight;
     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
 }
 
@@ skipping 214 matching lines @@
     return consumeLengthOrPercent(range, context.mode(), ValueRangeNonNegative, unitless);
 }
 
 static CSSValue* consumeMarginOrOffset(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
     return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless);
 }
 
-static CSSPrimitiveValue* consumeClipComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static CSSValue* consumeClipComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
     return consumeLength(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
 }
 
 static CSSValue* consumeClip(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
 
     if (range.peek().functionId() != CSSValueRect)
         return nullptr;
 
     CSSParserTokenRange args = consumeFunction(range);
     // rect(t, r, b, l) || rect(t r b l)
-    CSSPrimitiveValue* top = consumeClipComponent(args, cssParserMode);
+    CSSValue* top = consumeClipComponent(args, cssParserMode);
     if (!top)
         return nullptr;
     bool needsComma = consumeCommaIncludingWhitespace(args);
-    CSSPrimitiveValue* right = consumeClipComponent(args, cssParserMode);
+    CSSValue* right = consumeClipComponent(args, cssParserMode);
     if (!right || (needsComma && !consumeCommaIncludingWhitespace(args)))
         return nullptr;
-    CSSPrimitiveValue* bottom = consumeClipComponent(args, cssParserMode);
+    CSSValue* bottom = consumeClipComponent(args, cssParserMode);
     if (!bottom || (needsComma && !consumeCommaIncludingWhitespace(args)))
         return nullptr;
-    CSSPrimitiveValue* left = consumeClipComponent(args, cssParserMode);
+    CSSValue* left = consumeClipComponent(args, cssParserMode);
     if (!left || !args.atEnd())
         return nullptr;
     return CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsRect);
 }
 
 static bool consumePan(CSSParserTokenRange& range, CSSValue*& panX, CSSValue*& panY, CSSValue*& pinchZoom)
 {
     CSSValueID id = range.peek().id();
     if ((id == CSSValuePanX || id == CSSValuePanRight || id == CSSValuePanLeft) && !panX) {
         if (id != CSSValuePanX && !RuntimeEnabledFeatures::cssTouchActionPanDirectionsEnabled())
@@ skipping 84 matching lines @@
 }
 
 static CSSValue* consumeColumnSpan(CSSParserTokenRange& range)
 {
     return consumeIdent<CSSValueAll, CSSValueNone>(range);
 }
 
 static CSSValue* consumeZoom(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     const CSSParserToken& token = range.peek();
-    CSSPrimitiveValue* zoom = nullptr;
+    CSSValue* zoom = nullptr;
     if (token.type() == IdentToken) {
         zoom = consumeIdent<CSSValueNormal, CSSValueReset, CSSValueDocument>(range);
     } else {
         zoom = consumePercent(range, ValueRangeNonNegative);
         if (!zoom)
             zoom = consumeNumber(range, ValueRangeNonNegative);
     }
     if (zoom && context.useCounter()) {
         if (!(token.id() == CSSValueNormal
-            || (token.type() == NumberToken && zoom->getDoubleValue() == 1)
-            || (token.type() == PercentageToken && zoom->getDoubleValue() == 100)))
+            || (token.type() == NumberToken && toCSSPrimitiveValue(zoom)->getDoubleValue() == 1)
+            || (token.type() == PercentageToken && toCSSPrimitiveValue(zoom)->getDoubleValue() == 100)))
             context.useCounter()->count(UseCounter::CSSZoomNotEqualToOne);
         if (token.id() == CSSValueReset)
             context.useCounter()->count(UseCounter::CSSZoomReset);
         if (token.id() == CSSValueDocument)
             context.useCounter()->count(UseCounter::CSSZoomDocument);
     }
     return zoom;
 }
 
 static CSSValue* consumeAnimationIterationCount(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueInfinite)
         return consumeIdent(range);
     return consumeNumber(range, ValueRangeNonNegative);
 }
 
 static CSSValue* consumeAnimationName(CSSParserTokenRange& range, const CSSParserContext& context, bool allowQuotedName)
 {
     if (range.peek().id() == CSSValueNone)
         return consumeIdent(range);
 
     if (allowQuotedName && range.peek().type() == StringToken) {
         // Legacy support for strings in prefixed animations.
         if (context.useCounter())
             context.useCounter()->count(UseCounter::QuotedAnimationName);
 
         const CSSParserToken& token = range.consumeIncludingWhitespace();
         if (equalIgnoringASCIICase(token.value(), "none"))
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::create(CSSValueNone);
         return CSSCustomIdentValue::create(token.value().toAtomicString());
     }
 
     return consumeCustomIdent(range);
 }
 
 static CSSValue* consumeTransitionProperty(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.peek();
     if (token.type() != IdentToken)
@@ skipping 114 matching lines @@
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
 static bool isValidAnimationPropertyList(CSSPropertyID property, const CSSValueList& valueList)
 {
     if (property != CSSPropertyTransitionProperty || valueList.length() < 2)
         return true;
     for (auto& value : valueList) {
-        if (value->isPrimitiveValue() && toCSSPrimitiveValue(*value).isValueID()
-            && toCSSPrimitiveValue(*value).getValueID() == CSSValueNone)
+        if (value->isIdentifierValue() && toCSSIdentifierValue(*value).getValueID() == CSSValueNone)
             return false;
     }
     return true;
 }
 
 static CSSValueList* consumeAnimationPropertyList(CSSPropertyID property, CSSParserTokenRange& range, const CSSParserContext& context, bool useLegacyParsing)
 {
     CSSValueList* list = CSSValueList::createCommaSeparated();
     do {
         CSSValue* value = consumeAnimationValue(property, range, context, useLegacyParsing);
@@ skipping 55 matching lines @@
 
 static CSSValue* consumeZIndex(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
     return consumeInteger(range);
 }
 
 static CSSShadowValue* parseSingleShadow(CSSParserTokenRange& range, CSSParserMode cssParserMode, bool allowInset, bool allowSpread)
 {
-    CSSPrimitiveValue* style = nullptr;
+    CSSIdentifierValue* style = nullptr;
     CSSValue* color = nullptr;
 
     if (range.atEnd())
         return nullptr;
     if (range.peek().id() == CSSValueInset) {
         if (!allowInset)
             return nullptr;
         style = consumeIdent(range);
     }
     color = consumeColor(range, cssParserMode);
@@ skipping 111 matching lines @@
 }
 
 static CSSValue* consumeTextDecorationLine(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueNone)
         return consumeIdent(range);
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     while (true) {
-        CSSPrimitiveValue* ident = consumeIdent<CSSValueBlink, CSSValueUnderline, CSSValueOverline, CSSValueLineThrough>(range);
+        CSSIdentifierValue* ident = consumeIdent<CSSValueBlink, CSSValueUnderline, CSSValueOverline, CSSValueLineThrough>(range);
         if (!ident)
             break;
         if (list->hasValue(*ident))
             return nullptr;
         list->append(*ident);
     }
 
     if (!list->length())
         return nullptr;
     return list;
 }
 
 // none | strict | content | [ layout || style || paint || size ]
 static CSSValue* consumeContain(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueNone)
         return consumeIdent(range);
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (id == CSSValueStrict || id == CSSValueContent) {
         list->append(*consumeIdent(range));
         return list;
     }
     while (true) {
-        CSSPrimitiveValue* ident = consumeIdent<CSSValuePaint, CSSValueLayout, CSSValueStyle, CSSValueSize>(range);
+        CSSIdentifierValue* ident = consumeIdent<CSSValuePaint, CSSValueLayout, CSSValueStyle, CSSValueSize>(range);
         if (!ident)
             break;
         if (list->hasValue(*ident))
             return nullptr;
         list->append(*ident);
     }
 
     if (!list->length())
         return nullptr;
     return list;
@@ skipping 12 matching lines @@
         return nullptr;
     String pathString = functionArgs.consumeIncludingWhitespace().value().toString();
 
     std::unique_ptr<SVGPathByteStream> byteStream = SVGPathByteStream::create();
     if (buildByteStreamFromString(pathString, *byteStream) != SVGParseStatus::NoError
         || !functionArgs.atEnd())
         return nullptr;
 
     range = functionRange;
     if (byteStream->isEmpty())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::create(CSSValueNone);
     return CSSPathValue::create(std::move(byteStream));
 }
 
 static CSSValue* consumePathOrNone(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueNone)
         return consumeIdent(range);
 
     return consumePath(range);
@@ skipping 27 matching lines @@
 
 static CSSValue* consumeTextEmphasisStyle(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueNone)
         return consumeIdent(range);
 
     if (CSSValue* textEmphasisStyle = consumeString(range))
         return textEmphasisStyle;
 
-    CSSPrimitiveValue* fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
-    CSSPrimitiveValue* shape = consumeIdent<CSSValueDot, CSSValueCircle, CSSValueDoubleCircle, CSSValueTriangle, CSSValueSesame>(range);
+    CSSIdentifierValue* fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
+    CSSIdentifierValue* shape = consumeIdent<CSSValueDot, CSSValueCircle, CSSValueDoubleCircle, CSSValueTriangle, CSSValueSesame>(range);
     if (!fill)
         fill = consumeIdent<CSSValueFilled, CSSValueOpen>(range);
     if (fill && shape) {
         CSSValueList* parsedValues = CSSValueList::createSpaceSeparated();
         parsedValues->append(*fill);
         parsedValues->append(*shape);
         return parsedValues;
     }
     if (fill)
         return fill;
     if (shape)
         return shape;
     return nullptr;
 }
 
 static CSSValue* consumeOutlineColor(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     // Allow the special focus color even in HTML Standard parsing mode.
     if (range.peek().id() == CSSValueWebkitFocusRingColor)
         return consumeIdent(range);
     return consumeColor(range, cssParserMode);
 }
 
-static CSSPrimitiveValue* consumeLineWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+static CSSValue* consumeLineWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
         return consumeIdent(range);
     return consumeLength(range, cssParserMode, ValueRangeNonNegative, unitless);
 }
 
-static CSSPrimitiveValue* consumeBorderWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+static CSSValue* consumeBorderWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
     return consumeLineWidth(range, cssParserMode, unitless);
 }
 
-static CSSPrimitiveValue* consumeTextStrokeWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static CSSValue* consumeTextStrokeWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
 }
 
-static CSSPrimitiveValue* consumeColumnRuleWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static CSSValue* consumeColumnRuleWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
 }
 
 static bool consumeTranslate3d(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSFunctionValue*& transformValue)
 {
     unsigned numberOfArguments = 2;
     CSSValue* parsedValue = nullptr;
     do {
         parsedValue = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
@@ skipping 197 matching lines @@
     }
     return consumeColor(range, cssParserMode);
 }
 
 static CSSValue* consumePaintOrder(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueNormal)
         return consumeIdent(range);
 
     Vector<CSSValueID, 3> paintTypeList;
-    CSSPrimitiveValue* fill = nullptr;
-    CSSPrimitiveValue* stroke = nullptr;
-    CSSPrimitiveValue* markers = nullptr;
+    CSSIdentifierValue* fill = nullptr;
+    CSSIdentifierValue* stroke = nullptr;
+    CSSIdentifierValue* markers = nullptr;
     do {
         CSSValueID id = range.peek().id();
         if (id == CSSValueFill && !fill)
             fill = consumeIdent(range);
         else if (id == CSSValueStroke && !stroke)
             stroke = consumeIdent(range);
         else if (id == CSSValueMarkers && !markers)
             markers = consumeIdent(range);
         else
             return nullptr;
@@ skipping 52 matching lines @@
     CSSValueList* dashes = CSSValueList::createCommaSeparated();
     do {
         CSSPrimitiveValue* dash = consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeNonNegative);
         if (!dash || (consumeCommaIncludingWhitespace(range) && range.atEnd()))
             return nullptr;
         dashes->append(*dash);
     } while (!range.atEnd());
     return dashes;
 }
 
-static CSSPrimitiveValue* consumeBaselineShift(CSSParserTokenRange& range)
+static CSSValue* consumeBaselineShift(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
         return consumeIdent(range);
     return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll);
 }
 
-static CSSPrimitiveValue* consumeRxOrRy(CSSParserTokenRange& range)
+static CSSValue* consumeRxOrRy(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
     return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll, UnitlessQuirk::Forbid);
 }
 
 static CSSValue* consumeCursor(CSSParserTokenRange& range, const CSSParserContext& context, bool inQuirksMode)
 {
     CSSValueList* list = nullptr;
     while (CSSValue* image = consumeImage(range, context, ConsumeGeneratedImage::Forbid)) {
@@ skipping 20 matching lines @@
     if (!range.atEnd() && context.useCounter()) {
         if (id == CSSValueWebkitZoomIn)
             context.useCounter()->count(UseCounter::PrefixedCursorZoomIn);
         else if (id == CSSValueWebkitZoomOut)
             context.useCounter()->count(UseCounter::PrefixedCursorZoomOut);
     }
     CSSValue* cursorType = nullptr;
     if (id == CSSValueHand) {
         if (!inQuirksMode) // Non-standard behavior
             return nullptr;
-        cursorType = CSSPrimitiveValue::createIdentifier(CSSValuePointer);
+        cursorType = CSSIdentifierValue::create(CSSValuePointer);
         range.consumeIncludingWhitespace();
     } else if ((id >= CSSValueAuto && id <= CSSValueWebkitZoomOut) || id == CSSValueCopy || id == CSSValueNone) {
         cursorType = consumeIdent(range);
     } else {
         return nullptr;
     }
 
     if (!list)
         return cursorType;
     list->append(*cursorType);
@@ skipping 26 matching lines @@
 
     CSSStringValue* separator = nullptr;
     if (!counters) {
         separator = CSSStringValue::create(String());
     } else {
         if (!consumeCommaIncludingWhitespace(args) || args.peek().type() != StringToken)
             return nullptr;
         separator = CSSStringValue::create(args.consumeIncludingWhitespace().value().toString());
     }
 
-    CSSPrimitiveValue* listStyle = nullptr;
+    CSSIdentifierValue* listStyle = nullptr;
     if (consumeCommaIncludingWhitespace(args)) {
         CSSValueID id = args.peek().id();
         if ((id != CSSValueNone && (id < CSSValueDisc || id > CSSValueKatakanaIroha)))
             return nullptr;
         listStyle = consumeIdent(args);
     } else {
-        listStyle = CSSPrimitiveValue::createIdentifier(CSSValueDecimal);
+        listStyle = CSSIdentifierValue::create(CSSValueDecimal);
     }
 
     if (!args.atEnd())
         return nullptr;
     return CSSCounterValue::create(identifier, listStyle, separator);
 }
 
 static CSSValue* consumeContent(CSSParserTokenRange& range, CSSParserContext context)
 {
     if (identMatches<CSSValueNone, CSSValueNormal>(range.peek().id()))
@@ skipping 16 matching lines @@
                 parsedValue = consumeCounterContent(consumeFunction(range), true);
             if (!parsedValue)
                 return nullptr;
         }
         values->append(*parsedValue);
     } while (!range.atEnd());
 
     return values;
 }
 
-static CSSPrimitiveValue* consumePerspective(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSPropertyID unresolvedProperty)
+static CSSValue* consumePerspective(CSSParserTokenRange& range, CSSParserMode cssParserMode, CSSPropertyID unresolvedProperty)
 {
     if (range.peek().id() == CSSValueNone)
         return consumeIdent(range);
     CSSPrimitiveValue* parsedValue = consumeLength(range, cssParserMode, ValueRangeAll);
     if (!parsedValue && (unresolvedProperty == CSSPropertyAliasWebkitPerspective)) {
         double perspective;
         if (!consumeNumberRaw(range, perspective))
             return nullptr;
         parsedValue = CSSPrimitiveValue::create(perspective, CSSPrimitiveValue::UnitType::Pixels);
     }
@@ skipping 41 matching lines @@
 {
     CSSValue* parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     if (!parsedValue1)
         return nullptr;
     CSSValue* parsedValue2 = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
     if (!parsedValue2)
         parsedValue2 = parsedValue1;
     return CSSValuePair::create(parsedValue1, parsedValue2, CSSValuePair::DropIdenticalValues);
 }
 
-static CSSPrimitiveValue* consumeVerticalAlign(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static CSSValue* consumeVerticalAlign(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
-    CSSPrimitiveValue* parsedValue = consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
+    CSSValue* parsedValue = consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
     if (!parsedValue)
         parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Allow);
     return parsedValue;
 }
 
-static CSSPrimitiveValue* consumeShapeRadius(CSSParserTokenRange& args, CSSParserMode cssParserMode)
+static CSSValue* consumeShapeRadius(CSSParserTokenRange& args, CSSParserMode cssParserMode)
 {
     if (identMatches<CSSValueClosestSide, CSSValueFarthestSide>(args.peek().id()))
         return consumeIdent(args);
     return consumeLengthOrPercent(args, cssParserMode, ValueRangeNonNegative);
 }
 
 static CSSBasicShapeCircleValue* consumeBasicShapeCircle(CSSParserTokenRange& args, const CSSParserContext& context)
 {
     // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes
     // circle( [<shape-radius>]? [at <position>]? )
     CSSBasicShapeCircleValue* shape = CSSBasicShapeCircleValue::create();
-    if (CSSPrimitiveValue* radius = consumeShapeRadius(args, context.mode()))
+    if (CSSValue* radius = consumeShapeRadius(args, context.mode()))
         shape->setRadius(radius);
     if (consumeIdent<CSSValueAt>(args)) {
         CSSValue* centerX = nullptr;
         CSSValue* centerY = nullptr;
         if (!consumePosition(args, context.mode(), UnitlessQuirk::Forbid, centerX, centerY))
             return nullptr;
         shape->setCenterX(centerX);
         shape->setCenterY(centerY);
     }
     return shape;
 }
 
 static CSSBasicShapeEllipseValue* consumeBasicShapeEllipse(CSSParserTokenRange& args, const CSSParserContext& context)
 {
     // spec: https://drafts.csswg.org/css-shapes/#supported-basic-shapes
     // ellipse( [<shape-radius>{2}]? [at <position>]? )
     CSSBasicShapeEllipseValue* shape = CSSBasicShapeEllipseValue::create();
-    if (CSSPrimitiveValue* radiusX = consumeShapeRadius(args, context.mode())) {
+    if (CSSValue* radiusX = consumeShapeRadius(args, context.mode())) {
         shape->setRadiusX(radiusX);
-        if (CSSPrimitiveValue* radiusY = consumeShapeRadius(args, context.mode()))
+        if (CSSValue* radiusY = consumeShapeRadius(args, context.mode()))
             shape->setRadiusY(radiusY);
     }
     if (consumeIdent<CSSValueAt>(args)) {
         CSSValue* centerX = nullptr;
         CSSValue* centerY = nullptr;
         if (!consumePosition(args, context.mode(), UnitlessQuirk::Forbid, centerX, centerY))
             return nullptr;
         shape->setCenterX(centerX);
         shape->setCenterY(centerY);
     }
@@ skipping 14 matching lines @@
         if (!xLength)
             return nullptr;
         CSSPrimitiveValue* yLength = consumeLengthOrPercent(args, context.mode(), ValueRangeAll);
         if (!yLength)
             return nullptr;
         shape->appendPoint(xLength, yLength);
     } while (consumeCommaIncludingWhitespace(args));
     return shape;
 }
 
-static void complete4Sides(CSSPrimitiveValue* side[4])
+static void complete4Sides(CSSValue* side[4])
 {
     if (side[3])
         return;
     if (!side[2]) {
         if (!side[1])
             side[1] = side[0];
         side[2] = side[0];
     }
     side[3] = side[1];
 }
 
-static bool consumeRadii(CSSPrimitiveValue* horizontalRadii[4], CSSPrimitiveValue* verticalRadii[4], CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
+static bool consumeRadii(CSSValue* horizontalRadii[4], CSSValue* verticalRadii[4], CSSParserTokenRange& range, CSSParserMode cssParserMode, bool useLegacyParsing)
 {
     unsigned i = 0;
     for (; i < 4 && !range.atEnd() && range.peek().type() != DelimiterToken; ++i) {
         horizontalRadii[i] = consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative);
         if (!horizontalRadii[i])
             return false;
     }
     if (!horizontalRadii[0])
         return false;
     if (range.atEnd()) {
@@ skipping 40 matching lines @@
     if (left)
         shape->updateShapeSize4Values(top, right, bottom, left);
     else if (bottom)
         shape->updateShapeSize3Values(top, right, bottom);
     else if (right)
         shape->updateShapeSize2Values(top, right);
     else
         shape->updateShapeSize1Value(top);
 
     if (consumeIdent<CSSValueRound>(args)) {
-        CSSPrimitiveValue* horizontalRadii[4] = { 0 };
-        CSSPrimitiveValue* verticalRadii[4] = { 0 };
+        CSSValue* horizontalRadii[4] = { 0 };
+        CSSValue* verticalRadii[4] = { 0 };
         if (!consumeRadii(horizontalRadii, verticalRadii, args, context.mode(), false))
             return nullptr;
         shape->setTopLeftRadius(CSSValuePair::create(horizontalRadii[0], verticalRadii[0], CSSValuePair::DropIdenticalValues));
         shape->setTopRightRadius(CSSValuePair::create(horizontalRadii[1], verticalRadii[1], CSSValuePair::DropIdenticalValues));
         shape->setBottomRightRadius(CSSValuePair::create(horizontalRadii[2], verticalRadii[2], CSSValuePair::DropIdenticalValues));
         shape->setBottomLeftRadius(CSSValuePair::create(horizontalRadii[3], verticalRadii[3], CSSValuePair::DropIdenticalValues));
     }
     return shape;
 }
 
@@ skipping 79 matching lines @@
     if (position == CSSValueInvalid && distribution == CSSValueInvalid)
         return nullptr;
 
     // The grammar states that <overflow-position> must be associated to <content-position>.
     if (overflow != CSSValueInvalid && position == CSSValueInvalid)
         return nullptr;
 
     return CSSContentDistributionValue::create(distribution, position, overflow);
 }
 
-static CSSPrimitiveValue* consumeBorderImageRepeatKeyword(CSSParserTokenRange& range)
+static CSSIdentifierValue* consumeBorderImageRepeatKeyword(CSSParserTokenRange& range)
 {
     return consumeIdent<CSSValueStretch, CSSValueRepeat, CSSValueSpace, CSSValueRound>(range);
 }
 
 static CSSValue* consumeBorderImageRepeat(CSSParserTokenRange& range)
 {
-    CSSPrimitiveValue* horizontal = consumeBorderImageRepeatKeyword(range);
+    CSSIdentifierValue* horizontal = consumeBorderImageRepeatKeyword(range);
     if (!horizontal)
         return nullptr;
-    CSSPrimitiveValue* vertical = consumeBorderImageRepeatKeyword(range);
+    CSSIdentifierValue* vertical = consumeBorderImageRepeatKeyword(range);
     if (!vertical)
         vertical = horizontal;
     return CSSValuePair::create(horizontal, vertical, CSSValuePair::DropIdenticalValues);
 }
 
 static CSSValue* consumeBorderImageSlice(CSSPropertyID property, CSSParserTokenRange& range)
 {
     bool fill = consumeIdent<CSSValueFill>(range);
-    CSSPrimitiveValue* slices[4] = { 0 };
+    CSSValue* slices[4] = { 0 };
 
     for (size_t index = 0; index < 4; ++index) {
         CSSPrimitiveValue* value = consumePercent(range, ValueRangeNonNegative);
         if (!value)
             value = consumeNumber(range, ValueRangeNonNegative);
         if (!value)
             break;
         slices[index] = value;
     }
     if (!slices[0])
         return nullptr;
     if (consumeIdent<CSSValueFill>(range)) {
         if (fill)
             return nullptr;
         fill = true;
     }
     complete4Sides(slices);
     // FIXME: For backwards compatibility, -webkit-border-image, -webkit-mask-box-image and -webkit-box-reflect have to do a fill by default.
     // FIXME: What do we do with -webkit-box-reflect and -webkit-mask-box-image? Probably just have to leave them filling...
     if (property == CSSPropertyWebkitBorderImage || property == CSSPropertyWebkitMaskBoxImage || property == CSSPropertyWebkitBoxReflect)
         fill = true;
     return CSSBorderImageSliceValue::create(CSSQuadValue::create(slices[0], slices[1], slices[2], slices[3], CSSQuadValue::SerializeAsQuad), fill);
 }
 
 static CSSValue* consumeBorderImageOutset(CSSParserTokenRange& range)
 {
-    CSSPrimitiveValue* outsets[4] = { 0 };
+    CSSValue* outsets[4] = { 0 };
 
-    CSSPrimitiveValue* value = nullptr;
+    CSSValue* value = nullptr;
     for (size_t index = 0; index < 4; ++index) {
         value = consumeNumber(range, ValueRangeNonNegative);
         if (!value)
             value = consumeLength(range, HTMLStandardMode, ValueRangeNonNegative);
         if (!value)
             break;
         outsets[index] = value;
     }
     if (!outsets[0])
         return nullptr;
     complete4Sides(outsets);
     return CSSQuadValue::create(outsets[0], outsets[1], outsets[2], outsets[3], CSSQuadValue::SerializeAsQuad);
 }
 
 static CSSValue* consumeBorderImageWidth(CSSParserTokenRange& range)
 {
-    CSSPrimitiveValue* widths[4] = { 0 };
+    CSSValue* widths[4] = { 0 };
 
-    CSSPrimitiveValue* value = nullptr;
+    CSSValue* value = nullptr;
     for (size_t index = 0; index < 4; ++index) {
         value = consumeNumber(range, ValueRangeNonNegative);
         if (!value)
             value = consumeLengthOrPercent(range, HTMLStandardMode, ValueRangeNonNegative, UnitlessQuirk::Forbid);
         if (!value)
             value = consumeIdent<CSSValueAuto>(range);
         if (!value)
             break;
         widths[index] = value;
     }
@@ skipping 48 matching lines @@
     CSSValue* width = nullptr;
     CSSValue* outset = nullptr;
     CSSValue* repeat = nullptr;
     if (consumeBorderImageComponents(property, range, context, source, slice, width, outset, repeat))
         return createBorderImageValue(source, slice, width, outset, repeat);
     return nullptr;
 }
 
 static CSSValue* consumeReflect(CSSParserTokenRange& range, const CSSParserContext& context)
 {
-    CSSPrimitiveValue* direction = consumeIdent<CSSValueAbove, CSSValueBelow, CSSValueLeft, CSSValueRight>(range);
+    CSSIdentifierValue* direction = consumeIdent<CSSValueAbove, CSSValueBelow, CSSValueLeft, CSSValueRight>(range);
     if (!direction)
         return nullptr;
 
     CSSPrimitiveValue* offset = nullptr;
     if (range.atEnd()) {
         offset = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Pixels);
     } else {
         offset = consumeLengthOrPercent(range, context.mode(), ValueRangeAll, UnitlessQuirk::Forbid);
         if (!offset)
             return nullptr;
@@ skipping 64 matching lines @@
     if ((property == CSSPropertyWebkitBackgroundClip || property == CSSPropertyWebkitMaskClip) && range.peek().id() == CSSValueText)
         return consumeIdent(range);
     return nullptr;
 }
 
 static CSSValue* consumeBackgroundSize(CSSPropertyID unresolvedProperty, CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     if (identMatches<CSSValueContain, CSSValueCover>(range.peek().id()))
         return consumeIdent(range);
 
-    CSSPrimitiveValue* horizontal = consumeIdent<CSSValueAuto>(range);
+    CSSValue* horizontal = consumeIdent<CSSValueAuto>(range);
     if (!horizontal)
         horizontal = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Forbid);
 
-    CSSPrimitiveValue* vertical = nullptr;
+    CSSValue* vertical = nullptr;
     if (!range.atEnd()) {
         if (range.peek().id() == CSSValueAuto) // `auto' is the default
             range.consumeIncludingWhitespace();
         else
             vertical = consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, UnitlessQuirk::Forbid);
     } else if (unresolvedProperty == CSSPropertyAliasWebkitBackgroundSize) {
         // Legacy syntax: "-webkit-background-size: 10px" is equivalent to "background-size: 10px 10px".
         vertical = horizontal;
     }
     if (!vertical)
         return horizontal;
     return CSSValuePair::create(horizontal, vertical, CSSValuePair::KeepIdenticalValues);
 }
 
 static CSSValueList* consumeGridAutoFlow(CSSParserTokenRange& range)
 {
-    CSSPrimitiveValue* rowOrColumnValue = consumeIdent<CSSValueRow, CSSValueColumn>(range);
-    CSSPrimitiveValue* denseAlgorithm = consumeIdent<CSSValueDense>(range);
+    CSSIdentifierValue* rowOrColumnValue = consumeIdent<CSSValueRow, CSSValueColumn>(range);
+    CSSIdentifierValue* denseAlgorithm = consumeIdent<CSSValueDense>(range);
     if (!rowOrColumnValue) {
         rowOrColumnValue = consumeIdent<CSSValueRow, CSSValueColumn>(range);
         if (!rowOrColumnValue && !denseAlgorithm)
             return nullptr;
     }
     CSSValueList* parsedValues = CSSValueList::createSpaceSeparated();
     if (rowOrColumnValue)
         parsedValues->append(*rowOrColumnValue);
     if (denseAlgorithm)
         parsedValues->append(*denseAlgorithm);
@@ skipping 61 matching lines @@
     CSSValue* result = nullptr;
     do {
         CSSValue* value = consumeBackgroundComponent(unresolvedProperty, range, context);
         if (!value)
             return nullptr;
         addBackgroundValue(result, value);
     } while (consumeCommaIncludingWhitespace(range));
     return result;
 }
 
-static CSSPrimitiveValue* consumeSelfPositionKeyword(CSSParserTokenRange& range)
+static CSSIdentifierValue* consumeSelfPositionKeyword(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter
         || id == CSSValueSelfStart || id == CSSValueSelfEnd || id == CSSValueFlexStart
         || id == CSSValueFlexEnd || id == CSSValueLeft || id == CSSValueRight)
         return consumeIdent(range);
     return nullptr;
 }
 
 static CSSValue* consumeSelfPositionOverflowPosition(CSSParserTokenRange& range)
 {
     if (identMatches<CSSValueAuto, CSSValueNormal, CSSValueStretch, CSSValueBaseline, CSSValueLastBaseline>(range.peek().id()))
         return consumeIdent(range);
 
-    CSSPrimitiveValue* overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
-    CSSPrimitiveValue* selfPosition = consumeSelfPositionKeyword(range);
+    CSSIdentifierValue* overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
+    CSSIdentifierValue* selfPosition = consumeSelfPositionKeyword(range);
     if (!selfPosition)
         return nullptr;
     if (!overflowPosition)
         overflowPosition = consumeIdent<CSSValueUnsafe, CSSValueSafe>(range);
     if (overflowPosition)
         return CSSValuePair::create(selfPosition, overflowPosition, CSSValuePair::DropIdenticalValues);
     return selfPosition;
 }
 
 static CSSValue* consumeAlignItems(CSSParserTokenRange& range)
 {
     // align-items property does not allow the 'auto' value.
     if (identMatches<CSSValueAuto>(range.peek().id()))
         return nullptr;
     return consumeSelfPositionOverflowPosition(range);
 }
 
 static CSSValue* consumeJustifyItems(CSSParserTokenRange& range)
 {
     CSSParserTokenRange rangeCopy = range;
-    CSSPrimitiveValue* legacy = consumeIdent<CSSValueLegacy>(rangeCopy);
-    CSSPrimitiveValue* positionKeyword = consumeIdent<CSSValueCenter, CSSValueLeft, CSSValueRight>(rangeCopy);
+    CSSIdentifierValue* legacy = consumeIdent<CSSValueLegacy>(rangeCopy);
+    CSSIdentifierValue* positionKeyword = consumeIdent<CSSValueCenter, CSSValueLeft, CSSValueRight>(rangeCopy);
     if (!legacy)
         legacy = consumeIdent<CSSValueLegacy>(rangeCopy);
     if (legacy && positionKeyword) {
         range = rangeCopy;
         return CSSValuePair::create(legacy, positionKeyword, CSSValuePair::DropIdenticalValues);
     }
     return consumeSelfPositionOverflowPosition(range);
 }
 
 static CSSValue* consumeFitContent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
@@ skipping 14 matching lines @@
     if (range.peek().id() == CSSValueAuto || range.peek().id() == CSSValueSpan)
         return nullptr;
     return consumeCustomIdent(range);
 }
 
 static CSSValue* consumeGridLine(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
 
-    CSSPrimitiveValue* spanValue = nullptr;
+    CSSIdentifierValue* spanValue = nullptr;
     CSSCustomIdentValue* gridLineName = nullptr;
     CSSPrimitiveValue* numericValue = consumeInteger(range);
     if (numericValue) {
         gridLineName = consumeCustomIdentForGridLine(range);
         spanValue = consumeIdent<CSSValueSpan>(range);
     } else {
         spanValue = consumeIdent<CSSValueSpan>(range);
         if (spanValue) {
             numericValue = consumeInteger(range);
             gridLineName = consumeCustomIdentForGridLine(range);
@@ skipping 23 matching lines @@
     if (spanValue)
         values->append(*spanValue);
     if (numericValue)
         values->append(*numericValue);
     if (gridLineName)
         values->append(*gridLineName);
     ASSERT(values->length());
     return values;
 }
 
-static bool isGridTrackFixedSized(const CSSPrimitiveValue& primitiveValue)
+static bool isGridBreadthFixedSized(const CSSValue& value)
 {
-    CSSValueID valueID = primitiveValue.getValueID();
-    if (valueID == CSSValueMinContent || valueID == CSSValueMaxContent || valueID == CSSValueAuto || primitiveValue.isFlex())
-        return false;
+    if (value.isIdentifierValue()) {
+        CSSValueID valueID = toCSSIdentifierValue(value).getValueID();
+        return !(valueID == CSSValueMinContent || valueID == CSSValueMaxContent || valueID == CSSValueAuto);
+    }
 
+    if (value.isPrimitiveValue()) {
+        return !toCSSPrimitiveValue(value).isFlex();
+    }
+
+    NOTREACHED();
     return true;
 }
 
 static bool isGridTrackFixedSized(const CSSValue& value)
 {
-    if (value.isPrimitiveValue())
-        return isGridTrackFixedSized(toCSSPrimitiveValue(value));
+    if (value.isPrimitiveValue() || value.isIdentifierValue())
+        return isGridBreadthFixedSized(value);
 
     DCHECK(value.isFunctionValue());
     auto& function = toCSSFunctionValue(value);
     if (function.functionType() == CSSValueFitContent)
         return false;
 
-    const CSSPrimitiveValue& minPrimitiveValue = toCSSPrimitiveValue(function.item(0));
-    const CSSPrimitiveValue& maxPrimitiveValue = toCSSPrimitiveValue(function.item(1));
-    return isGridTrackFixedSized(minPrimitiveValue) || isGridTrackFixedSized(maxPrimitiveValue);
+    const CSSValue& minValue = function.item(0);
+    const CSSValue& maxValue = function.item(1);
+    return isGridBreadthFixedSized(minValue) || isGridBreadthFixedSized(maxValue);
 }
 
 static Vector<String> parseGridTemplateAreasColumnNames(const String& gridRowNames)
 {
     ASSERT(!gridRowNames.isEmpty());
     Vector<String> columnNames;
     // Using StringImpl to avoid checks and indirection in every call to String::operator[].
     StringImpl& text = *gridRowNames.impl();
 
     StringBuilder areaName;
@@ skipping 76 matching lines @@
                 return false;
 
             gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.startLine(), gridArea.rows.endLine() + 1);
         }
         currentColumn = lookAheadColumn - 1;
     }
 
     return true;
 }
 
-static CSSPrimitiveValue* consumeGridBreadth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
+static CSSValue* consumeGridBreadth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     const CSSParserToken& token = range.peek();
     if (identMatches<CSSValueMinContent, CSSValueMaxContent, CSSValueAuto>(token.id()))
         return consumeIdent(range);
     if (token.type() == DimensionToken && token.unitType() == CSSPrimitiveValue::UnitType::Fraction) {
         if (range.peek().numericValue() < 0)
             return nullptr;
         return CSSPrimitiveValue::create(range.consumeIncludingWhitespace().numericValue(), CSSPrimitiveValue::UnitType::Fraction);
     }
     return consumeLengthOrPercent(range, cssParserMode, ValueRangeNonNegative, UnitlessQuirk::Allow);
 }
 
 static CSSValue* consumeGridTrackSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     const CSSParserToken& token = range.peek();
     if (identMatches<CSSValueAuto>(token.id()))
         return consumeIdent(range);
 
     if (token.functionId() == CSSValueMinmax) {
         CSSParserTokenRange rangeCopy = range;
         CSSParserTokenRange args = consumeFunction(rangeCopy);
-        CSSPrimitiveValue* minTrackBreadth = consumeGridBreadth(args, cssParserMode);
-        if (!minTrackBreadth || minTrackBreadth->isFlex() || !consumeCommaIncludingWhitespace(args))
+        CSSValue* minTrackBreadth = consumeGridBreadth(args, cssParserMode);
+        if (!minTrackBreadth || (minTrackBreadth->isPrimitiveValue() && toCSSPrimitiveValue(minTrackBreadth)->isFlex()) || !consumeCommaIncludingWhitespace(args))
             return nullptr;
-        CSSPrimitiveValue* maxTrackBreadth = consumeGridBreadth(args, cssParserMode);
+        CSSValue* maxTrackBreadth = consumeGridBreadth(args, cssParserMode);
         if (!maxTrackBreadth || !args.atEnd())
             return nullptr;
         range = rangeCopy;
         CSSFunctionValue* result = CSSFunctionValue::create(CSSValueMinmax);
         result->append(*minTrackBreadth);
         result->append(*maxTrackBreadth);
         return result;
     }
 
     if (token.functionId() == CSSValueFitContent)
@@ skipping 571 matching lines @@
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return consumeGridTemplateAreas(m_range);
     case CSSPropertyGridAutoFlow:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return consumeGridAutoFlow(m_range);
     default:
         return nullptr;
     }
 }
 
-static CSSPrimitiveValue* consumeFontDisplay(CSSParserTokenRange& range)
+static CSSIdentifierValue* consumeFontDisplay(CSSParserTokenRange& range)
 {
     return consumeIdent<CSSValueAuto, CSSValueBlock, CSSValueSwap, CSSValueFallback, CSSValueOptional>(range);
 }
 
 static CSSValueList* consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
 {
     CSSValueList* values = CSSValueList::createCommaSeparated();
 
     do {
         const CSSParserToken& token = range.consumeIncludingWhitespace();
@@ skipping 84 matching lines @@
         parsedValue = consumeFontFaceUnicodeRange(m_range);
         break;
     case CSSPropertyFontDisplay:
         parsedValue = consumeFontDisplay(m_range);
         break;
     case CSSPropertyFontStretch:
     case CSSPropertyFontStyle: {
         CSSValueID id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id, m_context.mode()))
             return false;
-        parsedValue = CSSPrimitiveValue::createIdentifier(id);
+        parsedValue = CSSIdentifierValue::create(id);
         break;
     }
     case CSSPropertyFontVariant:
         parsedValue = consumeFontVariantList(m_range);
         break;
     case CSSPropertyFontWeight:
         parsedValue = consumeFontWeight(m_range);
         break;
     case CSSPropertyFontFeatureSettings:
         parsedValue = consumeFontFeatureSettings(m_range);
@@ skipping 15 matching lines @@
     ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar);
     if (!m_range.atEnd())
         return false;
 
     FontStyle fontStyle = FontStyleNormal;
     FontWeight fontWeight = FontWeightNormal;
     float fontSize = 0;
     AtomicString fontFamily;
     LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize, fontFamily);
 
-    addProperty(CSSPropertyFontStyle, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
-    addProperty(CSSPropertyFontWeight, CSSPropertyFont, *CSSPrimitiveValue::create(fontWeight), important);
+    addProperty(CSSPropertyFontStyle, CSSPropertyFont, *CSSIdentifierValue::create(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
+    addProperty(CSSPropertyFontWeight, CSSPropertyFont, *CSSIdentifierValue::create(fontWeight), important);
     addProperty(CSSPropertyFontSize, CSSPropertyFont, *CSSPrimitiveValue::create(fontSize, CSSPrimitiveValue::UnitType::Pixels), important);
     CSSValueList* fontFamilyList = CSSValueList::createCommaSeparated();
     fontFamilyList->append(*CSSFontFamilyValue::create(fontFamily));
     addProperty(CSSPropertyFontFamily, CSSPropertyFont, *fontFamilyList, important);
 
-    addProperty(CSSPropertyFontStretch, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyLineHeight, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
+    addProperty(CSSPropertyFontStretch, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyLineHeight, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
     return true;
 }
 
 bool CSSPropertyParser::consumeFont(bool important)
 {
     // Let's check if there is an inherit or initial somewhere in the shorthand.
     CSSParserTokenRange range = m_range;
     while (!range.atEnd()) {
         CSSValueID id = range.consumeIncludingWhitespace().id();
         if (id == CSSValueInherit || id == CSSValueInitial)
             return false;
     }
     // Optional font-style, font-variant, font-stretch and font-weight.
-    CSSPrimitiveValue* fontStyle = nullptr;
-    CSSPrimitiveValue* fontVariantCaps = nullptr;
-    CSSPrimitiveValue* fontWeight = nullptr;
-    CSSPrimitiveValue* fontStretch = nullptr;
+    CSSIdentifierValue* fontStyle = nullptr;
+    CSSIdentifierValue* fontVariantCaps = nullptr;
+    CSSIdentifierValue* fontWeight = nullptr;
+    CSSIdentifierValue* fontStretch = nullptr;
     while (!m_range.atEnd()) {
         CSSValueID id = m_range.peek().id();
         if (!fontStyle && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStyle, id, m_context.mode())) {
             fontStyle = consumeIdent(m_range);
             continue;
         }
         if (!fontVariantCaps && (id == CSSValueNormal || id == CSSValueSmallCaps)) {
             // Font variant in the shorthand is particular, it only accepts normal or small-caps.
             // See https://drafts.csswg.org/css-fonts/#propdef-font
             fontVariantCaps = consumeFontVariantCSS21(m_range);
             if (fontVariantCaps)
                 continue;
         }
         if (!fontWeight) {
             fontWeight = consumeFontWeight(m_range);
             if (fontWeight)
                 continue;
         }
         if (!fontStretch && CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyFontStretch, id, m_context.mode()))
             fontStretch = consumeIdent(m_range);
         else
             break;
     }
 
     if (m_range.atEnd())
         return false;
 
-    addProperty(CSSPropertyFontStyle, CSSPropertyFont, fontStyle ? *fontStyle : *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, fontVariantCaps ? *fontVariantCaps : *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
+    addProperty(CSSPropertyFontStyle, CSSPropertyFont, fontStyle ? *fontStyle : *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFont, fontVariantCaps ? *fontVariantCaps : *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
 
-    addProperty(CSSPropertyFontWeight, CSSPropertyFont, fontWeight ? *fontWeight : *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
-    addProperty(CSSPropertyFontStretch, CSSPropertyFont, fontStretch ? *fontStretch : *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
+    addProperty(CSSPropertyFontWeight, CSSPropertyFont, fontWeight ? *fontWeight : *CSSIdentifierValue::create(CSSValueNormal), important);
+    addProperty(CSSPropertyFontStretch, CSSPropertyFont, fontStretch ? *fontStretch : *CSSIdentifierValue::create(CSSValueNormal), important);
 
     // Now a font size _must_ come.
     CSSValue* fontSize = consumeFontSize(m_range, m_context.mode());
     if (!fontSize || m_range.atEnd())
         return false;
 
     addProperty(CSSPropertyFontSize, CSSPropertyFont, *fontSize, important);
 
     if (consumeSlashIncludingWhitespace(m_range)) {
-        CSSPrimitiveValue* lineHeight = consumeLineHeight(m_range, m_context.mode());
+        CSSValue* lineHeight = consumeLineHeight(m_range, m_context.mode());
         if (!lineHeight)
             return false;
         addProperty(CSSPropertyLineHeight, CSSPropertyFont, *lineHeight, important);
     } else {
-        addProperty(CSSPropertyLineHeight, CSSPropertyFont, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
+        addProperty(CSSPropertyLineHeight, CSSPropertyFont, *CSSIdentifierValue::create(CSSValueNormal), important);
     }
 
     // Font family must come now.
     CSSValue* parsedFamilyValue = consumeFontFamily(m_range);
     if (!parsedFamilyValue)
         return false;
 
     addProperty(CSSPropertyFontFamily, CSSPropertyFont, *parsedFamilyValue, important);
 
     // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20110324/#font-prop requires that
     // "font-stretch", "font-size-adjust", and "font-kerning" be reset to their initial values
     // but we don't seem to support them at the moment. They should also be added here once implemented.
     return m_range.atEnd();
 }
 
 bool CSSPropertyParser::consumeFontVariantShorthand(bool important)
 {
     if (identMatches<CSSValueNormal, CSSValueNone>(m_range.peek().id())) {
         addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFontVariant, *consumeIdent(m_range), important);
-        addProperty(CSSPropertyFontVariantCaps, CSSPropertyFontVariant, *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
+        addProperty(CSSPropertyFontVariantCaps, CSSPropertyFontVariant, *CSSIdentifierValue::create(CSSValueNormal), important);
         return m_range.atEnd();
     }
 
-    CSSPrimitiveValue* capsValue = nullptr;
+    CSSIdentifierValue* capsValue = nullptr;
     FontVariantLigaturesParser ligaturesParser;
     FontVariantNumericParser numericParser;
     do {
         FontVariantLigaturesParser::ParseResult ligaturesParseResult = ligaturesParser.consumeLigature(m_range);
         FontVariantNumericParser::ParseResult numericParseResult = numericParser.consumeNumeric(m_range);
         if (ligaturesParseResult == FontVariantLigaturesParser::ParseResult::ConsumedValue
             || numericParseResult == FontVariantNumericParser::ParseResult::ConsumedValue)
             continue;
 
         if (ligaturesParseResult == FontVariantLigaturesParser::ParseResult::DisallowedValue
@@ skipping 13 matching lines @@
                 return false;
             capsValue = consumeIdent(m_range);
             break;
         default:
             return false;
         }
     } while (!m_range.atEnd());
 
     addProperty(CSSPropertyFontVariantLigatures, CSSPropertyFontVariant, *ligaturesParser.finalizeValue(), important);
     addProperty(CSSPropertyFontVariantNumeric, CSSPropertyFontVariant, *numericParser.finalizeValue(), important);
-    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFontVariant, capsValue ? *capsValue : *CSSPrimitiveValue::createIdentifier(CSSValueNormal), important);
+    addProperty(CSSPropertyFontVariantCaps, CSSPropertyFontVariant, capsValue ? *capsValue : *CSSIdentifierValue::create(CSSValueNormal), important);
     return true;
 }
 
 bool CSSPropertyParser::consumeBorderSpacing(bool important)
 {
     CSSValue* horizontalSpacing = consumeLength(m_range, m_context.mode(), ValueRangeNonNegative, UnitlessQuirk::Allow);
     if (!horizontalSpacing)
         return false;
     CSSValue* verticalSpacing = horizontalSpacing;
     if (!m_range.atEnd())
@@ skipping 109 matching lines @@
 bool CSSPropertyParser::consumeColumns(bool important)
 {
     CSSValue* columnWidth = nullptr;
     CSSValue* columnCount = nullptr;
     if (!consumeColumnWidthOrCount(m_range, columnWidth, columnCount))
         return false;
     consumeColumnWidthOrCount(m_range, columnWidth, columnCount);
     if (!m_range.atEnd())
         return false;
     if (!columnWidth)
-        columnWidth = CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        columnWidth = CSSIdentifierValue::create(CSSValueAuto);
     if (!columnCount)
-        columnCount = CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        columnCount = CSSIdentifierValue::create(CSSValueAuto);
     addProperty(CSSPropertyColumnWidth, CSSPropertyInvalid, *columnWidth, important);
     addProperty(CSSPropertyColumnCount, CSSPropertyInvalid, *columnCount, important);
     return true;
 }
 
 bool CSSPropertyParser::consumeShorthandGreedily(const StylePropertyShorthand& shorthand, bool important)
 {
     ASSERT(shorthand.length() <= 6); // Existing shorthands have at most 6 longhands.
     const CSSValue* longhands[6] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
     const CSSPropertyID* shorthandProperties = shorthand.properties();
@@ skipping 17 matching lines @@
             addProperty(shorthandProperties[i], shorthand.id(), *CSSInitialValue::createLegacyImplicit(), important);
     }
     return true;
 }
 
 bool CSSPropertyParser::consumeFlex(bool important)
 {
     static const double unsetValue = -1;
     double flexGrow = unsetValue;
     double flexShrink = unsetValue;
-    CSSPrimitiveValue* flexBasis = nullptr;
+    CSSValue* flexBasis = nullptr;
 
     if (m_range.peek().id() == CSSValueNone) {
         flexGrow = 0;
         flexShrink = 0;
-        flexBasis = CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        flexBasis = CSSIdentifierValue::create(CSSValueAuto);
         m_range.consumeIncludingWhitespace();
     } else {
         unsigned index = 0;
         while (!m_range.atEnd() && index++ < 3) {
             double num;
             if (consumeNumberRaw(m_range, num)) {
                 if (num < 0)
                     return false;
                 if (flexGrow == unsetValue)
                     flexGrow = num;
@@ skipping 169 matching lines @@
         return CSSPropertyBreakBefore;
     ASSERT(property == CSSPropertyPageBreakInside || property == CSSPropertyWebkitColumnBreakInside);
     return CSSPropertyBreakInside;
 }
 
 bool CSSPropertyParser::consumeLegacyBreakProperty(CSSPropertyID property, bool important)
 {
     // The fragmentation spec says that page-break-(after|before|inside) are to be treated as
     // shorthands for their break-(after|before|inside) counterparts. We'll do the same for the
     // non-standard properties -webkit-column-break-(after|before|inside).
-    CSSPrimitiveValue* keyword = consumeIdent(m_range);
+    CSSIdentifierValue* keyword = consumeIdent(m_range);
     if (!keyword)
         return false;
     if (!m_range.atEnd())
         return false;
     CSSValueID value = keyword->getValueID();
     switch (property) {
     case CSSPropertyPageBreakAfter:
     case CSSPropertyPageBreakBefore:
         value = mapFromPageBreakBetween(value);
         break;
     case CSSPropertyWebkitColumnBreakAfter:
     case CSSPropertyWebkitColumnBreakBefore:
         value = mapFromColumnBreakBetween(value);
         break;
     case CSSPropertyPageBreakInside:
     case CSSPropertyWebkitColumnBreakInside:
         value = mapFromColumnOrPageBreakInside(value);
         break;
     default:
         ASSERT_NOT_REACHED();
     }
     if (value == CSSValueInvalid)
         return false;
 
     CSSPropertyID genericBreakProperty = mapFromLegacyBreakProperty(property);
-    addProperty(genericBreakProperty, property, *CSSPrimitiveValue::createIdentifier(value), important);
+    addProperty(genericBreakProperty, property, *CSSIdentifierValue::create(value), important);
     return true;
 }
 
 static bool consumeBackgroundPosition(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless, CSSValue*& resultX, CSSValue*& resultY)
 {
     do {
         CSSValue* positionX = nullptr;
         CSSValue* positionY = nullptr;
         if (!consumePosition(range, context.mode(), unitless, positionX, positionY))
             return false;
         addBackgroundValue(resultX, positionX);
         addBackgroundValue(resultY, positionY);
     } while (consumeCommaIncludingWhitespace(range));
     return true;
 }
 
 static bool consumeRepeatStyleComponent(CSSParserTokenRange& range, CSSValue*& value1, CSSValue*& value2, bool& implicit)
 {
     if (consumeIdent<CSSValueRepeatX>(range)) {
-        value1 = CSSPrimitiveValue::createIdentifier(CSSValueRepeat);
-        value2 = CSSPrimitiveValue::createIdentifier(CSSValueNoRepeat);
+        value1 = CSSIdentifierValue::create(CSSValueRepeat);
+        value2 = CSSIdentifierValue::create(CSSValueNoRepeat);
         implicit = true;
         return true;
     }
     if (consumeIdent<CSSValueRepeatY>(range)) {
-        value1 = CSSPrimitiveValue::createIdentifier(CSSValueNoRepeat);
-        value2 = CSSPrimitiveValue::createIdentifier(CSSValueRepeat);
+        value1 = CSSIdentifierValue::create(CSSValueNoRepeat);
+        value2 = CSSIdentifierValue::create(CSSValueRepeat);
         implicit = true;
         return true;
     }
     value1 = consumeIdent<CSSValueRepeat, CSSValueNoRepeat, CSSValueRound, CSSValueSpace>(range);
     if (!value1)
         return false;
 
     value2 = consumeIdent<CSSValueRepeat, CSSValueNoRepeat, CSSValueRound, CSSValueSpace>(range);
     if (!value2) {
         value2 = value1;
@@ skipping 105 matching lines @@
     CSSValue* startValue = consumeGridLine(m_range);
     if (!startValue)
         return false;
 
     CSSValue* endValue = nullptr;
     if (consumeSlashIncludingWhitespace(m_range)) {
         endValue = consumeGridLine(m_range);
         if (!endValue)
             return false;
     } else {
-        endValue = startValue->isCustomIdentValue() ? startValue : CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        endValue = startValue->isCustomIdentValue() ? startValue : CSSIdentifierValue::create(CSSValueAuto);
     }
     if (!m_range.atEnd())
         return false;
     addProperty(shorthand.properties()[0], shorthandId, *startValue, important);
     addProperty(shorthand.properties()[1], shorthandId, *endValue, important);
     return true;
 }
 
 bool CSSPropertyParser::consumeGridAreaShorthand(bool important)
 {
@@ skipping 16 matching lines @@
             if (consumeSlashIncludingWhitespace(m_range)) {
                 columnEndValue = consumeGridLine(m_range);
                 if (!columnEndValue)
                     return false;
             }
         }
     }
     if (!m_range.atEnd())
         return false;
     if (!columnStartValue)
-        columnStartValue = rowStartValue->isCustomIdentValue() ? rowStartValue : CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        columnStartValue = rowStartValue->isCustomIdentValue() ? rowStartValue : CSSIdentifierValue::create(CSSValueAuto);
     if (!rowEndValue)
-        rowEndValue = rowStartValue->isCustomIdentValue() ? rowStartValue : CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        rowEndValue = rowStartValue->isCustomIdentValue() ? rowStartValue : CSSIdentifierValue::create(CSSValueAuto);
     if (!columnEndValue)
-        columnEndValue = columnStartValue->isCustomIdentValue() ? columnStartValue : CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        columnEndValue = columnStartValue->isCustomIdentValue() ? columnStartValue : CSSIdentifierValue::create(CSSValueAuto);
 
     addProperty(CSSPropertyGridRowStart, CSSPropertyGridArea, *rowStartValue, important);
     addProperty(CSSPropertyGridColumnStart, CSSPropertyGridArea, *columnStartValue, important);
     addProperty(CSSPropertyGridRowEnd, CSSPropertyGridArea, *rowEndValue, important);
     addProperty(CSSPropertyGridColumnEnd, CSSPropertyGridArea, *columnEndValue, important);
     return true;
 }
 
 bool CSSPropertyParser::consumeGridTemplateRowsAndAreasAndColumns(CSSPropertyID shorthandId, bool important)
 {
@@ skipping 14 matching lines @@
             templateRows->append(*lineNames);
 
         // Handle a template-area's row.
         if (m_range.peek().type() != StringToken || !parseGridTemplateAreasRow(m_range.consumeIncludingWhitespace().value().toString(), gridAreaMap, rowCount, columnCount))
             return false;
         ++rowCount;
 
         // Handle template-rows's track-size.
         CSSValue* value = consumeGridTrackSize(m_range, m_context.mode());
         if (!value)
-            value = CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            value = CSSIdentifierValue::create(CSSValueAuto);
         templateRows->append(*value);
 
         // This will handle the trailing/leading <custom-ident>* in the grammar.
         lineNames = consumeGridLineNames(m_range);
         if (lineNames)
             templateRows->append(*lineNames);
     } while (!m_range.atEnd() && !(m_range.peek().type() == DelimiterToken && m_range.peek().delimiter() == '/'));
 
     CSSValue* columnsValue = nullptr;
     if (!m_range.atEnd()) {
         if (!consumeSlashIncludingWhitespace(m_range))
             return false;
         columnsValue = consumeGridTrackList(m_range, m_context.mode(), GridTemplateNoRepeat);
         if (!columnsValue || !m_range.atEnd())
             return false;
     } else {
-        columnsValue = CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        columnsValue = CSSIdentifierValue::create(CSSValueNone);
     }
     addProperty(CSSPropertyGridTemplateRows, shorthandId, *templateRows, important);
     addProperty(CSSPropertyGridTemplateColumns, shorthandId, *columnsValue, important);
     addProperty(CSSPropertyGridTemplateAreas, shorthandId, *CSSGridTemplateAreasValue::create(gridAreaMap, rowCount, columnCount), important);
     return true;
 }
 
 bool CSSPropertyParser::consumeGridTemplateShorthand(CSSPropertyID shorthandId, bool important)
 {
     ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
     ASSERT(gridTemplateShorthand().length() == 3);
 
     CSSParserTokenRange rangeCopy = m_range;
     CSSValue* rowsValue = consumeIdent<CSSValueNone>(m_range);
 
     // 1- 'none' case.
     if (rowsValue && m_range.atEnd()) {
-        addProperty(CSSPropertyGridTemplateRows, shorthandId, *CSSPrimitiveValue::createIdentifier(CSSValueNone), important);
-        addProperty(CSSPropertyGridTemplateColumns, shorthandId, *CSSPrimitiveValue::createIdentifier(CSSValueNone), important);
-        addProperty(CSSPropertyGridTemplateAreas, shorthandId, *CSSPrimitiveValue::createIdentifier(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateRows, shorthandId, *CSSIdentifierValue::create(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateColumns, shorthandId, *CSSIdentifierValue::create(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateAreas, shorthandId, *CSSIdentifierValue::create(CSSValueNone), important);
         return true;
     }
 
     // 2- <grid-template-rows> / <grid-template-columns>
     if (!rowsValue)
         rowsValue = consumeGridTrackList(m_range, m_context.mode(), GridTemplate);
 
     if (rowsValue) {
         if (!consumeSlashIncludingWhitespace(m_range))
             return false;
         CSSValue* columnsValue = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode());
         if (!columnsValue || !m_range.atEnd())
             return false;
 
         addProperty(CSSPropertyGridTemplateRows, shorthandId, *rowsValue, important);
         addProperty(CSSPropertyGridTemplateColumns, shorthandId, *columnsValue, important);
-        addProperty(CSSPropertyGridTemplateAreas, shorthandId, *CSSPrimitiveValue::createIdentifier(CSSValueNone), important);
+        addProperty(CSSPropertyGridTemplateAreas, shorthandId, *CSSIdentifierValue::create(CSSValueNone), important);
         return true;
     }
 
     // 3- [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <track-list> ]?
     m_range = rangeCopy;
     return consumeGridTemplateRowsAndAreasAndColumns(shorthandId, important);
 }
 
 static CSSValueList* consumeImplicitAutoFlow(CSSParserTokenRange& range, const CSSValue& flowDirection)
 {
@@ skipping 36 matching lines @@
 
     m_range = rangeCopy;
 
     CSSValue* autoColumnsValue = nullptr;
     CSSValue* autoRowsValue = nullptr;
     CSSValue* templateRows = nullptr;
     CSSValue* templateColumns = nullptr;
     CSSValueList* gridAutoFlow = nullptr;
     if (identMatches<CSSValueDense, CSSValueAutoFlow>(m_range.peek().id())) {
         // 2- [ auto-flow && dense? ] <grid-auto-rows>? / <grid-template-columns>
-        gridAutoFlow = consumeImplicitAutoFlow(m_range, *CSSPrimitiveValue::createIdentifier(CSSValueRow));
+        gridAutoFlow = consumeImplicitAutoFlow(m_range, *CSSIdentifierValue::create(CSSValueRow));
         if (!gridAutoFlow)
             return false;
         if (consumeSlashIncludingWhitespace(m_range)) {
             autoRowsValue = CSSInitialValue::createLegacyImplicit();
         } else {
             autoRowsValue = consumeGridTrackList(m_range, m_context.mode(), GridAuto);
             if (!autoRowsValue)
                 return false;
             if (!consumeSlashIncludingWhitespace(m_range))
                 return false;
         }
         if (!(templateColumns = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode())))
             return false;
         templateRows = CSSInitialValue::createLegacyImplicit();
         autoColumnsValue = CSSInitialValue::createLegacyImplicit();
     } else {
         // 3- <grid-template-rows> / [ auto-flow && dense? ] <grid-auto-columns>?
         templateRows = consumeGridTemplatesRowsOrColumns(m_range, m_context.mode());
         if (!templateRows)
             return false;
         if (!consumeSlashIncludingWhitespace(m_range))
             return false;
-        gridAutoFlow = consumeImplicitAutoFlow(m_range, *CSSPrimitiveValue::createIdentifier(CSSValueColumn));
+        gridAutoFlow = consumeImplicitAutoFlow(m_range, *CSSIdentifierValue::create(CSSValueColumn));
         if (!gridAutoFlow)
             return false;
         if (m_range.atEnd()) {
             autoColumnsValue = CSSInitialValue::createLegacyImplicit();
         } else {
             autoColumnsValue = consumeGridTrackList(m_range, m_context.mode(), GridAuto);
             if (!autoColumnsValue)
                 return false;
         }
         templateColumns = CSSInitialValue::createLegacyImplicit();
@@ skipping 18 matching lines @@
 
 bool CSSPropertyParser::parseShorthand(CSSPropertyID unresolvedProperty, bool important)
 {
     CSSPropertyID property = resolveCSSPropertyID(unresolvedProperty);
 
     switch (property) {
     case CSSPropertyWebkitMarginCollapse: {
         CSSValueID id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginBeforeCollapse, id, m_context.mode()))
             return false;
-        CSSValue* beforeCollapse = CSSPrimitiveValue::createIdentifier(id);
+        CSSValue* beforeCollapse = CSSIdentifierValue::create(id);
         addProperty(CSSPropertyWebkitMarginBeforeCollapse, CSSPropertyWebkitMarginCollapse, *beforeCollapse, important);
         if (m_range.atEnd()) {
             addProperty(CSSPropertyWebkitMarginAfterCollapse, CSSPropertyWebkitMarginCollapse, *beforeCollapse, important);
             return true;
         }
         id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyWebkitMarginAfterCollapse, id, m_context.mode()))
             return false;
-        addProperty(CSSPropertyWebkitMarginAfterCollapse, CSSPropertyWebkitMarginCollapse, *CSSPrimitiveValue::createIdentifier(id), important);
+        addProperty(CSSPropertyWebkitMarginAfterCollapse, CSSPropertyWebkitMarginCollapse, *CSSIdentifierValue::create(id), important);
         return true;
     }
     case CSSPropertyOverflow: {
         CSSValueID id = m_range.consumeIncludingWhitespace().id();
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(CSSPropertyOverflowY, id, m_context.mode()))
             return false;
         if (!m_range.atEnd())
             return false;
-        CSSValue* overflowYValue = CSSPrimitiveValue::createIdentifier(id);
+        CSSValue* overflowYValue = CSSIdentifierValue::create(id);
 
         CSSValue* overflowXValue = nullptr;
 
         // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If this value has been
         // set using the shorthand, then for now overflow-x will default to auto, but once we implement
         // pagination controls, it should default to hidden. If the overflow-y value is anything but
         // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
         if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
-            overflowXValue = CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            overflowXValue = CSSIdentifierValue::create(CSSValueAuto);
         else
             overflowXValue = overflowYValue;
         addProperty(CSSPropertyOverflowX, CSSPropertyOverflow, *overflowXValue, important);
         addProperty(CSSPropertyOverflowY, CSSPropertyOverflow, *overflowYValue, important);
         return true;
     }
     case CSSPropertyFont: {
         const CSSParserToken& token = m_range.peek();
         if (token.id() >= CSSValueCaption && token.id() <= CSSValueStatusBar)
             return consumeSystemFont(important);
@@ skipping 45 matching lines @@
     }
     case CSSPropertyFlex:
         return consumeFlex(important);
     case CSSPropertyFlexFlow:
         return consumeShorthandGreedily(flexFlowShorthand(), important);
     case CSSPropertyColumnRule:
         return consumeShorthandGreedily(columnRuleShorthand(), important);
     case CSSPropertyListStyle:
         return consumeShorthandGreedily(listStyleShorthand(), important);
     case CSSPropertyBorderRadius: {
-        CSSPrimitiveValue* horizontalRadii[4] = { 0 };
-        CSSPrimitiveValue* verticalRadii[4] = { 0 };
+        CSSValue* horizontalRadii[4] = { 0 };
+        CSSValue* verticalRadii[4] = { 0 };
         if (!consumeRadii(horizontalRadii, verticalRadii, m_range, m_context.mode(), unresolvedProperty == CSSPropertyAliasWebkitBorderRadius))
             return false;
         addProperty(CSSPropertyBorderTopLeftRadius, CSSPropertyBorderRadius, *CSSValuePair::create(horizontalRadii[0], verticalRadii[0], CSSValuePair::DropIdenticalValues), important);
         addProperty(CSSPropertyBorderTopRightRadius, CSSPropertyBorderRadius, *CSSValuePair::create(horizontalRadii[1], verticalRadii[1], CSSValuePair::DropIdenticalValues), important);
         addProperty(CSSPropertyBorderBottomRightRadius, CSSPropertyBorderRadius, *CSSValuePair::create(horizontalRadii[2], verticalRadii[2], CSSValuePair::DropIdenticalValues), important);
         addProperty(CSSPropertyBorderBottomLeftRadius, CSSPropertyBorderRadius, *CSSValuePair::create(horizontalRadii[3], verticalRadii[3], CSSValuePair::DropIdenticalValues), important);
         return true;
     }
     case CSSPropertyBorderColor:
         return consume4Values(borderColorShorthand(), important);
@@ skipping 66 matching lines @@
     case CSSPropertyGridTemplate:
         return consumeGridTemplateShorthand(CSSPropertyGridTemplate, important);
     case CSSPropertyGrid:
         return consumeGridShorthand(important);
     default:
         return false;
     }
 }
 
 } // namespace blink