Convert //base to use std::unique_ptr

base/profiler/stack_sampling_profiler.h

 // 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.
 
 #ifndef BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
 #define BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 
 namespace base {
 
 class NativeStackSampler;
 class NativeStackSamplerTestDelegate;
 
@@ skipping 162 matching lines @@
   void Stop();
 
  private:
   // SamplingThread is a separate thread used to suspend and sample stacks from
   // the target thread.
   class SamplingThread : public PlatformThread::Delegate {
    public:
     // Samples stacks using |native_sampler|. When complete, invokes
     // |completed_callback| with the collected call stack profiles.
     // |completed_callback| must be callable on any thread.
-    SamplingThread(scoped_ptr<NativeStackSampler> native_sampler,
+    SamplingThread(std::unique_ptr<NativeStackSampler> native_sampler,
                    const SamplingParams& params,
                    const CompletedCallback& completed_callback);
     ~SamplingThread() override;
 
     // PlatformThread::Delegate:
     void ThreadMain() override;
 
     void Stop();
 
    private:
     // Collects |profile| from a single burst. If the profiler was stopped
     // during collection, sets |was_stopped| and provides the set of samples
     // collected up to that point.
     void CollectProfile(CallStackProfile* profile, TimeDelta* elapsed_time,
                         bool* was_stopped);
 
     // Collects call stack profiles from all bursts, or until the sampling is
     // stopped. If stopped before complete, the last profile in
     // |call_stack_profiles| may contain a partial burst.
     void CollectProfiles(CallStackProfiles* profiles);
 
-    scoped_ptr<NativeStackSampler> native_sampler_;
+    std::unique_ptr<NativeStackSampler> native_sampler_;
     const SamplingParams params_;
 
     // If Stop() is called, it signals this event to force the sampling to
     // terminate before all the samples specified in |params_| are collected.
     WaitableEvent stop_event_;
 
     const CompletedCallback completed_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(SamplingThread);
   };
 
   // The thread whose stack will be sampled.
   PlatformThreadId thread_id_;
 
   const SamplingParams params_;
 
-  scoped_ptr<SamplingThread> sampling_thread_;
+  std::unique_ptr<SamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   const CompletedCallback completed_callback_;
 
   // Stored until it can be passed to the NativeStackSampler created in Start().
   NativeStackSamplerTestDelegate* const test_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(StackSamplingProfiler);
 };
 
 // The metrics provider code wants to put Samples in a map and compare them,
 // which requires us to define a few operators.
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Frame& a,
                             const StackSamplingProfiler::Frame& b);
 BASE_EXPORT bool operator<(const StackSamplingProfiler::Frame& a,
                            const StackSamplingProfiler::Frame& b);
 
 }  // namespace base
 
 #endif  // BASE_PROFILER_STACK_SAMPLING_PROFILER_H_