Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

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

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "core/css/StylePropertySerializer.h"
 
 #include "core/CSSValueKeywords.h"
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPendingSubstitutionValue.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSValuePool.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include <bitset>
 
 namespace blink {
 
 StylePropertySerializer::StylePropertySetForSerializer::StylePropertySetForSerializer(const StylePropertySet& properties)
@@ skipping 460 matching lines @@
         return horizontalValueCSSText;
     return horizontalValueCSSText + ' ' + verticalValueCSSText;
 }
 
 void StylePropertySerializer::appendFontLonghandValueIfNotNormal(CSSPropertyID propertyID, StringBuilder& result) const
 {
     int foundPropertyIndex = m_propertySet.findPropertyIndex(propertyID);
     ASSERT(foundPropertyIndex != -1);
 
     const CSSValue* val = m_propertySet.propertyAt(foundPropertyIndex).value();
-    if (val->isPrimitiveValue() && toCSSPrimitiveValue(val)->getValueID() == CSSValueNormal)
+    if (val->isIdentifierValue() && toCSSIdentifierValue(val)->getValueID() == CSSValueNormal)
         return;
 
     char prefix = '\0';
     switch (propertyID) {
     case CSSPropertyFontStyle:
         break; // No prefix.
     case CSSPropertyFontFamily:
     case CSSPropertyFontStretch:
     case CSSPropertyFontVariantCaps:
     case CSSPropertyFontVariantLigatures:
     case CSSPropertyFontVariantNumeric:
     case CSSPropertyFontWeight:
         prefix = ' ';
         break;
     case CSSPropertyLineHeight:
         prefix = '/';
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     if (prefix && !result.isEmpty())
         result.append(prefix);
 
     String value;
     // In the font-variant shorthand a "none" ligatures value needs to be expanded.
     if (propertyID == CSSPropertyFontVariantLigatures
-        && val->isPrimitiveValue()
-        && toCSSPrimitiveValue(val)->getValueID() == CSSValueNone) {
+        && val->isIdentifierValue()
+        && toCSSIdentifierValue(val)->getValueID() == CSSValueNone) {
         value = "no-common-ligatures no-discretionary-ligatures no-historical-ligatures no-contextual";
     } else {
         value = m_propertySet.propertyAt(foundPropertyIndex).value()->cssText();
     }
 
     result.append(value);
 }
 
 String StylePropertySerializer::fontValue() const
 {
@@ skipping 10 matching lines @@
 
     PropertyValueForSerializer fontSizeProperty = m_propertySet.propertyAt(fontSizePropertyIndex);
     PropertyValueForSerializer fontFamilyProperty = m_propertySet.propertyAt(fontFamilyPropertyIndex);
     PropertyValueForSerializer fontVariantCapsProperty = m_propertySet.propertyAt(fontVariantCapsPropertyIndex);
     PropertyValueForSerializer fontVariantLigaturesProperty = m_propertySet.propertyAt(fontVariantLigaturesPropertyIndex);
     PropertyValueForSerializer fontVariantNumericProperty = m_propertySet.propertyAt(fontVariantNumericPropertyIndex);
 
     // Check that non-initial font-variant subproperties are not conflicting with this serialization.
     const CSSValue* ligaturesValue = fontVariantLigaturesProperty.value();
     const CSSValue* numericValue = fontVariantNumericProperty.value();
-    if ((ligaturesValue->isPrimitiveValue()
-        && toCSSPrimitiveValue(ligaturesValue)->getValueID() != CSSValueNormal)
+    if ((ligaturesValue->isIdentifierValue()
+        && toCSSIdentifierValue(ligaturesValue)->getValueID() != CSSValueNormal)
         || ligaturesValue->isValueList()
-        || (numericValue->isPrimitiveValue()
-        && toCSSPrimitiveValue(numericValue)->getValueID() != CSSValueNormal)
+        || (numericValue->isIdentifierValue()
+        && toCSSIdentifierValue(numericValue)->getValueID() != CSSValueNormal)
         || numericValue->isValueList())
         return emptyString();
 
     StringBuilder result;
     appendFontLonghandValueIfNotNormal(CSSPropertyFontStyle, result);
 
     const CSSValue* val = fontVariantCapsProperty.value();
-    if (val->isPrimitiveValue()
-        && (toCSSPrimitiveValue(val)->getValueID() != CSSValueSmallCaps
-        && toCSSPrimitiveValue(val)->getValueID() != CSSValueNormal))
+    if (val->isIdentifierValue()
+        && (toCSSIdentifierValue(val)->getValueID() != CSSValueSmallCaps
+        && toCSSIdentifierValue(val)->getValueID() != CSSValueNormal))
         return emptyString();
     appendFontLonghandValueIfNotNormal(CSSPropertyFontVariantCaps, result);
 
     appendFontLonghandValueIfNotNormal(CSSPropertyFontWeight, result);
     appendFontLonghandValueIfNotNormal(CSSPropertyFontStretch, result);
     if (!result.isEmpty())
         result.append(' ');
     result.append(fontSizeProperty.value()->cssText());
     appendFontLonghandValueIfNotNormal(CSSPropertyLineHeight, result);
     if (!result.isEmpty())
@@ skipping 109 matching lines @@
             if ((propertyIndex < size - 1 && m_propertySet.isPropertyImplicit(property))
                 && (property == CSSPropertyBackgroundRepeatX || property == CSSPropertyWebkitMaskRepeatX)) {
                 ASSERT(shorthand.properties()[propertyIndex + 1] == CSSPropertyBackgroundRepeatY
                     || shorthand.properties()[propertyIndex + 1] == CSSPropertyWebkitMaskRepeatY);
                 const CSSValue& yValue = values[propertyIndex + 1]->isValueList() ?
                     toCSSValueList(values[propertyIndex + 1])->item(layer) : *values[propertyIndex + 1];
 
 
                 // FIXME: At some point we need to fix this code to avoid returning an invalid shorthand,
                 // since some longhand combinations are not serializable into a single shorthand.
-                if (!value->isPrimitiveValue() || !yValue.isPrimitiveValue())
+                if (!value->isIdentifierValue() || !yValue.isIdentifierValue())
                     continue;
 
-                CSSValueID xId = toCSSPrimitiveValue(value)->getValueID();
-                CSSValueID yId = toCSSPrimitiveValue(yValue).getValueID();
+                CSSValueID xId = toCSSIdentifierValue(value)->getValueID();
+                CSSValueID yId = toCSSIdentifierValue(yValue).getValueID();
                 // Maybe advance propertyIndex to look at the next CSSValue in the list for the checks below.
                 if (xId == yId) {
                     useSingleWordShorthand = true;
                     property = shorthand.properties()[++propertyIndex];
                 } else if (xId == CSSValueRepeat && yId == CSSValueNoRepeat) {
                     useRepeatXShorthand = true;
                     property = shorthand.properties()[++propertyIndex];
                 } else if (xId == CSSValueNoRepeat && yId == CSSValueRepeat) {
                     useRepeatYShorthand = true;
                     property = shorthand.properties()[++propertyIndex];
@@ skipping 85 matching lines @@
         if (!result.isEmpty())
             result.append(' ');
         result.append(value);
     }
     return result.isEmpty() ? String() : result.toString();
 }
 
 static void appendBackgroundRepeatValue(StringBuilder& builder, const CSSValue& repeatXCSSValue, const CSSValue& repeatYCSSValue)
 {
     // FIXME: Ensure initial values do not appear in CSS_VALUE_LISTS.
-    DEFINE_STATIC_LOCAL(CSSPrimitiveValue, initialRepeatValue, (CSSPrimitiveValue::createIdentifier(CSSValueRepeat)));
-    const CSSPrimitiveValue& repeatX = repeatXCSSValue.isInitialValue() ? initialRepeatValue : toCSSPrimitiveValue(repeatXCSSValue);
-    const CSSPrimitiveValue& repeatY = repeatYCSSValue.isInitialValue() ? initialRepeatValue : toCSSPrimitiveValue(repeatYCSSValue);
+    DEFINE_STATIC_LOCAL(CSSIdentifierValue, initialRepeatValue, (CSSIdentifierValue::createIdentifier(CSSValueRepeat)));
+    const CSSIdentifierValue& repeatX = repeatXCSSValue.isInitialValue() ? initialRepeatValue : toCSSIdentifierValue(repeatXCSSValue);
+    const CSSIdentifierValue& repeatY = repeatYCSSValue.isInitialValue() ? initialRepeatValue : toCSSIdentifierValue(repeatYCSSValue);
     CSSValueID repeatXValueId = repeatX.getValueID();
     CSSValueID repeatYValueId = repeatY.getValueID();
     if (repeatXValueId == repeatYValueId) {
         builder.append(repeatX.cssText());
     } else if (repeatXValueId == CSSValueNoRepeat && repeatYValueId == CSSValueRepeat) {
         builder.append("repeat-y");
     } else if (repeatXValueId == CSSValueRepeat && repeatYValueId == CSSValueNoRepeat) {
         builder.append("repeat-x");
     } else {
         builder.append(repeatX.cssText());
         builder.append(' ');
         builder.append(repeatY.cssText());
     }
 }
 
 String StylePropertySerializer::backgroundRepeatPropertyValue() const
 {
     const CSSValue& repeatX = *m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatX);
     const CSSValue& repeatY = *m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatY);
 
     const CSSValueList* repeatXList = 0;
     int repeatXLength = 1;
     if (repeatX.isValueList()) {
         repeatXList = &toCSSValueList(repeatX);
         repeatXLength = repeatXList->length();
-    } else if (!repeatX.isPrimitiveValue()) {
+    } else if (!repeatX.isIdentifierValue()) {
         return String();
     }
 
     const CSSValueList* repeatYList = 0;
     int repeatYLength = 1;
     if (repeatY.isValueList()) {
         repeatYList = &toCSSValueList(repeatY);
         repeatYLength = repeatYList->length();
-    } else if (!repeatY.isPrimitiveValue()) {
+    } else if (!repeatY.isIdentifierValue()) {
         return String();
     }
 
     size_t shorthandLength = lowestCommonMultiple(repeatXLength, repeatYLength);
     StringBuilder builder;
     for (size_t i = 0; i < shorthandLength; ++i) {
         if (i)
             builder.append(", ");
 
         const CSSValue& xValue = repeatXList ? repeatXList->item(i % repeatXList->length()) : repeatX;
         const CSSValue& yValue = repeatYList ? repeatYList->item(i % repeatYList->length()) : repeatY;
         appendBackgroundRepeatValue(builder, xValue, yValue);
     }
     return builder.toString();
 }
 
 } // namespace blink