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/command_line.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"
 #include "chrome/browser/prefs/pref_notifier.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/pref_names.h"
 #include "content/common/notification_service.h"
 
 using base::Time;
 
 namespace {
 
@@ skipping 203 matching lines @@
 ExtensionPrefs::ExtensionPrefs(
     PrefService* prefs,
     const FilePath& root_dir,
     ExtensionPrefValueMap* extension_pref_value_map)
     : prefs_(prefs),
       install_directory_(root_dir),
       extension_pref_value_map_(extension_pref_value_map),
       content_settings_store_(new ExtensionContentSettingsStore()) {
   MakePathsRelative();
 
-  InitPrefStore();
+  bool extensions_disabled =
+      (prefs->FindPreference(prefs::kDisableExtensions) &&
+       prefs->GetBoolean(prefs::kDisableExtensions)) ||
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableExtensions);

[Mattias Nissler (ping if slow), 2011/09/28 09:24:51]

I must say I personally don't like depending on static stuff such as
CommandLine::ForCurrentProcess() and in most cases it's much better to just pass
the parameters to the ctor, s.t. writing tests for the class becomes easier.

Admittedly, for the test cases that use TestExtensionPrefs, there's not so much
of a difference, but then it may be a good idea to at least keep the
dependencies of the non-testing code as lightweight as possible.

Bottom line: I'd prefer passing |extensions_disabled| to the ctor, but I leave
the decision to you.

+  InitPrefStore(!extensions_disabled);
 
   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_enabled) {
+  if (!extensions_enabled) {
+    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);
 }