Always use TaskScheduler::InitParams to initialize a TaskScheduler.

base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc

 // Copyright 2017 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_single_thread_task_runner_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/atomic_flag.h"
 #include "base/synchronization/lock.h"
@@ skipping 14 matching lines @@
 #include <objbase.h>
 
 #include "base/win/current_module.h"
 #endif  // defined(OS_WIN)
 
 namespace base {
 namespace internal {
 
 namespace {
 
-enum WorkerPoolType : size_t {
-  BACKGROUND_WORKER_POOL = 0,
-  FOREGROUND_WORKER_POOL,
-};
-
-static size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) {
-  return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL
-                                                       : FOREGROUND_WORKER_POOL;
-}
-
-std::vector<SchedulerWorkerPoolParams> GetParamsVector() {
-  using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy;
-
-  std::vector<SchedulerWorkerPoolParams> params_vector;
-
-  DCHECK_EQ(BACKGROUND_WORKER_POOL, params_vector.size());
-  params_vector.emplace_back("Background", ThreadPriority::BACKGROUND,
-                             StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
-
-  DCHECK_EQ(FOREGROUND_WORKER_POOL, params_vector.size());
-  params_vector.emplace_back("Foreground", ThreadPriority::NORMAL,
-                             StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
-
-  return params_vector;
-}
-
 class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test {
  public:
   TaskSchedulerSingleThreadTaskRunnerManagerTest()
       : service_thread_("TaskSchedulerServiceThread") {}
 
   void SetUp() override {
     service_thread_.Start();
-
     delayed_task_manager_ =
         MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
     single_thread_task_runner_manager_ =
         MakeUnique<SchedulerSingleThreadTaskRunnerManager>(
-            GetParamsVector(), Bind(&GetThreadPoolIndexForTraits),
             &task_tracker_, delayed_task_manager_.get());
     StartSingleThreadTaskRunnerManagerFromSetUp();
   }
 
   void TearDown() override {
     TearDownSingleThreadTaskRunnerManager();
     delayed_task_manager_.reset();
     service_thread_.Stop();
   }
 
@@ skipping 31 matching lines @@
 void ShouldNotRun() {
   ADD_FAILURE() << "Ran a task that shouldn't run.";
 }
 
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
+              "A", ThreadPriority::NORMAL,
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
+              "B", ThreadPriority::NORMAL,
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
 
   PlatformThreadRef thread_ref_1;
   task_runner_1->PostTask(FROM_HERE,
                           BindOnce(&CaptureThreadRef, &thread_ref_1));
   PlatformThreadRef thread_ref_2;
   task_runner_2->PostTask(FROM_HERE,
                           BindOnce(&CaptureThreadRef, &thread_ref_2));
 
   task_tracker_.Shutdown();
 
   ASSERT_FALSE(thread_ref_1.is_null());
   ASSERT_FALSE(thread_ref_2.is_null());
   EXPECT_NE(thread_ref_1, thread_ref_2);
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) {
   // Why are events used here instead of the task tracker?
   // Shutting down can cause priorities to get raised. This means we have to use
   // events to determine when a task is run.
   scoped_refptr<SingleThreadTaskRunner> task_runner_background =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
+              "Background", ThreadPriority::BACKGROUND,
               TaskTraits().WithPriority(TaskPriority::BACKGROUND));
-  scoped_refptr<SingleThreadTaskRunner> task_runner_user_visible =
+  scoped_refptr<SingleThreadTaskRunner> task_runner_normal =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
+              "Normal", ThreadPriority::NORMAL,
               TaskTraits().WithPriority(TaskPriority::USER_VISIBLE));
-  scoped_refptr<SingleThreadTaskRunner> task_runner_user_blocking =
-      single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              TaskTraits()
-                  .WithPriority(TaskPriority::USER_BLOCKING)
-                  .WithShutdownBehavior(TaskShutdownBehavior::BLOCK_SHUTDOWN));
 
   ThreadPriority thread_priority_background;
   task_runner_background->PostTask(
       FROM_HERE, BindOnce(&CaptureThreadPriority, &thread_priority_background));
   WaitableEvent waitable_event_background(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner_background->PostTask(
       FROM_HERE,
       BindOnce(&WaitableEvent::Signal, Unretained(&waitable_event_background)));
 
-  ThreadPriority thread_priority_user_visible;
-  task_runner_user_visible->PostTask(
-      FROM_HERE,
-      BindOnce(&CaptureThreadPriority, &thread_priority_user_visible));
-  WaitableEvent waitable_event_user_visible(
+  ThreadPriority thread_priority_normal;
+  task_runner_normal->PostTask(
+      FROM_HERE, BindOnce(&CaptureThreadPriority, &thread_priority_normal));
+  WaitableEvent waitable_event_normal(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
-  task_runner_user_visible->PostTask(
-      FROM_HERE, BindOnce(&WaitableEvent::Signal,
-                          Unretained(&waitable_event_user_visible)));
-
-  ThreadPriority thread_priority_user_blocking;
-  task_runner_user_blocking->PostTask(
+  task_runner_normal->PostTask(
       FROM_HERE,
-      BindOnce(&CaptureThreadPriority, &thread_priority_user_blocking));
-  WaitableEvent waitable_event_user_blocking(
-      WaitableEvent::ResetPolicy::MANUAL,
-      WaitableEvent::InitialState::NOT_SIGNALED);
-  task_runner_user_blocking->PostTask(
-      FROM_HERE, BindOnce(&WaitableEvent::Signal,
-                          Unretained(&waitable_event_user_blocking)));
+      BindOnce(&WaitableEvent::Signal, Unretained(&waitable_event_normal)));
 
   waitable_event_background.Wait();
-  waitable_event_user_visible.Wait();
-  waitable_event_user_blocking.Wait();
+  waitable_event_normal.Wait();
 
   if (Lock::HandlesMultipleThreadPriorities())
     EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background);
   else
     EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background);
-  EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_visible);
-  EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_blocking);
+  EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_normal);
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) {
   auto task_runner = single_thread_task_runner_manager_
-                         ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
+                         ->CreateSingleThreadTaskRunnerWithTraits(
+                             "A", ThreadPriority::NORMAL, TaskTraits());
   task_tracker_.Shutdown();
   EXPECT_FALSE(task_runner->PostTask(FROM_HERE, BindOnce(&ShouldNotRun)));
 }
 
 // Verify that a Task runs shortly after its delay expires.
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) {
   TimeTicks start_time = TimeTicks::Now();
 
   // Post a task with a short delay.
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   auto task_runner = single_thread_task_runner_manager_
-                         ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
+                         ->CreateSingleThreadTaskRunnerWithTraits(
+                             "A", ThreadPriority::NORMAL, TaskTraits());
   EXPECT_TRUE(task_runner->PostDelayedTask(
       FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_ran)),
       TestTimeouts::tiny_timeout()));
 
   // Wait until the task runs.
   task_ran.Wait();
 
   // Expect the task to run after its delay expires, but not more than 250 ms
   // after that.
   const TimeDelta actual_delay = TimeTicks::Now() - start_time;
   EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout());
   EXPECT_LT(actual_delay,
             TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout());
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest,
        RunsTasksOnCurrentThread) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
