Support Closure in ALL the loops!

base/message_loop.cc

 // 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.
 
 #include "base/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 67 matching lines @@
 
   // A few events we handle (kindred to messages), and used to profile actions.
   VALUE_TO_NUMBER_AND_NAME(kTaskRunEvent)
   VALUE_TO_NUMBER_AND_NAME(kTimerEvent)
 
   {-1, NULL}  // The list must be null terminated, per API to histogram.
 };
 
 bool enable_histogrammer_ = false;
 
-// TODO(ajwong): This is one use case for having a Owned() tag that behaves
-// like a "Unique" pointer.  If we had that, and Tasks were always safe to
-// delete on MessageLoop shutdown, this class could just be a function.
-class TaskClosureAdapter : public base::RefCounted<TaskClosureAdapter> {
- public:
-  // |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::RefCounted<TaskClosureAdapter>;
-
-  ~TaskClosureAdapter() {
-    if (!*should_leak_task_) {
-      delete task_;
-    }
-  }
-
-  Task* task_;
-  bool* should_leak_task_;
-};
-
 }  // namespace
 
 //------------------------------------------------------------------------------
 
 #if defined(OS_WIN)
 
 // Upon a SEH exception in this thread, it restores the original unhandled
 // exception filter.
 static int SEHFilter(LPTOP_LEVEL_EXCEPTION_FILTER old_filter) {
   ::SetUnhandledExceptionFilter(old_filter);
@@ skipping 132 matching lines @@
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::PostTask(
     const tracked_objects::Location& from_here, Task* task) {
   CHECK(task);
   PendingTask pending_task(
-      base::Bind(&TaskClosureAdapter::Run,
-                 new TaskClosureAdapter(task, &should_leak_tasks_)),
+      base::Bind(
+          &base::subtle::TaskClosureAdapter::Run,
+          new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(0), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
   CHECK(task);
   PendingTask pending_task(
-      base::Bind(&TaskClosureAdapter::Run,
-                 new TaskClosureAdapter(task, &should_leak_tasks_)),
+      base::Bind(
+          &base::subtle::TaskClosureAdapter::Run,
+          new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(delay_ms), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here, Task* task) {
   CHECK(task);
   PendingTask pending_task(
-      base::Bind(&TaskClosureAdapter::Run,
-                 new TaskClosureAdapter(task, &should_leak_tasks_)),
+      base::Bind(
+          &base::subtle::TaskClosureAdapter::Run,
+          new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(0), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
   CHECK(task);
   PendingTask pending_task(
-      base::Bind(&TaskClosureAdapter::Run,
-                 new TaskClosureAdapter(task, &should_leak_tasks_)),
+      base::Bind(
+          &base::subtle::TaskClosureAdapter::Run,
+          new base::subtle::TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(delay_ms), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostTask(
     const tracked_objects::Location& from_here, const base::Closure& task) {
   CHECK(!task.is_null());
   PendingTask pending_task(task, from_here, CalculateDelayedRuntime(0), true);
   AddToIncomingQueue(&pending_task);
@@ skipping 160 matching lines @@
   base::debug::Alias(&program_counter);
 
   HistogramEvent(kTaskRunEvent);
   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
                     WillProcessTask(pending_task.time_posted));
   pending_task.task.Run();
   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
                     DidProcessTask(pending_task.time_posted));
 
 #if defined(TRACK_ALL_TASK_OBJECTS)
-  if (tracked_objects::ThreadData::IsActive() && pending_task.post_births) {
-    tracked_objects::ThreadData::current()->TallyADeath(
-        *pending_task.post_births,
-        TimeTicks::Now() - pending_task.time_posted);
-  }
+  tracked_objects::ThreadData::TallyADeathIfActive(
+      pending_task.post_births,
+      TimeTicks::Now() - pending_task.time_posted);
 #endif  // defined(TRACK_ALL_TASK_OBJECTS)
 
   nestable_tasks_allowed_ = true;
 }
 
 bool MessageLoop::DeferOrRunPendingTask(
     const PendingTask& pending_task) {
   if (pending_task.nestable || state_->run_depth == 1) {
     RunTask(pending_task);
     // Show that we ran a task (Note: a new one might arrive as a
@@ skipping 269 matching lines @@
     const tracked_objects::Location& posted_from,
     TimeTicks delayed_run_time,
     bool nestable)
     : task(task),
       time_posted(TimeTicks::Now()),
       delayed_run_time(delayed_run_time),
       sequence_num(0),
       nestable(nestable),
       birth_program_counter(posted_from.program_counter()) {
 #if defined(TRACK_ALL_TASK_OBJECTS)
-  post_births = NULL;
-  if (tracked_objects::ThreadData::IsActive()) {
-    tracked_objects::ThreadData* current_thread_data =
-        tracked_objects::ThreadData::current();
-    if (current_thread_data) {
-      post_births = current_thread_data->TallyABirth(posted_from);
-    }
-  }
+  post_births = tracked_objects::ThreadData::TallyABirthIfActive(posted_from);
 #endif  // defined(TRACK_ALL_TASK_OBJECTS)
 }
 
 MessageLoop::PendingTask::~PendingTask() {
 }
 
 bool MessageLoop::PendingTask::operator<(const PendingTask& other) const {
   // Since the top of a priority queue is defined as the "greatest" element, we
   // need to invert the comparison here.  We want the smaller time to be at the
   // top of the heap.
@@ skipping 56 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif