Allow construction and assignment of one scoped_ptr from another if the types are convertible.

base/memory/scoped_ptr.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 the
 // 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):
 //   {
@@ skipping 107 matching lines @@
  public:
 
   // The element type
   typedef C element_type;
 
   // Constructor.  Defaults to initializing with NULL.
   // There is no way to create an uninitialized scoped_ptr.
   // The input parameter must be allocated with new.
   explicit scoped_ptr(C* p = NULL) : ptr_(p) { }
 
+  // Constructor.  Allows construction from a scoped_ptr rvalue for a
+  // convertible type.
+  template <typename U>
+  scoped_ptr(scoped_ptr<U> other) : ptr_(other.release()) {
+  }
+
   // Destructor.  If there is a C object, delete it.
   // We don't need to test ptr_ == NULL because C++ does that for us.
   ~scoped_ptr() {
     enum { type_must_be_complete = sizeof(C) };
     delete ptr_;
   }
 
+  // operator=.  Allows assignment from a scoped_ptr rvalue for a convertible
+  // type.
+  template <typename U>
+  scoped_ptr& operator=(scoped_ptr<U> rhs) {
+    reset(rhs.release());
+    return *this;
+  }
+
   // Reset.  Deletes the current owned object, if any.
   // Then takes ownership of a new object, if given.
   // this->reset(this->get()) works.
   void reset(C* p = NULL) {
     if (p != ptr_) {
       enum { type_must_be_complete = sizeof(C) };
       delete ptr_;
       ptr_ = p;
     }
   }
@@ skipping 293 matching lines @@
 bool operator==(C* p, const scoped_ptr_malloc<C, FP>& b) {
   return p == b.get();
 }
 
 template<class C, class FP> inline
 bool operator!=(C* p, const scoped_ptr_malloc<C, FP>& b) {
   return p != b.get();
 }
 
 #endif  // BASE_MEMORY_SCOPED_PTR_H_