chrome/browser/prefs/profile_pref_store_manager.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/prefs/profile_pref_store_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/callback.h"
   9 #include "base/files/file_util.h"
  10 #include "base/json/json_file_value_serializer.h"
  11 #include "base/logging.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/prefs/json_pref_store.h"
  14 #include "base/prefs/persistent_pref_store.h"
  15 #include "base/prefs/pref_registry_simple.h"
  16 #include "base/sequenced_task_runner.h"
  17 #include "chrome/browser/prefs/tracked/pref_hash_store_impl.h"
  18 #include "chrome/browser/prefs/tracked/pref_service_hash_store_contents.h"
  19 #include "chrome/browser/prefs/tracked/segregated_pref_store.h"
  20 #include "chrome/browser/prefs/tracked/tracked_preferences_migration.h"
  21 #include "chrome/common/chrome_constants.h"
  22 #include "chrome/common/pref_names.h"
  23 #include "components/pref_registry/pref_registry_syncable.h"
  24
  25 namespace {
  26
  27 void RemoveValueSilently(const base::WeakPtr<JsonPrefStore> pref_store,
  28                          const std::string& key) {
  29   if (pref_store) {
  30     pref_store->RemoveValueSilently(
  31         key, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
  32   }
  33 }
  34
  35 }  // namespace
  36
  37 // Preference tracking and protection is not required on platforms where other
  38 // apps do not have access to chrome's persistent storage.
  39 const bool ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking =
  40 #if defined(OS_ANDROID) || defined(OS_CHROMEOS) || defined(OS_IOS)
  41     false;
  42 #else
  43     true;
  44 #endif
  45
  46 ProfilePrefStoreManager::ProfilePrefStoreManager(
  47     const base::FilePath& profile_path,
  48     const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
  49         tracking_configuration,
  50     size_t reporting_ids_count,
  51     const std::string& seed,
  52     const std::string& device_id,
  53     PrefService* local_state)
  54     : profile_path_(profile_path),
  55       tracking_configuration_(tracking_configuration),
  56       reporting_ids_count_(reporting_ids_count),
  57       seed_(seed),
  58       device_id_(device_id),
  59       local_state_(local_state) {}
  60
  61 ProfilePrefStoreManager::~ProfilePrefStoreManager() {}
  62
  63 // static
  64 void ProfilePrefStoreManager::RegisterPrefs(PrefRegistrySimple* registry) {
  65   PrefServiceHashStoreContents::RegisterPrefs(registry);
  66 }
  67
  68 // static
  69 void ProfilePrefStoreManager::RegisterProfilePrefs(
  70     user_prefs::PrefRegistrySyncable* registry) {
  71   PrefHashFilter::RegisterProfilePrefs(registry);
  72 }
  73
  74 // static
  75 base::FilePath ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
  76     const base::FilePath& profile_path) {
  77   return profile_path.Append(chrome::kPreferencesFilename);
  78 }
  79
  80 // static
  81 void ProfilePrefStoreManager::ResetAllPrefHashStores(PrefService* local_state) {
  82   PrefServiceHashStoreContents::ResetAllPrefHashStores(local_state);
  83 }
  84
  85 //  static
  86 base::Time ProfilePrefStoreManager::GetResetTime(PrefService* pref_service) {
  87   return PrefHashFilter::GetResetTime(pref_service);
  88 }
  89
  90 // static
  91 void ProfilePrefStoreManager::ClearResetTime(PrefService* pref_service) {
  92   PrefHashFilter::ClearResetTime(pref_service);
  93 }
  94
  95 PersistentPrefStore* ProfilePrefStoreManager::CreateProfilePrefStore(
  96     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
  97     const base::Closure& on_reset_on_load,
  98     TrackedPreferenceValidationDelegate* validation_delegate) {
  99   scoped_ptr<PrefFilter> pref_filter;
 100   if (!kPlatformSupportsPreferenceTracking) {
 101     return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
 102                              io_task_runner.get(),
 103                              scoped_ptr<PrefFilter>());
 104   }
 105
 106   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
 107       unprotected_configuration;
 108   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
 109       protected_configuration;
 110   std::set<std::string> protected_pref_names;
 111   std::set<std::string> unprotected_pref_names;
 112   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::const_iterator
 113            it = tracking_configuration_.begin();
 114        it != tracking_configuration_.end();
 115        ++it) {
 116     if (it->enforcement_level > PrefHashFilter::NO_ENFORCEMENT) {
 117       protected_configuration.push_back(*it);
 118       protected_pref_names.insert(it->name);
 119     } else {
 120       unprotected_configuration.push_back(*it);
 121       unprotected_pref_names.insert(it->name);
 122     }
 123   }
 124
 125   scoped_ptr<PrefHashFilter> unprotected_pref_hash_filter(
 126       new PrefHashFilter(GetPrefHashStore(false),
 127                          unprotected_configuration,
 128                          base::Closure(),
 129                          validation_delegate,
 130                          reporting_ids_count_,
 131                          false));
 132   scoped_ptr<PrefHashFilter> protected_pref_hash_filter(
 133       new PrefHashFilter(GetPrefHashStore(true),
 134                          protected_configuration,
 135                          on_reset_on_load,
 136                          validation_delegate,
 137                          reporting_ids_count_,
 138                          true));
 139
 140   PrefHashFilter* raw_unprotected_pref_hash_filter =
 141       unprotected_pref_hash_filter.get();
 142   PrefHashFilter* raw_protected_pref_hash_filter =
 143       protected_pref_hash_filter.get();
 144
 145   scoped_refptr<JsonPrefStore> unprotected_pref_store(
 146       new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
 147                         io_task_runner.get(),
 148                         unprotected_pref_hash_filter.Pass()));
 149   // TODO(gab): Remove kDeprecatedProtectedPreferencesFilename as an alternate
 150   // file in M40+.
 151   scoped_refptr<JsonPrefStore> protected_pref_store(new JsonPrefStore(
 152       profile_path_.Append(chrome::kSecurePreferencesFilename),
 153       profile_path_.Append(chrome::kProtectedPreferencesFilenameDeprecated),
 154       io_task_runner.get(),
 155       protected_pref_hash_filter.Pass()));
 156
 157   SetupTrackedPreferencesMigration(
 158       unprotected_pref_names, protected_pref_names,
 159       base::Bind(&RemoveValueSilently, unprotected_pref_store->AsWeakPtr()),
 160       base::Bind(&RemoveValueSilently, protected_pref_store->AsWeakPtr()),
 161       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
 162                  unprotected_pref_store->AsWeakPtr()),
 163       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
 164                  protected_pref_store->AsWeakPtr()),
 165       GetPrefHashStore(false), GetPrefHashStore(true),
 166       scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
 167           profile_path_.AsUTF8Unsafe(), local_state_)),
 168       raw_unprotected_pref_hash_filter, raw_protected_pref_hash_filter);
 169
 170   return new SegregatedPrefStore(unprotected_pref_store, protected_pref_store,
 171                                  protected_pref_names);
 172 }
 173
 174 bool ProfilePrefStoreManager::InitializePrefsFromMasterPrefs(
 175     const base::DictionaryValue& master_prefs) {
 176   // Create the profile directory if it doesn't exist yet (very possible on
 177   // first run).
 178   if (!base::CreateDirectory(profile_path_))
 179     return false;
 180
 181   const base::DictionaryValue* to_serialize = &master_prefs;
 182   scoped_ptr<base::DictionaryValue> copy;
 183
 184   if (kPlatformSupportsPreferenceTracking) {
 185     copy.reset(master_prefs.DeepCopy());
 186     to_serialize = copy.get();
 187     PrefHashFilter(GetPrefHashStore(false),
 188                    tracking_configuration_,
 189                    base::Closure(),
 190                    NULL,
 191                    reporting_ids_count_,
 192                    false).Initialize(copy.get());
 193   }
 194
 195   // This will write out to a single combined file which will be immediately
 196   // migrated to two files on load.
 197   JSONFileValueSerializer serializer(
 198       GetPrefFilePathFromProfilePath(profile_path_));
 199
 200   // Call Serialize (which does IO) on the main thread, which would _normally_
 201   // be verboten. In this case however, we require this IO to synchronously
 202   // complete before Chrome can start (as master preferences seed the Local
 203   // State and Preferences files). This won't trip ThreadIORestrictions as they
 204   // won't have kicked in yet on the main thread.
 205   bool success = serializer.Serialize(*to_serialize);
 206
 207   UMA_HISTOGRAM_BOOLEAN("Settings.InitializedFromMasterPrefs", success);
 208   return success;
 209 }
 210
 211 PersistentPrefStore*
 212 ProfilePrefStoreManager::CreateDeprecatedCombinedProfilePrefStore(
 213     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) {
 214   scoped_ptr<PrefFilter> pref_filter;
 215   if (kPlatformSupportsPreferenceTracking) {
 216     scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl(
 217         new PrefHashStoreImpl(seed_, device_id_, true));
 218     pref_hash_store_impl->set_legacy_hash_store_contents(
 219         scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
 220             profile_path_.AsUTF8Unsafe(), local_state_)));
 221     pref_filter.reset(new PrefHashFilter(pref_hash_store_impl.Pass(),
 222                                          tracking_configuration_,
 223                                          base::Closure(),
 224                                          NULL,
 225                                          reporting_ids_count_,
 226                                          false));
 227   }
 228   return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
 229                            io_task_runner.get(),
 230                            pref_filter.Pass());
 231 }
 232
 233 scoped_ptr<PrefHashStore> ProfilePrefStoreManager::GetPrefHashStore(
 234     bool use_super_mac) {
 235   DCHECK(kPlatformSupportsPreferenceTracking);
 236
 237   return scoped_ptr<PrefHashStore>(new PrefHashStoreImpl(
 238       seed_,
 239       device_id_,
 240       use_super_mac));
 241 }