Add std::unique_ptr conversions to scoped_ptr.

base/memory/scoped_ptr.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Scopers help you manage ownership of a pointer, helping you easily manage a
 // pointer within a scope, and automatically destroying the pointer at the end
 // of a scope.  There are two main classes you will use, which correspond to the
 // operators new/delete and new[]/delete[].
 //
 // Example usage (scoped_ptr<T>):
@@ skipping 127 matching lines @@
   template <typename U, typename V>
   scoped_ptr_impl(scoped_ptr_impl<U, V>* other)
       : data_(other->release(), other->get_deleter()) {
     // We do not support move-only deleters.  We could modify our move
     // emulation to have base::subtle::move() and base::subtle::forward()
     // functions that are imperfect emulations of their C++11 equivalents,
     // but until there's a requirement, just assume deleters are copyable.
   }
 
   template <typename U, typename V>
+  void TakeState(std::unique_ptr<U, V>* other) {
+    reset(other->release());
+    get_deleter() = other->get_deleter();
+  }
+
+  template <typename U, typename V>
   void TakeState(scoped_ptr_impl<U, V>* other) {
     // See comment in templated constructor above regarding lack of support
     // for move-only deleters.
     reset(other->release());
     get_deleter() = other->get_deleter();
   }
 
   ~scoped_ptr_impl() {
     // Match libc++, which calls reset() in its destructor.
     // Use nullptr as the new value for three reasons:
@@ skipping 229 matching lines @@
   }
 
   // Release a pointer.
   // The return value is the current pointer held by this object. If this object
   // holds a nullptr, the return value is nullptr. After this operation, this
   // object will hold a nullptr, and will not own the object any more.
   element_type* release() WARN_UNUSED_RESULT {
     return impl_.release();
   }
 
+  // Conversion shims to help with the std::unique_ptr transition.
+  template <typename U, typename V>
+  scoped_ptr(std::unique_ptr<U, V>&& p)
+      : impl_(p.release(), p.get_deleter()) {}
+
+  template <typename U, typename V>
+  scoped_ptr& operator=(std::unique_ptr<U, V>&& p) {
+    impl_.TakeState(&p);
+    return *this;
+  }
+
+  template <typename U, typename V>
+  operator std::unique_ptr<U, V>() && {
+    return std::unique_ptr<U, V>(release(), get_deleter());
+  }
+
  private:
   // Needed to reach into |impl_| in the constructor.
   template <typename U, typename V> friend class scoped_ptr;
   base::internal::scoped_ptr_impl<element_type, deleter_type> impl_;
 
   // Forbidden for API compatibility with std::unique_ptr.
   explicit scoped_ptr(int disallow_construction_from_null);
 };
 
 template <class T, class D>
@@ skipping 72 matching lines @@
   }
 
   // Release a pointer.
   // The return value is the current pointer held by this object. If this object
   // holds a nullptr, the return value is nullptr. After this operation, this
   // object will hold a nullptr, and will not own the object any more.
   element_type* release() WARN_UNUSED_RESULT {
     return impl_.release();
   }
 
+  // Conversion shims to help with the std::unique_ptr transition.
+  scoped_ptr(std::unique_ptr<T[], D>&& p)
+      : impl_(p.release(), p.get_deleter()) {}
+
+  scoped_ptr& operator=(std::unique_ptr<T[], D>&& p) {
+    impl_.TakeState(&p);
+    return *this;
+  }
+
+  operator std::unique_ptr<T[], D>() && {
+    return std::unique_ptr<T[], D>(release(), get_deleter());
+  }
+
  private:
   // Force element_type to be a complete type.
   enum { type_must_be_complete = sizeof(element_type) };
 
   // Actually hold the data.
   base::internal::scoped_ptr_impl<element_type, deleter_type> impl_;
 
   // Disable initialization from any type other than element_type*, by
   // providing a constructor that matches such an initialization, but is
   // private and has no definition. This is disabled because it is not safe to
@@ skipping 99 matching lines @@
 scoped_ptr<T> make_scoped_ptr(T* ptr) {
   return scoped_ptr<T>(ptr);
 }
 
 template <typename T>
 std::ostream& operator<<(std::ostream& out, const scoped_ptr<T>& p) {
   return out << p.get();
 }
 
 #endif  // BASE_MEMORY_SCOPED_PTR_H_