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 53 matching lines @@
     fontFace->initCSSFontFace(static_cast<const unsigned char*>(source->baseAddress()), source->byteLength());
     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 148 matching lines @@
         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 95 matching lines @@
     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 32 matching lines @@
 
 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 94 matching lines @@
 {
     return m_cssFontFace->hadBlankText();
 }
 
 bool FontFace::hasPendingActivity() const
 {
     return m_status == Loading && getExecutionContext() && !getExecutionContext()->activeDOMObjectsAreStopped();
 }
 
 } // namespace blink