Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/Source/core/css/resolver/StyleBuilderConverter.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 17 matching lines @@
 
 #include "core/css/BasicShapeFunctions.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSFontFamilyValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridAutoRepeatValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPathValue.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/CSSURIValue.h"
 #include "core/css/CSSValuePair.h"
 #include "core/css/resolver/FilterOperationResolver.h"
 #include "core/frame/LocalFrame.h"
 #include "core/style/ClipPathOperation.h"
 #include "core/style/TextSizeAdjust.h"
 #include "core/svg/SVGURIReference.h"
 #include "platform/transforms/RotateTransformOperation.h"
 #include "platform/transforms/ScaleTransformOperation.h"
 #include "platform/transforms/TranslateTransformOperation.h"
 #include <algorithm>
 
 namespace blink {
 
 namespace {
 
-static GridLength convertGridTrackBreadth(const StyleResolverState& state, const CSSPrimitiveValue& primitiveValue)
+static GridLength convertGridTrackBreadth(const StyleResolverState& state, const CSSValue& value)
 {
-    if (primitiveValue.getValueID() == CSSValueMinContent)
+    // Fractional unit.
+    if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).isFlex())
+        return GridLength(toCSSPrimitiveValue(value).getDoubleValue());
+
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueMinContent)
         return Length(MinContent);
 
-    if (primitiveValue.getValueID() == CSSValueMaxContent)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueMaxContent)
         return Length(MaxContent);
 
