Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 23 matching lines @@
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSCounterValue.h"
 #include "core/css/CSSCursorImageValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSFontFamilyValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSGridTemplateAreasValue.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSInitialValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValue.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"
 #include "core/css/CSSURIValue.h"
@@ skipping 17 matching lines @@
 inline static bool isFlexOrGrid(const ComputedStyle* style)
 {
     return style && style->isDisplayFlexibleOrGridBox();
 }
 
 inline static CSSPrimitiveValue* zoomAdjustedPixelValue(double value, const ComputedStyle& style)
 {
     return CSSPrimitiveValue::create(adjustFloatForAbsoluteZoom(value, style), CSSPrimitiveValue::UnitType::Pixels);
 }
 
+inline static CSSValue* zoomAdjustedPixelValueOrAuto(const Length& length, const ComputedStyle& style)
+{
+    if (length.isAuto())
+        return CSSIdentifierValue::createIdentifier(CSSValueAuto);
+    return zoomAdjustedPixelValue(length.value(), style);
+}
+
 inline static CSSPrimitiveValue* zoomAdjustedNumberValue(double value, const ComputedStyle& style)
 {
     return CSSPrimitiveValue::create(value / style.effectiveZoom(), CSSPrimitiveValue::UnitType::Number);
 }
 
-static CSSPrimitiveValue* zoomAdjustedPixelValueForLength(const Length& length, const ComputedStyle& style)
+static CSSValue* zoomAdjustedPixelValueForLength(const Length& length, const ComputedStyle& style)
 {
     if (length.isFixed())
         return zoomAdjustedPixelValue(length.value(), style);
-    return CSSPrimitiveValue::create(length, style.effectiveZoom());
+    return CSSValue::create(length, style.effectiveZoom());
 }
 
-static CSSPrimitiveValue* pixelValueForUnzoomedLength(const UnzoomedLength& unzoomedLength, const ComputedStyle& style)
+static CSSValue* pixelValueForUnzoomedLength(const UnzoomedLength& unzoomedLength, const ComputedStyle& style)
 {
     const Length& length = unzoomedLength.length();
     if (length.isFixed())
         return CSSPrimitiveValue::create(length.value(), CSSPrimitiveValue::UnitType::Pixels);
-    return CSSPrimitiveValue::create(length, style.effectiveZoom());
+    return CSSValue::create(length, style.effectiveZoom());
 }
 
 static CSSValueList* createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const ComputedStyle& style)
 {
     CSSValueList* positionList = CSSValueList::createSpaceSeparated();
     if (layer.isBackgroundXOriginSet()) {
         ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
-        positionList->append(*CSSPrimitiveValue::create(layer.backgroundXOrigin()));
+        positionList->append(*CSSIdentifierValue::create(layer.backgroundXOrigin()));
     }
     positionList->append(*zoomAdjustedPixelValueForLength(layer.xPosition(), style));
     if (layer.isBackgroundYOriginSet()) {
         ASSERT(propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
-        positionList->append(*CSSPrimitiveValue::create(layer.backgroundYOrigin()));
+        positionList->append(*CSSIdentifierValue::create(layer.backgroundYOrigin()));
     }
     positionList->append(*zoomAdjustedPixelValueForLength(layer.yPosition(), style));
     return positionList;
 }
 
 CSSValue* ComputedStyleCSSValueMapping::currentColorOrValidColor(const ComputedStyle& style, const StyleColor& color)
 {
     // This function does NOT look at visited information, so that computed style doesn't expose that.
     return CSSColorValue::create(color.resolve(style.color()).rgb());
 }
 
 static CSSValue* valueForFillSize(const FillSize& fillSize, const ComputedStyle& style)
 {
     if (fillSize.type == Contain)
-        return CSSPrimitiveValue::createIdentifier(CSSValueContain);
+        return CSSIdentifierValue::createIdentifier(CSSValueContain);
 
     if (fillSize.type == Cover)
-        return CSSPrimitiveValue::createIdentifier(CSSValueCover);
+        return CSSIdentifierValue::createIdentifier(CSSValueCover);
 
     if (fillSize.size.height().isAuto())
         return zoomAdjustedPixelValueForLength(fillSize.size.width(), style);
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(*zoomAdjustedPixelValueForLength(fillSize.size.width(), style));
     list->append(*zoomAdjustedPixelValueForLength(fillSize.size.height(), style));
     return list;
 }
 
 static CSSValue* valueForFillRepeat(EFillRepeat xRepeat, EFillRepeat yRepeat)
 {
     // For backwards compatibility, if both values are equal, just return one of them. And
     // if the two values are equivalent to repeat-x or repeat-y, just return the shorthand.
     if (xRepeat == yRepeat)
-        return CSSPrimitiveValue::create(xRepeat);
+        return CSSIdentifierValue::create(xRepeat);
     if (xRepeat == RepeatFill && yRepeat == NoRepeatFill)
-        return CSSPrimitiveValue::createIdentifier(CSSValueRepeatX);
+        return CSSIdentifierValue::createIdentifier(CSSValueRepeatX);
     if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)
-        return CSSPrimitiveValue::createIdentifier(CSSValueRepeatY);
+        return CSSIdentifierValue::createIdentifier(CSSValueRepeatY);
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
-    list->append(*CSSPrimitiveValue::create(xRepeat));
-    list->append(*CSSPrimitiveValue::create(yRepeat));
+    list->append(*CSSIdentifierValue::create(xRepeat));
+    list->append(*CSSIdentifierValue::create(yRepeat));
     return list;
 }
 
 static CSSValue* valueForFillSourceType(EMaskSourceType type)
 {
     switch (type) {
     case MaskAlpha:
-        return CSSPrimitiveValue::createIdentifier(CSSValueAlpha);
+        return CSSIdentifierValue::createIdentifier(CSSValueAlpha);
     case MaskLuminance:
-        return CSSPrimitiveValue::createIdentifier(CSSValueLuminance);
+        return CSSIdentifierValue::createIdentifier(CSSValueLuminance);
     }
 
     ASSERT_NOT_REACHED();
 
     return nullptr;
 }
 
 static CSSValue* valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* layoutObject)
 {
     Length offset, opposite;
@@ skipping 36 matching lines @@
 
             if (opposite.isPercentOrCalc() || opposite.isCalculated()) {
                 if (layoutObject->isBox()) {
                     LayoutUnit containingBlockSize =
                         (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight) ?
                         toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent() :
                         toLayoutBox(layoutObject)->containingBlockLogicalHeightForGetComputedStyle();
                     return zoomAdjustedPixelValue(-floatValueForLength(opposite, containingBlockSize), style);
                 }
                 // FIXME:  fall back to auto for position:relative, display:inline
-                return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+                return CSSIdentifierValue::createIdentifier(CSSValueAuto);
             }
 
             // Length doesn't provide operator -, so multiply by -1.
             opposite *= -1.f;
             return zoomAdjustedPixelValueForLength(opposite, style);
         }
 
         if (layoutObject->isOutOfFlowPositioned() && layoutObject->isBox()) {
             // For fixed and absolute positioned elements, the top, left, bottom, and right
             // are defined relative to the corresponding sides of the containing block.
@@ skipping 22 matching lines @@
                     (layoutBox->offsetHeight() + clientOffset.height());
                 break;
             default:
                 ASSERT_NOT_REACHED();
             }
             return zoomAdjustedPixelValue(position, style);
         }
     }
 
     if (offset.isAuto())
-        return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        return CSSIdentifierValue::createIdentifier(CSSValueAuto);
 
     return zoomAdjustedPixelValueForLength(offset, style);
 }
 
 static CSSBorderImageSliceValue* valueForNinePieceImageSlice(const NinePieceImage& image)
 {
     // Create the slices.
     CSSPrimitiveValue* top = nullptr;
     CSSPrimitiveValue* right = nullptr;
     CSSPrimitiveValue* bottom = nullptr;
@@ skipping 32 matching lines @@
                     left = CSSPrimitiveValue::create(image.imageSlices().left().value(), CSSPrimitiveValue::UnitType::Percentage);
                 else
                     left = CSSPrimitiveValue::create(image.imageSlices().left().value(), CSSPrimitiveValue::UnitType::Number);
             }
         }
     }
 
     return CSSBorderImageSliceValue::create(CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsQuad), image.fill());
 }
 
