CSSValue Immediates: Remove redundant isTaggedPtr() checks

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 163 matching lines @@
     };
     static UnitCategory unitCategory(UnitType);
     static float clampToCSSLengthRange(double);
 
     static void initUnitTable();
 
     static UnitType fromName(const String& unit);
 
     bool isAngle() const
     {
-        return type() == CSS_DEG
-            || type() == CSS_RAD
-            || type() == CSS_GRAD
-            || type() == CSS_TURN;
+        UnitType unitType = type();
+        return unitType == CSS_DEG
+            || unitType == CSS_RAD
+            || unitType == CSS_GRAD
+            || unitType == CSS_TURN;
     }
     bool isAttr() const { return type() == CSS_ATTR; }
     bool isCounter() const { return type() == CSS_COUNTER; }
     bool isCustomIdent() const { return type() == CSS_CUSTOM_IDENT; }
     bool isFontRelativeLength() const
     {
-        return type() == CSS_EMS
-            || type() == CSS_EXS
-            || type() == CSS_REMS
-            || type() == CSS_CHS;
+        UnitType unitType = type();
+        return unitType == CSS_EMS
+            || unitType == CSS_EXS
+            || unitType == CSS_REMS
+            || unitType == CSS_CHS;
     }
     bool isViewportPercentageLength() const { return isViewportPercentageLength(type()); }
     static bool isViewportPercentageLength(UnitType type) { return type >= CSS_VW && type <= CSS_VMAX; }
     static bool isLength(UnitType type)
     {
         return (type >= CSS_EMS && type <= CSS_PC) || type == CSS_REMS || type == CSS_CHS || isViewportPercentageLength(type);
     }
     bool isLength() const { return isLength(primitiveType()); }
     bool isNumber() const { return primitiveType() == CSS_NUMBER || primitiveType() == CSS_INTEGER; }
     bool isPercentage() const { return primitiveType() == CSS_PERCENTAGE; }
     bool isPx() const { return primitiveType() == CSS_PX; }
     bool isRect() const { return type() == CSS_RECT; }
     bool isRGBColor() const { return type() == CSS_RGBCOLOR; }
     bool isShape() const { return type() == CSS_SHAPE; }
     bool isString() const { return type() == CSS_STRING; }
-    bool isTime() const { return type() == CSS_S || type() == CSS_MS; }
+    bool isTime() const { UnitType unitType = type(); return unitType == CSS_S || unitType == CSS_MS; }
     bool isURI() const { return type() == CSS_URI; }
     bool isCalculated() const { return type() == CSS_CALC; }
     bool isCalculatedPercentageWithNumber() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_NUMBER; }
     bool isCalculatedPercentageWithLength() const { return primitiveType() == CSS_CALC_PERCENTAGE_WITH_LENGTH; }
     static bool isDotsPerInch(UnitType type) { return type == CSS_DPI; }
     static bool isDotsPerPixel(UnitType type) { return type == CSS_DPPX; }
     static bool isDotsPerCentimeter(UnitType type) { return type == CSS_DPCM; }
     static bool isResolution(UnitType type) { return type >= CSS_DPPX && type <= CSS_DPCM; }
     bool isFlex() const { return primitiveType() == CSS_FR; }
     bool isValueID() const { return type() == CSS_VALUE_ID; }
@@ skipping 92 matching lines @@
     double computeSeconds();
 
     // Computes a length in pixels, resolving relative lengths
     template<typename T> T computeLength(const CSSToLengthConversionData&);
 
     // Converts to a Length (Fixed, Percent or Calculated)
     Length convertToLength(const CSSToLengthConversionData&);
 
     double getDoubleValue() const
     {
-        if (type() == CSS_CALC)
+        if (isTaggedPtr())
+            return numTaggedValue();
+        if (m_primitiveUnitType == CSS_CALC)
             return getCalcDoubleValue();
-        return value().num;
+        return m_value.num;
     }
 
     double getCalcDoubleValue() 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;
 
