Support Closure in ALL the loops!

base/task.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_TASK_H_
 #define BASE_TASK_H_
 #pragma once
 
 #include "base/base_api.h"
 #include "base/debug/alias.h"
@@ skipping 546 matching lines @@
   ~ScopedTaskRunner();
 
   Task* Release();
 
  private:
   Task* task_;
 
   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_