Replace scoped_ptr with std::unique_ptr in //ui

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_ptr<ConvertableToTraceFormat> FromValue(
-      scoped_ptr<base::Value> value);
+  static std::unique_ptr<ConvertableToTraceFormat> FromValue(
+      std::unique_ptr<base::Value> value);
 
   void AppendAsTraceFormat(std::string* out) const override;
 
  private:
   explicit LatencyInfoTracedValue(base::Value* value);
   ~LatencyInfoTracedValue() override;
 
-  scoped_ptr<base::Value> value_;
+  std::unique_ptr<base::Value> value_;
 
   DISALLOW_COPY_AND_ASSIGN(LatencyInfoTracedValue);
 };
 
-scoped_ptr<base::trace_event::ConvertableToTraceFormat>
-LatencyInfoTracedValue::FromValue(scoped_ptr<base::Value> value) {
-  return scoped_ptr<base::trace_event::ConvertableToTraceFormat>(
+std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
+LatencyInfoTracedValue::FromValue(std::unique_ptr<base::Value> value) {
+  return std::unique_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 193 matching lines @@
                                   "coordinates", CoordinatesAsTraceableData());
     }
 
     TRACE_EVENT_WITH_FLOW0("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(trace_id_),
                            TRACE_EVENT_FLAG_FLOW_IN);
   }
 }
 
-scoped_ptr<base::trace_event::ConvertableToTraceFormat>
+std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 LatencyInfo::AsTraceableData() {
-  scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> record_data(
+      new base::DictionaryValue());
   for (const auto& lc : latency_components_) {
-    scoped_ptr<base::DictionaryValue>
-        component_info(new base::DictionaryValue());
+    std::unique_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_ptr<base::trace_event::ConvertableToTraceFormat>
+std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 LatencyInfo::CoordinatesAsTraceableData() {
-  scoped_ptr<base::ListValue> coordinates(new base::ListValue());
+  std::unique_ptr<base::ListValue> coordinates(new base::ListValue());
   for (size_t i = 0; i < input_coordinates_size_; i++) {
-    scoped_ptr<base::DictionaryValue> coordinate_pair(
+    std::unique_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));
 }
 
 bool LatencyInfo::FindLatency(LatencyComponentType type,
                               int64_t id,
@@ skipping 21 matching lines @@
 }
 
 bool LatencyInfo::AddInputCoordinate(const InputCoordinate& input_coordinate) {
   if (input_coordinates_size_ >= kMaxInputCoordinates)
     return false;
   input_coordinates_[input_coordinates_size_++] = input_coordinate;
   return true;
 }
 
 }  // namespace ui