Convert Pass()→std::move() in //components/[n-z]*

components/user_prefs/tracked/segregated_pref_store.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 "components/user_prefs/tracked/segregated_pref_store.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 
 SegregatedPrefStore::AggregatingObserver::AggregatingObserver(
     SegregatedPrefStore* outer)
     : outer_(outer),
       failed_sub_initializations_(0),
       successful_sub_initializations_(0) {
 }
@@ skipping 61 matching lines @@
 }
 
 bool SegregatedPrefStore::GetValue(const std::string& key,
                                    const base::Value** result) const {
   return StoreForKey(key)->GetValue(key, result);
 }
 
 void SegregatedPrefStore::SetValue(const std::string& key,
                                    scoped_ptr<base::Value> value,
                                    uint32_t flags) {
-  StoreForKey(key)->SetValue(key, value.Pass(), flags);
+  StoreForKey(key)->SetValue(key, std::move(value), flags);
 }
 
 void SegregatedPrefStore::RemoveValue(const std::string& key, uint32_t flags) {
   StoreForKey(key)->RemoveValue(key, flags);
 }
 
 bool SegregatedPrefStore::GetMutableValue(const std::string& key,
                                           base::Value** result) {
   return StoreForKey(key)->GetMutableValue(key, result);
 }
 
 void SegregatedPrefStore::ReportValueChanged(const std::string& key,
                                              uint32_t flags) {
   StoreForKey(key)->ReportValueChanged(key, flags);
 }
 
 void SegregatedPrefStore::SetValueSilently(const std::string& key,
                                            scoped_ptr<base::Value> value,
                                            uint32_t flags) {
-  StoreForKey(key)->SetValueSilently(key, value.Pass(), flags);
+  StoreForKey(key)->SetValueSilently(key, std::move(value), flags);
 }
 
 bool SegregatedPrefStore::ReadOnly() const {
   return selected_pref_store_->ReadOnly() || default_pref_store_->ReadOnly();
 }
 
 PersistentPrefStore::PrefReadError SegregatedPrefStore::GetReadError() const {
   PersistentPrefStore::PrefReadError read_error =
       default_pref_store_->GetReadError();
   if (read_error == PersistentPrefStore::PREF_READ_ERROR_NONE) {
@@ skipping 45 matching lines @@
               ? selected_pref_store_
               : default_pref_store_).get();
 }
 
 const PersistentPrefStore* SegregatedPrefStore::StoreForKey(
     const std::string& key) const {
   return (ContainsKey(selected_preference_names_, key)
               ? selected_pref_store_
               : default_pref_store_).get();
 }