Convert //base to use std::unique_ptr

base/task_scheduler/scheduler_worker_thread_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/scheduler_worker_thread.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/task_scheduler/scheduler_lock.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 namespace {
@@ skipping 66 matching lines @@
     AutoSchedulerLock auto_lock(lock_);
     EXPECT_EQ(0U, num_sequences_to_create_);
     num_sequences_to_create_ = num_sequences_to_create;
   }
 
   size_t NumGetWorkCallback() const {
     AutoSchedulerLock auto_lock(lock_);
     return num_get_work_callback_;
   }
 
-  scoped_ptr<SchedulerWorkerThread> worker_thread_;
+  std::unique_ptr<SchedulerWorkerThread> worker_thread_;
 
  private:
   void MainEntryCallback() {
     AutoSchedulerLock auto_lock(lock_);
     ++num_main_entry_callback_;
     num_main_entry_callback_cv_->Signal();
   }
 
   // Returns a Sequence that contains 1 Task if |num_sequences_to_create_| is
   // greater than 0.
@@ skipping 11 matching lines @@
       // Check if a Sequence should be returned.
       if (num_sequences_to_create_ == 0)
         return nullptr;
       --num_sequences_to_create_;
     }
 
     // Create a Sequence that contains 1 Task.
     scoped_refptr<Sequence> sequence(new Sequence);
     task_tracker_.PostTask(
         Bind(IgnoreResult(&Sequence::PushTask), Unretained(sequence.get())),
-        make_scoped_ptr(new Task(
+        base::WrapUnique(new Task(
             FROM_HERE, Bind(&TaskSchedulerWorkerThreadTest::RunTaskCallback,
                             Unretained(this)),
             TaskTraits())));
 
     {
       // Add the Sequence to the vector of created Sequences.
       AutoSchedulerLock auto_lock(lock_);
       created_sequences_.push_back(sequence);
     }
 
@@ skipping 16 matching lines @@
 
   TaskTracker task_tracker_;
 
   // Synchronizes access to all members below.
   mutable SchedulerLock lock_;
 
   // Number of times that MainEntryCallback() has been called.
   size_t num_main_entry_callback_ = 0;
 
   // Condition variable signaled when |num_main_entry_callback_| is incremented.
-  scoped_ptr<ConditionVariable> num_main_entry_callback_cv_;
+  std::unique_ptr<ConditionVariable> num_main_entry_callback_cv_;
 
   // Number of Sequences that should be created by GetWorkCallback(). When this
   // is 0, GetWorkCallback() returns nullptr.
   size_t num_sequences_to_create_ = 0;
 
   // Number of times that GetWorkCallback() has been called.
   size_t num_get_work_callback_ = 0;
 
   // Condition variable signaled when |num_get_work_callback_| is incremented.
-  scoped_ptr<ConditionVariable> num_get_work_callback_cv_;
+  std::unique_ptr<ConditionVariable> num_get_work_callback_cv_;
 
   // Sequences created by GetWorkCallback().
   std::vector<scoped_refptr<Sequence>> created_sequences_;
 
   // Sequences passed to RanTaskFromSequenceCallback().
   std::vector<scoped_refptr<Sequence>> run_sequences_;
 
   // Condition variable signaled when a Sequence is added to |run_sequences_|.
-  scoped_ptr<ConditionVariable> run_sequences_cv_;
+  std::unique_ptr<ConditionVariable> run_sequences_cv_;
 
   // Number of times that RunTaskCallback() has been called.
   size_t num_run_tasks_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerThreadTest);
 };
 
 // Verify that when GetWorkCallback() continuously returns Sequences, all Tasks
 // in these Sequences run successfully. The SchedulerWorkerThread is woken up
 // once.
@@ skipping 32 matching lines @@
     // |i| calls in which it returned nullptr.
     const size_t expected_num_get_work_callback = 2 * (i + 1);
     WaitForNumGetWorkCallback(expected_num_get_work_callback);
     EXPECT_EQ(expected_num_get_work_callback, NumGetWorkCallback());
   }
 }
 
 }  // namespace
 }  // namespace internal
 }  // namespace base