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

components/user_prefs/tracked/tracked_preferences_migration_unittest.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/tracked_preferences_migration.h"
 
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/values.h"
 #include "components/user_prefs/tracked/dictionary_hash_store_contents.h"
@@ skipping 32 matching lines @@
       base::DictionaryValue* pref_store_contents) override {
     ADD_FAILURE();
   }
 
  private:
   // InterceptablePrefFilter implementation.
   void FinalizeFilterOnLoad(
       const PostFilterOnLoadCallback& post_filter_on_load_callback,
       scoped_ptr<base::DictionaryValue> pref_store_contents,
       bool prefs_altered) override {
-    post_filter_on_load_callback.Run(pref_store_contents.Pass(), prefs_altered);
+    post_filter_on_load_callback.Run(std::move(pref_store_contents),
+                                     prefs_altered);
   }
 };
 
 // A test fixture designed to be used like this:
 //  1) Set up initial store prefs with PresetStoreValue().
 //  2) Hand both sets of prefs to the migrator via HandPrefsToMigrator().
 //  3) Migration completes synchronously when the second store hands its prefs
 //     over.
 //  4) Verifications can be made via various methods of this fixture.
 // Call Reset() to perform a second migration.
@@ skipping 197 matching lines @@
                                           static_cast<std::string*>(NULL));
   }
 
   // Both stores need to hand their prefs over in order for migration to kick
   // in.
   void HandPrefsToMigrator(MockPrefStoreID store_id) {
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         mock_unprotected_pref_filter_.FilterOnLoad(
             base::Bind(&TrackedPreferencesMigrationTest::GetPrefsBack,
-                       base::Unretained(this),
-                       MOCK_UNPROTECTED_PREF_STORE),
-            unprotected_prefs_.Pass());
+                       base::Unretained(this), MOCK_UNPROTECTED_PREF_STORE),
+            std::move(unprotected_prefs_));
         break;
       case MOCK_PROTECTED_PREF_STORE:
         mock_protected_pref_filter_.FilterOnLoad(
             base::Bind(&TrackedPreferencesMigrationTest::GetPrefsBack,
-                       base::Unretained(this),
-                       MOCK_PROTECTED_PREF_STORE),
-            protected_prefs_.Pass());
+                       base::Unretained(this), MOCK_PROTECTED_PREF_STORE),
+            std::move(protected_prefs_));
         break;
     }
   }
 
   bool HasPrefs(MockPrefStoreID store_id) {
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         return unprotected_prefs_;
       case MOCK_PROTECTED_PREF_STORE:
         return protected_prefs_;
@@ skipping 50 matching lines @@
   }
 
   // Helper given as an InterceptablePrefFilter::FinalizeFilterOnLoadCallback
   // to the migrator to be invoked when it's done.
   void GetPrefsBack(MockPrefStoreID store_id,
                     scoped_ptr<base::DictionaryValue> prefs,
                     bool prefs_altered) {
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         EXPECT_FALSE(unprotected_prefs_);
-        unprotected_prefs_ = prefs.Pass();
+        unprotected_prefs_ = std::move(prefs);
         migration_modified_unprotected_store_ = prefs_altered;
         unprotected_store_migration_complete_ = true;
         break;
       case MOCK_PROTECTED_PREF_STORE:
         EXPECT_FALSE(protected_prefs_);
-        protected_prefs_ = prefs.Pass();
+        protected_prefs_ = std::move(prefs);
         migration_modified_protected_store_ = prefs_altered;
         protected_store_migration_complete_ = true;
         break;
     }
   }
 
   // Helper given as a cleaning callback to the migrator.
   void RemovePathFromStore(MockPrefStoreID store_id, const std::string& key) {
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
@@ skipping 521 matching lines @@
                        expected_unprotected_values);
 
     base::StringPairs expected_protected_values;
     expected_protected_values.push_back(std::make_pair(
         kProtectedPref, kProtectedPrefValue));
     expected_protected_values.push_back(std::make_pair(
         kPreviouslyUnprotectedPref, kPreviouslyUnprotectedPrefValue));
     VerifyValuesStored(MOCK_PROTECTED_PREF_STORE, expected_protected_values);
   }
 }