base: Always specify thread affinity when posting tasks

*** Note: There is no behavior change from this patch. ***

The PostTask APIs will shortly be changed to require all tasks to explicitly
specify their thread affinity, i.e., whether the task should run on the thread
pool or a specific named thread such as a BrowserThread. This patch updates all
call sites with thread affinity annotation. We also remove the "WithTraits"
suffix to make the call sites more readable.

Before:

    // Thread pool task.
    base::PostTaskWithTraits(FROM_HERE, {...}, ...);

    // UI thread task.
    base::PostTaskWithTraits(FROM_HERE, {BrowserThread::UI, ...}, ...);

After:

    // Thread pool task.
    base::PostTask(FROM_HERE, {base::ThreadPool(), ...}, ...);

    // UI thread task.
    base::PostTask(FROM_HERE, {BrowserThread::UI, ...}, ...);

This patch was semi-automatically prepared with these steps:

    1. Patch in https://chromium-review.googlesource.com/c/chromium/src/+/1635827
       to make thread affinity a build-time requirement.
    2. Run an initial pass with a clang rewriter:
       https://chromium-review.googlesource.com/c/chromium/src/+/1635623
    3. ninja -C out/Debug | grep 'requested here' | cut -d: -f1-3 | sort | \
           uniq > errors.txt
    4. while read line; do
         f=$(echo $line | cut -d: -f 1)
         r=$(echo $line | cut -d: -f 2)
         c=$(echo $line | cut -d: -f 3)
         sed -i "${r}s/./&base::ThreadPool(),/$c" $f
       done < errors.txt
    5. GOTO 3 until build succeeds.
    6. Remove the "WithTraits" suffix from task API call sites:

       $ tools/git/mffr.py -i <(cat <<EOF
       [
         ["PostTaskWithTraits",                            "PostTask"],
         ["PostDelayedTaskWithTraits",                     "PostDelayedTask"],
         ["PostTaskWithTraitsAndReply",                    "PostTaskAndReply"],
         ["CreateTaskRunnerWithTraits",                    "CreateTaskRunner"],
         ["CreateSequencedTaskRunnerWithTraits",           "CreateSequencedTaskRunner"],
         ["CreateUpdateableSequencedTaskRunnerWithTraits", "CreateUpdateableSequencedTaskRunner"],
         ["CreateSingleThreadTaskRunnerWithTraits",        "CreateSingleThreadTaskRunner"],
         ["CreateCOMSTATaskRunnerWithTraits",              "CreateCOMSTATaskRunner"]
       ]
       EOF
       )

This CL was uploaded by git cl split.

R=fdoray@chromium.org

