Add support for base::Closure in the MessageLoop.

base/message_loop.cc

 // Copyright (c) 2010 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/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 193 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) {
-  PostTask_Helper(from_here, task, 0, true);
+  task->SetBirthPlace(from_here);
+  PendingTask pending_task(task, CalculateDelayedRuntime(0), true);
+  AddToIncomingQueue(pending_task);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
-  PostTask_Helper(from_here, task, delay_ms, true);
+  task->SetBirthPlace(from_here);
+  PendingTask pending_task(task, CalculateDelayedRuntime(delay_ms), true);
+  AddToIncomingQueue(pending_task);
 }
 
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here, Task* task) {
-  PostTask_Helper(from_here, task, 0, false);
+  task->SetBirthPlace(from_here);
+  PendingTask pending_task(task, CalculateDelayedRuntime(0), false);
+  AddToIncomingQueue(pending_task);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
-  PostTask_Helper(from_here, task, delay_ms, false);
+  task->SetBirthPlace(from_here);
+  PendingTask pending_task(task, CalculateDelayedRuntime(delay_ms), false);
+  AddToIncomingQueue(pending_task);
+}
+
+void MessageLoop::PostClosure(
+    const tracked_objects::Location& from_here, const base::Closure& closure) {
+  // TODO(ajwong): Record |from_here| correctly for Closures.

[willchan no longer on Chromium, 2011/02/09 05:51:48]

IIRC, when we discussed this before, I suggested ripping
tracked_objects::Location out of Task (which actually inherits from some sort of
tracked object thingy) and embedding it in the PendingTask itself. This should
hopefully allow a way to fix the TaskObserver too.

+  PendingTask pending_task(closure, CalculateDelayedRuntime(0), true);
+  AddToIncomingQueue(pending_task);
+}
+
+void MessageLoop::PostDelayedClosure(
+    const tracked_objects::Location& from_here, const base::Closure& closure,
+    int64 delay_ms) {
+  // TODO(ajwong): Record |from_here| correctly for Closures.
+  PendingTask pending_task(closure, CalculateDelayedRuntime(delay_ms), true);
+  AddToIncomingQueue(pending_task);
+}
+
+void MessageLoop::PostNonNestableClosure(
+    const tracked_objects::Location& from_here, const base::Closure& closure) {
+  // TODO(ajwong): Record |from_here| correctly for Closures.
+  PendingTask pending_task(closure, CalculateDelayedRuntime(0), false);
+  AddToIncomingQueue(pending_task);
+}
+
+void MessageLoop::PostNonNestableDelayedClosure(
+    const tracked_objects::Location& from_here, const base::Closure& closure,
+    int64 delay_ms) {
+  // TODO(ajwong): Record |from_here| correctly for Closures.
+  PendingTask pending_task(closure, CalculateDelayedRuntime(delay_ms), false);
+  AddToIncomingQueue(pending_task);
 }
 
 void MessageLoop::Run() {
   AutoRunState save_state(this);
   RunHandler();
 }
 
 void MessageLoop::RunAllPending() {
   AutoRunState save_state(this);
   state_->quit_received = true;  // Means run until we would otherwise block.
@@ skipping 98 matching lines @@
 }
 
 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
   if (state_->run_depth != 1)
     return false;
 
   if (deferred_non_nestable_work_queue_.empty())
     return false;
 
   Task* task = deferred_non_nestable_work_queue_.front().task;
-  deferred_non_nestable_work_queue_.pop();
-
-  RunTask(task);
+  if (task) {
+    deferred_non_nestable_work_queue_.pop();
+    RunTask(task);
+  } else {
+    // Take a copy since we will pop the queue.
+    base::Closure closure = deferred_non_nestable_work_queue_.front().closure;
+    deferred_non_nestable_work_queue_.pop();
+    RunClosure(closure);
+  }
   return true;
 }
 
 void MessageLoop::RunTask(Task* task) {
   DCHECK(nestable_tasks_allowed_);
   // Execute the task and assume the worst: It is probably not reentrant.
   nestable_tasks_allowed_ = false;
 
   HistogramEvent(kTaskRunEvent);
   FOR_EACH_OBSERVER(TaskObserver, task_observers_,
                     WillProcessTask(task));
   task->Run();
   FOR_EACH_OBSERVER(TaskObserver, task_observers_, DidProcessTask(task));
   delete task;
 
   nestable_tasks_allowed_ = true;
 }
 
