CSSValue Immediates: Make CSSPrimitiveValue store a tagged pointer

Source/core/css/CSSValue.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 23 matching lines @@
 // CSSValueObject.
 class CORE_EXPORT CSSValue {
     ALLOW_ONLY_INLINE_ALLOCATION();
     friend class NullableCSSValue;
 public:
     // Not explicit to allow for casting.
     CSSValue(const CSSValueObject& cssValueObject)
         : m_data(const_cast<CSSValueObject*>(&cssValueObject))
     {
         ASSERT(m_data);
+        ASSERT(isObject());
         ref();
     }
 
     // TODO(sashab): Remove these; construction should only be available with
     // CSSValueObject&.
     template<class T> CSSValue(PassRefPtrWillBeRawPtr<T> cssValueObject)
         : m_data(cssValueObject.leakRef())
     {
         static_assert(WTF::IsSubclass<T, CSSValueObject>::value, "Parameter must be a container for CSSValueObject");
+        ASSERT(isObject());
         ASSERT(m_data);
     }
 
 #if !ENABLE(OILPAN)
     template<class T> CSSValue(RefPtrWillBeRawPtr<T> cssValueObject)
         : m_data(cssValueObject.release().leakRef())
     {
         static_assert(WTF::IsSubclass<T, CSSValueObject>::value, "Parameter must be a container for CSSValueObject");
+        ASSERT(isObject());
         ASSERT(m_data);
     }
 #endif
 
     CSSValue(const CSSValue& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
@@ skipping 12 matching lines @@
     CSSValue& operator=(const CSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
     bool operator==(const CSSValue& other) const
     {
+        if (m_data == other.m_data)
+            return true;
+        if (!isObject() || !other.isObject())
+            return false;
         return m_data->equals(*other.m_data);
     }
 
     // TODO: Remove this and update callsites to use operator== instead.
     bool equals(const CSSValue& other) const
     {
+        if (m_data == other.m_data)
+            return true;
+        if (!isObject() || !other.isObject())
+            return false;
         return m_data->equals(*other.m_data);
     }
 
     bool ptrEquals(const CSSValue& other) const
     {
         return m_data == other.m_data;
     }
 
     // Methods that proxy to CSSValueObject.
-    String cssText() const { return m_data->cssText(); }
-    bool hasFailedOrCanceledSubresources() const { return m_data->hasFailedOrCanceledSubresources(); };
-    bool isPrimitiveValue() const { return m_data->isPrimitiveValue(); }
-    bool isValueList() const { return m_data->isValueList(); }
-    bool isBaseValueList() const { return m_data->isBaseValueList(); }
-    bool isBorderImageSliceValue() const { return m_data->isBorderImageSliceValue(); }
-    bool isCanvasValue() const { return m_data->isCanvasValue(); }
-    bool isCursorImageValue() const { return m_data->isCursorImageValue(); }
-    bool isCrossfadeValue() const { return m_data->isCrossfadeValue(); }
-    bool isFontFeatureValue() const { return m_data->isFontFeatureValue(); }
-    bool isFontFaceSrcValue() const { return m_data->isFontFaceSrcValue(); }
-    bool isFunctionValue() const { return m_data->isFunctionValue(); }
-    bool isImageGeneratorValue() const { return m_data->isImageGeneratorValue(); }
-    bool isGradientValue() const { return m_data->isGradientValue(); }
-    bool isImageSetValue() const { return m_data->isImageSetValue(); }
-    bool isImageValue() const { return m_data->isImageValue(); }
-    bool isImplicitInitialValue() const { return m_data->isImplicitInitialValue(); };
-    bool isInheritedValue() const { return m_data->isInheritedValue(); };
-    bool isInitialValue() const { return m_data->isInitialValue(); };
-    bool isUnsetValue() const { return m_data->isUnsetValue(); };
-    bool isCSSWideKeyword() const { return m_data->isCSSWideKeyword(); };
-    bool isLinearGradientValue() const { return m_data->isLinearGradientValue(); };
-    bool isPathValue() const { return m_data->isPathValue(); };
-    bool isRadialGradientValue() const { return m_data->isRadialGradientValue(); };
-    bool isReflectValue() const { return m_data->isReflectValue(); };
-    bool isShadowValue() const { return m_data->isShadowValue(); };
-    bool isCubicBezierTimingFunctionValue() const { return m_data->isCubicBezierTimingFunctionValue(); };
-    bool isStepsTimingFunctionValue() const { return m_data->isStepsTimingFunctionValue(); };
-    bool isLineBoxContainValue() const { return m_data->isLineBoxContainValue(); };
-    bool isCalcValue() const { return m_data->isCalcValue(); };
-    bool isGridTemplateAreasValue() const { return m_data->isGridTemplateAreasValue(); };
-    bool isSVGDocumentValue() const { return m_data->isSVGDocumentValue(); };
-    bool isContentDistributionValue() const { return m_data->isContentDistributionValue(); };
-    bool isUnicodeRangeValue() const { return m_data->isUnicodeRangeValue(); };
-    bool isGridLineNamesValue() const { return m_data->isGridLineNamesValue(); };
+    String cssText() const
+    {
+        if (isObject())
+            return m_data->cssText();
+        return CSSPrimitiveValue(reinterpret_cast<CSSPrimitiveValue::CSSLargePrimitiveValue*>(m_data.get())).cssText();
+    }
+
+    bool hasFailedOrCanceledSubresources() const { return isObject() ? m_data->hasFailedOrCanceledSubresources() : false; };
+    bool isPrimitiveValue() const { return isObject() ? m_data->isPrimitiveValue() : true; }
+    bool isValueList() const { return isObject() ? m_data->isValueList() : false; }
+    bool isBaseValueList() const { return isObject() ? m_data->isBaseValueList() : false; }
+    bool isBorderImageSliceValue() const { return isObject() ? m_data->isBorderImageSliceValue() : false; }
+    bool isCanvasValue() const { return isObject() ? m_data->isCanvasValue() : false; }
+    bool isCursorImageValue() const { return isObject() ? m_data->isCursorImageValue() : false; }
+    bool isCrossfadeValue() const { return isObject() ? m_data->isCrossfadeValue() : false; }
+    bool isFontFeatureValue() const { return isObject() ? m_data->isFontFeatureValue(): false; }
+    bool isFontFaceSrcValue() const { return isObject() ? m_data->isFontFaceSrcValue(): false; }
+    bool isFunctionValue() const { return isObject() ? m_data->isFunctionValue(): false; }
+    bool isImageGeneratorValue() const { return isObject() ? m_data->isImageGeneratorValue(): false; }
+    bool isGradientValue() const { return isObject() ? m_data->isGradientValue(): false; }
+    bool isImageSetValue() const { return isObject() ? m_data->isImageSetValue(): false; }
+    bool isImageValue() const { return isObject() ? m_data->isImageValue(): false; }
+    bool isImplicitInitialValue() const { return isObject() ? m_data->isImplicitInitialValue(): false; }
+    bool isInheritedValue() const { return isObject() ? m_data->isInheritedValue(): false; }
+    bool isInitialValue() const { return isObject() ? m_data->isInitialValue(): false; }
+    bool isUnsetValue() const { return isObject() ? m_data->isUnsetValue(): false; }
+    bool isCSSWideKeyword() const { return isObject() ? m_data->isCSSWideKeyword(): false; }
+    bool isLinearGradientValue() const { return isObject() ? m_data->isLinearGradientValue(): false; }
+    bool isPathValue() const { return isObject() ? m_data->isPathValue(): false; }
+    bool isRadialGradientValue() const { return isObject() ? m_data->isRadialGradientValue(): false; }
+    bool isReflectValue() const { return isObject() ? m_data->isReflectValue(): false; }
+    bool isShadowValue() const { return isObject() ? m_data->isShadowValue(): false; }
+    bool isCubicBezierTimingFunctionValue() const { return isObject() ? m_data->isCubicBezierTimingFunctionValue(): false; }
+    bool isStepsTimingFunctionValue() const { return isObject() ? m_data->isStepsTimingFunctionValue(): false; }
+    bool isLineBoxContainValue() const { return isObject() ? m_data->isLineBoxContainValue(): false; }
+    bool isCalcValue() const { return isObject() ? m_data->isCalcValue(): false; }
+    bool isGridTemplateAreasValue() const { return isObject() ? m_data->isGridTemplateAreasValue(): false; }
+    bool isSVGDocumentValue() const { return isObject() ? m_data->isSVGDocumentValue(): false; }
+    bool isContentDistributionValue() const { return isObject() ? m_data->isContentDistributionValue(): false; }
+    bool isUnicodeRangeValue() const { return isObject() ? m_data->isUnicodeRangeValue(): false; }
+    bool isGridLineNamesValue() const { return isObject() ? m_data->isGridLineNamesValue(): false; }
 
     DEFINE_INLINE_TRACE()
     {
         ASSERT(m_data);
-        visitor->trace(m_data);
+        if (isObject())
+            visitor->trace(m_data);
     }
 
     // Only for use by the toFooCSSValue() macros. Don't use this.
     // TODO(sashab): Remove this and use value.to<Type> and value.isValid<Type>
     // like WebNode.
     CSSValueObject* get() const
     {
         return m_data.get();
     }
 
 private:
     CSSValue() = delete; // compile-time guard
     CSSValue(std::nullptr_t) = delete; // compile-time guard
 
     void ref() const
     {
 #if !ENABLE(OILPAN)
-        if (m_data)
+        if (m_data && isObject())
             m_data->ref();
 #endif
     }
 
     void deref() const
     {
 #if !ENABLE(OILPAN)
-        if (m_data)
+        if (m_data && isObject())
             m_data->deref();
 #endif
     }
 
+    bool isObject() const
+    {
+        return !(*reinterpret_cast<const uintptr_t*>(&m_data) & 1);
+    }
+
     RawPtrWillBeMember<CSSValueObject> m_data;
 };
 
 // A nullable container for CSSValueObject. Contents are the same as CSSValue.
 // Behavior is similar to a CSSValue*.
 class CORE_EXPORT NullableCSSValue {
     ALLOW_ONLY_INLINE_ALLOCATION();
 public:
     // Not explicit to allow for casting.
     NullableCSSValue()
@@ skipping 61 matching lines @@
     NullableCSSValue& operator=(const NullableCSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
     bool operator==(const NullableCSSValue& rhs) const
     {
+        if (m_data == rhs.m_data)
+            return true;
+        if (!isObject() || (rhs && !rhs.isObject()))
+            return false;
         return m_data ? rhs.m_data && m_data->equals(*rhs.m_data) : !bool(rhs.m_data);
     }
 
     bool operator!=(const NullableCSSValue& rhs) const
     {
         return !(*this == rhs);
     }
 
     CSSValue& operator*()
     {
@@ skipping 20 matching lines @@
         return reinterpret_cast<const CSSValue*>(this);
     }
 
     void swap(NullableCSSValue& rhs)
     {
         std::swap(this->m_data, rhs.m_data);
     }
 
     DEFINE_INLINE_TRACE()
     {
-        visitor->trace(m_data);
+        if (isObject())
+            visitor->trace(m_data);
     }
 
     // Only for use by the toFooCSSValue() macros. Don't use this.
     // TODO(sashab): Remove this and use value.to<Type> and value.isValid<Type>
     // like WebNode.
     CSSValueObject* get() const
     {
         return m_data.get();
     }
 
 private:
     void ref() const
     {
 #if !ENABLE(OILPAN)
-        if (m_data)
+        if (m_data && isObject())
             m_data->ref();
 #endif
     }
 
     void deref() const
     {
 #if !ENABLE(OILPAN)
-        if (m_data)
+        if (m_data && isObject())
             m_data->deref();
 #endif
     }
 
+    bool isObject() const
+    {
+        return !(*reinterpret_cast<const uintptr_t*>(&m_data) & 1);
+    }
+
     RawPtrWillBeMember<CSSValueObject> m_data;
 };
 
 static_assert(sizeof(CSSValue) == sizeof(void*), "CSSValue should be pointer-sized");
 static_assert(sizeof(NullableCSSValue) == sizeof(void*), "CSSValue should be pointer-sized");
 static_assert(sizeof(CSSValue) == sizeof(NullableCSSValue), "Both CSSValue containers must contain the same data");
 
 template<size_t inlineCapacity>
 inline bool compareCSSValueVector(const WillBeHeapVector<CSSValue, inlineCapacity>& firstVector, const WillBeHeapVector<CSSValue, inlineCapacity>& secondVector)
 {
@@ skipping 32 matching lines @@
     ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
     return CSSPrimitiveValue(static_cast<CSSPrimitiveValue::CSSLargePrimitiveValue*>(value.get()));
 }
 
 } // namespace blink
 
 WTF_ALLOW_CLEAR_UNUSED_SLOTS_WITH_MEM_FUNCTIONS(blink::CSSValue);
 WTF_ALLOW_CLEAR_UNUSED_SLOTS_WITH_MEM_FUNCTIONS(blink::NullableCSSValue);
 
 #endif // CSSValue_h