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

components/user_prefs/tracked/tracked_preferences_migration.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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 16 matching lines @@
       const std::set<std::string>& unprotected_pref_names,
       const std::set<std::string>& protected_pref_names,
       const base::Callback<void(const std::string& key)>&
           unprotected_store_cleaner,
       const base::Callback<void(const std::string& key)>&
           protected_store_cleaner,
       const base::Callback<void(const base::Closure&)>&
           register_on_successful_unprotected_store_write_callback,
       const base::Callback<void(const base::Closure&)>&
           register_on_successful_protected_store_write_callback,
-      scoped_ptr<PrefHashStore> unprotected_pref_hash_store,
-      scoped_ptr<PrefHashStore> protected_pref_hash_store,
-      scoped_ptr<HashStoreContents> legacy_pref_hash_store,
+      std::unique_ptr<PrefHashStore> unprotected_pref_hash_store,
+      std::unique_ptr<PrefHashStore> protected_pref_hash_store,
+      std::unique_ptr<HashStoreContents> legacy_pref_hash_store,
       InterceptablePrefFilter* unprotected_pref_filter,
       InterceptablePrefFilter* protected_pref_filter);
 
  private:
   friend class base::RefCounted<TrackedPreferencesMigrator>;
 
   enum PrefFilterID {
     UNPROTECTED_PREF_FILTER,
     PROTECTED_PREF_FILTER
   };
 
   ~TrackedPreferencesMigrator();
 
   // Stores the data coming in from the filter identified by |id| into this
   // class and then calls MigrateIfReady();
   void InterceptFilterOnLoad(
       PrefFilterID id,
       const InterceptablePrefFilter::FinalizeFilterOnLoadCallback&
           finalize_filter_on_load,
-      scoped_ptr<base::DictionaryValue> prefs);
+      std::unique_ptr<base::DictionaryValue> prefs);
 
   // Proceeds with migration if both |unprotected_prefs_| and |protected_prefs_|
   // have been set.
   void MigrateIfReady();
 
   const std::set<std::string> unprotected_pref_names_;
   const std::set<std::string> protected_pref_names_;
 
   const base::Callback<void(const std::string& key)> unprotected_store_cleaner_;
   const base::Callback<void(const std::string& key)> protected_store_cleaner_;
   const base::Callback<void(const base::Closure&)>
       register_on_successful_unprotected_store_write_callback_;
   const base::Callback<void(const base::Closure&)>
       register_on_successful_protected_store_write_callback_;
 
   InterceptablePrefFilter::FinalizeFilterOnLoadCallback
       finalize_unprotected_filter_on_load_;
   InterceptablePrefFilter::FinalizeFilterOnLoadCallback
       finalize_protected_filter_on_load_;
 
-  scoped_ptr<PrefHashStore> unprotected_pref_hash_store_;
-  scoped_ptr<PrefHashStore> protected_pref_hash_store_;
-  scoped_ptr<HashStoreContents> legacy_pref_hash_store_;
+  std::unique_ptr<PrefHashStore> unprotected_pref_hash_store_;
+  std::unique_ptr<PrefHashStore> protected_pref_hash_store_;
+  std::unique_ptr<HashStoreContents> legacy_pref_hash_store_;
 
