Move Task Scheduler Single Thread Task Runners to Dedicated Threads

base/task_scheduler/scheduler_worker_pool_impl_unittest.cc

Index: base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
diff --git a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc b/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
index dfaa9c7ff3d3a8071aceda80584d98eb447622d9..d3281cc8bc4d33475054d0f0c5b6135f2796d454 100644
--- a/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
+++ b/base/task_scheduler/scheduler_worker_pool_impl_unittest.cc
@@ -67,7 +67,10 @@ class TaskSchedulerWorkerPoolImplTest
       : service_thread_("TaskSchedulerServiceThread") {}
 
   void SetUp() override {
-    InitializeWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
+    if (GetParam() == test::ExecutionMode::SINGLE_THREADED)
+      InitializeSingleThreadWorkerPool(TimeDelta::Max());
+    else
+      InitializeWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
   }
 
   void TearDown() override {
@@ -93,6 +96,23 @@ class TaskSchedulerWorkerPoolImplTest
     ASSERT_TRUE(worker_pool_);
   }
 
+  void InitializeSingleThreadWorkerPool(TimeDelta suggested_reclaim_time) {
+    ASSERT_FALSE(worker_pool_);
+    ASSERT_FALSE(delayed_task_manager_);
+    service_thread_.Start();
+    delayed_task_manager_ =
+        base::MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
+    worker_pool_ = SchedulerWorkerPoolImpl::CreateSingleThreadWorkerPool(
+        SchedulerWorkerPoolParams("TestWorkerPool", ThreadPriority::NORMAL,
+                                  StandbyThreadPolicy::LAZY, 1,
+                                  suggested_reclaim_time),
+        Bind(&TaskSchedulerWorkerPoolImplTest::
+                 UnregisterSingleThreadWorkerPoolCallback,
+             Unretained(this)),
+        &task_tracker_, delayed_task_manager_.get());
+    ASSERT_TRUE(worker_pool_);
+  }
+
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_;
 
   TaskTracker task_tracker_;
@@ -108,6 +128,11 @@ class TaskSchedulerWorkerPoolImplTest
     worker_pool_->ReEnqueueSequence(std::move(sequence), sort_key);
   }
 
+  void UnregisterSingleThreadWorkerPoolCallback(
+      const SchedulerWorkerPoolImpl* scheduler_worker_pool) {
+    EXPECT_EQ(worker_pool_.get(), scheduler_worker_pool);
+  }
+
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTest);
 };
 
@@ -257,10 +282,14 @@ TEST_P(TaskSchedulerWorkerPoolImplTest, PostTasksWithOneAvailableWorker) {
   // Post blocking tasks to keep all workers busy except one until |event| is
   // signaled. Use different factories so that tasks are added to different
   // sequences and can run simultaneously when the execution mode is SEQUENCED.
+  const size_t num_workers_in_pool =
+      (GetParam() == test::ExecutionMode::SINGLE_THREADED)
+          ? 1
+          : kNumWorkersInWorkerPool;
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   std::vector<std::unique_ptr<test::TestTaskFactory>> blocked_task_factories;
-  for (size_t i = 0; i < (kNumWorkersInWorkerPool - 1); ++i) {
+  for (size_t i = 0; i < (num_workers_in_pool - 1); ++i) {
     blocked_task_factories.push_back(MakeUnique<test::TestTaskFactory>(
         CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam()),
         GetParam()));
@@ -291,10 +320,14 @@ TEST_P(TaskSchedulerWorkerPoolImplTest, Saturate) {
   // tasks/sequences running simultaneously. Use different factories so that the
   // blocking tasks are added to different sequences and can run simultaneously
   // when the execution mode is SEQUENCED.
+  const size_t num_workers_in_pool =
+      (GetParam() == test::ExecutionMode::SINGLE_THREADED)
+          ? 1
+          : kNumWorkersInWorkerPool;
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   std::vector<std::unique_ptr<test::TestTaskFactory>> factories;
-  for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
+  for (size_t i = 0; i < num_workers_in_pool; ++i) {
     factories.push_back(MakeUnique<test::TestTaskFactory>(
         CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam()),
         GetParam()));
@@ -388,9 +421,7 @@ class TaskSchedulerWorkerPoolImplSingleWorkerTest
   TaskSchedulerWorkerPoolImplSingleWorkerTest() = default;
 
  protected:
-  void SetUp() override {
-    InitializeWorkerPool(TimeDelta::Max(), 1);
-  }
+  void SetUp() override { InitializeSingleThreadWorkerPool(TimeDelta::Max()); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplSingleWorkerTest);
@@ -452,7 +483,7 @@ class TaskSchedulerWorkerPoolSingleThreadedTest
 
  protected:
   void SetUp() override {
-    InitializeWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
+    InitializeSingleThreadWorkerPool(kReclaimTimeForDetachTests);
   }
 
   TaskSchedulerWorkerPoolSingleThreadedTest() = default;
@@ -738,13 +769,11 @@ void VerifyThreadIdIsNot(PlatformThreadId thread_id) {
 }  // namespace
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
-  InitializeWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
+  InitializeSingleThreadWorkerPool(kReclaimTimeForDetachTests);
 
   // This test assumes that the TaskRunners aren't assigned to the same worker.
   auto task_runner =
       worker_pool_->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
-  auto other_task_runner =
-      worker_pool_->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
 
   // Post 3 tasks and wait until they run.
   PlatformThreadId thread_id;
@@ -758,7 +787,6 @@ TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
   // - Make sure it isn't on top of the idle stack by waking up another
   //   SchedulerWorker and waiting until it goes back to sleep.
   // - Release |task_runner|.
-  other_task_runner->PostTask(FROM_HERE, Bind(&VerifyThreadIdIsNot, thread_id));
   worker_pool_->WaitForAllWorkersIdleForTesting();
   task_runner = nullptr;