Add PassRef and createRefCounted so we can improve creation of RefCounted objects
[WebKit-https.git] / Source / WTF / wtf / RefPtr.h
index 00be88b..4e4fcf0 100644 (file)
 #ifndef WTF_RefPtr_h
 #define WTF_RefPtr_h
 
+#include "FastMalloc.h"
+#include "PassRefPtr.h"
 #include <algorithm>
 #include <utility>
-#include <wtf/FastMalloc.h>
-#include <wtf/PassRefPtr.h>
 
 namespace WTF {
 
-    template<typename T> class PassRefPtr;
-
     enum HashTableDeletedValueType { HashTableDeletedValue };
 
     template<typename T> class RefPtr {
         WTF_MAKE_FAST_ALLOCATED;
     public:
-        ALWAYS_INLINE RefPtr() : m_ptr(0) { }
+        ALWAYS_INLINE RefPtr() : m_ptr(nullptr) { }
         ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
         ALWAYS_INLINE RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { refIfNotNull(m_ptr); }
         template<typename U> RefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { refIfNotNull(m_ptr); }
@@ -48,6 +46,8 @@ namespace WTF {
         // See comments in PassRefPtr.h for an explanation of why this takes a const reference.
         template<typename U> RefPtr(const PassRefPtr<U>&);
 
+        template<typename U> RefPtr(PassRef<U>);
+
         // Hash table deleted values, which are only constructed and never copied or destroyed.
         RefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { }
         bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
@@ -57,7 +57,7 @@ namespace WTF {
         T* get() const { return m_ptr; }
         
         void clear();
-        PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = 0; return tmp; }
+        PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }
 
         T& operator*() const { return *m_ptr; }
         ALWAYS_INLINE T* operator->() const { return m_ptr; }
@@ -66,7 +66,7 @@ namespace WTF {
     
         // This conversion operator allows implicit conversion to bool but not to other integer types.
         typedef T* (RefPtr::*UnspecifiedBoolType);
-        operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::m_ptr : 0; }
+        operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::m_ptr : nullptr; }
         
         RefPtr& operator=(const RefPtr&);
         RefPtr& operator=(T*);
@@ -78,6 +78,8 @@ namespace WTF {
         template<typename U> RefPtr& operator=(const PassRefPtr<U>&);
         RefPtr& operator=(RefPtr&&);
         template<typename U> RefPtr& operator=(RefPtr<U>&&);
+        template<typename U> RefPtr& operator=(PassRef<U>);
+
         void swap(RefPtr&);
 
         static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
@@ -91,10 +93,15 @@ namespace WTF {
     {
     }
 
+    template<typename T> template<typename U> inline RefPtr<T>::RefPtr(PassRef<U> reference)
+        : m_ptr(&reference.takeReference())
+    {
+    }
+
     template<typename T> inline void RefPtr<T>::clear()
     {
         T* ptr = m_ptr;
-        m_ptr = 0;
+        m_ptr = nullptr;
         derefIfNotNull(ptr);
     }
 
@@ -147,6 +154,13 @@ namespace WTF {
         return *this;
     }
 
+    template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(PassRef<U> reference)
+    {
+        RefPtr ptr = reference;
+        swap(ptr);
+        return *this;
+    }
+
     template<class T> inline void RefPtr<T>::swap(RefPtr& o)
     {
         std::swap(m_ptr, o.m_ptr);