CSSValue Immediates: Make toCSSPrimitiveValue() return a const reference

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 172 matching lines @@
             unsigned red : 8;
             unsigned green : 8;
             unsigned blue : 8;
 #if CPU(32BIT)
             unsigned alpha : 1;
 #elif CPU(64BIT)
             unsigned alpha : 8;
 #endif
         } packedColor;
 
-
         // Returns true if value can be stored in the value field of the tagged pointer
         // without losing information.
-        inline static bool fitsWithoutDataLoss(double value)
+        inline static bool canFitWithoutDataLoss(CSSPrimitiveValueData data, UnitType type)
         {
-            union {
-                double asDouble;
-                uint64_t asBits;
-            } interpretableValue;
-            interpretableValue.asDouble = value;
-            return (interpretableValue.asBits & mantissaTruncationMask) == 0;
+            switch (type) {
+            case CSS_PROPERTY_ID:
+                return true;
+            case CSS_VALUE_ID:
+                return true;
+            case CSS_RGBCOLOR:
+#if CPU(32BIT)
+                if (alphaChannel(data.rgbcolor) != 0 && alphaChannel(data.rgbcolor) != 255)
+                    return false;
+#endif
+                return true;
+            default:
+                union {
+                    double asDouble;
+                    uint64_t asBits;
+                } interpretableValue;
+                interpretableValue.asDouble = data.num;
+                if ((interpretableValue.asBits & mantissaTruncationMask) != 0)
+                    return false;
+                return true;
+            }
         }
 
-        inline static bool fitsWithoutDataLoss(RGBA32 color)
+        inline void setValue(CSSPrimitiveValueData data, UnitType type)
         {
+            this->flag = 1;
+            this->type = static_cast<uintptr_t>(type);
+            switch (type) {
+            case CSS_PROPERTY_ID:
+                valueRaw = static_cast<uintptr_t>(data.propertyID);
+                return;
+            case CSS_VALUE_ID:
+                valueRaw = static_cast<uintptr_t>(data.valueID);
+                return;
+            case CSS_RGBCOLOR:
+                packedColor color;
+                color.red = static_cast<uintptr_t>(redChannel(data.rgbcolor));
+                color.green = static_cast<uintptr_t>(greenChannel(data.rgbcolor));
+                color.blue = static_cast<uintptr_t>(blueChannel(data.rgbcolor));
 #if CPU(32BIT)
-            return alphaChannel(color) == 0 || alphaChannel(color) == 255;
+                color.alpha = static_cast<uintptr_t>(alphaChannel(data.rgbcolor) == 255 ? 1 : 0);
 #elif CPU(64BIT)
-            return true;
+                color.alpha = static_cast<uintptr_t>(alphaChannel(data.rgbcolor));
 #endif
+                valueRaw = *reinterpret_cast<uintptr_t*>(&color);
+                return;
+            default:
+                union {
+                    double asDouble;
+                    uint64_t asBits;
+                } interpretableValue;
+                interpretableValue.asDouble = data.num;
+                valueRaw = interpretableValue.asBits >> doubleShiftAmount;
+                return;
+            }
+        }
+
+        inline CSSPrimitiveValueData getValue() const
+        {
+            CSSPrimitiveValueData data;
+            switch (type) {
+            case CSS_PROPERTY_ID:
+                data.propertyID = getPropertyIDValue();
+                break;
+            case CSS_VALUE_ID:
+                data.valueID = getValueIDValue();
+                break;
+            case CSS_RGBCOLOR:
+                data.rgbcolor = getColorValue();
+                break;
+            default:
+                data.num = getDoubleValue();
+                break;
+            }
+            return data;
         }
 
         // Convenience methods for getting/setting the value field, which is truncated.
