Extend scoped_ptr to be closer to unique_ptr. Support custom deleters, and deleting arrays.

base/callback_internal.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.
 
 // This file contains utility functions and classes that help the
 // implementation, and management of the Callback objects.
 
 #ifndef BASE_CALLBACK_INTERNAL_H_
 #define BASE_CALLBACK_INTERNAL_H_
 
@@ skipping 112 matching lines @@
 //
 // For these types, the ForwardType must not be a const reference, or a
 // reference.  A const reference is inappropriate, and would break const
 // correctness, because we are implementing a destructive move.  A non-const
 // reference cannot be used with temporaries which means the result of a
 // function or a cast would not be usable with Callback<> or Bind().
 //
 // TODO(ajwong): We might be able to use SFINAE to search for the existence of
 // a Pass() function in the type and avoid the whitelist in CallbackParamTraits
 // and CallbackForward.
-template <typename T>
-struct CallbackParamTraits<scoped_ptr<T> > {
-  typedef scoped_ptr<T> ForwardType;
-  typedef scoped_ptr<T> StorageType;
+template <typename T, typename D>
+struct CallbackParamTraits<scoped_ptr<T, D> > {
+  typedef scoped_ptr<T, D> ForwardType;
+  typedef scoped_ptr<T, D> StorageType;
 };
 
 template <typename T>
 struct CallbackParamTraits<scoped_array<T> > {
   typedef scoped_array<T> ForwardType;
   typedef scoped_array<T> StorageType;
 };
 
 template <typename T, typename R>
 struct CallbackParamTraits<scoped_ptr_malloc<T, R> > {
@@ skipping 19 matching lines @@
 // is impossible to implement a general std::forward with C++11 due to a lack
 // of rvalue references.
 //
 // In addition to Callback/Bind, this is used by PostTaskAndReplyWithResult to
 // simulate std::forward() and forward the result of one Callback as a
 // parameter to another callback. This is to support Callbacks that return
 // the movable-but-not-copyable types whitelisted above.
 template <typename T>
 T& CallbackForward(T& t) { return t; }
 
-template <typename T>
-scoped_ptr<T> CallbackForward(scoped_ptr<T>& p) { return p.Pass(); }
+template <typename T, typename D>
+scoped_ptr<T, D> CallbackForward(scoped_ptr<T, D>& p) { return p.Pass(); }
 
 template <typename T>
 scoped_array<T> CallbackForward(scoped_array<T>& p) { return p.Pass(); }
 
 template <typename T, typename R>
 scoped_ptr_malloc<T, R> CallbackForward(scoped_ptr_malloc<T, R>& p) {
   return p.Pass();
 }
 
 template <typename T>
 ScopedVector<T> CallbackForward(ScopedVector<T>& p) { return p.Pass(); }
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_CALLBACK_INTERNAL_H_