CSSValue Immediates: Replace CSSPrimitiveValue usage with const references

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 47 matching lines @@
 #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)
+    CSSValue(CSSValue const& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
+
+    CSSValue(CSSValue&& cssValue)
+        : m_data(cssValue.m_data)
+    {
+        cssValue.m_data.clear();
+    }
+
+
     // Implicit conversion from CSSPrimitiveValue.
     CSSValue(const CSSPrimitiveValue& cssPrimitiveValue)
-        : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
+        : m_data(reinterpret_cast<CSSValueObject*>(cssPrimitiveValue.get()))
     {
         ref();
     }
 
     ~CSSValue()
     {
-        deref();
+        // Could be null, because of move operations.
+        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.get();
+        rhs.m_data = nullptr;
+        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);
     }
@@ skipping 68 matching lines @@
     // 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
+    inline void ref() const
     {
 #if !ENABLE(OILPAN)
-        if (m_data && isObject())
+        if (isObject())
             m_data->ref();
 #endif
     }
 
-    void deref() const
+    inline void deref() const
     {
 #if !ENABLE(OILPAN)
-        if (m_data && isObject())
+        if (isObject())
             m_data->deref();
 #endif
     }
 
     bool isObject() const
     {
-        return !(*reinterpret_cast<const uintptr_t*>(&m_data) & 1);
+        return !(reinterpret_cast<const uintptr_t>(m_data.get()) & 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:
@@ skipping 36 matching lines @@
     {
         ref();
     }
 
     NullableCSSValue(const CSSValue& cssValue)
         : m_data(cssValue.m_data)
     {
         ref();
     }
 
+    NullableCSSValue(CSSValue&& cssValue)
+        : m_data(cssValue.m_data)
+    {
+        cssValue.m_data.clear();
+    }
+
+    NullableCSSValue(NullableCSSValue&& cssValue)
+        : m_data(cssValue.m_data)
+    {
+        cssValue.m_data.clear();
+    }
+
     // Implicit conversion from CSSPrimitiveValue.
     NullableCSSValue(const CSSPrimitiveValue& cssPrimitiveValue)
         : m_data(static_cast<CSSValueObject*>(cssPrimitiveValue.get()))
     {
         ref();
     }
 
     ~NullableCSSValue()
     {
         deref();
     };
 
     explicit operator bool() const
     {
         return m_data;
     }
 
-    NullableCSSValue& operator=(const NullableCSSValue& rhs)
+    NullableCSSValue& operator=(NullableCSSValue const& rhs)
     {
         rhs.ref();
         deref();
         m_data = rhs.m_data;
         return *this;
     }
 
+    NullableCSSValue& operator=(NullableCSSValue&& rhs)
+    {
+        m_data = rhs.m_data.get();
+        rhs.m_data = nullptr;
+        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*()
-    {
-        ASSERT(m_data);
-        // reinterpret_casts used to avoid ref-churn.
-        return *reinterpret_cast<CSSValue*>(this);
-    }
-
     const CSSValue& operator*() const
     {
         ASSERT(m_data);
         return *reinterpret_cast<const CSSValue*>(this);
     }
 
-    CSSValue* operator->()
-    {
-        ASSERT(m_data);
-        return reinterpret_cast<CSSValue*>(this);
-    }
-
     const CSSValue* operator->() const
     {
         ASSERT(m_data);
         return reinterpret_cast<const CSSValue*>(this);
     }
 
     void swap(NullableCSSValue& rhs)
     {
         std::swap(this->m_data, rhs.m_data);
     }
@@ skipping 24 matching lines @@
     void deref() const
     {
 #if !ENABLE(OILPAN)
         if (m_data && isObject())
             m_data->deref();
 #endif
     }
 
     bool isObject() const
     {
-        return !(*reinterpret_cast<const uintptr_t*>(&m_data) & 1);
+        return !(reinterpret_cast<const uintptr_t>(m_data.get()) & 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");
 
@@ skipping 14 matching lines @@
     return true;
 }
 
 #define DEFINE_CSS_VALUE_TYPE_CASTS(thisType, predicate) \
     DEFINE_TYPE_CASTS(thisType, CSSValueObject, value, value->predicate, value.predicate); \
     inline thisType& to##thisType(const CSSValue& value) \
     { \
         ASSERT_WITH_SECURITY_IMPLICATION(value.predicate); \
         return *static_cast<thisType*>(value.get()); \
     } \
+    inline thisType& to##thisType(CSSValue&& value) \
+    { \
+        ASSERT_WITH_SECURITY_IMPLICATION(value.predicate); \
+        return *static_cast<thisType*>(value.get()); \
+    } \
+    inline thisType* to##thisType(NullableCSSValue&& value) \
+    { \
+        if (!value) \
+            return nullptr; \
+        ASSERT_WITH_SECURITY_IMPLICATION(value->predicate); \
+        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()); \
     }
 
-// Returns by value on purpose.
 inline const CSSPrimitiveValue& toCSSPrimitiveValue(const CSSValue& value)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
     return *reinterpret_cast<const CSSPrimitiveValue*>(&value);
 }
-/*
-inline CSSPrimitiveValue& toCSSPrimitiveValue(const CSSValue& value)
+
+inline const CSSPrimitiveValue& toCSSPrimitiveValue(CSSValue&& value)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
-    return *const_cast<CSSPrimitiveValue*>(reinterpret_cast<const CSSPrimitiveValue*>(&value));
+    return *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