Remove unloaded profile hash store initialization,

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 14 matching lines @@
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
 #include "chrome/browser/prefs/pref_hash_filter.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/browser/prefs/pref_service_syncable.h"
 #include "chrome/browser/prefs/pref_service_syncable_factory.h"
 #include "chrome/browser/prefs/profile_pref_store_manager.h"
 #include "chrome/browser/profiles/file_path_verifier_win.h"
-#include "chrome/browser/profiles/profile_info_cache.h"
-#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/default_search_manager.h"
 #include "chrome/browser/search_engines/default_search_pref_migration.h"
 #include "chrome/browser/ui/profile_error_dialog.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/pref_names.h"
 #include "grit/browser_resources.h"
@@ skipping 130 matching lines @@
 
 // The count of tracked preferences IDs across all platforms.
 const size_t kTrackedPrefsReportingIDsCount = 16;
 COMPILE_ASSERT(kTrackedPrefsReportingIDsCount >= arraysize(kTrackedPrefs),
                need_to_increment_ids_count);
 
 // Each group enforces a superset of the protection provided by the previous
 // one.
 enum SettingsEnforcementGroup {
   GROUP_NO_ENFORCEMENT,
-  // Only enforce settings on profile loads; still allow seeding of unloaded
-  // profiles.
-  GROUP_ENFORCE_ON_LOAD,
-  // Also disallow seeding of unloaded profiles.
+  // Enforce protected settings on profile loads.
   GROUP_ENFORCE_ALWAYS,
   // Also enforce extension settings.
   GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS,
   // Also enforce extension settings and default search.
   GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS_AND_DSE,
   // The default enforcement group contains all protection features.
   GROUP_ENFORCE_DEFAULT
 };
 
 SettingsEnforcementGroup GetSettingsEnforcementGroup() {
@@ skipping 10 matching lines @@
       return GROUP_NO_ENFORCEMENT;
   }
 #endif
 
   struct {
     const char* group_name;
     SettingsEnforcementGroup group;
   } static const kEnforcementLevelMap[] = {
     { chrome_prefs::internals::kSettingsEnforcementGroupNoEnforcement,
       GROUP_NO_ENFORCEMENT },
-    { chrome_prefs::internals::kSettingsEnforcementGroupEnforceOnload,
-      GROUP_ENFORCE_ON_LOAD },
     { chrome_prefs::internals::kSettingsEnforcementGroupEnforceAlways,
       GROUP_ENFORCE_ALWAYS },
     { chrome_prefs::internals::
           kSettingsEnforcementGroupEnforceAlwaysWithExtensions,
       GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS },
     { chrome_prefs::internals::
           kSettingsEnforcementGroupEnforceAlwaysWithExtensionsAndDSE,
       GROUP_ENFORCE_ALWAYS_WITH_EXTENSIONS_AND_DSE },
   };
 
   // Use the no enforcement setting in the absence of a field trial
-  // config. Remember to update the OFFICIAL_BUILD sections of
-  // pref_hash_browsertest.cc and extension_startup_browsertest.cc when updating
-  // the default value below.
+  // config. Remember to update the OFFICIAL_BUILD section of
+  // extension_startup_browsertest.cc when updating the default value below.
   // TODO(gab): Change this to the strongest enforcement on all platforms.
   SettingsEnforcementGroup enforcement_group = GROUP_NO_ENFORCEMENT;
   bool group_determined_from_trial = false;
   base::FieldTrial* trial =
       base::FieldTrialList::Find(
           chrome_prefs::internals::kSettingsEnforcementTrialName);
   if (trial) {
     const std::string& group_name = trial->group_name();
     // ARRAYSIZE_UNSAFE must be used since the array is declared locally; it is
     // only unsafe because it could not trigger a compile error on some
@@ skipping 134 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";
 const char kSettingsEnforcementGroupEnforceAlwaysWithExtensions[] =
     "enforce_always_with_extensions";
 const char kSettingsEnforcementGroupEnforceAlwaysWithExtensionsAndDSE[] =
     "enforce_always_with_extensions_and_dse";
 
 }  // namespace internals
 
 scoped_ptr<PrefService> CreateLocalState(
     const base::FilePath& pref_filename,
@@ skipping 53 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