Convert //base to use std::unique_ptr

base/message_loop/message_pump_perftest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/perf/perf_test.h"
@@ skipping 60 matching lines @@
       target_->StartWithOptions(Thread::Options(target_type, 0u));
 
       // Without this, it's possible for the scheduling threads to start and run
       // before the target thread. In this case, the scheduling threads will
       // call target_message_loop()->ScheduleWork(), which dereferences the
       // loop's message pump, which is only created after the target thread has
       // finished starting.
       target_->WaitUntilThreadStarted();
     }
 
-    std::vector<scoped_ptr<Thread>> scheduling_threads;
+    std::vector<std::unique_ptr<Thread>> scheduling_threads;
     scheduling_times_.reset(new base::TimeDelta[num_scheduling_threads]);
     scheduling_thread_times_.reset(new base::TimeDelta[num_scheduling_threads]);
     min_batch_times_.reset(new base::TimeDelta[num_scheduling_threads]);
     max_batch_times_.reset(new base::TimeDelta[num_scheduling_threads]);
 
     for (int i = 0; i < num_scheduling_threads; ++i) {
       scheduling_threads.push_back(
-          make_scoped_ptr(new Thread("posting thread")));
+          WrapUnique(new Thread("posting thread")));
       scheduling_threads[i]->Start();
     }
 
     for (int i = 0; i < num_scheduling_threads; ++i) {
       scheduling_threads[i]->message_loop()->PostTask(
           FROM_HERE,
           base::Bind(&ScheduleWorkTest::Schedule, base::Unretained(this), i));
     }
 
     for (int i = 0; i < num_scheduling_threads; ++i) {
@@ skipping 59 matching lines @@
 
   MessageLoop* target_message_loop() {
 #if defined(OS_ANDROID)
     if (java_thread_)
       return java_thread_->message_loop();
 #endif
     return target_->message_loop();
   }
 
  private:
-  scoped_ptr<Thread> target_;
+  std::unique_ptr<Thread> target_;
 #if defined(OS_ANDROID)
-  scoped_ptr<android::JavaHandlerThread> java_thread_;
+  std::unique_ptr<android::JavaHandlerThread> java_thread_;
 #endif
-  scoped_ptr<base::TimeDelta[]> scheduling_times_;
-  scoped_ptr<base::TimeDelta[]> scheduling_thread_times_;
-  scoped_ptr<base::TimeDelta[]> min_batch_times_;
-  scoped_ptr<base::TimeDelta[]> max_batch_times_;
+  std::unique_ptr<base::TimeDelta[]> scheduling_times_;
+  std::unique_ptr<base::TimeDelta[]> scheduling_thread_times_;
+  std::unique_ptr<base::TimeDelta[]> min_batch_times_;
+  std::unique_ptr<base::TimeDelta[]> max_batch_times_;
   uint64_t counter_;
 
   static const size_t kTargetTimeSec = 5;
   static const size_t kBatchSize = 1000;
 };
 
 TEST_F(ScheduleWorkTest, ThreadTimeToIOFromOneThread) {
   ScheduleWork(MessageLoop::TYPE_IO, 1);
 }
 
@@ skipping 53 matching lines @@
   void Quit() override {}
   void ScheduleWork() override {}
   void ScheduleDelayedWork(const TimeTicks& delayed_work_time) override {}
 };
 
 class PostTaskTest : public testing::Test {
  public:
   void Run(int batch_size, int tasks_per_reload) {
     base::TimeTicks start = base::TimeTicks::Now();
     base::TimeTicks now;
-    MessageLoop loop(scoped_ptr<MessagePump>(new FakeMessagePump));
+    MessageLoop loop(std::unique_ptr<MessagePump>(new FakeMessagePump));
     scoped_refptr<internal::IncomingTaskQueue> queue(
         new internal::IncomingTaskQueue(&loop));
     uint32_t num_posted = 0;
     do {
       for (int i = 0; i < batch_size; ++i) {
         for (int j = 0; j < tasks_per_reload; ++j) {
           queue->AddToIncomingQueue(
               FROM_HERE, base::Bind(&DoNothing), base::TimeDelta(), false);
           num_posted++;
         }
@@ skipping 25 matching lines @@
 
 TEST_F(PostTaskTest, TenTasksPerReload) {
   Run(10000, 10);
 }
 
 TEST_F(PostTaskTest, OneHundredTasksPerReload) {
   Run(1000, 100);
 }
 
 }  // namespace base