Bug: 968047
Change-Id: I3451c35ce8c86d97fadac722781c92142be0d905
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1728586
Commit-Queue: Sami Kyöstilä <skyostil@chromium.org>
Reviewed-by: Gabriel Charette <gab@chromium.org>
Auto-Submit: Sami Kyöstilä <skyostil@chromium.org>
Cr-Commit-Position: refs/heads/master@{#682789}

base/memory/memory_pressure_monitor_chromeos.cc

@@ -293,7 +293,7 @@ void MemoryPressureMonitor::ScheduleEarlyCheck() {
 void MemoryPressureMonitor::ScheduleWaitForKernelNotification() {
   base::PostTaskAndReplyWithResult(
       FROM_HERE,
-      {base::MayBlock(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      {ThreadPool(), MayBlock(), TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       kernel_waiting_callback_,
       base::BindRepeating(&MemoryPressureMonitor::HandleKernelNotification,
                           weak_ptr_factory_.GetWeakPtr()));

base/process/kill.cc

@@ -42,7 +42,8 @@ void EnsureProcessTerminated(Process process) {
 
   PostDelayedTask(
       FROM_HERE,
-      {TaskPriority::BEST_EFFORT, TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
+      {ThreadPool(), TaskPriority::BEST_EFFORT,
+       TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       BindOnce(
           [](Process process) {
             if (process.WaitForExitWithTimeout(TimeDelta(), nullptr))

base/sequence_checker_unittest.cc

@@ -272,9 +272,9 @@ TEST(SequenceCheckerTest, CalledOnValidSequenceFromThreadDestruction) {
   ThreadLocalOwnedPointer<SequenceCheckerOwner> thread_local_owner;
   {
     test::ScopedTaskEnvironment task_environment;
-    auto task_runner = CreateSequencedTaskRunner({});
+    auto task_runner = CreateSequencedTaskRunner({ThreadPool()});
     task_runner->PostTask(
-        FROM_HERE, base::BindLambdaForTesting([&]() {
+        FROM_HERE, BindLambdaForTesting([&]() {
           thread_local_owner.Set(std::make_unique<SequenceCheckerOwner>());
         }));
     task_runner = nullptr;

base/system/sys_info.cc

@@ -107,7 +107,7 @@ std::string SysInfo::HardwareModelName() {
 void SysInfo::GetHardwareInfo(base::OnceCallback<void(HardwareInfo)> callback) {
 #if defined(OS_WIN)
   base::PostTaskAndReplyWithResult(
-      base::CreateCOMSTATaskRunner({}).get(), FROM_HERE,
+      base::CreateCOMSTATaskRunner({ThreadPool()}).get(), FROM_HERE,
       base::BindOnce(&GetHardwareInfoSync), std::move(callback));
 #elif defined(OS_ANDROID) || defined(OS_MACOSX)
   base::PostTaskAndReplyWithResult(

base/task/post_task_unittest.cc

@@ -114,7 +114,7 @@ TEST_F(PostTaskTestWithExecutor, PostTaskToThreadPool) {
   auto single_thread_task_runner = CreateSingleThreadTaskRunner({ThreadPool()});
   EXPECT_NE(executor_.runner(), single_thread_task_runner);
 #if defined(OS_WIN)
-  auto comsta_task_runner = CreateCOMSTATaskRunner({});
+  auto comsta_task_runner = CreateCOMSTATaskRunner({ThreadPool()});
   EXPECT_NE(executor_.runner(), comsta_task_runner);
 #endif  // defined(OS_WIN)
 

base/task/promise/abstract_promise_unittest.cc

@@ -2425,8 +2425,8 @@ TEST_F(AbstractPromiseTest, SingleRejectPrerequisitePolicyALLModified) {
               p->OnRejected();
             }));
 
-    base::PostTaskWithTraits(
-        FROM_HERE, {},
+    base::PostTask(
+        FROM_HERE, {base::ThreadPool()},
         base::Bind([](scoped_refptr<AbstractPromise> p2) { p2->OnRejected(); },
                    p2));
 

base/task/promise/promise_unittest.cc

@@ -1136,11 +1136,10 @@ TEST_F(PromiseTest, CurriedVoidPromiseModified) {
                                    promise_resolver->promise()))
         .ThenHere(FROM_HERE, base::BindOnce([](int v) { EXPECT_EQ(v, 42); }))
         .ThenHere(FROM_HERE, run_loop.QuitClosure());
-    PostTaskWithTraits(FROM_HERE, {ThreadPool()},
-                       base::BindLambdaForTesting([&]() {
-                         promise_resolver->Resolve(42);
-                         promise_resolver.reset();
-                       }));
+    PostTask(FROM_HERE, {ThreadPool()}, BindLambdaForTesting([&]() {
+               promise_resolver->Resolve(42);
+               promise_resolver.reset();
+             }));
     run_loop.Run();
     scoped_task_environment_.RunUntilIdle();
   }

base/task/task_traits_extension_unittest.cc

@@ -17,7 +17,7 @@ TEST(TaskTraitsExtensionTest, NoExtension) {
 }
 
 TEST(TaskTraitsExtensionTest, CreateWithOneExtensionTrait) {
-  constexpr TaskTraits traits = {ThreadPool(), TestExtensionEnumTrait::kB};
+  constexpr TaskTraits traits = {TestExtensionEnumTrait::kB};
 
   EXPECT_EQ(traits.GetExtension<TestTaskTraitsExtension>().enum_trait(),
             TestExtensionEnumTrait::kB);
@@ -25,7 +25,7 @@ TEST(TaskTraitsExtensionTest, CreateWithOneExtensionTrait) {
 }
 
 TEST(TaskTraitsExtensionTest, CreateWithMultipleExtensionTraits) {
-  constexpr TaskTraits traits = {ThreadPool(), TestExtensionEnumTrait::kB,
+  constexpr TaskTraits traits = {TestExtensionEnumTrait::kB,
                                  TestExtensionBoolTrait()};
 
   EXPECT_EQ(traits.GetExtension<TestTaskTraitsExtension>().enum_trait(),
@@ -34,7 +34,7 @@ TEST(TaskTraitsExtensionTest, CreateWithMultipleExtensionTraits) {
 }
 
 TEST(TaskTraitsExtensionTest, CreateWithBaseAndExtensionTraits) {
-  constexpr TaskTraits traits = {ThreadPool(), TaskPriority::USER_BLOCKING,
+  constexpr TaskTraits traits = {TaskPriority::USER_BLOCKING,
                                  TestExtensionEnumTrait::kC,
                                  TestExtensionBoolTrait()};
 

base/task/thread_pool/job_task_source_unittest.cc

@@ -20,8 +20,8 @@ namespace internal {
 TEST(ThreadPoolJobTaskSourceTest, RunTasks) {
   auto job_task = base::MakeRefCounted<test::MockJobTask>(
       DoNothing(), /* num_tasks_to_run */ 2);
-  scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskPriority::BEST_EFFORT);
+  scoped_refptr<JobTaskSource> task_source = job_task->GetJobTaskSource(
+      FROM_HERE, {ThreadPool(), TaskPriority::BEST_EFFORT});
 
   TaskSource::Transaction task_source_transaction(
       task_source->BeginTransaction());
@@ -55,8 +55,8 @@ TEST(ThreadPoolJobTaskSourceTest, RunTasks) {
 TEST(ThreadPoolJobTaskSourceTest, SkipTask) {
   auto job_task = base::MakeRefCounted<test::MockJobTask>(
       DoNothing(), /* num_tasks_to_run */ 1);
-  scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskPriority::BEST_EFFORT);
+  scoped_refptr<JobTaskSource> task_source = job_task->GetJobTaskSource(
+      FROM_HERE, {ThreadPool(), TaskPriority::BEST_EFFORT});
 
   TaskSource::Transaction task_source_transaction(
       task_source->BeginTransaction());
@@ -73,8 +73,8 @@ TEST(ThreadPoolJobTaskSourceTest, SkipTask) {
 TEST(ThreadPoolJobTaskSourceTest, RunTasksInParallel) {
   auto job_task = base::MakeRefCounted<test::MockJobTask>(
       DoNothing(), /* num_tasks_to_run */ 2);
-  scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskPriority::BEST_EFFORT);
+  scoped_refptr<JobTaskSource> task_source = job_task->GetJobTaskSource(
+      FROM_HERE, {ThreadPool(), TaskPriority::BEST_EFFORT});
 
   TaskSource::Transaction task_source_transaction(
       task_source->BeginTransaction());
@@ -115,8 +115,8 @@ TEST(ThreadPoolJobTaskSourceTest, InvalidTakeTask) {
   auto job_task =
       base::MakeRefCounted<test::MockJobTask>(DoNothing(),
                                               /* num_tasks_to_run */ 1);
-  scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskPriority::BEST_EFFORT);
+  scoped_refptr<JobTaskSource> task_source = job_task->GetJobTaskSource(
+      FROM_HERE, {ThreadPool(), TaskPriority::BEST_EFFORT});
   TaskSource::Transaction task_source_transaction(
       task_source->BeginTransaction());
 
@@ -135,8 +135,8 @@ TEST(ThreadPoolJobTaskSourceTest, InvalidDidProcessTask) {
   auto job_task =
       base::MakeRefCounted<test::MockJobTask>(DoNothing(),
                                               /* num_tasks_to_run */ 1);
-  scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskPriority::BEST_EFFORT);
+  scoped_refptr<JobTaskSource> task_source = job_task->GetJobTaskSource(
+      FROM_HERE, {ThreadPool(), TaskPriority::BEST_EFFORT});
   TaskSource::Transaction task_source_transaction(
       task_source->BeginTransaction());
 

base/task/thread_pool/pooled_single_thread_task_runner_manager.cc

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

base/task/thread_pool/pooled_single_thread_task_runner_manager_unittest.cc

@@ -560,7 +560,7 @@ TEST_F(PooledSingleThreadTaskRunnerManagerJoinTest,
 TEST_P(PooledSingleThreadTaskRunnerManagerCommonTest, COMSTAInitialized) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
-          {TaskShutdownBehavior::BLOCK_SHUTDOWN}, GetParam());
+          {ThreadPool(), TaskShutdownBehavior::BLOCK_SHUTDOWN}, GetParam());
 
   com_task_runner->PostTask(FROM_HERE, BindOnce(&win::AssertComApartmentType,
                                                 win::ComApartmentType::STA));
@@ -571,11 +571,11 @@ TEST_P(PooledSingleThreadTaskRunnerManagerCommonTest, COMSTAInitialized) {
 TEST_F(PooledSingleThreadTaskRunnerManagerTest, COMSTASameThreadUsed) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
-          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          {ThreadPool(), TaskShutdownBehavior::BLOCK_SHUTDOWN},
           SingleThreadTaskRunnerThreadMode::SHARED);
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
-          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          {ThreadPool(), TaskShutdownBehavior::BLOCK_SHUTDOWN},
           SingleThreadTaskRunnerThreadMode::SHARED);
 
   PlatformThreadRef thread_ref_1;
@@ -640,7 +640,7 @@ class PooledSingleThreadTaskRunnerManagerTestWin
 TEST_F(PooledSingleThreadTaskRunnerManagerTestWin, PumpsMessages) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
-          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          {ThreadPool(), TaskShutdownBehavior::BLOCK_SHUTDOWN},
           SingleThreadTaskRunnerThreadMode::DEDICATED);
   HWND hwnd = nullptr;
   // HWNDs process messages on the thread that created them, so we have to

base/task/thread_pool/thread_group_impl_unittest.cc

@@ -310,8 +310,8 @@ TEST_F(ThreadGroupImplImplTest, ShouldYieldFloodedUserVisible) {
         test::WaitWithoutBlockingObserver(&threads_continue);
       }),
       /* num_tasks_to_run */ kMaxTasks);
-  scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskPriority::USER_VISIBLE);
+  scoped_refptr<JobTaskSource> task_source = job_task->GetJobTaskSource(
+      FROM_HERE, {ThreadPool(), TaskPriority::USER_VISIBLE});
 
   auto registered_task_source = task_tracker_.WillQueueTaskSource(task_source);
   ASSERT_TRUE(registered_task_source);
@@ -327,7 +327,7 @@ TEST_F(ThreadGroupImplImplTest, ShouldYieldFloodedUserVisible) {
   // Note: This is only true because this test is using a single ThreadGroup.
   //       Under the ThreadPool this wouldn't be racy because BEST_EFFORT tasks
   //       run in an independent ThreadGroup.
-  test::CreateTaskRunner(TaskPriority::BEST_EFFORT,
+  test::CreateTaskRunner({ThreadPool(), TaskPriority::BEST_EFFORT},
                          &mock_pooled_task_runner_delegate_)
       ->PostTask(
           FROM_HERE, BindLambdaForTesting([&]() {
@@ -338,7 +338,7 @@ TEST_F(ThreadGroupImplImplTest, ShouldYieldFloodedUserVisible) {
   EXPECT_FALSE(thread_group_->ShouldYield(TaskPriority::USER_BLOCKING));
 
   // Posting a USER_VISIBLE task should cause BEST_EFFORT tasks to yield.
-  test::CreateTaskRunner(TaskPriority::USER_VISIBLE,
+  test::CreateTaskRunner({ThreadPool(), TaskPriority::USER_VISIBLE},
                          &mock_pooled_task_runner_delegate_)
       ->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
                    EXPECT_FALSE(
@@ -350,7 +350,7 @@ TEST_F(ThreadGroupImplImplTest, ShouldYieldFloodedUserVisible) {
 
   // Posting a USER_BLOCKING task should cause BEST_EFFORT and USER_VISIBLE
   // tasks to yield.
-  test::CreateTaskRunner(TaskPriority::USER_BLOCKING,
+  test::CreateTaskRunner({ThreadPool(), TaskPriority::USER_BLOCKING},
                          &mock_pooled_task_runner_delegate_)
       ->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
                    // Once this task got to start, no other task needs to yield.
@@ -1340,7 +1340,7 @@ TEST_P(ThreadGroupImplBlockingTest, ThreadBlockedUnblockedShouldYield) {
 
   // Post a USER_VISIBLE task that can't run since workers are saturated. This
   // should cause BEST_EFFORT tasks to yield.
-  test::CreateTaskRunner(TaskPriority::USER_VISIBLE,
+  test::CreateTaskRunner({ThreadPool(), TaskPriority::USER_VISIBLE},
                          &mock_pooled_task_runner_delegate_)
       ->PostTask(
           FROM_HERE, BindLambdaForTesting([&]() {
@@ -1350,7 +1350,7 @@ TEST_P(ThreadGroupImplBlockingTest, ThreadBlockedUnblockedShouldYield) {
 
   // Post a USER_BLOCKING task that can't run since workers are saturated. This
   // should cause USER_VISIBLE tasks to yield.
-  test::CreateTaskRunner(TaskPriority::USER_BLOCKING,
+  test::CreateTaskRunner({ThreadPool(), TaskPriority::USER_BLOCKING},
                          &mock_pooled_task_runner_delegate_)
       ->PostTask(FROM_HERE, BindLambdaForTesting([&]() {
                    EXPECT_FALSE(

base/task/thread_pool/thread_group_unittest.cc

@@ -564,7 +564,7 @@ TEST_P(ThreadGroupTestAllExecutionModes, NoWorkerEnvironment) {
 TEST_P(ThreadGroupTest, ShouldYieldSingleTask) {
   StartThreadGroup();
 
-  test::CreateTaskRunner(TaskPriority::USER_BLOCKING,
+  test::CreateTaskRunner({ThreadPool(), TaskPriority::USER_BLOCKING},
                          &mock_pooled_task_runner_delegate_)
       ->PostTask(
           FROM_HERE, BindLambdaForTesting([&]() {
@@ -597,7 +597,7 @@ TEST_P(ThreadGroupTest, ScheduleJobTaskSource) {
       }),
       /* num_tasks_to_run */ kMaxTasks);
   scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskTraits());
+      job_task->GetJobTaskSource(FROM_HERE, {ThreadPool()});
 
   auto registered_task_source =
       task_tracker_.WillQueueTaskSource(std::move(task_source));
@@ -643,8 +643,8 @@ TEST_P(ThreadGroupTest, JobTaskSourceUpdatePriority) {
         }
       }),
       /* num_tasks_to_run */ kMaxTasks);
-  scoped_refptr<JobTaskSource> task_source =
-      job_task->GetJobTaskSource(FROM_HERE, TaskPriority::BEST_EFFORT);
+  scoped_refptr<JobTaskSource> task_source = job_task->GetJobTaskSource(
+      FROM_HERE, {ThreadPool(), TaskPriority::BEST_EFFORT});
 
   auto registered_task_source = task_tracker_.WillQueueTaskSource(task_source);
   EXPECT_TRUE(registered_task_source);

base/task/thread_pool/thread_pool.h

@@ -59,8 +59,8 @@ class BASE_EXPORT ThreadPoolInstance {
       // Place the pool's *foreground* workers in a COM STA. This exists to
       // mimic the behavior of SequencedWorkerPool and BrowserThreadImpl that
       // ThreadPool has replaced. Tasks that need a COM STA should use
-      // CreateCOMSTATaskRunner() instead of
-      // Create(Sequenced)TaskRunnerWithTraits() + this init param.
+      // CreateCOMSTATaskRunner() instead of Create(Sequenced)TaskRunner() +
+      // this init param.
       DEPRECATED_COM_STA_IN_FOREGROUND_GROUP,
 #endif  // defined(OS_WIN)
     };

base/task/thread_pool/thread_pool_impl_unittest.cc

@@ -1030,27 +1030,29 @@ TEST_P(ThreadPoolImplTest, WorkerThreadObserver) {
 
 #if defined(OS_WIN)
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::BEST_EFFORT}, SingleThreadTaskRunnerThreadMode::SHARED));
+      {ThreadPool(), TaskPriority::BEST_EFFORT},
+      SingleThreadTaskRunnerThreadMode::SHARED));
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::BEST_EFFORT, MayBlock()},
+      {ThreadPool(), TaskPriority::BEST_EFFORT, MayBlock()},
       SingleThreadTaskRunnerThreadMode::SHARED));
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::USER_BLOCKING}, SingleThreadTaskRunnerThreadMode::SHARED));
+      {ThreadPool(), TaskPriority::USER_BLOCKING},
+      SingleThreadTaskRunnerThreadMode::SHARED));
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::USER_BLOCKING, MayBlock()},
+      {ThreadPool(), TaskPriority::USER_BLOCKING, MayBlock()},
       SingleThreadTaskRunnerThreadMode::SHARED));
 
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::BEST_EFFORT},
+      {ThreadPool(), TaskPriority::BEST_EFFORT},
       SingleThreadTaskRunnerThreadMode::DEDICATED));
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::BEST_EFFORT, MayBlock()},
+      {ThreadPool(), TaskPriority::BEST_EFFORT, MayBlock()},
       SingleThreadTaskRunnerThreadMode::DEDICATED));
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::USER_BLOCKING},
+      {ThreadPool(), TaskPriority::USER_BLOCKING},
       SingleThreadTaskRunnerThreadMode::DEDICATED));
   task_runners.push_back(thread_pool_->CreateCOMSTATaskRunner(
-      {TaskPriority::USER_BLOCKING, MayBlock()},
+      {ThreadPool(), TaskPriority::USER_BLOCKING, MayBlock()},
       SingleThreadTaskRunnerThreadMode::DEDICATED));
 #endif
 
@@ -1164,7 +1166,7 @@ std::vector<std::unique_ptr<TaskRunnerAndEvents>> CreateTaskRunnersAndEvents(
   // Its task is expected to run after the USER_BLOCKING task runner's task.
   task_runners_and_events.push_back(std::make_unique<TaskRunnerAndEvents>(
       thread_pool->CreateUpdateableSequencedTaskRunner(
-          TaskTraits({ThreadPool(), TaskPriority::BEST_EFFORT, thread_policy})),
+          {ThreadPool(), TaskPriority::BEST_EFFORT, thread_policy}),
       TaskPriority::USER_VISIBLE, &task_runners_and_events.back()->task_ran));
 
   // -----

base/test/scoped_task_environment_unittest.cc

@@ -675,7 +675,7 @@ TEST_F(ScopedTaskEnvironmentTest, MultiThreadedMockTime) {
 
   ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, post_main_thread_delayed_task, kOneMs);
-  CreateSequencedTaskRunnerWithTraits({ThreadPool()})
+  CreateSequencedTaskRunner({ThreadPool()})
       ->PostDelayedTask(FROM_HERE, post_thread_pool_delayed_task, kOneMs);
 
   scoped_task_environment.FastForwardUntilNoTasksRemain();