Move preference MACs to the protected preference stores.

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 "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
@@ skipping 46 matching lines @@
     return scoped_ptr<MutableDictionary>(
         new SimpleMutableDictionary(this));
   }
 
   virtual std::string GetSuperMac() const OVERRIDE { return super_mac_; }
 
   virtual void SetSuperMac(const std::string& super_mac) OVERRIDE {
     super_mac_ = super_mac;
   }
 
-  virtual void CommitPendingWrite() OVERRIDE {}
-
  private:
   class SimpleMutableDictionary
       : public HashStoreContents::MutableDictionary {
    public:
     explicit SimpleMutableDictionary(DictionaryHashStoreContents* outer)
         : outer_(outer) {}
 
     virtual ~SimpleMutableDictionary() {}
 
     // MutableDictionary implementation
@@ skipping 125 matching lines @@
     if (it->enforcement_level > PrefHashFilter::NO_ENFORCEMENT) {
       protected_configuration.push_back(*it);
       protected_pref_names.insert(it->name);
     } else {
       unprotected_configuration.push_back(*it);
       unprotected_pref_names.insert(it->name);
     }
   }
 
   scoped_ptr<PrefHashFilter> unprotected_pref_hash_filter(
-      new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
+      new PrefHashFilter(GetPrefHashStoreImpl(false).PassAs<PrefHashStore>(),
                          unprotected_configuration,
                          validation_delegate,
                          reporting_ids_count_));
   scoped_ptr<PrefHashFilter> protected_pref_hash_filter(
-      new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
+      new PrefHashFilter(GetPrefHashStoreImpl(true).PassAs<PrefHashStore>(),
                          protected_configuration,
                          validation_delegate,
                          reporting_ids_count_));
 
   PrefHashFilter* raw_unprotected_pref_hash_filter =
       unprotected_pref_hash_filter.get();
   PrefHashFilter* raw_protected_pref_hash_filter =
       protected_pref_hash_filter.get();
 
   scoped_refptr<JsonPrefStore> unprotected_pref_store(
       new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
                         io_task_runner,
                         unprotected_pref_hash_filter.PassAs<PrefFilter>()));
   scoped_refptr<JsonPrefStore> protected_pref_store(new JsonPrefStore(
       profile_path_.Append(chrome::kProtectedPreferencesFilename),
       io_task_runner,
       protected_pref_hash_filter.PassAs<PrefFilter>()));
 
   SetupTrackedPreferencesMigration(
       unprotected_pref_names,
       protected_pref_names,
       base::Bind(&JsonPrefStore::RemoveValueSilently,
                  unprotected_pref_store->AsWeakPtr()),
       base::Bind(&JsonPrefStore::RemoveValueSilently,
                  protected_pref_store->AsWeakPtr()),
       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
                  unprotected_pref_store->AsWeakPtr()),
       base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteCallback,
                  protected_pref_store->AsWeakPtr()),
+      GetPrefHashStoreImpl(false).PassAs<PrefHashStore>(),
+      GetPrefHashStoreImpl(true).PassAs<PrefHashStore>(),
+      scoped_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).
   if (!base::CreateDirectory(profile_path_))
     return false;
 
+  const base::DictionaryValue* to_serialize = &master_prefs;
+  scoped_ptr<base::DictionaryValue> copy;
+
+  if (kPlatformSupportsPreferenceTracking) {
+    copy.reset(master_prefs.DeepCopy());
+    to_serialize = copy.get();
+    PrefHashFilter(GetPrefHashStoreImpl(false).PassAs<PrefHashStore>(),
+                   tracking_configuration_,
+                   NULL,
+                   reporting_ids_count_).Initialize(copy.get());
+  }
+
   // This will write out to a single combined file which will be immediately
   // migrated to two files on load.
   JSONFileValueSerializer serializer(
       GetPrefFilePathFromProfilePath(profile_path_));
 
   // Call Serialize (which does IO) on the main thread, which would _normally_
   // 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(master_prefs);
-
-  if (success && kPlatformSupportsPreferenceTracking) {
-    scoped_refptr<const PrefStore> pref_store(
-        new DictionaryPrefStore(&master_prefs));
-    PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
-                   tracking_configuration_,
-                   NULL,
-                   reporting_ids_count_).Initialize(*pref_store);
-  }
+  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) {
-  scoped_ptr<PrefFilter> pref_filter;
-  if (kPlatformSupportsPreferenceTracking) {
-    pref_filter.reset(
-        new PrefHashFilter(GetPrefHashStoreImpl().PassAs<PrefHashStore>(),
-                           tracking_configuration_,
-                           NULL,
-                           reporting_ids_count_));
-  }
-  return new JsonPrefStore(GetPrefFilePathFromProfilePath(profile_path_),
-                           io_task_runner,
-                           pref_filter.Pass());
-}
-
-scoped_ptr<PrefHashStoreImpl> ProfilePrefStoreManager::GetPrefHashStoreImpl() {
+scoped_ptr<PrefHashStoreImpl> ProfilePrefStoreManager::GetPrefHashStoreImpl(
+    bool use_super_mac) {
   DCHECK(kPlatformSupportsPreferenceTracking);
 
   return make_scoped_ptr(new PrefHashStoreImpl(
       seed_,
       device_id_,
-      scoped_ptr<HashStoreContents>(new PrefServiceHashStoreContents(
-          profile_path_.AsUTF8Unsafe(), local_state_)),
-      true));
+      use_super_mac));
 }