Support Closure in ALL the loops!

base/message_loop_proxy.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.
 
 #ifndef BASE_MESSAGE_LOOP_PROXY_H_
 #define BASE_MESSAGE_LOOP_PROXY_H_
 #pragma once
 
 #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"
 
 namespace base {
 
 struct MessageLoopProxyTraits;
 
 // This class provides a thread-safe refcounted interface to the Post* methods
 // of a message loop. This class can outlive the target message loop. You can
 // obtain a MessageLoopProxy via Thread::message_loop_proxy() or
 // MessageLoopProxy::CreateForCurrentThread().
 class BASE_API MessageLoopProxy
     : public base::RefCountedThreadSafe<MessageLoopProxy,
                                         MessageLoopProxyTraits> {
  public:
   // These methods are the same as in message_loop.h, but are guaranteed to
   // either post the Task to the MessageLoop (if it's still alive), or to
   // delete the Task otherwise.
   // They return true iff the thread existed and the task was posted.  Note that
   // even if the task is posted, there's no guarantee that it will run; for
   // example the target loop may already be quitting, or in the case of a
   // delayed task a Quit message may preempt it in the message loop queue.
   // Conversely, a return value of false is a guarantee the task will not run.
   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;
 
   template <class T>
   bool DeleteSoon(const tracked_objects::Location& from_here,
                   T* object) {
     return PostNonNestableTask(from_here, new DeleteTask<T>(object));
   }
   template <class T>
@@ skipping 20 matching lines @@
 
 struct MessageLoopProxyTraits {
   static void Destruct(const MessageLoopProxy* proxy) {
     proxy->OnDestruct();
   }
 };
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_PROXY_H_