-static CSSPrimitiveValue* valueForBorderImageLength(const BorderImageLength& borderImageLength, const ComputedStyle& style)
+static CSSValue* valueForBorderImageLength(const BorderImageLength& borderImageLength, const ComputedStyle& style)
 {
     if (borderImageLength.isNumber())
         return CSSPrimitiveValue::create(borderImageLength.number(), CSSPrimitiveValue::UnitType::Number);
-    return CSSPrimitiveValue::create(borderImageLength.length(), style.effectiveZoom());
+    return CSSValue::create(borderImageLength.length(), style.effectiveZoom());
 }
 
 static CSSQuadValue* valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
 {
     // Create the slices.
-    CSSPrimitiveValue* top = nullptr;
-    CSSPrimitiveValue* right = nullptr;
-    CSSPrimitiveValue* bottom = nullptr;
-    CSSPrimitiveValue* left = nullptr;
+    CSSValue* top = nullptr;
+    CSSValue* right = nullptr;
+    CSSValue* bottom = nullptr;
+    CSSValue* left = nullptr;
 
     top = valueForBorderImageLength(box.top(), style);
 
     if (box.right() == box.top() && box.bottom() == box.top() && box.left() == box.top()) {
         right = top;
         bottom = top;
         left = top;
     } else {
         right = valueForBorderImageLength(box.right(), style);
 
@@ skipping 21 matching lines @@
         return CSSValueRound;
     case SpaceImageRule:
         return CSSValueSpace;
     default:
         return CSSValueStretch;
     }
 }
 
 static CSSValue* valueForNinePieceImageRepeat(const NinePieceImage& image)
 {
-    CSSPrimitiveValue* horizontalRepeat = nullptr;
-    CSSPrimitiveValue* verticalRepeat = nullptr;
+    CSSIdentifierValue* horizontalRepeat = nullptr;
+    CSSIdentifierValue* verticalRepeat = nullptr;
 
-    horizontalRepeat = CSSPrimitiveValue::createIdentifier(valueForRepeatRule(image.horizontalRule()));
+    horizontalRepeat = CSSIdentifierValue::createIdentifier(valueForRepeatRule(image.horizontalRule()));
     if (image.horizontalRule() == image.verticalRule())
         verticalRepeat = horizontalRepeat;
     else
-        verticalRepeat = CSSPrimitiveValue::createIdentifier(valueForRepeatRule(image.verticalRule()));
+        verticalRepeat = CSSIdentifierValue::createIdentifier(valueForRepeatRule(image.verticalRule()));
     return CSSValuePair::create(horizontalRepeat, verticalRepeat, CSSValuePair::DropIdenticalValues);
 }
 
 static CSSValue* valueForNinePieceImage(const NinePieceImage& image, const ComputedStyle& style)
 {
     if (!image.hasImage())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     // Image first.
     CSSValue* imageValue = nullptr;
     if (image.image())
         imageValue = image.image()->computedCSSValue();
 
     // Create the image slice.
     CSSBorderImageSliceValue* imageSlices = valueForNinePieceImageSlice(image);
 
     // Create the border area slices.
     CSSValue* borderSlices = valueForNinePieceImageQuad(image.borderSlices(), style);
 
     // Create the border outset.
     CSSValue* outset = valueForNinePieceImageQuad(image.outset(), style);
 
     // Create the repeat rules.
     CSSValue* repeat = valueForNinePieceImageRepeat(image);
 
     return createBorderImageValue(imageValue, imageSlices, borderSlices, outset, repeat);
 }
 
 static CSSValue* valueForReflection(const StyleReflection* reflection, const ComputedStyle& style)
 {
     if (!reflection)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     CSSPrimitiveValue* offset = nullptr;
     // TODO(alancutter): Make this work correctly for calc lengths.
     if (reflection->offset().isPercentOrCalc())
         offset = CSSPrimitiveValue::create(reflection->offset().percent(), CSSPrimitiveValue::UnitType::Percentage);
     else
         offset = zoomAdjustedPixelValue(reflection->offset().value(), style);
 
-    CSSPrimitiveValue* direction = nullptr;
+    CSSIdentifierValue* direction = nullptr;
     switch (reflection->direction()) {
     case ReflectionBelow:
-        direction = CSSPrimitiveValue::createIdentifier(CSSValueBelow);
+        direction = CSSIdentifierValue::createIdentifier(CSSValueBelow);
         break;
     case ReflectionAbove:
-        direction = CSSPrimitiveValue::createIdentifier(CSSValueAbove);
+        direction = CSSIdentifierValue::createIdentifier(CSSValueAbove);
         break;
     case ReflectionLeft:
-        direction = CSSPrimitiveValue::createIdentifier(CSSValueLeft);
+        direction = CSSIdentifierValue::createIdentifier(CSSValueLeft);
         break;
     case ReflectionRight:
-        direction = CSSPrimitiveValue::createIdentifier(CSSValueRight);
+        direction = CSSIdentifierValue::createIdentifier(CSSValueRight);
         break;
     }
 
     return CSSReflectValue::create(direction, offset, valueForNinePieceImage(reflection->mask(), style));
 }
 
 static CSSValueList* valueForItemPositionWithOverflowAlignment(const StyleSelfAlignmentData& data)
 {
     CSSValueList* result = CSSValueList::createSpaceSeparated();
     if (data.positionType() == LegacyPosition)
-        result->append(*CSSPrimitiveValue::createIdentifier(CSSValueLegacy));
+        result->append(*CSSIdentifierValue::createIdentifier(CSSValueLegacy));
     // To avoid needing to copy the RareNonInheritedData, we repurpose the 'auto' flag to not just mean 'auto' prior to running the StyleAdjuster but also mean 'normal' after running it.
-    result->append(*CSSPrimitiveValue::create(data.position() == ItemPositionAuto ? ComputedStyle::initialDefaultAlignment().position() : data.position()));
+    result->append(*CSSIdentifierValue::create(data.position() == ItemPositionAuto ? ComputedStyle::initialDefaultAlignment().position() : data.position()));
     if (data.position() >= ItemPositionCenter && data.overflow() != OverflowAlignmentDefault)
-        result->append(*CSSPrimitiveValue::create(data.overflow()));
+        result->append(*CSSIdentifierValue::create(data.overflow()));
     ASSERT(result->length() <= 2);
     return result;
 }
 
 static CSSValueList* valuesForGridShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     CSSValueList* list = CSSValueList::createSlashSeparated();
     for (size_t i = 0; i < shorthand.length(); ++i) {
         const CSSValue* value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
         ASSERT(value);
         list->append(*value);
     }
     return list;
 }
 
 static CSSValueList* valuesForShorthandProperty(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     for (size_t i = 0; i < shorthand.length(); ++i) {
         const CSSValue* value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
         ASSERT(value);
         list->append(*value);
     }
     return list;
 }
 
 static CSSValue* expandNoneLigaturesValue()
 {
     CSSValueList* list = CSSValueList::createSpaceSeparated();
-    list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNoCommonLigatures));
-    list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNoDiscretionaryLigatures));
-    list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNoHistoricalLigatures));
-    list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNoContextual));
+    list->append(*CSSIdentifierValue::createIdentifier(CSSValueNoCommonLigatures));
+    list->append(*CSSIdentifierValue::createIdentifier(CSSValueNoDiscretionaryLigatures));
+    list->append(*CSSIdentifierValue::createIdentifier(CSSValueNoHistoricalLigatures));
+    list->append(*CSSIdentifierValue::createIdentifier(CSSValueNoContextual));
     return list;
 }
 
 static CSSValue* valuesForFontVariantProperty(const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     enum VariantShorthandCases { AllNormal, NoneLigatures, ConcatenateNonNormal };
     VariantShorthandCases shorthandCase = AllNormal;
     for (size_t i = 0; i < fontVariantShorthand().length(); ++i) {
         const CSSValue* value = ComputedStyleCSSValueMapping::get(fontVariantShorthand().properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
 
         if (shorthandCase == AllNormal
-            && value->isPrimitiveValue()
-            && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone
+            && value->isIdentifierValue()
+            && toCSSIdentifierValue(value)->getValueID() == CSSValueNone
             && fontVariantShorthand().properties()[i] == CSSPropertyFontVariantLigatures) {
             shorthandCase = NoneLigatures;
-        } else if (!(value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNormal)) {
+        } else if (!(value->isIdentifierValue() && toCSSIdentifierValue(value)->getValueID() == CSSValueNormal)) {
             shorthandCase = ConcatenateNonNormal;
             break;
         }
     }
 
     switch (shorthandCase) {
     case AllNormal:
-        return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+        return CSSIdentifierValue::createIdentifier(CSSValueNormal);
     case NoneLigatures:
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case ConcatenateNonNormal:
         {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         for (size_t i = 0; i < fontVariantShorthand().length(); ++i) {
             const CSSValue* value = ComputedStyleCSSValueMapping::get(fontVariantShorthand().properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
             ASSERT(value);
-            if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNone) {
+            if (value->isIdentifierValue() && toCSSIdentifierValue(value)->getValueID() == CSSValueNone) {
                 list->append(*expandNoneLigaturesValue());
-            } else if (!(value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueNormal)) {
+            } else if (!(value->isIdentifierValue() && toCSSIdentifierValue(value)->getValueID() == CSSValueNormal)) {
                 list->append(*value);
             }
         }
         return list;
         }
     default:
         NOTREACHED();
         return nullptr;
     }
 }
 
 static CSSValueList* valuesForBackgroundShorthand(const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     CSSValueList* ret = CSSValueList::createCommaSeparated();
     const FillLayer* currLayer = &style.backgroundLayers();
     for (; currLayer; currLayer = currLayer->next()) {
         CSSValueList* list = CSSValueList::createSlashSeparated();
         CSSValueList* beforeSlash = CSSValueList::createSpaceSeparated();
         if (!currLayer->next()) { // color only for final layer
             const CSSValue* value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, layoutObject, styledNode, allowVisitedStyle);
             ASSERT(value);
             beforeSlash->append(*value);
         }
-        beforeSlash->append(currLayer->image() ? *currLayer->image()->computedCSSValue() : *CSSPrimitiveValue::createIdentifier(CSSValueNone));
+        beforeSlash->append(currLayer->image() ? *currLayer->image()->computedCSSValue() : *CSSIdentifierValue::createIdentifier(CSSValueNone));
         beforeSlash->append(*valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
-        beforeSlash->append(*CSSPrimitiveValue::create(currLayer->attachment()));
+        beforeSlash->append(*CSSIdentifierValue::create(currLayer->attachment()));
         beforeSlash->append(*createPositionListForLayer(CSSPropertyBackgroundPosition, *currLayer, style));
         list->append(*beforeSlash);
         CSSValueList* afterSlash = CSSValueList::createSpaceSeparated();
         afterSlash->append(*valueForFillSize(currLayer->size(), style));
-        afterSlash->append(*CSSPrimitiveValue::create(currLayer->origin()));
-        afterSlash->append(*CSSPrimitiveValue::create(currLayer->clip()));
+        afterSlash->append(*CSSIdentifierValue::create(currLayer->origin()));
+        afterSlash->append(*CSSIdentifierValue::create(currLayer->clip()));
         list->append(*afterSlash);
         ret->append(*list);
     }
     return ret;
 }
 
 static CSSValueList* valueForContentPositionAndDistributionWithOverflowAlignment(const StyleContentAlignmentData& data)
 {
     CSSValueList* result = CSSValueList::createSpaceSeparated();
     if (data.distribution() != ContentDistributionDefault)
-        result->append(*CSSPrimitiveValue::create(data.distribution()));
+        result->append(*CSSIdentifierValue::create(data.distribution()));
     if (data.distribution() == ContentDistributionDefault || data.position() != ContentPositionNormal)
-        result->append(*CSSPrimitiveValue::create(data.position()));
+        result->append(*CSSIdentifierValue::create(data.position()));
     if ((data.position() >= ContentPositionCenter || data.distribution() != ContentDistributionDefault) && data.overflow() != OverflowAlignmentDefault)
-        result->append(*CSSPrimitiveValue::create(data.overflow()));
+        result->append(*CSSIdentifierValue::create(data.overflow()));
     ASSERT(result->length() > 0);
     ASSERT(result->length() <= 3);
     return result;
 }
 
-static CSSPrimitiveValue* valueForLineHeight(const ComputedStyle& style)
+static CSSValue* valueForLineHeight(const ComputedStyle& style)
 {
     Length length = style.lineHeight();
     if (length.isNegative())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+        return CSSIdentifierValue::createIdentifier(CSSValueNormal);
 
     return zoomAdjustedPixelValue(floatValueForLength(length, style.getFontDescription().computedSize()), style);
 }
 
 static CSSValueID identifierForFamily(const AtomicString& family)
 {
     if (family == FontFamilyNames::webkit_cursive)
         return CSSValueCursive;
     if (family == FontFamilyNames::webkit_fantasy)
         return CSSValueFantasy;
     if (family == FontFamilyNames::webkit_monospace)
         return CSSValueMonospace;
     if (family == FontFamilyNames::webkit_pictograph)
         return CSSValueWebkitPictograph;
     if (family == FontFamilyNames::webkit_sans_serif)
         return CSSValueSansSerif;
     if (family == FontFamilyNames::webkit_serif)
         return CSSValueSerif;
     return CSSValueInvalid;
 }
 
 static CSSValue* valueForFamily(const AtomicString& family)
 {
     if (CSSValueID familyIdentifier = identifierForFamily(family))
-        return CSSPrimitiveValue::createIdentifier(familyIdentifier);
+        return CSSIdentifierValue::createIdentifier(familyIdentifier);
     return CSSFontFamilyValue::create(family.getString());
 }
 
 static CSSValueList* valueForFontFamily(const ComputedStyle& style)
 {
     const FontFamily& firstFamily = style.getFontDescription().family();
     CSSValueList* list = CSSValueList::createCommaSeparated();
     for (const FontFamily* family = &firstFamily; family; family = family->next())
         list->append(*valueForFamily(family->family()));
     return list;
 }
 
 static CSSPrimitiveValue* valueForFontSize(const ComputedStyle& style)
 {
     return zoomAdjustedPixelValue(style.getFontDescription().computedSize(), style);
 }
 
-static CSSPrimitiveValue* valueForFontStretch(const ComputedStyle& style)
+static CSSIdentifierValue* valueForFontStretch(const ComputedStyle& style)
 {
-    return CSSPrimitiveValue::create(style.getFontDescription().stretch());
+    return CSSIdentifierValue::create(style.getFontDescription().stretch());
 }
 
-static CSSPrimitiveValue* valueForFontStyle(const ComputedStyle& style)
+static CSSIdentifierValue* valueForFontStyle(const ComputedStyle& style)
 {
-    return CSSPrimitiveValue::create(style.getFontDescription().style());
+    return CSSIdentifierValue::create(style.getFontDescription().style());
 }
 
-static CSSPrimitiveValue* valueForFontWeight(const ComputedStyle& style)
+static CSSIdentifierValue* valueForFontWeight(const ComputedStyle& style)
 {
-    return CSSPrimitiveValue::create(style.getFontDescription().weight());
+    return CSSIdentifierValue::create(style.getFontDescription().weight());
 }
 
-static CSSPrimitiveValue* valueForFontVariantCaps(const ComputedStyle& style)
+static CSSIdentifierValue* valueForFontVariantCaps(const ComputedStyle& style)
 {
     FontDescription::FontVariantCaps variantCaps = style.getFontDescription().variantCaps();
     switch (variantCaps) {
     case FontDescription::CapsNormal:
-        return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+        return CSSIdentifierValue::createIdentifier(CSSValueNormal);
     case FontDescription::SmallCaps:
-        return CSSPrimitiveValue::createIdentifier(CSSValueSmallCaps);
+        return CSSIdentifierValue::createIdentifier(CSSValueSmallCaps);
     case FontDescription::AllSmallCaps:
-        return CSSPrimitiveValue::createIdentifier(CSSValueAllSmallCaps);
+        return CSSIdentifierValue::createIdentifier(CSSValueAllSmallCaps);
     case FontDescription::PetiteCaps:
-        return CSSPrimitiveValue::createIdentifier(CSSValuePetiteCaps);
+        return CSSIdentifierValue::createIdentifier(CSSValuePetiteCaps);
     case FontDescription::AllPetiteCaps:
-        return CSSPrimitiveValue::createIdentifier(CSSValueAllPetiteCaps);
+        return CSSIdentifierValue::createIdentifier(CSSValueAllPetiteCaps);
     case FontDescription::Unicase:
-        return CSSPrimitiveValue::createIdentifier(CSSValueUnicase);
+        return CSSIdentifierValue::createIdentifier(CSSValueUnicase);
     case FontDescription::TitlingCaps:
-        return CSSPrimitiveValue::createIdentifier(CSSValueTitlingCaps);
+        return CSSIdentifierValue::createIdentifier(CSSValueTitlingCaps);
     default:
         NOTREACHED();
         return nullptr;
     }
 }
 
 static CSSValue* valueForFontVariantLigatures(const ComputedStyle& style)
 {
     FontDescription::LigaturesState commonLigaturesState = style.getFontDescription().commonLigaturesState();
     FontDescription::LigaturesState discretionaryLigaturesState = style.getFontDescription().discretionaryLigaturesState();
     FontDescription::LigaturesState historicalLigaturesState = style.getFontDescription().historicalLigaturesState();
     FontDescription::LigaturesState contextualLigaturesState = style.getFontDescription().contextualLigaturesState();
     if (commonLigaturesState == FontDescription::NormalLigaturesState && discretionaryLigaturesState == FontDescription::NormalLigaturesState
         && historicalLigaturesState == FontDescription::NormalLigaturesState && contextualLigaturesState == FontDescription::NormalLigaturesState)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+        return CSSIdentifierValue::createIdentifier(CSSValueNormal);
 
     if (commonLigaturesState == FontDescription::DisabledLigaturesState && discretionaryLigaturesState == FontDescription::DisabledLigaturesState
         && historicalLigaturesState == FontDescription::DisabledLigaturesState && contextualLigaturesState == FontDescription::DisabledLigaturesState)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     CSSValueList* valueList = CSSValueList::createSpaceSeparated();
     if (commonLigaturesState != FontDescription::NormalLigaturesState)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(commonLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoCommonLigatures : CSSValueCommonLigatures));
+        valueList->append(*CSSIdentifierValue::createIdentifier(commonLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoCommonLigatures : CSSValueCommonLigatures));
     if (discretionaryLigaturesState != FontDescription::NormalLigaturesState)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(discretionaryLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoDiscretionaryLigatures : CSSValueDiscretionaryLigatures));
+        valueList->append(*CSSIdentifierValue::createIdentifier(discretionaryLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoDiscretionaryLigatures : CSSValueDiscretionaryLigatures));
     if (historicalLigaturesState != FontDescription::NormalLigaturesState)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(historicalLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoHistoricalLigatures : CSSValueHistoricalLigatures));
+        valueList->append(*CSSIdentifierValue::createIdentifier(historicalLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoHistoricalLigatures : CSSValueHistoricalLigatures));
     if (contextualLigaturesState != FontDescription::NormalLigaturesState)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(contextualLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoContextual : CSSValueContextual));
+        valueList->append(*CSSIdentifierValue::createIdentifier(contextualLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoContextual : CSSValueContextual));
     return valueList;
 }
 
 static CSSValue* valueForFontVariantNumeric(const ComputedStyle& style)
 {
     FontVariantNumeric variantNumeric = style.getFontDescription().variantNumeric();
     if (variantNumeric.isAllNormal())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+        return CSSIdentifierValue::createIdentifier(CSSValueNormal);
 
     CSSValueList* valueList = CSSValueList::createSpaceSeparated();
     if (variantNumeric.numericFigureValue() != FontVariantNumeric::NormalFigure)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(variantNumeric.numericFigureValue() == FontVariantNumeric::LiningNums ? CSSValueLiningNums : CSSValueOldstyleNums));
+        valueList->append(*CSSIdentifierValue::createIdentifier(variantNumeric.numericFigureValue() == FontVariantNumeric::LiningNums ? CSSValueLiningNums : CSSValueOldstyleNums));
     if (variantNumeric.numericSpacingValue() != FontVariantNumeric::NormalSpacing)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(variantNumeric.numericSpacingValue() == FontVariantNumeric::ProportionalNums ? CSSValueProportionalNums : CSSValueTabularNums));
+        valueList->append(*CSSIdentifierValue::createIdentifier(variantNumeric.numericSpacingValue() == FontVariantNumeric::ProportionalNums ? CSSValueProportionalNums : CSSValueTabularNums));
     if (variantNumeric.numericFractionValue() != FontVariantNumeric::NormalFraction)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(variantNumeric.numericFractionValue() == FontVariantNumeric::DiagonalFractions ? CSSValueDiagonalFractions : CSSValueStackedFractions));
+        valueList->append(*CSSIdentifierValue::createIdentifier(variantNumeric.numericFractionValue() == FontVariantNumeric::DiagonalFractions ? CSSValueDiagonalFractions : CSSValueStackedFractions));
     if (variantNumeric.ordinalValue() == FontVariantNumeric::OrdinalOn)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(CSSValueOrdinal));
+        valueList->append(*CSSIdentifierValue::createIdentifier(CSSValueOrdinal));
     if (variantNumeric.slashedZeroValue() == FontVariantNumeric::SlashedZeroOn)
