Convert //components/user_prefs from scoped_ptr to std::unique_ptr

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 <memory>
 #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/strings/string_split.h"
 #include "base/values.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/user_prefs/tracked/dictionary_hash_store_contents.h"
 #include "components/user_prefs/tracked/hash_store_contents.h"
 #include "components/user_prefs/tracked/interceptable_pref_filter.h"
 #include "components/user_prefs/tracked/pref_hash_store.h"
 #include "components/user_prefs/tracked/pref_hash_store_impl.h"
 #include "components/user_prefs/tracked/pref_hash_store_transaction.h"
 #include "components/user_prefs/tracked/pref_service_hash_store_contents.h"
@@ skipping 24 matching lines @@
   void FilterUpdate(const std::string& path) override { ADD_FAILURE(); }
   void FilterSerializeData(
       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,
+      std::unique_ptr<base::DictionaryValue> pref_store_contents,
       bool prefs_altered) override {
     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
@@ skipping 30 matching lines @@
 
     migration_modified_unprotected_store_ = false;
     migration_modified_protected_store_ = false;
     unprotected_store_migration_complete_ = false;
     protected_store_migration_complete_ = false;
 
     unprotected_store_successful_write_callback_.Reset();
     protected_store_successful_write_callback_.Reset();
 
     SetupTrackedPreferencesMigration(
-        unprotected_pref_names,
-        protected_pref_names,
+        unprotected_pref_names, protected_pref_names,
         base::Bind(&TrackedPreferencesMigrationTest::RemovePathFromStore,
-                   base::Unretained(this),
-                   MOCK_UNPROTECTED_PREF_STORE),
+                   base::Unretained(this), MOCK_UNPROTECTED_PREF_STORE),
         base::Bind(&TrackedPreferencesMigrationTest::RemovePathFromStore,
-                   base::Unretained(this),
-                   MOCK_PROTECTED_PREF_STORE),
+                   base::Unretained(this), MOCK_PROTECTED_PREF_STORE),
         base::Bind(
             &TrackedPreferencesMigrationTest::RegisterSuccessfulWriteClosure,
-            base::Unretained(this),
-            MOCK_UNPROTECTED_PREF_STORE),
+            base::Unretained(this), MOCK_UNPROTECTED_PREF_STORE),
         base::Bind(
             &TrackedPreferencesMigrationTest::RegisterSuccessfulWriteClosure,
-            base::Unretained(this),
-            MOCK_PROTECTED_PREF_STORE),
-        scoped_ptr<PrefHashStore>(
+            base::Unretained(this), MOCK_PROTECTED_PREF_STORE),
+        std::unique_ptr<PrefHashStore>(
             new PrefHashStoreImpl(kSeed, kDeviceId, false)),
-        scoped_ptr<PrefHashStore>(
+        std::unique_ptr<PrefHashStore>(
             new PrefHashStoreImpl(kSeed, kDeviceId, true)),
-        scoped_ptr<HashStoreContents>(
+        std::unique_ptr<HashStoreContents>(
             new PrefServiceHashStoreContents(kHashStoreId, &local_state_)),
 
-        &mock_unprotected_pref_filter_,
-        &mock_protected_pref_filter_);
+        &mock_unprotected_pref_filter_, &mock_protected_pref_filter_);
 
     // Verify initial expectations are met.
     EXPECT_TRUE(HasPrefs(MOCK_UNPROTECTED_PREF_STORE));
     EXPECT_TRUE(HasPrefs(MOCK_PROTECTED_PREF_STORE));
     EXPECT_FALSE(
         WasOnSuccessfulWriteCallbackRegistered(MOCK_UNPROTECTED_PREF_STORE));
     EXPECT_FALSE(
         WasOnSuccessfulWriteCallbackRegistered(MOCK_PROTECTED_PREF_STORE));
   }
 
@@ skipping 16 matching lines @@
     PresetStoreValueOnly(store_id, key, value);
     PresetLegacyValueHash(key, value);
   }
 
   // Stores a hash for |key| and |value| in the hash store identified by
   // |store_id| before migration begins.
   void PresetStoreValueHash(MockPrefStoreID store_id,
                             const std::string& key,
                             const std::string value) {
     base::DictionaryValue* store = NULL;
-    scoped_ptr<PrefHashStore> pref_hash_store;
+    std::unique_ptr<PrefHashStore> pref_hash_store;
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         store = unprotected_prefs_.get();
         pref_hash_store.reset(new PrefHashStoreImpl(kSeed, kDeviceId, false));
         break;
       case MOCK_PROTECTED_PREF_STORE:
         store = protected_prefs_.get();
         pref_hash_store.reset(new PrefHashStoreImpl(kSeed, kDeviceId, true));
         break;
     }
     DCHECK(store);
 
     base::StringValue string_value(value);
-    pref_hash_store->BeginTransaction(
-        scoped_ptr<HashStoreContents>(
-            new DictionaryHashStoreContents(store)))->StoreHash(
-                key, &string_value);
+    pref_hash_store
+        ->BeginTransaction(std::unique_ptr<HashStoreContents>(
+            new DictionaryHashStoreContents(store)))
+        ->StoreHash(key, &string_value);
   }
 
   // Stores a hash for |key| and |value| in the legacy hash store in
   // local_state.
   void PresetLegacyValueHash(const std::string& key,
                              const std::string value) {
-    scoped_ptr<PrefHashStore> pref_hash_store(
+    std::unique_ptr<PrefHashStore> pref_hash_store(
         new PrefHashStoreImpl(kSeed, kDeviceId, true));
 
     base::StringValue string_value(value);
     PrefHashStoreImpl(kSeed, kDeviceId, true)
-        .BeginTransaction(scoped_ptr<HashStoreContents>(
+        .BeginTransaction(std::unique_ptr<HashStoreContents>(
             new PrefServiceHashStoreContents(kHashStoreId, &local_state_)))
         ->StoreHash(key, &string_value);
   }
 
   // Returns true if the store opposite to |store_id| is observed for its next
   // successful write.
   bool WasOnSuccessfulWriteCallbackRegistered(MockPrefStoreID store_id) {
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         return !protected_store_successful_write_callback_.is_null();
@@ skipping 132 matching lines @@
       case MOCK_PROTECTED_PREF_STORE:
         EXPECT_TRUE(protected_store_successful_write_callback_.is_null());
         protected_store_successful_write_callback_ = successful_write_closure;
         break;
     }
   }
 
   // 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,
+                    std::unique_ptr<base::DictionaryValue> prefs,
                     bool prefs_altered) {
     switch (store_id) {
       case MOCK_UNPROTECTED_PREF_STORE:
         EXPECT_FALSE(unprotected_prefs_);
         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_);
@@ skipping 34 matching lines @@
     }
     DCHECK(store);
 
     store->SetString(key, value);
   }
 
   static const char kHashStoreId[];
   static const char kSeed[];
   static const char kDeviceId[];
 
-  scoped_ptr<base::DictionaryValue> unprotected_prefs_;
-  scoped_ptr<base::DictionaryValue> protected_prefs_;
+  std::unique_ptr<base::DictionaryValue> unprotected_prefs_;
+  std::unique_ptr<base::DictionaryValue> protected_prefs_;
 
   SimpleInterceptablePrefFilter mock_unprotected_pref_filter_;
   SimpleInterceptablePrefFilter mock_protected_pref_filter_;
 
   base::Closure unprotected_store_successful_write_callback_;
   base::Closure protected_store_successful_write_callback_;
 
   bool migration_modified_unprotected_store_;
   bool migration_modified_protected_store_;
 
@@ skipping 476 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);
   }
 }