-    Counter* getCounterValue() const { return type() != CSS_COUNTER ? 0 : value().counter; }
+    Counter* getCounterValue() const { return type() != CSS_COUNTER ? 0 : m_value.counter; }
 
-    Rect* getRectValue() const { return type() != CSS_RECT ? 0 : value().rect; }
+    Rect* getRectValue() const { return type() != CSS_RECT ? 0 : m_value.rect; }
 
-    Quad* getQuadValue() const { return type() != CSS_QUAD ? 0 : value().quad; }
+    Quad* getQuadValue() const { return type() != CSS_QUAD ? 0 : m_value.quad; }
 
-    RGBA32 getRGBA32Value() const { return type() != CSS_RGBCOLOR ? 0 : value().rgbcolor; }
+    RGBA32 getRGBA32Value() const
+    {
+        if (isTaggedPtr())
+            return taggedType() != CSS_RGBCOLOR ? 0 : rgbcolorTaggedValue();
+        return m_primitiveUnitType != CSS_RGBCOLOR ? 0 : m_value.rgbcolor;
+    }
 
-    Pair* getPairValue() const { return type() != CSS_PAIR ? 0 : value().pair; }
+    Pair* getPairValue() const { return type() != CSS_PAIR ? 0 : m_value.pair; }
 
-    CSSBasicShape* getShapeValue() const { return type() != CSS_SHAPE ? 0 : value().shape; }
+    CSSBasicShape* getShapeValue() const { return type() != CSS_SHAPE ? 0 : m_value.shape; }
 
-    CSSCalcValue* cssCalcValue() const { return type() != CSS_CALC ? 0 : value().calc; }
+    CSSCalcValue* cssCalcValue() const { return type() != CSS_CALC ? 0 : m_value.calc; }
 
-    CSSPropertyID getPropertyID() const { return type() == CSS_PROPERTY_ID ? value().propertyID : CSSPropertyInvalid; }
-    CSSValueID getValueID() const { return type() == CSS_VALUE_ID ? value().valueID : CSSValueInvalid; }
+    CSSPropertyID getPropertyID() const
+    {
+        if (isTaggedPtr())
+            return taggedType() == CSS_PROPERTY_ID ? propertyIDTaggedValue() : CSSPropertyInvalid;
+        return m_primitiveUnitType == CSS_PROPERTY_ID ? m_value.propertyID : CSSPropertyInvalid;
+    }
+
+    CSSValueID getValueID() const
+    {
+        if (isTaggedPtr())
+            return taggedType() == CSS_VALUE_ID ? valueIDTaggedValue() : CSSValueInvalid;
+        return m_primitiveUnitType == CSS_VALUE_ID ? m_value.valueID : CSSValueInvalid;
+    }
 
     template<typename T> inline operator T() const; // Defined in CSSPrimitiveValueMappings.h
 
     static const char* unitTypeToString(UnitType);
     String customCSSText() const;
 
     inline bool isQuirkValue() const
     {
         if (isTaggedPtr())
             return false;
@@ skipping 86 matching lines @@
         return reinterpret_cast<CSSTaggedPtrValue&&>(nonConstThis);
     }
 
     inline UnitType type() const
     {
         if (!isTaggedPtr())
             return static_cast<UnitType>(m_primitiveUnitType);
         return static_cast<UnitType>(toTaggedPtr().type);
     }
 
-    inline CSSPrimitiveValueData value() const
+    inline double taggedType() const
     {
-        if (!isTaggedPtr())
-            return m_value;
+        ASSERT(isTaggedPtr());
+        return static_cast<UnitType>(toTaggedPtr().type);
+    }
 
