WTF: Make PassOwnPtr<T> move-only.

third_party/WebKit/Source/wtf/PassOwnPtr.h

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 29 matching lines @@
 
 template <typename T> class PassOwnPtr {
     DISALLOW_NEW();
 public:
     typedef typename std::remove_extent<T>::type ValueType;
     typedef ValueType* PtrType;
 
     PassOwnPtr() : m_ptr(nullptr) {}
     PassOwnPtr(std::nullptr_t) : m_ptr(nullptr) {}
 
     // It somewhat breaks the type system to allow transfer of ownership out of

[Mikhail, 2016/04/27 09:57:10]

Now this comment looks outdated.

[Yuta Kitamura, 2016/04/27 10:10:35]

You are right; removed.

     // a const PassOwnPtr. However, it makes it much easier to work with
     // PassOwnPtr temporaries, and we don't have a need to use real const
     // PassOwnPtrs anyway.
-    PassOwnPtr(const PassOwnPtr& o) : m_ptr(o.leakPtr()) {}
-    template <typename U> PassOwnPtr(const PassOwnPtr<U>&, EnsurePtrConvertibleArgDecl(U, T));
+    PassOwnPtr(PassOwnPtr&& o) : m_ptr(o.leakPtr()) {}
+    template <typename U> PassOwnPtr(PassOwnPtr<U>&&, EnsurePtrConvertibleArgDecl(U, T));
 
     ~PassOwnPtr() { OwnedPtrDeleter<T>::deletePtr(m_ptr); }
 
     PtrType get() const { return m_ptr; }
 
     PtrType leakPtr() const WARN_UNUSED_RETURN;
 
     ValueType& operator*() const { ASSERT(m_ptr); return *m_ptr; }
     PtrType operator->() const { ASSERT(m_ptr); return m_ptr; }
 
     bool operator!() const { return !m_ptr; }
     explicit operator bool() const { return m_ptr; }
 
     template <typename U> friend PassOwnPtr<U> adoptPtr(U*);
     template <typename U> friend PassOwnPtr<U[]> adoptArrayPtr(U*);
     template <typename U> friend class OwnPtr;
 
 private:
     explicit PassOwnPtr(PtrType ptr) : m_ptr(ptr) {}
 
+    PassOwnPtr(const PassOwnPtr&) = delete;
     PassOwnPtr& operator=(const PassOwnPtr&) = delete;
 
     // We should never have two OwnPtrs for the same underlying object
     // (otherwise we'll get double-destruction), so these equality operators
     // should never be needed.
     template <typename U> bool operator==(const PassOwnPtr<U>&) const = delete;
     template <typename U> bool operator!=(const PassOwnPtr<U>&) const = delete;
     template <typename U> bool operator==(const OwnPtr<U>&) const = delete;
     template <typename U> bool operator!=(const OwnPtr<U>&) const = delete;
 
     mutable PtrType m_ptr;

[tzik, 2016/04/27 09:40:14]

Can we remove this "mutable" now?

[Yuta Kitamura, 2016/04/27 10:10:35]

Yep, but removing this "mutable" has caused an error in
leakPtr() being const, which caused several errors in
public/platform etc. Fixed anyway.

 };
 
 template <typename T>
-template <typename U> inline PassOwnPtr<T>::PassOwnPtr(const PassOwnPtr<U>& o, EnsurePtrConvertibleArgDefn(U, T))
+template <typename U> inline PassOwnPtr<T>::PassOwnPtr(PassOwnPtr<U>&& o, EnsurePtrConvertibleArgDefn(U, T))
     : m_ptr(o.leakPtr())
 {
     static_assert(!std::is_array<T>::value, "pointers to array must never be converted");
 }
 
 template <typename T> inline typename PassOwnPtr<T>::PtrType PassOwnPtr<T>::leakPtr() const
 {
     PtrType ptr = m_ptr;
     m_ptr = nullptr;
     return ptr;
@@ skipping 22 matching lines @@
 template <typename T> inline PassOwnPtr<T> adoptPtr(T* ptr)
 {
     return PassOwnPtr<T>(ptr);
 }
 
 template <typename T> inline PassOwnPtr<T[]> adoptArrayPtr(T* ptr)
 {
     return PassOwnPtr<T[]>(ptr);
 }
 
-template <typename T, typename U> inline PassOwnPtr<T> static_pointer_cast(const PassOwnPtr<U>& p)
+template <typename T, typename U> inline PassOwnPtr<T> static_pointer_cast(PassOwnPtr<U>&& p)
 {
     static_assert(!std::is_array<T>::value, "pointers to array must never be converted");
     return adoptPtr(static_cast<T*>(p.leakPtr()));
 }
 
 template <typename T> inline T* getPtr(const PassOwnPtr<T>& p)
 {
     return p.get();
 }
 
 } // namespace WTF
 
 using WTF::PassOwnPtr;
 using WTF::adoptPtr;
 using WTF::adoptArrayPtr;
 using WTF::static_pointer_cast;
 
 #endif // WTF_PassOwnPtr_h