Convert Pass()→std::move() in //net

net/sdch/sdch_owner.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 "net/sdch/sdch_owner.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/persistent_pref_store.h"
 #include "base/prefs/value_map_pref_store.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
@@ skipping 79 matching lines @@
 }
 
 // This function initializes a pref store with an empty version of the
 // above schema, removing anything previously in the store under
 // kPreferenceName.
 void InitializePrefStore(WriteablePrefStore* store) {
   scoped_ptr<base::DictionaryValue> empty_store(new base::DictionaryValue);
   empty_store->SetInteger(kVersionKey, kVersion);
   empty_store->Set(kDictionariesKey,
                    make_scoped_ptr(new base::DictionaryValue));
-  store->SetValue(kPreferenceName, empty_store.Pass(),
+  store->SetValue(kPreferenceName, std::move(empty_store),
                   WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 }
 
 // A class to allow iteration over all dictionaries in the pref store, and
 // easy lookup of the information associated with those dictionaries.
 // Note that this is an "Iterator" in the same sense (and for the same
 // reasons) that base::Dictionary::Iterator is an iterator--it allows
 // iterating over all the dictionaries in the preference store, but it
 // does not allow use as an STL iterator because the container it
 // is iterating over does not export begin()/end() methods. This iterator can
@@ skipping 320 matching lines @@
 
   // Record the addition in the pref store.
   scoped_ptr<base::DictionaryValue> dictionary_description(
       new base::DictionaryValue());
   dictionary_description->SetString(kDictionaryUrlKey, dictionary_url.spec());
   dictionary_description->SetDouble(kDictionaryLastUsedKey,
                                     last_used.ToDoubleT());
   dictionary_description->SetInteger(kDictionaryUseCountKey, use_count);
   dictionary_description->SetInteger(kDictionarySizeKey,
                                      dictionary_text.size());
-  pref_dictionary_map->Set(server_hash, dictionary_description.Pass());
+  pref_dictionary_map->Set(server_hash, std::move(dictionary_description));
   load_times_[server_hash] = clock_->Now();
 }
 
 void SdchOwner::OnDictionaryAdded(const GURL& dictionary_url,
                                   const std::string& server_hash) { }
 
 void SdchOwner::OnDictionaryRemoved(const std::string& server_hash) { }
 
 void SdchOwner::OnDictionaryUsed(const std::string& server_hash) {
   base::Time now(clock_->Now());
@@ skipping 155 matching lines @@
 
   // This object can stop waiting on (i.e. observing) the external preference
   // store and switch over to using it as the primary preference store.
   pref_store_ = external_pref_store_;
   external_pref_store_->RemoveObserver(this);
   external_pref_store_ = nullptr;
   in_memory_pref_store_ = nullptr;
 }
 
 void SdchOwner::SetClockForTesting(scoped_ptr<base::Clock> clock) {
-  clock_ = clock.Pass();
+  clock_ = std::move(clock);
 }
 
 int SdchOwner::GetDictionaryCountForTesting() const {
   int count = 0;
   for (DictionaryPreferenceIterator it(pref_store_); !it.IsAtEnd();
        it.Advance()) {
     count++;
   }
   return count;
 }
@@ skipping 77 matching lines @@
   }
 
   return true;
 }
 
 bool SdchOwner::IsPersistingDictionaries() const {
   return in_memory_pref_store_.get() != nullptr;
 }
 
 }  // namespace net