TaskScheduler [12] Support SINGLE_THREADED in SchedulerThreadPool DO NOT SUBMIT

base/task_scheduler/scheduler_worker_thread.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_worker_thread.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 13 matching lines @@
 // SchedulerWorkerThread that owns the current thread, if any.
 LazyInstance<ThreadLocalPointer<const SchedulerTaskExecutor>>::Leaky
     tls_current_worker_thread = LAZY_INSTANCE_INITIALIZER;
 
 // A task runner that runs tasks on a single SchedulerWorkerThread.
 class SchedulerSingleThreadTaskRunner : public SingleThreadTaskRunner {
  public:
   // 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,
                        const Closure& closure,
                        TimeDelta delay) override {
     // Post the task as part of |sequence_|.
     return PostTaskToExecutor(
         WrapUnique(
             new Task(from_here, closure, traits_,
                      delay.is_zero() ? TimeTicks() : TimeTicks::Now() + delay)),
         sequence_, executor_, task_tracker_, delayed_task_manager_);
   }
 
   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_worker_thread.Get().Get() == executor_;
   }
 
  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;
 
   const TaskTraits traits_;
   SchedulerTaskExecutor* const executor_;
   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);
 };
 
 }  // namespace
 
 std::unique_ptr<SchedulerWorkerThread>
 SchedulerWorkerThread::CreateSchedulerWorkerThread(
     ThreadPriority thread_priority,
     Delegate* delegate,
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager,
     const PriorityQueue* predecessor_priority_queue) {
   std::unique_ptr<SchedulerWorkerThread> worker_thread(
       new SchedulerWorkerThread(thread_priority, delegate, task_tracker,
                                 delayed_task_manager,
                                 predecessor_priority_queue));
 
   if (worker_thread->thread_handle_.is_null())
     return nullptr;
   return worker_thread;
 }
 
 SchedulerWorkerThread::~SchedulerWorkerThread() {
   DCHECK(ShouldExitForTesting());
 }
 
 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() {
   wake_up_event_.Signal();
 }
 
 void SchedulerWorkerThread::JoinForTesting() {
   {
     AutoSchedulerLock auto_lock(should_exit_for_testing_lock_);
     should_exit_for_testing_ = true;
@@ skipping 28 matching lines @@
     : wake_up_event_(false, false),
       single_threaded_priority_queue_(predecessor_priority_queue),
       delegate_(delegate),
       task_tracker_(task_tracker),
       delayed_task_manager_(delayed_task_manager) {
   DCHECK(delegate_);
   DCHECK(task_tracker_);
   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);
 }
 
 void SchedulerWorkerThread::ThreadMain() {
   delegate_->OnMainEntry();
   tls_current_worker_thread.Get().Set(this);
 
   // A SchedulerWorkerThread starts out sleeping.
@@ skipping 39 matching lines @@
   }
 }
 
 bool SchedulerWorkerThread::ShouldExitForTesting() const {
   AutoSchedulerLock auto_lock(should_exit_for_testing_lock_);
   return should_exit_for_testing_;
 }
 
 }  // namespace internal
 }  // namespace base