Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/Source/core/css/FontFace.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 21 matching lines @@
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/StringOrArrayBufferOrArrayBufferView.h"
 #include "core/CSSValueKeywords.h"
 #include "core/css/BinaryDataFontFaceSource.h"
 #include "core/css/CSSFontFace.h"
 #include "core/css/CSSFontFaceSrcValue.h"
 #include "core/css/CSSFontFamilyValue.h"
 #include "core/css/CSSFontSelector.h"
-#include "core/css/CSSPrimitiveValue.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/FontFaceDescriptors.h"
 #include "core/css/LocalFontFaceSource.h"
 #include "core/css/RemoteFontFaceSource.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMArrayBufferView.h"
@@ skipping 69 matching lines @@
   return fontFace;
 }
 
 FontFace* FontFace::create(Document* document,
                            const StyleRuleFontFace* fontFaceRule) {
   const StylePropertySet& properties = fontFaceRule->properties();
 
   // Obtain the font-family property and the src property. Both must be defined.
   const CSSValue* family =
       properties.getPropertyCSSValue(CSSPropertyFontFamily);
-  if (!family || (!family->isFontFamilyValue() && !family->isPrimitiveValue()))
+  if (!family || (!family->isFontFamilyValue() && !family->isIdentifierValue()))
     return nullptr;
   const CSSValue* src = properties.getPropertyCSSValue(CSSPropertySrc);
   if (!src || !src->isValueList())
     return nullptr;
 
   FontFace* fontFace = new FontFace(document);
 
   if (fontFace->setFamilyValue(*family) &&
       fontFace->setPropertyFromStyle(properties, CSSPropertyFontStyle) &&
       fontFace->setPropertyFromStyle(properties, CSSPropertyFontWeight) &&
@@ skipping 158 matching lines @@
       ASSERT_NOT_REACHED();
       return false;
   }
   return true;
 }
 
 bool FontFace::setFamilyValue(const CSSValue& familyValue) {
   AtomicString family;
   if (familyValue.isFontFamilyValue()) {
     family = AtomicString(toCSSFontFamilyValue(familyValue).value());
-  } else if (toCSSPrimitiveValue(familyValue).isValueID()) {
+  } else if (familyValue.isIdentifierValue()) {
     // We need to use the raw text for all the generic family types, since @font-face is a way of actually
     // defining what font to use for those types.
-    switch (toCSSPrimitiveValue(familyValue).getValueID()) {
+    switch (toCSSIdentifierValue(familyValue).getValueID()) {
       case CSSValueSerif:
         family = FontFamilyNames::webkit_serif;
         break;
       case CSSValueSansSerif:
         family = FontFamilyNames::webkit_sans_serif;
         break;
       case CSSValueCursive:
         family = FontFamilyNames::webkit_cursive;
         break;
       case CSSValueFantasy:
@@ skipping 93 matching lines @@
 void FontFace::loadInternal(ExecutionContext* context) {
   if (m_status != Unloaded)
     return;
 
   m_cssFontFace->load();
 }
 
 FontTraits FontFace::traits() const {
   FontStretch stretch = FontStretchNormal;
   if (m_stretch) {
-    if (!m_stretch->isPrimitiveValue())
+    if (!m_stretch->isIdentifierValue())
       return 0;
 
-    switch (toCSSPrimitiveValue(m_stretch.get())->getValueID()) {
+    switch (toCSSIdentifierValue(m_stretch.get())->getValueID()) {
       case CSSValueUltraCondensed:
         stretch = FontStretchUltraCondensed;
         break;
       case CSSValueExtraCondensed:
         stretch = FontStretchExtraCondensed;
         break;
       case CSSValueCondensed:
         stretch = FontStretchCondensed;
         break;
       case CSSValueSemiCondensed:
@@ skipping 11 matching lines @@
       case CSSValueUltraExpanded:
         stretch = FontStretchUltraExpanded;
         break;
       default:
         break;
     }
   }
 
   FontStyle style = FontStyleNormal;
   if (m_style) {
-    if (!m_style->isPrimitiveValue())
+    if (!m_style->isIdentifierValue())
       return 0;
 
-    switch (toCSSPrimitiveValue(m_style.get())->getValueID()) {
+    switch (toCSSIdentifierValue(m_style.get())->getValueID()) {
       case CSSValueNormal:
         style = FontStyleNormal;
         break;
       case CSSValueOblique:
         style = FontStyleOblique;
         break;
       case CSSValueItalic:
         style = FontStyleItalic;
         break;
       default:
         break;
     }
   }
 
   FontWeight weight = FontWeight400;
   if (m_weight) {
-    if (!m_weight->isPrimitiveValue())
+    if (!m_weight->isIdentifierValue())
       return 0;
 
-    switch (toCSSPrimitiveValue(m_weight.get())->getValueID()) {
+    switch (toCSSIdentifierValue(m_weight.get())->getValueID()) {
       case CSSValueBold:
       case CSSValue700:
         weight = FontWeight700;
         break;
       case CSSValueNormal:
       case CSSValue400:
         weight = FontWeight400;
         break;
       case CSSValue900:
         weight = FontWeight900;
@@ skipping 30 matching lines @@
   return FontTraits(style, weight, stretch);
 }
 
 size_t FontFace::approximateBlankCharacterCount() const {
   if (m_status == Loading)
     return m_cssFontFace->approximateBlankCharacterCount();
   return 0;
 }
 
 static FontDisplay CSSValueToFontDisplay(const CSSValue* value) {
-  if (value && value->isPrimitiveValue()) {
-    switch (toCSSPrimitiveValue(value)->getValueID()) {
+  if (value && value->isIdentifierValue()) {
+    switch (toCSSIdentifierValue(value)->getValueID()) {
       case CSSValueAuto:
         return FontDisplayAuto;
       case CSSValueBlock:
         return FontDisplayBlock;
       case CSSValueSwap:
         return FontDisplaySwap;
       case CSSValueFallback:
         return FontDisplayFallback;
       case CSSValueOptional:
         return FontDisplayOptional;
@@ skipping 97 matching lines @@
 bool FontFace::hadBlankText() const {
   return m_cssFontFace->hadBlankText();
 }
 
 bool FontFace::hasPendingActivity() const {
   return m_status == Loading && getExecutionContext() &&
          !getExecutionContext()->activeDOMObjectsAreStopped();
 }
 
 }  // namespace blink