Add move semantics to RefPtr

Source/wtf/RefPtr.h

Index: Source/wtf/RefPtr.h
diff --git a/Source/wtf/RefPtr.h b/Source/wtf/RefPtr.h
index 322cbd6f8f7b20555dda97f8ba46e8e628400519..2fa2251b866aab74ae528190ad6778f64d54bcd6 100644
--- a/Source/wtf/RefPtr.h
+++ b/Source/wtf/RefPtr.h
@@ -24,6 +24,7 @@
 #define WTF_RefPtr_h
 
 #include <algorithm>
+#include <utility>
 #include <wtf/FastAllocBase.h>
 #include <wtf/PassRefPtr.h>
 
@@ -43,6 +44,11 @@ namespace WTF {
         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); }
 
+#if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
+        ALWAYS_INLINE RefPtr(RefPtr&& o) : m_ptr(o.release().leakRef()) { }

[Jeffrey Yasskin, 2013/04/26 19:56:46]

This looks correct, but you're not getting much benefit from the ALWAYS_INLINE
here because neither release() nor leakRef() is ALWAYS_INLINE. It's not a big
deal, but I'd implement this more directly as:

 ALWAYS_INLINE RefPtr(RefPtr&& o) : m_ptr(o.m_ptr) { o.m_ptr = 0; }

That's also more obviously correct to people who aren't familiar with
PassRefPtr.

+        template<typename U> RefPtr(RefPtr<U>&& o) : m_ptr(o.release().leakRef()) { }

[Jeffrey Yasskin, 2013/04/26 19:56:46]

In the long run, we'll probably want to enable_if this and the converting copy
constructor on is_convertible<U*, T*>, but that's not really relevant to this
change.

+#endif
+
         // See comments in PassRefPtr.h for an explanation of why this takes a const reference.
         template<typename U> RefPtr(const PassRefPtr<U>&);
 
@@ -77,7 +83,10 @@ namespace WTF {
 #endif
         template<typename U> RefPtr& operator=(const RefPtr<U>&);
         template<typename U> RefPtr& operator=(const PassRefPtr<U>&);
-
+#if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
+        RefPtr& operator=(RefPtr&&);

[Jeffrey Yasskin, 2013/04/26 19:56:46]

I usually recommend writing operator= as

RefPtr& operator=(RefPtr other) {
  swap(other);
  return *this;
}

unless the implementation sometimes doesn't move an rvalue argument (libc++'s
std::string, for example).

I don't immediately see a reason to avoid that definition of operator= here, and
it would save a bunch of overloads and the use of std::move in the
implementation.

+        template<typename U> RefPtr& operator=(RefPtr<U>&&);
+#endif
         void swap(RefPtr&);
 
         static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
@@ -142,7 +151,21 @@ namespace WTF {
         derefIfNotNull(ptr);
         return *this;
     }
+#if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
+    template<typename T> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr<T>&& o)
+    {
+        RefPtr<T> ptr = std::move(o);
+        swap(ptr);
+        return *this;
+    }
 
+    template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(RefPtr<U>&& o)
+    {
+        RefPtr<T> ptr = std::move(o);
+        swap(ptr);
+        return *this;
+    }
+#endif
     template<class T> inline void RefPtr<T>::swap(RefPtr<T>& o)
     {
         std::swap(m_ptr, o.m_ptr);