Support Closure in ALL the loops!

base/message_loop_proxy.h

Index: base/message_loop_proxy.h
diff --git a/base/message_loop_proxy.h b/base/message_loop_proxy.h
index 07bca646f56ab9e676d4b8ab51c50f4361a23250..d6955ba294247c52fd0ca504236511632e0c9696 100644
--- a/base/message_loop_proxy.h
+++ b/base/message_loop_proxy.h
@@ -8,6 +8,7 @@
 
 #include "base/base_api.h"
 #include "base/basictypes.h"
+#include "base/callback.h"

[akalin, 2011/07/20 07:52:03]

Can you remove this and instead forward-declare Callback and Closure?

You can do:

template <typename Sig> Callback<Sig>;
typedef Callback<void()> Closure;

Otherwise, bind.h will end up pulling callback.h with my WeakHandle change.

bind.h needs to #include weak_handle.h for support for the special syntax. 
weak_handle.h needs to #include message_loop_proxy.h because it needs to delete
the weak ptr on the correct thread, so it needs access to the (templated)
DeleteSoon method.  And so if message_loop_proxy.h needs callback.h, then bind.h
will end up including callback.h.

An alternate solution would be for me to remove the #include for weak_ptr.h and
weak_handle.h.  I'm not familiar with the details of template expansion, but it
seems like the definitions of WeakPtr/WeakHandle, etc. would need to be present
only at template instantation time, i.e. when you actually Bind() a WeakHandle,
aand if you're binding a WeakHandle, then you must have already included
weak_handle.h.  Unless you've forward-declared WeakHandle and are binding a
const ref, I guess?  I dunno.

I'll temporarily proceed with replacing this #include with a forward-declare in
my CL, but what do you think?

[awong, 2011/07/20 21:17:41]

Talked with Fred offline.  We realized that the main point of keeping callback.h
out of bind.h was so that bind.h wouldn't provide the Callback<> and Closure
types, thus deterring people from using bind.h just to get the correct types.
So, forward declaring is equivalent to including.

I'm going to leave this as is for now.  We'll try to solve the WeakHandle issue
separately.

 #include "base/memory/ref_counted.h"
 #include "base/task.h"
 
@@ -34,13 +35,34 @@ class BASE_API MessageLoopProxy
   virtual bool PostTask(const tracked_objects::Location& from_here,
                         Task* task) = 0;
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
-                               Task* task, int64 delay_ms) = 0;
+                               Task* task,
+                               int64 delay_ms) = 0;
   virtual bool PostNonNestableTask(const tracked_objects::Location& from_here,
                                    Task* task) = 0;
   virtual bool PostNonNestableDelayedTask(
       const tracked_objects::Location& from_here,
       Task* task,
       int64 delay_ms) = 0;
+
+  // TODO(ajwong): Remove the functions above once the Task -> Closure migration
+  // is complete.
+  //
+  // There are 2 sets of Post*Task functions, one which takes the older Task*
+  // function object representation, and one that takes the newer base::Closure.
+  // We have this overload to allow a staged transition between the two systems.
+  // Once the transition is done, the functions above should be deleted.
+  virtual bool PostTask(const tracked_objects::Location& from_here,
+                        const base::Closure& task) = 0;
+  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
+                               const base::Closure& task,
+                               int64 delay_ms) = 0;
+  virtual bool PostNonNestableTask(const tracked_objects::Location& from_here,
+                                   const base::Closure& task) = 0;
+  virtual bool PostNonNestableDelayedTask(
+      const tracked_objects::Location& from_here,
+      const base::Closure& task,
+      int64 delay_ms) = 0;
+
   // A method which checks if the caller is currently running in the thread that
   // this proxy represents.
   virtual bool BelongsToCurrentThread() = 0;