Add scoped_ptr<>::PassAs<>().

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 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 49 matching lines @@
 //     scoped_ptr<Foo> ptr3 =                // ptr3 now owns what was in ptr2.
 //         PassThru(ptr2.Pass());            // ptr2 is correspondingly NULL.
 //   }
 //
 // Notice that if you do not call Pass() when returning from PassThru(), or
 // when invoking TakesOwnership(), the code will not compile because scopers
 // are not copyable; they only implement move semantics which require calling
 // the Pass() function to signify a destructive transfer of state. CreateFoo()
 // is different though because we are constructing a temporary on the return
 // line and thus can avoid needing to call Pass().
+//
+// Pass() properly handles upcast in assignment, i.e. you can assign
+// scoped_ptr<Child> to scoped_ptr<Parent>:
+//
+//   scoped_ptr<Foo> foo(new Foo());
+//   scoped_ptr<FooParent> parent = foo.Pass();
+//
+// PassAs<>() should be used to upcast return value in return statement:
+//
+//   scoped_ptr<Foo> CreateFoo() {
+//     scoped_ptr<FooChild> result(new FooChild());
+//     return result.PassAs<Foo>();
+//   }
+//
+// Note that PassAs<>() is implemented only for scoped_ptr, but not for
+// scoped_array. This is because casting array pointers may not be safe.
 
 #ifndef BASE_MEMORY_SCOPED_PTR_H_
 #define BASE_MEMORY_SCOPED_PTR_H_
 #pragma once
 
 // This is an implementation designed to match the anticipated future TR2
 // implementation of the scoped_ptr class, and its closely-related brethren,
 // scoped_array, scoped_ptr_malloc.
 
 #include <assert.h>
@@ skipping 95 matching lines @@
   // The return value is the current pointer held by this object.
   // If this object holds a NULL pointer, the return value is NULL.
   // After this operation, this object will hold a NULL pointer,
   // and will not own the object any more.
   C* release() WARN_UNUSED_RESULT {
     C* retVal = ptr_;
     ptr_ = NULL;
     return retVal;
   }
 
+  template <typename PassAsType>
+  scoped_ptr<PassAsType> PassAs() {

[darin (slow to review), 2012/01/24 21:17:53]

Had you considered putting this in base/move.h alongside the definition of Pass?
 I'm not sure how to do it, so maybe it isn't even possible.

[Sergey Ulanov, 2012/01/24 21:55:18]

Yes, I considered it, but decided against it because it would be unsafe to allow
PassAs<>() for scoped_array. Specifically upcasting array pointers isn't safe
when sizes of parent and child classes differ.

+    return scoped_ptr<PassAsType>(release());
+  }
+
  private:
   C* ptr_;
 
   // Forbid comparison of scoped_ptr types.  If C2 != C, it totally doesn't
   // make sense, and if C2 == C, it still doesn't make sense because you should
   // never have the same object owned by two different scoped_ptrs.
   template <class C2> bool operator==(scoped_ptr<C2> const& p2) const;
   template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const;
 
 };
@@ skipping 246 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_