Clean up old legacy preference migration logic.

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 18 matching lines @@
       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,
       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
   };
@@ skipping 22 matching lines @@
   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_;
 
   std::unique_ptr<PrefHashStore> unprotected_pref_hash_store_;
   std::unique_ptr<PrefHashStore> protected_pref_hash_store_;
-  std::unique_ptr<HashStoreContents> legacy_pref_hash_store_;
 
   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,
@@ skipping 41 matching lines @@
 }
 
 // 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) {
+                                   bool* new_store_altered) {
   const base::DictionaryValue* old_hash_store_contents =
       DictionaryHashStoreContents(old_store).GetContents();
-  const base::DictionaryValue* legacy_hash_store_contents =
-      legacy_hash_store->GetContents();
   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;
 
@@ skipping 17 matching lines @@
         new_store->Set(pref_name, value_in_old_store->DeepCopy());
         migrated_value = true;
         *new_store_altered = true;
       }
     }
 
     if (destination_hash_missing || migrated_value) {
       const base::Value* old_hash = NULL;
       if (old_hash_store_contents)
         old_hash_store_contents->Get(pref_name, &old_hash);
-      if (!old_hash && legacy_hash_store_contents) {
-        legacy_hash_store_contents->Get(pref_name, &old_hash);
-        if (old_hash)
-          *used_legacy_pref_hashes = true;
-      }
       if (old_hash) {
         new_hash_store_transaction->ImportHash(pref_name, old_hash);
         *new_store_altered = true;
       } else if (!destination_hash_missing) {
         // Do not allow values to be migrated without MACs if the destination
         // already has a MAC (http://crbug.com/414554). Remove the migrated
         // value in order to provide the same no-op behaviour as if the pref was
         // added to the wrong file when there was already a value for
         // |pref_name| in |new_store|.
         new_store->Remove(pref_name, NULL);
         *new_store_altered = true;
       }
     }
   }
 }
 
 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,
     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),
       unprotected_pref_hash_store_(std::move(unprotected_pref_hash_store)),
-      protected_pref_hash_store_(std::move(protected_pref_hash_store)),
-      legacy_pref_hash_store_(std::move(legacy_pref_hash_store)) {
+      protected_pref_hash_store_(std::move(protected_pref_hash_store)) {
   // The callbacks bound below will own this TrackedPreferencesMigrator by
   // reference.
   unprotected_pref_filter->InterceptNextFilterOnLoad(
       base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad,
                  this,
                  UNPROTECTED_PREF_FILTER));
   protected_pref_filter->InterceptNextFilterOnLoad(
       base::Bind(&TrackedPreferencesMigrator::InterceptFilterOnLoad,
                  this,
                  PROTECTED_PREF_FILTER));
@@ skipping 18 matching lines @@
   }
 
   MigrateIfReady();
 }
 
 void TrackedPreferencesMigrator::MigrateIfReady() {
   // Wait for both stores to have been read before proceeding.
   if (!protected_prefs_ || !unprotected_prefs_)
     return;
 
-  bool used_legacy_pref_hashes = false;
   bool protected_prefs_need_cleanup = false;
   bool unprotected_prefs_altered = false;
-  MigratePrefsFromOldToNewStore(unprotected_pref_names_,
-                                protected_prefs_.get(),
-                                unprotected_prefs_.get(),
-                                unprotected_pref_hash_store_.get(),
-                                legacy_pref_hash_store_.get(),
-                                &protected_prefs_need_cleanup,
-                                &unprotected_prefs_altered,
-                                &used_legacy_pref_hashes);
+  MigratePrefsFromOldToNewStore(
+      unprotected_pref_names_, protected_prefs_.get(), unprotected_prefs_.get(),
+      unprotected_pref_hash_store_.get(), &protected_prefs_need_cleanup,
+      &unprotected_prefs_altered);
   bool unprotected_prefs_need_cleanup = false;
   bool protected_prefs_altered = false;
-  MigratePrefsFromOldToNewStore(protected_pref_names_,
-                                unprotected_prefs_.get(),
-                                protected_prefs_.get(),
-                                protected_pref_hash_store_.get(),
-                                legacy_pref_hash_store_.get(),
-                                &unprotected_prefs_need_cleanup,
-                                &protected_prefs_altered,
-                                &used_legacy_pref_hashes);
-  UMA_HISTOGRAM_BOOLEAN("Settings.MigratedHashesFromLocalState",
-                        used_legacy_pref_hashes);
+  MigratePrefsFromOldToNewStore(
+      protected_pref_names_, unprotected_prefs_.get(), protected_prefs_.get(),
+      protected_pref_hash_store_.get(), &unprotected_prefs_need_cleanup,
+      &protected_prefs_altered);
 
   if (!unprotected_prefs_altered && !protected_prefs_altered) {
     // Clean up any MACs that might have been previously migrated from the
     // various stores. It's safe to leave them behind for a little while as they
     // will be ignored unless the corresponding value is _also_ present. The
     // cleanup must be deferred until the MACs have been written to their target
     // stores, and doing so in a subsequent launch is easier than within the
     // same process.
     CleanupMigratedHashes(unprotected_pref_names_,
                           protected_pref_hash_store_.get(),
                           protected_prefs_.get());
     CleanupMigratedHashes(protected_pref_names_,
                           unprotected_pref_hash_store_.get(),
                           unprotected_prefs_.get());
-    legacy_pref_hash_store_->Reset();
   }
 
   // Hand the processed prefs back to their respective filters.
   finalize_unprotected_filter_on_load_.Run(std::move(unprotected_prefs_),
                                            unprotected_prefs_altered);
   finalize_protected_filter_on_load_.Run(std::move(protected_prefs_),
                                          protected_prefs_altered);
 
   if (unprotected_prefs_need_cleanup) {
     // Schedule a cleanup of the |protected_pref_names_| from the unprotected
@@ skipping 25 matching lines @@
     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,
     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,
+          std::move(protected_pref_hash_store), unprotected_pref_filter,
           protected_pref_filter));
 }