Ensure that --disable-extensions disables extension prefs from being enacted

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2011 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/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 209 matching lines @@
 
 std::string JoinPrefs(std::string parent, const char* child) {
   return parent + "." + child;
 }
 
 }  // namespace
 
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const FilePath& root_dir,
-    ExtensionPrefValueMap* extension_pref_value_map)
+    ExtensionPrefValueMap* extension_pref_value_map,
+    bool extensions_disabled)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       content_settings_store_(new ExtensionContentSettingsStore()) {
   MakePathsRelative();
 
-  InitPrefStore();
+  InitPrefStore(extensions_disabled);

[asargent_no_longer_on_chrome, 2011/09/29 18:06:59]

It is sort of against the style guide to be doing non-trivial work in the
constructor like this. 

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Doing_Work_in_...

I wonder if a better approach would be to move the call to InitPrefStore to
after the object is created. Then in profile_impl.cc, you can not call it if
extensions are disabled.

Does that seem workable?

[battre, 2011/09/29 20:37:47]

I would still want to call InitPrefStore(false) to call
extension_pref_value_map_->NotifyInitializationCompleted();

It's a trivial change. I can do that tomorrow.

 
   content_settings_store_->AddObserver(this);
 }
 
 ExtensionPrefs::~ExtensionPrefs() {
 }
 
 // static
 const char ExtensionPrefs::kExtensionsPref[] = "extensions.settings";
 
@@ skipping 1264 matching lines @@
   const DictionaryValue* source_dict = prefs_->GetDictionary(kExtensionsPref);
   if (!source_dict->GetDictionary(key, &preferences)) {
     // And then create a dictionary if it did not exist before.
     DictionaryPrefUpdate update(prefs_, kExtensionsPref);
     preferences = new DictionaryValue;
     update->Set(key, preferences);
   }
   return preferences;
 }
 
-void ExtensionPrefs::InitPrefStore() {
+void ExtensionPrefs::InitPrefStore(bool extensions_disabled) {
+  if (extensions_disabled) {
+    extension_pref_value_map_->NotifyInitializationCompleted();
+    return;
+  }
+
   // When this is called, the PrefService is initialized and provides access
   // to the user preferences stored in a JSON file.
   ExtensionIdSet extension_ids;
   GetExtensions(&extension_ids);
   // Create empty preferences dictionary for each extension (these dictionaries
   // are pruned when persisting the preferences to disk).
   for (ExtensionIdSet::iterator ext_id = extension_ids.begin();
        ext_id != extension_ids.end(); ++ext_id) {
     ScopedExtensionPrefUpdate update(prefs_, *ext_id);
     // This creates an empty dictionary if none is stored.
@@ skipping 169 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }