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..b961203864c936e580922d543ac0ed4e4ad6e4e4 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,32 @@ 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_ = CreateSingleThreadWorkerPool(
+        suggested_reclaim_time,
+        Bind(&TaskSchedulerWorkerPoolImplTest::
+                 UnregisterSingleThreadWorkerPoolCallback,
+             Unretained(this)));
+    ASSERT_TRUE(worker_pool_);
+  }
+
+  std::unique_ptr<SchedulerWorkerPoolImpl> CreateSingleThreadWorkerPool(
+      TimeDelta suggested_reclaim_time,
+      SchedulerWorkerPoolImpl::UnregisterSingleThreadWorkerPoolCallback
+          unregister_single_thread_worker_pool_callback) {
+    return SchedulerWorkerPoolImpl::CreateSingleThreadWorkerPool(
+        SchedulerWorkerPoolParams("TestWorkerPool", ThreadPriority::NORMAL,
+                                  StandbyThreadPolicy::LAZY, 1,
+                                  suggested_reclaim_time),
+        unregister_single_thread_worker_pool_callback, &task_tracker_,
+        delayed_task_manager_.get());
+  }
+
   std::unique_ptr<SchedulerWorkerPoolImpl> worker_pool_;
 
   TaskTracker task_tracker_;
@@ -108,6 +137,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 +291,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 +329,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 +430,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 +492,7 @@ class TaskSchedulerWorkerPoolSingleThreadedTest
 
  protected:
   void SetUp() override {
-    InitializeWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
+    InitializeSingleThreadWorkerPool(kReclaimTimeForDetachTests);
   }
 
   TaskSchedulerWorkerPoolSingleThreadedTest() = default;
@@ -738,13 +778,19 @@ void VerifyThreadIdIsNot(PlatformThreadId thread_id) {
 }  // namespace
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
-  InitializeWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
+  InitializeSingleThreadWorkerPool(kReclaimTimeForDetachTests);
+  std::unique_ptr<SchedulerWorkerPoolImpl> other_worker_pool =
+      CreateSingleThreadWorkerPool(
+          kReclaimTimeForDetachTests,
+          base::Bind(
+              [](const SchedulerWorkerPoolImpl* scheduler_worker_pool) {}));
 
   // This test assumes that the TaskRunners aren't assigned to the same worker.
   auto task_runner =
       worker_pool_->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
   auto other_task_runner =

[fdoray, 2017/01/27 16:47:35]

|other_task_runner| was used to change the order of workers on the idle stack
and allow the worker associated with |task_runner| to detach. Now that a worker
in single-threaded pool is always allowed to detach even when it's on top of the
idle stack, you don't need |other_task_runner|. 

[robliao, 2017/01/27 21:25:41]

Removed!

-      worker_pool_->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
+      other_worker_pool->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
+  other_worker_pool->DisallowWorkerDetachmentForTesting();
 
   // Post 3 tasks and wait until they run.
   PlatformThreadId thread_id;
@@ -760,6 +806,7 @@ TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
   // - Release |task_runner|.
   other_task_runner->PostTask(FROM_HERE, Bind(&VerifyThreadIdIsNot, thread_id));
   worker_pool_->WaitForAllWorkersIdleForTesting();
+  other_worker_pool->WaitForAllWorkersIdleForTesting();
   task_runner = nullptr;
 
   // Allow the SchedulerWorker that was associated with |task_runner| to detach.
@@ -771,6 +818,7 @@ TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(0));
   EXPECT_EQ(1, histogram->SnapshotSamples()->GetCount(3));
   EXPECT_EQ(0, histogram->SnapshotSamples()->GetCount(10));
+  other_worker_pool->JoinForTesting();
 }
 
 TEST(TaskSchedulerWorkerPoolStandbyPolicyTest, InitLazy) {