-        inline double getValue() const
+        inline double getDoubleValue() const
         {
             uint64_t shiftedValue = valueRaw;
             shiftedValue = shiftedValue << doubleShiftAmount;
             return *reinterpret_cast<double*>(&shiftedValue);
         }
 
         inline RGBA32 getColorValue() const
         {
             uintptr_t valueRawVar = valueRaw;
             packedColor color = *reinterpret_cast<packedColor*>(&valueRawVar);
@@ skipping 198 matching lines @@
     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; }
     bool colorIsDerivedFromElement() const;
 
     static CSSPrimitiveValue createIdentifier(CSSValueID valueID)
     {
-        CSSTaggedPtrValue taggedPointer;
-        taggedPointer.flag = 1;
-        taggedPointer.type = CSS_VALUE_ID;
-        taggedPointer.setValue(valueID);
-        return CSSPrimitiveValue(taggedPointer);
+        CSSPrimitiveValueData data;
+        data.valueID = valueID;
+        CSSTaggedPtrValue taggedPtr;
+        taggedPtr.setValue(data, CSS_VALUE_ID);
+        return CSSPrimitiveValue(taggedPtr);
     }
 
     static CSSPrimitiveValue createIdentifier(CSSPropertyID propertyID)
     {
-        CSSTaggedPtrValue taggedPointer;
-        taggedPointer.flag = 1;
-        taggedPointer.type = CSS_PROPERTY_ID;
-        taggedPointer.setValue(propertyID);
-        return CSSPrimitiveValue(taggedPointer);
+        CSSPrimitiveValueData data;
+        data.propertyID = propertyID;
+        CSSTaggedPtrValue taggedPtr;
+        taggedPtr.setValue(data, CSS_PROPERTY_ID);
+        return CSSPrimitiveValue(taggedPtr);
     }
     static CSSPrimitiveValue createColor(RGBA32 rgbValue)
     {
-        if (CSSTaggedPtrValue::fitsWithoutDataLoss(rgbValue)) {
-            CSSTaggedPtrValue taggedPointer;
-            taggedPointer.flag = 1;
-            taggedPointer.type = CSS_RGBCOLOR;
-            taggedPointer.setValue(rgbValue);
-            return CSSPrimitiveValue(taggedPointer);
+        CSSPrimitiveValueData data;
+        data.rgbcolor = rgbValue;
+        if (CSSTaggedPtrValue::canFitWithoutDataLoss(data, CSS_RGBCOLOR)) {
+            CSSTaggedPtrValue taggedPtr;
+            taggedPtr.setValue(data, CSS_RGBCOLOR);
+            return CSSPrimitiveValue(taggedPtr);
         }
         return CSSPrimitiveValue(adoptRefWillBeNoop(new CSSLargePrimitiveValue(rgbValue)));
     }
     static CSSPrimitiveValue create(double value, UnitType type)
     {
-        if (CSSTaggedPtrValue::fitsWithoutDataLoss(value)) {
-            CSSTaggedPtrValue taggedPointer;
-            taggedPointer.flag = 1;
-            taggedPointer.type = type;
-            taggedPointer.setValue(value);
-            return CSSPrimitiveValue(taggedPointer);
+        CSSPrimitiveValueData data;
+        data.num = value;
+        if (CSSTaggedPtrValue::canFitWithoutDataLoss(data, type)) {
+            CSSTaggedPtrValue taggedPtr;
+            taggedPtr.setValue(data, type);
+            return CSSPrimitiveValue(taggedPtr);
         }
         return CSSPrimitiveValue(adoptRefWillBeNoop(new CSSLargePrimitiveValue(value, type)));
     }
     static CSSPrimitiveValue create(const String& value, UnitType type)
     {
         return CSSPrimitiveValue(adoptRefWillBeNoop(new CSSLargePrimitiveValue(value, type)));
     }
     static CSSPrimitiveValue create(const Length& value, float zoom)
     {
         return CSSPrimitiveValue(adoptRefWillBeNoop(new CSSLargePrimitiveValue(value, zoom)));
@@ skipping 12 matching lines @@
     // When the quirky value is used, if you're in quirks mode, the margin will collapse away
     // inside a table cell.
     static CSSPrimitiveValue createAllowingMarginQuirk(double value, UnitType type)
     {
         return CSSPrimitiveValue(adoptRefWillBeNoop(new CSSLargePrimitiveValue(value, type, true)));
     }
 
     UnitType primitiveType() const;
 
     double computeDegrees() const;
-    double computeSeconds();
+    double computeSeconds() const;
 
     // Computes a length in pixels, resolving relative lengths
-    template<typename T> T computeLength(const CSSToLengthConversionData&);
+    template<typename T> T computeLength(const CSSToLengthConversionData&) const;
 
     // Converts to a Length (Fixed, Percent or Calculated)
-    Length convertToLength(const CSSToLengthConversionData&);
+    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()); }
 
     String getStringValue() const;
 
     Counter* getCounterValue() const { return type() != CSS_COUNTER ? 0 : value().counter; }
 
@@ skipping 54 matching lines @@
 #if !ENABLE(OILPAN)
         if (isObject())
             m_rawValue.asPtr->deref();
 #endif
     }
 
     static void create(int); // compile-time guard
     static void create(unsigned); // compile-time guard
     template<typename T> operator T*(); // compile-time guard
 
