[base] Migrate to thread_pool.h in base/task

Migrates everything in base/task but post_job.h and lazy_task_runner.h
which will be migrated in their own CLs.

Bug: 1026641
Change-Id: If58acf8dd79ef848a16df210d4a283db10231a98
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1996991
Commit-Queue: Gabriel Charette <gab@chromium.org>
Reviewed-by: Etienne Pierre-Doray <etiennep@chromium.org>
Cr-Commit-Position: refs/heads/master@{#735733}

base/task/common/task_annotator_unittest.cc

@@ -218,9 +218,9 @@ TEST_F(TaskAnnotatorBacktraceIntegrationTest, MultipleThreads) {
   // SingleThreadTaskRunner) to verify that TaskAnnotator can capture backtraces
   // for PostTasks back-and-forth between these.
   auto main_thread_a = ThreadTaskRunnerHandle::Get();
-  auto task_runner_b = CreateSingleThreadTaskRunner({ThreadPool()});
-  auto task_runner_c = CreateSequencedTaskRunner(
-      {ThreadPool(), base::MayBlock(), base::WithBaseSyncPrimitives()});
+  auto task_runner_b = ThreadPool::CreateSingleThreadTaskRunner({});
+  auto task_runner_c = ThreadPool::CreateSequencedTaskRunner(
+      {base::MayBlock(), base::WithBaseSyncPrimitives()});
 
   const Location& location_a0 = FROM_HERE;
   const Location& location_a1 = FROM_HERE;

base/task/sequence_manager/sequence_manager_perftest.cc

@@ -23,6 +23,7 @@
 #include "base/task/sequence_manager/test/test_task_time_observer.h"
 #include "base/task/sequence_manager/thread_controller_with_message_pump_impl.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_impl.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/threading/thread.h"
@@ -207,8 +208,8 @@ class SingleThreadInThreadPoolPerfTestDelegate : public PerfTestDelegate {
   bool MultipleQueuesSupported() const override { return false; }
 
   scoped_refptr<TaskRunner> CreateTaskRunner() override {
-    return CreateSingleThreadTaskRunner(
-        {ThreadPool(), TaskPriority::USER_BLOCKING});
+    return ThreadPool::CreateSingleThreadTaskRunner(
+        {TaskPriority::USER_BLOCKING});
   }
 
   void WaitUntilDone() override {

base/task/thread_pool/pooled_single_thread_task_runner_manager.cc

@@ -364,7 +364,7 @@ class WorkerThreadCOMDelegate : public WorkerThreadDelegate {
 
   bool get_work_first_ = true;
   const scoped_refptr<Sequence> message_pump_sequence_ =
-      MakeRefCounted<Sequence>(TaskTraits{ThreadPool(), MayBlock()},
+      MakeRefCounted<Sequence>(TaskTraits{MayBlock()},
                                nullptr,
                                TaskSourceExecutionMode::kParallel);
   std::unique_ptr<win::ScopedCOMInitializer> scoped_com_initializer_;

base/task/thread_pool/priority_queue_unittest.cc

@@ -57,20 +57,20 @@ class PriorityQueueWithSequencesTest : public testing::Test {
   test::TaskEnvironment task_environment{
       test::TaskEnvironment::TimeSource::MOCK_TIME};
 
-  scoped_refptr<TaskSource> sequence_a = MakeSequenceWithTraitsAndTask(
-      TaskTraits(ThreadPool(), TaskPriority::USER_VISIBLE));
+  scoped_refptr<TaskSource> sequence_a =
+      MakeSequenceWithTraitsAndTask(TaskTraits(TaskPriority::USER_VISIBLE));
   SequenceSortKey sort_key_a = sequence_a->BeginTransaction().GetSortKey();
 
-  scoped_refptr<TaskSource> sequence_b = MakeSequenceWithTraitsAndTask(
-      TaskTraits(ThreadPool(), TaskPriority::USER_BLOCKING));
+  scoped_refptr<TaskSource> sequence_b =
+      MakeSequenceWithTraitsAndTask(TaskTraits(TaskPriority::USER_BLOCKING));
   SequenceSortKey sort_key_b = sequence_b->BeginTransaction().GetSortKey();
 
-  scoped_refptr<TaskSource> sequence_c = MakeSequenceWithTraitsAndTask(
-      TaskTraits(ThreadPool(), TaskPriority::USER_BLOCKING));
+  scoped_refptr<TaskSource> sequence_c =
+      MakeSequenceWithTraitsAndTask(TaskTraits(TaskPriority::USER_BLOCKING));
   SequenceSortKey sort_key_c = sequence_c->BeginTransaction().GetSortKey();
 
-  scoped_refptr<TaskSource> sequence_d = MakeSequenceWithTraitsAndTask(
-      TaskTraits(ThreadPool(), TaskPriority::BEST_EFFORT));
+  scoped_refptr<TaskSource> sequence_d =
+      MakeSequenceWithTraitsAndTask(TaskTraits(TaskPriority::BEST_EFFORT));
   SequenceSortKey sort_key_d = sequence_d->BeginTransaction().GetSortKey();
 
   PriorityQueue pq;

base/task/thread_pool/sequence_unittest.cc

@@ -44,8 +44,8 @@ TEST(ThreadPoolSequenceTest, PushTakeRemove) {
   testing::StrictMock<MockTask> mock_task_d;
   testing::StrictMock<MockTask> mock_task_e;
 
-  scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>(
-      TaskTraits(ThreadPool(), TaskPriority::BEST_EFFORT), nullptr,
+  scoped_refptr<Sequence> sequence =
+      MakeRefCounted<Sequence>(TaskTraits(TaskPriority::BEST_EFFORT), nullptr,
                                TaskSourceExecutionMode::kParallel);
   Sequence::Transaction sequence_transaction(sequence->BeginTransaction());
 
@@ -119,8 +119,8 @@ TEST(ThreadPoolSequenceTest, PushTakeRemove) {
 TEST(ThreadPoolSequenceTest, GetSortKeyBestEffort) {
   // Create a BEST_EFFORT sequence with a task.
   Task best_effort_task(FROM_HERE, DoNothing(), TimeDelta());
-  scoped_refptr<Sequence> best_effort_sequence = MakeRefCounted<Sequence>(
-      TaskTraits(ThreadPool(), TaskPriority::BEST_EFFORT), nullptr,
+  scoped_refptr<Sequence> best_effort_sequence =
+      MakeRefCounted<Sequence>(TaskTraits(TaskPriority::BEST_EFFORT), nullptr,
                                TaskSourceExecutionMode::kParallel);
   Sequence::Transaction best_effort_sequence_transaction(
       best_effort_sequence->BeginTransaction());
@@ -153,8 +153,8 @@ TEST(ThreadPoolSequenceTest, GetSortKeyBestEffort) {
 TEST(ThreadPoolSequenceTest, GetSortKeyForeground) {
   // Create a USER_VISIBLE sequence with a task.
   Task foreground_task(FROM_HERE, DoNothing(), TimeDelta());
-  scoped_refptr<Sequence> foreground_sequence = MakeRefCounted<Sequence>(
-      TaskTraits(ThreadPool(), TaskPriority::USER_VISIBLE), nullptr,
+  scoped_refptr<Sequence> foreground_sequence =
+      MakeRefCounted<Sequence>(TaskTraits(TaskPriority::USER_VISIBLE), nullptr,
                                TaskSourceExecutionMode::kParallel);
   Sequence::Transaction foreground_sequence_transaction(
       foreground_sequence->BeginTransaction());
@@ -186,7 +186,7 @@ TEST(ThreadPoolSequenceTest, GetSortKeyForeground) {
 // didn't return a Task.
 TEST(ThreadPoolSequenceTest, DidProcessTaskWithoutWillRunTask) {
   scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>(
-      TaskTraits(ThreadPool()), nullptr, TaskSourceExecutionMode::kParallel);
+      TaskTraits(), nullptr, TaskSourceExecutionMode::kParallel);
   Sequence::Transaction sequence_transaction(sequence->BeginTransaction());
   sequence_transaction.PushTask(Task(FROM_HERE, DoNothing(), TimeDelta()));
 
@@ -201,7 +201,7 @@ TEST(ThreadPoolSequenceTest, DidProcessTaskWithoutWillRunTask) {
 // slot is empty.
 TEST(ThreadPoolSequenceTest, TakeEmptyFrontSlot) {
   scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>(
-      TaskTraits(ThreadPool()), nullptr, TaskSourceExecutionMode::kParallel);
+      TaskTraits(), nullptr, TaskSourceExecutionMode::kParallel);
   Sequence::Transaction sequence_transaction(sequence->BeginTransaction());
   sequence_transaction.PushTask(Task(FROM_HERE, DoNothing(), TimeDelta()));
 
@@ -221,7 +221,7 @@ TEST(ThreadPoolSequenceTest, TakeEmptyFrontSlot) {
 // Verify that a DCHECK fires if TakeTask() is called on an empty sequence.
 TEST(ThreadPoolSequenceTest, TakeEmptySequence) {
   scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>(
-      TaskTraits(ThreadPool()), nullptr, TaskSourceExecutionMode::kParallel);
+      TaskTraits(), nullptr, TaskSourceExecutionMode::kParallel);
   auto registered_task_source =
       RegisteredTaskSource::CreateForTesting(sequence);
   EXPECT_DCHECK_DEATH({

base/task/thread_pool/service_thread.cc

@@ -9,8 +9,8 @@
 #include "base/debug/alias.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
-#include "base/task/post_task.h"
 #include "base/task/task_traits.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/task_tracker.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 
@@ -87,8 +87,8 @@ void ServiceThread::PerformHeartbeatLatencyReport() const {
   // every set of traits in case PostTask() itself is slow.
   // Bonus: this approach also includes the overhead of BindOnce() in the
   // reported latency.
-  base::PostTask(
-      FROM_HERE, {base::ThreadPool(), profiled_priority},
+  ThreadPool::PostTask(
+      FROM_HERE, {profiled_priority},
       BindOnce(
           &TaskTracker::RecordHeartbeatLatencyAndTasksRunWhileQueuingHistograms,
           Unretained(task_tracker_), profiled_priority, TimeTicks::Now(),

base/task/thread_pool/task_tracker.cc

@@ -492,7 +492,7 @@ RegisteredTaskSource TaskTracker::RunAndPopNextTask(
 
   // Run the next task in |task_source|.
   Optional<Task> task;
-  TaskTraits traits{ThreadPool()};
+  TaskTraits traits;
   {
     auto transaction = task_source->BeginTransaction();
     task = task_is_worker_task ? task_source.TakeTask(&transaction)

base/task/thread_pool/task_tracker_posix_unittest.cc

@@ -57,7 +57,7 @@ TEST_F(ThreadPoolTaskTrackerPosixTest, RunTask) {
       FROM_HERE,
       BindOnce([](bool* did_run) { *did_run = true; }, Unretained(&did_run)),
       TimeDelta());
-  constexpr TaskTraits default_traits = {ThreadPool()};
+  constexpr TaskTraits default_traits;
 
   EXPECT_TRUE(tracker_.WillPostTask(&task, default_traits.shutdown_behavior()));
 
@@ -78,7 +78,7 @@ TEST_F(ThreadPoolTaskTrackerPosixTest, FileDescriptorWatcher) {
             BindOnce(IgnoreResult(&FileDescriptorWatcher::WatchReadable),
                      fds[0], DoNothing()),
             TimeDelta());
-  constexpr TaskTraits default_traits = {ThreadPool()};
+  constexpr TaskTraits default_traits;
 
   EXPECT_TRUE(tracker_.WillPostTask(&task, default_traits.shutdown_behavior()));
 

base/task/thread_pool/test_utils.cc

@@ -109,15 +109,15 @@ scoped_refptr<Sequence> CreateSequenceWithTask(
   return sequence;
 }
 
-scoped_refptr<TaskRunner> CreateTaskRunnerWithExecutionMode(
+scoped_refptr<TaskRunner> CreatePooledTaskRunnerWithExecutionMode(
     TaskSourceExecutionMode execution_mode,
     MockPooledTaskRunnerDelegate* mock_pooled_task_runner_delegate,
     const TaskTraits& traits) {
   switch (execution_mode) {
     case TaskSourceExecutionMode::kParallel:
-      return CreateTaskRunner(traits, mock_pooled_task_runner_delegate);
+      return CreatePooledTaskRunner(traits, mock_pooled_task_runner_delegate);
     case TaskSourceExecutionMode::kSequenced:
-      return CreateSequencedTaskRunner(traits,
+      return CreatePooledSequencedTaskRunner(traits,
                                              mock_pooled_task_runner_delegate);
     case TaskSourceExecutionMode::kJob:
       return CreateJobTaskRunner(traits, mock_pooled_task_runner_delegate);
@@ -129,14 +129,14 @@ scoped_refptr<TaskRunner> CreateTaskRunnerWithExecutionMode(
   return nullptr;
 }
 
-scoped_refptr<TaskRunner> CreateTaskRunner(
+scoped_refptr<TaskRunner> CreatePooledTaskRunner(
     const TaskTraits& traits,
     MockPooledTaskRunnerDelegate* mock_pooled_task_runner_delegate) {
   return MakeRefCounted<PooledParallelTaskRunner>(
       traits, mock_pooled_task_runner_delegate);
 }
 
-scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunner(
+scoped_refptr<SequencedTaskRunner> CreatePooledSequencedTaskRunner(
     const TaskTraits& traits,
     MockPooledTaskRunnerDelegate* mock_pooled_task_runner_delegate) {
   return MakeRefCounted<PooledSequencedTaskRunner>(

base/task/thread_pool/test_utils.h

@@ -136,16 +136,16 @@ scoped_refptr<Sequence> CreateSequenceWithTask(
 // Creates a TaskRunner that posts tasks to the thread group owned by
 // |pooled_task_runner_delegate| with the |execution_mode|.
 // Caveat: this does not support TaskSourceExecutionMode::kSingleThread.
-scoped_refptr<TaskRunner> CreateTaskRunnerWithExecutionMode(
+scoped_refptr<TaskRunner> CreatePooledTaskRunnerWithExecutionMode(
     TaskSourceExecutionMode execution_mode,
     MockPooledTaskRunnerDelegate* mock_pooled_task_runner_delegate,
-    const TaskTraits& traits = {ThreadPool()});
+    const TaskTraits& traits = {});
 
-scoped_refptr<TaskRunner> CreateTaskRunner(
+scoped_refptr<TaskRunner> CreatePooledTaskRunner(
     const TaskTraits& traits,
     MockPooledTaskRunnerDelegate* mock_pooled_task_runner_delegate);
 
-scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunner(
+scoped_refptr<SequencedTaskRunner> CreatePooledSequencedTaskRunner(
     const TaskTraits& traits,
     MockPooledTaskRunnerDelegate* mock_pooled_task_runner_delegate);
 

base/task/thread_pool/thread_group_unittest.cc

@@ -74,7 +74,7 @@ class ThreadPostingTasks : public SimpleThread {
       PostNestedTask post_nested_task)
       : SimpleThread("ThreadPostingTasks"),
         post_nested_task_(post_nested_task),
-        factory_(test::CreateTaskRunnerWithExecutionMode(
+        factory_(test::CreatePooledTaskRunnerWithExecutionMode(
                      execution_mode,
                      mock_pooled_task_runner_delegate_),
                  execution_mode) {}
@@ -207,9 +207,9 @@ class ThreadGroupTestAllExecutionModes
     return std::get<1>(GetParam());
   }
 
-  scoped_refptr<TaskRunner> CreateTaskRunner(
-      const TaskTraits& traits = TaskTraits(ThreadPool())) {
-    return test::CreateTaskRunnerWithExecutionMode(
+  scoped_refptr<TaskRunner> CreatePooledTaskRunner(
+      const TaskTraits& traits = {}) {
+    return test::CreatePooledTaskRunnerWithExecutionMode(
         execution_mode(), &mock_pooled_task_runner_delegate_, traits);
   }
 
@@ -271,7 +271,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, NestedPostTasks) {
 // Verify that a Task can't be posted after shutdown.
 TEST_P(ThreadGroupTestAllExecutionModes, PostTaskAfterShutdown) {
   StartThreadGroup();
-  auto task_runner = CreateTaskRunner();
+  auto task_runner = CreatePooledTaskRunner();
   test::ShutdownTaskTracker(&task_tracker_);
   EXPECT_FALSE(task_runner->PostTask(FROM_HERE, BindOnce(&ShouldNotRun)));
 }
@@ -285,7 +285,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, PostDelayedTask) {
 
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::AUTOMATIC,
                          WaitableEvent::InitialState::NOT_SIGNALED);
-  auto task_runner = CreateTaskRunner();
+  auto task_runner = CreatePooledTaskRunner();
 
   // Wait until the task runner is up and running to make sure the test below is
   // solely timing the delayed task, not bringing up a physical thread.
@@ -318,9 +318,9 @@ TEST_P(ThreadGroupTestAllExecutionModes, PostDelayedTask) {
 // complements it to get full coverage of that method.
 TEST_P(ThreadGroupTestAllExecutionModes, SequencedRunsTasksInCurrentSequence) {
   StartThreadGroup();
-  auto task_runner = CreateTaskRunner();
-  auto sequenced_task_runner = test::CreateSequencedTaskRunner(
-      TaskTraits(ThreadPool()), &mock_pooled_task_runner_delegate_);
+  auto task_runner = CreatePooledTaskRunner();
+  auto sequenced_task_runner = test::CreatePooledSequencedTaskRunner(
+      TaskTraits(), &mock_pooled_task_runner_delegate_);
 
   WaitableEvent task_ran;
   task_runner->PostTask(
@@ -340,7 +340,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, PostBeforeStart) {
   WaitableEvent task_1_running;
   WaitableEvent task_2_running;
 
-  auto task_runner = CreateTaskRunner();
+  auto task_runner = CreatePooledTaskRunner();
   task_runner->PostTask(
       FROM_HERE, BindOnce(&WaitableEvent::Signal, Unretained(&task_1_running)));
   task_runner->PostTask(
@@ -368,7 +368,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, CanRunPolicyBasic) {
   test::TestCanRunPolicyBasic(
       thread_group_.get(),
       [this](TaskPriority priority) {
-        return CreateTaskRunner({ThreadPool(), priority});
+        return CreatePooledTaskRunner({priority});
       },
       &task_tracker_);
 }
@@ -380,8 +380,8 @@ TEST_P(ThreadGroupTest, CanRunPolicyUpdatedBeforeRun) {
   test::TestCanRunPolicyChangedBeforeRun(
       thread_group_.get(),
       [this](TaskPriority priority) {
-        return test::CreateSequencedTaskRunner(
-            {ThreadPool(), priority}, &mock_pooled_task_runner_delegate_);
+        return test::CreatePooledSequencedTaskRunner(
+            {priority}, &mock_pooled_task_runner_delegate_);
       },
       &task_tracker_);
 }
@@ -391,7 +391,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, CanRunPolicyLoad) {
   test::TestCanRunPolicyLoad(
       thread_group_.get(),
       [this](TaskPriority priority) {
-        return CreateTaskRunner({ThreadPool(), priority});
+        return CreatePooledTaskRunner({priority});
       },
       &task_tracker_);
 }
@@ -433,7 +433,7 @@ TEST_P(ThreadGroupTest, UpdatePriorityBestEffortToUserBlocking) {
 
   for (size_t i = 0; i < kMaxTasks; ++i) {
     task_runners.push_back(MakeRefCounted<PooledSequencedTaskRunner>(
-        TaskTraits(ThreadPool(), TaskPriority::BEST_EFFORT),
+        TaskTraits(TaskPriority::BEST_EFFORT),
         &mock_pooled_task_runner_delegate_));
     task_runners.back()->PostTask(
         FROM_HERE, BindLambdaForTesting([&]() {
@@ -481,9 +481,8 @@ TEST_P(ThreadGroupTest, UpdatePriorityBestEffortToUserBlocking) {
 // Regression test for crbug.com/955953.
 TEST_P(ThreadGroupTestAllExecutionModes, ScopedBlockingCallTwice) {
   StartThreadGroup();
-  auto task_runner = test::CreateTaskRunnerWithExecutionMode(
-      execution_mode(), &mock_pooled_task_runner_delegate_,
-      {ThreadPool(), MayBlock()});
+  auto task_runner = test::CreatePooledTaskRunnerWithExecutionMode(
+      execution_mode(), &mock_pooled_task_runner_delegate_, {MayBlock()});
 
   WaitableEvent task_ran;
   task_runner->PostTask(FROM_HERE,
@@ -506,7 +505,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, ScopedBlockingCallTwice) {
 #if defined(OS_WIN)
 TEST_P(ThreadGroupTestAllExecutionModes, COMMTAWorkerEnvironment) {
   StartThreadGroup(ThreadGroup::WorkerEnvironment::COM_MTA);
-  auto task_runner = test::CreateTaskRunnerWithExecutionMode(
+  auto task_runner = test::CreatePooledTaskRunnerWithExecutionMode(
       execution_mode(), &mock_pooled_task_runner_delegate_);
 
   WaitableEvent task_ran;
@@ -522,7 +521,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, COMMTAWorkerEnvironment) {
 
 TEST_P(ThreadGroupTestAllExecutionModes, COMSTAWorkerEnvironment) {
   StartThreadGroup(ThreadGroup::WorkerEnvironment::COM_STA);
-  auto task_runner = test::CreateTaskRunnerWithExecutionMode(
+  auto task_runner = test::CreatePooledTaskRunnerWithExecutionMode(
       execution_mode(), &mock_pooled_task_runner_delegate_);
 
   WaitableEvent task_ran;
@@ -544,7 +543,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, COMSTAWorkerEnvironment) {
 
 TEST_P(ThreadGroupTestAllExecutionModes, NoWorkerEnvironment) {
   StartThreadGroup(ThreadGroup::WorkerEnvironment::NONE);
-  auto task_runner = test::CreateTaskRunnerWithExecutionMode(
+  auto task_runner = test::CreatePooledTaskRunnerWithExecutionMode(
       execution_mode(), &mock_pooled_task_runner_delegate_);
 
   WaitableEvent task_ran;
@@ -563,7 +562,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, NoWorkerEnvironment) {
 TEST_P(ThreadGroupTest, ShouldYieldSingleTask) {
   StartThreadGroup();
 
-  test::CreateTaskRunner({ThreadPool(), TaskPriority::USER_BLOCKING},
+  test::CreatePooledTaskRunner({TaskPriority::USER_BLOCKING},
                                &mock_pooled_task_runner_delegate_)
       ->PostTask(
           FROM_HERE, BindLambdaForTesting([&]() {

base/task/thread_pool/thread_pool_impl.cc

@@ -420,14 +420,13 @@ bool ThreadPoolImpl::PostTaskWithSequence(Task task,
 
 bool ThreadPoolImpl::ShouldYield(const TaskSource* task_source) const {
   const TaskPriority priority = task_source->priority_racy();
-  auto* const thread_group = GetThreadGroupForTraits(
-      {ThreadPool(), priority, task_source->thread_policy()});
+  auto* const thread_group =
+      GetThreadGroupForTraits({priority, task_source->thread_policy()});
   // A task whose priority changed and is now running in the wrong thread group
   // should yield so it's rescheduled in the right one.
   if (!thread_group->IsBoundToCurrentThread())
     return true;
-  return GetThreadGroupForTraits(
-             {ThreadPool(), priority, task_source->thread_policy()})
+  return GetThreadGroupForTraits({priority, task_source->thread_policy()})
       ->ShouldYield(priority);
 }
 

base/task/thread_pool/thread_pool_perftest.cc

@@ -13,7 +13,7 @@
 #include "base/callback.h"
 #include "base/optional.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/task/post_task.h"
+#include "base/task/thread_pool.h"
 #include "base/task/thread_pool/thread_pool_instance.h"
 #include "base/threading/simple_thread.h"
 #include "base/time/time.h"
@@ -93,7 +93,7 @@ class ThreadPoolPerfTest : public testing::Test {
   // Posting actions:
 
   void ContinuouslyBindAndPostNoOpTasks(size_t num_tasks) {
-    scoped_refptr<TaskRunner> task_runner = CreateTaskRunner({ThreadPool()});
+    scoped_refptr<TaskRunner> task_runner = ThreadPool::CreateTaskRunner({});
     for (size_t i = 0; i < num_tasks; ++i) {
       ++num_tasks_pending_;
       ++num_posted_tasks_;
@@ -107,7 +107,7 @@ class ThreadPoolPerfTest : public testing::Test {
   }
 
   void ContinuouslyPostNoOpTasks(size_t num_tasks) {
-    scoped_refptr<TaskRunner> task_runner = CreateTaskRunner({ThreadPool()});
+    scoped_refptr<TaskRunner> task_runner = ThreadPool::CreateTaskRunner({});
     base::RepeatingClosure closure = base::BindRepeating(
         [](std::atomic_size_t* num_task_pending) { (*num_task_pending)--; },
         &num_tasks_pending_);
@@ -120,7 +120,7 @@ class ThreadPoolPerfTest : public testing::Test {
 
   void ContinuouslyPostBusyWaitTasks(size_t num_tasks,
                                      base::TimeDelta duration) {
-    scoped_refptr<TaskRunner> task_runner = CreateTaskRunner({ThreadPool()});
+    scoped_refptr<TaskRunner> task_runner = ThreadPool::CreateTaskRunner({});
     base::RepeatingClosure closure = base::BindRepeating(
         [](std::atomic_size_t* num_task_pending, base::TimeDelta duration) {
           base::TimeTicks end_time = base::TimeTicks::Now() + duration;

base/task/thread_pool/worker_thread_unittest.cc

@@ -166,9 +166,8 @@ class ThreadPoolWorkerTest : public testing::TestWithParam<int> {
       }
 
       // Create a Sequence with TasksPerSequence() Tasks.
-      scoped_refptr<Sequence> sequence =
-          MakeRefCounted<Sequence>(TaskTraits{ThreadPool()}, nullptr,
-                                   TaskSourceExecutionMode::kParallel);
+      scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>(
+          TaskTraits(), nullptr, TaskSourceExecutionMode::kParallel);
       Sequence::Transaction sequence_transaction(sequence->BeginTransaction());
       for (int i = 0; i < outer_->TasksPerSequence(); ++i) {
         Task task(FROM_HERE,
@@ -445,7 +444,7 @@ class ControllableCleanupDelegate : public WorkerThreadDefaultDelegate {
 
     controls_->work_requested_ = true;
     scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>(
-        TaskTraits(ThreadPool(), WithBaseSyncPrimitives(),
+        TaskTraits(WithBaseSyncPrimitives(),
                    TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
         nullptr, TaskSourceExecutionMode::kParallel);
     Task task(
@@ -746,9 +745,9 @@ TEST(ThreadPoolWorkerTest, BumpPriorityOfAliveThreadDuringShutdown) {
 
   // Block shutdown to ensure that the worker doesn't exit when StartShutdown()
   // is called.
-  scoped_refptr<Sequence> sequence = MakeRefCounted<Sequence>(
-      TaskTraits{ThreadPool(), TaskShutdownBehavior::BLOCK_SHUTDOWN}, nullptr,
-      TaskSourceExecutionMode::kParallel);
+  scoped_refptr<Sequence> sequence =
+      MakeRefCounted<Sequence>(TaskTraits{TaskShutdownBehavior::BLOCK_SHUTDOWN},
+                               nullptr, TaskSourceExecutionMode::kParallel);
   auto registered_task_source =
       task_tracker.RegisterTaskSource(std::move(sequence));