CSSValue Immediates: Add move operators to CSSPrimitiveValue

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,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #ifndef CSSValue_h
 #define CSSValue_h
 
 #include "core/CoreExport.h"
+#include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSValueObject.h"
 #include "platform/heap/Handle.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 // A non-nullable container for CSSValueObject. Takes ownership of the passed
 // 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();
     }
 
+    // Implicit conversion from CSSPrimitiveValue.
+    CSSValue(const CSSPrimitiveValue& cssPrimitiveValue)
+        : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
+    {
+        ref();
+    }
+
     ~CSSValue()
     {
         // Although m_data can't be null, a move constructor from NullableCSSValue
         // could make it null for a short time.
         if (m_data)
             deref();
 
     }
 
     CSSValue& operator=(const CSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
     CSSValue& operator=(CSSValue&& rhs)
     {
         m_data = rhs.m_data;
         rhs.m_data.clear();
         return *this;
     }
 
     CSSValue(CSSValue&& rhs)
+        : m_data(rhs.m_data)
     {
-        m_data = rhs.m_data;
+        rhs.m_data.clear();
     }
 
     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 35 matching lines @@
         ref();
     }
 
     NullableCSSValue(const CSSValue& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
     NullableCSSValue(NullableCSSValue&& rhs)
+        : m_data(rhs.m_data)
     {
-        m_data = rhs.m_data;
-        rhs.m_data = nullptr;
+        rhs.m_data.clear();
     }
 
+    // Implicit conversion from CSSPrimitiveValue.
+    NullableCSSValue(const CSSPrimitiveValue& cssPrimitiveValue)
+        : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
+    {
+        ref();
+    }
 
     ~NullableCSSValue()
     {
         deref();
     };
 
-    operator bool() const
+    explicit operator bool() const
     {
         return m_data;
     }
 
     NullableCSSValue& operator=(const NullableCSSValue& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
     NullableCSSValue& operator=(NullableCSSValue&& rhs)
     {
         m_data = rhs.m_data;
         rhs.m_data.clear();
         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)
+    bool operator!=(const NullableCSSValue& rhs) const
     {
         return !(*this == rhs);
     }
 
     CSSValue& operator*()
     {
         ASSERT(m_data);
         // reinterpret_casts used to avoid ref-churn.
         return *reinterpret_cast<CSSValue*>(this);
     }
@@ skipping 16 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");
+static_assert(sizeof(CSSValue) == sizeof(CSSPrimitiveValue), "Both CSSValue and CSSPrimitiveValue must contain the same data");
 
 template<size_t inlineCapacity>
 inline bool compareCSSValueVector(const WillBeHeapVector<CSSValue, inlineCapacity>& firstVector, const WillBeHeapVector<CSSValue, inlineCapacity>& secondVector)
 {
     size_t size = firstVector.size();
     if (size != secondVector.size())
         return false;
 
     for (size_t i = 0; i < size; i++) {
         const CSSValue& firstPtr = firstVector[i];
@@ skipping 13 matching lines @@
         return *static_cast<thisType*>(value.get()); \
     } \
     inline thisType* to##thisType(const NullableCSSValue& value) \
     { \
         if (!value) \
             return nullptr; \
         ASSERT_WITH_SECURITY_IMPLICATION(value->predicate); \
         return static_cast<thisType*>(value.get()); \
     }
 
+inline const CSSPrimitiveValue& toCSSPrimitiveValue(const CSSValue& value)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
+    return *reinterpret_cast<const CSSPrimitiveValue*>(&value);
+}
+inline const CSSPrimitiveValue& toCSSPrimitiveValue(const NullableCSSValue& value)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(value && value->isPrimitiveValue());
+    return *reinterpret_cast<const CSSPrimitiveValue*>(&value);
+}
+/*
+inline CSSPrimitiveValue& toCSSPrimitiveValue(const CSSValue& value)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
+    return *const_cast<CSSPrimitiveValue*>(reinterpret_cast<const CSSPrimitiveValue*>(&value));
+}
+*/
+
 } // 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