Convert Pass()→std::move() 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 <algorithm>
 #include <string>
+#include <utility>
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 
 namespace {
 
 const size_t kMaxLatencyInfoNumber = 100;
 
 const char* GetComponentName(ui::LatencyComponentType type) {
@@ skipping 298 matching lines @@
   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), component_info.Pass());
+    record_data->Set(GetComponentName(lc.first.first),
+                     std::move(component_info));
   }
   record_data->SetDouble("trace_id", static_cast<double>(trace_id_));
-  return LatencyInfoTracedValue::FromValue(record_data.Pass());
+  return LatencyInfoTracedValue::FromValue(std::move(record_data));
 }
 
 scoped_refptr<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(coordinates.Pass());
+  return LatencyInfoTracedValue::FromValue(std::move(coordinates));
 }
 
 bool LatencyInfo::FindLatency(LatencyComponentType type,
                               int64 id,
                               LatencyComponent* output) const {
   LatencyMap::const_iterator it = latency_components_.find(
       std::make_pair(type, id));
   if (it == latency_components_.end())
     return false;
   if (output)
@@ skipping 22 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