Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/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 11 matching lines @@
 #ifndef CSSPrimitiveValue_h
 #define CSSPrimitiveValue_h
 
 #include "core/CSSPropertyNames.h"
 #include "core/CSSValueKeywords.h"
 #include "core/CoreExport.h"
 #include "core/css/CSSValue.h"
 #include "wtf/BitVector.h"
 #include "wtf/Forward.h"
 #include "wtf/MathExtras.h"
-#include "wtf/TypeTraits.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/StringView.h"
 
 namespace blink {
 
 class CSSCalcValue;
 class CSSToLengthConversionData;
 class Length;
 
 // Dimension calculations are imprecise, often resulting in values of e.g.
 // 44.99998. We need to go ahead and round if we're really close to the next
 // integer value.
 template<typename T> inline T roundForImpreciseConversion(double value)
 {
     value += (value < 0) ? -0.01 : +0.01;
     return ((value > std::numeric_limits<T>::max()) || (value < std::numeric_limits<T>::min())) ? 0 : static_cast<T>(value);
 }
 
 template<> inline float roundForImpreciseConversion(double value)
 {
     double ceiledValue = ceil(value);
     double proximityToNextInt = ceiledValue - value;
     if (proximityToNextInt <= 0.01 && value > 0)
         return static_cast<float>(ceiledValue);
     if (proximityToNextInt >= 0.99 && value < 0)
         return static_cast<float>(floor(value));
     return static_cast<float>(value);
 }
 
-// CSSPrimitiveValues are immutable. This class has manual ref-counting
-// of unioned types and does not have the code necessary
-// to handle any kind of mutations.
+// CSSPrimitiveValue stores both numbers/lengths (e.g. 1, 10px, 4%) and calc()

[Timothy Loh, 2016/09/30 05:44:35]

4% isn't a length, also it stores other values like angles and so on. Maybe
'numeric data types' is a better description.

[sashab, 2016/09/30 06:45:48]

Done

+// values (e.g. calc(3px + 2em)).
+// TODO(sashab): Split calc functionality out of CSSPrimitiveValue.

[Timothy Loh, 2016/09/30 05:44:35]

I think calc makes sense to be in CSSPrimtiveValue, what do you expect things to
look like if you do this? I don't think this TODO should be added right now.

[sashab, 2016/09/30 06:45:48]

Done

 class CORE_EXPORT CSSPrimitiveValue : public CSSValue {
 public:
     // These units are iterated through, so be careful when adding or changing the order.
     enum class UnitType {
         Unknown,
         Number,
         Percentage,
         // Length units
         Ems,
         Exs,
@@ skipping 25 matching lines @@
         DotsPerInch,
         DotsPerCentimeter,
         // Other units
         Fraction,
         Integer,
         Calc,
         CalcPercentageWithNumber,
         CalcPercentageWithLength,
         CalcLengthWithNumber,
         CalcPercentageWithLengthAndNumber,
-        ValueID,
 
         // This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
         // The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em.
         // When the quirky value is used, if you're in quirks mode, the margin will collapse away
         // inside a table cell. This quirk is specified in the HTML spec but our impl is different.
         // TODO: Remove this. crbug.com/443952
         QuirkyEms,
     };
 
     enum LengthUnitType {
@@ skipping 74 matching lines @@
     bool isLength() const { return isLength(typeWithCalcResolved()); }
     bool isNumber() const { return typeWithCalcResolved() == UnitType::Number || typeWithCalcResolved() == UnitType::Integer; }
     bool isPercentage() const { return typeWithCalcResolved() == UnitType::Percentage; }
     bool isPx() const { return typeWithCalcResolved() == UnitType::Pixels; }
     bool isTime() const { return type() == UnitType::Seconds || type() == UnitType::Milliseconds; }
     bool isCalculated() const { return type() == UnitType::Calc; }
     bool isCalculatedPercentageWithNumber() const { return typeWithCalcResolved() == UnitType::CalcPercentageWithNumber; }
     bool isCalculatedPercentageWithLength() const { return typeWithCalcResolved() == UnitType::CalcPercentageWithLength; }
     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 CSSPrimitiveValue* createIdentifier(CSSValueID);
     static CSSPrimitiveValue* create(double value, UnitType);
     static CSSPrimitiveValue* create(const Length& value, float zoom)
     {
         return new CSSPrimitiveValue(value, zoom);
     }
+
+    // TODO(sashab): Remove this.
     template<typename T> static CSSPrimitiveValue* create(T value)
     {
-        static_assert(!std::is_same<T, CSSValueID>::value, "Do not call create() with a CSSValueID; call createIdentifier() instead");
         return new CSSPrimitiveValue(value);
     }
 
     ~CSSPrimitiveValue();
 
     UnitType typeWithCalcResolved() const;
 
     double computeDegrees() const;
     double computeSeconds() const;
 
     // Computes a length in pixels, resolving relative lengths
     template<typename T> T computeLength(const CSSToLengthConversionData&) const;
 
     // Converts to a Length (Fixed, Percent or Calculated)
     Length convertToLength(const CSSToLengthConversionData&) const;
 
     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()); }
 
     CSSCalcValue* cssCalcValue() const { ASSERT(isCalculated()); return m_value.calc; }
 
-    CSSValueID getValueID() const { return type() == UnitType::ValueID ? m_value.valueID : CSSValueInvalid; }
-
     template<typename T> inline T convertTo() const; // Defined in CSSPrimitiveValueMappings.h
 
     static const char* unitTypeToString(UnitType);
     static UnitType stringToUnitType(StringView string)
     {
         if (string.is8Bit())
             return stringToUnitType(string.characters8(), string.length());
         return stringToUnitType(string.characters16(), string.length());
     }
 
     String customCSSText() const;
 
     bool equals(const CSSPrimitiveValue&) const;
 
     DECLARE_TRACE_AFTER_DISPATCH();
 
     static UnitType canonicalUnitTypeForCategory(UnitCategory);
     static double conversionToCanonicalUnitsScaleFactor(UnitType);
 
     // 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(const Length&, float zoom);
     CSSPrimitiveValue(double, UnitType);
 
     template<typename T> CSSPrimitiveValue(T); // Defined in CSSPrimitiveValueMappings.h
 
     template<typename T> CSSPrimitiveValue(T* val)
         : CSSValue(PrimitiveClass)
     {
         init(val);
     }
 
     static void create(int); // compile-time guard
     static void create(unsigned); // compile-time guard
     template<typename T> operator T*(); // compile-time guard
 
     // Code generated by CSSPrimitiveValueUnitTrie.cpp.tmpl
     static UnitType stringToUnitType(const LChar*, unsigned length);
     static UnitType stringToUnitType(const UChar*, unsigned length);
 
     void init(UnitType);
     void init(const Length&);
     void init(CSSCalcValue*);
 
     double computeLengthDouble(const CSSToLengthConversionData&) const;
 
     inline UnitType type() const { return static_cast<UnitType>(m_primitiveUnitType); }
 
     union {
-        CSSValueID valueID;
         double num;
         // FIXME: oilpan: Should be a member, but no support for members in unions. Just trace the raw ptr for now.
         CSSCalcValue* calc;
     } m_value;
 };
 
 using CSSLengthArray = CSSPrimitiveValue::CSSLengthArray;
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSPrimitiveValue, isPrimitiveValue());
 
 } // namespace blink
 
 #endif // CSSPrimitiveValue_h