TaskScheduler [11] Support ExecutionMode::SINGLE_THREADED.

base/task_scheduler/delayed_task_manager.cc

 // Copyright 2016 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/task_scheduler/delayed_task_manager.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/task_scheduler/scheduler_thread_pool_interface.h"
 
 namespace base {
 namespace internal {
 
 struct DelayedTaskManager::DelayedTask {
   DelayedTask(std::unique_ptr<Task> task,
               scoped_refptr<Sequence> sequence,
+              SchedulerWorkerThread* worker_thread,
               SchedulerThreadPoolInterface* thread_pool,
               uint64_t index)
       : task(std::move(task)),
         sequence(std::move(sequence)),
+        worker_thread(worker_thread),
         thread_pool(thread_pool),
         index(index) {}
 
   DelayedTask(DelayedTask&& other) = default;
 
   ~DelayedTask() = default;
 
   DelayedTask& operator=(DelayedTask&& other) = default;
 
-  // |task| will be posted to |thread_pool| as part of |sequence| when it
-  // becomes ripe for execution.
+  // |task| will be posted to |thread_pool| with |sequence| and |worker_thread|
+  // when it becomes ripe for execution.
   std::unique_ptr<Task> task;
   scoped_refptr<Sequence> sequence;
+  SchedulerWorkerThread* worker_thread;
   SchedulerThreadPoolInterface* thread_pool;
 
   // Ensures that tasks that have the same |delayed_run_time| are sorted
   // according to the order in which they were added to the DelayedTaskManager.
   uint64_t index;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DelayedTask);
 };
 
 DelayedTaskManager::DelayedTaskManager(
     const Closure& on_delayed_run_time_updated)
     : on_delayed_run_time_updated_(on_delayed_run_time_updated) {
   DCHECK(!on_delayed_run_time_updated_.is_null());
 }
 
 DelayedTaskManager::~DelayedTaskManager() = default;
 
 void DelayedTaskManager::AddDelayedTask(
     std::unique_ptr<Task> task,
     scoped_refptr<Sequence> sequence,
+    SchedulerWorkerThread* worker_thread,
     SchedulerThreadPoolInterface* thread_pool) {
   DCHECK(task);
   DCHECK(sequence);
   DCHECK(thread_pool);
 
   const TimeTicks new_task_delayed_run_time = task->delayed_run_time;
   TimeTicks current_delayed_run_time;
 
   {
     AutoSchedulerLock auto_lock(lock_);
 
     if (!delayed_tasks_.empty())
       current_delayed_run_time = delayed_tasks_.top().task->delayed_run_time;
 
-    delayed_tasks_.emplace(std::move(task), std::move(sequence), thread_pool,
-                           ++delayed_task_index_);
+    delayed_tasks_.emplace(std::move(task), std::move(sequence), worker_thread,
+                           thread_pool, ++delayed_task_index_);
   }
 
   if (current_delayed_run_time.is_null() ||
       new_task_delayed_run_time < current_delayed_run_time) {
     on_delayed_run_time_updated_.Run();
   }
 }
 
 void DelayedTaskManager::PostReadyTasks() {
   const TimeTicks now = Now();
@@ skipping 12 matching lines @@
       // for minor debug-check implications.
       ready_tasks.push_back(
           std::move(const_cast<DelayedTask&>(delayed_tasks_.top())));
       delayed_tasks_.pop();
     }
   }
 
   // Post delayed tasks that are ready for execution.
   for (auto& delayed_task : ready_tasks) {
     delayed_task.thread_pool->PostTaskWithSequenceNow(
-        std::move(delayed_task.task), std::move(delayed_task.sequence));
+        std::move(delayed_task.task), std::move(delayed_task.sequence),
+        delayed_task.worker_thread);
   }
 }
 
 TimeTicks DelayedTaskManager::GetDelayedRunTime() const {
   AutoSchedulerLock auto_lock(lock_);
 
   if (delayed_tasks_.empty())
     return TimeTicks();
 
   return delayed_tasks_.top().task->delayed_run_time;
@@ skipping 25 matching lines @@
     return false;
   return left.index > right.index;
 }
 
 TimeTicks DelayedTaskManager::Now() const {
   return TimeTicks::Now();
 }
 
 }  // namespace internal
 }  // namespace base