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 109 matching lines @@
 static CSSComputedStyleDeclaration* ensureComputedStyle(const Position& position)
 {
     Element* elem = associatedElementOf(position);
     if (!elem)
         return nullptr;
     return CSSComputedStyleDeclaration::create(elem);
 }
 
 static MutableStylePropertySet* getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle);
 enum LegacyFontSizeMode { AlwaysUseLegacyFontSize, UseLegacyFontSizeOnlyIfPixelValuesMatch };
-static int legacyFontSizeFromCSSValue(Document*, const CSSPrimitiveValue*, bool, LegacyFontSizeMode);
+static int legacyFontSizeFromCSSValue(Document*, 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, const HTMLQualifiedName& tagName)
+HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, CSSValueID valueID, const HTMLQualifiedName& tagName)
     : m_propertyID(id)
-    , m_primitiveValue(CSSPrimitiveValue::createIdentifier(primitiveValue))
+    , m_identifierValue(CSSIdentifierValue::createIdentifier(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 14 matching lines @@
 {
     return style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect)
         || style->getPropertyCSSValue(textDecorationPropertyForEditing());
 }
 
 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);
+    return matches(element) && styleValue && styleValue->isValueList() && 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, const QualifiedName& attrName)
     {
@@ skipping 75 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::createIdentifier(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()))
+    if (!colorValue || (!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 135 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 ? LeftToRightWritingDirection : RightToLeftWritingDirection;
+        writingDirection = toCSSIdentifierValue(direction)->getValueID() == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
 
         return true;
     }
 
     if (unicodeBidiValue == CSSValueNormal) {
         writingDirection = NaturalWritingDirection;
         return true;
     }
 
     return false;
@@ skipping 189 matching lines @@
     TriState state = FalseTriState;
     bool nodeIsStart = true;
     for (Node& node : NodeTraversal::startsAt(*selection.start().anchorNode())) {
         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(m_mutableStyle->getPropertyCSSValue(CSSPropertyVerticalAlign));
+                    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);
                 if (nodeIsStart) {
                     state = nodeState;
                     nodeIsStart = false;
@@ skipping 244 matching lines @@
     if (textAlignResolvingStartAndEnd(m_mutableStyle.get()) == textAlignResolvingStartAndEnd(styleAtPosition))
         m_mutableStyle->removeProperty(CSSPropertyTextAlign);
 
     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 99 matching lines @@
             wrappingStyle->mergeInlineAndImplicitStyleOfElement(toElement(&node), EditingStyle::DoNotOverrideValues,
                 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::createIdentifier(CSSValueUnderline)));
+    DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough, (CSSIdentifierValue::createIdentifier(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 160 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;
 
     Position position = adjustedSelectionStartForStyleComputation(selection);
 
     // If the pos is at the end of a text node, then this node is not fully selected.
@@ skipping 59 matching lines @@
         end = mostBackwardCaretPosition(selection.end());
 
         DCHECK(end.document());
         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();
+            CSSValueID unicodeBidiValue = toCSSIdentifierValue(unicodeBidi)->getValueID();
             if (isUnicodeBidiNestedOrMultipleEmbeddings(unicodeBidiValue))
                 return NaturalWritingDirection;
         }
     }
 
     if (selection.isCaret()) {
         WritingDirection direction;
         if (typingStyle && typingStyle->textDirection(direction)) {
             hasNestedOrMultipleEmbeddings = false;
             return direction;
         }
         node = selection.visibleStart().deepEquivalent().anchorNode();
     }
     DCHECK(node);
 
     // The selection is either a caret with no typing attributes or a range in which no embedding is added, so just use the start position
     // to decide.
     Node* block = enclosingBlock(node);
     WritingDirection foundDirection = NaturalWritingDirection;
 
     for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*node)) {
         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();
+        CSSValueID unicodeBidiValue = 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 82 matching lines @@
     int fontStyle = getIdentifierValue(style, CSSPropertyFontStyle);
     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::createIdentifier(CSSValueUnderline)));
+        DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough, (CSSIdentifierValue::createIdentifier(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 13 matching lines @@
         m_applyFontColor = getFontColor(style).serialized();
         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, UseLegacyFontSizeOnlyIfPixelValuesMatch)) {
+        } else if (int legacyFontSize = legacyFontSizeFromCSSValue(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();
 
     result->removeEquivalentProperties(baseStyle);
@@ skipping 21 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, bool isMonospaceFont, LegacyFontSizeMode mode)
+int legacyFontSizeFromCSSValue(Document* document, 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