[Extensions] Show a "refresh" bubble when needed with click-to-script

chrome/browser/extensions/extension_action_runner.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/extension_action_runner.h"
 
+#include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "chrome/browser/extensions/active_tab_permission_granter.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
+#include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/extensions/blocked_action_bubble_delegate.h"
+#include "chrome/browser/ui/toolbar/toolbar_actions_bar.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "ipc/ipc_message_macros.h"
 
 namespace extensions {
 
+namespace {
+
+// The blocked actions that require a page refresh to run.
+const int kRefreshRequiredActionsMask =
+    BLOCKED_ACTION_WEB_REQUEST | BLOCKED_ACTION_SCRIPT_AT_START;
+}
+
 ExtensionActionRunner::PendingScript::PendingScript(
     UserScript::RunLocation run_location,
     const base::Closure& permit_script)
     : run_location(run_location), permit_script(permit_script) {}
 
 ExtensionActionRunner::PendingScript::PendingScript(
     const PendingScript& other) = default;
 
 ExtensionActionRunner::PendingScript::~PendingScript() {}
 
 ExtensionActionRunner::ExtensionActionRunner(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       num_page_requests_(0),
       browser_context_(web_contents->GetBrowserContext()),
       was_used_on_page_(false),
-      extension_registry_observer_(this) {
+      ignore_active_tab_granted_(false),
+      extension_registry_observer_(this),
+      weak_factory_(this) {
   CHECK(web_contents);
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 }
 
 ExtensionActionRunner::~ExtensionActionRunner() {
   LogUMA();
 }
 
 // static
 ExtensionActionRunner* ExtensionActionRunner::GetForWebContents(
     content::WebContents* web_contents) {
   if (!web_contents)
     return NULL;
   TabHelper* tab_helper = TabHelper::FromWebContents(web_contents);
   return tab_helper ? tab_helper->extension_action_runner() : NULL;
 }
 
 ExtensionAction::ShowAction ExtensionActionRunner::RunAction(
     const Extension* extension,
     bool grant_tab_permissions) {
-  bool has_pending_scripts = WantsToRun(extension);
   if (grant_tab_permissions) {
+    int blocked = GetBlockedActions(extension);
+    if ((blocked & kRefreshRequiredActionsMask) != 0) {
+      ShowBlockedActionBubble(extension);
+      return ExtensionAction::ACTION_NONE;
+    }
     TabHelper::FromWebContents(web_contents())
         ->active_tab_permission_granter()
         ->GrantIfRequested(extension);
     // If the extension had blocked actions, granting active tab will have
     // run the extension. Don't execute further since clicking should run
     // blocked actions *or* the normal extension action, not both.
-    if (has_pending_scripts)
+    if (blocked != BLOCKED_ACTION_NONE)
       return ExtensionAction::ACTION_NONE;
   }
 
   ExtensionAction* extension_action =
       ExtensionActionManager::Get(browser_context_)
           ->GetExtensionAction(*extension);
 
   // Anything that gets here should have a page or browser action.
   DCHECK(extension_action);
   int tab_id = SessionTabHelper::IdForTab(web_contents());
@@ skipping 23 matching lines @@
   RunPendingScriptsForExtension(extension);
   web_request_blocked_.erase(extension->id());
 
   // The extension ran, so we need to tell the ExtensionActionAPI that we no
   // longer want to act.
   NotifyChange(extension);
 }
 
 void ExtensionActionRunner::OnActiveTabPermissionGranted(
     const Extension* extension) {
-  if (WantsToRun(extension))
+  if (!ignore_active_tab_granted_ && WantsToRun(extension))
     RunBlockedActions(extension);
 }
 
 void ExtensionActionRunner::OnWebRequestBlocked(const Extension* extension) {
   web_request_blocked_.insert(extension->id());
 }
 
 int ExtensionActionRunner::GetBlockedActions(const Extension* extension) {
   int blocked_actions = BLOCKED_ACTION_NONE;
   if (web_request_blocked_.count(extension->id()) != 0)
@@ skipping 18 matching lines @@
     }
   }
 
   return blocked_actions;
 }
 
 bool ExtensionActionRunner::WantsToRun(const Extension* extension) {
   return GetBlockedActions(extension) != BLOCKED_ACTION_NONE;
 }
 
+void ExtensionActionRunner::RunForTesting(const Extension* extension) {
+  if (WantsToRun(extension)) {
+    TabHelper::FromWebContents(web_contents())
+          ->active_tab_permission_granter()
+          ->GrantIfRequested(extension);
+  }
+}
+
 PermissionsData::AccessType
 ExtensionActionRunner::RequiresUserConsentForScriptInjection(
     const Extension* extension,
     UserScript::InjectionType type) {
   CHECK(extension);
 
   // Allow the extension if it's been explicitly granted permission.
   if (permitted_extensions_.count(extension->id()) > 0)
     return PermissionsData::ACCESS_ALLOWED;
 
@@ skipping 130 matching lines @@
   if (was_used_on_page_) {
     UMA_HISTOGRAM_COUNTS_100(
         "Extensions.ActiveScriptController.PermittedExtensions",
         permitted_extensions_.size());
     UMA_HISTOGRAM_COUNTS_100(
         "Extensions.ActiveScriptController.DeniedExtensions",
         pending_scripts_.size());
   }
 }
 
+void ExtensionActionRunner::ShowBlockedActionBubble(
+    const Extension* extension) {
+  Browser* browser = chrome::FindBrowserWithWebContents(web_contents());
+  ToolbarActionsBar* toolbar_actions_bar =
+      browser ? browser->window()->GetToolbarActionsBar() : nullptr;
+  if (toolbar_actions_bar) {
+    auto callback =
+        base::Bind(&ExtensionActionRunner::OnBlockedActionBubbleClosed,
+                   weak_factory_.GetWeakPtr(), extension->id());
+    if (default_bubble_close_action_for_testing_) {
+      base::MessageLoop::current()->PostTask(
+          FROM_HERE,
+          base::Bind(callback, *default_bubble_close_action_for_testing_));
+    } else {
+      toolbar_actions_bar->ShowToolbarActionBubble(make_scoped_ptr(
+          new BlockedActionBubbleDelegate(callback, extension->id())));
+    }
+  }
+}
+
+void ExtensionActionRunner::OnBlockedActionBubbleClosed(
+    const std::string& extension_id,
+    ToolbarActionsBarBubbleDelegate::CloseAction action) {
+  // If the user agreed to refresh the page, do so.
+  if (action == ToolbarActionsBarBubbleDelegate::CLOSE_EXECUTE) {
+    const Extension* extension = ExtensionRegistry::Get(browser_context_)
+                                     ->enabled_extensions()
+                                     .GetByID(extension_id);
+    if (!extension)
+      return;
+    {
+      // Ignore the active tab permission being granted because we don't want
+      // to run scripts right before we refresh the page.
+      base::AutoReset<bool> ignore_active_tab(&ignore_active_tab_granted_,
+                                              true);
+      TabHelper::FromWebContents(web_contents())
+          ->active_tab_permission_granter()
+          ->GrantIfRequested(extension);
+    }
+    web_contents()->GetController().Reload(false);
+  }
+}
+
 bool ExtensionActionRunner::OnMessageReceived(
     const IPC::Message& message,
     content::RenderFrameHost* render_frame_host) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionActionRunner, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_RequestScriptInjectionPermission,
                         OnRequestScriptInjectionPermission)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ExtensionActionRunner::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (details.is_in_page)
     return;
 
   LogUMA();
   num_page_requests_ = 0;
   permitted_extensions_.clear();
   pending_scripts_.clear();
   web_request_blocked_.clear();
   was_used_on_page_ = false;
+  weak_factory_.InvalidateWeakPtrs();
 }
 
 void ExtensionActionRunner::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   PendingScriptMap::iterator iter = pending_scripts_.find(extension->id());
   if (iter != pending_scripts_.end()) {
     pending_scripts_.erase(iter);
     ExtensionActionAPI::Get(browser_context_)
         ->NotifyPageActionsChanged(web_contents());
   }
 }
 
 }  // namespace extensions