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

base/task_scheduler/task_tracker_unittest.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/task_tracker.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
@@ skipping 109 matching lines @@
   const bool previous_value_;
 };
 
 class TaskSchedulerTaskTrackerTest
     : public testing::TestWithParam<TaskShutdownBehavior> {
  protected:
   TaskSchedulerTaskTrackerTest() = default;
 
   // Creates a task with |shutdown_behavior|.
   std::unique_ptr<Task> CreateTask(TaskShutdownBehavior shutdown_behavior) {
-    return WrapUnique(new Task(
+    return MakeUnique<Task>(
         FROM_HERE,
         Bind(&TaskSchedulerTaskTrackerTest::RunTaskCallback, Unretained(this)),
-        TaskTraits().WithShutdownBehavior(shutdown_behavior), TimeDelta()));
+        TaskTraits().WithShutdownBehavior(shutdown_behavior), TimeDelta());
   }
 
   // Calls tracker_->Shutdown() on a new thread. When this returns, Shutdown()
   // method has been entered on the new thread, but it hasn't necessarily
   // returned.
   void CallShutdownAsync() {
     ASSERT_FALSE(thread_calling_shutdown_);
     thread_calling_shutdown_.reset(new ThreadCallingShutdown(&tracker_));
     thread_calling_shutdown_->Start();
     while (!tracker_.HasShutdownStarted())
@@ skipping 361 matching lines @@
   EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
   tracker_.RunNextTaskInSequence(sequence.get());
   EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
 }
 
 TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunBeforeShutdown) {
   // Post and run tasks asynchronously.
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> threads;
 
   for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
-    threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, CreateSequenceWithTask(
                        CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)),
-        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true)));
+        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
 
-    threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, CreateSequenceWithTask(
                        CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN)),
-        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true)));
+        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
 
-    threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, CreateSequenceWithTask(
                        CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN)),
-        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true)));
+        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
   }
 
   for (const auto& thread : threads)
     thread->Join();
 
   // Expect all tasks to be executed.
   EXPECT_EQ(kLoadTestNumIterations * 3, NumTasksExecuted());
 
   // Should return immediately because no tasks are blocking shutdown.
   tracker_.Shutdown();
 }
 
 TEST_F(TaskSchedulerTaskTrackerTest,
        LoadWillPostBeforeShutdownAndRunDuringShutdown) {
   // Post tasks asynchronously.
   std::vector<scoped_refptr<Sequence>> sequences;
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> post_threads;
 
   for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
     sequences.push_back(CreateSequenceWithTask(
         CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)));
-    post_threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    post_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, sequences.back(),
-        ThreadPostingAndRunningTask::Action::WILL_POST, true)));
+        ThreadPostingAndRunningTask::Action::WILL_POST, true));
     post_threads.back()->Start();
 
     sequences.push_back(CreateSequenceWithTask(
         CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN)));
-    post_threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    post_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, sequences.back(),
-        ThreadPostingAndRunningTask::Action::WILL_POST, true)));
+        ThreadPostingAndRunningTask::Action::WILL_POST, true));
     post_threads.back()->Start();
 
     sequences.push_back(CreateSequenceWithTask(
         CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN)));
-    post_threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    post_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, sequences.back(),
-        ThreadPostingAndRunningTask::Action::WILL_POST, true)));
+        ThreadPostingAndRunningTask::Action::WILL_POST, true));
     post_threads.back()->Start();
   }
 
   for (const auto& thread : post_threads)
     thread->Join();
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
 
   // Run tasks asynchronously.
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> run_threads;
 
   for (const auto& sequence : sequences) {
-    run_threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
-        &tracker_, sequence, ThreadPostingAndRunningTask::Action::RUN, false)));
+    run_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
+        &tracker_, sequence, ThreadPostingAndRunningTask::Action::RUN, false));
     run_threads.back()->Start();
   }
 
   for (const auto& thread : run_threads)
     thread->Join();
 
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 
   // Expect BLOCK_SHUTDOWN tasks to have been executed.
   EXPECT_EQ(kLoadTestNumIterations, NumTasksExecuted());
 }
 
 TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunDuringShutdown) {
   // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted just to
   // block shutdown.
   std::unique_ptr<Task> block_shutdown_task(
       CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
   EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task.get()));
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
 
   // Post and run tasks asynchronously.
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> threads;
 
   for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
-    threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, CreateSequenceWithTask(
                        CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)),
-        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false)));
+        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));
     threads.back()->Start();
 
-    threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, CreateSequenceWithTask(
                        CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN)),
-        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false)));
+        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));
     threads.back()->Start();
 
-    threads.push_back(WrapUnique(new ThreadPostingAndRunningTask(
+    threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
         &tracker_, CreateSequenceWithTask(
                        CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN)),
-        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true)));
+        ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
   }
 
   for (const auto& thread : threads)
     thread->Join();
 
   // Expect BLOCK_SHUTDOWN tasks to have been executed.
   EXPECT_EQ(kLoadTestNumIterations, NumTasksExecuted());
 
   // Shutdown() shouldn't return before |block_shutdown_task| is executed.
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
   // Unblock shutdown by running |block_shutdown_task|.
   tracker_.RunNextTaskInSequence(
       CreateSequenceWithTask(std::move(block_shutdown_task)).get());
   EXPECT_EQ(kLoadTestNumIterations + 1, NumTasksExecuted());
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 }  // namespace internal
 }  // namespace base