base/message_loop/incoming_task_queue.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/message_loop/incoming_task_queue.h"
   6
   7 #include "base/location.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/synchronization/waitable_event.h"
  10 #include "base/time/time.h"
  11
  12 namespace base {
  13 namespace internal {
  14
  15 IncomingTaskQueue::IncomingTaskQueue(MessageLoop* message_loop)
  16     : high_res_task_count_(0),
  17       message_loop_(message_loop),
  18       next_sequence_num_(0) {
  19 }
  20
  21 bool IncomingTaskQueue::AddToIncomingQueue(
  22     const tracked_objects::Location& from_here,
  23     const Closure& task,
  24     TimeDelta delay,
  25     bool nestable) {
  26   AutoLock locked(incoming_queue_lock_);
  27   PendingTask pending_task(
  28       from_here, task, CalculateDelayedRuntime(delay), nestable);
  29 #if defined(OS_WIN)
  30   // We consider the task needs a high resolution timer if the delay is
  31   // more than 0 and less than 32ms. This caps the relative error to
  32   // less than 50% : a 33ms wait can wake at 48ms since the default
  33   // resolution on Windows is between 10 and 15ms.
  34   if (delay > TimeDelta() &&
  35       delay.InMilliseconds() < (2 * Time::kMinLowResolutionThresholdMs)) {
  36     ++high_res_task_count_;
  37     pending_task.is_high_res = true;
  38   }
  39 #endif
  40   return PostPendingTask(&pending_task);
  41 }
  42
  43 bool IncomingTaskQueue::HasHighResolutionTasks() {
  44   AutoLock lock(incoming_queue_lock_);
  45   return high_res_task_count_ > 0;
  46 }
  47
  48 bool IncomingTaskQueue::IsIdleForTesting() {
  49   AutoLock lock(incoming_queue_lock_);
  50   return incoming_queue_.empty();
  51 }
  52
  53 int IncomingTaskQueue::ReloadWorkQueue(TaskQueue* work_queue) {
  54   // Make sure no tasks are lost.
  55   DCHECK(work_queue->empty());
  56
  57   // Acquire all we can from the inter-thread queue with one lock acquisition.
  58   AutoLock lock(incoming_queue_lock_);
  59   if (!incoming_queue_.empty())
  60     incoming_queue_.Swap(work_queue);
  61
  62   // Reset the count of high resolution tasks since our queue is now empty.
  63   int high_res_tasks = high_res_task_count_;
  64   high_res_task_count_ = 0;
  65   return high_res_tasks;
  66 }
  67
  68 void IncomingTaskQueue::WillDestroyCurrentMessageLoop() {
  69   AutoLock lock(incoming_queue_lock_);
  70   message_loop_ = NULL;
  71 }
  72
  73 IncomingTaskQueue::~IncomingTaskQueue() {
  74   // Verify that WillDestroyCurrentMessageLoop() has been called.
  75   DCHECK(!message_loop_);
  76 }
  77
  78 TimeTicks IncomingTaskQueue::CalculateDelayedRuntime(TimeDelta delay) {
  79   TimeTicks delayed_run_time;
  80   if (delay > TimeDelta())
  81     delayed_run_time = TimeTicks::Now() + delay;
  82   else
  83     DCHECK_EQ(delay.InMilliseconds(), 0) << "delay should not be negative";
  84   return delayed_run_time;
  85 }
  86
  87 bool IncomingTaskQueue::PostPendingTask(PendingTask* pending_task) {
  88   // Warning: Don't try to short-circuit, and handle this thread's tasks more
  89   // directly, as it could starve handling of foreign threads.  Put every task
  90   // into this queue.
  91
  92   // This should only be called while the lock is taken.
  93   incoming_queue_lock_.AssertAcquired();
  94
  95   if (!message_loop_) {
  96     pending_task->task.Reset();
  97     return false;
  98   }
  99
 100   // Initialize the sequence number. The sequence number is used for delayed
 101   // tasks (to faciliate FIFO sorting when two tasks have the same
 102   // delayed_run_time value) and for identifying the task in about:tracing.
 103   pending_task->sequence_num = next_sequence_num_++;
 104
 105   message_loop_->task_annotator()->DidQueueTask("MessageLoop::PostTask",
 106                                                 *pending_task);
 107
 108   bool was_empty = incoming_queue_.empty();
 109   incoming_queue_.push(*pending_task);
 110   pending_task->task.Reset();
 111
 112   // Wake up the pump.
 113   message_loop_->ScheduleWork(was_empty);
 114
 115   return true;
 116 }
 117
 118 }  // namespace internal
 119 }  // namespace base