Remove all uses of PassRefPtr in WTF
[WebKit-https.git] / Source / WTF / wtf / RefPtr.h
index b54261e..de47b66 100644 (file)
@@ -31,6 +31,9 @@
 
 namespace WTF {
 
+template<typename T> class RefPtr;
+template<typename T> RefPtr<T> adoptRef(T*);
+
 enum HashTableDeletedValueType { HashTableDeletedValue };
 
 template<typename T> class RefPtr {
@@ -39,6 +42,8 @@ public:
     typedef T ValueType;
     typedef ValueType* PtrType;
 
+    static constexpr bool isRefPtr = true;
+
     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); }
@@ -56,17 +61,17 @@ public:
     RefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { }
     bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
 
-    ALWAYS_INLINE ~RefPtr() { derefIfNotNull(m_ptr); }
+    ALWAYS_INLINE ~RefPtr() { derefIfNotNull(std::exchange(m_ptr, nullptr)); }
 
     T* get() const { return m_ptr; }
     
-    void clear();
-    PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }
+    // FIXME: Remove release() and change all call sites to call WTFMove().
+    RefPtr<T> release() { RefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }
     Ref<T> releaseNonNull() { ASSERT(m_ptr); Ref<T> tmp(adoptRef(*m_ptr)); m_ptr = nullptr; return tmp; }
 
     T* leakRef() WARN_UNUSED_RETURN;
 
-    T& operator*() const { return *m_ptr; }
+    T& operator*() const { ASSERT(m_ptr); return *m_ptr; }
     ALWAYS_INLINE T* operator->() const { return m_ptr; }
     
     bool operator!() const { return !m_ptr; }
@@ -77,6 +82,7 @@ public:
     
     RefPtr& operator=(const RefPtr&);
     RefPtr& operator=(T*);
+    RefPtr& operator=(std::nullptr_t);
     RefPtr& operator=(const PassRefPtr<T>&);
     template<typename U> RefPtr& operator=(const RefPtr<U>&);
     template<typename U> RefPtr& operator=(const PassRefPtr<U>&);
@@ -96,6 +102,11 @@ public:
 #endif
 
 private:
+    friend RefPtr adoptRef<T>(T*);
+
+    enum AdoptTag { Adopt };
+    RefPtr(T* ptr, AdoptTag) : m_ptr(ptr) { }
+
     T* m_ptr;
 };
 
@@ -109,11 +120,6 @@ template<typename T> template<typename U> inline RefPtr<T>::RefPtr(Ref<U>&& refe
 {
 }
 
-template<typename T> inline void RefPtr<T>::clear()
-{
-    derefIfNotNull(std::exchange(m_ptr, nullptr));
-}
-
 template<typename T>
 inline T* RefPtr<T>::leakRef()
 {
@@ -141,6 +147,12 @@ template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(T* optr)
     return *this;
 }
 
+template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(std::nullptr_t)
+{
+    derefIfNotNull(std::exchange(m_ptr, nullptr));
+    return *this;
+}
+
 template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(const PassRefPtr<T>& o)
 {
     RefPtr ptr = o;
@@ -157,21 +169,21 @@ template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=
 
 template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr&& o)
 {
-    RefPtr ptr = WTF::move(o);
+    RefPtr ptr = WTFMove(o);
     swap(ptr);
     return *this;
 }
 
 template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr<U>&& o)
 {
-    RefPtr ptr = WTF::move(o);
+    RefPtr ptr = WTFMove(o);
     swap(ptr);
     return *this;
 }
 
 template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(Ref<U>&& reference)
 {
-    RefPtr ptr = WTF::move(reference);
+    RefPtr ptr = WTFMove(reference);
     swap(ptr);
     return *this;
 }
@@ -225,9 +237,16 @@ template <typename T> struct IsSmartPtr<RefPtr<T>> {
     static const bool value = true;
 };
 
+template<typename T> inline RefPtr<T> adoptRef(T* p)
+{
+    adopted(p);
+    return RefPtr<T>(p, RefPtr<T>::Adopt);
+}
+
 } // namespace WTF
 
 using WTF::RefPtr;
+using WTF::adoptRef;
 using WTF::static_pointer_cast;
 
 #endif // WTF_RefPtr_h