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) {
-  if (primitiveValue.getValueID() == CSSValueMinContent)
+static GridLength convertGridTrackBreadth(const StyleResolverState& state,
+                                          const CSSValue& value) {
+  // 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()));
@@ skipping 44 matching lines @@
                                      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(
@@ skipping 21 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());
+        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 22 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 19 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>());
+          toCSSIdentifierValue(pair.second()).convertTo<ItemPosition>());
     } else {
       alignmentData.setPosition(
-          toCSSPrimitiveValue(pair.first()).convertTo<ItemPosition>());
+          toCSSIdentifierValue(pair.first()).convertTo<ItemPosition>());
       alignmentData.setOverflow(
-          toCSSPrimitiveValue(pair.second()).convertTo<OverflowAlignment>());
+          toCSSIdentifierValue(pair.second()).convertTo<OverflowAlignment>());
     }
   } else {
     alignmentData.setPosition(
-        toCSSPrimitiveValue(value).convertTo<ItemPosition>());
+        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>());
+            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());
 
@@ skipping 25 matching lines @@
     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 85 matching lines @@
 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:
-      return convertLength(state, value);
+  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());
@@ skipping 12 matching lines @@
     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);
+  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());
 
-  const CSSPrimitiveValue& primitiveValueX = toCSSPrimitiveValue(list.item(0));
-  const CSSPrimitiveValue& primitiveValueY = toCSSPrimitiveValue(list.item(1));
-  const CSSPrimitiveValue& primitiveValueZ = toCSSPrimitiveValue(list.item(2));
-
-  return TransformOrigin(convertPositionLength<CSSValueLeft, CSSValueRight>(
-                             state, primitiveValueX),
-                         convertPositionLength<CSSValueTop, CSSValueBottom>(
-                             state, primitiveValueY),
-                         StyleBuilderConverter::convertComputedLength<float>(
-                             state, primitiveValueZ));
+  return TransformOrigin(
+      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 79 matching lines @@
   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
+  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