TaskScheduler [8] SEQUENCED TaskRunners in SchedulerThreadPool.

base/task_scheduler/scheduler_thread_pool.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/scheduler_thread_pool.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/sequenced_task_runner.h"
 #include "base/task_scheduler/utils.h"
 #include "base/threading/thread_local.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 // Shared PriorityQueue of a thread's SchedulerThreadPool. Not set for threads
 // that don't belong to a SchedulerThreadPool.
@@ skipping 32 matching lines @@
  private:
   ~SchedulerParallelTaskRunner() override = default;
 
   const TaskTraits traits_;
   PriorityQueue* const priority_queue_;
   TaskTracker* const task_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerParallelTaskRunner);
 };
 
+// A task runner that runs tasks with the SEQUENCED ExecutionMode.
+class SchedulerSequencedTaskRunner : public SequencedTaskRunner {
+ public:
+  SchedulerSequencedTaskRunner(const TaskTraits& traits,
+                               PriorityQueue* priority_queue,
+                               TaskTracker* task_tracker)
+      : traits_(traits),
+        priority_queue_(priority_queue),
+        task_tracker_(task_tracker) {}
+
+  // SequencedTaskRunner:
+  bool PostDelayedTask(const tracked_objects::Location& from_here,
+                       const Closure& closure,
+                       TimeDelta delay) override {
+    // TODO(fdoray): Support delayed tasks.
+    DCHECK(delay.is_zero());
+
+    return PostTaskHelper(WrapUnique(new Task(from_here, closure, traits_)),
+                          sequence_, priority_queue_, task_tracker_);
+  }
+
+  bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
+                                  const Closure& closure,
+                                  base::TimeDelta delay) override {
+    // Tasks are never nested within the task scheduler.
+    return PostDelayedTask(from_here, closure, delay);
+  }
+
+  bool RunsTasksOnCurrentThread() const override {
+    return tls_current_shared_priority_queue.Get().Get() == priority_queue_;
+  }
+
+ private:
+  ~SchedulerSequencedTaskRunner() override = default;
+
+  // Sequence in which all Tasks posted through this TaskRunner are inserted.
+  const scoped_refptr<Sequence> sequence_ = new Sequence;
+
+  const TaskTraits traits_;
+  PriorityQueue* const priority_queue_;
+  TaskTracker* const task_tracker_;
+
+  DISALLOW_COPY_AND_ASSIGN(SchedulerSequencedTaskRunner);
+};
+
 }  // namespace
 
 std::unique_ptr<SchedulerThreadPool> SchedulerThreadPool::CreateThreadPool(
     ThreadPriority thread_priority,
     size_t max_threads,
     const RanTaskFromSequenceCallback& ran_task_from_sequence_callback,
     TaskTracker* task_tracker) {
   std::unique_ptr<SchedulerThreadPool> thread_pool(
       new SchedulerThreadPool(ran_task_from_sequence_callback, task_tracker));
   thread_pool->Initialize(thread_priority, max_threads);
   if (thread_pool->worker_threads_.empty())
     return nullptr;
   return thread_pool;
 }
 
 SchedulerThreadPool::~SchedulerThreadPool() {
   AutoSchedulerLock auto_lock(join_for_testing_returned_lock_);
   DCHECK(join_for_testing_returned_ || worker_threads_.empty());
 }
 
 scoped_refptr<TaskRunner> SchedulerThreadPool::CreateTaskRunnerWithTraits(
     const TaskTraits& traits,
     ExecutionMode execution_mode) {
   switch (execution_mode) {
     case ExecutionMode::PARALLEL:
       return make_scoped_refptr(new SchedulerParallelTaskRunner(
           traits, &shared_priority_queue_, task_tracker_));
 
     case ExecutionMode::SEQUENCED:
+      return make_scoped_refptr(new SchedulerSequencedTaskRunner(
+          traits, &shared_priority_queue_, task_tracker_));
+
     case ExecutionMode::SINGLE_THREADED:
-      // TODO(fdoray): Support SEQUENCED and SINGLE_THREADED TaskRunners.
+      // TODO(fdoray): Support SINGLE_THREADED TaskRunners.
       NOTREACHED();
       return nullptr;
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 void SchedulerThreadPool::InsertSequenceAfterTaskRan(
     scoped_refptr<Sequence> sequence,
@@ skipping 120 matching lines @@
   return sequence_and_sort_key.sequence;
 }
 
 void SchedulerThreadPool::RanTaskFromSequence(
     scoped_refptr<Sequence> sequence) {
   ran_task_from_sequence_callback_.Run(std::move(sequence));
 }
 
 }  // namespace internal
 }  // namespace base