Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
@@ skipping 149 matching lines @@
     Color color = state.parentStyle()->color();
     if (state.applyPropertyToRegularStyle())
         state.style()->setColor(color);
     if (state.applyPropertyToVisitedLinkStyle())
         state.style()->setVisitedLinkColor(color);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyColor(StyleResolverState& state, const CSSValue& value)
 {
     // As per the spec, 'color: currentColor' is treated as 'color: inherit'
-    if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueCurrentcolor) {
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueCurrentcolor) {
         applyInheritCSSPropertyColor(state);
         return;
     }
 
     if (state.applyPropertyToRegularStyle())
         state.style()->setColor(StyleBuilderConverter::convertColor(state, value));
     if (state.applyPropertyToVisitedLinkStyle())
         state.style()->setVisitedLinkColor(StyleBuilderConverter::convertColor(state, value, true));
 }
 
@@ skipping 42 matching lines @@
                     SVGElement* svgElement = toSVGElement(element);
                     svgElement->setCursorImageValue(&image);
                     cursorElement->addClient(svgElement);
 
                     // Elements with SVG cursors are not allowed to share style.
                     state.style()->setUnique();
                 }
 
                 state.style()->addCursor(state.styleImage(CSSPropertyCursor, image), hotSpotSpecified, hotSpot);
             } else {
-                state.style()->setCursor(toCSSPrimitiveValue(item).convertTo<ECursor>());
+                state.style()->setCursor(toCSSIdentifierValue(item).convertTo<ECursor>());
             }
         }
     } else {
-        state.style()->setCursor(toCSSPrimitiveValue(value).convertTo<ECursor>());
+        state.style()->setCursor(toCSSIdentifierValue(value).convertTo<ECursor>());
     }
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyDirection(StyleResolverState& state, const CSSValue& value)
 {
-    state.style()->setDirection(toCSSPrimitiveValue(value).convertTo<TextDirection>());
+    state.style()->setDirection(toCSSIdentifierValue(value).convertTo<TextDirection>());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateAreas(StyleResolverState& state)
 {
     state.style()->setNamedGridArea(ComputedStyle::initialNamedGridArea());
     state.style()->setNamedGridAreaRowCount(ComputedStyle::initialNamedGridAreaCount());
     state.style()->setNamedGridAreaColumnCount(ComputedStyle::initialNamedGridAreaCount());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyGridTemplateAreas(StyleResolverState& state)
 {
     state.style()->setNamedGridArea(state.parentStyle()->namedGridArea());
     state.style()->setNamedGridAreaRowCount(state.parentStyle()->namedGridAreaRowCount());
     state.style()->setNamedGridAreaColumnCount(state.parentStyle()->namedGridAreaColumnCount());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyGridTemplateAreas(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue()) {
+    if (value.isIdentifierValue()) {
         // FIXME: Shouldn't we clear the grid-area values
-        DCHECK_EQ(toCSSPrimitiveValue(value).getValueID(), CSSValueNone);
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
         return;
     }
 
     const CSSGridTemplateAreasValue& gridTemplateAreasValue = toCSSGridTemplateAreasValue(value);
     const NamedGridAreaMap& newNamedGridAreas = gridTemplateAreasValue.gridAreaMap();
 
     NamedGridLinesMap namedGridColumnLines;
     NamedGridLinesMap namedGridRowLines;
     StyleBuilderConverter::convertOrderedNamedGridLinesMapToNamedGridLinesMap(state.style()->orderedNamedGridColumnLines(), namedGridColumnLines);
     StyleBuilderConverter::convertOrderedNamedGridLinesMapToNamedGridLinesMap(state.style()->orderedNamedGridRowLines(), namedGridRowLines);
@@ skipping 19 matching lines @@
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyOutlineStyle(StyleResolverState& state)
 {
     state.style()->setOutlineStyleIsAuto(state.parentStyle()->outlineStyleIsAuto());
     state.style()->setOutlineStyle(state.parentStyle()->outlineStyle());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyOutlineStyle(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    state.style()->setOutlineStyleIsAuto(primitiveValue.convertTo<OutlineIsAuto>());
-    state.style()->setOutlineStyle(primitiveValue.convertTo<EBorderStyle>());
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    state.style()->setOutlineStyleIsAuto(identifierValue.convertTo<OutlineIsAuto>());
+    state.style()->setOutlineStyle(identifierValue.convertTo<EBorderStyle>());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyResize(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
 
     EResize r = RESIZE_NONE;
-    if (primitiveValue.getValueID() == CSSValueAuto) {
+    if (identifierValue.getValueID() == CSSValueAuto) {
         if (Settings* settings = state.document().settings())
             r = settings->textAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
     } else {
-        r = primitiveValue.convertTo<EResize>();
+        r = identifierValue.convertTo<EResize>();
     }
     state.style()->setResize(r);
 }
 
 static float mmToPx(float mm) { return mm * cssPixelsPerMillimeter; }
 static float inchToPx(float inch) { return inch * cssPixelsPerInch; }
-static FloatSize getPageSizeFromName(const CSSPrimitiveValue& pageSizeName)
+static FloatSize getPageSizeFromName(const CSSIdentifierValue& pageSizeName)
 {
     switch (pageSizeName.getValueID()) {
     case CSSValueA5:
         return FloatSize(mmToPx(148), mmToPx(210));
     case CSSValueA4:
         return FloatSize(mmToPx(210), mmToPx(297));
     case CSSValueA3:
         return FloatSize(mmToPx(297), mmToPx(420));
     case CSSValueB5:
         return FloatSize(mmToPx(176), mmToPx(250));
@@ skipping 14 matching lines @@
 void StyleBuilderFunctions::applyInitialCSSPropertySize(StyleResolverState&) { }
 void StyleBuilderFunctions::applyInheritCSSPropertySize(StyleResolverState&) { }
 void StyleBuilderFunctions::applyValueCSSPropertySize(StyleResolverState& state, const CSSValue& value)
 {
     state.style()->resetPageSizeType();
     FloatSize size;
     PageSizeType pageSizeType = PAGE_SIZE_AUTO;
     const CSSValueList& list = toCSSValueList(value);
     if (list.length() == 2) {
         // <length>{2} | <page-size> <orientation>
-        const CSSPrimitiveValue& first = toCSSPrimitiveValue(list.item(0));
-        const CSSPrimitiveValue& second = toCSSPrimitiveValue(list.item(1));
-        if (first.isLength()) {
+        const CSSValue& first = list.item(0);
+        const CSSValue& second = list.item(1);
+        if (first.isPrimitiveValue() && toCSSPrimitiveValue(first).isLength()) {
             // <length>{2}
-            size = FloatSize(first.computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)),
-                second.computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)));
+            size = FloatSize(toCSSPrimitiveValue(first).computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)),
+                toCSSPrimitiveValue(second).computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)));
         } else {
             // <page-size> <orientation>
-            size = getPageSizeFromName(first);
+            size = getPageSizeFromName(toCSSIdentifierValue(first));
 
-            DCHECK(second.getValueID() == CSSValueLandscape || second.getValueID() == CSSValuePortrait);
-            if (second.getValueID() == CSSValueLandscape)
+            DCHECK(toCSSIdentifierValue(second).getValueID() == CSSValueLandscape || toCSSIdentifierValue(second).getValueID() == CSSValuePortrait);
+            if (toCSSIdentifierValue(second).getValueID() == CSSValueLandscape)
                 size = size.transposedSize();
         }
         pageSizeType = PAGE_SIZE_RESOLVED;
     } else {
         DCHECK_EQ(list.length(), 1U);
         // <length> | auto | <page-size> | [ portrait | landscape]
-        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(list.item(0));
-        if (primitiveValue.isLength()) {
+        const CSSValue& first = list.item(0);
+        if (first.isPrimitiveValue() && toCSSPrimitiveValue(first).isLength()) {
             // <length>
             pageSizeType = PAGE_SIZE_RESOLVED;
-            float width = primitiveValue.computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0));
+            float width = toCSSPrimitiveValue(first).computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0));
             size = FloatSize(width, width);
         } else {
-            switch (primitiveValue.getValueID()) {
+            const CSSIdentifierValue& ident = toCSSIdentifierValue(first);
+            switch (ident.getValueID()) {
             case CSSValueAuto:
                 pageSizeType = PAGE_SIZE_AUTO;
                 break;
             case CSSValuePortrait:
                 pageSizeType = PAGE_SIZE_AUTO_PORTRAIT;
                 break;
             case CSSValueLandscape:
                 pageSizeType = PAGE_SIZE_AUTO_LANDSCAPE;
                 break;
             default:
                 // <page-size>
                 pageSizeType = PAGE_SIZE_RESOLVED;
-                size = getPageSizeFromName(primitiveValue);
+                size = getPageSizeFromName(ident);
             }
         }
     }
     state.style()->setPageSizeType(pageSizeType);
     state.style()->setPageSize(size);
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertySnapHeight(StyleResolverState& state)
 {
     state.style()->setSnapHeightUnit(0);
@@ skipping 23 matching lines @@
     DCHECK_EQ(list.length(), 2U);
     const CSSPrimitiveValue& second = toCSSPrimitiveValue(list.item(1));
     DCHECK(second.isNumber());
     int position = second.getIntValue();
     DCHECK(position > 0 && position <= 100);
     state.style()->setSnapHeightPosition(position);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyTextAlign(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.isValueID() && primitiveValue.getValueID() != CSSValueWebkitMatchParent) {
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() != CSSValueWebkitMatchParent) {
         // Special case for th elements - UA stylesheet text-align does not apply if parent's computed value for text-align is not its initial value
         // https://html.spec.whatwg.org/multipage/rendering.html#tables-2
-        if (primitiveValue.getValueID() == CSSValueInternalCenter && state.parentStyle()->textAlign() != ComputedStyle::initialTextAlign())
+        const CSSIdentifierValue& identValue = toCSSIdentifierValue(value);
+        if (identValue.getValueID() == CSSValueInternalCenter && state.parentStyle()->textAlign() != ComputedStyle::initialTextAlign())
             state.style()->setTextAlign(state.parentStyle()->textAlign());
         else
-            state.style()->setTextAlign(primitiveValue.convertTo<ETextAlign>());
+            state.style()->setTextAlign(identValue.convertTo<ETextAlign>());
     }
     else if (state.parentStyle()->textAlign() == TASTART)
         state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection() ? LEFT : RIGHT);
     else if (state.parentStyle()->textAlign() == TAEND)
         state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection() ? RIGHT : LEFT);
     else
         state.style()->setTextAlign(state.parentStyle()->textAlign());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyTextIndent(StyleResolverState& state)