-        valueList->append(*CSSPrimitiveValue::createIdentifier(CSSValueSlashedZero));
+        valueList->append(*CSSIdentifierValue::createIdentifier(CSSValueSlashedZero));
 
     return valueList;
 }
 
 
 static CSSValue* specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const ComputedStyle& style)
 {
     if (!trackBreadth.isLength())
         return CSSPrimitiveValue::create(trackBreadth.flex(), CSSPrimitiveValue::UnitType::Fraction);
 
     const Length& trackBreadthLength = trackBreadth.length();
     if (trackBreadthLength.isAuto())
-        return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        return CSSIdentifierValue::createIdentifier(CSSValueAuto);
     return zoomAdjustedPixelValueForLength(trackBreadthLength, style);
 }
 
 static CSSValue* specifiedValueForGridTrackSize(const GridTrackSize& trackSize, const ComputedStyle& style)
 {
     switch (trackSize.type()) {
     case LengthTrackSizing:
         return specifiedValueForGridTrackBreadth(trackSize.minTrackBreadth(), style);
     case MinMaxTrackSizing: {
         auto* minMaxTrackBreadths = CSSFunctionValue::create(CSSValueMinmax);
@@ skipping 113 matching lines @@
     // Handle the 'none' case.
     bool trackListIsEmpty = trackSizes.isEmpty() && autoRepeatTrackSizes.isEmpty();
     if (isLayoutGrid && trackListIsEmpty) {
         // For grids we should consider every listed track, whether implicitly or explicitly
         // created. Empty grids have a sole grid line per axis.
         auto& positions = isRowAxis ? toLayoutGrid(layoutObject)->columnPositions() : toLayoutGrid(layoutObject)->rowPositions();
         trackListIsEmpty = positions.size() == 1;
     }
 
     if (trackListIsEmpty)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     size_t autoRepeatTotalTracks = isLayoutGrid ? toLayoutGrid(layoutObject)->autoRepeatCountForDirection(direction) : 0;
     OrderedNamedLinesCollector collector(style, isRowAxis, autoRepeatTotalTracks);
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     size_t insertionIndex;
     if (isLayoutGrid) {
         const auto* grid = toLayoutGrid(layoutObject);
         Vector<LayoutUnit> computedTrackSizes = grid->trackSizesForComputedStyle(direction);
         size_t numTracks = computedTrackSizes.size();
 
@@ skipping 12 matching lines @@
         insertionIndex = trackSizes.size();
     }
     // Those are the trailing <string>* allowed in the syntax.
     addValuesForNamedGridLinesAtIndex(collector, insertionIndex, *list);
     return list;
 }
 
 static CSSValue* valueForGridPosition(const GridPosition& position)
 {
     if (position.isAuto())
-        return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+        return CSSIdentifierValue::createIdentifier(CSSValueAuto);
 
     if (position.isNamedGridArea())
         return CSSCustomIdentValue::create(position.namedGridLine());
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (position.isSpan()) {
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueSpan));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueSpan));
         list->append(*CSSPrimitiveValue::create(position.spanPosition(), CSSPrimitiveValue::UnitType::Number));
     } else {
         list->append(*CSSPrimitiveValue::create(position.integerPosition(), CSSPrimitiveValue::UnitType::Number));
     }
 
     if (!position.namedGridLine().isNull())
         list->append(*CSSCustomIdentValue::create(position.namedGridLine()));
     return list;
 }
 
 static LayoutRect sizingBox(const LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
         return LayoutRect();
 
     const LayoutBox* box = toLayoutBox(layoutObject);
     return box->style()->boxSizing() == BoxSizingBorderBox ? box->borderBoxRect() : box->computedCSSContentBoxRect();
 }
 
 static CSSValue* renderTextDecorationFlagsToCSSValue(int textDecoration)
 {
     // Blink value is ignored.
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (textDecoration & TextDecorationUnderline)
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueUnderline));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueUnderline));
     if (textDecoration & TextDecorationOverline)
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueOverline));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueOverline));
     if (textDecoration & TextDecorationLineThrough)
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueLineThrough));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueLineThrough));
 
     if (!list->length())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     return list;
 }
 
 static CSSValue* valueForTextDecorationStyle(TextDecorationStyle textDecorationStyle)
 {
     switch (textDecorationStyle) {
     case TextDecorationStyleSolid:
-        return CSSPrimitiveValue::createIdentifier(CSSValueSolid);
+        return CSSIdentifierValue::createIdentifier(CSSValueSolid);
     case TextDecorationStyleDouble:
-        return CSSPrimitiveValue::createIdentifier(CSSValueDouble);
+        return CSSIdentifierValue::createIdentifier(CSSValueDouble);
     case TextDecorationStyleDotted:
-        return CSSPrimitiveValue::createIdentifier(CSSValueDotted);
+        return CSSIdentifierValue::createIdentifier(CSSValueDotted);
     case TextDecorationStyleDashed:
-        return CSSPrimitiveValue::createIdentifier(CSSValueDashed);
+        return CSSIdentifierValue::createIdentifier(CSSValueDashed);
     case TextDecorationStyleWavy:
-        return CSSPrimitiveValue::createIdentifier(CSSValueWavy);
+        return CSSIdentifierValue::createIdentifier(CSSValueWavy);
     }
 
     ASSERT_NOT_REACHED();
     return CSSInitialValue::create();
 }
 
 static CSSValue* touchActionFlagsToCSSValue(TouchAction touchAction)
 {
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     if (touchAction == TouchActionAuto) {
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueAuto));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueAuto));
     } else if (touchAction == TouchActionNone) {
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNone));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueNone));
     } else if (touchAction == TouchActionManipulation) {
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueManipulation));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueManipulation));
     } else {
         if ((touchAction & TouchActionPanX) == TouchActionPanX)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValuePanX));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValuePanX));
         else if (touchAction & TouchActionPanLeft)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValuePanLeft));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValuePanLeft));
         else if (touchAction & TouchActionPanRight)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValuePanRight));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValuePanRight));
 
         if ((touchAction & TouchActionPanY) == TouchActionPanY)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValuePanY));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValuePanY));
         else if (touchAction & TouchActionPanUp)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValuePanUp));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValuePanUp));
         else if (touchAction & TouchActionPanDown)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValuePanDown));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValuePanDown));
     }
     ASSERT(list->length());
     return list;
 }
 
 static CSSValue* valueForWillChange(const Vector<CSSPropertyID>& willChangeProperties, bool willChangeContents, bool willChangeScrollPosition)
 {
     CSSValueList* list = CSSValueList::createCommaSeparated();
     if (willChangeContents)
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueContents));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueContents));
     if (willChangeScrollPosition)
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueScrollPosition));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueScrollPosition));
     for (size_t i = 0; i < willChangeProperties.size(); ++i)
         list->append(*CSSCustomIdentValue::create(willChangeProperties[i]));
     if (!list->length())
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueAuto));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueAuto));
     return list;
 }
 
 static CSSValue* valueForAnimationDelay(const CSSTimingData* timingData)
 {
     CSSValueList* list = CSSValueList::createCommaSeparated();
     if (timingData) {
         for (size_t i = 0; i < timingData->delayList().size(); ++i)
             list->append(*CSSPrimitiveValue::create(timingData->delayList()[i], CSSPrimitiveValue::UnitType::Seconds));
     } else {
         list->append(*CSSPrimitiveValue::create(CSSTimingData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
     }
     return list;
 }
 
 static CSSValue* valueForAnimationDirection(Timing::PlaybackDirection direction)
 {
     switch (direction) {
     case Timing::PlaybackDirection::NORMAL:
-        return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+        return CSSIdentifierValue::createIdentifier(CSSValueNormal);
     case Timing::PlaybackDirection::ALTERNATE_NORMAL:
-        return CSSPrimitiveValue::createIdentifier(CSSValueAlternate);
+        return CSSIdentifierValue::createIdentifier(CSSValueAlternate);
     case Timing::PlaybackDirection::REVERSE:
-        return CSSPrimitiveValue::createIdentifier(CSSValueReverse);
+        return CSSIdentifierValue::createIdentifier(CSSValueReverse);
     case Timing::PlaybackDirection::ALTERNATE_REVERSE:
-        return CSSPrimitiveValue::createIdentifier(CSSValueAlternateReverse);
+        return CSSIdentifierValue::createIdentifier(CSSValueAlternateReverse);
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
 static CSSValue* valueForAnimationDuration(const CSSTimingData* timingData)
 {
     CSSValueList* list = CSSValueList::createCommaSeparated();
     if (timingData) {
         for (size_t i = 0; i < timingData->durationList().size(); ++i)
             list->append(*CSSPrimitiveValue::create(timingData->durationList()[i], CSSPrimitiveValue::UnitType::Seconds));
     } else {
         list->append(*CSSPrimitiveValue::create(CSSTimingData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
     }
     return list;
 }
 
 static CSSValue* valueForAnimationFillMode(Timing::FillMode fillMode)
 {
     switch (fillMode) {
     case Timing::FillMode::NONE:
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case Timing::FillMode::FORWARDS:
-        return CSSPrimitiveValue::createIdentifier(CSSValueForwards);
+        return CSSIdentifierValue::createIdentifier(CSSValueForwards);
     case Timing::FillMode::BACKWARDS:
-        return CSSPrimitiveValue::createIdentifier(CSSValueBackwards);
+        return CSSIdentifierValue::createIdentifier(CSSValueBackwards);
     case Timing::FillMode::BOTH:
-        return CSSPrimitiveValue::createIdentifier(CSSValueBoth);
+        return CSSIdentifierValue::createIdentifier(CSSValueBoth);
     default:
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 }
 
 static CSSValue* valueForAnimationIterationCount(double iterationCount)
 {
     if (iterationCount == std::numeric_limits<double>::infinity())
-        return CSSPrimitiveValue::createIdentifier(CSSValueInfinite);
+        return CSSIdentifierValue::createIdentifier(CSSValueInfinite);
     return CSSPrimitiveValue::create(iterationCount, CSSPrimitiveValue::UnitType::Number);
 }
 
 static CSSValue* valueForAnimationPlayState(EAnimPlayState playState)
 {
     if (playState == AnimPlayStatePlaying)
-        return CSSPrimitiveValue::createIdentifier(CSSValueRunning);
+        return CSSIdentifierValue::createIdentifier(CSSValueRunning);
     ASSERT(playState == AnimPlayStatePaused);
-    return CSSPrimitiveValue::createIdentifier(CSSValuePaused);
+    return CSSIdentifierValue::createIdentifier(CSSValuePaused);
 }
 
 static CSSValue* createTimingFunctionValue(const TimingFunction* timingFunction)
 {
     switch (timingFunction->getType()) {
     case TimingFunction::Type::CUBIC_BEZIER:
         {
             const CubicBezierTimingFunction* bezierTimingFunction = toCubicBezierTimingFunction(timingFunction);
             if (bezierTimingFunction->getEaseType() != CubicBezierTimingFunction::EaseType::CUSTOM) {
                 CSSValueID valueId = CSSValueInvalid;
                 switch (bezierTimingFunction->getEaseType()) {
                 case CubicBezierTimingFunction::EaseType::EASE:
                     valueId = CSSValueEase;
                     break;
                 case CubicBezierTimingFunction::EaseType::EASE_IN:
                     valueId = CSSValueEaseIn;
                     break;
                 case CubicBezierTimingFunction::EaseType::EASE_OUT:
                     valueId = CSSValueEaseOut;
                     break;
                 case CubicBezierTimingFunction::EaseType::EASE_IN_OUT:
                     valueId = CSSValueEaseInOut;
                     break;
                 default:
                     ASSERT_NOT_REACHED();
                     return nullptr;
                 }
-                return CSSPrimitiveValue::createIdentifier(valueId);
+                return CSSIdentifierValue::createIdentifier(valueId);
             }
             return CSSCubicBezierTimingFunctionValue::create(bezierTimingFunction->x1(), bezierTimingFunction->y1(), bezierTimingFunction->x2(), bezierTimingFunction->y2());
         }
 
     case TimingFunction::Type::STEPS:
         {
             const StepsTimingFunction* stepsTimingFunction = toStepsTimingFunction(timingFunction);
             StepsTimingFunction::StepPosition position = stepsTimingFunction->getStepPosition();
             int steps = stepsTimingFunction->numberOfSteps();
             DCHECK(position == StepsTimingFunction::StepPosition::START || position == StepsTimingFunction::StepPosition::END);
 
             if (steps > 1)
                 return CSSStepsTimingFunctionValue::create(steps, position);
             CSSValueID valueId = position == StepsTimingFunction::StepPosition::START ? CSSValueStepStart : CSSValueStepEnd;
-            return CSSPrimitiveValue::createIdentifier(valueId);
+            return CSSIdentifierValue::createIdentifier(valueId);
         }
 
     default:
-        return CSSPrimitiveValue::createIdentifier(CSSValueLinear);
+        return CSSIdentifierValue::createIdentifier(CSSValueLinear);
     }
 }
 
 static CSSValue* valueForAnimationTimingFunction(const CSSTimingData* timingData)
 {
     CSSValueList* list = CSSValueList::createCommaSeparated();
     if (timingData) {
         for (size_t i = 0; i < timingData->timingFunctionList().size(); ++i)
             list->append(*createTimingFunctionValue(timingData->timingFunctionList()[i].get()));
     } else {
@@ skipping 59 matching lines @@
         transformValue->append(*zoomAdjustedNumberValue(transform.m43(), style));
         transformValue->append(*CSSPrimitiveValue::create(transform.m44(), CSSPrimitiveValue::UnitType::Number));
     }
 
     return transformValue;
 }
 
 static CSSValue* computedTransform(const LayoutObject* layoutObject, const ComputedStyle& style)
 {
     if (!layoutObject || !style.hasTransform())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     IntRect box;
     if (layoutObject->isBox())
         box = pixelSnappedIntRect(toLayoutBox(layoutObject)->borderBoxRect());
 
     TransformationMatrix transform;
     style.applyTransform(transform, LayoutSize(box.size()), ComputedStyle::ExcludeTransformOrigin, ComputedStyle::ExcludeMotionPath, ComputedStyle::ExcludeIndependentTransformProperties);
 
     // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(*valueForMatrixTransform(transform, style));
 
     return list;
 }
 
 static CSSValue* createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
 {
     if (property.propertyType == CSSTransitionData::TransitionNone)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     if (property.propertyType == CSSTransitionData::TransitionUnknownProperty)
         return CSSCustomIdentValue::create(property.propertyString);
     ASSERT(property.propertyType == CSSTransitionData::TransitionKnownProperty);
     return CSSCustomIdentValue::create(getPropertyNameAtomicString(property.unresolvedProperty));
 }
 
 static CSSValue* valueForTransitionProperty(const CSSTransitionData* transitionData)
 {
     CSSValueList* list = CSSValueList::createCommaSeparated();
     if (transitionData) {
         for (size_t i = 0; i < transitionData->propertyList().size(); ++i)
             list->append(*createTransitionPropertyValue(transitionData->propertyList()[i]));
     } else {
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueAll));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueAll));
     }
     return list;
 }
 
 CSSValueID valueForQuoteType(const QuoteType quoteType)
 {
     switch (quoteType) {
     case NO_OPEN_QUOTE:
         return CSSValueNoOpenQuote;
     case NO_CLOSE_QUOTE:
@@ skipping 12 matching lines @@
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     for (const ContentData* contentData = style.contentData(); contentData; contentData = contentData->next()) {
         if (contentData->isCounter()) {
             const CounterContent* counter = toCounterContentData(contentData)->counter();
             ASSERT(counter);
             CSSCustomIdentValue* identifier = CSSCustomIdentValue::create(counter->identifier());
             CSSStringValue* separator = CSSStringValue::create(counter->separator());
             CSSValueID listStyleIdent = CSSValueNone;
             if (counter->listStyle() != NoneListStyle)
                 listStyleIdent = static_cast<CSSValueID>(CSSValueDisc + counter->listStyle());
-            CSSPrimitiveValue* listStyle = CSSPrimitiveValue::createIdentifier(listStyleIdent);
+            CSSIdentifierValue* listStyle = CSSIdentifierValue::createIdentifier(listStyleIdent);
             list->append(*CSSCounterValue::create(identifier, listStyle, separator));
         } else if (contentData->isImage()) {
             const StyleImage* image = toImageContentData(contentData)->image();
             ASSERT(image);
             list->append(*image->computedCSSValue());
         } else if (contentData->isText()) {
             list->append(*CSSStringValue::create(toTextContentData(contentData)->text()));
         } else if (contentData->isQuote()) {
             const QuoteType quoteType = toQuoteContentData(contentData)->quote();
-            list->append(*CSSPrimitiveValue::createIdentifier(valueForQuoteType(quoteType)));
+            list->append(*CSSIdentifierValue::createIdentifier(valueForQuoteType(quoteType)));
         } else {
             ASSERT_NOT_REACHED();
         }
     }
     return list;
 }
 
 static CSSValue* valueForCounterDirectives(const ComputedStyle& style, CSSPropertyID propertyID)
 {
     const CounterDirectiveMap* map = style.counterDirectives();
     if (!map)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     for (const auto& item : *map) {
         bool isValidCounterValue = propertyID == CSSPropertyCounterIncrement ? item.value.isIncrement() : item.value.isReset();
         if (!isValidCounterValue)
             continue;
 
         list->append(*CSSCustomIdentValue::create(item.key));
         short number = propertyID == CSSPropertyCounterIncrement ? item.value.incrementValue() : item.value.resetValue();
         list->append(*CSSPrimitiveValue::create((double)number, CSSPrimitiveValue::UnitType::Integer));
     }
 
     if (!list->length())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     return list;
 }
 
 static CSSValue* valueForShape(const ComputedStyle& style, ShapeValue* shapeValue)
 {
     if (!shapeValue)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     if (shapeValue->type() == ShapeValue::Box)
-        return CSSPrimitiveValue::create(shapeValue->cssBox());
+        return CSSIdentifierValue::create(shapeValue->cssBox());
     if (shapeValue->type() == ShapeValue::Image) {
         if (shapeValue->image())
             return shapeValue->image()->computedCSSValue();
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     }
 
     ASSERT(shapeValue->type() == ShapeValue::Shape);
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(*valueForBasicShape(style, shapeValue->shape()));
     if (shapeValue->cssBox() != BoxMissing)
-        list->append(*CSSPrimitiveValue::create(shapeValue->cssBox()));
+        list->append(*CSSIdentifierValue::create(shapeValue->cssBox()));
     return list;
 }
 
 static CSSValueList* valuesForSidesShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     // Assume the properties are in the usual order top, right, bottom, left.
     const CSSValue* topValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[0], style, layoutObject, styledNode, allowVisitedStyle);
     const CSSValue* rightValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[1], style, layoutObject, styledNode, allowVisitedStyle);
     const CSSValue* bottomValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[2], style, layoutObject, styledNode, allowVisitedStyle);
@@ skipping 57 matching lines @@
 
     if (!verticalRadii->equals(toCSSValueList(list->item(0))))
         list->append(*verticalRadii);
 
     return list;
 }
 
 static CSSValue* strokeDashArrayToCSSValueList(const SVGDashArray& dashes, const ComputedStyle& style)
 {
     if (dashes.isEmpty())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     CSSValueList* list = CSSValueList::createCommaSeparated();
     for (const Length& dashLength : dashes.vector())
         list->append(*zoomAdjustedPixelValueForLength(dashLength, style));
 
     return list;
 }
 
 static CSSValue* paintOrderToCSSValueList(const SVGComputedStyle& svgStyle)
 {
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     for (int i = 0; i < 3; i++) {
         EPaintOrderType paintOrderType = svgStyle.paintOrderType(i);
         switch (paintOrderType) {
         case PT_FILL:
         case PT_STROKE:
         case PT_MARKERS:
-            list->append(*CSSPrimitiveValue::create(paintOrderType));
+            list->append(*CSSIdentifierValue::create(paintOrderType));
             break;
         case PT_NONE:
         default:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
     return list;
 }
 
 static CSSValue* adjustSVGPaintForCurrentColor(SVGPaintType paintType, const String& url, const Color& color, const Color& currentColor)
 {
     if (paintType >= SVG_PAINTTYPE_URI_NONE) {
         CSSValueList* values = CSSValueList::createSpaceSeparated();
         values->append(*CSSURIValue::create(url));
         if (paintType == SVG_PAINTTYPE_URI_NONE)
-            values->append(*CSSPrimitiveValue::createIdentifier(CSSValueNone));
+            values->append(*CSSIdentifierValue::createIdentifier(CSSValueNone));
         else if (paintType == SVG_PAINTTYPE_URI_CURRENTCOLOR)
             values->append(*CSSColorValue::create(currentColor.rgb()));
         else if (paintType == SVG_PAINTTYPE_URI_RGBCOLOR)
             values->append(*CSSColorValue::create(color.rgb()));
         return values;
     }
     if (paintType == SVG_PAINTTYPE_NONE)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     if (paintType == SVG_PAINTTYPE_CURRENTCOLOR)
         return CSSColorValue::create(currentColor.rgb());
 
     return CSSColorValue::create(color.rgb());
 }
 
 static inline String serializeAsFragmentIdentifier(const AtomicString& resource)
 {
     return "#" + resource;
 }
 
 CSSValue* ComputedStyleCSSValueMapping::valueForShadowData(const ShadowData& shadow, const ComputedStyle& style, bool useSpread)
 {
     CSSPrimitiveValue* x = zoomAdjustedPixelValue(shadow.x(), style);
     CSSPrimitiveValue* y = zoomAdjustedPixelValue(shadow.y(), style);
     CSSPrimitiveValue* blur = zoomAdjustedPixelValue(shadow.blur(), style);
     CSSPrimitiveValue* spread = useSpread ? zoomAdjustedPixelValue(shadow.spread(), style) : nullptr;
-    CSSPrimitiveValue* shadowStyle = shadow.style() == Normal ? nullptr : CSSPrimitiveValue::createIdentifier(CSSValueInset);
+    CSSIdentifierValue* shadowStyle = shadow.style() == Normal ? nullptr : CSSIdentifierValue::createIdentifier(CSSValueInset);
     CSSValue* color = currentColorOrValidColor(style, shadow.color());
     return CSSShadowValue::create(x, y, blur, spread, shadowStyle, color);
 }
 
 CSSValue* ComputedStyleCSSValueMapping::valueForShadowList(const ShadowList* shadowList, const ComputedStyle& style, bool useSpread)
 {
     if (!shadowList)
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     CSSValueList* list = CSSValueList::createCommaSeparated();
     size_t shadowCount = shadowList->shadows().size();
     for (size_t i = 0; i < shadowCount; ++i)
         list->append(*valueForShadowData(shadowList->shadows()[i], style, useSpread));
     return list;
 }
 
 CSSValue* ComputedStyleCSSValueMapping::valueForFilter(const ComputedStyle& style, const FilterOperations& filterOperations)
 {
     if (filterOperations.operations().isEmpty())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
 
     CSSFunctionValue* filterValue = nullptr;
 
     for (const auto& operation : filterOperations.operations()) {
         FilterOperation* filterOperation = operation.get();
         switch (filterOperation->type()) {
         case FilterOperation::REFERENCE:
             filterValue = CSSFunctionValue::create(CSSValueUrl);
@@ skipping 59 matching lines @@
     CSSValueList* sizeAndLineHeight = CSSValueList::createSlashSeparated();
     sizeAndLineHeight->append(*valueForFontSize(style));
     sizeAndLineHeight->append(*valueForLineHeight(style));
 
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(*valueForFontStyle(style));
 
     // Check that non-initial font-variant subproperties are not conflicting with this serialization.
     CSSValue* ligaturesValue = valueForFontVariantLigatures(style);
     CSSValue* numericValue = valueForFontVariantNumeric(style);
-    if (!ligaturesValue->equals(*CSSPrimitiveValue::createIdentifier(CSSValueNormal))
-        || !numericValue->equals(*CSSPrimitiveValue::createIdentifier(CSSValueNormal)))
+    if (!ligaturesValue->equals(*CSSIdentifierValue::createIdentifier(CSSValueNormal))
+        || !numericValue->equals(*CSSIdentifierValue::createIdentifier(CSSValueNormal)))
         return nullptr;
 
-    CSSPrimitiveValue* capsValue = valueForFontVariantCaps(style);
-    if (!capsValue->equals(*CSSPrimitiveValue::createIdentifier(CSSValueNormal))
-        && !capsValue->equals(*CSSPrimitiveValue::createIdentifier(CSSValueSmallCaps)))
+    CSSIdentifierValue* capsValue = valueForFontVariantCaps(style);
+    if (capsValue->getValueID() != CSSValueNormal
+        && capsValue->getValueID() != CSSValueSmallCaps)
         return nullptr;
     list->append(*capsValue);
 
     list->append(*valueForFontWeight(style));
     list->append(*valueForFontStretch(style));
     list->append(*sizeAndLineHeight);
     list->append(*valueForFontFamily(style));
 
     return list;
 }
 
 static CSSValue* valueForScrollSnapDestination(const LengthPoint& destination, const ComputedStyle& style)
 {
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     list->append(*zoomAdjustedPixelValueForLength(destination.x(), style));
     list->append(*zoomAdjustedPixelValueForLength(destination.y(), style));
     return list;
 }
 
 static CSSValue* valueForScrollSnapPoints(const ScrollSnapPoints& points, const ComputedStyle& style)
 {
     if (points.hasRepeat) {
         CSSFunctionValue* repeat = CSSFunctionValue::create(CSSValueRepeat);
         repeat->append(*zoomAdjustedPixelValueForLength(points.repeatOffset, style));
         return repeat;
     }
 
-    return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+    return CSSIdentifierValue::createIdentifier(CSSValueNone);
 }
 
 static CSSValue* valueForScrollSnapCoordinate(const Vector<LengthPoint>& coordinates, const ComputedStyle& style)
 {
     if (coordinates.isEmpty())
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     CSSValueList* list = CSSValueList::createCommaSeparated();
 
     for (auto& coordinate : coordinates) {
         auto pair = CSSValueList::createSpaceSeparated();
         pair->append(*zoomAdjustedPixelValueForLength(coordinate.x(), style));
         pair->append(*zoomAdjustedPixelValueForLength(coordinate.y(), style));
         list->append(*pair);
     }
 
@@ skipping 80 matching lines @@
     case CSSPropertyBackgroundColor:
         return allowVisitedStyle ? CSSColorValue::create(style.visitedDependentColor(CSSPropertyBackgroundColor).rgb()) : currentColorOrValidColor(style, style.backgroundColor());
     case CSSPropertyBackgroundImage:
     case CSSPropertyWebkitMaskImage: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskImage ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next()) {
             if (currLayer->image())
                 list->append(*currLayer->image()->computedCSSValue());
             else
-                list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNone));
+                list->append(*CSSIdentifierValue::createIdentifier(CSSValueNone));
         }
         return list;
     }
     case CSSPropertyBackgroundSize:
     case CSSPropertyWebkitMaskSize: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskSize ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(*valueForFillSize(currLayer->size(), style));
         return list;
     }
     case CSSPropertyBackgroundRepeat:
     case CSSPropertyWebkitMaskRepeat: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskRepeat ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(*valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
         return list;
     }
     case CSSPropertyMaskSourceType: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         for (const FillLayer* currLayer = &style.maskLayers(); currLayer; currLayer = currLayer->next())
             list->append(*valueForFillSourceType(currLayer->maskSourceType()));
         return list;
     }
     case CSSPropertyWebkitMaskComposite: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskComposite ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
-            list->append(*CSSPrimitiveValue::create(currLayer->composite()));
+            list->append(*CSSIdentifierValue::create(currLayer->composite()));
         return list;
     }
     case CSSPropertyBackgroundAttachment: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         for (const FillLayer* currLayer = &style.backgroundLayers(); currLayer; currLayer = currLayer->next())
-            list->append(*CSSPrimitiveValue::create(currLayer->attachment()));
+            list->append(*CSSIdentifierValue::create(currLayer->attachment()));
         return list;
     }
     case CSSPropertyBackgroundClip:
     case CSSPropertyBackgroundOrigin:
     case CSSPropertyWebkitBackgroundClip:
     case CSSPropertyWebkitBackgroundOrigin:
     case CSSPropertyWebkitMaskClip:
     case CSSPropertyWebkitMaskOrigin: {
         bool isClip = propertyID == CSSPropertyBackgroundClip || propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyWebkitMaskClip;
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = (propertyID == CSSPropertyWebkitMaskClip || propertyID == CSSPropertyWebkitMaskOrigin) ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next()) {
             EFillBox box = isClip ? currLayer->clip() : currLayer->origin();
-            list->append(*CSSPrimitiveValue::create(box));
+            list->append(*CSSIdentifierValue::create(box));
         }
         return list;
     }
     case CSSPropertyBackgroundPosition:
     case CSSPropertyWebkitMaskPosition: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPosition ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(*createPositionListForLayer(propertyID, *currLayer, style));
         return list;
     }
     case CSSPropertyBackgroundPositionX:
     case CSSPropertyWebkitMaskPositionX: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionX ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(*zoomAdjustedPixelValueForLength(currLayer->xPosition(), style));
         return list;
     }
     case CSSPropertyBackgroundPositionY:
     case CSSPropertyWebkitMaskPositionY: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionY ? &style.maskLayers() : &style.backgroundLayers();
         for (; currLayer; currLayer = currLayer->next())
             list->append(*zoomAdjustedPixelValueForLength(currLayer->yPosition(), style));
         return list;
     }
     case CSSPropertyBorderCollapse:
         if (style.borderCollapse())
-            return CSSPrimitiveValue::createIdentifier(CSSValueCollapse);
-        return CSSPrimitiveValue::createIdentifier(CSSValueSeparate);
+            return CSSIdentifierValue::createIdentifier(CSSValueCollapse);
+        return CSSIdentifierValue::createIdentifier(CSSValueSeparate);
     case CSSPropertyBorderSpacing: {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(*zoomAdjustedPixelValue(style.horizontalBorderSpacing(), style));
         list->append(*zoomAdjustedPixelValue(style.verticalBorderSpacing(), style));
         return list;
     }
     case CSSPropertyWebkitBorderHorizontalSpacing:
         return zoomAdjustedPixelValue(style.horizontalBorderSpacing(), style);
     case CSSPropertyWebkitBorderVerticalSpacing:
         return zoomAdjustedPixelValue(style.verticalBorderSpacing(), style);
     case CSSPropertyBorderImageSource:
         if (style.borderImageSource())
             return style.borderImageSource()->computedCSSValue();
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyBorderTopColor:
         return allowVisitedStyle ? CSSColorValue::create(style.visitedDependentColor(CSSPropertyBorderTopColor).rgb()) : currentColorOrValidColor(style, style.borderTopColor());
     case CSSPropertyBorderRightColor:
         return allowVisitedStyle ? CSSColorValue::create(style.visitedDependentColor(CSSPropertyBorderRightColor).rgb()) : currentColorOrValidColor(style, style.borderRightColor());
     case CSSPropertyBorderBottomColor:
         return allowVisitedStyle ? CSSColorValue::create(style.visitedDependentColor(CSSPropertyBorderBottomColor).rgb()) : currentColorOrValidColor(style, style.borderBottomColor());
     case CSSPropertyBorderLeftColor:
         return allowVisitedStyle ? CSSColorValue::create(style.visitedDependentColor(CSSPropertyBorderLeftColor).rgb()) : currentColorOrValidColor(style, style.borderLeftColor());
     case CSSPropertyBorderTopStyle:
