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 04117f213eda428e557cfd733693c38df0f65dc5..00ac91f922261a51b0fee496ff6f32fed6819025 100644
--- a/base/task_scheduler/scheduler_worker_thread.cc
+++ b/base/task_scheduler/scheduler_worker_thread.cc
@@ -31,14 +31,24 @@ class SchedulerSingleThreadTaskRunner : public SingleThreadTaskRunner {
   // Constructs a SchedulerSingleThreadTaskRunner which can be used to post
   // tasks so long as |executor| is alive.
   // TODO(robliao): Find a concrete way to manage |executor|'s memory.
-  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,
@@ -64,7 +74,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;
@@ -74,6 +87,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);
 };
 
@@ -103,7 +120,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() {
@@ -152,6 +174,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);