-        CSSPrimitiveValueData data;
-        switch (type()) {
-        case CSSPrimitiveValue::CSS_PROPERTY_ID:
-            data.propertyID = static_cast<CSSPropertyID>(toTaggedPtr().value);
-            break;
-        case CSSPrimitiveValue::CSS_VALUE_ID:
-            data.valueID = static_cast<CSSValueID>(toTaggedPtr().value);
-            break;
-        case CSSPrimitiveValue::CSS_RGBCOLOR: {
-            uintptr_t valueRawVar = toTaggedPtr().value;
-            packedColor color = *reinterpret_cast<packedColor*>(&valueRawVar);
-            unsigned alpha;
+    inline CSSPropertyID propertyIDValue() const
+    {
+        if (isTaggedPtr())
+            return propertyIDTaggedValue();
+        return m_value.propertyID;
+    }
+
+    inline CSSValueID valueIDValue() const
+    {
+        if (isTaggedPtr())
+            return valueIDTaggedValue();
+        return m_value.valueID;
+    }
+
+
+    inline double numValue() const
+    {
+        if (isTaggedPtr())
+            return numTaggedValue();
+        return m_value.num;
+    }
+
+
+    inline RGBA32 rgbcolorValue() const
+    {
+        if (isTaggedPtr())
+            return rgbcolorTaggedValue();
+        return m_value.rgbcolor;
+    }
+
+    inline CSSPropertyID propertyIDTaggedValue() const
+    {
+        ASSERT(isTaggedPtr());
+        return static_cast<CSSPropertyID>(toTaggedPtr().value);
+    }
+
+    inline CSSValueID valueIDTaggedValue() const
+    {
+        ASSERT(isTaggedPtr());
+        return static_cast<CSSValueID>(toTaggedPtr().value);
+    }
+
+    inline double numTaggedValue() const
+    {
+        ASSERT(isTaggedPtr());
+        uint64_t shiftedValue = toTaggedPtr().value;
+        shiftedValue = shiftedValue << doubleShiftAmount;
+        return *reinterpret_cast<double*>(&shiftedValue);
+    }
+
+    inline RGBA32 rgbcolorTaggedValue() const
+    {
+        ASSERT(isTaggedPtr());
+        uintptr_t valueRawVar = toTaggedPtr().value;
+        packedColor color = *reinterpret_cast<packedColor*>(&valueRawVar);
+        unsigned alpha;
 #if CPU(32BIT)
-            alpha = color.alpha == 1 ? 255 : 0;
+        alpha = color.alpha == 1 ? 255 : 0;
 #elif CPU(64BIT)
-            alpha = color.alpha;
+        alpha = color.alpha;
 #endif
-            data.rgbcolor = makeRGBA(color.red, color.green, color.blue, alpha);
-            break;
-        }
-        default:
-            uint64_t shiftedValue = toTaggedPtr().value;
-            shiftedValue = shiftedValue << doubleShiftAmount;
-            data.num = *reinterpret_cast<double*>(&shiftedValue);
-            break;
-        }
-        return data;
+        return makeRGBA(color.red, color.green, color.blue, alpha);
     }
 
+
     CSSPrimitiveValueData m_value;
 };
 
 typedef CSSPrimitiveValue::CSSLengthArray CSSLengthArray;
 typedef CSSPrimitiveValue::CSSLengthTypeArray CSSLengthTypeArray;
 
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSPrimitiveValue, isPrimitiveValue());
 
 } // namespace blink
 
 namespace WTF {
 
 #if !ENABLE(OILPAN)
 // Must be defined *after* CSSPrimitiveValue to compile with the correct adopted() method.
 template<> inline PassRefPtr<blink::CSSPrimitiveValue> adoptRef<blink::CSSPrimitiveValue>(blink::CSSPrimitiveValue* p)
 {
     // Immediates (non-pointers) end in a 1.
     if (!(reinterpret_cast<uintptr_t>(p) & 1))
         adopted(p);
     return PassRefPtr<blink::CSSPrimitiveValue>(p, PassRefPtr<blink::CSSPrimitiveValue>::AdoptRef);
 }
 #endif
 
 } // namespace WTF
 
 #endif // CSSPrimitiveValue_h