TaskScheduler [12] Support SINGLE_THREADED in SchedulerThreadPool DO NOT SUBMIT

base/task_scheduler/scheduler_worker_thread.cc

Index: base/task_scheduler/scheduler_worker_thread.cc
diff --git a/base/task_scheduler/scheduler_worker_thread.cc b/base/task_scheduler/scheduler_worker_thread.cc
index 3565bd5e6b9f816cb1cf1d33074aea606e2255e0..54169499c2e173927495e0742328d96b928e5788 100644
--- a/base/task_scheduler/scheduler_worker_thread.cc
+++ b/base/task_scheduler/scheduler_worker_thread.cc
@@ -28,14 +28,24 @@ LazyInstance<ThreadLocalPointer<const SchedulerTaskExecutor>>::Leaky
 // A task runner that runs tasks on a single SchedulerWorkerThread.
 class SchedulerSingleThreadTaskRunner : public SingleThreadTaskRunner {
  public:
-  SchedulerSingleThreadTaskRunner(const TaskTraits& traits,
-                                  SchedulerTaskExecutor* executor,
-                                  TaskTracker* task_tracker,
-                                  DelayedTaskManager* delayed_task_manager)
+  SchedulerSingleThreadTaskRunner(
+      const TaskTraits& traits,
+      SchedulerTaskExecutor* executor,
+      TaskTracker* task_tracker,
+      DelayedTaskManager* delayed_task_manager,
+      base::subtle::Atomic32* num_single_thread_task_runners)
       : traits_(traits),
         executor_(executor),
         task_tracker_(task_tracker),
-        delayed_task_manager_(delayed_task_manager) {}
+        delayed_task_manager_(delayed_task_manager),
+        num_single_thread_task_runners_(num_single_thread_task_runners) {
+    DCHECK(executor_);
+    DCHECK(task_tracker_);
+    DCHECK(delayed_task_manager_);
+    DCHECK(num_single_thread_task_runners_);
+
+    base::subtle::NoBarrier_AtomicIncrement(num_single_thread_task_runners_, 1);
+  }
 
   // SingleThreadTaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
@@ -58,7 +68,10 @@ class SchedulerSingleThreadTaskRunner : public SingleThreadTaskRunner {
   }
 
  private:
-  ~SchedulerSingleThreadTaskRunner() override = default;
+  ~SchedulerSingleThreadTaskRunner() override {
+    base::subtle::NoBarrier_AtomicIncrement(num_single_thread_task_runners_,
+                                            -1);
+  }
 
   // Sequence for all Tasks posted through this TaskRunner.
   const scoped_refptr<Sequence> sequence_ = new Sequence;
@@ -68,6 +81,10 @@ class SchedulerSingleThreadTaskRunner : public SingleThreadTaskRunner {
   TaskTracker* const task_tracker_;
   DelayedTaskManager* const delayed_task_manager_;
 
+  // Number of single-thread TaskRunners associated with |executor_|.
+  // Incremented by the constructor and decremented by the destructor.
+  base::subtle::Atomic32* const num_single_thread_task_runners_;
+
   DISALLOW_COPY_AND_ASSIGN(SchedulerSingleThreadTaskRunner);
 };
 
@@ -97,7 +114,12 @@ SchedulerWorkerThread::~SchedulerWorkerThread() {
 scoped_refptr<SingleThreadTaskRunner>
 SchedulerWorkerThread::CreateTaskRunnerWithTraits(const TaskTraits& traits) {
   return make_scoped_refptr(new SchedulerSingleThreadTaskRunner(
-      traits, this, task_tracker_, delayed_task_manager_));
+      traits, this, task_tracker_, delayed_task_manager_,
+      &num_single_thread_task_runners_));
+}
+
+size_t SchedulerWorkerThread::GetNumSingleThreadTaskRunners() const {
+  return base::subtle::NoBarrier_Load(&num_single_thread_task_runners_);
 }
 
 void SchedulerWorkerThread::WakeUp() {
@@ -144,6 +166,8 @@ SchedulerWorkerThread::SchedulerWorkerThread(
   DCHECK(delayed_task_manager_);
   DCHECK(predecessor_priority_queue);
 
+  base::subtle::NoBarrier_Store(&num_single_thread_task_runners_, 0);
+
   const size_t kDefaultStackSize = 0;
   PlatformThread::CreateWithPriority(kDefaultStackSize, this, &thread_handle_,
                                      thread_priority);