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 162 matching lines @@
   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 51 matching lines @@
           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>());
+            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>());
+      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;
@@ skipping 31 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);
+  const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
   state.style()->setOutlineStyleIsAuto(
-      primitiveValue.convertTo<OutlineIsAuto>());
-  state.style()->setOutlineStyle(primitiveValue.convertTo<EBorderStyle>());
+      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));
     case CSSValueB4:
@@ skipping 13 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>(
+          toCSSPrimitiveValue(first).computeLength<float>(
               state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)),
-          second.computeLength<float>(
+          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>(
+      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 26 matching lines @@
   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 &&
+    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());
 }
 
@@ skipping 12 matching lines @@
 }
 
 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())
+    if (listValue->isPrimitiveValue()) {
       lengthOrPercentageValue =
-          primitiveValue->convertToLength(state.cssToLengthConversionData());
-    else if (primitiveValue->getValueID() == CSSValueEachLine)
+          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>());
-  else
+  if (value.isIdentifierValue()) {
+    state.style()->setVerticalAlign(
+        toCSSIdentifierValue(value).convertTo<EVerticalAlign>());
+  } else {
     state.style()->setVerticalAlignLength(
-        primitiveValue.convertToLength(state.cssToLengthConversionData()));
+        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 17 matching lines @@
       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) {
+  if (identifierValue.getValueID() == CSSValueFilled ||
+      identifierValue.getValueID() == CSSValueOpen) {
     state.style()->setTextEmphasisFill(
-        primitiveValue.convertTo<TextEmphasisFill>());
+        identifierValue.convertTo<TextEmphasisFill>());
     state.style()->setTextEmphasisMark(TextEmphasisMarkAuto);
   } else {
     state.style()->setTextEmphasisFill(TextEmphasisFillFilled);
     state.style()->setTextEmphasisMark(
-        primitiveValue.convertTo<TextEmphasisMark>());
+        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());
@@ skipping 11 matching lines @@
       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() ==
+      else if (toCSSIdentifierValue(*willChangeValue).getValueID() ==
                CSSValueContents)
         willChangeContents = true;
-      else if (toCSSPrimitiveValue(*willChangeValue).getValueID() ==
+      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 36 matching lines @@
 
     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);
+  const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
   state.style()->setDraggableRegionMode(
-      primitiveValue.getValueID() == CSSValueDrag ? DraggableRegionDrag
-                                                  : DraggableRegionNoDrag);
+      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>());
+      toCSSIdentifierValue(value).convertTo<TextOrientation>());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextOrientation(
     StyleResolverState& state,
     const CSSValue& value) {
   state.setTextOrientation(
-      toCSSPrimitiveValue(value).convertTo<TextOrientation>());
+      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();
@@ skipping 86 matching lines @@
   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