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::
@@ skipping 489 matching lines @@
   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);
 }
 
@@ skipping 21 matching lines @@
   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 121 matching lines @@
                    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 93 matching lines @@
       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::create(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