Move ExtensionAction from common/ to browser/.

chrome/browser/extensions/extension_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/extensions/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 332 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, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
+                 content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   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) {
@@ skipping 1488 matching lines @@
 
 void ExtensionService::UnloadAllExtensions() {
   profile_->GetExtensionSpecialStoragePolicy()->
       RevokeRightsForAllExtensions();
 
   extensions_.Clear();
   disabled_extensions_.Clear();
   terminated_extensions_.Clear();
   extension_runtime_data_.clear();
 
+  STLDeleteValues(&page_actions_);

[Jeffrey Yasskin, 2012/09/14 19:18:33]

Need to double-check if there are other places that can unload extensions
without sending the EXTENSION_UNLOADED notification, and call into the
ExtensionActionManager from there too.

+  STLDeleteValues(&browser_actions_);
+  STLDeleteValues(&script_badges_);
+
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled, and UnloadAll is just part of shutdown.
 }
 
 void ExtensionService::ReloadExtensions() {
   UnloadAllExtensions();
   component_loader_->LoadAll();
   extensions::InstalledLoader(this).LoadAllExtensions();
 }
@@ skipping 414 matching lines @@
 gfx::Image ExtensionService::GetOmniboxIcon(
     const std::string& extension_id) {
   return gfx::Image(omnibox_icon_manager_.GetIcon(extension_id));
 }
 
 gfx::Image ExtensionService::GetOmniboxPopupIcon(
     const std::string& extension_id) {
   return gfx::Image(omnibox_popup_icon_manager_.GetIcon(extension_id));
 }
 
+ExtensionAction* ExtensionService::GetPageAction(
+    const Extension& extension) const {
+  return ContainsKey(page_actions_, extension.id()) ?
+      page_actions_.find(extension.id())->second : NULL;
+}
+ExtensionAction* ExtensionService::GetBrowserAction(
+    const Extension& extension) const {
+  return ContainsKey(browser_actions_, extension.id()) ?
+      browser_actions_.find(extension.id())->second : NULL;
+}
+ExtensionAction* ExtensionService::GetScriptBadge(
+    const Extension& extension) const {
+  return ContainsKey(script_badges_, extension.id()) ?
+      script_badges_.find(extension.id())->second : NULL;
+}
+
 bool ExtensionService::OnExternalExtensionFileFound(
          const std::string& id,
          const Version* version,
          const FilePath& path,
          Extension::Location location,
          int creation_flags,
          bool mark_acknowledged) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(Extension::IdIsValid(id));
   if (extension_prefs_->IsExternalExtensionUninstalled(id))
@@ skipping 83 matching lines @@
       host->render_view_host());
   content::DevToolsManager::GetInstance()->AttachClientHost(iter->second,
                                                             agent);
   orphaned_dev_tools_.erase(iter);
 }
 
 void ExtensionService::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_LOADED: {

[Aaron Boodman, 2012/09/16 01:42:50]

This is the kind of code I'm trying to keep out of ExtensionService. Should be
in ExtensionActionManager and use EXTENSION_LOADED/UNLOADED notifications to
populate self.

[not at google - send to devlin, 2012/09/27 00:46:10]

Not that this solves the LOADED/UNLOADED problem, but what we need is an
ExtensionMap like ExtensionSet.

+      if (profile_ !=
+          content::Source<Profile>(source).ptr()->GetOriginalProfile()) {
+        break;
+      }
+
+      const Extension* extension =
+          content::Details<const Extension>(details).ptr();
+      if (extension->page_action() &&
+          !ContainsKey(page_actions_, extension->id())) {
+        page_actions_[extension->id()] =
+            new ExtensionAction(extension->id(), *extension->page_action());
+      }
+      if (extension->browser_action() &&
+          !ContainsKey(browser_actions_, extension->id())) {
+        browser_actions_[extension->id()] =
+            new ExtensionAction(extension->id(), *extension->browser_action());
+      }
+      DCHECK(extension->script_badge());
+      if (!ContainsKey(script_badges_, extension->id())) {
+        script_badges_[extension->id()] =
+            new ExtensionAction(extension->id(), *extension->script_badge());
+      }
+      break;
+    }
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
+      if (profile_ !=
+          content::Source<Profile>(source).ptr()->GetOriginalProfile()) {
+        break;
+      }
+
+      const Extension* extension =
+          content::Details<UnloadedExtensionInfo>(details)->extension;
+      if (ContainsKey(page_actions_, extension->id())) {
+        delete page_actions_[extension->id()];
+        page_actions_.erase(extension->id());
+      }
+      if (ContainsKey(browser_actions_, extension->id())) {
+        delete browser_actions_[extension->id()];
+        browser_actions_.erase(extension->id());
+      }
+      if (ContainsKey(script_badges_, extension->id())) {
+        script_badges_.erase(extension->id());
+      }
+      break;
+    }
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
       if (profile_ !=
           content::Source<Profile>(source).ptr()->GetOriginalProfile()) {
         break;
       }
 
       extensions::ExtensionHost* host =
           content::Details<extensions::ExtensionHost>(details).ptr();
 
       // Mark the extension as terminated and Unload it. We want it to
@@ skipping 232 matching lines @@
     extensions::ExtensionHost* extension_host) {
   if (!extension_host)
     return;
 
 #if !defined(OS_ANDROID)
   extensions::LaunchPlatformApp(extension_host->profile(),
                                 extension_host->extension(),
                                 NULL, FilePath());
 #endif
 }