Support Closure in ALL the loops!

base/task.h

Index: base/task.h
diff --git a/base/task.h b/base/task.h
index ae47f32615b1b789db5b8a841b5908e62a9ed57d..6fa026e44a3fbb99dbce387dcc4111a3715db468 100644
--- a/base/task.h
+++ b/base/task.h
@@ -564,6 +564,58 @@ class BASE_API ScopedTaskRunner {
   DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedTaskRunner);
 };
 
+namespace subtle {
+
+// This class is meant for use in the implementation of MessageLoop classes
+// such as MessageLoop, MessageLoopProxy, BrowserThread, and WorkerPool to
+// implement the compatibiltiy APIs while we are transitioning from Task to
+// Callback.
+//
+// It should NOT be used anywhere else!
+//
+// In particular, notice that the this is RefCounted instead of

[willchan no longer on Chromium, 2011/07/08 12:04:21]

Your comment is totally off. This is RefCountedThreadSafe.

[awong, 2011/07/08 18:36:51]

Sorry...it's actually supposed to just be RefCounted.  I switched it temporarily
in the last patch as a stab in the dark for the try servers.  Reverting to just
RefCounted.

A different question is whether or not this is a sane thing to do.  IIRC, people
were OCD about extra refcounts inside message loop code which lead this to being
just RefCounted instead of RefCountedThreadSafe when it was first added.

+// RefCountedThreadSafe.  We rely on the fact thas users of this class are

[willchan no longer on Chromium, 2011/07/08 12:04:21]

s/thas/that/

[awong, 2011/07/08 18:36:51]

Done.

+// careful to ensure that a lock is taken during transfer of ownership for
+// objects from this class to ensure the refcount is not corrupted.
+class TaskClosureAdapter : public RefCountedThreadSafe<TaskClosureAdapter> {
+ public:
+  explicit TaskClosureAdapter(Task* task)
+      : task_(task),
+        should_leak_task_(&kTaskLeakingDefault) {
+  }
+
+  // |should_leak_task| points to a flag variable that can be used to determine
+  // if this class should leak the Task on destruction.  This is important
+  // at MessageLoop shutdown since not all tasks can be safely deleted without
+  // running.  See MessageLoop::DeletePendingTasks() for the exact behavior
+  // of when a Task should be deleted. It is subtle.
+  TaskClosureAdapter(Task* task, bool* should_leak_task)
+      : task_(task),
+        should_leak_task_(should_leak_task) {
+  }
+
+  void Run() {
+    task_->Run();
+    delete task_;
+    task_ = NULL;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<TaskClosureAdapter>;
+
+  ~TaskClosureAdapter() {
+    if (!*should_leak_task_) {
+      delete task_;
+    }
+  }
+
+  Task* task_;
+  bool* should_leak_task_;
+  static bool kTaskLeakingDefault;
+};
+
+}  // namespace subtle
+
 }  // namespace base
 
 #endif  // BASE_TASK_H_