Convert //base to use std::unique_ptr

base/profiler/stack_sampling_profiler.cc

 // Copyright 2015 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/profiler/stack_sampling_profiler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
   // callback.
   static void Run(PlatformThreadId thread_id,
                   const StackSamplingProfiler::SamplingParams& params,
                   const StackSamplingProfiler::CompletedCallback& callback);
 
  private:
   AsyncRunner();
 
   // Runs the callback and deletes the AsyncRunner instance.
   static void RunCallbackAndDeleteInstance(
-      scoped_ptr<AsyncRunner> object_to_be_deleted,
+      std::unique_ptr<AsyncRunner> object_to_be_deleted,
       const StackSamplingProfiler::CompletedCallback& callback,
       scoped_refptr<SingleThreadTaskRunner> task_runner,
       const StackSamplingProfiler::CallStackProfiles& profiles);
 
-  scoped_ptr<StackSamplingProfiler> profiler_;
+  std::unique_ptr<StackSamplingProfiler> profiler_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncRunner);
 };
 
 // static
 void AsyncRunner::Run(
     PlatformThreadId thread_id,
     const StackSamplingProfiler::SamplingParams& params,
     const StackSamplingProfiler::CompletedCallback &callback) {
-  scoped_ptr<AsyncRunner> runner(new AsyncRunner);
+  std::unique_ptr<AsyncRunner> runner(new AsyncRunner);
   AsyncRunner* temp_ptr = runner.get();
   temp_ptr->profiler_.reset(
       new StackSamplingProfiler(thread_id, params,
                                 Bind(&AsyncRunner::RunCallbackAndDeleteInstance,
                                      Passed(&runner), callback,
                                      ThreadTaskRunnerHandle::Get())));
   // The callback won't be called until after Start(), so temp_ptr will still
   // be valid here.
   temp_ptr->profiler_->Start();
 }
 
 AsyncRunner::AsyncRunner() {}
 
 void AsyncRunner::RunCallbackAndDeleteInstance(
-    scoped_ptr<AsyncRunner> object_to_be_deleted,
+    std::unique_ptr<AsyncRunner> object_to_be_deleted,
     const StackSamplingProfiler::CompletedCallback& callback,
     scoped_refptr<SingleThreadTaskRunner> task_runner,
     const StackSamplingProfiler::CallStackProfiles& profiles) {
   callback.Run(profiles);
   // Delete the instance on the original calling thread.
   task_runner->DeleteSoon(FROM_HERE, object_to_be_deleted.release());
 }
 
 }  // namespace
 
@@ skipping 22 matching lines @@
 StackSamplingProfiler::CallStackProfile::CallStackProfile() {}
 
 StackSamplingProfiler::CallStackProfile::CallStackProfile(
     const CallStackProfile& other) = default;
 
 StackSamplingProfiler::CallStackProfile::~CallStackProfile() {}
 
 // StackSamplingProfiler::SamplingThread --------------------------------------
 
 StackSamplingProfiler::SamplingThread::SamplingThread(
-    scoped_ptr<NativeStackSampler> native_sampler,
+    std::unique_ptr<NativeStackSampler> native_sampler,
     const SamplingParams& params,
     const CompletedCallback& completed_callback)
     : native_sampler_(std::move(native_sampler)),
       params_(params),
       stop_event_(false, false),
       completed_callback_(completed_callback) {}
 
 StackSamplingProfiler::SamplingThread::~SamplingThread() {}
 
 void StackSamplingProfiler::SamplingThread::ThreadMain() {
@@ skipping 119 matching lines @@
     const SamplingParams& params,
     const CompletedCallback& callback) {
   CHECK(ThreadTaskRunnerHandle::Get());
   AsyncRunner::Run(thread_id, params, callback);
 }
 
 void StackSamplingProfiler::Start() {
   if (completed_callback_.is_null())
     return;
 
-  scoped_ptr<NativeStackSampler> native_sampler =
+  std::unique_ptr<NativeStackSampler> native_sampler =
       NativeStackSampler::Create(thread_id_, test_delegate_);
   if (!native_sampler)
     return;
 
   sampling_thread_.reset(new SamplingThread(std::move(native_sampler), params_,
                                             completed_callback_));
   if (!PlatformThread::Create(0, sampling_thread_.get(),
                               &sampling_thread_handle_))
     sampling_thread_.reset();
 }
@@ skipping 12 matching lines @@
 }
 
 bool operator<(const StackSamplingProfiler::Frame &a,
                const StackSamplingProfiler::Frame &b) {
   return (a.module_index < b.module_index) ||
       (a.module_index == b.module_index &&
        a.instruction_pointer < b.instruction_pointer);
 }
 
 }  // namespace base