1 files changed, 21 insertions, 26 deletions

diff --git a/chromium/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc b/chromium/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
index 0ebe5590c6c..a47760cb0c3 100644
--- a/chromium/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
+++ b/chromium/base/task_scheduler/scheduler_single_thread_task_runner_manager.cc
@@ -237,16 +237,15 @@ class SchedulerWorkerCOMDelegate : public SchedulerWorkerDelegate {
   scoped_refptr<Sequence> GetWorkFromWindowsMessageQueue() {
     MSG msg;
     if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE) != FALSE) {
-      auto pump_message_task =
-          std::make_unique<Task>(FROM_HERE,
-                                 Bind(
-                                     [](MSG msg) {
-                                       TranslateMessage(&msg);
-                                       DispatchMessage(&msg);
-                                     },
-                                     std::move(msg)),
-                                 TaskTraits(MayBlock()), TimeDelta());
-      if (task_tracker_->WillPostTask(pump_message_task.get())) {
+      Task pump_message_task(FROM_HERE,
+                             Bind(
+                                 [](MSG msg) {
+                                   TranslateMessage(&msg);
+                                   DispatchMessage(&msg);
+                                 },
+                                 std::move(msg)),
+                             TaskTraits(MayBlock()), TimeDelta());
+      if (task_tracker_->WillPostTask(pump_message_task)) {
         bool was_empty =
             message_pump_sequence_->PushTask(std::move(pump_message_task));
         DCHECK(was_empty) << "GetWorkFromWindowsMessageQueue() does not expect "
@@ -294,14 +293,13 @@ class SchedulerSingleThreadTaskRunnerManager::SchedulerSingleThreadTaskRunner
     if (!g_manager_is_alive)
       return false;
 
-    auto task =
-        std::make_unique<Task>(from_here, std::move(closure), traits_, delay);
-    task->single_thread_task_runner_ref = this;
+    Task task(from_here, std::move(closure), traits_, delay);
+    task.single_thread_task_runner_ref = this;
 
-    if (!outer_->task_tracker_->WillPostTask(task.get()))
+    if (!outer_->task_tracker_->WillPostTask(task))
       return false;
 
-    if (task->delayed_run_time.is_null()) {
+    if (task.delayed_run_time.is_null()) {
       PostTaskNow(std::move(task));
     } else {
       outer_->delayed_task_manager_->AddDelayedTask(
@@ -351,7 +349,7 @@ class SchedulerSingleThreadTaskRunnerManager::SchedulerSingleThreadTaskRunner
     }
   }
 
-  void PostTaskNow(std::unique_ptr<Task> task) {
+  void PostTaskNow(Task task) {
     scoped_refptr<Sequence> sequence = GetDelegate()->sequence();
     // If |sequence| is null, then the thread is effectively gone (either
     // shutdown or joined).
@@ -421,21 +419,19 @@ void SchedulerSingleThreadTaskRunnerManager::Start() {
 
 scoped_refptr<SingleThreadTaskRunner>
 SchedulerSingleThreadTaskRunnerManager::CreateSingleThreadTaskRunnerWithTraits(
-    const std::string& name,
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
-  return CreateTaskRunnerWithTraitsImpl<SchedulerWorkerDelegate>(name, traits,
+  return CreateTaskRunnerWithTraitsImpl<SchedulerWorkerDelegate>(traits,
                                                                  thread_mode);
 }
 
 #if defined(OS_WIN)
 scoped_refptr<SingleThreadTaskRunner>
 SchedulerSingleThreadTaskRunnerManager::CreateCOMSTATaskRunnerWithTraits(
-    const std::string& name,
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
   return CreateTaskRunnerWithTraitsImpl<SchedulerWorkerCOMDelegate>(
-      name, traits, thread_mode);
+      traits, thread_mode);
 }
 #endif  // defined(OS_WIN)
 
@@ -443,7 +439,6 @@ template <typename DelegateType>
 scoped_refptr<
     SchedulerSingleThreadTaskRunnerManager::SchedulerSingleThreadTaskRunner>
 SchedulerSingleThreadTaskRunnerManager::CreateTaskRunnerWithTraitsImpl(
-    const std::string& name,
     const TaskTraits& traits,
     SingleThreadTaskRunnerThreadMode thread_mode) {
   DCHECK(thread_mode != SingleThreadTaskRunnerThreadMode::SHARED ||
@@ -469,12 +464,12 @@ SchedulerSingleThreadTaskRunnerManager::CreateTaskRunnerWithTraitsImpl(
     if (!worker) {
       const auto& environment_params =
           kEnvironmentParams[GetEnvironmentIndexForTraits(traits)];
-      std::string processed_name =
-          thread_mode == SingleThreadTaskRunnerThreadMode::DEDICATED
-              ? name + environment_params.name_suffix
-              : "Shared" + name + environment_params.name_suffix;
+      std::string worker_name;
+      if (thread_mode == SingleThreadTaskRunnerThreadMode::SHARED)
+        worker_name += "Shared";
+      worker_name += environment_params.name_suffix;
       worker = CreateAndRegisterSchedulerWorker<DelegateType>(
-          processed_name, environment_params.priority_hint);
+          worker_name, environment_params.priority_hint);
       new_worker = true;
     }
     started = started_;