-    double computeLengthDouble(const CSSToLengthConversionData&);
+    double computeLengthDouble(const CSSToLengthConversionData&) const;
 
     union CSSPrimitivePointerValue {
         CSSTaggedPtrValue asTaggedPtr;
         RawPtrWillBeMember<CSSLargePrimitiveValue> asPtr;
 
         CSSPrimitivePointerValue(CSSLargePrimitiveValue* ptr) : asPtr(ptr) { }
         CSSPrimitivePointerValue(CSSTaggedPtrValue taggedPtr) : asTaggedPtr(taggedPtr) { }
 
         DEFINE_INLINE_TRACE()
         {
             if (!(reinterpret_cast<uintptr_t>(asPtr.get()) & 1)) {
                 visitor->trace(asPtr);
                 asPtr->traceAfterDispatch(visitor);
             }
         }
     } m_rawValue;
     static_assert(sizeof(m_rawValue) == sizeof(void*), "The tagged pointer field in CSSPrimitiveValue must be the size of a pointer");
 
     bool isObject() const
     {
         return m_rawValue.asTaggedPtr.flag == 0;
     }
 
     // Getters/setters for inner class.
     CSSPrimitiveValueData value() const
     {
         if (isObject())
             return m_rawValue.asPtr->m_value;
 
-        CSSPrimitiveValueData result;
-        if (m_rawValue.asTaggedPtr.type == CSS_RGBCOLOR)
-            result.rgbcolor = m_rawValue.asTaggedPtr.getColorValue();
-        else if (m_rawValue.asTaggedPtr.type == CSS_PROPERTY_ID)
-            result.propertyID = m_rawValue.asTaggedPtr.getPropertyIDValue();
-        else if (m_rawValue.asTaggedPtr.type == CSS_VALUE_ID)
-            result.valueID = m_rawValue.asTaggedPtr.getValueIDValue();
-        else
-            result.num = m_rawValue.asTaggedPtr.getValue();
-        return result;
+
+        return m_rawValue.asTaggedPtr.getValue();
     }
 
     UnitType type() const
     {
         if (isObject())
             return static_cast<UnitType>(m_rawValue.asPtr->m_primitiveUnitType);
         return static_cast<UnitType>(m_rawValue.asTaggedPtr.type);
     }
 };
 
 typedef CSSPrimitiveValue::CSSLengthArray CSSLengthArray;
 typedef CSSPrimitiveValue::CSSLengthTypeArray CSSLengthTypeArray;
 
 static_assert(sizeof(CSSPrimitiveValue) == sizeof(void*), "CSSPrimitiveValue must be the size of a pointer");
 
 } // namespace blink
 
 #endif // CSSPrimitiveValue_h