webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 17 insertions, 22 deletions

diff --git a/Source/WTF/wtf/PassRefPtr.h b/Source/WTF/wtf/PassRefPtr.h
index 62924464c..089192b0b 100644
--- a/Source/WTF/wtf/PassRefPtr.h
+++ b/Source/WTF/wtf/PassRefPtr.h
@@ -21,11 +21,12 @@
 #ifndef WTF_PassRefPtr_h
 #define WTF_PassRefPtr_h
 
-#include "PassRef.h"
+#include <wtf/Ref.h>
 
 namespace WTF {
 
-    template<typename T> PassRefPtr<T> adoptRef(T*);
+    template<typename T> class RefPtr;
+    template<typename T> class PassRefPtr;
 
     template<typename T> ALWAYS_INLINE void refIfNotNull(T* ptr)
     {
@@ -41,6 +42,9 @@ namespace WTF {
 
     template<typename T> class PassRefPtr {
     public:
+        typedef T ValueType;
+        typedef ValueType* PtrType;
+
         PassRefPtr() : m_ptr(nullptr) { }
         PassRefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
         // It somewhat breaks the type system to allow transfer of ownership out of
@@ -49,10 +53,11 @@ namespace WTF {
         PassRefPtr(const PassRefPtr& o) : m_ptr(o.leakRef()) { }
         template<typename U> PassRefPtr(const PassRefPtr<U>& o) : m_ptr(o.leakRef()) { }
 
-        ALWAYS_INLINE ~PassRefPtr() { derefIfNotNull(m_ptr); }
+        ALWAYS_INLINE ~PassRefPtr() { derefIfNotNull(std::exchange(m_ptr, nullptr)); }
 
         template<typename U> PassRefPtr(const RefPtr<U>&);
-        template<typename U> PassRefPtr(PassRef<U> reference) : m_ptr(&reference.leakRef()) { }
+        template<typename U> PassRefPtr(Ref<U>&& reference) : m_ptr(&reference.leakRef()) { }
+        template<typename U> PassRefPtr(RefPtr<U>&& reference) : m_ptr(reference.leakRef()) { }
 
         T* get() const { return m_ptr; }
 
@@ -67,7 +72,7 @@ namespace WTF {
         typedef T* (PassRefPtr::*UnspecifiedBoolType);
         operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::m_ptr : nullptr; }
 
-        friend PassRefPtr adoptRef<T>(T*);
+        template<typename V, typename U> friend PassRefPtr<V> static_pointer_cast(const PassRefPtr<U>&);
 
     private:
         PassRefPtr& operator=(const PassRefPtr&) = delete;
@@ -87,9 +92,7 @@ namespace WTF {
 
     template<typename T> inline T* PassRefPtr<T>::leakRef() const
     {
-        T* ptr = m_ptr;
-        m_ptr = nullptr;
-        return ptr;
+        return std::exchange(m_ptr, nullptr);
     }
 
     template<typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const PassRefPtr<U>& b) 
@@ -141,27 +144,19 @@ namespace WTF {
     { 
         return a != b.get(); 
     }
-    
-    template<typename T> inline PassRefPtr<T> adoptRef(T* p)
-    {
-        adopted(p);
-        return PassRefPtr<T>(p, PassRefPtr<T>::Adopt);
-    }
 
-    template<typename T, typename U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p) 
-    { 
-        return adoptRef(static_cast<T*>(p.leakRef())); 
-    }
-
-    template<typename T> inline T* getPtr(const PassRefPtr<T>& p)
+    template<typename V, typename U> inline PassRefPtr<V> static_pointer_cast(const PassRefPtr<U>& p)
     {
-        return p.get();
+        return PassRefPtr<V>(static_cast<V*>(p.leakRef()), PassRefPtr<V>::Adopt);
     }
 
+    template <typename T> struct IsSmartPtr<PassRefPtr<T>> {
+        static const bool value = true;
+    };
+
 } // namespace WTF
 
 using WTF::PassRefPtr;
-using WTF::adoptRef;
 using WTF::static_pointer_cast;
 
 #endif // WTF_PassRefPtr_h