Remove unused CSSPrimitiveValue::CSS_PARSER_{OPERATOR,INTEGER,IDENTIFIER}

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 77 matching lines @@
     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:
     case CSSPrimitiveValue::CSS_UNICODE_RANGE:
     case CSSPrimitiveValue::CSS_UNKNOWN:
     case CSSPrimitiveValue::CSS_URI:
         return false;
     }
@@ skipping 163 matching lines @@
     m_value.valueID = valueID;
 }
 
 CSSPrimitiveValue::CSSPrimitiveValue(CSSPropertyID propertyID)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_PROPERTY_ID;
     m_value.propertyID = propertyID;
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(int parserOperator, UnitType type)
-    : CSSValue(PrimitiveClass)
-{
-    ASSERT(type == CSS_PARSER_OPERATOR);
-    m_primitiveUnitType = CSS_PARSER_OPERATOR;
-    m_value.parserOperator = parserOperator;
-}
-
 CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitType type)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = type;
     ASSERT(std::isfinite(num));
     m_value.num = num;
 }
 
 CSSPrimitiveValue::CSSPrimitiveValue(const String& str, UnitType type)
     : CSSValue(PrimitiveClass)
@@ skipping 189 matching lines @@
     case CSS_CALC_PERCENTAGE_WITH_LENGTH:
         ASSERT_NOT_REACHED();
         break;
     case CSS_SHAPE:
         // We must not call deref() when oilpan is enabled because m_value.shape is traced.
 #if !ENABLE(OILPAN)
         m_value.shape->deref();
 #endif
         break;
     case CSS_NUMBER:
-    case CSS_PARSER_INTEGER:
     case CSS_PERCENTAGE:
     case CSS_EMS:
     case CSS_EXS:
     case CSS_REMS:
     case CSS_CHS:
     case CSS_PX:
     case CSS_CM:
     case CSS_MM:
     case CSS_IN:
     case CSS_PT:
@@ skipping 12 matching lines @@
     case CSS_VMAX:
     case CSS_DPPX:
     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;
     }
 }
@@ skipping 506 matching lines @@
 
 static String formatNumber(double number, const char* characters)
 {
     return formatNumber(number, characters, strlen(characters));
 }
 
 const char* CSSPrimitiveValue::unitTypeToString(UnitType type)
 {
     switch (type) {
     case CSS_NUMBER:
-    case CSS_PARSER_INTEGER:
         return "";
     case CSS_PERCENTAGE:
         return "%";
     case CSS_EMS:
         return "em";
     case CSS_EXS:
         return "ex";
     case CSS_REMS:
         return "rem";
     case CSS_CHS:
@@ skipping 49 matching lines @@
     case CSS_VALUE_ID:
     case CSS_PROPERTY_ID:
     case CSS_ATTR:
     case CSS_COUNTER_NAME:
     case CSS_COUNTER:
     case CSS_RECT:
     case CSS_QUAD:
     case CSS_RGBCOLOR:
     case CSS_PARSER_HEXCOLOR:
     case CSS_PAIR:
-    case CSS_PARSER_OPERATOR:
-    case CSS_PARSER_IDENTIFIER:
     case CSS_CALC:
     case CSS_SHAPE:
     case CSS_IDENT:
     case CSS_UNICODE_RANGE:
     case CSS_CALC_PERCENTAGE_WITH_NUMBER:
     case CSS_CALC_PERCENTAGE_WITH_LENGTH:
         break;
     };
     ASSERT_NOT_REACHED();
     return "";
 }
 
 String CSSPrimitiveValue::customCSSText(CSSTextFormattingFlags formattingFlag) const
 {
     // FIXME: return the original value instead of a generated one (e.g. color
     // name if it was specified) - check what spec says about this
 
     if (m_hasCachedCSSText) {
         ASSERT(cssTextCache().contains(this));
         return cssTextCache().get(this);
     }
 
     String text;
     switch (m_primitiveUnitType) {
         case CSS_UNKNOWN:
             // FIXME
             break;
         case CSS_NUMBER:
-        case CSS_PARSER_INTEGER:
         case CSS_PERCENTAGE:
         case CSS_EMS:
         case CSS_EXS:
         case CSS_REMS:
         case CSS_CHS:
         case CSS_PX:
         case CSS_CM:
         case CSS_DPPX:
         case CSS_DPI:
         case CSS_DPCM:
@@ skipping 78 matching lines @@
             RGBA32 rgbColor = m_value.rgbcolor;
             if (m_primitiveUnitType == CSS_PARSER_HEXCOLOR)
                 Color::parseHexColor(m_value.string, rgbColor);
             Color color(rgbColor);
             text = color.serializedAsCSSComponentValue();
             break;
         }
         case CSS_PAIR:
             text = getPairValue()->cssText();
             break;
-        case CSS_PARSER_OPERATOR: {
-            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:
             text = m_value.shape->cssText();
             break;
     }
 
     ASSERT(!cssTextCache().contains(this));
     cssTextCache().set(this, text);
@@ skipping 27 matching lines @@
         break;
     case CSS_CALC:
         // CSSCalcValue is not exposed to the CSSOM, no need for a deep clone.
         result = CSSPrimitiveValue::create(m_value.calc);
         break;
     case CSS_SHAPE:
         // CSSShapeValue is not exposed to the CSSOM, no need for a deep clone.
         result = CSSPrimitiveValue::create(m_value.shape);
         break;
     case CSS_NUMBER:
-    case CSS_PARSER_INTEGER:
     case CSS_PERCENTAGE:
     case CSS_EMS:
     case CSS_EXS:
     case CSS_REMS:
     case CSS_CHS:
     case CSS_PX:
     case CSS_CM:
     case CSS_MM:
     case CSS_IN:
     case CSS_PT:
@@ skipping 20 matching lines @@
         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();
         break;
     }
     if (result)
         result->setCSSOMSafe();
 
     return result;
 }
 
 bool CSSPrimitiveValue::equals(const CSSPrimitiveValue& other) const
 {
     if (m_primitiveUnitType != other.m_primitiveUnitType)
         return false;
 
     switch (m_primitiveUnitType) {
     case CSS_UNKNOWN:
         return false;
     case CSS_NUMBER:
-    case CSS_PARSER_INTEGER:
     case CSS_PERCENTAGE:
     case CSS_EMS:
     case CSS_EXS:
     case CSS_REMS:
     case CSS_PX:
     case CSS_CM:
     case CSS_DPPX:
     case CSS_DPI:
     case CSS_DPCM:
     case CSS_MM:
@@ skipping 16 matching lines @@
     case CSS_FR:
         return m_value.num == other.m_value.num;
     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:
         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.parserOperator == other.m_value.parserOperator;
     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::traceAfterDispatch(Visitor* visitor)
 {
@@ skipping 18 matching lines @@
         visitor->trace(m_value.shape);
         break;
     default:
         break;
     }
 #endif
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink