bool IncomingTaskQueue::AddToIncomingQueue(

    const tracked_objects::Location& from_here,

    const Closure& task,

    TimeDelta delay,

    bool nestable) {

  AutoLock locked(incoming_queue_lock_);

  PendingTask pending_task(

      from_here, task, CalculateDelayedRuntime(delay), nestable);

  return PostPendingTask(&pending_task);

}

bool IncomingTaskQueue::PostPendingTask(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.

  // This should only be called while the lock is taken.

  incoming_queue_lock_.AssertAcquired();

  if (!message_loop_) {

    pending_task->task.Reset();

    return false;

  }

  // Initialize the sequence number. The sequence number is used for delayed

  // tasks (to faciliate FIFO sorting when two tasks have the same

  // delayed_run_time value) and for identifying the task in about:tracing.

  pending_task->sequence_num = next_sequence_num_++;

  message_loop_->task_annotator()->DidQueueTask("MessageLoop::PostTask",

                                                *pending_task);

  bool was_empty = incoming_queue_.empty();

  incoming_queue_.push(*pending_task);

  pending_task->task.Reset();

  // Wake up the pump.

  message_loop_->ScheduleWork(was_empty);

  return true;

}

void MessageLoop::ScheduleWork(bool was_empty) {

  if (was_empty || AlwaysNotifyPump(type_))

    pump_->ScheduleWork();

}

void MessagePumpDefault::ScheduleWork() {

  // Since this can be called on any thread, we need to ensure that our Run

  // loop wakes up.

  event_.Signal();

}