Split out String, URI and CustomIdent from CSSPrimitiveValue

Source/core/css/CSSPrimitiveValue.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  *
  * 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.
  *
@@ skipping 69 matching lines @@
         Points,
         Picas,
         Degrees,
         Radians,
         Gradians,
         Turns,
         Milliseconds,
         Seconds,
         Hertz,
         Kilohertz,
-        CustomIdentifier,
-        URI,
         RGBColor,
         ViewportWidth,
         ViewportHeight,
         ViewportMin,
         ViewportMax,
         DotsPerPixel,
         DotsPerInch,
         DotsPerCentimeter,
         Fraction,
         Integer,
         Rems,
         Chs,
         Shape,
         Calc,
         CalcPercentageWithNumber,
         CalcPercentageWithLength,
-        String,
         PropertyID,
         ValueID,
         QuirkyEms,
     };
 
     enum LengthUnitType {
         UnitTypePixels = 0,
         UnitTypePercentage,
         UnitTypeFontSize,
         UnitTypeFontXSize,
@@ skipping 31 matching lines @@
 
     static UnitType fromName(const String& unit);
 
     bool isAngle() const
     {
         return type() == UnitType::Degrees
             || type() == UnitType::Radians
             || type() == UnitType::Gradians
             || type() == UnitType::Turns;
     }
-    bool isCustomIdent() const { return type() == UnitType::CustomIdentifier; }
     bool isFontRelativeLength() const
     {
         return type() == UnitType::Ems
             || type() == UnitType::Exs
             || type() == UnitType::Rems
             || type() == UnitType::Chs;
     }
     bool isViewportPercentageLength() const { return isViewportPercentageLength(type()); }
     static bool isViewportPercentageLength(UnitType type) { return type >= UnitType::ViewportWidth && type <= UnitType::ViewportMax; }
     static bool isLength(UnitType type)
     {
         return (type >= UnitType::Ems && type <= UnitType::Picas) || type == UnitType::Rems || type == UnitType::Chs || isViewportPercentageLength(type);
     }
     bool isLength() const { return isLength(typeWithCalcResolved()); }
     bool isNumber() const { return typeWithCalcResolved() == UnitType::Number || typeWithCalcResolved() == UnitType::Integer; }
     bool isPercentage() const { return typeWithCalcResolved() == UnitType::Percentage; }
     bool isPropertyID() const { return type() == UnitType::PropertyID; }
     bool isPx() const { return typeWithCalcResolved() == UnitType::Pixels; }
     bool isRGBColor() const { return type() == UnitType::RGBColor; }
     bool isShape() const { return type() == UnitType::Shape; }
-    bool isString() const { return type() == UnitType::String; }
     bool isTime() const { return type() == UnitType::Seconds || type() == UnitType::Milliseconds; }
-    bool isURI() const { return type() == UnitType::URI; }
     bool isCalculated() const { return type() == UnitType::Calc; }
     bool isCalculatedPercentageWithNumber() const { return typeWithCalcResolved() == UnitType::CalcPercentageWithNumber; }
     bool isCalculatedPercentageWithLength() const { return typeWithCalcResolved() == UnitType::CalcPercentageWithLength; }
     static bool isDotsPerInch(UnitType type) { return type == UnitType::DotsPerInch; }
     static bool isDotsPerPixel(UnitType type) { return type == UnitType::DotsPerPixel; }
     static bool isDotsPerCentimeter(UnitType type) { return type == UnitType::DotsPerCentimeter; }
     static bool isResolution(UnitType type) { return type >= UnitType::DotsPerPixel && type <= UnitType::DotsPerCentimeter; }
     bool isFlex() const { return typeWithCalcResolved() == UnitType::Fraction; }
     bool isValueID() const { return type() == UnitType::ValueID; }
     bool colorIsDerivedFromElement() const;
 
     static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> createIdentifier(CSSValueID valueID)
     {
         return adoptRefWillBeNoop(new CSSPrimitiveValue(valueID));
     }
     static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> createIdentifier(CSSPropertyID propertyID)
     {
         return adoptRefWillBeNoop(new CSSPrimitiveValue(propertyID));
     }
     static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> createColor(RGBA32 rgbValue)
     {
         return adoptRefWillBeNoop(new CSSPrimitiveValue(rgbValue));
     }
     static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> create(double value, UnitType type)
     {
         return adoptRefWillBeNoop(new CSSPrimitiveValue(value, type));
     }
-    static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> create(const String& value, UnitType type)
-    {
-        return adoptRefWillBeNoop(new CSSPrimitiveValue(value, type));
-    }
     static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> create(const Length& value, float zoom)
     {
         return adoptRefWillBeNoop(new CSSPrimitiveValue(value, zoom));
     }
     template<typename T> static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> create(T value)
     {
         return adoptRefWillBeNoop(new CSSPrimitiveValue(value));
     }
 
     // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
@@ skipping 20 matching lines @@
     template<typename T> T computeLength(const CSSToLengthConversionData&);
 
     // Converts to a Length (Fixed, Percent or Calculated)
     Length convertToLength(const CSSToLengthConversionData&);
 
     double getDoubleValue() const;
     float getFloatValue() const { return getValue<float>(); }
     int getIntValue() const { return getValue<int>(); }
     template<typename T> inline T getValue() const { return clampTo<T>(getDoubleValue()); }
 
-    String getStringValue() const;
     RGBA32 getRGBA32Value() const { ASSERT(isRGBColor()); return m_value.rgbcolor; }
 
     CSSBasicShape* getShapeValue() const { ASSERT(isShape()); return m_value.shape; }
     CSSCalcValue* cssCalcValue() const { ASSERT(isCalculated()); return m_value.calc; }
     CSSPropertyID getPropertyID() const { ASSERT(isPropertyID()); return m_value.propertyID; }
 
     CSSValueID getValueID() const { return type() == UnitType::ValueID ? m_value.valueID : CSSValueInvalid; }
 
     template<typename T> inline operator T() const; // Defined in CSSPrimitiveValueMappings.h
 
@@ skipping 11 matching lines @@
 
     // Returns true and populates lengthUnitType, if unitType is a length unit. Otherwise, returns false.
     static bool unitTypeToLengthUnitType(UnitType, LengthUnitType&);
     static UnitType lengthUnitTypeToUnitType(LengthUnitType);
 
 private:
     CSSPrimitiveValue(CSSValueID);
     CSSPrimitiveValue(CSSPropertyID);
     CSSPrimitiveValue(RGBA32 color);
     CSSPrimitiveValue(const Length&, float zoom);
-    CSSPrimitiveValue(const String&, UnitType);
     CSSPrimitiveValue(double, UnitType);
 
     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
     template<typename T> CSSPrimitiveValue(T* val)
         : CSSValue(PrimitiveClass)
     {
         init(PassRefPtrWillBeRawPtr<T>(val));
     }
 
     template<typename T> CSSPrimitiveValue(PassRefPtrWillBeRawPtr<T> val)
@@ skipping 12 matching lines @@
     void init(PassRefPtrWillBeRawPtr<CSSCalcValue>);
 
     double computeLengthDouble(const CSSToLengthConversionData&);
 
     inline UnitType type() const { return static_cast<UnitType>(m_primitiveUnitType); }
 
     union {
         CSSPropertyID propertyID;
         CSSValueID valueID;
         double num;
-        StringImpl* string;
         RGBA32 rgbcolor;
         // FIXME: oilpan: Should be members, but no support for members in unions. Just trace the raw ptr for now.
         CSSBasicShape* shape;
         CSSCalcValue* calc;
     } m_value;
 };
 
 typedef CSSPrimitiveValue::CSSLengthArray CSSLengthArray;
 typedef CSSPrimitiveValue::CSSLengthTypeArray CSSLengthTypeArray;
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSPrimitiveValue, isPrimitiveValue());
 
 } // namespace blink
 
 #endif // CSSPrimitiveValue_h