-        return CSSPrimitiveValue::create(style.borderTopStyle());
+        return CSSIdentifierValue::create(style.borderTopStyle());
     case CSSPropertyBorderRightStyle:
-        return CSSPrimitiveValue::create(style.borderRightStyle());
+        return CSSIdentifierValue::create(style.borderRightStyle());
     case CSSPropertyBorderBottomStyle:
-        return CSSPrimitiveValue::create(style.borderBottomStyle());
+        return CSSIdentifierValue::create(style.borderBottomStyle());
     case CSSPropertyBorderLeftStyle:
-        return CSSPrimitiveValue::create(style.borderLeftStyle());
+        return CSSIdentifierValue::create(style.borderLeftStyle());
     case CSSPropertyBorderTopWidth:
         return zoomAdjustedPixelValue(style.borderTopWidth(), style);
     case CSSPropertyBorderRightWidth:
         return zoomAdjustedPixelValue(style.borderRightWidth(), style);
     case CSSPropertyBorderBottomWidth:
         return zoomAdjustedPixelValue(style.borderBottomWidth(), style);
     case CSSPropertyBorderLeftWidth:
         return zoomAdjustedPixelValue(style.borderLeftWidth(), style);
     case CSSPropertyBottom:
         return valueForPositionOffset(style, CSSPropertyBottom, layoutObject);
     case CSSPropertyWebkitBoxAlign:
-        return CSSPrimitiveValue::create(style.boxAlign());
+        return CSSIdentifierValue::create(style.boxAlign());
     case CSSPropertyWebkitBoxDecorationBreak:
         if (style.boxDecorationBreak() == BoxDecorationBreakSlice)
-            return CSSPrimitiveValue::createIdentifier(CSSValueSlice);
-    return CSSPrimitiveValue::createIdentifier(CSSValueClone);
+            return CSSIdentifierValue::createIdentifier(CSSValueSlice);
+    return CSSIdentifierValue::createIdentifier(CSSValueClone);
     case CSSPropertyWebkitBoxDirection:
