Clean up how we handle themes in the extensions system and management API....

chrome/browser/extensions/extension_service.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_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 414 matching lines @@
 
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
   } else if (profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
   }
 
   registrar_.Add(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
                  NotificationService::AllSources());
+
+  registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
+                 NotificationService::AllSources());
+
   pref_change_registrar_.Init(profile->GetPrefs());
   pref_change_registrar_.Add(prefs::kExtensionInstallAllowList, this);
   pref_change_registrar_.Add(prefs::kExtensionInstallDenyList, this);
 
   // Set up the ExtensionUpdater
   if (autoupdate_enabled) {
     int update_frequency = kDefaultUpdateFrequencySeconds;
     if (command_line->HasSwitch(switches::kExtensionsUpdateFrequency)) {
       base::StringToInt(command_line->GetSwitchValueASCII(
           switches::kExtensionsUpdateFrequency),
@@ skipping 52 matching lines @@
   if (event_routers_initialized_)
     return;
 
   ExtensionHistoryEventRouter::GetInstance()->ObserveProfile(profile_);
   ExtensionAccessibilityEventRouter::GetInstance()->ObserveProfile(profile_);
   browser_event_router_.reset(new ExtensionBrowserEventRouter(profile_));
   browser_event_router_->Init();
   ExtensionBookmarkEventRouter::GetInstance()->Observe(
       profile_->GetBookmarkModel());
   ExtensionCookiesEventRouter::GetInstance()->Init();
-  ExtensionManagementEventRouter::GetInstance()->Init();
+
+  management_event_router_.reset(new ExtensionManagementEventRouter());
+  management_event_router_->Init();
+
   ExtensionProcessesEventRouter::GetInstance()->ObserveProfile(profile_);
   ExtensionWebNavigationEventRouter::GetInstance()->Init();
   event_routers_initialized_ = true;
 }
 
 const Extension* ExtensionService::GetExtensionById(const std::string& id,
                                                      bool include_disabled) {
   return GetExtensionByIdInternal(id, true, include_disabled);
 }
 
@@ skipping 727 matching lines @@
 
 Profile* ExtensionService::profile() {
   return profile_;
 }
 
 void ExtensionService::DestroyingProfile() {
   if (updater_.get()) {
     updater_->Stop();
   }
   browser_event_router_.reset();
+  management_event_router_.reset();
   pref_change_registrar_.RemoveAll();
   profile_ = NULL;
   toolbar_model_.DestroyingProfile();
 }
 
 ExtensionPrefs* ExtensionService::extension_prefs() {
   return extension_prefs_;
 }
 
 void ExtensionService::CheckAdminBlacklist() {
@@ skipping 433 matching lines @@
       initial_state =
           pending_extension_info.enable_on_install ?
           Extension::ENABLED : Extension::DISABLED;
       initial_enable_incognito =
           pending_extension_info.enable_incognito_on_install;
     }
   } else {
     // Make sure we preserve enabled/disabled states.
     Extension::State existing_state =
         extension_prefs_->GetExtensionState(extension->id());
-    initial_state =
-        (existing_state == Extension::DISABLED) ?
-        Extension::DISABLED : Extension::ENABLED;
+    initial_state = Extension::ENABLED;
+    if (!extension->is_theme() && existing_state == Extension::DISABLED)
+      initial_state = Extension::DISABLED;
     initial_enable_incognito =
         extension_prefs_->IsIncognitoEnabled(extension->id());
   }
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.InstallType",
                             extension->GetType(), 100);
   ShownSectionsHandler::OnExtensionInstalled(profile_->GetPrefs(), extension);
   extension_prefs_->OnExtensionInstalled(
       extension, initial_state, initial_enable_incognito);
 
   // Unpacked extensions start off with file access since they are a developer
   // feature.
   if (extension->location() == Extension::LOAD)
     extension_prefs_->SetAllowFileAccess(extension->id(), true);
 
-  // If the extension is a theme, tell the profile (and therefore ThemeProvider)
-  // to apply it.
-  if (extension->is_theme()) {
-    NotificationService::current()->Notify(
-        NotificationType::THEME_INSTALLED,
-        Source<Profile>(profile_),
-        Details<const Extension>(extension));
-  } else {
-    NotificationService::current()->Notify(
-        NotificationType::EXTENSION_INSTALLED,
-        Source<Profile>(profile_),
-        Details<const Extension>(extension));
-  }
+  NotificationService::current()->Notify(
+      NotificationType::EXTENSION_INSTALLED,
+      Source<Profile>(profile_),
+      Details<const Extension>(extension));
 
   if (extension->is_app()) {
     ExtensionIdSet installed_ids = GetAppIds();
     installed_ids.insert(extension->id());
     default_apps_.DidInstallApp(installed_ids);
   }
 
   // Transfer ownership of |extension| to AddExtension.
   AddExtension(scoped_extension);
 }
@@ skipping 163 matching lines @@
 
   DevToolsManager::GetInstance()->AttachClientHost(
       iter->second, host->render_view_host());
   orphaned_dev_tools_.erase(iter);
 }
 
 void ExtensionService::Observe(NotificationType type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
   switch (type.value) {
+    case NotificationType::BROWSER_THEME_CHANGED: {
+      // Disable any other enabled themes.
+      std::string new_theme_id;
+      const Extension* theme = Details<const Extension>(details).ptr();
+      if (theme)
+        new_theme_id = theme->id();
+
+      std::set<std::string> disable_list;
+      for (ExtensionList::iterator i = extensions_.begin();
+           i != extensions_.end(); ++i) {
+        const Extension* extension = i->get();
+        if (extension->is_theme() && extension->id() != new_theme_id)
+          disable_list.insert(extension->id());
+      }
+
+      for (std::set<std::string>::iterator i = disable_list.begin();
+           i != disable_list.end(); ++i) {
+        DisableExtension(*i);
+      }
+
+      break;
+    }
+
     case NotificationType::EXTENSION_PROCESS_TERMINATED: {
       if (profile_ != Source<Profile>(source).ptr()->GetOriginalProfile())
         break;
 
       ExtensionHost* host = Details<ExtensionHost>(details).ptr();
       TrackTerminatedExtension(host->extension());
 
       // Unload the entire extension. We want it to be in a consistent state:
       // either fully working or not loaded at all, but never half-crashed.
       // We do it in a PostTask so that other handlers of this notification will
@@ skipping 56 matching lines @@
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
 PropertyBag* ExtensionService::GetPropertyBag(const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
 }