base: Add wrappers for "WithTraits" task posting APIs

Add transparent forwarding wrappers in order to remove the "WithTraits"
suffix from the various task posting APIs. These wrappers will be
removed once all the call sites have been rewritten to also remove the
suffix.

This patch also renames methods on the TaskExecutor interface to remove
the same suffix as well as some internal ThreadPool APIs; the full code
base will be adjusted in later patches.

TBR=kkhorimoto@chromium.org

Bug: 968047
Change-Id: I429da2bdf0ad75240b3f4fc574e3b6932bf1be40
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1640650Reviewed-by: Kurt Horimoto <kkhorimoto@chromium.org>
Reviewed-by: François Doray <fdoray@chromium.org>
Commit-Queue: Sami Kyöstilä <skyostil@chromium.org>
Cr-Commit-Position: refs/heads/master@{#666224}

base/task/post_task.cc

@@ -25,7 +25,7 @@ class PostTaskAndReplyWithTraitsTaskRunner
 
  private:
   bool PostTask(const Location& from_here, OnceClosure task) override {
-    PostTaskWithTraits(from_here, traits_, std::move(task));
+    ::base::PostTask(from_here, traits_, std::move(task));
     return true;
   }
 
@@ -61,83 +61,129 @@ bool PostTask(const Location& from_here, OnceClosure task) {
 bool PostDelayedTask(const Location& from_here,
                      OnceClosure task,
                      TimeDelta delay) {
-  return PostDelayedTaskWithTraits(from_here, TaskTraits(), std::move(task),
-                                   delay);
+  return PostDelayedTask(from_here, TaskTraits(), std::move(task), delay);
 }
 
 bool PostTaskAndReply(const Location& from_here,
                       OnceClosure task,
                       OnceClosure reply) {
-  return PostTaskWithTraitsAndReply(from_here, TaskTraits(), std::move(task),
-                                    std::move(reply));
+  return PostTaskAndReply(from_here, TaskTraits(), std::move(task),
+                          std::move(reply));
 }
 
-bool PostTaskWithTraits(const Location& from_here,
-                        const TaskTraits& traits,
-                        OnceClosure task) {
-  return PostDelayedTaskWithTraits(from_here, traits, std::move(task),
-                                   TimeDelta());
+bool PostTask(const Location& from_here,
+              const TaskTraits& traits,
+              OnceClosure task) {
+  return PostDelayedTask(from_here, traits, std::move(task), TimeDelta());
 }
 
-bool PostDelayedTaskWithTraits(const Location& from_here,
-                               const TaskTraits& traits,
-                               OnceClosure task,
-                               TimeDelta delay) {
+bool PostDelayedTask(const Location& from_here,
+                     const TaskTraits& traits,
+                     OnceClosure task,
+                     TimeDelta delay) {
   const TaskTraits adjusted_traits = GetTaskTraitsWithExplicitPriority(traits);
   return GetTaskExecutorForTraits(adjusted_traits)
-      ->PostDelayedTaskWithTraits(from_here, adjusted_traits, std::move(task),
-                                  delay);
+      ->PostDelayedTask(from_here, adjusted_traits, std::move(task), delay);
 }
 
-bool PostTaskWithTraitsAndReply(const Location& from_here,
-                                const TaskTraits& traits,
-                                OnceClosure task,
-                                OnceClosure reply) {
+bool PostTaskAndReply(const Location& from_here,
+                      const TaskTraits& traits,
+                      OnceClosure task,
+                      OnceClosure reply) {
   return PostTaskAndReplyWithTraitsTaskRunner(traits).PostTaskAndReply(
       from_here, std::move(task), std::move(reply));
 }
 
-scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(const TaskTraits& traits) {
-  return GetTaskExecutorForTraits(traits)->CreateTaskRunnerWithTraits(traits);
+scoped_refptr<TaskRunner> CreateTaskRunner(const TaskTraits& traits) {
+  return GetTaskExecutorForTraits(traits)->CreateTaskRunner(traits);
 }
 
-scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
+scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunner(
     const TaskTraits& traits) {
-  return GetTaskExecutorForTraits(traits)->CreateSequencedTaskRunnerWithTraits(
-      traits);
+  return GetTaskExecutorForTraits(traits)->CreateSequencedTaskRunner(traits);
 }
 
 scoped_refptr<UpdateableSequencedTaskRunner>
-CreateUpdateableSequencedTaskRunnerWithTraits(const TaskTraits& traits) {
+CreateUpdateableSequencedTaskRunner(const TaskTraits& traits) {
   DCHECK(ThreadPoolInstance::Get())
       << "Ref. Prerequisite section of post_task.h.\n\n"
          "Hint: if this is in a unit test, you're likely merely missing a "
          "base::test::ScopedTaskEnvironment member in your fixture.\n";
   DCHECK(traits.use_thread_pool())
       << "The base::UseThreadPool() trait is mandatory with "
-         "CreateUpdateableSequencedTaskRunnerWithTraits().";
+         "CreateUpdateableSequencedTaskRunner().";
   CHECK_EQ(traits.extension_id(),
            TaskTraitsExtensionStorage::kInvalidExtensionId)
       << "Extension traits cannot be used with "
-         "CreateUpdateableSequencedTaskRunnerWithTraits().";
+         "CreateUpdateableSequencedTaskRunner().";
   const TaskTraits adjusted_traits = GetTaskTraitsWithExplicitPriority(traits);
   return static_cast<internal::ThreadPoolImpl*>(ThreadPoolInstance::Get())
-      ->CreateUpdateableSequencedTaskRunnerWithTraits(adjusted_traits);
+      ->CreateUpdateableSequencedTaskRunner(adjusted_traits);
+}
+
+scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunner(
+    const TaskTraits& traits,
+    SingleThreadTaskRunnerThreadMode thread_mode) {
+  return GetTaskExecutorForTraits(traits)->CreateSingleThreadTaskRunner(
+      traits, thread_mode);
+}
+
+#if defined(OS_WIN)
+scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunner(
+    const TaskTraits& traits,
+    SingleThreadTaskRunnerThreadMode thread_mode) {
+  return GetTaskExecutorForTraits(traits)->CreateCOMSTATaskRunner(traits,
+                                                                  thread_mode);
+}
+#endif  // defined(OS_WIN)
+
+// TODO(crbug.com/968047): Update all call sites and remove these forwarding
+// wrappers.
+bool PostTaskWithTraits(const Location& from_here,
+                        const TaskTraits& traits,
+                        OnceClosure task) {
+  return PostTask(from_here, traits, std::move(task));
+}
+
+bool PostDelayedTaskWithTraits(const Location& from_here,
+                               const TaskTraits& traits,
+                               OnceClosure task,
+                               TimeDelta delay) {
+  return PostDelayedTask(from_here, traits, std::move(task), delay);
+}
+
+bool PostTaskWithTraitsAndReply(const Location& from_here,
+                                const TaskTraits& traits,
+                                OnceClosure task,
+                                OnceClosure reply) {
+  return PostTaskAndReply(from_here, traits, std::move(task), std::move(reply));
+}
+
+scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(const TaskTraits& traits) {
+  return CreateTaskRunner(traits);
+}
+
+scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
+    const TaskTraits& traits) {
+  return CreateSequencedTaskRunner(traits);
+}
+
+scoped_refptr<UpdateableSequencedTaskRunner>
+CreateUpdateableSequencedTaskRunnerWithTraits(const TaskTraits& traits) {
+  return CreateUpdateableSequencedTaskRunner(traits);
 }
 
 scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
-  return GetTaskExecutorForTraits(traits)
-      ->CreateSingleThreadTaskRunnerWithTraits(traits, thread_mode);
+  return CreateSingleThreadTaskRunner(traits, thread_mode);
 }
 
 #if defined(OS_WIN)
 scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
-  return GetTaskExecutorForTraits(traits)->CreateCOMSTATaskRunnerWithTraits(
-      traits, thread_mode);
+  return CreateCOMSTATaskRunner(traits, thread_mode);
 }
 #endif  // defined(OS_WIN)
 

base/task/post_task_unittest.cc

@@ -26,47 +26,44 @@ namespace {
 class MockTaskExecutor : public TaskExecutor {
  public:
   MockTaskExecutor() {
-    ON_CALL(*this, PostDelayedTaskWithTraitsMock(_, _, _, _))
+    ON_CALL(*this, PostDelayedTaskMock(_, _, _, _))
         .WillByDefault(Invoke([this](const Location& from_here,
                                      const TaskTraits& traits,
                                      OnceClosure& task, TimeDelta delay) {
           return runner_->PostDelayedTask(from_here, std::move(task), delay);
         }));
-    ON_CALL(*this, CreateTaskRunnerWithTraits(_))
-        .WillByDefault(Return(runner_));
-    ON_CALL(*this, CreateSequencedTaskRunnerWithTraits(_))
-        .WillByDefault(Return(runner_));
-    ON_CALL(*this, CreateSingleThreadTaskRunnerWithTraits(_, _))
+    ON_CALL(*this, CreateTaskRunner(_)).WillByDefault(Return(runner_));
+    ON_CALL(*this, CreateSequencedTaskRunner(_)).WillByDefault(Return(runner_));
+    ON_CALL(*this, CreateSingleThreadTaskRunner(_, _))
         .WillByDefault(Return(runner_));
 #if defined(OS_WIN)
-    ON_CALL(*this, CreateCOMSTATaskRunnerWithTraits(_, _))
-        .WillByDefault(Return(runner_));
+    ON_CALL(*this, CreateCOMSTATaskRunner(_, _)).WillByDefault(Return(runner_));
 #endif  // defined(OS_WIN)
   }
 
   // TaskExecutor:
   // Helper because gmock doesn't support move-only types.
-  bool PostDelayedTaskWithTraits(const Location& from_here,
-                                 const TaskTraits& traits,
-                                 OnceClosure task,
-                                 TimeDelta delay) override {
-    return PostDelayedTaskWithTraitsMock(from_here, traits, task, delay);
+  bool PostDelayedTask(const Location& from_here,
+                       const TaskTraits& traits,
+                       OnceClosure task,
+                       TimeDelta delay) override {
+    return PostDelayedTaskMock(from_here, traits, task, delay);
   }
-  MOCK_METHOD4(PostDelayedTaskWithTraitsMock,
+  MOCK_METHOD4(PostDelayedTaskMock,
                bool(const Location& from_here,
                     const TaskTraits& traits,
                     OnceClosure& task,
                     TimeDelta delay));
-  MOCK_METHOD1(CreateTaskRunnerWithTraits,
+  MOCK_METHOD1(CreateTaskRunner,
                scoped_refptr<TaskRunner>(const TaskTraits& traits));
-  MOCK_METHOD1(CreateSequencedTaskRunnerWithTraits,
+  MOCK_METHOD1(CreateSequencedTaskRunner,
                scoped_refptr<SequencedTaskRunner>(const TaskTraits& traits));
-  MOCK_METHOD2(CreateSingleThreadTaskRunnerWithTraits,
+  MOCK_METHOD2(CreateSingleThreadTaskRunner,
                scoped_refptr<SingleThreadTaskRunner>(
                    const TaskTraits& traits,
                    SingleThreadTaskRunnerThreadMode thread_mode));
 #if defined(OS_WIN)
-  MOCK_METHOD2(CreateCOMSTATaskRunnerWithTraits,
+  MOCK_METHOD2(CreateCOMSTATaskRunner,
                scoped_refptr<SingleThreadTaskRunner>(
                    const TaskTraits& traits,
                    SingleThreadTaskRunnerThreadMode thread_mode));
@@ -103,34 +100,33 @@ TEST_F(PostTaskTestWithExecutor, PostTaskToThreadPool) {
   EXPECT_TRUE(PostTask(FROM_HERE, DoNothing()));
   EXPECT_FALSE(executor_.runner()->HasPendingTask());
 
-  EXPECT_TRUE(PostTaskWithTraits(FROM_HERE, {MayBlock()}, DoNothing()));
+  EXPECT_TRUE(PostTask(FROM_HERE, {MayBlock()}, DoNothing()));
   EXPECT_FALSE(executor_.runner()->HasPendingTask());
 
-  EXPECT_TRUE(PostTaskWithTraits(FROM_HERE, {ThreadPool()}, DoNothing()));
+  EXPECT_TRUE(PostTask(FROM_HERE, {ThreadPool()}, DoNothing()));
   EXPECT_FALSE(executor_.runner()->HasPendingTask());
 
   // Task runners without extension should not be the executor's.
-  auto task_runner = CreateTaskRunnerWithTraits({});
+  auto task_runner = CreateTaskRunner({});
   EXPECT_NE(executor_.runner(), task_runner);
-  auto sequenced_task_runner = CreateSequencedTaskRunnerWithTraits({});
+  auto sequenced_task_runner = CreateSequencedTaskRunner({});
   EXPECT_NE(executor_.runner(), sequenced_task_runner);
-  auto single_thread_task_runner = CreateSingleThreadTaskRunnerWithTraits({});
+  auto single_thread_task_runner = CreateSingleThreadTaskRunner({});
   EXPECT_NE(executor_.runner(), single_thread_task_runner);
 #if defined(OS_WIN)
-  auto comsta_task_runner = CreateCOMSTATaskRunnerWithTraits({});
+  auto comsta_task_runner = CreateCOMSTATaskRunner({});
   EXPECT_NE(executor_.runner(), comsta_task_runner);
 #endif  // defined(OS_WIN)
 
   // Thread pool task runners should not be the executor's.
-  task_runner = CreateTaskRunnerWithTraits({ThreadPool()});
+  task_runner = CreateTaskRunner({ThreadPool()});
   EXPECT_NE(executor_.runner(), task_runner);
-  sequenced_task_runner = CreateSequencedTaskRunnerWithTraits({ThreadPool()});
+  sequenced_task_runner = CreateSequencedTaskRunner({ThreadPool()});
   EXPECT_NE(executor_.runner(), sequenced_task_runner);
-  single_thread_task_runner =
-      CreateSingleThreadTaskRunnerWithTraits({ThreadPool()});
+  single_thread_task_runner = CreateSingleThreadTaskRunner({ThreadPool()});
   EXPECT_NE(executor_.runner(), single_thread_task_runner);
 #if defined(OS_WIN)
-  comsta_task_runner = CreateCOMSTATaskRunnerWithTraits({ThreadPool()});
+  comsta_task_runner = CreateCOMSTATaskRunner({ThreadPool()});
   EXPECT_NE(executor_.runner(), comsta_task_runner);
 #endif  // defined(OS_WIN)
 }
@@ -139,27 +135,24 @@ TEST_F(PostTaskTestWithExecutor, PostTaskToTaskExecutor) {
   // Tasks with extension should go to the executor.
   {
     TaskTraits traits = {TestExtensionBoolTrait()};
-    EXPECT_CALL(executor_, PostDelayedTaskWithTraitsMock(_, traits, _, _))
-        .Times(1);
-    EXPECT_TRUE(PostTaskWithTraits(FROM_HERE, traits, DoNothing()));
+    EXPECT_CALL(executor_, PostDelayedTaskMock(_, traits, _, _)).Times(1);
+    EXPECT_TRUE(PostTask(FROM_HERE, traits, DoNothing()));
     EXPECT_TRUE(executor_.runner()->HasPendingTask());
     executor_.runner()->ClearPendingTasks();
   }
 
   {
     TaskTraits traits = {MayBlock(), TestExtensionBoolTrait()};
-    EXPECT_CALL(executor_, PostDelayedTaskWithTraitsMock(_, traits, _, _))
-        .Times(1);
-    EXPECT_TRUE(PostTaskWithTraits(FROM_HERE, traits, DoNothing()));
+    EXPECT_CALL(executor_, PostDelayedTaskMock(_, traits, _, _)).Times(1);
+    EXPECT_TRUE(PostTask(FROM_HERE, traits, DoNothing()));
     EXPECT_TRUE(executor_.runner()->HasPendingTask());
     executor_.runner()->ClearPendingTasks();
   }
 
   {
     TaskTraits traits = {TestExtensionEnumTrait::kB, TestExtensionBoolTrait()};
-    EXPECT_CALL(executor_, PostDelayedTaskWithTraitsMock(_, traits, _, _))
-        .Times(1);
-    EXPECT_TRUE(PostTaskWithTraits(FROM_HERE, traits, DoNothing()));
+    EXPECT_CALL(executor_, PostDelayedTaskMock(_, traits, _, _)).Times(1);
+    EXPECT_TRUE(PostTask(FROM_HERE, traits, DoNothing()));
     EXPECT_TRUE(executor_.runner()->HasPendingTask());
     executor_.runner()->ClearPendingTasks();
   }
@@ -167,22 +160,18 @@ TEST_F(PostTaskTestWithExecutor, PostTaskToTaskExecutor) {
   // Task runners with extension should be the executor's.
   {
     TaskTraits traits = {TestExtensionBoolTrait()};
-    EXPECT_CALL(executor_, CreateTaskRunnerWithTraits(traits)).Times(1);
-    auto task_runner = CreateTaskRunnerWithTraits(traits);
+    EXPECT_CALL(executor_, CreateTaskRunner(traits)).Times(1);
+    auto task_runner = CreateTaskRunner(traits);
     EXPECT_EQ(executor_.runner(), task_runner);
-    EXPECT_CALL(executor_, CreateSequencedTaskRunnerWithTraits(traits))
-        .Times(1);
-    auto sequenced_task_runner = CreateSequencedTaskRunnerWithTraits(traits);
+    EXPECT_CALL(executor_, CreateSequencedTaskRunner(traits)).Times(1);
+    auto sequenced_task_runner = CreateSequencedTaskRunner(traits);
     EXPECT_EQ(executor_.runner(), sequenced_task_runner);
-    EXPECT_CALL(executor_, CreateSingleThreadTaskRunnerWithTraits(traits, _))
-        .Times(1);
-    auto single_thread_task_runner =
-        CreateSingleThreadTaskRunnerWithTraits(traits);
+    EXPECT_CALL(executor_, CreateSingleThreadTaskRunner(traits, _)).Times(1);
+    auto single_thread_task_runner = CreateSingleThreadTaskRunner(traits);
     EXPECT_EQ(executor_.runner(), single_thread_task_runner);
 #if defined(OS_WIN)
-    EXPECT_CALL(executor_, CreateCOMSTATaskRunnerWithTraits(traits, _))
-        .Times(1);
-    auto comsta_task_runner = CreateCOMSTATaskRunnerWithTraits(traits);
+    EXPECT_CALL(executor_, CreateCOMSTATaskRunner(traits, _)).Times(1);
+    auto comsta_task_runner = CreateCOMSTATaskRunner(traits);
     EXPECT_EQ(executor_.runner(), comsta_task_runner);
 #endif  // defined(OS_WIN)
   }
@@ -201,10 +190,10 @@ TEST_F(PostTaskTestWithExecutor, PriorityInherited) {
   TaskTraits traits_with_inherited_priority = traits;
   traits_with_inherited_priority.InheritPriority(TaskPriority::BEST_EFFORT);
   EXPECT_FALSE(traits_with_inherited_priority.priority_set_explicitly());
-  EXPECT_CALL(executor_, PostDelayedTaskWithTraitsMock(
-                             _, traits_with_inherited_priority, _, _))
+  EXPECT_CALL(executor_,
+              PostDelayedTaskMock(_, traits_with_inherited_priority, _, _))
       .Times(1);
-  EXPECT_TRUE(PostTaskWithTraits(FROM_HERE, traits, DoNothing()));
+  EXPECT_TRUE(PostTask(FROM_HERE, traits, DoNothing()));
   EXPECT_TRUE(executor_.runner()->HasPendingTask());
   executor_.runner()->ClearPendingTasks();
 }

base/task/task_executor.h

@@ -30,27 +30,26 @@ class BASE_EXPORT TaskExecutor {
   // Posts |task| with a |delay| and specific |traits|. |delay| can be zero. For
   // one off tasks that don't require a TaskRunner. Returns false if the task
   // definitely won't run because of current shutdown state.
-  virtual bool PostDelayedTaskWithTraits(const Location& from_here,
-                                         const TaskTraits& traits,
-                                         OnceClosure task,
-                                         TimeDelta delay) = 0;
+  virtual bool PostDelayedTask(const Location& from_here,
+                               const TaskTraits& traits,
+                               OnceClosure task,
+                               TimeDelta delay) = 0;
 
   // Returns a TaskRunner whose PostTask invocations result in scheduling tasks
   // using |traits|. Tasks may run in any order and in parallel.
-  virtual scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
+  virtual scoped_refptr<TaskRunner> CreateTaskRunner(
       const TaskTraits& traits) = 0;
 
   // Returns a SequencedTaskRunner whose PostTask invocations result in
   // scheduling tasks using |traits|. Tasks run one at a time in posting order.
-  virtual scoped_refptr<SequencedTaskRunner>
-  CreateSequencedTaskRunnerWithTraits(const TaskTraits& traits) = 0;
+  virtual scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunner(
+      const TaskTraits& traits) = 0;
 
   // Returns a SingleThreadTaskRunner whose PostTask invocations result in
   // scheduling tasks using |traits|. Tasks run on a single thread in posting
   // order. If |traits| identifies an existing thread,
   // SingleThreadTaskRunnerThreadMode::SHARED must be used.
-  virtual scoped_refptr<SingleThreadTaskRunner>
-  CreateSingleThreadTaskRunnerWithTraits(
+  virtual scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunner(
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode) = 0;
 
@@ -60,8 +59,7 @@ class BASE_EXPORT TaskExecutor {
   // run in the same Single-Threaded Apartment in posting order for the returned
   // SingleThreadTaskRunner. If |traits| identifies an existing thread,
   // SingleThreadTaskRunnerThreadMode::SHARED must be used.
-  virtual scoped_refptr<SingleThreadTaskRunner>
-  CreateCOMSTATaskRunnerWithTraits(
+  virtual scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunner(
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode) = 0;
 #endif  // defined(OS_WIN)

base/task/thread_pool/pooled_single_thread_task_runner_manager.cc

@@ -534,20 +534,18 @@ void PooledSingleThreadTaskRunnerManager::DidUpdateCanRunPolicy() {
 }
 
 scoped_refptr<SingleThreadTaskRunner>
-PooledSingleThreadTaskRunnerManager::CreateSingleThreadTaskRunnerWithTraits(
+PooledSingleThreadTaskRunnerManager::CreateSingleThreadTaskRunner(
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
-  return CreateTaskRunnerWithTraitsImpl<WorkerThreadDelegate>(traits,
-                                                              thread_mode);
+  return CreateTaskRunnerImpl<WorkerThreadDelegate>(traits, thread_mode);
 }
 
 #if defined(OS_WIN)
 scoped_refptr<SingleThreadTaskRunner>
-PooledSingleThreadTaskRunnerManager::CreateCOMSTATaskRunnerWithTraits(
+PooledSingleThreadTaskRunnerManager::CreateCOMSTATaskRunner(
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
-  return CreateTaskRunnerWithTraitsImpl<WorkerThreadCOMDelegate>(traits,
-                                                                 thread_mode);
+  return CreateTaskRunnerImpl<WorkerThreadCOMDelegate>(traits, thread_mode);
 }
 #endif  // defined(OS_WIN)
 
@@ -562,7 +560,7 @@ PooledSingleThreadTaskRunnerManager::TraitsToContinueOnShutdown(
 
 template <typename DelegateType>
 scoped_refptr<PooledSingleThreadTaskRunnerManager::PooledSingleThreadTaskRunner>
-PooledSingleThreadTaskRunnerManager::CreateTaskRunnerWithTraitsImpl(
+PooledSingleThreadTaskRunnerManager::CreateTaskRunnerImpl(
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
   DCHECK(thread_mode != SingleThreadTaskRunnerThreadMode::SHARED ||

base/task/thread_pool/pooled_single_thread_task_runner_manager.h

@@ -70,7 +70,7 @@ class BASE_EXPORT PooledSingleThreadTaskRunnerManager final {
   // named "ThreadPoolSingleThread[Shared]" +
   // kEnvironmentParams[GetEnvironmentIndexForTraits(traits)].name_suffix +
   // index.
-  scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
+  scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunner(
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode);
 
@@ -79,7 +79,7 @@ class BASE_EXPORT PooledSingleThreadTaskRunnerManager final {
   // STA thread named "ThreadPoolSingleThreadCOMSTA[Shared]" +
   // kEnvironmentParams[GetEnvironmentIndexForTraits(traits)].name_suffix +
   // index.
-  scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
+  scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunner(
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode);
 #endif  // defined(OS_WIN)
@@ -99,7 +99,7 @@ class BASE_EXPORT PooledSingleThreadTaskRunnerManager final {
       const TaskTraits& traits);
 
   template <typename DelegateType>
-  scoped_refptr<PooledSingleThreadTaskRunner> CreateTaskRunnerWithTraitsImpl(
+  scoped_refptr<PooledSingleThreadTaskRunner> CreateTaskRunnerImpl(
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode);
 

base/task/thread_pool/pooled_single_thread_task_runner_manager_unittest.cc

@@ -91,15 +91,13 @@ void ShouldNotRun() {
 
 TEST_F(PooledSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
-      single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              {TaskShutdownBehavior::BLOCK_SHUTDOWN},
-              SingleThreadTaskRunnerThreadMode::DEDICATED);
+      single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          SingleThreadTaskRunnerThreadMode::DEDICATED);
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
-      single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              {TaskShutdownBehavior::BLOCK_SHUTDOWN},
-              SingleThreadTaskRunnerThreadMode::DEDICATED);
+      single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          SingleThreadTaskRunnerThreadMode::DEDICATED);
 
   PlatformThreadRef thread_ref_1;
   task_runner_1->PostTask(FROM_HERE,
@@ -117,15 +115,13 @@ TEST_F(PooledSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
 
 TEST_F(PooledSingleThreadTaskRunnerManagerTest, SameThreadUsed) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
-      single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              {TaskShutdownBehavior::BLOCK_SHUTDOWN},
-              SingleThreadTaskRunnerThreadMode::SHARED);
+      single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          SingleThreadTaskRunnerThreadMode::SHARED);
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
-      single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              {TaskShutdownBehavior::BLOCK_SHUTDOWN},
-              SingleThreadTaskRunnerThreadMode::SHARED);
+      single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          SingleThreadTaskRunnerThreadMode::SHARED);
 
   PlatformThreadRef thread_ref_1;
   task_runner_1->PostTask(FROM_HERE,
@@ -143,15 +139,13 @@ TEST_F(PooledSingleThreadTaskRunnerManagerTest, SameThreadUsed) {
 
 TEST_F(PooledSingleThreadTaskRunnerManagerTest, RunsTasksInCurrentSequence) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
-      single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              {TaskShutdownBehavior::BLOCK_SHUTDOWN},
-              SingleThreadTaskRunnerThreadMode::DEDICATED);
+      single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          SingleThreadTaskRunnerThreadMode::DEDICATED);
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
-      single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              {TaskShutdownBehavior::BLOCK_SHUTDOWN},
-              SingleThreadTaskRunnerThreadMode::DEDICATED);
+      single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
+          SingleThreadTaskRunnerThreadMode::DEDICATED);
 
   EXPECT_FALSE(task_runner_1->RunsTasksInCurrentSequence());
   EXPECT_FALSE(task_runner_2->RunsTasksInCurrentSequence());
@@ -183,7 +177,7 @@ TEST_F(PooledSingleThreadTaskRunnerManagerTest,
        SharedWithBaseSyncPrimitivesDCHECKs) {
   testing::GTEST_FLAG(death_test_style) = "threadsafe";
   EXPECT_DCHECK_DEATH({
-    single_thread_task_runner_manager_->CreateSingleThreadTaskRunnerWithTraits(
+    single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
         {WithBaseSyncPrimitives()}, SingleThreadTaskRunnerThreadMode::SHARED);
   });
 }
@@ -197,7 +191,7 @@ TEST_F(PooledSingleThreadTaskRunnerManagerTest,
   // Post a CONTINUE_ON_SHUTDOWN task that waits on
   // |task_can_continue| to a shared SingleThreadTaskRunner.
   single_thread_task_runner_manager_
-      ->CreateSingleThreadTaskRunnerWithTraits(
+      ->CreateSingleThreadTaskRunner(
           {TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
           SingleThreadTaskRunnerThreadMode::SHARED)
       ->PostTask(FROM_HERE, base::BindOnce(
@@ -215,9 +209,8 @@ TEST_F(PooledSingleThreadTaskRunnerManagerTest,
 
   // Post a BLOCK_SHUTDOWN task to a shared SingleThreadTaskRunner.
   single_thread_task_runner_manager_
-      ->CreateSingleThreadTaskRunnerWithTraits(
-          {TaskShutdownBehavior::BLOCK_SHUTDOWN},
-          SingleThreadTaskRunnerThreadMode::SHARED)
+      ->CreateSingleThreadTaskRunner({TaskShutdownBehavior::BLOCK_SHUTDOWN},
+                                     SingleThreadTaskRunnerThreadMode::SHARED)
       ->PostTask(FROM_HERE, DoNothing());
 
   // Shutdown should not hang even though the first task hasn't finished.
@@ -241,8 +234,8 @@ class PooledSingleThreadTaskRunnerManagerCommonTest
 
   scoped_refptr<SingleThreadTaskRunner> CreateTaskRunner(
       TaskTraits traits = TaskTraits()) {
-    return single_thread_task_runner_manager_
-        ->CreateSingleThreadTaskRunnerWithTraits(traits, GetParam());
+    return single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+        traits, GetParam());
   }
 
  private:
@@ -496,10 +489,10 @@ TEST_F(PooledSingleThreadTaskRunnerManagerJoinTest, ConcurrentJoin) {
   WaitableEvent task_blocking;
 
   {
-    auto task_runner = single_thread_task_runner_manager_
-                           ->CreateSingleThreadTaskRunnerWithTraits(
-                               {WithBaseSyncPrimitives()},
-                               SingleThreadTaskRunnerThreadMode::DEDICATED);
+    auto task_runner =
+        single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+            {WithBaseSyncPrimitives()},
+            SingleThreadTaskRunnerThreadMode::DEDICATED);
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE,
         BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
@@ -524,10 +517,10 @@ TEST_F(PooledSingleThreadTaskRunnerManagerJoinTest,
   WaitableEvent task_blocking;
 
   {
-    auto task_runner = single_thread_task_runner_manager_
-                           ->CreateSingleThreadTaskRunnerWithTraits(
-                               {WithBaseSyncPrimitives()},
-                               SingleThreadTaskRunnerThreadMode::DEDICATED);
+    auto task_runner =
+        single_thread_task_runner_manager_->CreateSingleThreadTaskRunner(
+            {WithBaseSyncPrimitives()},
+            SingleThreadTaskRunnerThreadMode::DEDICATED);
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE,
         BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
@@ -549,7 +542,7 @@ TEST_F(PooledSingleThreadTaskRunnerManagerJoinTest,
 
 TEST_P(PooledSingleThreadTaskRunnerManagerCommonTest, COMSTAInitialized) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
-      single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
+      single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
           {TaskShutdownBehavior::BLOCK_SHUTDOWN}, GetParam());
 
   com_task_runner->PostTask(FROM_HERE, BindOnce(&win::AssertComApartmentType,
@@ -560,11 +553,11 @@ TEST_P(PooledSingleThreadTaskRunnerManagerCommonTest, COMSTAInitialized) {
 
 TEST_F(PooledSingleThreadTaskRunnerManagerTest, COMSTASameThreadUsed) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
-      single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
+      single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
           {TaskShutdownBehavior::BLOCK_SHUTDOWN},
           SingleThreadTaskRunnerThreadMode::SHARED);
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
-      single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
+      single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
           {TaskShutdownBehavior::BLOCK_SHUTDOWN},
           SingleThreadTaskRunnerThreadMode::SHARED);
 
@@ -629,7 +622,7 @@ class PooledSingleThreadTaskRunnerManagerTestWin
 
 TEST_F(PooledSingleThreadTaskRunnerManagerTestWin, PumpsMessages) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
-      single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
+      single_thread_task_runner_manager_->CreateCOMSTATaskRunner(
           {TaskShutdownBehavior::BLOCK_SHUTDOWN},
           SingleThreadTaskRunnerThreadMode::DEDICATED);
   HWND hwnd = nullptr;
@@ -679,7 +672,7 @@ TEST_F(PooledSingleThreadTaskRunnerManagerStartTest, PostTaskBeforeStart) {
   AtomicFlag manager_started;
   WaitableEvent task_finished;
   single_thread_task_runner_manager_
-      ->CreateSingleThreadTaskRunnerWithTraits(
+      ->CreateSingleThreadTaskRunner(
           TaskTraits(), SingleThreadTaskRunnerThreadMode::DEDICATED)
       ->PostTask(
           FROM_HERE,

base/task/thread_pool/thread_pool_impl.cc

@@ -212,10 +212,10 @@ void ThreadPoolImpl::Start(const ThreadPoolInstance::InitParams& init_params,
   started_ = true;
 }
 
-bool ThreadPoolImpl::PostDelayedTaskWithTraits(const Location& from_here,
-                                               const TaskTraits& traits,
-                                               OnceClosure task,
-                                               TimeDelta delay) {
+bool ThreadPoolImpl::PostDelayedTask(const Location& from_here,
+                                     const TaskTraits& traits,
+                                     OnceClosure task,
+                                     TimeDelta delay) {
   // Post |task| as part of a one-off single-task Sequence.
   const TaskTraits new_traits = SetUserBlockingPriorityIfNeeded(traits);
   return PostTaskWithSequence(
@@ -224,40 +224,37 @@ bool ThreadPoolImpl::PostDelayedTaskWithTraits(const Location& from_here,
                                TaskSourceExecutionMode::kParallel));
 }
 
-scoped_refptr<TaskRunner> ThreadPoolImpl::CreateTaskRunnerWithTraits(
+scoped_refptr<TaskRunner> ThreadPoolImpl::CreateTaskRunner(
     const TaskTraits& traits) {
   const TaskTraits new_traits = SetUserBlockingPriorityIfNeeded(traits);
   return MakeRefCounted<PooledParallelTaskRunner>(new_traits, this);
 }
 
-scoped_refptr<SequencedTaskRunner>
-ThreadPoolImpl::CreateSequencedTaskRunnerWithTraits(const TaskTraits& traits) {
+scoped_refptr<SequencedTaskRunner> ThreadPoolImpl::CreateSequencedTaskRunner(
+    const TaskTraits& traits) {
   const TaskTraits new_traits = SetUserBlockingPriorityIfNeeded(traits);
   return MakeRefCounted<PooledSequencedTaskRunner>(new_traits, this);
 }
 
 scoped_refptr<SingleThreadTaskRunner>
-ThreadPoolImpl::CreateSingleThreadTaskRunnerWithTraits(
+ThreadPoolImpl::CreateSingleThreadTaskRunner(
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
-  return single_thread_task_runner_manager_
-      .CreateSingleThreadTaskRunnerWithTraits(
-          SetUserBlockingPriorityIfNeeded(traits), thread_mode);
+  return single_thread_task_runner_manager_.CreateSingleThreadTaskRunner(
+      SetUserBlockingPriorityIfNeeded(traits), thread_mode);
 }
 
 #if defined(OS_WIN)
-scoped_refptr<SingleThreadTaskRunner>
-ThreadPoolImpl::CreateCOMSTATaskRunnerWithTraits(
+scoped_refptr<SingleThreadTaskRunner> ThreadPoolImpl::CreateCOMSTATaskRunner(
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
-  return single_thread_task_runner_manager_.CreateCOMSTATaskRunnerWithTraits(
+  return single_thread_task_runner_manager_.CreateCOMSTATaskRunner(
       SetUserBlockingPriorityIfNeeded(traits), thread_mode);
 }
 #endif  // defined(OS_WIN)
 
 scoped_refptr<UpdateableSequencedTaskRunner>
-ThreadPoolImpl::CreateUpdateableSequencedTaskRunnerWithTraits(
-    const TaskTraits& traits) {
+ThreadPoolImpl::CreateUpdateableSequencedTaskRunner(const TaskTraits& traits) {
   const TaskTraits new_traits = SetUserBlockingPriorityIfNeeded(traits);
   return MakeRefCounted<PooledSequencedTaskRunner>(new_traits, this);
 }

base/task/thread_pool/thread_pool_impl.h

@@ -82,24 +82,23 @@ class BASE_EXPORT ThreadPoolImpl : public ThreadPoolInstance,
   void SetHasBestEffortFence(bool has_best_effort_fence) override;
 
   // TaskExecutor:
-  bool PostDelayedTaskWithTraits(const Location& from_here,
-                                 const TaskTraits& traits,
-                                 OnceClosure task,
-                                 TimeDelta delay) override;
-  scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
+  bool PostDelayedTask(const Location& from_here,
+                       const TaskTraits& traits,
+                       OnceClosure task,
+                       TimeDelta delay) override;
+  scoped_refptr<TaskRunner> CreateTaskRunner(const TaskTraits& traits) override;
+  scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunner(
       const TaskTraits& traits) override;
-  scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
-      const TaskTraits& traits) override;
-  scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
+  scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunner(
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode) override;
 #if defined(OS_WIN)
-  scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
+  scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunner(
       const TaskTraits& traits,
       SingleThreadTaskRunnerThreadMode thread_mode) override;
 #endif  // defined(OS_WIN)
   scoped_refptr<UpdateableSequencedTaskRunner>
-  CreateUpdateableSequencedTaskRunnerWithTraits(const TaskTraits& traits);
+  CreateUpdateableSequencedTaskRunner(const TaskTraits& traits);
 
  private:
   // Invoked after |has_fence_| or |has_best_effort_fence_| is updated. Sets the

content/browser/scheduler/browser_task_executor.cc

@@ -172,11 +172,10 @@ void BrowserTaskExecutor::RunAllPendingTasksOnThreadForTesting(
   run_loop.Run();
 }
 
-bool BrowserTaskExecutor::PostDelayedTaskWithTraits(
-    const base::Location& from_here,
-    const base::TaskTraits& traits,
-    base::OnceClosure task,
-    base::TimeDelta delay) {
+bool BrowserTaskExecutor::PostDelayedTask(const base::Location& from_here,
+                                          const base::TaskTraits& traits,
+                                          base::OnceClosure task,
+                                          base::TimeDelta delay) {
   DCHECK_EQ(BrowserTaskTraitsExtension::kExtensionId, traits.extension_id());
   const BrowserTaskTraitsExtension& extension =
       traits.GetExtension<BrowserTaskTraitsExtension>();
@@ -189,19 +188,18 @@ bool BrowserTaskExecutor::PostDelayedTaskWithTraits(
   }
 }
 
-scoped_refptr<base::TaskRunner> BrowserTaskExecutor::CreateTaskRunnerWithTraits(
+scoped_refptr<base::TaskRunner> BrowserTaskExecutor::CreateTaskRunner(
     const base::TaskTraits& traits) {
   return GetTaskRunner(traits);
 }
 
 scoped_refptr<base::SequencedTaskRunner>
-BrowserTaskExecutor::CreateSequencedTaskRunnerWithTraits(
-    const base::TaskTraits& traits) {
+BrowserTaskExecutor::CreateSequencedTaskRunner(const base::TaskTraits& traits) {
   return GetTaskRunner(traits);
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
-BrowserTaskExecutor::CreateSingleThreadTaskRunnerWithTraits(
+BrowserTaskExecutor::CreateSingleThreadTaskRunner(
     const base::TaskTraits& traits,
     base::SingleThreadTaskRunnerThreadMode thread_mode) {
   return GetTaskRunner(traits);
@@ -209,7 +207,7 @@ BrowserTaskExecutor::CreateSingleThreadTaskRunnerWithTraits(
 
 #if defined(OS_WIN)
 scoped_refptr<base::SingleThreadTaskRunner>
-BrowserTaskExecutor::CreateCOMSTATaskRunnerWithTraits(
+BrowserTaskExecutor::CreateCOMSTATaskRunner(
     const base::TaskTraits& traits,
     base::SingleThreadTaskRunnerThreadMode thread_mode) {
   return GetTaskRunner(traits);

content/browser/scheduler/browser_task_executor.h

@@ -109,24 +109,23 @@ class CONTENT_EXPORT BrowserTaskExecutor : public base::TaskExecutor {
       const base::TaskTraits& traits);
 
   // base::TaskExecutor implementation.
-  bool PostDelayedTaskWithTraits(const base::Location& from_here,
-                                 const base::TaskTraits& traits,
-                                 base::OnceClosure task,
-                                 base::TimeDelta delay) override;
+  bool PostDelayedTask(const base::Location& from_here,
+                       const base::TaskTraits& traits,
+                       base::OnceClosure task,
+                       base::TimeDelta delay) override;
 
-  scoped_refptr<base::TaskRunner> CreateTaskRunnerWithTraits(
+  scoped_refptr<base::TaskRunner> CreateTaskRunner(
       const base::TaskTraits& traits) override;
 
-  scoped_refptr<base::SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
+  scoped_refptr<base::SequencedTaskRunner> CreateSequencedTaskRunner(
       const base::TaskTraits& traits) override;
 
-  scoped_refptr<base::SingleThreadTaskRunner>
-  CreateSingleThreadTaskRunnerWithTraits(
+  scoped_refptr<base::SingleThreadTaskRunner> CreateSingleThreadTaskRunner(
       const base::TaskTraits& traits,
       base::SingleThreadTaskRunnerThreadMode thread_mode) override;
 
 #if defined(OS_WIN)
-  scoped_refptr<base::SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
+  scoped_refptr<base::SingleThreadTaskRunner> CreateCOMSTATaskRunner(
       const base::TaskTraits& traits,
       base::SingleThreadTaskRunnerThreadMode thread_mode) override;
 #endif  // defined(OS_WIN)

ios/web/web_thread_impl.cc

@@ -152,27 +152,26 @@ class WebThreadTaskExecutor : public base::TaskExecutor {
   ~WebThreadTaskExecutor() override {}
 
   // base::TaskExecutor implementation.
-  bool PostDelayedTaskWithTraits(const base::Location& from_here,
-                                 const base::TaskTraits& traits,
-                                 base::OnceClosure task,
-                                 base::TimeDelta delay) override {
+  bool PostDelayedTask(const base::Location& from_here,
+                       const base::TaskTraits& traits,
+                       base::OnceClosure task,
+                       base::TimeDelta delay) override {
     return PostTaskHelper(
         GetWebThreadIdentifier(traits), from_here, std::move(task), delay,
         traits.GetExtension<WebTaskTraitsExtension>().nestable());
   }
 
-  scoped_refptr<base::TaskRunner> CreateTaskRunnerWithTraits(
+  scoped_refptr<base::TaskRunner> CreateTaskRunner(
       const base::TaskTraits& traits) override {
     return GetTaskRunnerForThread(GetWebThreadIdentifier(traits));
   }
 
-  scoped_refptr<base::SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
+  scoped_refptr<base::SequencedTaskRunner> CreateSequencedTaskRunner(
       const base::TaskTraits& traits) override {
     return GetTaskRunnerForThread(GetWebThreadIdentifier(traits));
   }
 
-  scoped_refptr<base::SingleThreadTaskRunner>
-  CreateSingleThreadTaskRunnerWithTraits(
+  scoped_refptr<base::SingleThreadTaskRunner> CreateSingleThreadTaskRunner(
       const base::TaskTraits& traits,
       base::SingleThreadTaskRunnerThreadMode thread_mode) override {
     // It's not possible to request DEDICATED access to a WebThread.