Add a move constructor and move assignment operator 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 295 matching lines @@
 template <class T, class D = base::DefaultDeleter<T> >
 class scoped_ptr {
   MOVE_ONLY_TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03(scoped_ptr)
 
   COMPILE_ASSERT(base::internal::IsNotRefCounted<T>::value,
                  T_is_refcounted_type_and_needs_scoped_refptr);
 
  public:
   // The element and deleter types.
   typedef T element_type;
+  using Pointer = element_type*;
   typedef D deleter_type;
 
   // Constructor.  Defaults to initializing with nullptr.
   scoped_ptr() : impl_(nullptr) {}
 
   // Constructor.  Takes ownership of p.
   explicit scoped_ptr(element_type* p) : impl_(p) {}
 
   // Constructor.  Allows initialization of a stateful deleter.
   scoped_ptr(element_type* p, const D& d) : impl_(p, d) {}
 
   // Constructor.  Allows construction from a nullptr.
   scoped_ptr(std::nullptr_t) : impl_(nullptr) {}
 
+  // Move constructor.
+  scoped_ptr(scoped_ptr&& other) : impl_(&other.impl_) {}
+
   // Constructor.  Allows construction from a scoped_ptr rvalue for a
   // convertible type and deleter.
-  //
-  // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this constructor distinct
-  // from the normal move constructor. By C++11 20.7.1.2.1.21, this constructor
-  // has different post-conditions if D is a reference type. Since this
-  // implementation does not support deleters with reference type,
-  // we do not need a separate move constructor allowing us to avoid one
-  // use of SFINAE. You only need to care about this if you modify the
-  // implementation of scoped_ptr.
   template <typename U, typename V>
-  scoped_ptr(scoped_ptr<U, V>&& other)
+  scoped_ptr(scoped_ptr<U, V>&& other,

[danakj, 2015/11/18 23:39:34]

I wish clang-format did a better job wrapping template code, this is always a
guessing game of find-the-closing-angle-bracket.

+             typename std::enable_if<
+                 std::is_convertible<typename scoped_ptr<U, V>::Pointer,

[danakj, 2015/11/18 23:39:34]

Can you explain to me why you used enable_if here? You only compare the Pointer,
and not the deleter, and it would return true of U::Pointer == |this
type|::Pointer.

We didn't need it before cuz the impl_(&other.impl_) requires them to convert, I
think? Why now?

[dcheng, 2015/11/19 00:23:24]

I don't actually know the reasoning behind this: it's just what the standard
says. Specifically, in 20.7.1.2.1.19:
  Remarks: This constructor shall not participate in overload resolution unless:
    — unique_ptr<U, E>::pointer is implicitly convertible to pointer,
    — U is not an array type, and
    — either D is a reference type and E is the same type as D, or D is not a
reference type and E is
      implicitly convertible to D.

I'm sure there's a good reason for this, but I don't know what it is.

[vmpstr, 2015/11/19 00:37:18]

Is it possible to enable_if in the template list instead?

[dcheng, 2015/11/19 00:38:57]

Any particular reason to prefer that? I guess the style ban on default args?

+                                     Pointer>::value>::type* = nullptr)
       : impl_(&other.impl_) {
     COMPILE_ASSERT(!base::is_array<U>::value, U_cannot_be_an_array);
   }
 
   // operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
   // type and deleter.
   //
   // IMPLEMENTATION NOTE: C++11 unique_ptr<> keeps this operator= distinct from
   // the normal move assignment operator. By C++11 20.7.1.2.3.4, this templated
   // form has different requirements on for move-only Deleters. Since this
@@ skipping 268 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_