Cleanup usage of CSSPropertyID and CSSValueID inside Blink.

Source/core/css/CSSPrimitiveValue.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 Apple Inc. 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,
@@ skipping 75 matching lines @@
     case CSSPrimitiveValue::CSS_VW:
     case CSSPrimitiveValue::CSS_VH:
     case CSSPrimitiveValue::CSS_VMIN:
     case CSSPrimitiveValue::CSS_VMAX:
     case CSSPrimitiveValue::CSS_FR:
         return true;
     case CSSPrimitiveValue::CSS_ATTR:
     case CSSPrimitiveValue::CSS_COUNTER:
     case CSSPrimitiveValue::CSS_COUNTER_NAME:
     case CSSPrimitiveValue::CSS_IDENT:
+    case CSSPrimitiveValue::CSS_PROPERTY_ID:
+    case CSSPrimitiveValue::CSS_VALUE_ID:
     case CSSPrimitiveValue::CSS_PAIR:
     case CSSPrimitiveValue::CSS_PARSER_HEXCOLOR:
     case CSSPrimitiveValue::CSS_PARSER_IDENTIFIER:
     case CSSPrimitiveValue::CSS_PARSER_INTEGER:
     case CSSPrimitiveValue::CSS_PARSER_OPERATOR:
     case CSSPrimitiveValue::CSS_RECT:
     case CSSPrimitiveValue::CSS_QUAD:
     case CSSPrimitiveValue::CSS_RGBCOLOR:
     case CSSPrimitiveValue::CSS_SHAPE:
     case CSSPrimitiveValue::CSS_STRING:
@@ skipping 51 matching lines @@
 
 typedef HashMap<const CSSPrimitiveValue*, String> CSSTextCache;
 static CSSTextCache& cssTextCache()
 {
     DEFINE_STATIC_LOCAL(CSSTextCache, cache, ());
     return cache;
 }
 
 unsigned short CSSPrimitiveValue::primitiveType() const 
 {
+    if (m_primitiveUnitType == CSS_PROPERTY_ID || m_primitiveUnitType == CSS_VALUE_ID)
+        return CSS_IDENT;
+
     if (m_primitiveUnitType != CSSPrimitiveValue::CSS_CALC)
         return m_primitiveUnitType; 
     
     switch (m_value.calc->category()) {
     case CalcNumber:
         return CSSPrimitiveValue::CSS_NUMBER;
     case CalcPercent:
         return CSSPrimitiveValue::CSS_PERCENTAGE;
     case CalcLength:
         return CSSPrimitiveValue::CSS_PX;
     case CalcPercentNumber:
         return CSSPrimitiveValue::CSS_CALC_PERCENTAGE_WITH_NUMBER;
     case CalcPercentLength:
         return CSSPrimitiveValue::CSS_CALC_PERCENTAGE_WITH_LENGTH;
     case CalcVariable:
         return CSSPrimitiveValue::CSS_UNKNOWN; // The type of a calculation containing a variable cannot be known until the value of the variable is determined.
     case CalcOther:
         return CSSPrimitiveValue::CSS_UNKNOWN;
     }
     return CSSPrimitiveValue::CSS_UNKNOWN;
 }
 