@@ skipping 10 matching lines @@
     state.style()->setTextIndentType(ComputedStyle::initialTextIndentType());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolverState& state, const CSSValue& value)
 {
     Length lengthOrPercentageValue;
     TextIndentLine textIndentLineValue = ComputedStyle::initialTextIndentLine();
     TextIndentType textIndentTypeValue = ComputedStyle::initialTextIndentType();
 
     for (auto& listValue : toCSSValueList(value)) {
-        const CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(listValue.get());
-        if (!primitiveValue->getValueID())
-            lengthOrPercentageValue = primitiveValue->convertToLength(state.cssToLengthConversionData());
-        else if (primitiveValue->getValueID() == CSSValueEachLine)
+        if (listValue->isPrimitiveValue()) {
+            lengthOrPercentageValue = toCSSPrimitiveValue(*listValue).convertToLength(state.cssToLengthConversionData());
+        } else if (toCSSIdentifierValue(*listValue).getValueID() == CSSValueEachLine) {
             textIndentLineValue = TextIndentEachLine;
-        else if (primitiveValue->getValueID() == CSSValueHanging)
+        } else if (toCSSIdentifierValue(*listValue).getValueID() == CSSValueHanging) {
             textIndentTypeValue = TextIndentHanging;
-        else
+        } else {
             NOTREACHED();
+        }
     }
 
     state.style()->setTextIndent(lengthOrPercentageValue);
     state.style()->setTextIndentLine(textIndentLineValue);
     state.style()->setTextIndentType(textIndentTypeValue);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyTransform(StyleResolverState& state, const CSSValue& value)
 {
     // FIXME: We should just make this a converter
     TransformOperations operations;
     TransformBuilder::createTransformOperations(value, state.cssToLengthConversionData(), operations);
     state.style()->setTransform(operations);
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyVerticalAlign(StyleResolverState& state)
 {
     EVerticalAlign verticalAlign = state.parentStyle()->verticalAlign();
     state.style()->setVerticalAlign(verticalAlign);
     if (verticalAlign == VerticalAlignLength)
         state.style()->setVerticalAlignLength(state.parentStyle()->getVerticalAlignLength());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-
-    if (primitiveValue.getValueID())
-        state.style()->setVerticalAlign(primitiveValue.convertTo<EVerticalAlign>());
+    if (value.isIdentifierValue())
+        state.style()->setVerticalAlign(toCSSIdentifierValue(value).convertTo<EVerticalAlign>());
     else
-        state.style()->setVerticalAlignLength(primitiveValue.convertToLength(state.cssToLengthConversionData()));
+        state.style()->setVerticalAlignLength(toCSSPrimitiveValue(value).convertToLength(state.cssToLengthConversionData()));
 }
 
 static void resetEffectiveZoom(StyleResolverState& state)
 {
     // Reset the zoom in effect. This allows the setZoom method to accurately compute a new zoom in effect.
     state.setEffectiveZoom(state.parentStyle() ? state.parentStyle()->effectiveZoom() : ComputedStyle::initialZoom());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
     state.setZoom(ComputedStyle::initialZoom());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
     state.setZoom(state.parentStyle()->zoom());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyZoom(StyleResolverState& state, const CSSValue& value)
 {
-    SECURITY_DCHECK(value.isPrimitiveValue());
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    SECURITY_DCHECK(value.isPrimitiveValue() || value.isIdentifierValue());
 
-    if (primitiveValue.getValueID() == CSSValueNormal) {
-        resetEffectiveZoom(state);
-        state.setZoom(ComputedStyle::initialZoom());
-    } else if (primitiveValue.getValueID() == CSSValueReset) {
-        state.setEffectiveZoom(ComputedStyle::initialZoom());
-        state.setZoom(ComputedStyle::initialZoom());
-    } else if (primitiveValue.getValueID() == CSSValueDocument) {
-        float docZoom = state.rootElementStyle() ? state.rootElementStyle()->zoom() : ComputedStyle::initialZoom();
-        state.setEffectiveZoom(docZoom);
-        state.setZoom(docZoom);
-    } else if (primitiveValue.isPercentage()) {
-        resetEffectiveZoom(state);
-        if (float percent = primitiveValue.getFloatValue())
-            state.setZoom(percent / 100.0f);
-    } else if (primitiveValue.isNumber()) {
-        resetEffectiveZoom(state);
-        if (float number = primitiveValue.getFloatValue())
-            state.setZoom(number);
+    if (value.isIdentifierValue()) {
+        const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+        if (identifierValue.getValueID() == CSSValueNormal) {
+            resetEffectiveZoom(state);
+            state.setZoom(ComputedStyle::initialZoom());
+        } else if (identifierValue.getValueID() == CSSValueReset) {
+            state.setEffectiveZoom(ComputedStyle::initialZoom());
+            state.setZoom(ComputedStyle::initialZoom());
+        } else if (identifierValue.getValueID() == CSSValueDocument) {
+            float docZoom = state.rootElementStyle() ? state.rootElementStyle()->zoom() : ComputedStyle::initialZoom();
+            state.setEffectiveZoom(docZoom);
+            state.setZoom(docZoom);
+        }
+    } else if (value.isPrimitiveValue()) {
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+        if (primitiveValue.isPercentage()) {
+            resetEffectiveZoom(state);
+            if (float percent = primitiveValue.getFloatValue())
+                state.setZoom(percent / 100.0f);
+        } else if (primitiveValue.isNumber()) {
+            resetEffectiveZoom(state);
+            if (float number = primitiveValue.getFloatValue())
+                state.setZoom(number);
+        }
     }
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitBorderImage(StyleResolverState& state, const CSSValue& value)
 {
     NinePieceImage image;
     CSSToStyleMap::mapNinePieceImage(state, CSSPropertyWebkitBorderImage, value, image);
     state.style()->setBorderImage(image);
 }
 
@@ skipping 10 matching lines @@
     state.style()->setTextEmphasisMark(state.parentStyle()->getTextEmphasisMark());
     state.style()->setTextEmphasisCustomMark(state.parentStyle()->textEmphasisCustomMark());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state, const CSSValue& value)
 {
     if (value.isValueList()) {
         const CSSValueList& list = toCSSValueList(value);
         DCHECK_EQ(list.length(), 2U);
         for (unsigned i = 0; i < 2; ++i) {
-            const CSSPrimitiveValue& value = toCSSPrimitiveValue(list.item(i));
+            const CSSIdentifierValue& value = toCSSIdentifierValue(list.item(i));
             if (value.getValueID() == CSSValueFilled || value.getValueID() == CSSValueOpen)
                 state.style()->setTextEmphasisFill(value.convertTo<TextEmphasisFill>());
             else
                 state.style()->setTextEmphasisMark(value.convertTo<TextEmphasisMark>());
         }
         state.style()->setTextEmphasisCustomMark(nullAtom);
         return;
     }
 
     if (value.isStringValue()) {
         state.style()->setTextEmphasisFill(TextEmphasisFillFilled);
         state.style()->setTextEmphasisMark(TextEmphasisMarkCustom);
         state.style()->setTextEmphasisCustomMark(AtomicString(toCSSStringValue(value).value()));
         return;
     }
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
 
     state.style()->setTextEmphasisCustomMark(nullAtom);
 
-    if (primitiveValue.getValueID() == CSSValueFilled || primitiveValue.getValueID() == CSSValueOpen) {
-        state.style()->setTextEmphasisFill(primitiveValue.convertTo<TextEmphasisFill>());
+    if (identifierValue.getValueID() == CSSValueFilled || identifierValue.getValueID() == CSSValueOpen) {
+        state.style()->setTextEmphasisFill(identifierValue.convertTo<TextEmphasisFill>());
         state.style()->setTextEmphasisMark(TextEmphasisMarkAuto);
     } else {
         state.style()->setTextEmphasisFill(TextEmphasisFillFilled);
-        state.style()->setTextEmphasisMark(primitiveValue.convertTo<TextEmphasisMark>());
+        state.style()->setTextEmphasisMark(identifierValue.convertTo<TextEmphasisMark>());
     }
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyWillChange(StyleResolverState& state)
 {
     state.style()->setWillChangeContents(false);
     state.style()->setWillChangeScrollPosition(false);
     state.style()->setWillChangeProperties(Vector<CSSPropertyID>());
     state.style()->setSubtreeWillChangeContents(state.parentStyle()->subtreeWillChangeContents());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyWillChange(StyleResolverState& state)
 {
     state.style()->setWillChangeContents(state.parentStyle()->willChangeContents());
     state.style()->setWillChangeScrollPosition(state.parentStyle()->willChangeScrollPosition());
     state.style()->setWillChangeProperties(state.parentStyle()->willChangeProperties());
     state.style()->setSubtreeWillChangeContents(state.parentStyle()->subtreeWillChangeContents());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWillChange(StyleResolverState& state, const CSSValue& value)
 {
     bool willChangeContents = false;
     bool willChangeScrollPosition = false;
     Vector<CSSPropertyID> willChangeProperties;
 
-    if (value.isPrimitiveValue()) {
-        DCHECK_EQ(toCSSPrimitiveValue(value).getValueID(), CSSValueAuto);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueAuto);
     } else {
         DCHECK(value.isValueList());
         for (auto& willChangeValue : toCSSValueList(value)) {
             if (willChangeValue->isCustomIdentValue())
                 willChangeProperties.append(toCSSCustomIdentValue(*willChangeValue).valueAsPropertyID());
-            else if (toCSSPrimitiveValue(*willChangeValue).getValueID() == CSSValueContents)
+            else if (toCSSIdentifierValue(*willChangeValue).getValueID() == CSSValueContents)
                 willChangeContents = true;
-            else if (toCSSPrimitiveValue(*willChangeValue).getValueID() == CSSValueScrollPosition)
+            else if (toCSSIdentifierValue(*willChangeValue).getValueID() == CSSValueScrollPosition)
                 willChangeScrollPosition = true;
             else
                 NOTREACHED();
         }
     }
     state.style()->setWillChangeContents(willChangeContents);
     state.style()->setWillChangeScrollPosition(willChangeScrollPosition);
     state.style()->setWillChangeProperties(willChangeProperties);
     state.style()->setSubtreeWillChangeContents(willChangeContents || state.parentStyle()->subtreeWillChangeContents());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyContent(StyleResolverState& state)
 {
     state.style()->setContent(nullptr);
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyContent(StyleResolverState&)
 {
     // FIXME: In CSS3, it will be possible to inherit content. In CSS2 it is not. This
     // note is a reminder that eventually "inherit" needs to be supported.
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyContent(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue()) {
-        DCHECK(toCSSPrimitiveValue(value).getValueID() == CSSValueNormal || toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    if (value.isIdentifierValue()) {
+        DCHECK(toCSSIdentifierValue(value).getValueID() == CSSValueNormal || toCSSIdentifierValue(value).getValueID() == CSSValueNone);
         state.style()->setContent(nullptr);
         return;
     }
 
     ContentData* firstContent = nullptr;
     ContentData* prevContent = nullptr;
     for (auto& item : toCSSValueList(value)) {
         ContentData* nextContent = nullptr;
         if (item->isImageGeneratorValue() || item->isImageSetValue() || item->isImageValue()) {
             nextContent = ContentData::create(state.styleImage(CSSPropertyContent, *item));
         } else if (item->isCounterValue()) {
             const CSSCounterValue* counterValue = toCSSCounterValue(item.get());
             EListStyleType listStyleType = NoneListStyle;
             CSSValueID listStyleIdent = counterValue->listStyle();
             if (listStyleIdent != CSSValueNone)
                 listStyleType = static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
             std::unique_ptr<CounterContent> counter = wrapUnique(new CounterContent(AtomicString(counterValue->identifier()), listStyleType, AtomicString(counterValue->separator())));
             nextContent = ContentData::create(std::move(counter));
-        } else if (item->isPrimitiveValue()) {
+        } else if (item->isIdentifierValue()) {
             QuoteType quoteType;
-            switch (toCSSPrimitiveValue(*item).getValueID()) {
+            switch (toCSSIdentifierValue(*item).getValueID()) {
             default:
                 NOTREACHED();
             case CSSValueOpenQuote:
                 quoteType = OPEN_QUOTE;
                 break;
             case CSSValueCloseQuote:
                 quoteType = CLOSE_QUOTE;
                 break;
             case CSSValueNoOpenQuote:
                 quoteType = NO_OPEN_QUOTE;
@@ skipping 33 matching lines @@
             prevContent->setNext(nextContent);
 
         prevContent = nextContent;
     }
     DCHECK(firstContent);
     state.style()->setContent(firstContent);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitLocale(StyleResolverState& state, const CSSValue& value)
 {
-    if (value.isPrimitiveValue()) {
-        DCHECK_EQ(toCSSPrimitiveValue(value).getValueID(), CSSValueAuto);
+    if (value.isIdentifierValue()) {
+        DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueAuto);
         state.fontBuilder().setLocale(nullptr);
     } else {
         state.fontBuilder().setLocale(LayoutLocale::get(AtomicString(toCSSStringValue(value).value())));
     }
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAppRegion(StyleResolverState&)
 {
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAppRegion(StyleResolverState&)
 {
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitAppRegion(StyleResolverState& state, const CSSValue& value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    state.style()->setDraggableRegionMode(primitiveValue.getValueID() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    state.style()->setDraggableRegionMode(identifierValue.getValueID() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
     state.document().setHasAnnotatedRegions(true);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWritingMode(StyleResolverState& state, const CSSValue& value)
 {
-    state.setWritingMode(toCSSPrimitiveValue(value).convertTo<WritingMode>());
+    state.setWritingMode(toCSSIdentifierValue(value).convertTo<WritingMode>());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitWritingMode(StyleResolverState& state, const CSSValue& value)
 {
-    state.setWritingMode(toCSSPrimitiveValue(value).convertTo<WritingMode>());
+    state.setWritingMode(toCSSIdentifierValue(value).convertTo<WritingMode>());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyTextOrientation(StyleResolverState& state, const CSSValue& value)
 {
-    state.setTextOrientation(toCSSPrimitiveValue(value).convertTo<TextOrientation>());
+    state.setTextOrientation(toCSSIdentifierValue(value).convertTo<TextOrientation>());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextOrientation(StyleResolverState& state, const CSSValue& value)
 {
-    state.setTextOrientation(toCSSPrimitiveValue(value).convertTo<TextOrientation>());
+    state.setTextOrientation(toCSSIdentifierValue(value).convertTo<TextOrientation>());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyVariable(StyleResolverState& state, const CSSValue& value)
 {
     const CSSCustomPropertyDeclaration& declaration = toCSSCustomPropertyDeclaration(value);
     const AtomicString& name = declaration.name();
     const PropertyRegistry::Registration* registration = nullptr;
     const PropertyRegistry* registry = state.document().propertyRegistry();
     if (registry)
         registration = registry->registration(name);
@@ skipping 47 matching lines @@
     EBaselineShift baselineShift = parentSvgStyle.baselineShift();
     SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
     svgStyle.setBaselineShift(baselineShift);
     if (baselineShift == BS_LENGTH)
         svgStyle.setBaselineShiftValue(parentSvgStyle.baselineShiftValue());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyBaselineShift(StyleResolverState& state, const CSSValue& value)
 {
     SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (!primitiveValue.isValueID()) {
+    if (!value.isIdentifierValue()) {
         svgStyle.setBaselineShift(BS_LENGTH);
-        svgStyle.setBaselineShiftValue(StyleBuilderConverter::convertLength(state, primitiveValue));
+        svgStyle.setBaselineShiftValue(StyleBuilderConverter::convertLength(state, toCSSPrimitiveValue(value)));
         return;
     }
-    switch (primitiveValue.getValueID()) {
+    switch (toCSSIdentifierValue(value).getValueID()) {
     case CSSValueBaseline:
         svgStyle.setBaselineShift(BS_LENGTH);
         svgStyle.setBaselineShiftValue(Length(Fixed));
         return;
     case CSSValueSub:
         svgStyle.setBaselineShift(BS_SUB);
         return;
     case CSSValueSuper:
         svgStyle.setBaselineShift(BS_SUPER);
         return;
     default:
         NOTREACHED();
     }
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyPosition(StyleResolverState& state)
 {
     if (!state.parentNode()->isDocumentNode())
         state.style()->setPosition(state.parentStyle()->position());
 }
 
 } // namespace blink