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.
@@ skipping 12 matching lines @@
 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 numeric data types (e.g. 1, 10px, 4%) and calc()
+// values (e.g. calc(3px + 2em)).
 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 79 matching lines @@
     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;
 
@@ skipping 10 matching lines @@
   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);
   }
@@ skipping 11 matching lines @@
   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