Convert //base to use std::unique_ptr

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 <memory>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/task_scheduler/test_utils.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
@@ skipping 37 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ThreadRunningTask);
 };
 
 class TaskSchedulerTaskTrackerTest
     : public testing::TestWithParam<TaskShutdownBehavior> {
  protected:
   TaskSchedulerTaskTrackerTest() = default;
 
   // Creates a task with |shutdown_behavior|.
-  scoped_ptr<Task> CreateTask(TaskShutdownBehavior shutdown_behavior) {
-    return make_scoped_ptr(new Task(
+  std::unique_ptr<Task> CreateTask(TaskShutdownBehavior shutdown_behavior) {
+    return base::WrapUnique(new Task(
         FROM_HERE,
         Bind(&TaskSchedulerTaskTrackerTest::RunTaskCallback, Unretained(this)),
         TaskTraits().WithShutdownBehavior(shutdown_behavior)));
   }
 
   // Tries to post |task| via |tracker_|. If |tracker_| approves the operation,
   // |task| is added to |posted_tasks_|.
-  void PostTaskViaTracker(scoped_ptr<Task> task) {
+  void PostTaskViaTracker(std::unique_ptr<Task> task) {
     tracker_.PostTask(
         Bind(&TaskSchedulerTaskTrackerTest::PostTaskCallback, Unretained(this)),
         std::move(task));
   }
 
   // Tries to run the next task in |posted_tasks_| via |tracker_|.
   void RunNextPostedTaskViaTracker() {
     ASSERT_FALSE(posted_tasks_.empty());
     tracker_.RunTask(posted_tasks_.front().get());
     posted_tasks_.pop();
@@ skipping 21 matching lines @@
 
   void VerifyAsyncShutdownInProgress() {
     ASSERT_TRUE(thread_calling_shutdown_);
     EXPECT_FALSE(thread_calling_shutdown_->has_returned());
     EXPECT_FALSE(tracker_.shutdown_completed());
     EXPECT_TRUE(tracker_.IsShuttingDownForTesting());
   }
 
   TaskTracker tracker_;
   size_t num_tasks_executed_ = 0;
-  std::queue<scoped_ptr<Task>> posted_tasks_;
+  std::queue<std::unique_ptr<Task>> posted_tasks_;
 
  private:
-  void PostTaskCallback(scoped_ptr<Task> task) {
+  void PostTaskCallback(std::unique_ptr<Task> task) {
     posted_tasks_.push(std::move(task));
   }
 
   void RunTaskCallback() { ++num_tasks_executed_; }
 
-  scoped_ptr<ThreadCallingShutdown> thread_calling_shutdown_;
+  std::unique_ptr<ThreadCallingShutdown> thread_calling_shutdown_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerTaskTrackerTest);
 };
 
 #define WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED() \
   do {                                      \
     SCOPED_TRACE("");                       \
     WaitForAsyncShutdownCompleted();        \
   } while (false)
 
 #define VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS() \
   do {                                      \
     SCOPED_TRACE("");                       \
     VerifyAsyncShutdownInProgress();        \
   } while (false)
 
 }  // namespace
 
 TEST_P(TaskSchedulerTaskTrackerTest, PostAndRunBeforeShutdown) {
-  scoped_ptr<Task> task_to_post(CreateTask(GetParam()));
+  std::unique_ptr<Task> task_to_post(CreateTask(GetParam()));
   const Task* task_to_post_raw = task_to_post.get();
 
   // Post the task.
   EXPECT_TRUE(posted_tasks_.empty());
   PostTaskViaTracker(std::move(task_to_post));
   EXPECT_EQ(1U, posted_tasks_.size());
   EXPECT_EQ(task_to_post_raw, posted_tasks_.front().get());
 
   // Run the posted task.
   EXPECT_EQ(0U, num_tasks_executed_);
   RunNextPostedTaskViaTracker();
   EXPECT_EQ(1U, num_tasks_executed_);
 
   // Shutdown() shouldn't block.
   tracker_.Shutdown();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, PostAndRunLongTaskBeforeShutdown) {
   // Post a task that will block until |event| is signaled.
   EXPECT_TRUE(posted_tasks_.empty());
   WaitableEvent event(false, false);
-  PostTaskViaTracker(make_scoped_ptr(
+  PostTaskViaTracker(base::WrapUnique(
       new Task(FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
                TaskTraits().WithShutdownBehavior(GetParam()))));
   EXPECT_EQ(1U, posted_tasks_.size());
 
   // Run the task asynchronouly.
   ThreadRunningTask thread_running_task(&tracker_, posted_tasks_.front().get());
   thread_running_task.Start();
 
   // Initiate shutdown while the task is running.
   CallShutdownAsync();
 
   if (GetParam() == TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN) {
     // Shutdown should complete even with a CONTINUE_ON_SHUTDOWN in progress.
     WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
   } else {
     // Shutdown should block with any non CONTINUE_ON_SHUTDOWN task in progress.
     VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
   }
 
   // Unblock the task.
   event.Signal();
   thread_running_task.Join();
 
   // Shutdown should now complete for a non CONTINUE_ON_SHUTDOWN task.
   if (GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
     WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, PostBeforeShutdownRunDuringShutdown) {
-  scoped_ptr<Task> task_to_post(CreateTask(GetParam()));
+  std::unique_ptr<Task> task_to_post(CreateTask(GetParam()));
   const Task* task_to_post_raw = task_to_post.get();
 
   // Post the task.
   EXPECT_TRUE(posted_tasks_.empty());
   PostTaskViaTracker(std::move(task_to_post));
   EXPECT_EQ(1U, posted_tasks_.size());
   EXPECT_EQ(task_to_post_raw, posted_tasks_.front().get());
 
   // Post a BLOCK_SHUTDOWN task just to block shutdown.
   PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
@@ skipping 11 matching lines @@
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
   // Unblock shutdown by running the remaining BLOCK_SHUTDOWN task.
   RunNextPostedTaskViaTracker();
   EXPECT_EQ(GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN ? 2U : 1U,
             num_tasks_executed_);
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, PostBeforeShutdownRunAfterShutdown) {
-  scoped_ptr<Task> task_to_post(CreateTask(GetParam()));
+  std::unique_ptr<Task> task_to_post(CreateTask(GetParam()));
   const Task* task_to_post_raw = task_to_post.get();
 
   // Post the task.
   EXPECT_TRUE(posted_tasks_.empty());
   PostTaskViaTracker(std::move(task_to_post));
   EXPECT_EQ(1U, posted_tasks_.size());
   EXPECT_EQ(task_to_post_raw, posted_tasks_.front().get());
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
@@ skipping 15 matching lines @@
 
     // The task shouldn't be allowed to run after shutdown.
     RunNextPostedTaskViaTracker();
     EXPECT_EQ(0U, num_tasks_executed_);
   }
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, PostAndRunDuringShutdown) {
   // Post a BLOCK_SHUTDOWN task just to block shutdown.
   PostTaskViaTracker(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
-  scoped_ptr<Task> block_shutdown_task = std::move(posted_tasks_.front());
+  std::unique_ptr<Task> block_shutdown_task = std::move(posted_tasks_.front());
   posted_tasks_.pop();
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
   if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {
     // Post a BLOCK_SHUTDOWN task. This should succeed.
     EXPECT_TRUE(posted_tasks_.empty());
     PostTaskViaTracker(CreateTask(GetParam()));
@@ skipping 42 matching lines @@
     SkipOnShutdown,
     TaskSchedulerTaskTrackerTest,
     ::testing::Values(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
 INSTANTIATE_TEST_CASE_P(
     BlockShutdown,
     TaskSchedulerTaskTrackerTest,
     ::testing::Values(TaskShutdownBehavior::BLOCK_SHUTDOWN));
 
 }  // namespace internal
 }  // namespace base