Callback API Change: Add in an Owned() wrapper to base::Bind().

base/bind_helpers.h

 // Copyright (c) 2011 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 defines a set of argument wrappers and related factory methods that
 // can be used specify the refcounting and reference semantics of arguments
 // that are bound by the Bind() function in base/bind.h.
 //
-// The public functions are base::Unretained(), base::ConstRef(), and
-// base::IgnoreReturn().
+// The public functions are base::Unretained(), base::Owned(),
+// base::ConstRef(), and base::IgnoreReturn().
 //
-// Unretained() allows Bind() to bind a non-refcounted class.
+// Unretained() allows Bind() to bind a non-refcounted class, and to disable
+// refcounting on arguments that are refcounted objects.
+// Owned() transfers ownership of an object to the Callback resulting from
+// bind; the object will be deleted when the Callback is deleted.
 // ConstRef() allows binding a constant reference to an argument rather
 // than a copy.
 // IgnoreReturn() is used to adapt a 0-argument Callback with a return type to
 // a Closure. This is useful if you need to PostTask with a function that has
 // a return value that you don't care about.
 //
 //
 // EXAMPLE OF Unretained():
 //
 //   class Foo {
 //    public:
 //     void func() { cout << "Foo:f" << endl; }
 //   };
 //
 //   // In some function somewhere.
 //   Foo foo;
-//   Callback<void(void)> foo_callback =
+//   Closure foo_callback =
 //       Bind(&Foo::func, Unretained(&foo));
 //   foo_callback.Run();  // Prints "Foo:f".
 //
 // Without the Unretained() wrapper on |&foo|, the above call would fail
 // to compile because Foo does not support the AddRef() and Release() methods.
 //
 //
+// EXAMPLE OF Owned():
+//
+//   void foo(int* arg) { cout << *arg << endl }
+//
+//   int* pn = new int(1);
+//   Closure foo_callback = Bind(&foo, Owned(pn));
+//
+//   foo_callback.Run();  // Prints "1"
+//   foo_callback.Run();  // Prints "1"
+//   *n = 2;
+//   foo_callback.Run();  // Prints "2"
+//
+//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
+//                          // |foo_callback| goes out of scope.
+//
+// Without Owned(), someone would have to know to delete |pn| when the last
+// reference to the Callback is deleted.
+//
+//
 // EXAMPLE OF ConstRef():
+//
 //   void foo(int arg) { cout << arg << endl }
 //
 //   int n = 1;
-//   Callback<void(void)> no_ref = Bind(&foo, n);
-//   Callback<void(void)> has_ref = Bind(&foo, ConstRef(n));
+//   Closure no_ref = Bind(&foo, n);
+//   Closure has_ref = Bind(&foo, ConstRef(n));
 //
 //   no_ref.Run();  // Prints "1"
 //   has_ref.Run();  // Prints "1"
 //
 //   n = 2;
 //   no_ref.Run();  // Prints "1"
 //   has_ref.Run();  // Prints "2"
 //
 // Note that because ConstRef() takes a reference on |n|, |n| must outlive all
 // its bound callbacks.
 //
 //
 // EXAMPLE OF IgnoreReturn():
+//
 //   int DoSomething(int arg) { cout << arg << endl; }
 //   Callback<int(void)> cb = Bind(&DoSomething, 1);
 //   Closure c = IgnoreReturn(cb);  // Prints "1"
 //       or
 //   ml->PostTask(FROM_HERE, IgnoreReturn(cb));  // Prints "1" on |ml|
 
 #ifndef BASE_BIND_HELPERS_H_
 #define BASE_BIND_HELPERS_H_
 #pragma once
 
@@ skipping 126 matching lines @@
 
 template <typename T>
 struct UnsafeBindtoRefCountedArg<T*>
     : UnsafeBindtoRefCountedArgHelper<is_class<T>::value, T> {
 };
 
 
 template <typename T>
 class UnretainedWrapper {
  public:
-  explicit UnretainedWrapper(T* o) : obj_(o) {}
-  T* get() { return obj_; }
+  explicit UnretainedWrapper(T* o) : ptr_(o) {}
+  T* get() const { return ptr_; }
  private:
-  T* obj_;
+  T* ptr_;
 };
 
 template <typename T>
 class ConstRefWrapper {
  public:
   explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
-  const T& get() { return *ptr_; }
+  const T& get() const { return *ptr_; }
  private:
   const T* ptr_;
 };
 