-static const AtomicString& valueOrPropertyName(int valueOrPropertyID)
+static const AtomicString& propertyName(CSSPropertyID propertyID)
 {
-    ASSERT_ARG(valueOrPropertyID, valueOrPropertyID >= 0);
-    ASSERT_ARG(valueOrPropertyID, valueOrPropertyID < numCSSValueKeywords || (valueOrPropertyID >= firstCSSProperty && valueOrPropertyID < firstCSSProperty + numCSSProperties));
+    ASSERT_ARG(propertyID, propertyID >= 0);
+    ASSERT_ARG(propertyID, (propertyID >= firstCSSProperty && propertyID < firstCSSProperty + numCSSProperties));
 
-    if (valueOrPropertyID < 0)
+    if (propertyID < 0)
         return nullAtom;
 
-    if (valueOrPropertyID < numCSSValueKeywords) {
-        static AtomicString* keywordStrings = new AtomicString[numCSSValueKeywords]; // Leaked intentionally.
-        AtomicString& keywordString = keywordStrings[valueOrPropertyID];
-        if (keywordString.isNull())
-            keywordString = getValueName(valueOrPropertyID);
-        return keywordString;
-    }
-
-    return getPropertyNameAtomicString(static_cast<CSSPropertyID>(valueOrPropertyID));
+    return getPropertyNameAtomicString(propertyID);
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(int ident)
+static const AtomicString& valueName(CSSValueID valueID)
+{
+    ASSERT_ARG(valueID, valueID >= 0);
+    ASSERT_ARG(valueID, valueID < numCSSValueKeywords);
+
+    if (valueID < 0)
+        return nullAtom;
+
+    static AtomicString* keywordStrings = new AtomicString[numCSSValueKeywords]; // Leaked intentionally.
+    AtomicString& keywordString = keywordStrings[valueID];
+    if (keywordString.isNull())
+        keywordString = getValueName(valueID);
+    return keywordString;
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(CSSValueID valueID)
     : CSSValue(PrimitiveClass)
 {
-    m_primitiveUnitType = CSS_IDENT;
-    m_value.ident = ident;
+    m_primitiveUnitType = CSS_VALUE_ID;
+    m_value.valueID = valueID;
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(CSSPropertyID propertyID)
+    : CSSValue(PrimitiveClass)
+{
+    m_primitiveUnitType = CSS_PROPERTY_ID;
+    m_value.propertyID = propertyID;
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(int parserOperator)
+    : CSSValue(PrimitiveClass)
+{
+    m_primitiveUnitType = CSS_PARSER_OPERATOR;
+    m_value.parserOperator = parserOperator;
 }
 
 CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitTypes type)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = type;
     ASSERT(std::isfinite(num));
     m_value.num = num;
 }
 
@@ skipping 11 matching lines @@
 {
     m_primitiveUnitType = CSS_RGBCOLOR;
     m_value.rgbcolor = color;
 }
 
 CSSPrimitiveValue::CSSPrimitiveValue(const Length& length)
     : CSSValue(PrimitiveClass)
 {
     switch (length.type()) {
         case Auto:
-            m_primitiveUnitType = CSS_IDENT;
-            m_value.ident = CSSValueAuto;
+            m_primitiveUnitType = CSS_VALUE_ID;
+            m_value.valueID = CSSValueAuto;
             break;
         case WebCore::Fixed:
             m_primitiveUnitType = CSS_PX;
             m_value.num = length.value();
             break;
         case Intrinsic:
-            m_primitiveUnitType = CSS_IDENT;
-            m_value.ident = CSSValueIntrinsic;
+            m_primitiveUnitType = CSS_VALUE_ID;
+            m_value.valueID = CSSValueIntrinsic;
             break;
         case MinIntrinsic:
-            m_primitiveUnitType = CSS_IDENT;
-            m_value.ident = CSSValueMinIntrinsic;
+            m_primitiveUnitType = CSS_VALUE_ID;
+            m_value.valueID = CSSValueMinIntrinsic;
             break;
         case MinContent:
-            m_primitiveUnitType = CSS_IDENT;
-            m_value.ident = CSSValueWebkitMinContent;
+            m_primitiveUnitType = CSS_VALUE_ID;
+            m_value.valueID = CSSValueWebkitMinContent;
             break;
         case MaxContent:
-            m_primitiveUnitType = CSS_IDENT;
-            m_value.ident = CSSValueWebkitMaxContent;
+            m_primitiveUnitType = CSS_VALUE_ID;
+            m_value.valueID = CSSValueWebkitMaxContent;
             break;
         case FillAvailable:
-            m_primitiveUnitType = CSS_IDENT;
-            m_value.ident = CSSValueWebkitFillAvailable;
+            m_primitiveUnitType = CSS_VALUE_ID;
+            m_value.valueID = CSSValueWebkitFillAvailable;
             break;
         case FitContent:
-            m_primitiveUnitType = CSS_IDENT;
-            m_value.ident = CSSValueWebkitFitContent;
+            m_primitiveUnitType = CSS_VALUE_ID;
+            m_value.valueID = CSSValueWebkitFitContent;
             break;
         case Percent:
             m_primitiveUnitType = CSS_PERCENTAGE;
             ASSERT(std::isfinite(length.percent()));
             m_value.num = length.percent();
             break;
         case ViewportPercentageWidth:
             m_primitiveUnitType = CSS_VW;
             m_value.num = length.viewportPercentageLength();
             break;
@@ skipping 127 matching lines @@
     case CSS_DPI:
     case CSS_DPCM:
     case CSS_FR:
     case CSS_IDENT:
     case CSS_RGBCOLOR:
     case CSS_DIMENSION:
     case CSS_UNKNOWN:
     case CSS_UNICODE_RANGE:
     case CSS_PARSER_OPERATOR:
     case CSS_PARSER_IDENTIFIER:
+    case CSS_PROPERTY_ID:
+    case CSS_VALUE_ID:
         break;
     }
     m_primitiveUnitType = 0;
     if (m_hasCachedCSSText) {
         cssTextCache().remove(this);
         m_hasCachedCSSText = false;
     }
 }
 
 double CSSPrimitiveValue::computeDegrees()
@@ skipping 287 matching lines @@
 
 String CSSPrimitiveValue::getStringValue(ExceptionCode& ec) const
 {
     ec = 0;
     switch (m_primitiveUnitType) {
         case CSS_STRING:
         case CSS_ATTR:
         case CSS_URI:
         case CSS_VARIABLE_NAME:
             return m_value.string;
-        case CSS_IDENT:
-            return valueOrPropertyName(m_value.ident);
+        case CSS_VALUE_ID:
+            return valueName(m_value.valueID);
+        case CSS_PROPERTY_ID:
+            return propertyName(m_value.propertyID);
         default:
             ec = INVALID_ACCESS_ERR;
             break;
     }
 
     return String();
 }
 
 String CSSPrimitiveValue::getStringValue() const
 {
     switch (m_primitiveUnitType) {
         case CSS_STRING:
         case CSS_ATTR:
         case CSS_URI:
         case CSS_VARIABLE_NAME:
             return m_value.string;
-        case CSS_IDENT:
-            return valueOrPropertyName(m_value.ident);
+        case CSS_VALUE_ID:
+            return valueName(m_value.valueID);
+        case CSS_PROPERTY_ID:
+            return propertyName(m_value.propertyID);
         default:
             break;
     }
 
     return String();
 }
 
 Counter* CSSPrimitiveValue::getCounterValue(ExceptionCode& ec) const
 {
     ec = 0;
@@ skipping 157 matching lines @@
             break;
         case CSS_DIMENSION:
             text = m_value.string;
             break;
         case CSS_STRING:
             text = quoteCSSStringIfNeeded(m_value.string);
             break;
         case CSS_URI:
             text = "url(" + quoteCSSURLIfNeeded(m_value.string) + ")";
             break;
-        case CSS_IDENT:
-            text = valueOrPropertyName(m_value.ident);
+        case CSS_VALUE_ID:
+            text = valueName(m_value.valueID);
+            break;
+        case CSS_PROPERTY_ID:
+            text = propertyName(m_value.propertyID);
             break;
         case CSS_ATTR: {
             StringBuilder result;
             result.reserveCapacity(6 + m_value.string->length());
             result.appendLiteral("attr(");
             result.append(m_value.string);
             result.append(')');
 
             text = result.toString();
             break;
@@ skipping 61 matching lines @@
             }
 
             result.append(')');
             text = String::adopt(result);
             break;
         }
         case CSS_PAIR:
             text = getPairValue()->cssText();
             break;
         case CSS_PARSER_OPERATOR: {
-            char c = static_cast<char>(m_value.ident);
+            char c = static_cast<char>(m_value.parserOperator);
             text = String(&c, 1U);
             break;
         }
         case CSS_PARSER_IDENTIFIER:
             text = quoteCSSStringIfNeeded(m_value.string);
             break;
         case CSS_CALC:
             text = m_value.calc->cssText();
             break;
         case CSS_SHAPE:
@@ skipping 138 matching lines @@
     case CSS_TURN:
     case CSS_VW:
     case CSS_VH:
     case CSS_VMIN:
     case CSS_VMAX:
     case CSS_DPPX:
     case CSS_DPI:
     case CSS_DPCM:
         result = CSSPrimitiveValue::create(m_value.num, static_cast<UnitTypes>(m_primitiveUnitType));
         break;
-    case CSS_IDENT:
-        result = CSSPrimitiveValue::createIdentifier(m_value.ident);
+    case CSS_PROPERTY_ID:
+        result = CSSPrimitiveValue::createIdentifier(m_value.propertyID);
+        break;
+    case CSS_VALUE_ID:
+        result = CSSPrimitiveValue::createIdentifier(m_value.valueID);
         break;
     case CSS_RGBCOLOR:
         result = CSSPrimitiveValue::createColor(m_value.rgbcolor);
         break;
     case CSS_DIMENSION:
     case CSS_UNKNOWN:
     case CSS_PARSER_OPERATOR:
     case CSS_PARSER_IDENTIFIER:
     case CSS_PARSER_HEXCOLOR:
         ASSERT_NOT_REACHED();
@@ skipping 35 matching lines @@
     case CSS_S:
     case CSS_HZ:
     case CSS_KHZ:
     case CSS_TURN:
     case CSS_VW:
     case CSS_VH:
     case CSS_VMIN:
     case CSS_VMAX:
     case CSS_DIMENSION:
         return m_value.num == other.m_value.num;
-    case CSS_IDENT:
-        return valueOrPropertyName(m_value.ident) == valueOrPropertyName(other.m_value.ident);
+    case CSS_PROPERTY_ID:
+        return propertyName(m_value.propertyID) == propertyName(other.m_value.propertyID);
+    case CSS_VALUE_ID:
+        return valueName(m_value.valueID) == valueName(other.m_value.valueID);
     case CSS_STRING:
     case CSS_URI:
     case CSS_ATTR:
     case CSS_COUNTER_NAME:
     case CSS_PARSER_IDENTIFIER:
     case CSS_PARSER_HEXCOLOR:
     case CSS_VARIABLE_NAME:
         return equal(m_value.string, other.m_value.string);
     case CSS_COUNTER:
         return m_value.counter && other.m_value.counter && m_value.counter->equals(*other.m_value.counter);
     case CSS_RECT:
         return m_value.rect && other.m_value.rect && m_value.rect->equals(*other.m_value.rect);
     case CSS_QUAD:
         return m_value.quad && other.m_value.quad && m_value.quad->equals(*other.m_value.quad);
     case CSS_RGBCOLOR:
         return m_value.rgbcolor == other.m_value.rgbcolor;
     case CSS_PAIR:
         return m_value.pair && other.m_value.pair && m_value.pair->equals(*other.m_value.pair);
     case CSS_PARSER_OPERATOR:
-        return m_value.ident == other.m_value.ident;
+        return m_value.valueID == other.m_value.valueID;
     case CSS_CALC:
         return m_value.calc && other.m_value.calc && m_value.calc->equals(*other.m_value.calc);
     case CSS_SHAPE:
         return m_value.shape && other.m_value.shape && m_value.shape->equals(*other.m_value.shape);
     }
     return false;
 }
 
 void CSSPrimitiveValue::reportDescendantMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
@@ skipping 26 matching lines @@
         break;
     case CSS_CALC:
         info.addMember(m_value.calc, "value.calc");
         break;
     default:
         break;
     }
 }
 
 } // namespace WebCore