-        return CSSPrimitiveValue::create(style.boxDirection());
+        return CSSIdentifierValue::create(style.boxDirection());
     case CSSPropertyWebkitBoxFlex:
         return CSSPrimitiveValue::create(style.boxFlex(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyWebkitBoxFlexGroup:
         return CSSPrimitiveValue::create(style.boxFlexGroup(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyWebkitBoxLines:
-        return CSSPrimitiveValue::create(style.boxLines());
+        return CSSIdentifierValue::create(style.boxLines());
     case CSSPropertyWebkitBoxOrdinalGroup:
         return CSSPrimitiveValue::create(style.boxOrdinalGroup(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyWebkitBoxOrient:
-        return CSSPrimitiveValue::create(style.boxOrient());
+        return CSSIdentifierValue::create(style.boxOrient());
     case CSSPropertyWebkitBoxPack:
-        return CSSPrimitiveValue::create(style.boxPack());
+        return CSSIdentifierValue::create(style.boxPack());
     case CSSPropertyWebkitBoxReflect:
         return valueForReflection(style.boxReflect(), style);
     case CSSPropertyBoxShadow:
         return valueForShadowList(style.boxShadow(), style, true);
     case CSSPropertyCaptionSide:
-        return CSSPrimitiveValue::create(style.captionSide());
+        return CSSIdentifierValue::create(style.captionSide());
     case CSSPropertyClear:
-        return CSSPrimitiveValue::create(style.clear());
+        return CSSIdentifierValue::create(style.clear());
     case CSSPropertyColor:
         return CSSColorValue::create(allowVisitedStyle ? style.visitedDependentColor(CSSPropertyColor).rgb() : style.color().rgb());
     case CSSPropertyWebkitPrintColorAdjust:
-        return CSSPrimitiveValue::create(style.getPrintColorAdjust());
+        return CSSIdentifierValue::create(style.getPrintColorAdjust());
     case CSSPropertyColumnCount:
         if (style.hasAutoColumnCount())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
         return CSSPrimitiveValue::create(style.columnCount(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyColumnFill:
-        return CSSPrimitiveValue::create(style.getColumnFill());
+        return CSSIdentifierValue::create(style.getColumnFill());
     case CSSPropertyColumnGap:
         if (style.hasNormalColumnGap())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+            return CSSIdentifierValue::createIdentifier(CSSValueNormal);
         return zoomAdjustedPixelValue(style.columnGap(), style);
     case CSSPropertyColumnRuleColor:
         return allowVisitedStyle ? CSSColorValue::create(style.visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style, style.columnRuleColor());
     case CSSPropertyColumnRuleStyle:
-        return CSSPrimitiveValue::create(style.columnRuleStyle());
+        return CSSIdentifierValue::create(style.columnRuleStyle());
     case CSSPropertyColumnRuleWidth:
         return zoomAdjustedPixelValue(style.columnRuleWidth(), style);
     case CSSPropertyColumnSpan:
-        return CSSPrimitiveValue::createIdentifier(style.getColumnSpan() ? CSSValueAll : CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(style.getColumnSpan() ? CSSValueAll : CSSValueNone);
     case CSSPropertyWebkitColumnBreakAfter:
-        return CSSPrimitiveValue::create(mapToColumnBreakValue(style.breakAfter()));
+        return CSSIdentifierValue::create(mapToColumnBreakValue(style.breakAfter()));
     case CSSPropertyWebkitColumnBreakBefore:
-        return CSSPrimitiveValue::create(mapToColumnBreakValue(style.breakBefore()));
+        return CSSIdentifierValue::create(mapToColumnBreakValue(style.breakBefore()));
     case CSSPropertyWebkitColumnBreakInside:
-        return CSSPrimitiveValue::create(mapToColumnBreakValue(style.breakInside()));
+        return CSSIdentifierValue::create(mapToColumnBreakValue(style.breakInside()));
     case CSSPropertyColumnWidth:
         if (style.hasAutoColumnWidth())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
         return zoomAdjustedPixelValue(style.columnWidth(), style);
     case CSSPropertyTabSize:
         return CSSPrimitiveValue::create(
             style.getTabSize().getPixelSize(1.0), style.getTabSize().isSpaces() ? CSSPrimitiveValue::UnitType::Number : CSSPrimitiveValue::UnitType::Pixels);
     case CSSPropertyTextSizeAdjust:
         if (style.getTextSizeAdjust().isAuto())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
         return CSSPrimitiveValue::create(style.getTextSizeAdjust().multiplier() * 100, CSSPrimitiveValue::UnitType::Percentage);
     case CSSPropertyCursor: {
         CSSValueList* list = nullptr;
         CursorList* cursors = style.cursors();
         if (cursors && cursors->size() > 0) {
             list = CSSValueList::createCommaSeparated();
             for (unsigned i = 0; i < cursors->size(); ++i) {
                 if (StyleImage* image = cursors->at(i).image())
                     list->append(*CSSCursorImageValue::create(image->computedCSSValue(), cursors->at(i).hotSpotSpecified(), cursors->at(i).hotSpot()));
             }
         }
-        CSSValue* value = CSSPrimitiveValue::create(style.cursor());
+        CSSValue* value = CSSIdentifierValue::create(style.cursor());
         if (list) {
             list->append(*value);
             return list;
         }
         return value;
     }
     case CSSPropertyDirection:
-        return CSSPrimitiveValue::create(style.direction());
+        return CSSIdentifierValue::create(style.direction());
     case CSSPropertyDisplay:
-        return CSSPrimitiveValue::create(style.display());
+        return CSSIdentifierValue::create(style.display());
     case CSSPropertyEmptyCells:
-        return CSSPrimitiveValue::create(style.emptyCells());
+        return CSSIdentifierValue::create(style.emptyCells());
     case CSSPropertyAlignContent:
         return valueForContentPositionAndDistributionWithOverflowAlignment(style.alignContent());
     case CSSPropertyAlignItems:
         return valueForItemPositionWithOverflowAlignment(style.alignItems());
     case CSSPropertyAlignSelf:
         return valueForItemPositionWithOverflowAlignment(style.alignSelf());
     case CSSPropertyFlex:
         return valuesForShorthandProperty(flexShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyFlexBasis:
         return zoomAdjustedPixelValueForLength(style.flexBasis(), style);
     case CSSPropertyFlexDirection:
-        return CSSPrimitiveValue::create(style.flexDirection());
+        return CSSIdentifierValue::create(style.flexDirection());
     case CSSPropertyFlexFlow:
         return valuesForShorthandProperty(flexFlowShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyFlexGrow:
         return CSSPrimitiveValue::create(style.flexGrow(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyFlexShrink:
         return CSSPrimitiveValue::create(style.flexShrink(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyFlexWrap:
-        return CSSPrimitiveValue::create(style.flexWrap());
+        return CSSIdentifierValue::create(style.flexWrap());
     case CSSPropertyJustifyContent:
         return valueForContentPositionAndDistributionWithOverflowAlignment(style.justifyContent());
     case CSSPropertyOrder:
         return CSSPrimitiveValue::create(style.order(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyFloat:
         if (style.display() != NONE && style.hasOutOfFlowPosition())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
-        return CSSPrimitiveValue::create(style.floating());
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::create(style.floating());
     case CSSPropertyFont:
         return valueForFont(style);
     case CSSPropertyFontFamily:
         return valueForFontFamily(style);
     case CSSPropertyFontSize:
         return valueForFontSize(style);
     case CSSPropertyFontSizeAdjust:
         if (style.hasFontSizeAdjust())
             return CSSPrimitiveValue::create(style.fontSizeAdjust(), CSSPrimitiveValue::UnitType::Number);
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyFontStretch:
         return valueForFontStretch(style);
     case CSSPropertyFontStyle:
         return valueForFontStyle(style);
     case CSSPropertyFontVariant:
         return valuesForFontVariantProperty(style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyFontWeight:
         return valueForFontWeight(style);
     case CSSPropertyFontFeatureSettings: {
         const FontFeatureSettings* featureSettings = style.getFontDescription().featureSettings();
         if (!featureSettings || !featureSettings->size())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+            return CSSIdentifierValue::createIdentifier(CSSValueNormal);
         CSSValueList* list = CSSValueList::createCommaSeparated();
         for (unsigned i = 0; i < featureSettings->size(); ++i) {
             const FontFeature& feature = featureSettings->at(i);
             CSSFontFeatureValue* featureValue = CSSFontFeatureValue::create(feature.tag(), feature.value());
             list->append(*featureValue);
         }
         return list;
     }
     case CSSPropertyGridAutoFlow: {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         switch (style.getGridAutoFlow()) {
         case AutoFlowRow:
         case AutoFlowRowDense:
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueRow));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueRow));
             break;
         case AutoFlowColumn:
         case AutoFlowColumnDense:
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueColumn));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueColumn));
             break;
         default:
             ASSERT_NOT_REACHED();
         }
 
         switch (style.getGridAutoFlow()) {
         case AutoFlowRowDense:
         case AutoFlowColumnDense:
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueDense));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueDense));
             break;
         default:
             // Do nothing.
             break;
         }
 
         return list;
     }
     // Specs mention that getComputedStyle() should return the used value of the property instead of the computed
     // one for grid-template-{rows|columns} but not for the grid-auto-{rows|columns} as things like
@@ skipping 24 matching lines @@
         return valuesForGridShorthand(gridRowShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGridArea:
         return valuesForGridShorthand(gridAreaShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGridTemplate:
         return valuesForGridShorthand(gridTemplateShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGrid:
         return valuesForGridShorthand(gridShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGridTemplateAreas:
         if (!style.namedGridAreaRowCount()) {
             ASSERT(!style.namedGridAreaColumnCount());
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         }
 
         return CSSGridTemplateAreasValue::create(style.namedGridArea(), style.namedGridAreaRowCount(), style.namedGridAreaColumnCount());
     case CSSPropertyGridColumnGap:
         return zoomAdjustedPixelValueForLength(style.gridColumnGap(), style);
     case CSSPropertyGridRowGap:
         return zoomAdjustedPixelValueForLength(style.gridRowGap(), style);
     case CSSPropertyGridGap:
         return valuesForShorthandProperty(gridGapShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
 
     case CSSPropertyHeight:
         if (layoutObject) {
             // According to http://www.w3.org/TR/CSS2/visudet.html#the-height-property,
             // the "height" property does not apply for non-atomic inline elements.
             if (!layoutObject->isAtomicInlineLevel() && layoutObject->isInline())
-                return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+                return CSSIdentifierValue::createIdentifier(CSSValueAuto);
             return zoomAdjustedPixelValue(sizingBox(layoutObject).height(), style);
         }
         return zoomAdjustedPixelValueForLength(style.height(), style);
     case CSSPropertyWebkitHighlight:
         if (style.highlight() == nullAtom)
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         return CSSStringValue::create(style.highlight());
     case CSSPropertyHyphens:
-        return CSSPrimitiveValue::create(style.getHyphens());
+        return CSSIdentifierValue::create(style.getHyphens());
     case CSSPropertyWebkitHyphenateCharacter:
         if (style.hyphenationString().isNull())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
         return CSSStringValue::create(style.hyphenationString());
     case CSSPropertyImageRendering:
-        return CSSPrimitiveValue::create(style.imageRendering());
+        return CSSIdentifierValue::create(style.imageRendering());
     case CSSPropertyImageOrientation:
         if (style.respectImageOrientation() == RespectImageOrientation)
-            return CSSPrimitiveValue::createIdentifier(CSSValueFromImage);
+            return CSSIdentifierValue::createIdentifier(CSSValueFromImage);
         return CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Degrees);
     case CSSPropertyIsolation:
-        return CSSPrimitiveValue::create(style.isolation());
+        return CSSIdentifierValue::create(style.isolation());
     case CSSPropertyJustifyItems:
         return valueForItemPositionWithOverflowAlignment(style.justifyItems());
     case CSSPropertyJustifySelf:
         return valueForItemPositionWithOverflowAlignment(style.justifySelf());
     case CSSPropertyLeft:
         return valueForPositionOffset(style, CSSPropertyLeft, layoutObject);
     case CSSPropertyLetterSpacing:
         if (!style.letterSpacing())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNormal);
+            return CSSIdentifierValue::createIdentifier(CSSValueNormal);
         return zoomAdjustedPixelValue(style.letterSpacing(), style);
     case CSSPropertyWebkitLineClamp:
         if (style.lineClamp().isNone())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         return CSSPrimitiveValue::create(style.lineClamp().value(), style.lineClamp().isPercentage() ? CSSPrimitiveValue::UnitType::Percentage : CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyLineHeight:
         return valueForLineHeight(style);
     case CSSPropertyListStyleImage:
         if (style.listStyleImage())
             return style.listStyleImage()->computedCSSValue();
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyListStylePosition:
-        return CSSPrimitiveValue::create(style.listStylePosition());
+        return CSSIdentifierValue::create(style.listStylePosition());
     case CSSPropertyListStyleType:
-        return CSSPrimitiveValue::create(style.listStyleType());
+        return CSSIdentifierValue::create(style.listStyleType());
     case CSSPropertyWebkitLocale:
         if (style.locale().isNull())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
         return CSSStringValue::create(style.locale());
     case CSSPropertyMarginTop: {
         Length marginTop = style.marginTop();
         if (marginTop.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginTop, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginTop(), style);
     }
     case CSSPropertyMarginRight: {
         Length marginRight = style.marginRight();
         if (marginRight.isFixed() || !layoutObject || !layoutObject->isBox())
@@ skipping 15 matching lines @@
             return zoomAdjustedPixelValueForLength(marginBottom, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginBottom(), style);
     }
     case CSSPropertyMarginLeft: {
         Length marginLeft = style.marginLeft();
         if (marginLeft.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginLeft, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginLeft(), style);
     }
     case CSSPropertyWebkitUserModify:
-        return CSSPrimitiveValue::create(style.userModify());
+        return CSSIdentifierValue::create(style.userModify());
     case CSSPropertyMaxHeight: {
         const Length& maxHeight = style.maxHeight();
         if (maxHeight.isMaxSizeNone())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         return zoomAdjustedPixelValueForLength(maxHeight, style);
     }
     case CSSPropertyMaxWidth: {
         const Length& maxWidth = style.maxWidth();
         if (maxWidth.isMaxSizeNone())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         return zoomAdjustedPixelValueForLength(maxWidth, style);
     }
     case CSSPropertyMinHeight:
         if (style.minHeight().isAuto()) {
             Node* parent = styledNode->parentNode();
             if (isFlexOrGrid(parent ? parent->ensureComputedStyle() : nullptr))
-                return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+                return CSSIdentifierValue::createIdentifier(CSSValueAuto);
             return zoomAdjustedPixelValue(0, style);
         }
         return zoomAdjustedPixelValueForLength(style.minHeight(), style);
     case CSSPropertyMinWidth:
         if (style.minWidth().isAuto()) {
             Node* parent = styledNode->parentNode();
             if (isFlexOrGrid(parent ? parent->ensureComputedStyle() : nullptr))
-                return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+                return CSSIdentifierValue::createIdentifier(CSSValueAuto);
             return zoomAdjustedPixelValue(0, style);
         }
         return zoomAdjustedPixelValueForLength(style.minWidth(), style);
     case CSSPropertyObjectFit:
-        return CSSPrimitiveValue::create(style.getObjectFit());
+        return CSSIdentifierValue::create(style.getObjectFit());
     case CSSPropertyObjectPosition:
         return CSSValuePair::create(
             zoomAdjustedPixelValueForLength(style.objectPosition().x(), style),
             zoomAdjustedPixelValueForLength(style.objectPosition().y(), style),
             CSSValuePair::KeepIdenticalValues);
     case CSSPropertyOpacity:
         return CSSPrimitiveValue::create(style.opacity(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyOrphans:
         return CSSPrimitiveValue::create(style.orphans(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyOutlineColor:
         return allowVisitedStyle ? CSSColorValue::create(style.visitedDependentColor(CSSPropertyOutlineColor).rgb()) : currentColorOrValidColor(style, style.outlineColor());
     case CSSPropertyOutlineOffset:
         return zoomAdjustedPixelValue(style.outlineOffset(), style);
     case CSSPropertyOutlineStyle:
         if (style.outlineStyleIsAuto())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
-        return CSSPrimitiveValue::create(style.outlineStyle());
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
+        return CSSIdentifierValue::create(style.outlineStyle());
     case CSSPropertyOutlineWidth:
         return zoomAdjustedPixelValue(style.outlineWidth(), style);
     case CSSPropertyOverflow:
-        return CSSPrimitiveValue::create(max(style.overflowX(), style.overflowY()));
+        return CSSIdentifierValue::create(max(style.overflowX(), style.overflowY()));
     case CSSPropertyOverflowAnchor:
-        return CSSPrimitiveValue::create(style.overflowAnchor());
+        return CSSIdentifierValue::create(style.overflowAnchor());
     case CSSPropertyOverflowWrap:
-        return CSSPrimitiveValue::create(style.overflowWrap());
+        return CSSIdentifierValue::create(style.overflowWrap());
     case CSSPropertyOverflowX:
-        return CSSPrimitiveValue::create(style.overflowX());
+        return CSSIdentifierValue::create(style.overflowX());
     case CSSPropertyOverflowY:
-        return CSSPrimitiveValue::create(style.overflowY());
+        return CSSIdentifierValue::create(style.overflowY());
     case CSSPropertyPaddingTop: {
         Length paddingTop = style.paddingTop();
         if (paddingTop.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingTop, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingTop(), style);
     }
     case CSSPropertyPaddingRight: {
         Length paddingRight = style.paddingRight();
         if (paddingRight.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingRight, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingRight(), style);
     }
     case CSSPropertyPaddingBottom: {
         Length paddingBottom = style.paddingBottom();
         if (paddingBottom.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingBottom, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingBottom(), style);
     }
     case CSSPropertyPaddingLeft: {
         Length paddingLeft = style.paddingLeft();
         if (paddingLeft.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingLeft, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingLeft(), style);
     }
     case CSSPropertyBreakAfter:
-        return CSSPrimitiveValue::create(style.breakAfter());
+        return CSSIdentifierValue::create(style.breakAfter());
     case CSSPropertyBreakBefore:
-        return CSSPrimitiveValue::create(style.breakBefore());
+        return CSSIdentifierValue::create(style.breakBefore());
     case CSSPropertyBreakInside:
-        return CSSPrimitiveValue::create(style.breakInside());
+        return CSSIdentifierValue::create(style.breakInside());
     case CSSPropertyPageBreakAfter:
-        return CSSPrimitiveValue::create(mapToPageBreakValue(style.breakAfter()));
+        return CSSIdentifierValue::create(mapToPageBreakValue(style.breakAfter()));
     case CSSPropertyPageBreakBefore:
-        return CSSPrimitiveValue::create(mapToPageBreakValue(style.breakBefore()));
+        return CSSIdentifierValue::create(mapToPageBreakValue(style.breakBefore()));
     case CSSPropertyPageBreakInside:
-        return CSSPrimitiveValue::create(mapToPageBreakValue(style.breakInside()));
+        return CSSIdentifierValue::create(mapToPageBreakValue(style.breakInside()));
     case CSSPropertyPosition:
-        return CSSPrimitiveValue::create(style.position());
+        return CSSIdentifierValue::create(style.position());
     case CSSPropertyQuotes:
         if (!style.quotes()) {
             // TODO(ramya.v): We should return the quote values that we're actually using.
             return nullptr;
         }
         if (style.quotes()->size()) {
             CSSValueList* list = CSSValueList::createSpaceSeparated();
             for (int i = 0; i < style.quotes()->size(); i++) {
                 list->append(*CSSStringValue::create(style.quotes()->getOpenQuote(i)));
                 list->append(*CSSStringValue::create(style.quotes()->getCloseQuote(i)));
             }
             return list;
         }
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyRight:
         return valueForPositionOffset(style, CSSPropertyRight, layoutObject);
     case CSSPropertyWebkitRubyPosition:
-        return CSSPrimitiveValue::create(style.getRubyPosition());
+        return CSSIdentifierValue::create(style.getRubyPosition());
     case CSSPropertyScrollBehavior:
-        return CSSPrimitiveValue::create(style.getScrollBehavior());
+        return CSSIdentifierValue::create(style.getScrollBehavior());
     case CSSPropertyTableLayout:
-        return CSSPrimitiveValue::create(style.tableLayout());
+        return CSSIdentifierValue::create(style.tableLayout());
     case CSSPropertyTextAlign:
-        return CSSPrimitiveValue::create(style.textAlign());
+        return CSSIdentifierValue::create(style.textAlign());
     case CSSPropertyTextAlignLast:
-        return CSSPrimitiveValue::create(style.getTextAlignLast());
+        return CSSIdentifierValue::create(style.getTextAlignLast());
     case CSSPropertyTextDecoration:
         if (RuntimeEnabledFeatures::css3TextDecorationsEnabled())
             return valuesForShorthandProperty(textDecorationShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
         // Fall through.
     case CSSPropertyTextDecorationLine:
         return renderTextDecorationFlagsToCSSValue(style.getTextDecoration());
     case CSSPropertyTextDecorationStyle:
         return valueForTextDecorationStyle(style.getTextDecorationStyle());
     case CSSPropertyTextDecorationColor:
         return currentColorOrValidColor(style, style.textDecorationColor());
     case CSSPropertyTextJustify:
-        return CSSPrimitiveValue::create(style.getTextJustify());
+        return CSSIdentifierValue::create(style.getTextJustify());
     case CSSPropertyTextUnderlinePosition:
-        return CSSPrimitiveValue::create(style.getTextUnderlinePosition());
+        return CSSIdentifierValue::create(style.getTextUnderlinePosition());
     case CSSPropertyWebkitTextDecorationsInEffect:
         return renderTextDecorationFlagsToCSSValue(style.textDecorationsInEffect());
     case CSSPropertyWebkitTextFillColor:
         return currentColorOrValidColor(style, style.textFillColor());
     case CSSPropertyWebkitTextEmphasisColor:
         return currentColorOrValidColor(style, style.textEmphasisColor());
     case CSSPropertyWebkitTextEmphasisPosition:
-        return CSSPrimitiveValue::create(style.getTextEmphasisPosition());
+        return CSSIdentifierValue::create(style.getTextEmphasisPosition());
     case CSSPropertyWebkitTextEmphasisStyle:
         switch (style.getTextEmphasisMark()) {
         case TextEmphasisMarkNone:
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         case TextEmphasisMarkCustom:
             return CSSStringValue::create(style.textEmphasisCustomMark());
         case TextEmphasisMarkAuto:
             ASSERT_NOT_REACHED();
             // Fall through
         case TextEmphasisMarkDot:
         case TextEmphasisMarkCircle:
         case TextEmphasisMarkDoubleCircle:
         case TextEmphasisMarkTriangle:
         case TextEmphasisMarkSesame: {
             CSSValueList* list = CSSValueList::createSpaceSeparated();
-            list->append(*CSSPrimitiveValue::create(style.getTextEmphasisFill()));
-            list->append(*CSSPrimitiveValue::create(style.getTextEmphasisMark()));
+            list->append(*CSSIdentifierValue::create(style.getTextEmphasisFill()));
+            list->append(*CSSIdentifierValue::create(style.getTextEmphasisMark()));
             return list;
         }
         }
     case CSSPropertyTextIndent: {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(*zoomAdjustedPixelValueForLength(style.textIndent(), style));
         if (RuntimeEnabledFeatures::css3TextEnabled() && (style.getTextIndentLine() == TextIndentEachLine || style.getTextIndentType() == TextIndentHanging)) {
             if (style.getTextIndentLine() == TextIndentEachLine)
-                list->append(*CSSPrimitiveValue::createIdentifier(CSSValueEachLine));
+                list->append(*CSSIdentifierValue::createIdentifier(CSSValueEachLine));
             if (style.getTextIndentType() == TextIndentHanging)
-                list->append(*CSSPrimitiveValue::createIdentifier(CSSValueHanging));
+                list->append(*CSSIdentifierValue::createIdentifier(CSSValueHanging));
         }
         return list;
     }
     case CSSPropertyTextShadow:
         return valueForShadowList(style.textShadow(), style, false);
     case CSSPropertyTextRendering:
-        return CSSPrimitiveValue::create(style.getFontDescription().textRendering());
+        return CSSIdentifierValue::create(style.getFontDescription().textRendering());
     case CSSPropertyTextOverflow:
         if (style.getTextOverflow())
-            return CSSPrimitiveValue::createIdentifier(CSSValueEllipsis);
-        return CSSPrimitiveValue::createIdentifier(CSSValueClip);
+            return CSSIdentifierValue::createIdentifier(CSSValueEllipsis);
+        return CSSIdentifierValue::createIdentifier(CSSValueClip);
     case CSSPropertyWebkitTextSecurity:
-        return CSSPrimitiveValue::create(style.textSecurity());
+        return CSSIdentifierValue::create(style.textSecurity());
     case CSSPropertyWebkitTextStrokeColor:
         return currentColorOrValidColor(style, style.textStrokeColor());
     case CSSPropertyWebkitTextStrokeWidth:
         return zoomAdjustedPixelValue(style.textStrokeWidth(), style);
     case CSSPropertyTextTransform:
-        return CSSPrimitiveValue::create(style.textTransform());
+        return CSSIdentifierValue::create(style.textTransform());
     case CSSPropertyTop:
         return valueForPositionOffset(style, CSSPropertyTop, layoutObject);
     case CSSPropertyTouchAction:
         return touchActionFlagsToCSSValue(style.getTouchAction());
     case CSSPropertyUnicodeBidi:
-        return CSSPrimitiveValue::create(style.unicodeBidi());
+        return CSSIdentifierValue::create(style.unicodeBidi());
     case CSSPropertyVerticalAlign:
         switch (style.verticalAlign()) {
         case VerticalAlignBaseline:
-            return CSSPrimitiveValue::createIdentifier(CSSValueBaseline);
+            return CSSIdentifierValue::createIdentifier(CSSValueBaseline);
         case VerticalAlignMiddle:
-            return CSSPrimitiveValue::createIdentifier(CSSValueMiddle);
+            return CSSIdentifierValue::createIdentifier(CSSValueMiddle);
         case VerticalAlignSub:
-            return CSSPrimitiveValue::createIdentifier(CSSValueSub);
+            return CSSIdentifierValue::createIdentifier(CSSValueSub);
         case VerticalAlignSuper:
-            return CSSPrimitiveValue::createIdentifier(CSSValueSuper);
+            return CSSIdentifierValue::createIdentifier(CSSValueSuper);
         case VerticalAlignTextTop:
-            return CSSPrimitiveValue::createIdentifier(CSSValueTextTop);
+            return CSSIdentifierValue::createIdentifier(CSSValueTextTop);
         case VerticalAlignTextBottom:
-            return CSSPrimitiveValue::createIdentifier(CSSValueTextBottom);
+            return CSSIdentifierValue::createIdentifier(CSSValueTextBottom);
         case VerticalAlignTop:
-            return CSSPrimitiveValue::createIdentifier(CSSValueTop);
+            return CSSIdentifierValue::createIdentifier(CSSValueTop);
         case VerticalAlignBottom:
-            return CSSPrimitiveValue::createIdentifier(CSSValueBottom);
+            return CSSIdentifierValue::createIdentifier(CSSValueBottom);
         case VerticalAlignBaselineMiddle:
-            return CSSPrimitiveValue::createIdentifier(CSSValueWebkitBaselineMiddle);
+            return CSSIdentifierValue::createIdentifier(CSSValueWebkitBaselineMiddle);
         case VerticalAlignLength:
             return zoomAdjustedPixelValueForLength(style.getVerticalAlignLength(), style);
         }
         ASSERT_NOT_REACHED();
         return nullptr;
     case CSSPropertyVisibility:
-        return CSSPrimitiveValue::create(style.visibility());
+        return CSSIdentifierValue::create(style.visibility());
     case CSSPropertyWhiteSpace:
-        return CSSPrimitiveValue::create(style.whiteSpace());
+        return CSSIdentifierValue::create(style.whiteSpace());
     case CSSPropertyWidows:
         return CSSPrimitiveValue::create(style.widows(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyWidth:
         if (layoutObject) {
             // According to http://www.w3.org/TR/CSS2/visudet.html#the-width-property,
             // the "width" property does not apply for non-atomic inline elements.
             if (!layoutObject->isAtomicInlineLevel() && layoutObject->isInline())
-                return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+                return CSSIdentifierValue::createIdentifier(CSSValueAuto);
             return zoomAdjustedPixelValue(sizingBox(layoutObject).width(), style);
         }
         return zoomAdjustedPixelValueForLength(style.width(), style);
     case CSSPropertyWillChange:
         return valueForWillChange(style.willChangeProperties(), style.willChangeContents(), style.willChangeScrollPosition());
     case CSSPropertyWordBreak:
-        return CSSPrimitiveValue::create(style.wordBreak());
+        return CSSIdentifierValue::create(style.wordBreak());
     case CSSPropertyWordSpacing:
         return zoomAdjustedPixelValue(style.wordSpacing(), style);
     case CSSPropertyWordWrap:
-        return CSSPrimitiveValue::create(style.overflowWrap());
+        return CSSIdentifierValue::create(style.overflowWrap());
     case CSSPropertyWebkitLineBreak:
-        return CSSPrimitiveValue::create(style.getLineBreak());
+        return CSSIdentifierValue::create(style.getLineBreak());
     case CSSPropertyResize:
-        return CSSPrimitiveValue::create(style.resize());
+        return CSSIdentifierValue::create(style.resize());
     case CSSPropertyFontKerning:
-        return CSSPrimitiveValue::create(style.getFontDescription().getKerning());
+        return CSSIdentifierValue::create(style.getFontDescription().getKerning());
     case CSSPropertyWebkitFontSmoothing:
-        return CSSPrimitiveValue::create(style.getFontDescription().fontSmoothing());
+        return CSSIdentifierValue::create(style.getFontDescription().fontSmoothing());
     case CSSPropertyFontVariantLigatures:
         return valueForFontVariantLigatures(style);
     case CSSPropertyFontVariantCaps:
         return valueForFontVariantCaps(style);
     case CSSPropertyFontVariantNumeric:
         return valueForFontVariantNumeric(style);
     case CSSPropertyZIndex:
         if (style.hasAutoZIndex())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
         return CSSPrimitiveValue::create(style.zIndex(), CSSPrimitiveValue::UnitType::Integer);
     case CSSPropertyZoom:
         return CSSPrimitiveValue::create(style.zoom(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyBoxSizing:
         if (style.boxSizing() == BoxSizingContentBox)
-            return CSSPrimitiveValue::createIdentifier(CSSValueContentBox);
-        return CSSPrimitiveValue::createIdentifier(CSSValueBorderBox);
+            return CSSIdentifierValue::createIdentifier(CSSValueContentBox);
+        return CSSIdentifierValue::createIdentifier(CSSValueBorderBox);
     case CSSPropertyWebkitAppRegion:
-        return CSSPrimitiveValue::createIdentifier(style.getDraggableRegionMode() == DraggableRegionDrag ? CSSValueDrag : CSSValueNoDrag);
+        return CSSIdentifierValue::createIdentifier(style.getDraggableRegionMode() == DraggableRegionDrag ? CSSValueDrag : CSSValueNoDrag);
     case CSSPropertyAnimationDelay:
         return valueForAnimationDelay(style.animations());
     case CSSPropertyAnimationDirection: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->directionList().size(); ++i)
                 list->append(*valueForAnimationDirection(animationData->directionList()[i]));
         } else {
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNormal));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueNormal));
         }
         return list;
     }
     case CSSPropertyAnimationDuration:
         return valueForAnimationDuration(style.animations());
     case CSSPropertyAnimationFillMode: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->fillModeList().size(); ++i)
                 list->append(*valueForAnimationFillMode(animationData->fillModeList()[i]));
         } else {
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNone));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueNone));
         }
         return list;
     }
     case CSSPropertyAnimationIterationCount: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->iterationCountList().size(); ++i)
                 list->append(*valueForAnimationIterationCount(animationData->iterationCountList()[i]));
         } else {
             list->append(*CSSPrimitiveValue::create(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::UnitType::Number));
         }
         return list;
     }
     case CSSPropertyAnimationName: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->nameList().size(); ++i)
                 list->append(*CSSCustomIdentValue::create(animationData->nameList()[i]));
         } else {
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNone));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueNone));
         }
         return list;
     }
     case CSSPropertyAnimationPlayState: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->playStateList().size(); ++i)
                 list->append(*valueForAnimationPlayState(animationData->playStateList()[i]));
         } else {
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueRunning));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueRunning));
         }
         return list;
     }
     case CSSPropertyAnimationTimingFunction:
         return valueForAnimationTimingFunction(style.animations());
     case CSSPropertyAnimation: {
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             CSSValueList* animationsList = CSSValueList::createCommaSeparated();
             for (size_t i = 0; i < animationData->nameList().size(); ++i) {
                 CSSValueList* list = CSSValueList::createSpaceSeparated();
                 list->append(*CSSCustomIdentValue::create(animationData->nameList()[i]));
                 list->append(*CSSPrimitiveValue::create(CSSTimingData::getRepeated(animationData->durationList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(*createTimingFunctionValue(CSSTimingData::getRepeated(animationData->timingFunctionList(), i).get()));
                 list->append(*CSSPrimitiveValue::create(CSSTimingData::getRepeated(animationData->delayList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(*valueForAnimationIterationCount(CSSTimingData::getRepeated(animationData->iterationCountList(), i)));
                 list->append(*valueForAnimationDirection(CSSTimingData::getRepeated(animationData->directionList(), i)));
                 list->append(*valueForAnimationFillMode(CSSTimingData::getRepeated(animationData->fillModeList(), i)));
                 list->append(*valueForAnimationPlayState(CSSTimingData::getRepeated(animationData->playStateList(), i)));
                 animationsList->append(*list);
             }
             return animationsList;
         }
 
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         // animation-name default value.
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueNone));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueNone));
         list->append(*CSSPrimitiveValue::create(CSSAnimationData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
         list->append(*createTimingFunctionValue(CSSAnimationData::initialTimingFunction().get()));
         list->append(*CSSPrimitiveValue::create(CSSAnimationData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
         list->append(*CSSPrimitiveValue::create(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::UnitType::Number));
         list->append(*valueForAnimationDirection(CSSAnimationData::initialDirection()));
         list->append(*valueForAnimationFillMode(CSSAnimationData::initialFillMode()));
         // Initial animation-play-state.
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueRunning));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueRunning));
         return list;
     }
     case CSSPropertyWebkitAppearance:
-        return CSSPrimitiveValue::create(style.appearance());
+        return CSSIdentifierValue::create(style.appearance());
     case CSSPropertyBackfaceVisibility:
-        return CSSPrimitiveValue::createIdentifier((style.backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
+        return CSSIdentifierValue::createIdentifier((style.backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
     case CSSPropertyWebkitBorderImage:
         return valueForNinePieceImage(style.borderImage(), style);
     case CSSPropertyBorderImageOutset:
         return valueForNinePieceImageQuad(style.borderImage().outset(), style);
     case CSSPropertyBorderImageRepeat:
         return valueForNinePieceImageRepeat(style.borderImage());
     case CSSPropertyBorderImageSlice:
         return valueForNinePieceImageSlice(style.borderImage());
     case CSSPropertyBorderImageWidth:
         return valueForNinePieceImageQuad(style.borderImage().borderSlices(), style);
     case CSSPropertyWebkitMaskBoxImage:
         return valueForNinePieceImage(style.maskBoxImage(), style);
     case CSSPropertyWebkitMaskBoxImageOutset:
         return valueForNinePieceImageQuad(style.maskBoxImage().outset(), style);
     case CSSPropertyWebkitMaskBoxImageRepeat:
         return valueForNinePieceImageRepeat(style.maskBoxImage());
     case CSSPropertyWebkitMaskBoxImageSlice:
         return valueForNinePieceImageSlice(style.maskBoxImage());
     case CSSPropertyWebkitMaskBoxImageWidth:
         return valueForNinePieceImageQuad(style.maskBoxImage().borderSlices(), style);
     case CSSPropertyWebkitMaskBoxImageSource:
         if (style.maskBoxImageSource())
             return style.maskBoxImageSource()->computedCSSValue();
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyWebkitFontSizeDelta:
         // Not a real style property -- used by the editing engine -- so has no computed value.
         return nullptr;
     case CSSPropertyWebkitMarginBottomCollapse:
     case CSSPropertyWebkitMarginAfterCollapse:
-        return CSSPrimitiveValue::create(style.marginAfterCollapse());
+        return CSSIdentifierValue::create(style.marginAfterCollapse());
     case CSSPropertyWebkitMarginTopCollapse:
     case CSSPropertyWebkitMarginBeforeCollapse:
-        return CSSPrimitiveValue::create(style.marginBeforeCollapse());
+        return CSSIdentifierValue::create(style.marginBeforeCollapse());
     case CSSPropertyPerspective:
         if (!style.hasPerspective())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         return zoomAdjustedPixelValue(style.perspective(), style);
     case CSSPropertyPerspectiveOrigin: {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (layoutObject) {
             LayoutRect box;
             if (layoutObject->isBox())
                 box = toLayoutBox(layoutObject)->borderBoxRect();
 
             list->append(*zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginX(), box.width()), style));
             list->append(*zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginY(), box.height()), style));
         } else {
             list->append(*zoomAdjustedPixelValueForLength(style.perspectiveOriginX(), style));
             list->append(*zoomAdjustedPixelValueForLength(style.perspectiveOriginY(), style));
         }
         return list;
     }
     case CSSPropertyWebkitRtlOrdering:
-        return CSSPrimitiveValue::createIdentifier(style.rtlOrdering() ? CSSValueVisual : CSSValueLogical);
+        return CSSIdentifierValue::createIdentifier(style.rtlOrdering() ? CSSValueVisual : CSSValueLogical);
     case CSSPropertyWebkitTapHighlightColor:
         return currentColorOrValidColor(style, style.tapHighlightColor());
     case CSSPropertyWebkitUserDrag:
-        return CSSPrimitiveValue::create(style.userDrag());
+        return CSSIdentifierValue::create(style.userDrag());
     case CSSPropertyUserSelect:
-        return CSSPrimitiveValue::create(style.userSelect());
+        return CSSIdentifierValue::create(style.userSelect());
     case CSSPropertyBorderBottomLeftRadius:
         return &valueForBorderRadiusCorner(style.borderBottomLeftRadius(), style);
     case CSSPropertyBorderBottomRightRadius:
         return &valueForBorderRadiusCorner(style.borderBottomRightRadius(), style);
     case CSSPropertyBorderTopLeftRadius:
         return &valueForBorderRadiusCorner(style.borderTopLeftRadius(), style);
     case CSSPropertyBorderTopRightRadius:
         return &valueForBorderRadiusCorner(style.borderTopRightRadius(), style);
     case CSSPropertyClip: {
         if (style.hasAutoClip())
-            return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
-        CSSPrimitiveValue* top = style.clip().top().isAuto()
-            ? CSSPrimitiveValue::createIdentifier(CSSValueAuto)
-            : zoomAdjustedPixelValue(style.clip().top().value(), style);
-        CSSPrimitiveValue* right = style.clip().right().isAuto()
-            ? CSSPrimitiveValue::createIdentifier(CSSValueAuto)
-            : zoomAdjustedPixelValue(style.clip().right().value(), style);
-        CSSPrimitiveValue* bottom = style.clip().bottom().isAuto()
-            ? CSSPrimitiveValue::createIdentifier(CSSValueAuto)
-            : zoomAdjustedPixelValue(style.clip().bottom().value(), style);
-        CSSPrimitiveValue* left = style.clip().left().isAuto()
-            ? CSSPrimitiveValue::createIdentifier(CSSValueAuto)
-            : zoomAdjustedPixelValue(style.clip().left().value(), style);
+            return CSSIdentifierValue::createIdentifier(CSSValueAuto);
+        CSSValue* top = zoomAdjustedPixelValueOrAuto(style.clip().top(), style);
+        CSSValue* right = zoomAdjustedPixelValueOrAuto(style.clip().right(), style);
+        CSSValue* bottom = zoomAdjustedPixelValueOrAuto(style.clip().bottom(), style);
+        CSSValue* left = zoomAdjustedPixelValueOrAuto(style.clip().left(), style);
         return CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsRect);
     }
     case CSSPropertySpeak:
