Reinitialize LocalState's CommandLinePrefStore after about_flags updates the command line.

chrome/browser/prefs/pref_service.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/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 162 matching lines @@
           pref_sync_associator,
           pref_notifier),
       user,
       default_pref_store,
       pref_sync_associator,
       async);
 }
 
 PrefService* PrefService::CreateIncognitoPrefService(
     PrefStore* incognito_extension_prefs) {
+  pref_service_forked_ = true;
   PrefNotifierImpl* pref_notifier = new PrefNotifierImpl();
   OverlayUserPrefStore* incognito_pref_store =
       new OverlayUserPrefStore(user_pref_store_.get());
   PrefsTabHelper::InitIncognitoUserPrefStore(incognito_pref_store);
   return new PrefService(
       pref_notifier,
       pref_value_store_->CloneAndSpecialize(
-          NULL, // managed_platform_prefs
-          NULL, // managed_cloud_prefs
+          NULL,  // managed_platform_prefs
+          NULL,  // managed_cloud_prefs
           incognito_extension_prefs,
-          NULL, // command_line_prefs
+          NULL,  // command_line_prefs
           incognito_pref_store,
-          NULL, // recommended_platform_prefs
-          NULL, // recommended_cloud_prefs
+          NULL,  // recommended_platform_prefs
+          NULL,  // recommended_cloud_prefs
           default_store_.get(),
-          NULL, // pref_sync_associator
+          NULL,  // pref_sync_associator
           pref_notifier),
       incognito_pref_store,
       default_store_.get(),
       NULL,
       false);
 }
 
 PrefService* PrefService::CreatePrefServiceWithPerTabPrefStore() {
+  pref_service_forked_ = true;
   PrefNotifierImpl* pref_notifier = new PrefNotifierImpl();
   OverlayUserPrefStore* per_tab_pref_store =
       new OverlayUserPrefStore(user_pref_store_.get());
   PrefsTabHelper::InitPerTabUserPrefStore(per_tab_pref_store);
   DefaultPrefStore* default_store = new DefaultPrefStore();
   return new PrefService(
       pref_notifier,
       pref_value_store_->CloneAndSpecialize(
-          NULL, // managed_platform_prefs
-          NULL, // managed_cloud_prefs
-          NULL, // extension_prefs
-          NULL, // command_line_prefs
+          NULL,  // managed_platform_prefs
+          NULL,  // managed_cloud_prefs
+          NULL,  // extension_prefs
+          NULL,  // command_line_prefs
           per_tab_pref_store,
-          NULL, // recommended_platform_prefs
-          NULL, // recommended_cloud_prefs
+          NULL,  // recommended_platform_prefs
+          NULL,  // recommended_cloud_prefs
           default_store,
           NULL,
           pref_notifier),
       per_tab_pref_store,
       default_store,
       NULL,
       false);
 }
 
 PrefService::PrefService(PrefNotifierImpl* pref_notifier,
                          PrefValueStore* pref_value_store,
                          PersistentPrefStore* user_prefs,
                          DefaultPrefStore* default_store,
                          PrefModelAssociator* pref_sync_associator,
                          bool async)
     : pref_notifier_(pref_notifier),
       pref_value_store_(pref_value_store),
       user_pref_store_(user_prefs),
       default_store_(default_store),
-      pref_sync_associator_(pref_sync_associator) {
+      pref_sync_associator_(pref_sync_associator),
+      pref_service_forked_(false) {
   pref_notifier_->SetPrefService(this);
   if (pref_sync_associator_.get())
     pref_sync_associator_->SetPrefService(this);
   InitFromStorage(async);
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
   STLDeleteContainerPointers(prefs_.begin(), prefs_.end());
   prefs_.clear();
@@ skipping 25 matching lines @@
 }
 
 void PrefService::CommitPendingWrite() {
   DCHECK(CalledOnValidThread());
   user_pref_store_->CommitPendingWrite();
 }
 
 namespace {
 
 // If there's no g_browser_process or no local state, return true (for testing).
-bool IsLocalStatePrefService(PrefService* prefs){
+bool IsLocalStatePrefService(PrefService* prefs) {
   return (!g_browser_process ||
           !g_browser_process->local_state() ||
           g_browser_process->local_state() == prefs);
 }
 
 // If there's no g_browser_process, return true (for testing).
-bool IsProfilePrefService(PrefService* prefs){
+bool IsProfilePrefService(PrefService* prefs) {
   // TODO(zea): uncomment this once all preferences are only ever registered
   // with either the local_state's pref service or the profile's pref service.
   // return (!g_browser_process || g_browser_process->local_state() != prefs);
   return true;
 }
 
 }  // namespace
 
 
 // Local State prefs.
@@ skipping 207 matching lines @@
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(path, default_value, sync_status);
 }
 
 void PrefService::RegisterLocalizedBooleanPref(const char* path,
                                                int locale_default_message_id,
                                                PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(
       path,
-      CreateLocaleDefaultValue(Value::TYPE_BOOLEAN,locale_default_message_id),
+      CreateLocaleDefaultValue(Value::TYPE_BOOLEAN, locale_default_message_id),
       sync_status);
 }
 
 void PrefService::RegisterLocalizedIntegerPref(const char* path,
                                                int locale_default_message_id,
                                                PrefSyncStatus sync_status) {
   DCHECK(IsProfilePrefService(this));
   RegisterPreference(
       path,
       CreateLocaleDefaultValue(Value::TYPE_INTEGER, locale_default_message_id),
@@ skipping 343 matching lines @@
     return;
   }
 
   user_pref_store_->SetValue(path, owned_value.release());
 }
 
 SyncableService* PrefService::GetSyncableService() {
   return pref_sync_associator_.get();
 }
 
+void PrefService::UpdateCommandLinePrefStore(CommandLine* command_line) {
+  // If |pref_service_forked_| is true, then this PrefService and the forked
+  // copies will be out of sync.
+  DCHECK(!pref_service_forked_);
+  pref_value_store_->UpdateCommandLinePrefStore(
+      new CommandLinePrefStore(command_line));
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PrefService::Preference
 
 PrefService::Preference::Preference(const PrefService* service,
                                     const char* name,
                                     base::Value::Type type)
       : name_(name),
         type_(type),
         pref_service_(service) {
   DCHECK(name);
@@ skipping 47 matching lines @@
   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 }
 
 bool PrefService::Preference::IsExtensionModifiable() const {
   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 }