-    // Fractional unit.
-    if (primitiveValue.isFlex())
-        return GridLength(primitiveValue.getDoubleValue());
-
-    return StyleBuilderConverter::convertLengthOrAuto(state, primitiveValue);
+    return StyleBuilderConverter::convertLengthOrAuto(state, value);
 }
 
 } // namespace
 
 PassRefPtr<StyleReflection> StyleBuilderConverter::convertBoxReflect(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue()) {
-        ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
         return ComputedStyle::initialBoxReflect();
     }
 
     const CSSReflectValue& reflectValue = toCSSReflectValue(value);
     RefPtr<StyleReflection> reflection = StyleReflection::create();
     reflection->setDirection(reflectValue.direction()->convertTo<CSSReflectionDirection>());
     if (reflectValue.offset())
         reflection->setOffset(reflectValue.offset()->convertToLength(state.cssToLengthConversionData()));
     if (reflectValue.mask()) {
         NinePieceImage mask;
@@ skipping 34 matching lines @@
     if (value.isURIValue()) {
         SVGURLReferenceResolver resolver(toCSSURIValue(value).value(), state.document());
         // If the reference is non-local, then the fragment will remain as a
         // null string, which makes the element lookup fail.
         AtomicString fragmentIdentifier;
         if (resolver.isLocal())
             fragmentIdentifier = resolver.fragmentIdentifier();
         // TODO(fs): Doesn't work with forward or external SVG references (crbug.com/391604, crbug.com/109212, ...)
         return ReferenceClipPathOperation::create(toCSSURIValue(value).value(), fragmentIdentifier);
     }
-    DCHECK(value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    DCHECK(value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueNone);
     return nullptr;
 }
 
 FilterOperations StyleBuilderConverter::convertFilterOperations(StyleResolverState& state, const CSSValue& value)
 {
     return FilterOperationResolver::createFilterOperations(state, value);
 }
 
 static FontDescription::GenericFamilyType convertGenericFamily(CSSValueID valueID)
 {
@@ skipping 17 matching lines @@
     }
 }
 
 static bool convertFontFamilyName(StyleResolverState& state, const CSSValue& value,
     FontDescription::GenericFamilyType& genericFamily, AtomicString& familyName)
 {
     if (value.isFontFamilyValue()) {
         genericFamily = FontDescription::NoFamily;
         familyName = AtomicString(toCSSFontFamilyValue(value).value());
     } else if (state.document().settings()) {
-        genericFamily = convertGenericFamily(toCSSPrimitiveValue(value).getValueID());
+        genericFamily = convertGenericFamily(toCSSIdentifierValue(value).getValueID());
         familyName = state.fontBuilder().genericFontFamilyName(genericFamily);
     }
 
     return !familyName.isEmpty();
 }
 
 FontDescription::FamilyDescription StyleBuilderConverter::convertFontFamily(StyleResolverState& state, const CSSValue& value)
 {
     ASSERT(value.isValueList());
 
@@ skipping 19 matching lines @@
 
         if (genericFamily != FontDescription::NoFamily)
             desc.genericFamily = genericFamily;
     }
 
     return desc;
 }
 
 PassRefPtr<FontFeatureSettings> StyleBuilderConverter::convertFontFeatureSettings(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueNormal)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueNormal)
         return FontBuilder::initialFeatureSettings();
 
     const CSSValueList& list = toCSSValueList(value);
     RefPtr<FontFeatureSettings> settings = FontFeatureSettings::create();
     int len = list.length();
     for (int i = 0; i < len; ++i) {
         const CSSFontFeatureValue& feature = toCSSFontFeatureValue(list.item(i));
         settings->append(FontFeature(feature.tag(), feature.value()));
     }
     return settings;
 }
 
 static float computeFontSize(StyleResolverState& state, const CSSPrimitiveValue& primitiveValue, const FontDescription::Size& parentSize)
 {
     if (primitiveValue.isLength())
         return primitiveValue.computeLength<float>(state.fontSizeConversionData());
     if (primitiveValue.isCalculatedPercentageWithLength())
         return primitiveValue.cssCalcValue()->toCalcValue(state.fontSizeConversionData())->evaluate(parentSize.value);
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 FontDescription::Size StyleBuilderConverter::convertFontSize(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-
     FontDescription::Size parentSize(0, 0.0f, false);
 
     // FIXME: Find out when parentStyle could be 0?
     if (state.parentStyle())
         parentSize = state.parentFontDescription().getSize();
 
-    if (CSSValueID valueID = primitiveValue.getValueID()) {
+    if (value.isIdentifierValue()) {
+        CSSValueID valueID = toCSSIdentifierValue(value).getValueID();
         if (FontSize::isValidValueID(valueID))
             return FontDescription::Size(FontSize::keywordSize(valueID), 0.0f, false);
         if (valueID == CSSValueSmaller)
             return FontDescription::smallerSize(parentSize);
         if (valueID == CSSValueLarger)
             return FontDescription::largerSize(parentSize);
         ASSERT_NOT_REACHED();
         return FontBuilder::initialSize();
     }
 
     bool parentIsAbsoluteSize = state.parentFontDescription().isAbsoluteSize();
 
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.isPercentage())
         return FontDescription::Size(0, (primitiveValue.getFloatValue() * parentSize.value / 100.0f), parentIsAbsoluteSize);
 
     return FontDescription::Size(0, computeFontSize(state, primitiveValue, parentSize), parentIsAbsoluteSize || !primitiveValue.isFontRelativeLength());
 }
 
 float StyleBuilderConverter::convertFontSizeAdjust(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.getValueID() == CSSValueNone)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueNone)
         return FontBuilder::initialSizeAdjust();
 
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     ASSERT(primitiveValue.isNumber());
     return primitiveValue.getFloatValue();
 }
 
 FontWeight StyleBuilderConverter::convertFontWeight(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    switch (primitiveValue.getValueID()) {
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    switch (identifierValue.getValueID()) {
     case CSSValueBolder:
         return FontDescription::bolderWeight(state.parentStyle()->getFontDescription().weight());
     case CSSValueLighter:
         return FontDescription::lighterWeight(state.parentStyle()->getFontDescription().weight());
     default:
-        return primitiveValue.convertTo<FontWeight>();
+        return identifierValue.convertTo<FontWeight>();
     }
 }
 
 FontDescription::FontVariantCaps StyleBuilderConverter::convertFontVariantCaps(StyleResolverState&, const CSSValue& value)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
-    CSSValueID valueID = toCSSPrimitiveValue(value).getValueID();
+    SECURITY_DCHECK(value.isIdentifierValue());
+    CSSValueID valueID = toCSSIdentifierValue(value).getValueID();
     switch (valueID) {
     case CSSValueNormal:
         return FontDescription::CapsNormal;
     case CSSValueSmallCaps:
         return FontDescription::SmallCaps;
     case CSSValueAllSmallCaps:
         return FontDescription::AllSmallCaps;
     case CSSValuePetiteCaps:
         return FontDescription::PetiteCaps;
     case CSSValueAllPetiteCaps:
         return FontDescription::AllPetiteCaps;
     case CSSValueUnicase:
         return FontDescription::Unicase;
     case CSSValueTitlingCaps:
         return FontDescription::TitlingCaps;
     default:
         return FontDescription::CapsNormal;
     }
 }
 
 FontDescription::VariantLigatures StyleBuilderConverter::convertFontVariantLigatures(StyleResolverState&, const CSSValue& value)
 {
     if (value.isValueList()) {
         FontDescription::VariantLigatures ligatures;
         const CSSValueList& valueList = toCSSValueList(value);
         for (size_t i = 0; i < valueList.length(); ++i) {
             const CSSValue& item = valueList.item(i);
-            const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(item);
-            switch (primitiveValue.getValueID()) {
+            switch (toCSSIdentifierValue(item).getValueID()) {
             case CSSValueNoCommonLigatures:
                 ligatures.common = FontDescription::DisabledLigaturesState;
                 break;
             case CSSValueCommonLigatures:
                 ligatures.common = FontDescription::EnabledLigaturesState;
                 break;
             case CSSValueNoDiscretionaryLigatures:
                 ligatures.discretionary = FontDescription::DisabledLigaturesState;
                 break;
             case CSSValueDiscretionaryLigatures:
@@ skipping 12 matching lines @@
                 ligatures.contextual = FontDescription::EnabledLigaturesState;
                 break;
             default:
                 ASSERT_NOT_REACHED();
                 break;
             }
         }
         return ligatures;
     }
 
-    ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
-
-    if (toCSSPrimitiveValue(value).getValueID() == CSSValueNone) {
+    SECURITY_DCHECK(value.isIdentifierValue());
+    if (toCSSIdentifierValue(value).getValueID() == CSSValueNone) {
         return FontDescription::VariantLigatures(FontDescription::DisabledLigaturesState);
     }
 
-    ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNormal);
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNormal);
     return FontDescription::VariantLigatures();
 }
 
 FontVariantNumeric StyleBuilderConverter::convertFontVariantNumeric(StyleResolverState&, const CSSValue& value)
 {
-    if (value.isPrimitiveValue()) {
-        ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNormal);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNormal);
         return FontVariantNumeric();
     }
 
     FontVariantNumeric variantNumeric;
     for (const CSSValue* feature : toCSSValueList(value)) {
-        switch (toCSSPrimitiveValue(feature)->getValueID()) {
+        switch (toCSSIdentifierValue(feature)->getValueID()) {
         case CSSValueLiningNums:
             variantNumeric.setNumericFigure(FontVariantNumeric::LiningNums);
             break;
         case CSSValueOldstyleNums:
             variantNumeric.setNumericFigure(FontVariantNumeric::OldstyleNums);
             break;
         case CSSValueProportionalNums:
             variantNumeric.setNumericSpacing(FontVariantNumeric::ProportionalNums);
             break;
         case CSSValueTabularNums:
@@ skipping 17 matching lines @@
         }
     }
     return variantNumeric;
 }
 
 StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignmentData(StyleResolverState&, const CSSValue& value)
 {
     StyleSelfAlignmentData alignmentData = ComputedStyle::initialSelfAlignment();
     if (value.isValuePair()) {
         const CSSValuePair& pair = toCSSValuePair(value);
-        if (toCSSPrimitiveValue(pair.first()).getValueID() == CSSValueLegacy) {
+        if (toCSSIdentifierValue(pair.first()).getValueID() == CSSValueLegacy) {
             alignmentData.setPositionType(LegacyPosition);
-            alignmentData.setPosition(toCSSPrimitiveValue(pair.second()).convertTo<ItemPosition>());
+            alignmentData.setPosition(toCSSIdentifierValue(pair.second()).convertTo<ItemPosition>());
         } else {
-            alignmentData.setPosition(toCSSPrimitiveValue(pair.first()).convertTo<ItemPosition>());
-            alignmentData.setOverflow(toCSSPrimitiveValue(pair.second()).convertTo<OverflowAlignment>());
+            alignmentData.setPosition(toCSSIdentifierValue(pair.first()).convertTo<ItemPosition>());
+            alignmentData.setOverflow(toCSSIdentifierValue(pair.second()).convertTo<OverflowAlignment>());
         }
     } else {
-        alignmentData.setPosition(toCSSPrimitiveValue(value).convertTo<ItemPosition>());
+        alignmentData.setPosition(toCSSIdentifierValue(value).convertTo<ItemPosition>());
     }
     return alignmentData;
 }
 
 StyleContentAlignmentData StyleBuilderConverter::convertContentAlignmentData(StyleResolverState&, const CSSValue& value)
 {
     StyleContentAlignmentData alignmentData = ComputedStyle::initialContentAlignment();
     if (!RuntimeEnabledFeatures::cssGridLayoutEnabled()) {
-        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-        switch (primitiveValue.getValueID()) {
+        const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+        switch (identifierValue.getValueID()) {
         case CSSValueStretch:
         case CSSValueSpaceBetween:
         case CSSValueSpaceAround:
-            alignmentData.setDistribution(primitiveValue.convertTo<ContentDistributionType>());
+            alignmentData.setDistribution(identifierValue.convertTo<ContentDistributionType>());
             break;
         case CSSValueFlexStart:
         case CSSValueFlexEnd:
         case CSSValueCenter:
-            alignmentData.setPosition(primitiveValue.convertTo<ContentPosition>());
+            alignmentData.setPosition(identifierValue.convertTo<ContentPosition>());
             break;
         default:
             ASSERT_NOT_REACHED();
         }
         return alignmentData;
     }
     const CSSContentDistributionValue& contentValue = toCSSContentDistributionValue(value);
     if (contentValue.distribution()->getValueID() != CSSValueInvalid)
         alignmentData.setDistribution(contentValue.distribution()->convertTo<ContentDistributionType>());
     if (contentValue.position()->getValueID() != CSSValueInvalid)
         alignmentData.setPosition(contentValue.position()->convertTo<ContentPosition>());
     if (contentValue.overflow()->getValueID() != CSSValueInvalid)
         alignmentData.setOverflow(contentValue.overflow()->convertTo<OverflowAlignment>());
     return alignmentData;
 }
 
 GridAutoFlow StyleBuilderConverter::convertGridAutoFlow(StyleResolverState&, const CSSValue& value)
 {
     const CSSValueList& list = toCSSValueList(value);
 
     ASSERT(list.length() >= 1);
-    const CSSPrimitiveValue& first = toCSSPrimitiveValue(list.item(0));
-    const CSSPrimitiveValue* second = list.length() == 2 ? &toCSSPrimitiveValue(list.item(1)) : nullptr;
+    const CSSIdentifierValue& first = toCSSIdentifierValue(list.item(0));
+    const CSSIdentifierValue* second = list.length() == 2 ? &toCSSIdentifierValue(list.item(1)) : nullptr;
 
     switch (first.getValueID()) {
     case CSSValueRow:
         if (second && second->getValueID() == CSSValueDense)
             return AutoFlowRowDense;
         return AutoFlowRow;
     case CSSValueColumn:
         if (second && second->getValueID() == CSSValueDense)
             return AutoFlowColumnDense;
         return AutoFlowColumn;
@@ skipping 14 matching lines @@
 
     GridPosition position;
 
     if (value.isCustomIdentValue()) {
         // We translate <custom-ident> to <string> during parsing as it
         // makes handling it more simple.
         position.setNamedGridArea(toCSSCustomIdentValue(value).value());
         return position;
     }
 
-    if (value.isPrimitiveValue()) {
-        ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueAuto);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueAuto);
         return position;
     }
 
     const CSSValueList& values = toCSSValueList(value);
     ASSERT(values.length());
 
     bool isSpanPosition = false;
     // The specification makes the <integer> optional, in which case it default to '1'.
     int gridLineNumber = 1;
     AtomicString gridLineName;
 
     auto it = values.begin();
     const CSSValue* currentValue = it->get();
-    if (currentValue->isPrimitiveValue() && toCSSPrimitiveValue(currentValue)->getValueID() == CSSValueSpan) {
+    if (currentValue->isIdentifierValue() && toCSSIdentifierValue(currentValue)->getValueID() == CSSValueSpan) {
         isSpanPosition = true;
         ++it;
         currentValue = it != values.end() ? it->get() : nullptr;
     }
 
     if (currentValue && currentValue->isPrimitiveValue() && toCSSPrimitiveValue(currentValue)->isNumber()) {
         gridLineNumber = toCSSPrimitiveValue(currentValue)->getIntValue();
         ++it;
         currentValue = it != values.end() ? it->get() : nullptr;
     }
 
     if (currentValue && currentValue->isCustomIdentValue()) {
         gridLineName = toCSSCustomIdentValue(currentValue)->value();
         ++it;
     }
 
     ASSERT(it == values.end());
     if (isSpanPosition)
         position.setSpanPosition(gridLineNumber, gridLineName);
     else
         position.setExplicitPosition(gridLineNumber, gridLineName);
 
     return position;
 }
 
 GridTrackSize StyleBuilderConverter::convertGridTrackSize(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue())
-        return GridTrackSize(convertGridTrackBreadth(state, toCSSPrimitiveValue(value)));
+    if (value.isPrimitiveValue() || value.isIdentifierValue())
+        return GridTrackSize(convertGridTrackBreadth(state, value));
 
     auto& function = toCSSFunctionValue(value);
     if (function.functionType() == CSSValueFitContent) {
         SECURITY_DCHECK(function.length() == 1);
-        return GridTrackSize(convertGridTrackBreadth(state, toCSSPrimitiveValue(function.item(0))), FitContentTrackSizing);
+        return GridTrackSize(convertGridTrackBreadth(state, function.item(0)), FitContentTrackSizing);
     }
 
     SECURITY_DCHECK(function.length() == 2);
-    GridLength minTrackBreadth(convertGridTrackBreadth(state, toCSSPrimitiveValue(function.item(0))));
-    GridLength maxTrackBreadth(convertGridTrackBreadth(state, toCSSPrimitiveValue(function.item(1))));
+    GridLength minTrackBreadth(convertGridTrackBreadth(state, function.item(0)));
+    GridLength maxTrackBreadth(convertGridTrackBreadth(state, function.item(1)));
     return GridTrackSize(minTrackBreadth, maxTrackBreadth);
 }
 
 static void convertGridLineNamesList(const CSSValue& value, size_t currentNamedGridLine, NamedGridLinesMap& namedGridLines, OrderedNamedGridLines& orderedNamedGridLines)
 {
     ASSERT(value.isGridLineNamesValue());
 
     for (auto& namedGridLineValue : toCSSValueList(value)) {
         String namedGridLine = toCSSCustomIdentValue(*namedGridLineValue).value();
         NamedGridLinesMap::AddResult result = namedGridLines.add(namedGridLine, Vector<size_t>());
@@ skipping 10 matching lines @@
     for (auto& currValue : toCSSValueList(value)) {
         DCHECK(!currValue->isGridLineNamesValue());
         DCHECK(!currValue->isGridAutoRepeatValue());
         trackSizes.append(convertGridTrackSize(state, *currValue));
     }
     return trackSizes;
 }
 
 void StyleBuilderConverter::convertGridTrackList(const CSSValue& value, Vector<GridTrackSize>& trackSizes, NamedGridLinesMap& namedGridLines, OrderedNamedGridLines& orderedNamedGridLines, Vector<GridTrackSize>& autoRepeatTrackSizes, NamedGridLinesMap& autoRepeatNamedGridLines, OrderedNamedGridLines& autoRepeatOrderedNamedGridLines, size_t& autoRepeatInsertionPoint, AutoRepeatType &autoRepeatType, StyleResolverState& state)
 {
-    if (value.isPrimitiveValue()) {
-        ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
         return;
     }
 
     size_t currentNamedGridLine = 0;
     for (auto currValue : toCSSValueList(value)) {
         if (currValue->isGridLineNamesValue()) {
             convertGridLineNamesList(*currValue, currentNamedGridLine, namedGridLines, orderedNamedGridLines);
             continue;
         }
 
@@ skipping 66 matching lines @@
     return toCSSPrimitiveValue(value).convertToLength(state.cssToLengthConversionData());
 }
 
 UnzoomedLength StyleBuilderConverter::convertUnzoomedLength(const StyleResolverState& state, const CSSValue& value)
 {
     return UnzoomedLength(toCSSPrimitiveValue(value).convertToLength(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0f)));
 }
 
 Length StyleBuilderConverter::convertLengthOrAuto(const StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.getValueID() == CSSValueAuto)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueAuto)
         return Length(Auto);
-    return primitiveValue.convertToLength(state.cssToLengthConversionData());
+    return toCSSPrimitiveValue(value).convertToLength(state.cssToLengthConversionData());
 }
 
 Length StyleBuilderConverter::convertLengthSizing(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    switch (primitiveValue.getValueID()) {
-    case CSSValueInvalid:
+    if (!value.isIdentifierValue())
         return convertLength(state, value);
+
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    switch (identifierValue.getValueID()) {
     case CSSValueMinContent:
     case CSSValueWebkitMinContent:
         return Length(MinContent);
     case CSSValueMaxContent:
     case CSSValueWebkitMaxContent:
         return Length(MaxContent);
     case CSSValueWebkitFillAvailable:
         return Length(FillAvailable);
     case CSSValueWebkitFitContent:
     case CSSValueFitContent:
         return Length(FitContent);
     case CSSValueAuto:
         return Length(Auto);
     default:
         ASSERT_NOT_REACHED();
         return Length();
     }
 }
 
 Length StyleBuilderConverter::convertLengthMaxSizing(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.getValueID() == CSSValueNone)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueNone)
         return Length(MaxSizeNone);
     return convertLengthSizing(state, value);
 }
 
 TabSize StyleBuilderConverter::convertLengthOrTabSpaces(StyleResolverState& state, const CSSValue& value)
 {
     const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.isNumber())
         return TabSize(primitiveValue.getIntValue());
     return TabSize(primitiveValue.computeLength<float>(state.cssToLengthConversionData()));
 }
 
 static CSSToLengthConversionData lineHeightToLengthConversionData(StyleResolverState& state)
 {
     float multiplier = state.style()->effectiveZoom();
     if (LocalFrame* frame = state.document().frame())
         multiplier *= frame->textZoomFactor();
     return state.cssToLengthConversionData().copyWithAdjustedZoom(multiplier);
 }
 
 Length StyleBuilderConverter::convertLineHeight(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-
-    if (primitiveValue.isLength())
-        return primitiveValue.computeLength<Length>(lineHeightToLengthConversionData(state));
-    if (primitiveValue.isPercentage())
-        return Length((state.style()->computedFontSize() * primitiveValue.getIntValue()) / 100.0, Fixed);
-    if (primitiveValue.isNumber())
-        return Length(primitiveValue.getDoubleValue() * 100.0, Percent);
-    if (primitiveValue.isCalculated()) {
-        Length zoomedLength = Length(primitiveValue.cssCalcValue()->toCalcValue(lineHeightToLengthConversionData(state)));
-        return Length(valueForLength(zoomedLength, LayoutUnit(state.style()->computedFontSize())), Fixed);
+    if (value.isPrimitiveValue()) {
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+        if (primitiveValue.isLength())
+            return primitiveValue.computeLength<Length>(lineHeightToLengthConversionData(state));
+        if (primitiveValue.isPercentage())
+            return Length((state.style()->computedFontSize() * primitiveValue.getIntValue()) / 100.0, Fixed);
+        if (primitiveValue.isNumber())
+            return Length(primitiveValue.getDoubleValue() * 100.0, Percent);
+        if (primitiveValue.isCalculated()) {
+            Length zoomedLength = Length(primitiveValue.cssCalcValue()->toCalcValue(lineHeightToLengthConversionData(state)));
+            return Length(valueForLength(zoomedLength, LayoutUnit(state.style()->computedFontSize())), Fixed);
+        }
     }
 
-    ASSERT(primitiveValue.getValueID() == CSSValueNormal);
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNormal);
     return ComputedStyle::initialLineHeight();
 }
 
 float StyleBuilderConverter::convertNumberOrPercentage(StyleResolverState& state, const CSSValue& value)
 {
     const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     ASSERT(primitiveValue.isNumber() || primitiveValue.isPercentage());
     if (primitiveValue.isNumber())
         return primitiveValue.getFloatValue();
     return primitiveValue.getFloatValue() / 100.0f;
 }
 
 StyleOffsetRotation StyleBuilderConverter::convertOffsetRotation(StyleResolverState&, const CSSValue& value)
 {
     return convertOffsetRotation(value);
 }
 
 StyleOffsetRotation StyleBuilderConverter::convertOffsetRotation(const CSSValue& value)
 {
     StyleOffsetRotation result(0, OffsetRotationFixed);
 
     const CSSValueList& list = toCSSValueList(value);
     ASSERT(list.length() == 1 || list.length() == 2);
     for (const auto& item : list) {
-        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(*item);
-        if (primitiveValue.getValueID() == CSSValueAuto) {
+        if (item->isIdentifierValue() && toCSSIdentifierValue(*item).getValueID() == CSSValueAuto) {
             result.type = OffsetRotationAuto;
-        } else if (primitiveValue.getValueID() == CSSValueReverse) {
+        } else if (item->isIdentifierValue() && toCSSIdentifierValue(*item).getValueID() == CSSValueReverse) {
             result.type = OffsetRotationAuto;
             result.angle += 180;
         } else {
+            const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(*item);
             result.angle += primitiveValue.computeDegrees();
         }
     }
     result.angle = clampTo<float>(result.angle);
 
     return result;
 }
 
 template <CSSValueID cssValueFor0, CSSValueID cssValueFor100>
 Length StyleBuilderConverter::convertPositionLength(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isValuePair()) {
         const CSSValuePair& pair = toCSSValuePair(value);
         Length length = StyleBuilderConverter::convertLength(state, pair.second());
-        if (toCSSPrimitiveValue(pair.first()).getValueID() == cssValueFor0)
+        if (toCSSIdentifierValue(pair.first()).getValueID() == cssValueFor0)
             return length;
-        ASSERT(toCSSPrimitiveValue(pair.first()).getValueID() == cssValueFor100);
+        DCHECK_EQ(toCSSIdentifierValue(pair.first()).getValueID(), cssValueFor100);
         return length.subtractFromOneHundredPercent();
     }
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.isValueID()) {
-        switch (primitiveValue.getValueID()) {
+    if (value.isIdentifierValue()) {
+        switch (toCSSIdentifierValue(value).getValueID()) {
         case cssValueFor0:
             return Length(0, Percent);
         case cssValueFor100:
             return Length(100, Percent);
         case CSSValueCenter:
             return Length(50, Percent);
         default:
             ASSERT_NOT_REACHED();
         }
     }
 
-    return StyleBuilderConverter::convertLength(state, primitiveValue);
+    return StyleBuilderConverter::convertLength(state, toCSSPrimitiveValue(value));
 }
 
 LengthPoint StyleBuilderConverter::convertPosition(StyleResolverState& state, const CSSValue& value)
 {
     const CSSValuePair& pair = toCSSValuePair(value);
     return LengthPoint(
         convertPositionLength<CSSValueLeft, CSSValueRight>(state, pair.first()),
         convertPositionLength<CSSValueTop, CSSValueBottom>(state, pair.second())
     );
 }
 
 LengthPoint StyleBuilderConverter::convertPositionOrAuto(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isValuePair())
         return convertPosition(state, value);
-    DCHECK(toCSSPrimitiveValue(value).getValueID() == CSSValueAuto);
+    DCHECK(toCSSIdentifierValue(value).getValueID() == CSSValueAuto);
     return LengthPoint(Length(Auto), Length(Auto));
 }
 
 static float convertPerspectiveLength(StyleResolverState& state, const CSSPrimitiveValue& primitiveValue)
 {
     return std::max(primitiveValue.computeLength<float>(state.cssToLengthConversionData()), 0.0f);
 }
 
 float StyleBuilderConverter::convertPerspective(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-
-    if (primitiveValue.getValueID() == CSSValueNone)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueNone)
         return ComputedStyle::initialPerspective();
