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/file_util.h"
   9 #include "base/json/json_file_value_serializer.h"
  10 #include "base/logging.h"
  11 #include "base/metrics/histogram.h"
  12 #include "base/prefs/json_pref_store.h"
  13 #include "base/prefs/persistent_pref_store.h"
  14 #include "base/prefs/pref_registry_simple.h"
  15 #include "chrome/browser/prefs/pref_hash_store_impl.h"
  16 #include "chrome/browser/prefs/tracked/pref_service_hash_store_contents.h"
  17 #include "chrome/browser/prefs/tracked/segregated_pref_store.h"
  18 #include "chrome/browser/prefs/tracked/tracked_preferences_migration.h"
  19 #include "chrome/common/chrome_constants.h"
  20 #include "chrome/common/pref_names.h"
  21 #include "components/pref_registry/pref_registry_syncable.h"
  22
  23 namespace {
  24
  25 // An adaptor that allows a PrefHashStoreImpl to access a preference store
  26 // directly as a dictionary. Uses an equivalent layout to
  27 // PrefStoreHashStoreContents.
  28 class DictionaryHashStoreContents : public HashStoreContents {
  29  public:
  30   // Instantiates a HashStoreContents that is a copy of |to_copy|. The copy is
  31   // mutable but does not affect the original, nor is it persisted to disk in
  32   // any other way.
  33   explicit DictionaryHashStoreContents(const HashStoreContents& to_copy)
  34       : hash_store_id_(to_copy.hash_store_id()),
  35         super_mac_(to_copy.GetSuperMac()) {
  36     if (to_copy.IsInitialized())
  37       dictionary_.reset(to_copy.GetContents()->DeepCopy());
  38     int version = 0;
  39     if (to_copy.GetVersion(&version))
  40       version_.reset(new int(version));
  41   }
  42
  43   // HashStoreContents implementation
  44   virtual std::string hash_store_id() const OVERRIDE { return hash_store_id_; }
  45
  46   virtual void Reset() OVERRIDE {
  47     dictionary_.reset();
  48     super_mac_.clear();
  49     version_.reset();
  50   }
  51
  52   virtual bool IsInitialized() const OVERRIDE {
  53     return dictionary_;
  54   }
  55
  56   virtual const base::DictionaryValue* GetContents() const OVERRIDE{
  57     return dictionary_.get();
  58   }
  59
  60   virtual scoped_ptr<MutableDictionary> GetMutableContents() OVERRIDE {
  61     return scoped_ptr<MutableDictionary>(
  62         new SimpleMutableDictionary(this));
  63   }
  64
  65   virtual std::string GetSuperMac() const OVERRIDE { return super_mac_; }
  66
  67   virtual void SetSuperMac(const std::string& super_mac) OVERRIDE {
  68     super_mac_ = super_mac;
  69   }
  70
  71   virtual bool GetVersion(int* version) const OVERRIDE {
  72     if (!version_)
  73       return false;
  74     *version = *version_;
  75     return true;
  76   }
  77
  78   virtual void SetVersion(int version) OVERRIDE {
  79     version_.reset(new int(version));
  80   }
  81
  82   virtual void CommitPendingWrite() OVERRIDE {}
  83
  84  private:
  85   class SimpleMutableDictionary
  86       : public HashStoreContents::MutableDictionary {
  87    public:
  88     explicit SimpleMutableDictionary(DictionaryHashStoreContents* outer)
  89         : outer_(outer) {}
  90
  91     virtual ~SimpleMutableDictionary() {}
  92
  93     // MutableDictionary implementation
  94     virtual base::DictionaryValue* operator->() OVERRIDE {
  95       if (!outer_->dictionary_)
  96         outer_->dictionary_.reset(new base::DictionaryValue);
  97       return outer_->dictionary_.get();
  98     }
  99
 100    private:
 101     DictionaryHashStoreContents* outer_;
 102
 103     DISALLOW_COPY_AND_ASSIGN(SimpleMutableDictionary);
 104   };
 105
 106   const std::string hash_store_id_;
 107   std::string super_mac_;
 108   scoped_ptr<int> version_;
 109   scoped_ptr<base::DictionaryValue> dictionary_;
 110
 111   DISALLOW_COPY_AND_ASSIGN(DictionaryHashStoreContents);
 112 };
 113
 114 // An in-memory PrefStore backed by an immutable DictionaryValue.
 115 class DictionaryPrefStore : public PrefStore {
 116  public:
 117   explicit DictionaryPrefStore(const base::DictionaryValue* dictionary)
 118       : dictionary_(dictionary) {}
 119
 120   virtual bool GetValue(const std::string& key,
 121                         const base::Value** result) const OVERRIDE {
 122     const base::Value* tmp = NULL;
 123     if (!dictionary_->Get(key, &tmp))
 124       return false;
 125
 126     if (result)
 127       *result = tmp;
 128     return true;
 129   }
 130
 131  private:
 132   virtual ~DictionaryPrefStore() {}
 133
 134   const base::DictionaryValue* dictionary_;
 135
 136   DISALLOW_COPY_AND_ASSIGN(DictionaryPrefStore);
 137 };
 138
 139 // Waits for a PrefStore to be initialized and then initializes the
 140 // corresponding PrefHashStore.
 141 // The observer deletes itself when its work is completed.
 142 class InitializeHashStoreObserver : public PrefStore::Observer {
 143  public:
 144   // Creates an observer that will initialize |pref_hash_store| with the
 145   // contents of |pref_store| when the latter is fully loaded.
 146   InitializeHashStoreObserver(
 147       const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
 148           tracking_configuration,
 149       size_t reporting_ids_count,
 150       const scoped_refptr<PrefStore>& pref_store,
 151       scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl)
 152       : tracking_configuration_(tracking_configuration),
 153         reporting_ids_count_(reporting_ids_count),
 154         pref_store_(pref_store),
 155         pref_hash_store_impl_(pref_hash_store_impl.Pass()) {}
 156
 157   virtual ~InitializeHashStoreObserver();
 158
 159   // PrefStore::Observer implementation.
 160   virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
 161   virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
 162
 163  private:
 164   const std::vector<PrefHashFilter::TrackedPreferenceMetadata>
 165       tracking_configuration_;
 166   const size_t reporting_ids_count_;
 167   scoped_refptr<PrefStore> pref_store_;
 168   scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl_;
 169
 170   DISALLOW_COPY_AND_ASSIGN(InitializeHashStoreObserver);
 171 };
 172
 173 InitializeHashStoreObserver::~InitializeHashStoreObserver() {}
 174
 175 void InitializeHashStoreObserver::OnPrefValueChanged(const std::string& key) {}
 176
 177 void InitializeHashStoreObserver::OnInitializationCompleted(bool succeeded) {
 178   // If we successfully loaded the preferences _and_ the PrefHashStoreImpl
 179   // hasn't been initialized by someone else in the meantime, initialize it now.
 180   const PrefHashStoreImpl::StoreVersion pre_update_version =
 181       pref_hash_store_impl_->GetCurrentVersion();
 182   if (succeeded && pre_update_version < PrefHashStoreImpl::VERSION_LATEST) {
 183     PrefHashFilter(pref_hash_store_impl_.PassAs<PrefHashStore>(),
 184                    tracking_configuration_,
 185                    NULL,
 186                    reporting_ids_count_).Initialize(*pref_store_);
 187     UMA_HISTOGRAM_ENUMERATION(
 188         "Settings.TrackedPreferencesAlternateStoreVersionUpdatedFrom",
 189         pre_update_version,
 190         PrefHashStoreImpl::VERSION_LATEST + 1);
 191   }
 192   pref_store_->RemoveObserver(this);
 193   delete this;
 194 }
 195
 196 }  // namespace
 197
 198 // TODO(erikwright): Enable this on Chrome OS and Android once MACs are moved
 199 // out of Local State. This will resolve a race condition on Android and a
 200 // privacy issue on ChromeOS. http://crbug.com/349158
 201 const bool ProfilePrefStoreManager::kPlatformSupportsPreferenceTracking =
 202 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
 203     false;
 204 #else
 205     true;
 206 #endif
 207
 208 ProfilePrefStoreManager::ProfilePrefStoreManager(
 209     const base::FilePath& profile_path,
 210     const std::vector<PrefHashFilter::TrackedPreferenceMetadata>&
 211         tracking_configuration,
 212     size_t reporting_ids_count,
 213     const std::string& seed,
 214     const std::string& device_id,
 215     PrefService* local_state)
 216     : profile_path_(profile_path),
 217       tracking_configuration_(tracking_configuration),
 218       reporting_ids_count_(reporting_ids_count),
 219       seed_(seed),
 220       device_id_(device_id),
 221       local_state_(local_state) {}
 222
 223 ProfilePrefStoreManager::~ProfilePrefStoreManager() {}
 224
 225 // static
 226 void ProfilePrefStoreManager::RegisterPrefs(PrefRegistrySimple* registry) {
 227   PrefServiceHashStoreContents::RegisterPrefs(registry);
 228 }
 229
 230 // static
 231 void ProfilePrefStoreManager::RegisterProfilePrefs(
 232     user_prefs::PrefRegistrySyncable* registry) {
 233   PrefHashFilter::RegisterProfilePrefs(registry);
 234 }
 235
 236 // static
 237 base::FilePath ProfilePrefStoreManager::GetPrefFilePathFromProfilePath(
 238     const base::FilePath& profile_path) {
 239   return profile_path.Append(chrome::kPreferencesFilename);
 240 }
 241
 242 // static
 243 void ProfilePrefStoreManager::ResetAllPrefHashStores(PrefService* local_state) {
 244   PrefServiceHashStoreContents::ResetAllPrefHashStores(local_state);
 245 }
 246
 247 //  static
 248 base::Time ProfilePrefStoreManager::GetResetTime(PrefService* pref_service) {
 249   return PrefHashFilter::GetResetTime(pref_service);
 250 }
 251
 252 // static
 253 void ProfilePrefStoreManager::ClearResetTime(PrefService* pref_service) {
 254   PrefHashFilter::ClearResetTime(pref_service);
 255 }
 256
 257 void ProfilePrefStoreManager::ResetPrefHashStore() {
 258   if (kPlatformSupportsPreferenceTracking)
 259     GetPrefHashStoreImpl()->Reset();
 260 }
 261
 262 PersistentPrefStore* ProfilePrefStoreManager::CreateProfilePrefStore(
 263     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner,
 264     TrackedPreferenceValidationDelegate* validation_delegate) {
 265   scoped_ptr<PrefFilter> pref_filter;
 266   if (!kPlatformSupportsPreferenceTracking) {
 267     return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
 268                              io_task_runner,
 269                              scoped_ptr<PrefFilter>());
 270   }
 271
 272   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
 273       unprotected_configuration;
 274   std::vector<PrefHashFilter::TrackedPreferenceMetadata>
 275       protected_configuration;
 276   std::set<std::string> protected_pref_names;
 277   std::set<std::string> unprotected_pref_names;
 278   for (std::vector<PrefHashFilter::TrackedPreferenceMetadata>::const_iterator
 279            it = tracking_configuration_.begin();
 280        it != tracking_configuration_.end();
 281        ++it) {
 282     if (it->enforcement_level > PrefHashFilter::NO_ENFORCEMENT) {
 283       protected_configuration.push_back(*it);
 284       protected_pref_names.insert(it->name);
 285     } else {
 286       unprotected_configuration.push_back(*it);
 287       unprotected_pref_names.insert(it->name);
 288     }
 289   }
 290
 291   scoped_ptr<PrefHashFilter> unprotected_pref_hash_filter(
 292       new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
 293                          unprotected_configuration,
 294                          validation_delegate,
 295                          reporting_ids_count_));
 296   scoped_ptr<PrefHashFilter> protected_pref_hash_filter(
 297       new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
 298                          protected_configuration,
 299                          validation_delegate,
 300                          reporting_ids_count_));
 301
 302   PrefHashFilter* raw_unprotected_pref_hash_filter =
 303       unprotected_pref_hash_filter.get();
 304   PrefHashFilter* raw_protected_pref_hash_filter =
 305       protected_pref_hash_filter.get();
 306
 307   scoped_refptr<JsonPrefStore> unprotected_pref_store(
 308       new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
 309                         io_task_runner,
 310                         unprotected_pref_hash_filter.PassAs<PrefFilter>()));
 311   scoped_refptr<JsonPrefStore> protected_pref_store(new JsonPrefStore(
 312       profile_path_.Append(chrome::kProtectedPreferencesFilename),
 313       io_task_runner,
 314       protected_pref_hash_filter.PassAs<PrefFilter>()));
 315
 316   SetupTrackedPreferencesMigration(
 317       unprotected_pref_names,
 318       protected_pref_names,
 319       base::Bind(&JsonPrefStore::RemoveValueSilently,
 320                  unprotected_pref_store->AsWeakPtr()),
 321       base::Bind(&JsonPrefStore::RemoveValueSilently,
 322                  protected_pref_store->AsWeakPtr()),
 323       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
 324                  unprotected_pref_store->AsWeakPtr()),
 325       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
 326                  protected_pref_store->AsWeakPtr()),
 327       raw_unprotected_pref_hash_filter,
 328       raw_protected_pref_hash_filter);
 329
 330   return new SegregatedPrefStore(unprotected_pref_store, protected_pref_store,
 331                                  protected_pref_names);
 332 }
 333
 334 void ProfilePrefStoreManager::UpdateProfileHashStoreIfRequired(
 335     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) {
 336   if (!kPlatformSupportsPreferenceTracking)
 337     return;
 338   scoped_ptr<PrefHashStoreImpl> pref_hash_store_impl(GetPrefHashStoreImpl());
 339   const PrefHashStoreImpl::StoreVersion current_version =
 340       pref_hash_store_impl->GetCurrentVersion();
 341   UMA_HISTOGRAM_ENUMERATION("Settings.TrackedPreferencesAlternateStoreVersion",
 342                             current_version,
 343                             PrefHashStoreImpl::VERSION_LATEST + 1);
 344
 345   // Update the pref hash store if it's not at the latest version.
 346   if (current_version != PrefHashStoreImpl::VERSION_LATEST) {
 347     scoped_refptr<JsonPrefStore> pref_store =
 348         new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
 349                           io_task_runner,
 350                           scoped_ptr<PrefFilter>());
 351     pref_store->AddObserver(
 352         new InitializeHashStoreObserver(tracking_configuration_,
 353                                         reporting_ids_count_,
 354                                         pref_store,
 355                                         pref_hash_store_impl.Pass()));
 356     pref_store->ReadPrefsAsync(NULL);
 357   }
 358 }
 359
 360 bool ProfilePrefStoreManager::InitializePrefsFromMasterPrefs(
 361     const base::DictionaryValue& master_prefs) {
 362   // Create the profile directory if it doesn't exist yet (very possible on
 363   // first run).
 364   if (!base::CreateDirectory(profile_path_))
 365     return false;
 366
 367   // This will write out to a single combined file which will be immediately
 368   // migrated to two files on load.
 369   JSONFileValueSerializer serializer(
 370       GetPrefFilePathFromProfilePath(profile_path_));
 371
 372   // Call Serialize (which does IO) on the main thread, which would _normally_
 373   // be verboten. In this case however, we require this IO to synchronously
 374   // complete before Chrome can start (as master preferences seed the Local
 375   // State and Preferences files). This won't trip ThreadIORestrictions as they
 376   // won't have kicked in yet on the main thread.
 377   bool success = serializer.Serialize(master_prefs);
 378
 379   if (success && kPlatformSupportsPreferenceTracking) {
 380     scoped_refptr<const PrefStore> pref_store(
 381         new DictionaryPrefStore(&master_prefs));
 382     PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
 383                    tracking_configuration_,
 384                    NULL,
 385                    reporting_ids_count_).Initialize(*pref_store);
 386   }
 387
 388   UMA_HISTOGRAM_BOOLEAN("Settings.InitializedFromMasterPrefs", success);
 389   return success;
 390 }
 391
 392 PersistentPrefStore*
 393 ProfilePrefStoreManager::CreateDeprecatedCombinedProfilePrefStore(
 394     const scoped_refptr<base::SequencedTaskRunner>& io_task_runner) {
 395   scoped_ptr<PrefFilter> pref_filter;
 396   if (kPlatformSupportsPreferenceTracking) {
 397     pref_filter.reset(
 398         new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
 399                            tracking_configuration_,
 400                            NULL,
 401                            reporting_ids_count_));
 402   }
 403   return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
 404                            io_task_runner,
 405                            pref_filter.Pass());
 406 }
 407
 408 scoped_ptr<PrefHashStoreImpl> ProfilePrefStoreManager::GetPrefHashStoreImpl() {
 409   DCHECK(kPlatformSupportsPreferenceTracking);
 410
 411   return make_scoped_ptr(new PrefHashStoreImpl(
 412       seed_,
 413       device_id_,
 414       scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
 415           profile_path_.AsUTF8Unsafe(), local_state_))));
 416 }