+              "A", ThreadPriority::NORMAL,
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
+              "B", ThreadPriority::NORMAL,
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
 
   EXPECT_FALSE(task_runner_1->RunsTasksOnCurrentThread());
   EXPECT_FALSE(task_runner_2->RunsTasksOnCurrentThread());
 
   task_runner_1->PostTask(
       FROM_HERE, BindOnce(
                      [](scoped_refptr<SingleThreadTaskRunner> task_runner_1,
                         scoped_refptr<SingleThreadTaskRunner> task_runner_2) {
@@ skipping 63 matching lines @@
   // Exercises the codepath where the workers are unavailable for unregistration
   // because of a Join call.
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
                               WaitableEvent::InitialState::NOT_SIGNALED);
 
   {
     auto task_runner = single_thread_task_runner_manager_
                            ->CreateSingleThreadTaskRunnerWithTraits(
+                               "A", ThreadPriority::NORMAL,
                                TaskTraits().WithBaseSyncPrimitives());
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE,
         BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE, BindOnce(&WaitableEvent::Wait, Unretained(&task_blocking))));
   }
 
   task_running.Wait();
   CallJoinFromDifferentThread join_from_different_thread(
       single_thread_task_runner_manager_.get());
   join_from_different_thread.Start();
   join_from_different_thread.WaitForRunToStart();
   task_blocking.Signal();
   join_from_different_thread.Join();
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest,
        ConcurrentJoinExtraSkippedTask) {
   // Tests to make sure that tasks are properly cleaned up at Join, allowing
   // SingleThreadTaskRunners to unregister themselves.
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
                               WaitableEvent::InitialState::NOT_SIGNALED);
 
   {
     auto task_runner = single_thread_task_runner_manager_
                            ->CreateSingleThreadTaskRunnerWithTraits(
+                               "A", ThreadPriority::NORMAL,
                                TaskTraits().WithBaseSyncPrimitives());
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE,
         BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE, BindOnce(&WaitableEvent::Wait, Unretained(&task_blocking))));
     EXPECT_TRUE(task_runner->PostTask(FROM_HERE, BindOnce(&DoNothing)));
   }
 
   task_running.Wait();
   CallJoinFromDifferentThread join_from_different_thread(
       single_thread_task_runner_manager_.get());
   join_from_different_thread.Start();
   join_from_different_thread.WaitForRunToStart();
   task_blocking.Signal();
   join_from_different_thread.Join();
 }
 
 #if defined(OS_WIN)
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, COMSTAInitialized) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
+          "A", ThreadPriority::NORMAL,
           TaskTraits().WithShutdownBehavior(
               TaskShutdownBehavior::BLOCK_SHUTDOWN));
 
   com_task_runner->PostTask(
-      FROM_HERE, Bind([]() {
+      FROM_HERE, BindOnce([]() {
         HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
         if (SUCCEEDED(hr)) {
           ADD_FAILURE() << "COM STA was not initialized on this thread";
           CoUninitialize();
         }
       }));
 
   task_tracker_.Shutdown();
 }
 
@@ skipping 38 matching lines @@
   bool register_class_succeeded_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTestWin);
 };
 
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTestWin, PumpsMessages) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
+          "A", ThreadPriority::NORMAL,
           TaskTraits().WithShutdownBehavior(
               TaskShutdownBehavior::BLOCK_SHUTDOWN));
   HWND hwnd = nullptr;
   // HWNDs process messages on the thread that created them, so we have to
   // create them within the context of the task runner to properly simulate a
   // COM callback.
   com_task_runner->PostTask(
       FROM_HERE,
-      Bind([](TaskSchedulerSingleThreadTaskRunnerManagerTestWin* test_harness,
-              HWND* hwnd) { *hwnd = test_harness->CreateTestWindow(); },
-           Unretained(this), &hwnd));
+      BindOnce(
+          [](TaskSchedulerSingleThreadTaskRunnerManagerTestWin* test_harness,
+             HWND* hwnd) { *hwnd = test_harness->CreateTestWindow(); },
+          Unretained(this), &hwnd));
 
   task_tracker_.Flush();
 
   ASSERT_NE(hwnd, nullptr);
   // If the message pump isn't running, we will hang here. This simulates how
   // COM would receive a callback with its own message HWND.
   SendMessage(hwnd, WM_USER, 0, 0);
 
   com_task_runner->PostTask(
-      FROM_HERE, Bind([](HWND hwnd) { ::DestroyWindow(hwnd); }, hwnd));
+      FROM_HERE, BindOnce([](HWND hwnd) { ::DestroyWindow(hwnd); }, hwnd));
 
   task_tracker_.Shutdown();
 }
 
 #endif  // defined(OS_WIN)
 
 namespace {
 
 class TaskSchedulerSingleThreadTaskRunnerManagerStartTest
     : public TaskSchedulerSingleThreadTaskRunnerManagerTest {
@@ skipping 10 matching lines @@
 
 }  // namespace
 
 // Verify that a task posted before Start() doesn't run until Start() is called.
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerStartTest,
        PostTaskBeforeStart) {
   AtomicFlag manager_started;
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   single_thread_task_runner_manager_
-      ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits())
+      ->CreateSingleThreadTaskRunnerWithTraits("A", ThreadPriority::NORMAL,
+                                               TaskTraits())
       ->PostTask(
           FROM_HERE,
-          Bind(
+          BindOnce(
               [](WaitableEvent* task_running, AtomicFlag* manager_started) {
                 task_running->Signal();
 
                 // The task should not run before Start().
                 EXPECT_TRUE(manager_started->IsSet());
               },
               Unretained(&task_running), Unretained(&manager_started)));
 
   // Wait a little bit to make sure that the task isn't scheduled before start.
   // Note: This test won't catch a case where the task is scheduled between
   // setting |manager_started| and calling Start(). However, we expect the test
   // to be flaky if the tested code allows that to happen.
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   manager_started.Set();
   single_thread_task_runner_manager_->Start();
 
   // This should not hang if the task is scheduled after Start().
   task_running.Wait();
 }
 
 }  // namespace internal
 }  // namespace base