-    return convertPerspectiveLength(state, primitiveValue);
+    return convertPerspectiveLength(state, toCSSPrimitiveValue(value));
 }
 
 EPaintOrder StyleBuilderConverter::convertPaintOrder(StyleResolverState&, const CSSValue& cssPaintOrder)
 {
     if (cssPaintOrder.isValueList()) {
         const CSSValueList& orderTypeList = toCSSValueList(cssPaintOrder);
-        switch (toCSSPrimitiveValue(orderTypeList.item(0)).getValueID()) {
+        switch (toCSSIdentifierValue(orderTypeList.item(0)).getValueID()) {
         case CSSValueFill:
             return orderTypeList.length() > 1 ? PaintOrderFillMarkersStroke : PaintOrderFillStrokeMarkers;
         case CSSValueStroke:
             return orderTypeList.length() > 1 ? PaintOrderStrokeMarkersFill : PaintOrderStrokeFillMarkers;
         case CSSValueMarkers:
             return orderTypeList.length() > 1 ? PaintOrderMarkersStrokeFill : PaintOrderMarkersFillStroke;
         default:
             ASSERT_NOT_REACHED();
             return PaintOrderNormal;
         }
     }
 
     return PaintOrderNormal;
 }
 
 Length StyleBuilderConverter::convertQuirkyLength(StyleResolverState& state, const CSSValue& value)
 {
     Length length = convertLengthOrAuto(state, value);
     // This is only for margins which use __qem
-    length.setQuirk(toCSSPrimitiveValue(value).isQuirkyEms());
+    length.setQuirk(value.isPrimitiveValue() && toCSSPrimitiveValue(value).isQuirkyEms());
     return length;
 }
 
 PassRefPtr<QuotesData> StyleBuilderConverter::convertQuotes(StyleResolverState&, const CSSValue& value)
 {
     if (value.isValueList()) {
         const CSSValueList& list = toCSSValueList(value);
         RefPtr<QuotesData> quotes = QuotesData::create();
         for (size_t i = 0; i < list.length(); i += 2) {
             String startQuote = toCSSStringValue(list.item(i)).value();
             String endQuote = toCSSStringValue(list.item(i + 1)).value();
             quotes->addPair(std::make_pair(startQuote, endQuote));
         }
         return quotes.release();
     }
-    ASSERT(value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return QuotesData::create();
 }
 
 LengthSize StyleBuilderConverter::convertRadius(StyleResolverState& state, const CSSValue& value)
 {
     const CSSValuePair& pair = toCSSValuePair(value);
     Length radiusWidth = toCSSPrimitiveValue(pair.first()).convertToLength(state.cssToLengthConversionData());
     Length radiusHeight = toCSSPrimitiveValue(pair.second()).convertToLength(state.cssToLengthConversionData());
     return LengthSize(radiusWidth, radiusHeight);
 }
 
 PassRefPtr<ShadowList> StyleBuilderConverter::convertShadow(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue()) {
-        ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
         return PassRefPtr<ShadowList>();
     }
 
     const CSSValueList& valueList = toCSSValueList(value);
     size_t shadowCount = valueList.length();
     ShadowDataVector shadows;
     for (size_t i = 0; i < shadowCount; ++i) {
         const CSSShadowValue& item = toCSSShadowValue(valueList.item(i));
         float x = item.x->computeLength<float>(state.cssToLengthConversionData());
         float y = item.y->computeLength<float>(state.cssToLengthConversionData());
         float blur = item.blur ? item.blur->computeLength<float>(state.cssToLengthConversionData()) : 0;
         float spread = item.spread ? item.spread->computeLength<float>(state.cssToLengthConversionData()) : 0;
         ShadowStyle shadowStyle = item.style && item.style->getValueID() == CSSValueInset ? Inset : Normal;
         StyleColor color = StyleColor::currentColor();
         if (item.color)
             color = convertStyleColor(state, *item.color);
         shadows.append(ShadowData(FloatPoint(x, y), blur, spread, shadowStyle, color));
     }
     return ShadowList::adopt(shadows);
 }
 
 ShapeValue* StyleBuilderConverter::convertShapeValue(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue()) {
-        ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
         return nullptr;
     }
 
     if (value.isImageValue() || value.isImageGeneratorValue() || value.isImageSetValue())
         return ShapeValue::createImageValue(state.styleImage(CSSPropertyShapeOutside, value));
 
     RefPtr<BasicShape> shape;
     CSSBoxType cssBox = BoxMissing;
     const CSSValueList& valueList = toCSSValueList(value);
     for (unsigned i = 0; i < valueList.length(); ++i) {
         const CSSValue& value = valueList.item(i);
         if (value.isBasicShapeValue()) {
             shape = basicShapeForValue(state, value);
         } else {
-            cssBox = toCSSPrimitiveValue(value).convertTo<CSSBoxType>();
+            cssBox = toCSSIdentifierValue(value).convertTo<CSSBoxType>();
         }
     }
 
     if (shape)
         return ShapeValue::createShapeValue(shape.release(), cssBox);
 
     ASSERT(cssBox != BoxMissing);
     return ShapeValue::createBoxShapeValue(cssBox);
 }
 
 float StyleBuilderConverter::convertSpacing(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.getValueID() == CSSValueNormal)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueNormal)
         return 0;
