Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/devtools/v8_sampling_profiler.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 "content/renderer/devtools/v8_sampling_profiler.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include "base/format_macros.h"
@@ skipping 88 matching lines @@
  public:
   static const int kMaxFramesCountLog2 = 8;
   static const unsigned kMaxFramesCount = (1u << kMaxFramesCountLog2) - 1;
 
   SampleRecord() {}
 
   base::TimeTicks timestamp() const { return timestamp_; }
   void Collect(v8::Isolate* isolate,
                base::TimeTicks timestamp,
                const v8::RegisterState& state);
-  scoped_ptr<ConvertableToTraceFormat> ToTraceFormat() const;
+  std::unique_ptr<ConvertableToTraceFormat> ToTraceFormat() const;
 
  private:
   base::TimeTicks timestamp_;
   unsigned vm_state_ : 4;
   unsigned frames_count_ : kMaxFramesCountLog2;
   const void* frames_[kMaxFramesCount];
 
   DISALLOW_COPY_AND_ASSIGN(SampleRecord);
 };
 
 void SampleRecord::Collect(v8::Isolate* isolate,
                            base::TimeTicks timestamp,
                            const v8::RegisterState& state) {
   v8::SampleInfo sample_info;
   isolate->GetStackSample(state, (void**)frames_, kMaxFramesCount,
                           &sample_info);
   timestamp_ = timestamp;
   frames_count_ = sample_info.frames_count;
   vm_state_ = sample_info.vm_state;
 }
 
