Re-write many calls to WrapUnique() with MakeUnique()

base/task_scheduler/scheduler_worker_pool_impl.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/task_scheduler/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 43 matching lines @@
       : traits_(traits), worker_pool_(worker_pool) {
     DCHECK(worker_pool_);
   }
 
   // TaskRunner:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const Closure& closure,
                        TimeDelta delay) override {
     // Post the task as part of a one-off single-task Sequence.
     return worker_pool_->PostTaskWithSequence(
-        WrapUnique(new Task(from_here, closure, traits_, delay)),
+        MakeUnique<Task>(from_here, closure, traits_, delay),
         make_scoped_refptr(new Sequence), nullptr);
   }
 
   bool RunsTasksOnCurrentThread() const override {
     return tls_current_worker_pool.Get().Get() == worker_pool_;
   }
 
  private:
   ~SchedulerParallelTaskRunner() override = default;
 
@@ skipping 561 matching lines @@
 bool SchedulerWorkerPoolImpl::Initialize(
     ThreadPriority priority_hint,
     size_t max_threads,
     const ReEnqueueSequenceCallback& re_enqueue_sequence_callback) {
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
 
   DCHECK(workers_.empty());
 
   for (size_t i = 0; i < max_threads; ++i) {
     std::unique_ptr<SchedulerWorker> worker = SchedulerWorker::Create(
-        priority_hint, WrapUnique(new SchedulerWorkerDelegateImpl(
+        priority_hint, MakeUnique<SchedulerWorkerDelegateImpl>(
                            this, re_enqueue_sequence_callback,
-                           &shared_priority_queue_, static_cast<int>(i))),
+                           &shared_priority_queue_, static_cast<int>(i)),
         task_tracker_, i == 0 ? SchedulerWorker::InitialState::ALIVE
                               : SchedulerWorker::InitialState::DETACHED);
     if (!worker)
       break;
     idle_workers_stack_.Push(worker.get());
     workers_.push_back(std::move(worker));
   }
 
 #if DCHECK_IS_ON()
   workers_created_.Signal();
@@ skipping 38 matching lines @@
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   idle_workers_stack_.Remove(worker);
 }
 
 bool SchedulerWorkerPoolImpl::CanWorkerDetachForTesting() {
   return !worker_detachment_disallowed_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base