-    return primitiveValue.computeLength<float>(state.cssToLengthConversionData());
+    return toCSSPrimitiveValue(value).computeLength<float>(state.cssToLengthConversionData());
 }
 
 PassRefPtr<SVGDashArray> StyleBuilderConverter::convertStrokeDasharray(StyleResolverState& state, const CSSValue& value)
 {
     if (!value.isValueList())
         return SVGComputedStyle::initialStrokeDashArray();
 
     const CSSValueList& dashes = toCSSValueList(value);
 
     RefPtr<SVGDashArray> array = SVGDashArray::create();
     size_t length = dashes.length();
     for (size_t i = 0; i < length; ++i) {
         array->append(convertLength(state, toCSSPrimitiveValue(dashes.item(i))));
     }
 
     return array.release();
 }
 
 StyleColor StyleBuilderConverter::convertStyleColor(StyleResolverState& state, const CSSValue& value, bool forVisitedLink)
 {
-    if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueCurrentcolor)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueCurrentcolor)
         return StyleColor::currentColor();
     return state.document().textLinkColors().colorFromCSSValue(value, Color(), forVisitedLink);
 }
 
 float StyleBuilderConverter::convertTextStrokeWidth(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.getValueID()) {
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID()) {
         float multiplier = convertLineWidth<float>(state, value);
         return CSSPrimitiveValue::create(multiplier / 48, CSSPrimitiveValue::UnitType::Ems)->computeLength<float>(state.cssToLengthConversionData());
     }
-    return primitiveValue.computeLength<float>(state.cssToLengthConversionData());
+    return toCSSPrimitiveValue(value).computeLength<float>(state.cssToLengthConversionData());
 }
 
 TextSizeAdjust StyleBuilderConverter::convertTextSizeAdjust(StyleResolverState& state, const CSSValue& value)
 {
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueNone)
+        return TextSizeAdjust::adjustNone();
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueAuto)
+        return TextSizeAdjust::adjustAuto();
     const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.getValueID() == CSSValueNone)
-        return TextSizeAdjust::adjustNone();
-    if (primitiveValue.getValueID() == CSSValueAuto)
-        return TextSizeAdjust::adjustAuto();
     DCHECK(primitiveValue.isPercentage());
     return TextSizeAdjust(primitiveValue.getFloatValue() / 100.0f);
 }
 
 TransformOrigin StyleBuilderConverter::convertTransformOrigin(StyleResolverState& state, const CSSValue& value)
 {
     const CSSValueList& list = toCSSValueList(value);
-    ASSERT(list.length() == 3);
-
-    const CSSPrimitiveValue& primitiveValueX = toCSSPrimitiveValue(list.item(0));
-    const CSSPrimitiveValue& primitiveValueY = toCSSPrimitiveValue(list.item(1));
-    const CSSPrimitiveValue& primitiveValueZ = toCSSPrimitiveValue(list.item(2));
+    DCHECK_EQ(list.length(), 3U);
+    DCHECK(list.item(0).isPrimitiveValue() || list.item(0).isIdentifierValue());
+    DCHECK(list.item(1).isPrimitiveValue() || list.item(1).isIdentifierValue());
+    DCHECK(list.item(2).isPrimitiveValue());
 
     return TransformOrigin(
-        convertPositionLength<CSSValueLeft, CSSValueRight>(state, primitiveValueX),
-        convertPositionLength<CSSValueTop, CSSValueBottom>(state, primitiveValueY),
-        StyleBuilderConverter::convertComputedLength<float>(state, primitiveValueZ)
+        convertPositionLength<CSSValueLeft, CSSValueRight>(state, list.item(0)),
+        convertPositionLength<CSSValueTop, CSSValueBottom>(state, list.item(1)),
+        StyleBuilderConverter::convertComputedLength<float>(state, list.item(2))
     );
 }
 
 ScrollSnapPoints StyleBuilderConverter::convertSnapPoints(StyleResolverState& state, const CSSValue& value)
 {
     // Handles: none | repeat(<length>)
     ScrollSnapPoints points;
     points.hasRepeat = false;
 
     if (!value.isFunctionValue())
@@ skipping 70 matching lines @@
     if (list.length() >= 2)
         sy = toCSSPrimitiveValue(list.item(1)).getDoubleValue();
     if (list.length() == 3)
         sz = toCSSPrimitiveValue(list.item(2)).getDoubleValue();
 
     return ScaleTransformOperation::create(sx, sy, sz, TransformOperation::Scale3D);
 }
 
 RespectImageOrientationEnum StyleBuilderConverter::convertImageOrientation(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    return primitiveValue.getValueID() == CSSValueFromImage ? RespectImageOrientation : DoNotRespectImageOrientation;
+    return value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueFromImage ? RespectImageOrientation : DoNotRespectImageOrientation;
 }
 
 PassRefPtr<StylePath> StyleBuilderConverter::convertPathOrNone(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isPathValue())
         return toCSSPathValue(value).stylePath();
-    ASSERT(value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return nullptr;
 }
 
 const CSSValue& StyleBuilderConverter::convertRegisteredPropertyValue(const StyleResolverState& state, const CSSValue& value)
 {
     // TODO(timloh): Images and transform-function values can also contain lengths.
     if (value.isValueList()) {
         CSSValueList* newList = CSSValueList::createSpaceSeparated();
         for (const CSSValue* innerValue : toCSSValueList(value))
             newList->append(convertRegisteredPropertyValue(state, *innerValue));
         return *newList;
     }
 
     if (value.isPrimitiveValue()) {
         const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
         if (primitiveValue.isCalculated() || CSSPrimitiveValue::isRelativeUnit(primitiveValue.typeWithCalcResolved())) {
             // Instead of the actual zoom, use 1 to avoid potential rounding errors
             Length length = primitiveValue.convertToLength(state.cssToLengthConversionData().copyWithAdjustedZoom(1));
             return *CSSPrimitiveValue::create(length, 1);
         }
     }
     return value;
 }
 
 } // namespace blink