Move preference MACs to the protected preference stores.

chrome/browser/prefs/chrome_pref_service_factory.cc

 // Copyright (c) 2012 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/chrome_pref_service_factory.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 375 matching lines @@
 
   factory->set_async(async);
   factory->set_extension_prefs(extension_prefs);
   factory->set_command_line_prefs(
       make_scoped_refptr(
           new CommandLinePrefStore(CommandLine::ForCurrentProcess())));
   factory->set_read_error_callback(base::Bind(&HandleReadError));
   factory->set_user_prefs(user_pref_store);
 }
 
-// Initialize/update preference hash stores for all profiles but the one whose
-// path matches |ignored_profile_path|.
-void UpdateAllPrefHashStoresIfRequired(
-    const base::FilePath& ignored_profile_path) {
-  const ProfileInfoCache& profile_info_cache =
-      g_browser_process->profile_manager()->GetProfileInfoCache();
-  const size_t n_profiles = profile_info_cache.GetNumberOfProfiles();
-  for (size_t i = 0; i < n_profiles; ++i) {
-    const base::FilePath profile_path =
-        profile_info_cache.GetPathOfProfileAtIndex(i);
-    if (profile_path != ignored_profile_path) {
-      CreateProfilePrefStoreManager(profile_path)
-          ->UpdateProfileHashStoreIfRequired(
-              JsonPrefStore::GetTaskRunnerForFile(
-                  profile_path, BrowserThread::GetBlockingPool()));
-    }
-  }
-}
-
 }  // namespace
 
 namespace chrome_prefs {
 
 namespace internals {
 
 const char kSettingsEnforcementTrialName[] = "SettingsEnforcement";
 const char kSettingsEnforcementGroupNoEnforcement[] = "no_enforcement";
 const char kSettingsEnforcementGroupEnforceOnload[] = "enforce_on_load";
 const char kSettingsEnforcementGroupEnforceAlways[] = "enforce_always";
@@ skipping 62 matching lines @@
       base::TimeDelta::FromSeconds(g_disable_delays_and_domain_check_for_testing
                                        ? 0
                                        : kVerifyPrefsFileDelaySeconds));
 #endif
 }
 
 void DisableDelaysAndDomainCheckForTesting() {
   g_disable_delays_and_domain_check_for_testing = true;
 }
 
-void SchedulePrefHashStoresUpdateCheck(
-    const base::FilePath& initial_profile_path) {
-  if (!ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking) {
-    ProfilePrefStoreManager::ResetAllPrefHashStores(
-        g_browser_process->local_state());
-    return;
-  }
-
-  if (GetSettingsEnforcementGroup() >= GROUP_ENFORCE_ALWAYS)
-    return;
-
-  const int kDefaultPrefHashStoresUpdateCheckDelaySeconds = 55;
-  BrowserThread::PostDelayedTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&UpdateAllPrefHashStoresIfRequired,
-                   initial_profile_path),
-        base::TimeDelta::FromSeconds(
-            g_disable_delays_and_domain_check_for_testing ?
-                0 : kDefaultPrefHashStoresUpdateCheckDelaySeconds));
-}
-
 void ResetPrefHashStore(const base::FilePath& profile_path) {
   CreateProfilePrefStoreManager(profile_path)->ResetPrefHashStore();
 }
 
 bool InitializePrefsFromMasterPrefs(
     const base::FilePath& profile_path,
     const base::DictionaryValue& master_prefs) {
   return CreateProfilePrefStoreManager(profile_path)
       ->InitializePrefsFromMasterPrefs(master_prefs);
 }
 
 base::Time GetResetTime(Profile* profile) {
   return ProfilePrefStoreManager::GetResetTime(profile->GetPrefs());
 }
 
 void ClearResetTime(Profile* profile) {
   ProfilePrefStoreManager::ClearResetTime(profile->GetPrefs());
 }
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   ProfilePrefStoreManager::RegisterProfilePrefs(registry);
 }
 
 void RegisterPrefs(PrefRegistrySimple* registry) {
   ProfilePrefStoreManager::RegisterPrefs(registry);
 }
 
 }  // namespace chrome_prefs