tracing: Make ConvertableToTraceFormat move-only scoped_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_refptr<ConvertableToTraceFormat> ToTraceFormat() const;
+  scoped_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_refptr<ConvertableToTraceFormat> SampleRecord::ToTraceFormat() const {
-  scoped_refptr<TracedValue> data(new TracedValue());
+scoped_ptr<ConvertableToTraceFormat> SampleRecord::ToTraceFormat() const {
+  scoped_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:
       vm_state = "compiler";
       break;
     case v8::StateTag::OTHER:
       vm_state = "other";
       break;
     case v8::StateTag::EXTERNAL:
       vm_state = "external";
       break;
     case v8::StateTag::IDLE:
       vm_state = "idle";
       break;
     default:
       NOTREACHED();
   }
   data->SetString("vm_state", vm_state);
   data->BeginArray("stack");
   for (unsigned i = 0; i < frames_count_; ++i) {
     data->AppendString(PtrToString(frames_[i]));
   }
   data->EndArray();
-  return data;
+  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();
@@ skipping 16 matching lines @@
                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_refptr<ConvertableToTraceFormat> JitCodeEventToTraceFormat(
+  static scoped_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_;
@@ skipping 142 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_refptr<ConvertableToTraceFormat> Sampler::JitCodeEventToTraceFormat(
+scoped_ptr<ConvertableToTraceFormat> Sampler::JitCodeEventToTraceFormat(
     const v8::JitCodeEvent* event) {
   switch (event->type) {
     case v8::JitCodeEvent::CODE_ADDED: {
-      scoped_refptr<TracedValue> data(new TracedValue());
+      scoped_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 data;
+      return std::move(data);
     }
 
     case v8::JitCodeEvent::CODE_MOVED: {
-      scoped_refptr<TracedValue> data(new TracedValue());
+      scoped_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 data;
+      return std::move(data);
     }
 
     case v8::JitCodeEvent::CODE_REMOVED: {
-      scoped_refptr<TracedValue> data(new TracedValue());
+      scoped_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 data;
+      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;
   }
   return nullptr;
 }
 
@@ skipping 237 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