Let chrome_prefs handle Preferences initialization from master_preferences.

chrome/browser/profiles/profile_impl.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/profiles/profile_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
+#include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/prefs/json_pref_store.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/sequenced_worker_pool.h"
@@ skipping 387 matching lines @@
       prefs::kClearSiteDataOnExit,
       false,
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
 // static
 void ProfileImpl::InitializePrefHashStoreIfRequired(
     const base::FilePath& profile_path) {
   scoped_ptr<PrefHashStoreImpl> pref_hash_store(GetPrefHashStore(profile_path));
   if (pref_hash_store && !pref_hash_store->IsInitialized()) {
-    chrome_prefs::InitializeHashStoreForPrefFile(
+    chrome_prefs::InitializeHashStoreFromPrefFile(
         GetPrefFilePathFromProfilePath(profile_path),
         JsonPrefStore::GetTaskRunnerForFile(
             profile_path, BrowserThread::GetBlockingPool()),
         pref_hash_store.PassAs<PrefHashStore>());
   }
 }
 
 // static
 void ProfileImpl::ResetPrefHashStore(const base::FilePath& profile_path) {
   GetPrefHashStore(profile_path)->Reset();
 }
 
+// static
+bool ProfileImpl::InitializePrefsFromMasterPrefs(

[noms (inactive), 2014/02/04 20:36:35]

As discussed offline, these prefs related methods would probably live a better
life if they got moved out of profiles and into somewhere else like
chrome_prefs. The only Profile thing (other than the profile path) this method
needs is GetPrefHashStore, and that doesn't seem to actually need any Profile
specific things, (other than that path)

+    const base::FilePath& profile_path,
+    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;
+
+  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) {
+    scoped_ptr<PrefHashStore> pref_hash_store(GetPrefHashStore(profile_path));
+    chrome_prefs::InitializeHashStoreFromMasterPrefs(master_prefs,
+                                                     pref_hash_store.Pass());
+  }
+
+  UMA_HISTOGRAM_BOOLEAN("Settings.InitializedFromMasterPrefs", success);
+  return success;
+}
+
 ProfileImpl::ProfileImpl(
     const base::FilePath& path,
     Delegate* delegate,
     CreateMode create_mode,
     base::SequencedTaskRunner* sequenced_task_runner)
     : path_(path),
       pref_registry_(new user_prefs::PrefRegistrySyncable),
       io_data_(this),
       host_content_settings_map_(NULL),
       last_session_exit_type_(EXIT_NORMAL),
@@ skipping 901 matching lines @@
 PrefProxyConfigTracker* ProfileImpl::CreateProxyConfigTracker() {
 #if defined(OS_CHROMEOS)
   if (chromeos::ProfileHelper::IsSigninProfile(this)) {
     return ProxyServiceFactory::CreatePrefProxyConfigTrackerOfLocalState(
         g_browser_process->local_state());
   }
 #endif  // defined(OS_CHROMEOS)
   return ProxyServiceFactory::CreatePrefProxyConfigTrackerOfProfile(
       GetPrefs(), g_browser_process->local_state());
 }