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

components/user_prefs/tracked/pref_hash_filter_unittest.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 "components/user_prefs/tracked/pref_hash_filter.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 370 matching lines @@
 
   // Initializes |pref_hash_filter_| with a PrefHashFilter that uses a
   // MockPrefHashStore. The raw pointer to the MockPrefHashStore (owned by the
   // PrefHashFilter) is stored in |mock_pref_hash_store_|.
   void InitializePrefHashFilter(const std::vector<
       PrefHashFilter::TrackedPreferenceMetadata>& configuration) {
     scoped_ptr<MockPrefHashStore> temp_mock_pref_hash_store(
         new MockPrefHashStore);
     mock_pref_hash_store_ = temp_mock_pref_hash_store.get();
     pref_hash_filter_.reset(new PrefHashFilter(
-        temp_mock_pref_hash_store.Pass(), configuration,
+        std::move(temp_mock_pref_hash_store), configuration,
         base::Bind(&PrefHashFilterTest::RecordReset, base::Unretained(this)),
         &mock_validation_delegate_, arraysize(kTestTrackedPrefs), true));
   }
 
   // Verifies whether a reset was reported by the PrefHashFiler. Also verifies
   // that kPreferenceResetTime was set (or not) accordingly.
   void VerifyRecordedReset(bool reset_expected) {
     EXPECT_EQ(reset_expected, reset_recorded_);
     EXPECT_EQ(reset_expected,
               pref_store_contents_->Get(
                   user_prefs::kPreferenceResetTime, NULL));
   }
 
   // Calls FilterOnLoad() on |pref_hash_Filter_|. |pref_store_contents_| is
   // handed off, but should be given back to us synchronously through
   // GetPrefsBack() as there is no FilterOnLoadInterceptor installed on
   // |pref_hash_filter_|.
   void DoFilterOnLoad(bool expect_prefs_modifications) {
     pref_hash_filter_->FilterOnLoad(
         base::Bind(&PrefHashFilterTest::GetPrefsBack, base::Unretained(this),
                    expect_prefs_modifications),
-        pref_store_contents_.Pass());
+        std::move(pref_store_contents_));
   }
 
   MockPrefHashStore* mock_pref_hash_store_;
   scoped_ptr<base::DictionaryValue> pref_store_contents_;
   MockValidationDelegate mock_validation_delegate_;
   scoped_ptr<PrefHashFilter> pref_hash_filter_;
 
  private:
   // Stores |prefs| back in |pref_store_contents| and ensure
   // |expected_schedule_write| matches the reported |schedule_write|.
   void GetPrefsBack(bool expected_schedule_write,
                     scoped_ptr<base::DictionaryValue> prefs,
                     bool schedule_write) {
-    pref_store_contents_ = prefs.Pass();
+    pref_store_contents_ = std::move(prefs);
     EXPECT_TRUE(pref_store_contents_);
     EXPECT_EQ(expected_schedule_write, schedule_write);
   }
 
   void RecordReset() {
     // As-is |reset_recorded_| is only designed to remember a single reset, make
     // sure none was previously recorded.
     EXPECT_FALSE(reset_recorded_);
     reset_recorded_ = true;
   }
@@ skipping 594 matching lines @@
               mock_pref_hash_store_->stored_value(kAtomicPref2).first);
 
     VerifyRecordedReset(false);
   }
 }
 
 INSTANTIATE_TEST_CASE_P(PrefHashFilterTestInstance,
                         PrefHashFilterTest,
                         testing::Values(PrefHashFilter::NO_ENFORCEMENT,
                                         PrefHashFilter::ENFORCE_ON_LOAD));