-  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_;
 
   DISALLOW_COPY_AND_ASSIGN(TrackedPreferencesMigrator);
 };
 
 // Invokes |store_cleaner| for every |keys_to_clean|.
 void CleanupPrefStore(
     const base::Callback<void(const std::string& key)>& store_cleaner,
     const std::set<std::string>& keys_to_clean) {
   for (std::set<std::string>::const_iterator it = keys_to_clean.begin();
        it != keys_to_clean.end(); ++it) {
@@ skipping 19 matching lines @@
   } else {
     CleanupPrefStore(source_store_cleaner, keys_to_clean);
   }
 }
 
 // Removes hashes for |migrated_pref_names| from |origin_pref_store| using
 // the configuration/implementation in |origin_pref_hash_store|.
 void CleanupMigratedHashes(const std::set<std::string>& migrated_pref_names,
                            PrefHashStore* origin_pref_hash_store,
                            base::DictionaryValue* origin_pref_store) {
-  scoped_ptr<PrefHashStoreTransaction> transaction(
-      origin_pref_hash_store->BeginTransaction(scoped_ptr<HashStoreContents>(
-          new DictionaryHashStoreContents(origin_pref_store))));
+  std::unique_ptr<PrefHashStoreTransaction> transaction(
+      origin_pref_hash_store->BeginTransaction(
+          std::unique_ptr<HashStoreContents>(
+              new DictionaryHashStoreContents(origin_pref_store))));
   for (std::set<std::string>::const_iterator it = migrated_pref_names.begin();
        it != migrated_pref_names.end();
        ++it) {
     transaction->ClearHash(*it);
   }
 }
 
 // Copies the value of each pref in |pref_names| which is set in |old_store|,
 // but not in |new_store| into |new_store|. Sets |old_store_needs_cleanup| to
 // true if any old duplicates remain in |old_store| and sets |new_store_altered|
 // to true if any value was copied to |new_store|.
 void MigratePrefsFromOldToNewStore(const std::set<std::string>& pref_names,
                                    base::DictionaryValue* old_store,
                                    base::DictionaryValue* new_store,
                                    PrefHashStore* new_hash_store,
                                    HashStoreContents* legacy_hash_store,
                                    bool* old_store_needs_cleanup,
                                    bool* new_store_altered,
                                    bool* used_legacy_pref_hashes) {
   const base::DictionaryValue* old_hash_store_contents =
       DictionaryHashStoreContents(old_store).GetContents();
   const base::DictionaryValue* legacy_hash_store_contents =
       legacy_hash_store->GetContents();
-  scoped_ptr<PrefHashStoreTransaction> new_hash_store_transaction(
-      new_hash_store->BeginTransaction(scoped_ptr<HashStoreContents>(
+  std::unique_ptr<PrefHashStoreTransaction> new_hash_store_transaction(
+      new_hash_store->BeginTransaction(std::unique_ptr<HashStoreContents>(
           new DictionaryHashStoreContents(new_store))));
 
   for (std::set<std::string>::const_iterator it = pref_names.begin();
        it != pref_names.end();
        ++it) {
      const std::string& pref_name = *it;
      const base::Value* value_in_old_store = NULL;
 
     // If the destination does not have a hash for this pref we will
     // unconditionally attempt to move it.
@@ skipping 46 matching lines @@
 TrackedPreferencesMigrator::TrackedPreferencesMigrator(
     const std::set<std::string>& unprotected_pref_names,
     const std::set<std::string>& protected_pref_names,
     const base::Callback<void(const std::string& key)>&
         unprotected_store_cleaner,
     const base::Callback<void(const std::string& key)>& protected_store_cleaner,
     const base::Callback<void(const base::Closure&)>&
         register_on_successful_unprotected_store_write_callback,
     const base::Callback<void(const base::Closure&)>&
         register_on_successful_protected_store_write_callback,
-    scoped_ptr<PrefHashStore> unprotected_pref_hash_store,
-    scoped_ptr<PrefHashStore> protected_pref_hash_store,
-    scoped_ptr<HashStoreContents> legacy_pref_hash_store,
+    std::unique_ptr<PrefHashStore> unprotected_pref_hash_store,
+    std::unique_ptr<PrefHashStore> protected_pref_hash_store,
+    std::unique_ptr<HashStoreContents> legacy_pref_hash_store,
     InterceptablePrefFilter* unprotected_pref_filter,
     InterceptablePrefFilter* protected_pref_filter)
     : unprotected_pref_names_(unprotected_pref_names),
       protected_pref_names_(protected_pref_names),
       unprotected_store_cleaner_(unprotected_store_cleaner),
       protected_store_cleaner_(protected_store_cleaner),
       register_on_successful_unprotected_store_write_callback_(
           register_on_successful_unprotected_store_write_callback),
       register_on_successful_protected_store_write_callback_(
           register_on_successful_protected_store_write_callback),
@@ skipping 11 matching lines @@
                  this,
                  PROTECTED_PREF_FILTER));
 }
 
 TrackedPreferencesMigrator::~TrackedPreferencesMigrator() {}
 
 void TrackedPreferencesMigrator::InterceptFilterOnLoad(
     PrefFilterID id,
     const InterceptablePrefFilter::FinalizeFilterOnLoadCallback&
         finalize_filter_on_load,
-    scoped_ptr<base::DictionaryValue> prefs) {
+    std::unique_ptr<base::DictionaryValue> prefs) {
   switch (id) {
     case UNPROTECTED_PREF_FILTER:
       finalize_unprotected_filter_on_load_ = finalize_filter_on_load;
       unprotected_prefs_ = std::move(prefs);
       break;
     case PROTECTED_PREF_FILTER:
       finalize_protected_filter_on_load_ = finalize_filter_on_load;
       protected_prefs_ = std::move(prefs);
       break;
   }
@@ skipping 80 matching lines @@
 void SetupTrackedPreferencesMigration(
     const std::set<std::string>& unprotected_pref_names,
     const std::set<std::string>& protected_pref_names,
     const base::Callback<void(const std::string& key)>&
         unprotected_store_cleaner,
     const base::Callback<void(const std::string& key)>& protected_store_cleaner,
     const base::Callback<void(const base::Closure&)>&
         register_on_successful_unprotected_store_write_callback,
     const base::Callback<void(const base::Closure&)>&
         register_on_successful_protected_store_write_callback,
-    scoped_ptr<PrefHashStore> unprotected_pref_hash_store,
-    scoped_ptr<PrefHashStore> protected_pref_hash_store,
-    scoped_ptr<HashStoreContents> legacy_pref_hash_store,
+    std::unique_ptr<PrefHashStore> unprotected_pref_hash_store,
+    std::unique_ptr<PrefHashStore> protected_pref_hash_store,
+    std::unique_ptr<HashStoreContents> legacy_pref_hash_store,
     InterceptablePrefFilter* unprotected_pref_filter,
     InterceptablePrefFilter* protected_pref_filter) {
   scoped_refptr<TrackedPreferencesMigrator> prefs_migrator(
       new TrackedPreferencesMigrator(
           unprotected_pref_names, protected_pref_names,
           unprotected_store_cleaner, protected_store_cleaner,
           register_on_successful_unprotected_store_write_callback,
           register_on_successful_protected_store_write_callback,
           std::move(unprotected_pref_hash_store),
           std::move(protected_pref_hash_store),
           std::move(legacy_pref_hash_store), unprotected_pref_filter,
           protected_pref_filter));
 }