Let chrome_prefs handle Preferences initialization from master_preferences.

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 "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/default_pref_store.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/pref_filter.h"
 #include "base/prefs/pref_notifier_impl.h"
 #include "base/prefs/pref_registry.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/pref_store.h"
 #include "base/prefs/pref_value_store.h"
+#include "base/values.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_hash_store.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/ui/profile_error_dialog.h"
 #include "chrome/common/pref_names.h"
 #include "components/user_prefs/pref_registry_syncable.h"
@@ skipping 226 matching lines @@
   scoped_ptr<PrefFilter> pref_filter;
   if (pref_hash_store)
     pref_filter = CreatePrefHashFilter(pref_hash_store.Pass());
   factory->set_user_prefs(
       new JsonPrefStore(
           pref_filename,
           pref_io_task_runner,
           pref_filter.Pass()));
 }
 
+// An in-memory PrefStore backed by an immutable DictionaryValue.
+class DictionaryPrefStore : public PrefStore {
+ public:
+  explicit DictionaryPrefStore(const base::DictionaryValue* dictionary)
+      : dictionary_(dictionary) {}
+
+  virtual bool GetValue(const std::string& key,
+                        const base::Value** result) const OVERRIDE {
+    const base::Value* tmp = NULL;
+    if (!dictionary_->Get(key, &tmp))
+      return false;
+
+    if (result)
+      *result = tmp;
+    return true;
+  }
+
+ protected:
+  virtual ~DictionaryPrefStore() {}

[Bernhard Bauer, 2014/02/04 09:08:02]

Nit: Make the destructor private? Protected implies to me that you're intending
to subclass it.

[gab, 2014/02/04 14:01:04]

Done.

+
+ private:
+  const base::DictionaryValue* dictionary_;
+
+  DISALLOW_COPY_AND_ASSIGN(DictionaryPrefStore);
+};
+
 // Waits for a PrefStore to be initialized and then initializes the
 // corresponding PrefHashStore.
 // The observer deletes itself when its work is completed.
 class InitializeHashStoreObserver : public PrefStore::Observer {
  public:
   // Creates an observer that will initialize |pref_hash_store| with the
   // contents of |pref_store| when the latter is fully loaded.
   InitializeHashStoreObserver(const scoped_refptr<PrefStore>& pref_store,
                               scoped_ptr<PrefHashStore> pref_hash_store)
       : pref_store_(pref_store), pref_hash_store_(pref_hash_store.Pass()) {}
@@ skipping 11 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(InitializeHashStoreObserver);
 };
 
 InitializeHashStoreObserver::~InitializeHashStoreObserver() {}
 
 void InitializeHashStoreObserver::OnPrefValueChanged(const std::string& key) {}
 
 void InitializeHashStoreObserver::OnInitializationCompleted(bool succeeded) {
   // If we successfully loaded the preferences _and_ the PrefHashStore hasn't
   // been initialized by someone else in the meantime initialize it now.
-  if (succeeded & !pref_hash_store_->IsInitialized())
-    CreatePrefHashFilter(pref_hash_store_.Pass())->Initialize(pref_store_);
+  if (succeeded & !pref_hash_store_->IsInitialized()) {
+    CreatePrefHashFilter(
+        pref_hash_store_.Pass())->Initialize(*pref_store_);
+    UMA_HISTOGRAM_BOOLEAN(
+        "Settings.TrackedPreferencesInitializedForUnloadedProfile", true);
+  }
   pref_store_->RemoveObserver(this);
   delete this;
 }
 
 }  // namespace
 
 namespace chrome_prefs {
 
 scoped_ptr<PrefService> CreateLocalState(
     const base::FilePath& pref_filename,
@@ skipping 28 matching lines @@
                  pref_filename,
                  pref_io_task_runner,
                  policy_service,
                  managed_user_settings,
                  pref_hash_store.Pass(),
                  extension_prefs,
                  async);
   return factory.CreateSyncable(pref_registry.get());
 }
 
-void InitializeHashStoreForPrefFile(
+void InitializeHashStoreFromPrefFile(
     const base::FilePath& pref_filename,
     base::SequencedTaskRunner* pref_io_task_runner,
     scoped_ptr<PrefHashStore> pref_hash_store) {
   scoped_refptr<JsonPrefStore> pref_store(
       new JsonPrefStore(pref_filename,
                         pref_io_task_runner,
                         scoped_ptr<PrefFilter>()));
   pref_store->AddObserver(
       new InitializeHashStoreObserver(pref_store, pref_hash_store.Pass()));
   pref_store->ReadPrefsAsync(NULL);
 }
 
+void InitializeHashStoreFromMasterPrefs(
+    const base::DictionaryValue& master_prefs,
+    scoped_ptr<PrefHashStore> pref_hash_store) {
+  scoped_refptr<const PrefStore> pref_store(
+      new DictionaryPrefStore(&master_prefs));
+  CreatePrefHashFilter(pref_hash_store.Pass())->Initialize(*pref_store);
+}
+
 }  // namespace chrome_prefs