+void MessageLoop::RunClosure(const base::Closure& closure) {
+  DCHECK(nestable_tasks_allowed_);
+  // Execute the task and assume the worst: It is probably not reentrant.
+  nestable_tasks_allowed_ = false;
+
+  // TODO(ajwong): Figure out how to handle FOR_EACH_OBSERVER.
+  closure.Run();
+
+  nestable_tasks_allowed_ = true;
+}
+
 bool MessageLoop::DeferOrRunPendingTask(const PendingTask& pending_task) {
   if (pending_task.nestable || state_->run_depth == 1) {
-    RunTask(pending_task.task);
-    // Show that we ran a task (Note: a new one might arrive as a
-    // consequence!).
+    if (pending_task.task) {
+      RunTask(pending_task.task);
+      // Show that we ran a task (Note: a new one might arrive as a
+      // consequence!).
+    } else {
+      RunClosure(pending_task.closure);
+    }
     return true;
   }
 
   // We couldn't run the task now because we're in a nested message loop
   // and the task isn't nestable.
   deferred_non_nestable_work_queue_.push(pending_task);
   return false;
 }
 
 void MessageLoop::AddToDelayedWorkQueue(const PendingTask& pending_task) {
@@ skipping 63 matching lines @@
   }
   did_work |= !delayed_work_queue_.empty();
   while (!delayed_work_queue_.empty()) {
     Task* task = delayed_work_queue_.top().task;
     delayed_work_queue_.pop();
     delete task;
   }
   return did_work;
 }
 
-// Possibly called on a background thread!
-void MessageLoop::PostTask_Helper(
-    const tracked_objects::Location& from_here, Task* task, int64 delay_ms,
-    bool nestable) {
-  task->SetBirthPlace(from_here);
-
-  PendingTask pending_task(task, nestable);
-
+base::TimeTicks MessageLoop::CalculateDelayedRuntime(int64 delay_ms) {
+  base::TimeTicks delayed_run_time;
   if (delay_ms > 0) {
-    pending_task.delayed_run_time =
+    delayed_run_time =
         TimeTicks::Now() + TimeDelta::FromMilliseconds(delay_ms);
 
 #if defined(OS_WIN)
     if (high_resolution_timer_expiration_.is_null()) {
       // Windows timers are granular to 15.6ms.  If we only set high-res
       // timers for those under 15.6ms, then a 18ms timer ticks at ~32ms,
       // which as a percentage is pretty inaccurate.  So enable high
       // res timers for any timer which is within 2x of the granularity.
       // This is a tradeoff between accuracy and power management.
       bool needs_high_res_timers =
@@ skipping 11 matching lines @@
 
 #if defined(OS_WIN)
   if (!high_resolution_timer_expiration_.is_null()) {
     if (TimeTicks::Now() > high_resolution_timer_expiration_) {
       base::Time::ActivateHighResolutionTimer(false);
       high_resolution_timer_expiration_ = TimeTicks();
     }
   }
 #endif
 
+  return delayed_run_time;
+}
+
+// Possibly called on a background thread!
+void MessageLoop::AddToIncomingQueue(const PendingTask& pending_task) {
   // Warning: Don't try to short-circuit, and handle this thread's tasks more
   // directly, as it could starve handling of foreign threads.  Put every task
   // into this queue.
 
   scoped_refptr<base::MessagePump> pump;
   {
     base::AutoLock locked(incoming_queue_lock_);
 
     bool was_empty = incoming_queue_.empty();
     incoming_queue_.push(pending_task);
@@ skipping 43 matching lines @@
     if (work_queue_.empty())
       break;
 
     // Execute oldest task.
     do {
       PendingTask pending_task = work_queue_.front();
       work_queue_.pop();
       if (!pending_task.delayed_run_time.is_null()) {
         AddToDelayedWorkQueue(pending_task);
         // If we changed the topmost task, then it is time to re-schedule.
-        if (delayed_work_queue_.top().task == pending_task.task)
+        if ((delayed_work_queue_.top().task == pending_task.task)) {
           pump_->ScheduleDelayedWork(pending_task.delayed_run_time);
+        }
       } else {
         if (DeferOrRunPendingTask(pending_task))
           return true;
       }
     } while (!work_queue_.empty());
   }
 
   // Nothing happened.
   return false;
 }
@@ skipping 129 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif