Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/Source/core/editing/EditingStyle.cpp

 /*
  * Copyright (C) 2007, 2008, 2009 Apple Computer, Inc.
  * Copyright (C) 2010, 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 12 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/EditingStyle.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/FontSize.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/parser/CSSParser.h"
@@ skipping 110 matching lines @@
 }
 
 static MutableStylePropertySet* getPropertiesNotIn(
     StylePropertySet* styleWithRedundantProperties,
     CSSStyleDeclaration* baseStyle);
 enum LegacyFontSizeMode {
   AlwaysUseLegacyFontSize,
   UseLegacyFontSizeOnlyIfPixelValuesMatch
 };
 static int legacyFontSizeFromCSSValue(Document*,
-                                      const CSSPrimitiveValue*,
+                                      const CSSValue*,
                                       bool,
                                       LegacyFontSizeMode);
 static bool isTransparentColorValue(const CSSValue*);
 static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
 static bool hasTransparentBackgroundColor(StylePropertySet*);
 static const CSSValue* backgroundColorValueInEffect(Node*);
 static bool hasAncestorVerticalAlignStyle(Node&, CSSValueID);
 
 class HTMLElementEquivalent : public GarbageCollected<HTMLElementEquivalent> {
  public:
   static HTMLElementEquivalent* create(CSSPropertyID propertyID,
                                        CSSValueID primitiveValue,
                                        const HTMLQualifiedName& tagName) {
     return new HTMLElementEquivalent(propertyID, primitiveValue, tagName);
   }
 
   virtual bool matches(const Element* element) const {
     return !m_tagName || element->hasTagName(*m_tagName);
   }
   virtual bool hasAttribute() const { return false; }
   virtual bool propertyExistsInStyle(const StylePropertySet* style) const {
     return style->getPropertyCSSValue(m_propertyID);
   }
   virtual bool valueIsPresentInStyle(HTMLElement*, StylePropertySet*) const;
   virtual void addToStyle(Element*, EditingStyle*) const;
 
-  DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_primitiveValue); }
+  DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_identifierValue); }
 
  protected:
   HTMLElementEquivalent(CSSPropertyID);
   HTMLElementEquivalent(CSSPropertyID, const HTMLQualifiedName& tagName);
   HTMLElementEquivalent(CSSPropertyID,
                         CSSValueID primitiveValue,
                         const HTMLQualifiedName& tagName);
   const CSSPropertyID m_propertyID;
-  const Member<CSSPrimitiveValue> m_primitiveValue;
+  const Member<CSSIdentifierValue> m_identifierValue;
   const HTMLQualifiedName*
       m_tagName;  // We can store a pointer because HTML tag names are const global.
 };
 
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id)
     : m_propertyID(id), m_tagName(0) {}
 
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id,
                                              const HTMLQualifiedName& tagName)
     : m_propertyID(id), m_tagName(&tagName) {}
 
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id,
-                                             CSSValueID primitiveValue,
+                                             CSSValueID valueID,
                                              const HTMLQualifiedName& tagName)
     : m_propertyID(id),
-      m_primitiveValue(CSSPrimitiveValue::createIdentifier(primitiveValue)),
+      m_identifierValue(CSSIdentifierValue::create(valueID)),
       m_tagName(&tagName) {
-  DCHECK_NE(primitiveValue, CSSValueInvalid);
+  DCHECK_NE(valueID, CSSValueInvalid);
 }
 
 bool HTMLElementEquivalent::valueIsPresentInStyle(
     HTMLElement* element,
     StylePropertySet* style) const {
   const CSSValue* value = style->getPropertyCSSValue(m_propertyID);
-  return matches(element) && value && value->isPrimitiveValue() &&
-         toCSSPrimitiveValue(value)->getValueID() ==
-             m_primitiveValue->getValueID();
+  return matches(element) && value && value->isIdentifierValue() &&
+         toCSSIdentifierValue(value)->getValueID() ==
+             m_identifierValue->getValueID();
 }
 
 void HTMLElementEquivalent::addToStyle(Element*, EditingStyle* style) const {
-  style->setProperty(m_propertyID, m_primitiveValue->cssText());
+  style->setProperty(m_propertyID, m_identifierValue->cssText());
 }
 
 class HTMLTextDecorationEquivalent final : public HTMLElementEquivalent {
  public:
   static HTMLElementEquivalent* create(CSSValueID primitiveValue,
                                        const HTMLQualifiedName& tagName) {
     return new HTMLTextDecorationEquivalent(primitiveValue, tagName);
   }
   bool propertyExistsInStyle(const StylePropertySet*) const override;
   bool valueIsPresentInStyle(HTMLElement*, StylePropertySet*) const override;
@@ skipping 21 matching lines @@
 }
 
 bool HTMLTextDecorationEquivalent::valueIsPresentInStyle(
     HTMLElement* element,
     StylePropertySet* style) const {
   const CSSValue* styleValue =
       style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
   if (!styleValue)
     styleValue = style->getPropertyCSSValue(textDecorationPropertyForEditing());
   return matches(element) && styleValue && styleValue->isValueList() &&
-         toCSSValueList(styleValue)->hasValue(*m_primitiveValue);
+         toCSSValueList(styleValue)->hasValue(*m_identifierValue);
 }
 
 class HTMLAttributeEquivalent : public HTMLElementEquivalent {
  public:
   static HTMLAttributeEquivalent* create(CSSPropertyID propertyID,
                                          const HTMLQualifiedName& tagName,
                                          const QualifiedName& attrName) {
     return new HTMLAttributeEquivalent(propertyID, tagName, attrName);
   }
   static HTMLAttributeEquivalent* create(CSSPropertyID propertyID,
@@ skipping 80 matching lines @@
 
 const CSSValue* HTMLFontSizeEquivalent::attributeValueAsCSSValue(
     Element* element) const {
   DCHECK(element);
   const AtomicString& value = element->getAttribute(m_attrName);
   if (value.isNull())
     return nullptr;
   CSSValueID size;
   if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size))
     return nullptr;
-  return CSSPrimitiveValue::createIdentifier(size);
+  return CSSIdentifierValue::create(size);
 }
 
 float EditingStyle::NoFontDelta = 0.0f;
 
 EditingStyle::EditingStyle(ContainerNode* node,
                            PropertiesToInclude propertiesToInclude) {
   init(node, propertiesToInclude);
 }
 
 EditingStyle::EditingStyle(const Position& position,
                            PropertiesToInclude propertiesToInclude) {
   init(position.anchorNode(), propertiesToInclude);
 }
 
 EditingStyle::EditingStyle(const StylePropertySet* style)
     : m_mutableStyle(style ? style->mutableCopy() : nullptr) {
   extractFontSizeDelta();
 }
 
 EditingStyle::EditingStyle(CSSPropertyID propertyID, const String& value)
     : m_mutableStyle(nullptr) {
   setProperty(propertyID, value);
   m_isVerticalAlign = propertyID == CSSPropertyVerticalAlign &&
                       (value == "sub" || value == "super");
 }
 
 static Color cssValueToColor(const CSSValue* colorValue) {
   if (!colorValue ||
-      (!colorValue->isColorValue() && !colorValue->isPrimitiveValue()))
+      (!colorValue->isColorValue() && !colorValue->isPrimitiveValue() &&
+       !colorValue->isIdentifierValue()))
     return Color::transparent;
 
   if (colorValue->isColorValue())
     return toCSSColorValue(colorValue)->value();
 
   Color color = 0;
   // FIXME: Why ignore the return value?
   CSSParser::parseColor(color, colorValue->cssText());
   return color;
 }
@@ skipping 140 matching lines @@
   return (!m_mutableStyle || m_mutableStyle->isEmpty()) &&
          m_fontSizeDelta == NoFontDelta;
 }
 
 bool EditingStyle::textDirection(WritingDirection& writingDirection) const {
   if (!m_mutableStyle)
     return false;
 
   const CSSValue* unicodeBidi =
       m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
-  if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
+  if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
     return false;
 
-  CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
+  CSSValueID unicodeBidiValue = toCSSIdentifierValue(unicodeBidi)->getValueID();
   if (isEmbedOrIsolate(unicodeBidiValue)) {
     const CSSValue* direction =
         m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
-    if (!direction || !direction->isPrimitiveValue())
+    if (!direction || !direction->isIdentifierValue())
       return false;
 
     writingDirection =
-        toCSSPrimitiveValue(direction)->getValueID() == CSSValueLtr
+        toCSSIdentifierValue(direction)->getValueID() == CSSValueLtr
             ? LeftToRightWritingDirection
             : RightToLeftWritingDirection;
 
     return true;
   }
 
   if (unicodeBidiValue == CSSValueNormal) {
     writingDirection = NaturalWritingDirection;
     return true;
   }
@@ skipping 205 matching lines @@
     if (node.layoutObject() && hasEditableStyle(node)) {
       CSSComputedStyleDeclaration* nodeStyle =
           CSSComputedStyleDeclaration::create(&node);
       if (nodeStyle) {
         // If the selected element has <sub> or <sup> ancestor element, apply the corresponding
         // style(vertical-align) to it so that document.queryCommandState() works with the style.
         // See bug http://crbug.com/582225.
         if (m_isVerticalAlign &&
             getIdentifierValue(nodeStyle, CSSPropertyVerticalAlign) ==
                 CSSValueBaseline) {
-          const CSSPrimitiveValue* verticalAlign = toCSSPrimitiveValue(
+          const CSSIdentifierValue* verticalAlign = toCSSIdentifierValue(
               m_mutableStyle->getPropertyCSSValue(CSSPropertyVerticalAlign));
           if (hasAncestorVerticalAlignStyle(node, verticalAlign->getValueID()))
             node.mutableComputedStyle()->setVerticalAlign(
                 verticalAlign->convertTo<EVerticalAlign>());
         }
 
         // Pass EditingStyle::DoNotIgnoreTextOnlyProperties without checking if node.isTextNode()
         // because the node can be an element node. See bug http://crbug.com/584939.
         TriState nodeState = triStateOfStyle(
             nodeStyle, EditingStyle::DoNotIgnoreTextOnlyProperties);
@@ skipping 300 matching lines @@
 
   if (getFontColor(m_mutableStyle.get()) == getFontColor(styleAtPosition))
     m_mutableStyle->removeProperty(CSSPropertyColor);
 
   if (hasTransparentBackgroundColor(m_mutableStyle.get()) ||
       cssValueToColor(
           m_mutableStyle->getPropertyCSSValue(CSSPropertyBackgroundColor)) ==
           backgroundColorInEffect(position.computeContainerNode()))
     m_mutableStyle->removeProperty(CSSPropertyBackgroundColor);
 
-  if (unicodeBidi && unicodeBidi->isPrimitiveValue()) {
-    m_mutableStyle->setProperty(CSSPropertyUnicodeBidi,
-                                toCSSPrimitiveValue(unicodeBidi)->getValueID());
-    if (direction && direction->isPrimitiveValue())
-      m_mutableStyle->setProperty(CSSPropertyDirection,
-                                  toCSSPrimitiveValue(direction)->getValueID());
+  if (unicodeBidi && unicodeBidi->isIdentifierValue()) {
+    m_mutableStyle->setProperty(
+        CSSPropertyUnicodeBidi,
+        toCSSIdentifierValue(unicodeBidi)->getValueID());
+    if (direction && direction->isIdentifierValue()) {
+      m_mutableStyle->setProperty(
+          CSSPropertyDirection, toCSSIdentifierValue(direction)->getValueID());
+    }
   }
 }
 
 void EditingStyle::mergeTypingStyle(Document* document) {
   DCHECK(document);
 
   EditingStyle* typingStyle = document->frame()->selection().typingStyle();
   if (!typingStyle || typingStyle == this)
     return;
 
@@ skipping 123 matching lines @@
           EditingStyle::EditingPropertiesInEffect);
     }
   }
 
   return wrappingStyle;
 }
 
 static const CSSValueList& mergeTextDecorationValues(
     const CSSValueList& mergedValue,
     const CSSValueList& valueToMerge) {
-  DEFINE_STATIC_LOCAL(CSSPrimitiveValue, underline,
-                      (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
-  DEFINE_STATIC_LOCAL(
-      CSSPrimitiveValue, lineThrough,
-      (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
+  DEFINE_STATIC_LOCAL(CSSIdentifierValue, underline,
+                      (CSSIdentifierValue::create(CSSValueUnderline)));
+  DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough,
+                      (CSSIdentifierValue::create(CSSValueLineThrough)));
   CSSValueList& result = *mergedValue.copy();
   if (valueToMerge.hasValue(underline) && !mergedValue.hasValue(underline))
     result.append(underline);
 
   if (valueToMerge.hasValue(lineThrough) && !mergedValue.hasValue(lineThrough))
     result.append(lineThrough);
 
   return result;
 }
 
@@ skipping 198 matching lines @@
   if (!m_mutableStyle)
     m_mutableStyle = MutableStylePropertySet::create(HTMLQuirksMode);
   const bool propertyIsImportant = true;
   m_mutableStyle->setProperty(CSSPropertyDisplay, CSSValueInline,
                               propertyIsImportant);
 }
 
 int EditingStyle::legacyFontSize(Document* document) const {
   const CSSValue* cssValue =
       m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize);
-  if (!cssValue || !cssValue->isPrimitiveValue())
+  if (!cssValue ||
+      !(cssValue->isPrimitiveValue() || cssValue->isIdentifierValue()))
     return 0;
-  return legacyFontSizeFromCSSValue(document, toCSSPrimitiveValue(cssValue),
-                                    m_isMonospaceFont, AlwaysUseLegacyFontSize);
+  return legacyFontSizeFromCSSValue(document, cssValue, m_isMonospaceFont,
+                                    AlwaysUseLegacyFontSize);
 }
 
 EditingStyle* EditingStyle::styleAtSelectionStart(
     const VisibleSelection& selection,
     bool shouldUseBackgroundColorInEffect,
     MutableStylePropertySet* styleToCheck) {
   if (selection.isNone())
     return nullptr;
 
   Document& document = *selection.start().document();
@@ skipping 88 matching lines @@
     const EphemeralRange caretRange(position.parentAnchoredEquivalent(),
                                     end.parentAnchoredEquivalent());
     for (Node& n : caretRange.nodes()) {
       if (!n.isStyledElement())
         continue;
 
       CSSComputedStyleDeclaration* style =
           CSSComputedStyleDeclaration::create(&n);
       const CSSValue* unicodeBidi =
           style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
-      if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
+      if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
         continue;
 
       CSSValueID unicodeBidiValue =
-          toCSSPrimitiveValue(unicodeBidi)->getValueID();
+          toCSSIdentifierValue(unicodeBidi)->getValueID();
       if (isUnicodeBidiNestedOrMultipleEmbeddings(unicodeBidiValue))
         return NaturalWritingDirection;
     }
   }
 
   if (selection.isCaret()) {
     WritingDirection direction;
     if (typingStyle && typingStyle->textDirection(direction)) {
       hasNestedOrMultipleEmbeddings = false;
       return direction;
@@ skipping 11 matching lines @@
     if (runner == block)
       break;
     if (!runner.isStyledElement())
       continue;
 
     Element* element = &toElement(runner);
     CSSComputedStyleDeclaration* style =
         CSSComputedStyleDeclaration::create(element);
     const CSSValue* unicodeBidi =
         style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
-    if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
+    if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
       continue;
 
     CSSValueID unicodeBidiValue =
-        toCSSPrimitiveValue(unicodeBidi)->getValueID();
+        toCSSIdentifierValue(unicodeBidi)->getValueID();
     if (unicodeBidiValue == CSSValueNormal)
       continue;
 
     if (unicodeBidiValue == CSSValueBidiOverride)
       return NaturalWritingDirection;
 
     DCHECK(isEmbedOrIsolate(unicodeBidiValue)) << unicodeBidiValue;
     const CSSValue* direction =
         style->getPropertyCSSValue(CSSPropertyDirection);
-    if (!direction || !direction->isPrimitiveValue())
+    if (!direction || !direction->isIdentifierValue())
       continue;
 
-    int directionValue = toCSSPrimitiveValue(direction)->getValueID();
+    int directionValue = toCSSIdentifierValue(direction)->getValueID();
     if (directionValue != CSSValueLtr && directionValue != CSSValueRtl)
       continue;
 
     if (foundDirection != NaturalWritingDirection)
       return NaturalWritingDirection;
 
     // In the range case, make sure that the embedding element persists until the end of the range.
     if (selection.isRange() && !end.anchorNode()->isDescendantOf(element))
       return NaturalWritingDirection;
 
@@ skipping 94 matching lines @@
   if (fontStyle == CSSValueItalic || fontStyle == CSSValueOblique) {
     style->removeProperty(CSSPropertyFontStyle);
     m_applyItalic = true;
   }
 
   // Assuming reconcileTextDecorationProperties has been called, there should not be -webkit-text-decorations-in-effect
   // Furthermore, text-decoration: none has been trimmed so that text-decoration property is always a CSSValueList.
   const CSSValue* textDecoration =
       style->getPropertyCSSValue(textDecorationPropertyForEditing());
   if (textDecoration && textDecoration->isValueList()) {
-    DEFINE_STATIC_LOCAL(
-        CSSPrimitiveValue, underline,
-        (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
-    DEFINE_STATIC_LOCAL(
-        CSSPrimitiveValue, lineThrough,
-        (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
+    DEFINE_STATIC_LOCAL(CSSIdentifierValue, underline,
+                        (CSSIdentifierValue::create(CSSValueUnderline)));
+    DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough,
+                        (CSSIdentifierValue::create(CSSValueLineThrough)));
     CSSValueList* newTextDecoration = toCSSValueList(textDecoration)->copy();
     if (newTextDecoration->removeAll(underline))
       m_applyUnderline = true;
     if (newTextDecoration->removeAll(lineThrough))
       m_applyLineThrough = true;
 
     // If trimTextDecorations, delete underline and line-through
     setTextDecorationProperty(style, newTextDecoration,
                               textDecorationPropertyForEditing());
   }
@@ skipping 15 matching lines @@
     style->removeProperty(CSSPropertyColor);
   }
 
   m_applyFontFace = style->getPropertyValue(CSSPropertyFontFamily);
   // Remove double quotes for Outlook 2007 compatibility. See https://bugs.webkit.org/show_bug.cgi?id=79448
   m_applyFontFace.replace('"', "");
   style->removeProperty(CSSPropertyFontFamily);
 
   if (const CSSValue* fontSize =
           style->getPropertyCSSValue(CSSPropertyFontSize)) {
-    if (!fontSize->isPrimitiveValue()) {
+    if (!fontSize->isPrimitiveValue() && !fontSize->isIdentifierValue()) {
       style->removeProperty(
           CSSPropertyFontSize);  // Can't make sense of the number. Put no font size.
     } else if (int legacyFontSize = legacyFontSizeFromCSSValue(
-                   document, toCSSPrimitiveValue(fontSize), isMonospaceFont,
+                   document, fontSize, isMonospaceFont,
                    UseLegacyFontSizeOnlyIfPixelValuesMatch)) {
       m_applyFontSize = String::number(legacyFontSize);
       style->removeProperty(CSSPropertyFontSize);
     }
   }
 }
 
 static void diffTextDecorations(MutableStylePropertySet* style,
                                 CSSPropertyID propertyID,
                                 const CSSValue* refTextDecoration) {
   const CSSValue* textDecoration = style->getPropertyCSSValue(propertyID);
   if (!textDecoration || !textDecoration->isValueList() || !refTextDecoration ||
       !refTextDecoration->isValueList())
     return;
 
   CSSValueList* newTextDecoration = toCSSValueList(textDecoration)->copy();
   const CSSValueList* valuesInRefTextDecoration =
       toCSSValueList(refTextDecoration);
 
   for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)
     newTextDecoration->removeAll(valuesInRefTextDecoration->item(i));
 
   setTextDecorationProperty(style, newTextDecoration, propertyID);
 }
 
 static bool fontWeightIsBold(const CSSValue* fontWeight) {
-  if (!fontWeight->isPrimitiveValue())
+  if (!fontWeight->isIdentifierValue())
     return false;
 
   // Because b tag can only bold text, there are only two states in plain html: bold and not bold.
   // Collapse all other values to either one of these two states for editing purposes.
-  switch (toCSSPrimitiveValue(fontWeight)->getValueID()) {
+  switch (toCSSIdentifierValue(fontWeight)->getValueID()) {
     case CSSValue100:
     case CSSValue200:
     case CSSValue300:
     case CSSValue400:
     case CSSValue500:
     case CSSValueNormal:
       return false;
     case CSSValueBold:
     case CSSValue600:
     case CSSValue700:
     case CSSValue800:
     case CSSValue900:
       return true;
     default:
       break;
   }
 
   NOTREACHED();  // For CSSValueBolder and CSSValueLighter
   return false;
 }
 
 static bool fontWeightNeedsResolving(const CSSValue* fontWeight) {
-  if (!fontWeight->isPrimitiveValue())
+  if (!fontWeight->isIdentifierValue())
     return true;
 
-  const CSSValueID value = toCSSPrimitiveValue(fontWeight)->getValueID();
+  const CSSValueID value = toCSSIdentifierValue(fontWeight)->getValueID();
   return value == CSSValueLighter || value == CSSValueBolder;
 }
 
 MutableStylePropertySet* getPropertiesNotIn(
     StylePropertySet* styleWithRedundantProperties,
     CSSStyleDeclaration* baseStyle) {
   DCHECK(styleWithRedundantProperties);
   DCHECK(baseStyle);
   MutableStylePropertySet* result = styleWithRedundantProperties->mutableCopy();
 
@@ skipping 32 matching lines @@
     result->removeProperty(CSSPropertyBackgroundColor);
 
   return result;
 }
 
 CSSValueID getIdentifierValue(StylePropertySet* style,
                               CSSPropertyID propertyID) {
   if (!style)
     return CSSValueInvalid;
   const CSSValue* value = style->getPropertyCSSValue(propertyID);
-  if (!value || !value->isPrimitiveValue())
+  if (!value || !value->isIdentifierValue())
     return CSSValueInvalid;
-  return toCSSPrimitiveValue(value)->getValueID();
+  return toCSSIdentifierValue(value)->getValueID();
 }
 
 CSSValueID getIdentifierValue(CSSStyleDeclaration* style,
                               CSSPropertyID propertyID) {
   if (!style)
     return CSSValueInvalid;
   const CSSValue* value = style->getPropertyCSSValueInternal(propertyID);
-  if (!value || !value->isPrimitiveValue())
+  if (!value || !value->isIdentifierValue())
     return CSSValueInvalid;
-  return toCSSPrimitiveValue(value)->getValueID();
+  return toCSSIdentifierValue(value)->getValueID();
 }
 
 int legacyFontSizeFromCSSValue(Document* document,
-                               const CSSPrimitiveValue* value,
+                               const CSSValue* value,
                                bool isMonospaceFont,
                                LegacyFontSizeMode mode) {
-  CSSPrimitiveValue::LengthUnitType lengthType;
-  if (CSSPrimitiveValue::unitTypeToLengthUnitType(value->typeWithCalcResolved(),
-                                                  lengthType) &&
-      lengthType == CSSPrimitiveValue::UnitTypePixels) {
-    double conversion =
-        CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(
-            value->typeWithCalcResolved());
-    int pixelFontSize = clampTo<int>(value->getDoubleValue() * conversion);
-    int legacyFontSize =
-        FontSize::legacyFontSize(document, pixelFontSize, isMonospaceFont);
-    // Use legacy font size only if pixel value matches exactly to that of legacy font size.
-    if (mode == AlwaysUseLegacyFontSize ||
-        FontSize::fontSizeForKeyword(document, legacyFontSize,
-                                     isMonospaceFont) == pixelFontSize)
-      return legacyFontSize;
+  if (value->isPrimitiveValue()) {
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(*value);
+    CSSPrimitiveValue::LengthUnitType lengthType;
+    if (CSSPrimitiveValue::unitTypeToLengthUnitType(
+            primitiveValue.typeWithCalcResolved(), lengthType) &&
+        lengthType == CSSPrimitiveValue::UnitTypePixels) {
+      double conversion =
+          CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(
+              primitiveValue.typeWithCalcResolved());
+      int pixelFontSize =
+          clampTo<int>(primitiveValue.getDoubleValue() * conversion);
+      int legacyFontSize =
+          FontSize::legacyFontSize(document, pixelFontSize, isMonospaceFont);
+      // Use legacy font size only if pixel value matches exactly to that of legacy font size.
+      if (mode == AlwaysUseLegacyFontSize ||
+          FontSize::fontSizeForKeyword(document, legacyFontSize,
+                                       isMonospaceFont) == pixelFontSize)
+        return legacyFontSize;
 
-    return 0;
+      return 0;
+    }
   }
 
-  if (CSSValueXSmall <= value->getValueID() &&
-      value->getValueID() <= CSSValueWebkitXxxLarge)
-    return value->getValueID() - CSSValueXSmall + 1;
+  if (value->isIdentifierValue()) {
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(*value);
+    if (CSSValueXSmall <= identifierValue.getValueID() &&
+        identifierValue.getValueID() <= CSSValueWebkitXxxLarge)
+      return identifierValue.getValueID() - CSSValueXSmall + 1;
+  }
 
   return 0;
 }
 
 bool isTransparentColorValue(const CSSValue* cssValue) {
   if (!cssValue)
     return true;
   if (cssValue->isColorValue())
     return !toCSSColorValue(cssValue)->value().alpha();
-  if (!cssValue->isPrimitiveValue())
+  if (!cssValue->isIdentifierValue())
     return false;
-  const CSSPrimitiveValue* value = toCSSPrimitiveValue(cssValue);
-  return value->getValueID() == CSSValueTransparent;
+  return toCSSIdentifierValue(cssValue)->getValueID() == CSSValueTransparent;
 }
 
 bool hasTransparentBackgroundColor(CSSStyleDeclaration* style) {
   const CSSValue* cssValue =
       style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor);
   return isTransparentColorValue(cssValue);
 }
 
 bool hasTransparentBackgroundColor(StylePropertySet* style) {
   const CSSValue* cssValue =
       style->getPropertyCSSValue(CSSPropertyBackgroundColor);
   return isTransparentColorValue(cssValue);
 }
 
 const CSSValue* backgroundColorValueInEffect(Node* node) {
   for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
     CSSComputedStyleDeclaration* ancestorStyle =
         CSSComputedStyleDeclaration::create(ancestor);
     if (!hasTransparentBackgroundColor(ancestorStyle))
       return ancestorStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
   }
   return nullptr;
 }
 
 }  // namespace blink