Callback API Change: is_null, Reset, and Equals

base/callback.h

 // This file was GENERATED by command:
 //     pump.py callback.h.pump
 // DO NOT EDIT BY HAND!!!
 
 
 // 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.
 
 #ifndef BASE_CALLBACK_H_
@@ skipping 194 matching lines @@
 //  - Invoking the return of Bind.  Bind(&foo).Run() does not work;
 //  - Binding arrays to functions that take a non-const pointer.
 //    Example:
 //      void Foo(const char* ptr);
 //      void Bar(char* ptr);
 //      Bind(&Foo, "test");
 //      Bind(&Bar, "test");  // This fails because ptr is not const.
 
 namespace base {
 
+namespace internal {
+
+// Holds the methods that don't require specialization to reduce template bloat.
+class CallbackBase {
+ protected:
+  // In C++, it is safe to cast function pointers to function pointers of
+  // another type. It is not okay to use void*. We create a InvokeFuncStorage
+  // that that can store our function pointer, and then cast it back to
+  // the original type on usage.
+  typedef void(*InvokeFuncStorage)(void);
+
+ public:
+  explicit CallbackBase(InvokeFuncStorage polymorphic_invoke)

[willchan no longer on Chromium, 2011/02/17 01:09:57]

Can't this be protected? And then you can move all these accessors to public,
above the initial protected: section? Then you won't need to have them out of
order and won't need 2 protected sections.

[awong, 2011/02/17 02:05:29]

Good point. Fixed.

+      : polymorphic_invoke_(polymorphic_invoke) {
+  }
+
+  // Returns true if Callback is empty (doesn't refer to anything).
+  bool is_empty() const {

[willchan no longer on Chromium, 2011/02/17 01:09:57]

Bike shed alert: I prefer empty() to is_empty(). For some reason, the latter
sounds fugly to me. This is just me being neurotic, so feel free to ignore.

To add a minor bit of weight behind my bike shed comment, I refer to the
tr1::function proposal document
(http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1402.html) which says:

=====

IIIc. Lack of extraneous null-checking syntax

This follows from the lack of comparison operators. For a function object
wrapper f, there is no syntax f != 0, f == 0, etc. The allowed syntactic
constructs for checking for an empty (null) function object wrapper are f or !f
in a boolean context, (bool)f or f.empty().

=====

So I favor empty(). And if it becomes useful, then maybe we can add the other
operators but I figure let's not bother unless people demand it.

[awong, 2011/02/17 02:05:29]

Yeah...now that you mention it, empty() is my preference as well.

+    return invoker_storage_.get() == NULL;
+  }
+
+  // Returns the Callback into an empty state.
+  void reset() {
+    invoker_storage_ = NULL;
+    polymorphic_invoke_ = NULL;
+  }
+
+  bool Equals(const CallbackBase& other) const {

[akalin, 2011/02/17 01:16:39]

Do we really need this?  I have a hard time imagining when I'd need to compare
callbacks, although I guess it may help when stuffing them in a container.

Bikeshed alert: Why is Equals() uppercase but all the other methods lowercase?

[awong, 2011/02/17 02:05:29]

I struggled with this...I almost actually wanted to overload operator ==.

The usecase is actually in messageloop.  There is a point where they currently
test "Task*" for equality.  I can drop this for now and try to find a way in
message-loop to tag a change differently.  That might be cleaner.

+    return invoker_storage_.get() == other.invoker_storage_.get() &&
+           polymorphic_invoke_ == other.polymorphic_invoke_;
+  }
+
+ protected:
+  scoped_refptr<InvokerStorageBase> invoker_storage_;
+  InvokeFuncStorage polymorphic_invoke_;
+};
+
+}  // namespace internal
+
+
 // First, we forward declare the Callback class template. This informs the
 // compiler that the template only has 1 type parameter which is the function
 // signature that the Callback is representing.
 //
 // After this, create template specializations for 0-6 parameters. Note that
 // even though the template typelist grows, the specialization still
 // only has one type: the function signature.
 template <typename Sig>
 class Callback;
-
 template <typename R>
-class Callback<R(void)> {
+class Callback<R(void)> : public internal::CallbackBase {
  public:
   typedef R(*PolymorphicInvoke)(internal::InvokerStorageBase*);
 
-  Callback() : polymorphic_invoke_(NULL) { }
+  Callback() : CallbackBase(NULL) { }
 
   // We pass InvokerStorageHolder by const ref to avoid incurring an
   // unnecessary AddRef/Unref pair even though we will modify the object.
   // We cannot use a normal reference because the compiler will warn
   // since this is often used on a return value, which is a temporary.
   //
   // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
   // return the exact Callback<> type.  See base/bind.h for details.
   template <typename T>
   Callback(const internal::InvokerStorageHolder<T>& invoker_holder)
-      : polymorphic_invoke_(&T::FunctionTraits::DoInvoke) {
+      : CallbackBase(
+          reinterpret_cast<InvokeFuncStorage>(&T::FunctionTraits::DoInvoke)) {
     invoker_storage_.swap(invoker_holder.invoker_storage_);

[akalin, 2011/02/17 01:16:39]

can't you add an InvokerStorageBase param to the CallbackBase constructor and do
the (and const cast) swap there?

[awong, 2011/02/17 02:05:29]

Oh...good point.

   }
 
-  R Run(void) const {
-    return polymorphic_invoke_(invoker_storage_.get());
+
+  R Run() const {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(invoker_storage_.get());
   }
-
- private:
-  scoped_refptr<internal::InvokerStorageBase> invoker_storage_;
-  PolymorphicInvoke polymorphic_invoke_;
 };
 
 template <typename R, typename A1>
-class Callback<R(A1)> {
+class Callback<R(A1)> : public internal::CallbackBase {
  public:
   typedef R(*PolymorphicInvoke)(internal::InvokerStorageBase*, const A1&);
 
-  Callback() : polymorphic_invoke_(NULL) { }
+  Callback() : CallbackBase(NULL) { }
 
   // We pass InvokerStorageHolder by const ref to avoid incurring an
   // unnecessary AddRef/Unref pair even though we will modify the object.
   // We cannot use a normal reference because the compiler will warn
   // since this is often used on a return value, which is a temporary.
   //
   // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
   // return the exact Callback<> type.  See base/bind.h for details.
   template <typename T>
   Callback(const internal::InvokerStorageHolder<T>& invoker_holder)
-      : polymorphic_invoke_(&T::FunctionTraits::DoInvoke) {
+      : CallbackBase(
+          reinterpret_cast<InvokeFuncStorage>(&T::FunctionTraits::DoInvoke)) {
     invoker_storage_.swap(invoker_holder.invoker_storage_);
   }
 
+
   R Run(const A1& a1) const {
-    return polymorphic_invoke_(invoker_storage_.get(), a1);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(invoker_storage_.get(), a1);
   }
-
- private:
-  scoped_refptr<internal::InvokerStorageBase> invoker_storage_;
-  PolymorphicInvoke polymorphic_invoke_;
 };
 
 template <typename R, typename A1, typename A2>
-class Callback<R(A1, A2)> {
+class Callback<R(A1, A2)> : public internal::CallbackBase {
  public:
   typedef R(*PolymorphicInvoke)(internal::InvokerStorageBase*, const A1&,
                                 const A2&);
 
-  Callback() : polymorphic_invoke_(NULL) { }
+  Callback() : CallbackBase(NULL) { }
 
   // We pass InvokerStorageHolder by const ref to avoid incurring an
   // unnecessary AddRef/Unref pair even though we will modify the object.
   // We cannot use a normal reference because the compiler will warn
   // since this is often used on a return value, which is a temporary.
   //
   // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
   // return the exact Callback<> type.  See base/bind.h for details.
   template <typename T>
   Callback(const internal::InvokerStorageHolder<T>& invoker_holder)
-      : polymorphic_invoke_(&T::FunctionTraits::DoInvoke) {
+      : CallbackBase(
+          reinterpret_cast<InvokeFuncStorage>(&T::FunctionTraits::DoInvoke)) {
     invoker_storage_.swap(invoker_holder.invoker_storage_);
   }
 
+
   R Run(const A1& a1,
         const A2& a2) const {
-    return polymorphic_invoke_(invoker_storage_.get(), a1,
-                               a2);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(invoker_storage_.get(), a1,
+             a2);
   }
-
- private:
-  scoped_refptr<internal::InvokerStorageBase> invoker_storage_;
-  PolymorphicInvoke polymorphic_invoke_;
 };
 
 template <typename R, typename A1, typename A2, typename A3>
-class Callback<R(A1, A2, A3)> {
+class Callback<R(A1, A2, A3)> : public internal::CallbackBase {
  public:
   typedef R(*PolymorphicInvoke)(internal::InvokerStorageBase*, const A1&,
                                 const A2&,
                                 const A3&);
 
-  Callback() : polymorphic_invoke_(NULL) { }
+  Callback() : CallbackBase(NULL) { }
 
   // We pass InvokerStorageHolder by const ref to avoid incurring an
   // unnecessary AddRef/Unref pair even though we will modify the object.
   // We cannot use a normal reference because the compiler will warn
   // since this is often used on a return value, which is a temporary.
   //
   // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
   // return the exact Callback<> type.  See base/bind.h for details.
   template <typename T>
   Callback(const internal::InvokerStorageHolder<T>& invoker_holder)
-      : polymorphic_invoke_(&T::FunctionTraits::DoInvoke) {
+      : CallbackBase(
+          reinterpret_cast<InvokeFuncStorage>(&T::FunctionTraits::DoInvoke)) {
     invoker_storage_.swap(invoker_holder.invoker_storage_);
   }
 
+
   R Run(const A1& a1,
         const A2& a2,
         const A3& a3) const {
-    return polymorphic_invoke_(invoker_storage_.get(), a1,
-                               a2,
-                               a3);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(invoker_storage_.get(), a1,
+             a2,
+             a3);
   }
-
- private:
-  scoped_refptr<internal::InvokerStorageBase> invoker_storage_;
-  PolymorphicInvoke polymorphic_invoke_;
 };
 
 template <typename R, typename A1, typename A2, typename A3, typename A4>
-class Callback<R(A1, A2, A3, A4)> {
+class Callback<R(A1, A2, A3, A4)> : public internal::CallbackBase {
  public:
   typedef R(*PolymorphicInvoke)(internal::InvokerStorageBase*, const A1&,
                                 const A2&,
                                 const A3&,
                                 const A4&);
 
-  Callback() : polymorphic_invoke_(NULL) { }
+  Callback() : CallbackBase(NULL) { }
 
   // We pass InvokerStorageHolder by const ref to avoid incurring an
   // unnecessary AddRef/Unref pair even though we will modify the object.
   // We cannot use a normal reference because the compiler will warn
   // since this is often used on a return value, which is a temporary.
   //
   // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
   // return the exact Callback<> type.  See base/bind.h for details.
   template <typename T>
   Callback(const internal::InvokerStorageHolder<T>& invoker_holder)
-      : polymorphic_invoke_(&T::FunctionTraits::DoInvoke) {
+      : CallbackBase(
+          reinterpret_cast<InvokeFuncStorage>(&T::FunctionTraits::DoInvoke)) {
     invoker_storage_.swap(invoker_holder.invoker_storage_);
   }
 
+
   R Run(const A1& a1,
         const A2& a2,
         const A3& a3,
         const A4& a4) const {
-    return polymorphic_invoke_(invoker_storage_.get(), a1,
-                               a2,
-                               a3,
-                               a4);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(invoker_storage_.get(), a1,
+             a2,
+             a3,
+             a4);
   }
-
- private:
-  scoped_refptr<internal::InvokerStorageBase> invoker_storage_;
-  PolymorphicInvoke polymorphic_invoke_;
 };
 
 template <typename R, typename A1, typename A2, typename A3, typename A4,
     typename A5>
-class Callback<R(A1, A2, A3, A4, A5)> {
+class Callback<R(A1, A2, A3, A4, A5)> : public internal::CallbackBase {
  public:
   typedef R(*PolymorphicInvoke)(internal::InvokerStorageBase*, const A1&,
                                 const A2&,
                                 const A3&,
                                 const A4&,
                                 const A5&);
 
-  Callback() : polymorphic_invoke_(NULL) { }
+  Callback() : CallbackBase(NULL) { }
 
   // We pass InvokerStorageHolder by const ref to avoid incurring an
   // unnecessary AddRef/Unref pair even though we will modify the object.
   // We cannot use a normal reference because the compiler will warn
   // since this is often used on a return value, which is a temporary.
   //
   // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
   // return the exact Callback<> type.  See base/bind.h for details.
   template <typename T>
   Callback(const internal::InvokerStorageHolder<T>& invoker_holder)
-      : polymorphic_invoke_(&T::FunctionTraits::DoInvoke) {
+      : CallbackBase(
+          reinterpret_cast<InvokeFuncStorage>(&T::FunctionTraits::DoInvoke)) {
     invoker_storage_.swap(invoker_holder.invoker_storage_);
   }
 
+
   R Run(const A1& a1,
         const A2& a2,
         const A3& a3,
         const A4& a4,
         const A5& a5) const {
-    return polymorphic_invoke_(invoker_storage_.get(), a1,
-                               a2,
-                               a3,
-                               a4,
-                               a5);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(invoker_storage_.get(), a1,
+             a2,
+             a3,
+             a4,
+             a5);
   }
-
- private:
-  scoped_refptr<internal::InvokerStorageBase> invoker_storage_;
-  PolymorphicInvoke polymorphic_invoke_;
 };
 
 template <typename R, typename A1, typename A2, typename A3, typename A4,
     typename A5, typename A6>
-class Callback<R(A1, A2, A3, A4, A5, A6)> {
+class Callback<R(A1, A2, A3, A4, A5, A6)> : public internal::CallbackBase {
  public:
   typedef R(*PolymorphicInvoke)(internal::InvokerStorageBase*, const A1&,
                                 const A2&,
                                 const A3&,
                                 const A4&,
                                 const A5&,
                                 const A6&);
 
-  Callback() : polymorphic_invoke_(NULL) { }
+  Callback() : CallbackBase(NULL) { }
 
   // We pass InvokerStorageHolder by const ref to avoid incurring an
   // unnecessary AddRef/Unref pair even though we will modify the object.
   // We cannot use a normal reference because the compiler will warn
   // since this is often used on a return value, which is a temporary.
   //
   // Note that this constructor CANNOT be explicit, and that Bind() CANNOT
   // return the exact Callback<> type.  See base/bind.h for details.
   template <typename T>
   Callback(const internal::InvokerStorageHolder<T>& invoker_holder)
-      : polymorphic_invoke_(&T::FunctionTraits::DoInvoke) {
+      : CallbackBase(
+          reinterpret_cast<InvokeFuncStorage>(&T::FunctionTraits::DoInvoke)) {
     invoker_storage_.swap(invoker_holder.invoker_storage_);
   }
 
+
   R Run(const A1& a1,
         const A2& a2,
         const A3& a3,
         const A4& a4,
         const A5& a5,
         const A6& a6) const {
-    return polymorphic_invoke_(invoker_storage_.get(), a1,
-                               a2,
-                               a3,
-                               a4,
-                               a5,
-                               a6);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(polymorphic_invoke_);
+
+    return f(invoker_storage_.get(), a1,
+             a2,
+             a3,
+             a4,
+             a5,
+             a6);
   }
-
- private:
-  scoped_refptr<internal::InvokerStorageBase> invoker_storage_;
-  PolymorphicInvoke polymorphic_invoke_;
 };
 
 
 // Syntactic sugar to make Callbacks<void(void)> easier to declare since it
 // will be used in a lot of APIs with delayed execution.
 typedef Callback<void(void)> Closure;
 
 }  // namespace base
 
 #endif  // BASE_CALLBACK_H