tracing: Make ConvertableToTraceFormat move-only scoped_ptr

ui/events/latency_info.cc

 // Copyright 2013 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 "ui/events/latency_info.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 66 matching lines @@
 }
 
 bool IsInputLatencyBeginComponent(ui::LatencyComponentType type) {
   return type == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT;
 }
 
 // This class is for converting latency info to trace buffer friendly format.
 class LatencyInfoTracedValue
     : public base::trace_event::ConvertableToTraceFormat {
  public:
-  static scoped_refptr<ConvertableToTraceFormat> FromValue(
+  static scoped_ptr<ConvertableToTraceFormat> FromValue(
       scoped_ptr<base::Value> value);
 
   void AppendAsTraceFormat(std::string* out) const override;
 
  private:
   explicit LatencyInfoTracedValue(base::Value* value);
   ~LatencyInfoTracedValue() override;
 
   scoped_ptr<base::Value> value_;
 
   DISALLOW_COPY_AND_ASSIGN(LatencyInfoTracedValue);
 };
 
-scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+scoped_ptr<base::trace_event::ConvertableToTraceFormat>
 LatencyInfoTracedValue::FromValue(scoped_ptr<base::Value> value) {
-  return scoped_refptr<base::trace_event::ConvertableToTraceFormat>(
+  return scoped_ptr<base::trace_event::ConvertableToTraceFormat>(
       new LatencyInfoTracedValue(value.release()));
 }
 
 LatencyInfoTracedValue::~LatencyInfoTracedValue() {
 }
 
 void LatencyInfoTracedValue::AppendAsTraceFormat(std::string* out) const {
   std::string tmp;
   base::JSONWriter::Write(*value_, &tmp);
   *out += tmp;
@@ skipping 196 matching lines @@
                                   "coordinates", CoordinatesAsTraceableData());
     }
 
     TRACE_EVENT_WITH_FLOW0("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(trace_id_),
                            TRACE_EVENT_FLAG_FLOW_IN);
   }
 }
 
-scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+scoped_ptr<base::trace_event::ConvertableToTraceFormat>
 LatencyInfo::AsTraceableData() {
   scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
   for (const auto& lc : latency_components_) {
     scoped_ptr<base::DictionaryValue>
         component_info(new base::DictionaryValue());
     component_info->SetDouble("comp_id", static_cast<double>(lc.first.second));
     component_info->SetDouble(
         "time",
         static_cast<double>(lc.second.event_time.ToInternalValue()));
     component_info->SetDouble("count", lc.second.event_count);
     component_info->SetDouble("sequence_number",
                               lc.second.sequence_number);
     record_data->Set(GetComponentName(lc.first.first),
                      std::move(component_info));
   }
   record_data->SetDouble("trace_id", static_cast<double>(trace_id_));
   return LatencyInfoTracedValue::FromValue(std::move(record_data));
 }
 
-scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+scoped_ptr<base::trace_event::ConvertableToTraceFormat>
 LatencyInfo::CoordinatesAsTraceableData() {
   scoped_ptr<base::ListValue> coordinates(new base::ListValue());
   for (size_t i = 0; i < input_coordinates_size_; i++) {
     scoped_ptr<base::DictionaryValue> coordinate_pair(
         new base::DictionaryValue());
     coordinate_pair->SetDouble("x", input_coordinates_[i].x);
     coordinate_pair->SetDouble("y", input_coordinates_[i].y);
     coordinates->Append(coordinate_pair.release());
   }
   return LatencyInfoTracedValue::FromValue(std::move(coordinates));
@@ skipping 32 matching lines @@
 }
 
 bool LatencyInfo::AddCoalescedEventTimestamp(double timestamp) {
   if (coalesced_events_size_ >= kMaxCoalescedEventTimestamps)
     return false;
   timestamps_of_coalesced_events_[coalesced_events_size_++] = timestamp;
   return true;
 }
 
 }  // namespace ui