Add move semantics to RefPtr

Source/wtf/RefPtr.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 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,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Library General Public License for more details.
  *
  *  You should have received a copy of the GNU Library General Public License
  *  along with this library; see the file COPYING.LIB.  If not, write to
  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *  Boston, MA 02110-1301, USA.
  *
  */
 
 // RefPtr and PassRefPtr are documented at http://webkit.org/coding/RefPtr.html
 
 #ifndef WTF_RefPtr_h
 #define WTF_RefPtr_h
 
 #include <algorithm>
+#include <utility>
 #include <wtf/FastAllocBase.h>
 #include <wtf/PassRefPtr.h>
 
 namespace WTF {
 
     enum PlacementNewAdoptType { PlacementNewAdopt };
 
     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(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); }
 
+#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>&);
 
         // Special constructor for cases where we overwrite an object in place.
         ALWAYS_INLINE RefPtr(PlacementNewAdoptType) { }
 
         // 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(); }
 
@@ skipping 14 matching lines @@
         operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::m_ptr : 0; }
         
         RefPtr& operator=(const RefPtr&);
         RefPtr& operator=(T*);
         RefPtr& operator=(const PassRefPtr<T>&);
 #if !COMPILER_SUPPORTS(CXX_NULLPTR)
         RefPtr& operator=(std::nullptr_t) { clear(); return *this; }
 #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); }
 
     private:
         T* m_ptr;
     };
     
     template<typename T> template<typename U> inline RefPtr<T>::RefPtr(const PassRefPtr<U>& o)
         : m_ptr(o.leakRef())
@@ skipping 44 matching lines @@
         return *this;
     }
 
     template<typename T> template<typename U> inline RefPtr<T>& RefPtr<T>::operator=(const PassRefPtr<U>& o)
     {
         T* ptr = m_ptr;
         m_ptr = o.leakRef();
         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);
     }
 
     template<class T> inline void swap(RefPtr<T>& a, RefPtr<T>& b)
     {
         a.swap(b);
     }
 
@@ skipping 42 matching lines @@
         return p.get();
     }
 
 } // namespace WTF
 
 using WTF::RefPtr;
 using WTF::static_pointer_cast;
 using WTF::const_pointer_cast;
 
 #endif // WTF_RefPtr_h