-        return CSSPrimitiveValue::create(style.speak());
+        return CSSIdentifierValue::create(style.speak());
     case CSSPropertyTransform:
         return computedTransform(layoutObject, style);
     case CSSPropertyTransformOrigin: {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (layoutObject) {
             LayoutRect box;
             if (layoutObject->isBox())
                 box = toLayoutBox(layoutObject)->borderBoxRect();
 
             list->append(*zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginX(), box.width()), style));
             list->append(*zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginY(), box.height()), style));
             if (style.transformOriginZ() != 0)
                 list->append(*zoomAdjustedPixelValue(style.transformOriginZ(), style));
         } else {
             list->append(*zoomAdjustedPixelValueForLength(style.transformOriginX(), style));
             list->append(*zoomAdjustedPixelValueForLength(style.transformOriginY(), style));
             if (style.transformOriginZ() != 0)
                 list->append(*zoomAdjustedPixelValue(style.transformOriginZ(), style));
         }
         return list;
     }
     case CSSPropertyTransformStyle:
-        return CSSPrimitiveValue::createIdentifier((style.transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
+        return CSSIdentifierValue::createIdentifier((style.transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
     case CSSPropertyTransitionDelay:
         return valueForAnimationDelay(style.transitions());
     case CSSPropertyTransitionDuration:
         return valueForAnimationDuration(style.transitions());
     case CSSPropertyTransitionProperty:
         return valueForTransitionProperty(style.transitions());
     case CSSPropertyTransitionTimingFunction:
         return valueForAnimationTimingFunction(style.transitions());
     case CSSPropertyTransition: {
         const CSSTransitionData* transitionData = style.transitions();
         if (transitionData) {
             CSSValueList* transitionsList = CSSValueList::createCommaSeparated();
             for (size_t i = 0; i < transitionData->propertyList().size(); ++i) {
                 CSSValueList* list = CSSValueList::createSpaceSeparated();
                 list->append(*createTransitionPropertyValue(transitionData->propertyList()[i]));
                 list->append(*CSSPrimitiveValue::create(CSSTimingData::getRepeated(transitionData->durationList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(*createTimingFunctionValue(CSSTimingData::getRepeated(transitionData->timingFunctionList(), i).get()));
                 list->append(*CSSPrimitiveValue::create(CSSTimingData::getRepeated(transitionData->delayList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 transitionsList->append(*list);
             }
             return transitionsList;
         }
 
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         // transition-property default value.
-        list->append(*CSSPrimitiveValue::createIdentifier(CSSValueAll));
+        list->append(*CSSIdentifierValue::createIdentifier(CSSValueAll));
         list->append(*CSSPrimitiveValue::create(CSSTransitionData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
         list->append(*createTimingFunctionValue(CSSTransitionData::initialTimingFunction().get()));
         list->append(*CSSPrimitiveValue::create(CSSTransitionData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
         return list;
     }
     case CSSPropertyPointerEvents:
-        return CSSPrimitiveValue::create(style.pointerEvents());
+        return CSSIdentifierValue::create(style.pointerEvents());
     case CSSPropertyWritingMode:
     case CSSPropertyWebkitWritingMode:
-        return CSSPrimitiveValue::create(style.getWritingMode());
+        return CSSIdentifierValue::create(style.getWritingMode());
     case CSSPropertyWebkitTextCombine:
         if (style.getTextCombine() == TextCombineAll)
-            return CSSPrimitiveValue::createIdentifier(CSSValueHorizontal);
+            return CSSIdentifierValue::createIdentifier(CSSValueHorizontal);
     case CSSPropertyTextCombineUpright:
-        return CSSPrimitiveValue::create(style.getTextCombine());
+        return CSSIdentifierValue::create(style.getTextCombine());
     case CSSPropertyWebkitTextOrientation:
         if (style.getTextOrientation() == TextOrientationMixed)
-            return CSSPrimitiveValue::createIdentifier(CSSValueVerticalRight);
+            return CSSIdentifierValue::createIdentifier(CSSValueVerticalRight);
     case CSSPropertyTextOrientation:
-        return CSSPrimitiveValue::create(style.getTextOrientation());
+        return CSSIdentifierValue::create(style.getTextOrientation());
     case CSSPropertyContent:
         return valueForContentData(style);
     case CSSPropertyCounterIncrement:
         return valueForCounterDirectives(style, propertyID);
     case CSSPropertyCounterReset:
         return valueForCounterDirectives(style, propertyID);
     case CSSPropertyClipPath:
         if (ClipPathOperation* operation = style.clipPath()) {
             if (operation->type() == ClipPathOperation::SHAPE)
                 return valueForBasicShape(style, toShapeClipPathOperation(operation)->basicShape());
             if (operation->type() == ClipPathOperation::REFERENCE)
                 return CSSURIValue::create(toReferenceClipPathOperation(operation)->url());
         }
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyShapeMargin:
-        return CSSPrimitiveValue::create(style.shapeMargin(), style.effectiveZoom());
+        return CSSValue::create(style.shapeMargin(), style.effectiveZoom());
     case CSSPropertyShapeImageThreshold:
         return CSSPrimitiveValue::create(style.shapeImageThreshold(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyShapeOutside:
         return valueForShape(style, style.shapeOutside());
     case CSSPropertyFilter:
         return valueForFilter(style, style.filter());
     case CSSPropertyBackdropFilter:
         return valueForFilter(style, style.backdropFilter());
     case CSSPropertyMixBlendMode:
-        return CSSPrimitiveValue::create(style.blendMode());
+        return CSSIdentifierValue::create(style.blendMode());
 
     case CSSPropertyBackgroundBlendMode: {
         CSSValueList* list = CSSValueList::createCommaSeparated();
         for (const FillLayer* currLayer = &style.backgroundLayers(); currLayer; currLayer = currLayer->next())
-            list->append(*CSSPrimitiveValue::create(currLayer->blendMode()));
+            list->append(*CSSIdentifierValue::create(currLayer->blendMode()));
         return list;
     }
     case CSSPropertyBackground:
         return valuesForBackgroundShorthand(style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorder: {
         const CSSValue* value = get(CSSPropertyBorderTop, style, layoutObject, styledNode, allowVisitedStyle);
         const CSSPropertyID properties[] = {
             CSSPropertyBorderRight,
             CSSPropertyBorderBottom,
             CSSPropertyBorderLeft
@@ skipping 38 matching lines @@
     case CSSPropertyBackgroundRepeatX:
     case CSSPropertyBackgroundRepeatY:
         return nullptr;
 
     case CSSPropertyMotion:
         return valuesForShorthandProperty(motionShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
 
     case CSSPropertyMotionPath:
         if (const StylePath* styleMotionPath = style.motionPath())
             return styleMotionPath->computedCSSValue();
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
 
     case CSSPropertyMotionOffset:
         return zoomAdjustedPixelValueForLength(style.motionOffset(), style);
 
     case CSSPropertyMotionRotation: {
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (style.motionRotation().type == MotionRotationAuto)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueAuto));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueAuto));
         list->append(*CSSPrimitiveValue::create(style.motionRotation().angle, CSSPrimitiveValue::UnitType::Degrees));
         return list;
     }
 
     // Unimplemented CSS 3 properties (including CSS3 shorthand properties).
     case CSSPropertyWebkitTextEmphasis:
         return nullptr;
 
     // Directional properties are resolved by resolveDirectionAwareProperty() before the switch.
     case CSSPropertyWebkitBorderEnd:
@@ skipping 54 matching lines @@
 
     // @viewport rule properties.
     case CSSPropertyMaxZoom:
     case CSSPropertyMinZoom:
     case CSSPropertyOrientation:
     case CSSPropertyUserZoom:
         return nullptr;
 
     // SVG properties.
     case CSSPropertyClipRule:
-        return CSSPrimitiveValue::create(svgStyle.clipRule());
+        return CSSIdentifierValue::create(svgStyle.clipRule());
     case CSSPropertyFloodOpacity:
         return CSSPrimitiveValue::create(svgStyle.floodOpacity(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyStopOpacity:
         return CSSPrimitiveValue::create(svgStyle.stopOpacity(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyColorInterpolation:
-        return CSSPrimitiveValue::create(svgStyle.colorInterpolation());
+        return CSSIdentifierValue::create(svgStyle.colorInterpolation());
     case CSSPropertyColorInterpolationFilters:
-        return CSSPrimitiveValue::create(svgStyle.colorInterpolationFilters());
+        return CSSIdentifierValue::create(svgStyle.colorInterpolationFilters());
     case CSSPropertyFillOpacity:
         return CSSPrimitiveValue::create(svgStyle.fillOpacity(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyFillRule:
-        return CSSPrimitiveValue::create(svgStyle.fillRule());
+        return CSSIdentifierValue::create(svgStyle.fillRule());
     case CSSPropertyColorRendering:
-        return CSSPrimitiveValue::create(svgStyle.colorRendering());
+        return CSSIdentifierValue::create(svgStyle.colorRendering());
     case CSSPropertyShapeRendering:
-        return CSSPrimitiveValue::create(svgStyle.shapeRendering());
+        return CSSIdentifierValue::create(svgStyle.shapeRendering());
     case CSSPropertyStrokeLinecap:
-        return CSSPrimitiveValue::create(svgStyle.capStyle());
+        return CSSIdentifierValue::create(svgStyle.capStyle());
     case CSSPropertyStrokeLinejoin:
-        return CSSPrimitiveValue::create(svgStyle.joinStyle());
+        return CSSIdentifierValue::create(svgStyle.joinStyle());
     case CSSPropertyStrokeMiterlimit:
         return CSSPrimitiveValue::create(svgStyle.strokeMiterLimit(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyStrokeOpacity:
         return CSSPrimitiveValue::create(svgStyle.strokeOpacity(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyAlignmentBaseline:
-        return CSSPrimitiveValue::create(svgStyle.alignmentBaseline());
+        return CSSIdentifierValue::create(svgStyle.alignmentBaseline());
     case CSSPropertyDominantBaseline:
-        return CSSPrimitiveValue::create(svgStyle.dominantBaseline());
+        return CSSIdentifierValue::create(svgStyle.dominantBaseline());
     case CSSPropertyTextAnchor:
-        return CSSPrimitiveValue::create(svgStyle.textAnchor());
+        return CSSIdentifierValue::create(svgStyle.textAnchor());
     case CSSPropertyMask:
         if (!svgStyle.maskerResource().isEmpty())
             return CSSURIValue::create(serializeAsFragmentIdentifier(svgStyle.maskerResource()));
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyFloodColor:
         return currentColorOrValidColor(style, svgStyle.floodColor());
     case CSSPropertyLightingColor:
         return currentColorOrValidColor(style, svgStyle.lightingColor());
     case CSSPropertyStopColor:
         return currentColorOrValidColor(style, svgStyle.stopColor());
     case CSSPropertyFill:
         return adjustSVGPaintForCurrentColor(svgStyle.fillPaintType(), svgStyle.fillPaintUri(), svgStyle.fillPaintColor(), style.color());
     case CSSPropertyMarkerEnd:
         if (!svgStyle.markerEndResource().isEmpty())
             return CSSURIValue::create(serializeAsFragmentIdentifier(svgStyle.markerEndResource()));
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyMarkerMid:
         if (!svgStyle.markerMidResource().isEmpty())
             return CSSURIValue::create(serializeAsFragmentIdentifier(svgStyle.markerMidResource()));
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyMarkerStart:
         if (!svgStyle.markerStartResource().isEmpty())
             return CSSURIValue::create(serializeAsFragmentIdentifier(svgStyle.markerStartResource()));
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyStroke:
         return adjustSVGPaintForCurrentColor(svgStyle.strokePaintType(), svgStyle.strokePaintUri(), svgStyle.strokePaintColor(), style.color());
     case CSSPropertyStrokeDasharray:
         return strokeDashArrayToCSSValueList(*svgStyle.strokeDashArray(), style);
     case CSSPropertyStrokeDashoffset:
         return zoomAdjustedPixelValueForLength(svgStyle.strokeDashOffset(), style);
     case CSSPropertyStrokeWidth:
         return pixelValueForUnzoomedLength(svgStyle.strokeWidth(), style);
     case CSSPropertyBaselineShift: {
         switch (svgStyle.baselineShift()) {
         case BS_SUPER:
-            return CSSPrimitiveValue::createIdentifier(CSSValueSuper);
+            return CSSIdentifierValue::createIdentifier(CSSValueSuper);
         case BS_SUB:
-            return CSSPrimitiveValue::createIdentifier(CSSValueSub);
+            return CSSIdentifierValue::createIdentifier(CSSValueSub);
         case BS_LENGTH:
             return zoomAdjustedPixelValueForLength(svgStyle.baselineShiftValue(), style);
         }
         ASSERT_NOT_REACHED();
         return nullptr;
     }
     case CSSPropertyBufferedRendering:
-        return CSSPrimitiveValue::create(svgStyle.bufferedRendering());
+        return CSSIdentifierValue::create(svgStyle.bufferedRendering());
     case CSSPropertyPaintOrder:
         return paintOrderToCSSValueList(svgStyle);
     case CSSPropertyVectorEffect:
-        return CSSPrimitiveValue::create(svgStyle.vectorEffect());
+        return CSSIdentifierValue::create(svgStyle.vectorEffect());
     case CSSPropertyMaskType:
-        return CSSPrimitiveValue::create(svgStyle.maskType());
+        return CSSIdentifierValue::create(svgStyle.maskType());
     case CSSPropertyMarker:
         // the above properties are not yet implemented in the engine
         return nullptr;
     case CSSPropertyD:
         if (const StylePath* stylePath = svgStyle.d())
             return stylePath->computedCSSValue();
-        return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+        return CSSIdentifierValue::createIdentifier(CSSValueNone);
     case CSSPropertyCx:
         return zoomAdjustedPixelValueForLength(svgStyle.cx(), style);
     case CSSPropertyCy:
         return zoomAdjustedPixelValueForLength(svgStyle.cy(), style);
     case CSSPropertyX:
         return zoomAdjustedPixelValueForLength(svgStyle.x(), style);
     case CSSPropertyY:
         return zoomAdjustedPixelValueForLength(svgStyle.y(), style);
     case CSSPropertyR:
         return zoomAdjustedPixelValueForLength(svgStyle.r(), style);
     case CSSPropertyRx:
         return zoomAdjustedPixelValueForLength(svgStyle.rx(), style);
     case CSSPropertyRy:
         return zoomAdjustedPixelValueForLength(svgStyle.ry(), style);
     case CSSPropertyScrollSnapType:
-        return CSSPrimitiveValue::create(style.getScrollSnapType());
+        return CSSIdentifierValue::create(style.getScrollSnapType());
     case CSSPropertyScrollSnapPointsX:
         return valueForScrollSnapPoints(style.scrollSnapPointsX(), style);
     case CSSPropertyScrollSnapPointsY:
         return valueForScrollSnapPoints(style.scrollSnapPointsY(), style);
     case CSSPropertyScrollSnapCoordinate:
         return valueForScrollSnapCoordinate(style.scrollSnapCoordinate(), style);
     case CSSPropertyScrollSnapDestination:
         return valueForScrollSnapDestination(style.scrollSnapDestination(), style);
     case CSSPropertyTranslate: {
         if (!style.translate())
@@ skipping 40 matching lines @@
         list->append(*CSSPrimitiveValue::create(style.scale()->x(), CSSPrimitiveValue::UnitType::Number));
         if (style.scale()->y() == 1 && style.scale()->z() == 1)
             return list;
         list->append(*CSSPrimitiveValue::create(style.scale()->y(), CSSPrimitiveValue::UnitType::Number));
         if (style.scale()->z() != 1)
             list->append(*CSSPrimitiveValue::create(style.scale()->z(), CSSPrimitiveValue::UnitType::Number));
         return list;
     }
     case CSSPropertyContain: {
         if (!style.contain())
-            return CSSPrimitiveValue::createIdentifier(CSSValueNone);
+            return CSSIdentifierValue::createIdentifier(CSSValueNone);
         if (style.contain() == ContainsStrict)
-            return CSSPrimitiveValue::createIdentifier(CSSValueStrict);
+            return CSSIdentifierValue::createIdentifier(CSSValueStrict);
         if (style.contain() == ContainsContent)
-            return CSSPrimitiveValue::createIdentifier(CSSValueContent);
+            return CSSIdentifierValue::createIdentifier(CSSValueContent);
 
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         if (style.containsStyle())
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueStyle));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueStyle));
         if (style.contain() & ContainsLayout)
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueLayout));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueLayout));
         if (style.containsPaint())
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValuePaint));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValuePaint));
         if (style.containsSize())
-            list->append(*CSSPrimitiveValue::createIdentifier(CSSValueSize));
+            list->append(*CSSIdentifierValue::createIdentifier(CSSValueSize));
         ASSERT(list->length());
         return list;
     }
     case CSSPropertySnapHeight: {
         if (!style.snapHeightUnit())
             return CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Pixels);
         CSSValueList* list = CSSValueList::createSpaceSeparated();
         list->append(*CSSPrimitiveValue::create(style.snapHeightUnit(), CSSPrimitiveValue::UnitType::Pixels));
         if (style.snapHeightPosition())
             list->append(*CSSPrimitiveValue::create(style.snapHeightPosition(), CSSPrimitiveValue::UnitType::Integer));
         return list;
     }
     case CSSPropertyVariable:
         // Variables are retrieved via get(AtomicString).
         ASSERT_NOT_REACHED();
         return nullptr;
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 } // namespace blink