+// An alternate implementation is to avoid the destructive copy, and instead
+// specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
+// a class that is essentially a scoped_ptr<>.
+//
+// The current implementation has the benefit though of leaving ParamTraits<>
+// fully in callback_internal.h as well as avoiding type conversions during
+// storage.
+template <typename T>
+class OwnedWrapper {
+ public:
+  explicit OwnedWrapper(T* o) : ptr_(o) {}
+  ~OwnedWrapper() { delete ptr_; }
+  T* get() const { return ptr_; }
+  OwnedWrapper(const OwnedWrapper& other) {
+    ptr_ = other.ptr_;
+    other.ptr_ = NULL;
+  }
+
+ private:
+  mutable T* ptr_;
+};
+
 
 // Unwrap the stored parameters for the wrappers above.
 template <typename T>
 T Unwrap(T o) { return o; }
 
 template <typename T>
 T* Unwrap(UnretainedWrapper<T> unretained) { return unretained.get(); }
 
 template <typename T>
 const T& Unwrap(ConstRefWrapper<T> const_ref) {
   return const_ref.get();
 }
 
 template <typename T>
 T* Unwrap(const scoped_refptr<T>& o) { return o.get(); }
 
 template <typename T>
 const WeakPtr<T>& Unwrap(const WeakPtr<T>& o) { return o; }
 
+template <typename T>
+T* Unwrap(const OwnedWrapper<T>& o) {
+  return o.get();
+}
+
 // Utility for handling different refcounting semantics in the Bind()
 // function.
 template <typename IsMethod, typename T>
 struct MaybeRefcount;
 
 template <typename T>
 struct MaybeRefcount<base::false_type, T> {
   static void AddRef(const T&) {}
   static void Release(const T&) {}
 };
 
 template <typename T, size_t n>
 struct MaybeRefcount<base::false_type, T[n]> {
   static void AddRef(const T*) {}
   static void Release(const T*) {}
 };
 
 template <typename T>
+struct MaybeRefcount<base::true_type, T*> {
+  static void AddRef(T* o) { o->AddRef(); }
+  static void Release(T* o) { o->Release(); }
+};
+
+template <typename T>
 struct MaybeRefcount<base::true_type, UnretainedWrapper<T> > {
   static void AddRef(const UnretainedWrapper<T>&) {}
   static void Release(const UnretainedWrapper<T>&) {}
 };
 
 template <typename T>
-struct MaybeRefcount<base::true_type, T*> {
-  static void AddRef(T* o) { o->AddRef(); }
-  static void Release(T* o) { o->Release(); }
+struct MaybeRefcount<base::true_type, OwnedWrapper<T> > {
+  static void AddRef(const OwnedWrapper<T>&) {}
+  static void Release(const OwnedWrapper<T>&) {}
 };
 
 // No need to additionally AddRef() and Release() since we are storing a
 // scoped_refptr<> inside the storage object already.
 template <typename T>
 struct MaybeRefcount<base::true_type, scoped_refptr<T> > {
   static void AddRef(const scoped_refptr<T>& o) {}
   static void Release(const scoped_refptr<T>& o) {}
 };
 
@@ skipping 19 matching lines @@
 template <typename T>
 inline internal::UnretainedWrapper<T> Unretained(T* o) {
   return internal::UnretainedWrapper<T>(o);
 }
 
 template <typename T>
 inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
   return internal::ConstRefWrapper<T>(o);
 }
 
+template <typename T>
+inline internal::OwnedWrapper<T> Owned(T* o) {
+  return internal::OwnedWrapper<T>(o);
+}
+
 template <typename R>
 Closure IgnoreReturn(Callback<R(void)> callback) {
   return Bind(&internal::VoidReturnAdapter<R>, callback);
 }
 
 }  // namespace base
 
 #endif  // BASE_BIND_HELPERS_H_