-scoped_ptr<ConvertableToTraceFormat> SampleRecord::ToTraceFormat() const {
-  scoped_ptr<base::trace_event::TracedValue> data(
+std::unique_ptr<ConvertableToTraceFormat> SampleRecord::ToTraceFormat() const {
+  std::unique_ptr<base::trace_event::TracedValue> data(
       new base::trace_event::TracedValue());
   const char* vm_state = nullptr;
   switch (vm_state_) {
     case v8::StateTag::JS:
       vm_state = "js";
       break;
     case v8::StateTag::GC:
       vm_state = "gc";
       break;
     case v8::StateTag::COMPILER:
@@ skipping 20 matching lines @@
   return std::move(data);
 }
 
 }  // namespace
 
 // The class implements a sampler responsible for sampling a single thread.
 class Sampler {
  public:
   ~Sampler();
 
-  static scoped_ptr<Sampler> CreateForCurrentThread();
+  static std::unique_ptr<Sampler> CreateForCurrentThread();
   static Sampler* GetInstance() { return tls_instance_.Pointer()->Get(); }
 
   // These methods are called from the sampling thread.
   void Start();
   void Stop();
   void Sample();
 
   void DoSample(const v8::RegisterState& state);
 
   void SetEventsToCollectForTest(int code_added_events, int sample_events) {
     code_added_events_to_collect_for_test_ = code_added_events;
     sample_events_to_collect_for_test_ = sample_events;
   }
 
   bool EventsCollectedForTest() const {
     return base::subtle::NoBarrier_Load(&code_added_events_count_) >=
                code_added_events_to_collect_for_test_ &&
            base::subtle::NoBarrier_Load(&samples_count_) >=
                sample_events_to_collect_for_test_;
   }
 
  private:
   Sampler();
 
   static void InstallJitCodeEventHandler(Isolate* isolate, void* data);
   static void HandleJitCodeEvent(const v8::JitCodeEvent* event);
-  static scoped_ptr<ConvertableToTraceFormat> JitCodeEventToTraceFormat(
+  static std::unique_ptr<ConvertableToTraceFormat> JitCodeEventToTraceFormat(
       const v8::JitCodeEvent* event);
 
   void InjectPendingEvents();
 
   static const unsigned kNumberOfSamples = 10;
   typedef LockFreeCircularQueue<SampleRecord, kNumberOfSamples> SamplingQueue;
 
   PlatformData platform_data_;
   Isolate* isolate_;
-  scoped_ptr<SamplingQueue> samples_data_;
+  std::unique_ptr<SamplingQueue> samples_data_;
   base::subtle::Atomic32 code_added_events_count_;
   base::subtle::Atomic32 samples_count_;
   int code_added_events_to_collect_for_test_;
   int sample_events_to_collect_for_test_;
 
   static base::LazyInstance<base::ThreadLocalPointer<Sampler>>::Leaky
       tls_instance_;
 };
 
 base::LazyInstance<base::ThreadLocalPointer<Sampler>>::Leaky
     Sampler::tls_instance_ = LAZY_INSTANCE_INITIALIZER;
 
 Sampler::Sampler()
     : isolate_(Isolate::GetCurrent()),
       code_added_events_count_(0),
       samples_count_(0),
       code_added_events_to_collect_for_test_(0),
       sample_events_to_collect_for_test_(0) {
   DCHECK(isolate_);
   DCHECK(!GetInstance());
   tls_instance_.Pointer()->Set(this);
 }
 
 Sampler::~Sampler() {
   DCHECK(GetInstance());
   tls_instance_.Pointer()->Set(nullptr);
 }
 
 // static
-scoped_ptr<Sampler> Sampler::CreateForCurrentThread() {
-  return scoped_ptr<Sampler>(new Sampler());
+std::unique_ptr<Sampler> Sampler::CreateForCurrentThread() {
+  return std::unique_ptr<Sampler>(new Sampler());
 }
 
 void Sampler::Start() {
   samples_data_.reset(new SamplingQueue());
   v8::JitCodeEventHandler handler = &HandleJitCodeEvent;
   isolate_->RequestInterrupt(&InstallJitCodeEventHandler,
                              reinterpret_cast<void*>(handler));
 }
 
 void Sampler::Stop() {
@@ skipping 101 matching lines @@
       break;
 
     case v8::JitCodeEvent::CODE_ADD_LINE_POS_INFO:
     case v8::JitCodeEvent::CODE_START_LINE_INFO_RECORDING:
     case v8::JitCodeEvent::CODE_END_LINE_INFO_RECORDING:
       break;
   }
 }
 
 // static
-scoped_ptr<ConvertableToTraceFormat> Sampler::JitCodeEventToTraceFormat(
+std::unique_ptr<ConvertableToTraceFormat> Sampler::JitCodeEventToTraceFormat(
     const v8::JitCodeEvent* event) {
   switch (event->type) {
     case v8::JitCodeEvent::CODE_ADDED: {
-      scoped_ptr<base::trace_event::TracedValue> data(
+      std::unique_ptr<base::trace_event::TracedValue> data(
           new base::trace_event::TracedValue());
       data->SetString("code_start", PtrToString(event->code_start));
       data->SetInteger("code_len", static_cast<unsigned>(event->code_len));
       data->SetString("name", std::string(event->name.str, event->name.len));
       if (!event->script.IsEmpty()) {
         data->SetInteger("script_id", event->script->GetId());
       }
       return std::move(data);
     }
 
     case v8::JitCodeEvent::CODE_MOVED: {
-      scoped_ptr<base::trace_event::TracedValue> data(
+      std::unique_ptr<base::trace_event::TracedValue> data(
           new base::trace_event::TracedValue());
       data->SetString("code_start", PtrToString(event->code_start));
       data->SetInteger("code_len", static_cast<unsigned>(event->code_len));
       data->SetString("new_code_start", PtrToString(event->new_code_start));
       return std::move(data);
     }
 
     case v8::JitCodeEvent::CODE_REMOVED: {
-      scoped_ptr<base::trace_event::TracedValue> data(
+      std::unique_ptr<base::trace_event::TracedValue> data(
           new base::trace_event::TracedValue());
       data->SetString("code_start", PtrToString(event->code_start));
       data->SetInteger("code_len", static_cast<unsigned>(event->code_len));
       return std::move(data);
     }
 
     case v8::JitCodeEvent::CODE_ADD_LINE_POS_INFO:
     case v8::JitCodeEvent::CODE_START_LINE_INFO_RECORDING:
     case v8::JitCodeEvent::CODE_END_LINE_INFO_RECORDING:
       return nullptr;
@@ skipping 241 matching lines @@
   render_thread_sampler_->SetEventsToCollectForTest(code_added_events,
                                                     sample_events);
   waitable_event_for_testing_.reset(new base::WaitableEvent(false, false));
 }
 
 void V8SamplingProfiler::WaitSamplingEventForTesting() {
   waitable_event_for_testing_->Wait();
 }
 
 }  // namespace content