Clean up old legacy preference migration logic.

chrome/browser/prefs/profile_pref_store_manager.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 "chrome/browser/prefs/profile_pref_store_manager.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/persistent_pref_store.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/user_prefs/tracked/pref_hash_store_impl.h"
-#include "components/user_prefs/tracked/pref_service_hash_store_contents.h"
 #include "components/user_prefs/tracked/segregated_pref_store.h"
 #include "components/user_prefs/tracked/tracked_preferences_migration.h"
 
 namespace {
 
 void RemoveValueSilently(const base::WeakPtr<JsonPrefStore> pref_store,
                          const std::string& key) {
   if (pref_store) {
     pref_store->RemoveValueSilently(
         key, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
@@ skipping 22 matching lines @@
     : profile_path_(profile_path),
       tracking_configuration_(tracking_configuration),
       reporting_ids_count_(reporting_ids_count),
       seed_(seed),
       device_id_(device_id),
       local_state_(local_state) {}
 
 ProfilePrefStoreManager::~ProfilePrefStoreManager() {}
 
 // static
-void ProfilePrefStoreManager::RegisterPrefs(PrefRegistrySimple* registry) {
-  PrefServiceHashStoreContents::RegisterPrefs(registry);
-}
-
-// static
 void ProfilePrefStoreManager::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   PrefHashFilter::RegisterProfilePrefs(registry);
 }
 
-// static
-void ProfilePrefStoreManager::ResetAllPrefHashStores(PrefService* local_state) {
-  PrefServiceHashStoreContents::ResetAllPrefHashStores(local_state);
-}
-
 //  static
 base::Time ProfilePrefStoreManager::GetResetTime(PrefService* pref_service) {
   return PrefHashFilter::GetResetTime(pref_service);
 }
 
 // static
 void ProfilePrefStoreManager::ClearResetTime(PrefService* pref_service) {
   PrefHashFilter::ClearResetTime(pref_service);
 }
 
@@ skipping 52 matching lines @@
 
   SetupTrackedPreferencesMigration(
       unprotected_pref_names, protected_pref_names,
       base::Bind(&RemoveValueSilently, unprotected_pref_store->AsWeakPtr()),
       base::Bind(&RemoveValueSilently, protected_pref_store->AsWeakPtr()),
       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
                  unprotected_pref_store->AsWeakPtr()),
       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
                  protected_pref_store->AsWeakPtr()),
       GetPrefHashStore(false), GetPrefHashStore(true),
-      std::unique_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
-          profile_path_.AsUTF8Unsafe(), local_state_)),
       raw_unprotected_pref_hash_filter, raw_protected_pref_hash_filter);
 
   return new SegregatedPrefStore(unprotected_pref_store, protected_pref_store,
                                  protected_pref_names);
 }
 
 bool ProfilePrefStoreManager::InitializePrefsFromMasterPrefs(
     const base::DictionaryValue& master_prefs) {
   // Create the profile directory if it doesn't exist yet (very possible on
   // first run).
@@ skipping 23 matching lines @@
   // be verboten. In this case however, we require this IO to synchronously
   // complete before Chrome can start (as master preferences seed the Local
   // State and Preferences files). This won't trip ThreadIORestrictions as they
   // won't have kicked in yet on the main thread.
   bool success = serializer.Serialize(*to_serialize);
 
   UMA_HISTOGRAM_BOOLEAN("Settings.InitializedFromMasterPrefs", success);
   return success;
 }
 
-PersistentPrefStore*
-ProfilePrefStoreManager::CreateDeprecatedCombinedProfilePrefStore(
-    const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) {
-  std::unique_ptr<PrefFilter> pref_filter;
-  if (kPlatformSupportsPreferenceTracking) {
-    std::unique_ptr<PrefHashStoreImpl> pref_hash_store_impl(
-        new PrefHashStoreImpl(seed_, device_id_, true));
-    pref_hash_store_impl->set_legacy_hash_store_contents(

[gab, 2016/07/04 15:21:46]

Also rm set_legacy_hash_store_contents() (was only caller).

[proberge, 2016/07/04 20:31:42]

Done. I think there's some logic that could be cleaned up in
pref_hash_calculator as well, but I'll leave that to you.

[gab, 2016/07/04 20:46:45]

Yes there is, we were going to switch the device ID being used to one that
doesn't depend on RLZ at some point (ask alito/robertshield), device_id_win.cc
actually has all the logic but it isn't hooked up to anything but its own
unittest...

That is still a worthwhile effort IMO and I was hoping cleaning up the old
device ID migration support could be bundled with that.

-        std::unique_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
-            profile_path_.AsUTF8Unsafe(), local_state_)));
-    pref_filter.reset(new PrefHashFilter(
-        std::move(pref_hash_store_impl), tracking_configuration_,
-        base::Closure(), NULL, reporting_ids_count_, false));
-  }
-  return new JsonPrefStore(profile_path_.Append(chrome::kPreferencesFilename),
-                           io_task_runner.get(), std::move(pref_filter));
-}
-
 std::unique_ptr<PrefHashStore> ProfilePrefStoreManager::GetPrefHashStore(
     bool use_super_mac) {
   DCHECK(kPlatformSupportsPreferenceTracking);
 
   return std::unique_ptr<PrefHashStore>(
       new PrefHashStoreImpl(seed_, device_id_, use_super_mac));
 }