Introduce an "ExtensionWantsToAct" method

chrome/browser/extensions/active_script_controller.cc

 // Copyright 2014 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/active_script_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 42 matching lines @@
          extension->permissions_data()
              ->active_permissions()
              ->ShouldWarnAllHosts();
 }
 
 }  // namespace
 
 ActiveScriptController::ActiveScriptController(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
+      browser_context_(web_contents->GetBrowserContext()),
       enabled_(FeatureSwitch::scripts_require_action()->IsEnabled()),
       extension_registry_observer_(this) {
   CHECK(web_contents);
-  extension_registry_observer_.Add(
-      ExtensionRegistry::Get(web_contents->GetBrowserContext()));
+  extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 }
 
 ActiveScriptController::~ActiveScriptController() {
   LogUMA();
 }
 
 // static
 ActiveScriptController* ActiveScriptController::GetForWebContents(
     content::WebContents* web_contents) {
   if (!web_contents)
@@ skipping 45 matching lines @@
   scoped_refptr<PermissionSet> new_permissions =
       new PermissionSet(APIPermissionSet(),
                         ManifestPermissionSet(),
                         new_explicit_hosts,
                         new_scriptable_hosts);
 
   // Update permissions for the session. This adds |new_permissions| to active
   // permissions and granted permissions.
   // TODO(devlin): Make sure that the permission is removed from
   // withheld_permissions if appropriate.
-  PermissionsUpdater(web_contents()->GetBrowserContext())
-      .AddPermissions(extension, new_permissions.get());
+  PermissionsUpdater(browser_context_).AddPermissions(extension,
+                                                      new_permissions.get());
 
   // Allow current tab to run injection.
   OnClicked(extension);
 }
 
 void ActiveScriptController::OnClicked(const Extension* extension) {
   DCHECK(ContainsKey(pending_requests_, extension->id()));
   RunPendingForExtension(extension);
 }
 
@@ skipping 31 matching lines @@
   return PermissionsData::ACCESS_DENIED;
 }
 
 void ActiveScriptController::RequestScriptInjection(
     const Extension* extension,
     const base::Closure& callback) {
   CHECK(extension);
   PendingRequestList& list = pending_requests_[extension->id()];
   list.push_back(callback);
 
-  // If this was the first entry, notify the location bar that there's a new
-  // icon.
-  if (list.size() == 1u) {
-    ExtensionActionAPI::Get(web_contents()->GetBrowserContext())->
-        NotifyPageActionsChanged(web_contents());
-  }
+  // If this was the first entry, we need to notify that a new extension wants
+  // to run.
+  if (list.size() == 1u)
+    NotifyChange(extension);
 }
 
 void ActiveScriptController::RunPendingForExtension(
     const Extension* extension) {
   DCHECK(extension);
 
   content::NavigationEntry* visible_entry =
       web_contents()->GetController().GetVisibleEntry();
   // Refuse to run if there's no visible entry, because we have no idea of
   // determining if it's the proper page. This should rarely, if ever, happen.
@@ skipping 20 matching lines @@
   TabHelper::FromWebContents(web_contents())->
       active_tab_permission_granter()->GrantIfRequested(extension);
 
   // Run all pending injections for the given extension.
   for (PendingRequestList::iterator request = requests.begin();
        request != requests.end();
        ++request) {
     request->Run();
   }
 
-  // Inform the location bar that the action is now gone.
-  ExtensionActionAPI::Get(web_contents()->GetBrowserContext())->
-      NotifyPageActionsChanged(web_contents());
+  // The extension ran, so we need to update the ExtensionActionAPI that we no
+  // longer want to act.
+  NotifyChange(extension);
 }
 
 void ActiveScriptController::OnRequestScriptInjectionPermission(
     const std::string& extension_id,
     UserScript::InjectionType script_type,
     int64 request_id) {
   if (!crx_file::id_util::IdIsValid(extension_id)) {
     NOTREACHED() << "'" << extension_id << "' is not a valid id.";
     return;
   }
 
   const Extension* extension =
-      ExtensionRegistry::Get(web_contents()->GetBrowserContext())
+      ExtensionRegistry::Get(browser_context_)
           ->enabled_extensions().GetByID(extension_id);
   // We shouldn't allow extensions which are no longer enabled to run any
   // scripts. Ignore the request.
   if (!extension)
     return;
 
   // If the request id is -1, that signals that the content script has already
   // ran (because this feature is not enabled). Add the extension to the list of
   // permitted extensions (for metrics), and return immediately.
   if (request_id == -1) {
@@ skipping 29 matching lines @@
   // This only sends the response to the renderer - the process of adding the
   // extension to the list of |permitted_extensions_| is done elsewhere.
   content::RenderViewHost* render_view_host =
       web_contents()->GetRenderViewHost();
   if (render_view_host) {
     render_view_host->Send(new ExtensionMsg_PermitScriptInjection(
         render_view_host->GetRoutingID(), request_id));
   }
 }
 
+void ActiveScriptController::NotifyChange(const Extension* extension) {
+  ExtensionActionAPI* extension_action_api =
+      ExtensionActionAPI::Get(browser_context_);
+  ExtensionAction* extension_action =
+      ExtensionActionManager::Get(browser_context_)->
+          GetExtensionAction(*extension);
+  // If the extension has an action, we need to notify that it's updated.
+  if (extension_action) {
+    extension_action_api->NotifyChange(
+        extension_action, web_contents(), browser_context_);
+  }
+
+  // We also notify that page actions may have changed.
+  extension_action_api->NotifyPageActionsChanged(web_contents());
+}
+
 void ActiveScriptController::LogUMA() const {
   UMA_HISTOGRAM_COUNTS_100(
       "Extensions.ActiveScriptController.ShownActiveScriptsOnPage",
       pending_requests_.size());
 
   // We only log the permitted extensions metric if the feature is enabled,
   // because otherwise the data will be boring (100% allowed).
   if (enabled_) {
     UMA_HISTOGRAM_COUNTS_100(
         "Extensions.ActiveScriptController.PermittedExtensions",
@@ skipping 25 matching lines @@
   pending_requests_.clear();
 }
 
 void ActiveScriptController::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   PendingRequestMap::iterator iter = pending_requests_.find(extension->id());
   if (iter != pending_requests_.end()) {
     pending_requests_.erase(iter);
-    ExtensionActionAPI::Get(web_contents()->GetBrowserContext())->
+    ExtensionActionAPI::Get(browser_context_)->
         NotifyPageActionsChanged(web_contents());
   }
 }
 
 }  // namespace extensions