[Extensions] Refactor extension action execution

chrome/browser/extensions/extension_action_runner_unittest.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 <stddef.h>
 
 #include <map>
 #include <utility>
 
 #include "base/values.h"
@@ skipping 181 matching lines @@
 TEST_F(ExtensionActionRunnerUnitTest, RequestPermissionAndExecute) {
   const Extension* extension = AddExtension();
   ASSERT_TRUE(extension);
 
   NavigateAndCommit(GURL("https://www.google.com"));
 
   // Ensure that there aren't any executions pending.
   ASSERT_EQ(0u, GetExecutionCountForExtension(extension->id()));
   ASSERT_FALSE(runner()->WantsToRun(extension));
 
-  ExtensionActionAPI* extension_action_api = ExtensionActionAPI::Get(profile());
-  ASSERT_FALSE(extension_action_api->HasBeenBlocked(extension, web_contents()));
-
   // Since the extension requests all_hosts, we should require user consent.
   EXPECT_TRUE(RequiresUserConsent(extension));
 
   // Request an injection. The extension should want to run, but should not have
   // executed.
   RequestInjection(extension);
   EXPECT_TRUE(runner()->WantsToRun(extension));
-  EXPECT_TRUE(extension_action_api->HasBeenBlocked(extension, web_contents()));
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   // Click to accept the extension executing.
-  runner()->OnClicked(extension);
+  runner()->RunAction(extension, true);
 
   // The extension should execute, and the extension shouldn't want to run.
   EXPECT_EQ(1u, GetExecutionCountForExtension(extension->id()));
   EXPECT_FALSE(runner()->WantsToRun(extension));
-  EXPECT_FALSE(extension_action_api->HasBeenBlocked(extension, web_contents()));
 
   // Since we already executed on the given page, we shouldn't need permission
   // for a second time.
   EXPECT_FALSE(RequiresUserConsent(extension));
 
   // Reloading and same-origin navigations shouldn't clear those permissions,
   // and we shouldn't require user constent again.
   Reload();
   EXPECT_FALSE(RequiresUserConsent(extension));
   NavigateAndCommit(GURL("https://www.google.com/foo"));
   EXPECT_FALSE(RequiresUserConsent(extension));
   NavigateAndCommit(GURL("https://www.google.com/bar"));
   EXPECT_FALSE(RequiresUserConsent(extension));
 
   // Cross-origin navigations should clear permissions.
   NavigateAndCommit(GURL("https://otherdomain.google.com"));
   EXPECT_TRUE(RequiresUserConsent(extension));
 
   // Grant access.
   RequestInjection(extension);
-  runner()->OnClicked(extension);
+  runner()->RunAction(extension, true);
   EXPECT_EQ(2u, GetExecutionCountForExtension(extension->id()));
   EXPECT_FALSE(runner()->WantsToRun(extension));
 
   // Navigating to another site should also clear the permissions.
   NavigateAndCommit(GURL("https://www.foo.com"));
   EXPECT_TRUE(RequiresUserConsent(extension));
 }
 
 // Test that injections that are not executed by the time the user navigates are
 // ignored and never execute.
@@ skipping 11 matching lines @@
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   // Reload. This should remove the pending injection, and we should not
   // execute anything.
   Reload();
   EXPECT_FALSE(runner()->WantsToRun(extension));
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   // Request and accept a new injection.
   RequestInjection(extension);
-  runner()->OnClicked(extension);
+  runner()->RunAction(extension, true);
 
   // The extension should only have executed once, even though a grand total
   // of two executions were requested.
   EXPECT_EQ(1u, GetExecutionCountForExtension(extension->id()));
   EXPECT_FALSE(runner()->WantsToRun(extension));
 }
 
 // Test that queueing multiple pending injections, and then accepting, triggers
 // them all.
 TEST_F(ExtensionActionRunnerUnitTest, MultiplePendingInjection) {
   const Extension* extension = AddExtension();
   ASSERT_TRUE(extension);
   NavigateAndCommit(GURL("https://www.google.com"));
 
   ASSERT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   const size_t kNumInjections = 3u;
   // Queue multiple pending injections.
   for (size_t i = 0u; i < kNumInjections; ++i)
     RequestInjection(extension);
 
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
-  runner()->OnClicked(extension);
+  runner()->RunAction(extension, true);
 
   // All pending injections should have executed.
   EXPECT_EQ(kNumInjections, GetExecutionCountForExtension(extension->id()));
   EXPECT_FALSE(runner()->WantsToRun(extension));
 }
 
 TEST_F(ExtensionActionRunnerUnitTest, ActiveScriptsUseActiveTabPermissions) {
   const Extension* extension = AddExtension();
   NavigateAndCommit(GURL("https://www.google.com"));
 
@@ skipping 77 matching lines @@
   EXPECT_TRUE(RequiresUserConsent(extension));
 
   // Request an injection. The extension should want to run, but not execute.
   RequestInjection(extension);
   EXPECT_TRUE(runner()->WantsToRun(extension));
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   // Allow the extension to always run on this origin.
   ScriptingPermissionsModifier modifier(profile(), extension);
   modifier.GrantHostPermission(web_contents()->GetLastCommittedURL());
-  runner()->OnClicked(extension);
+  runner()->RunAction(extension, true);
 
   // The extension should execute, and the extension shouldn't want to run.
   EXPECT_EQ(1u, GetExecutionCountForExtension(extension->id()));
   EXPECT_FALSE(runner()->WantsToRun(extension));
 
   // Since we already executed on the given page, we shouldn't need permission
   // for a second time.
   EXPECT_FALSE(RequiresUserConsent(extension));
 
   // Navigating to another site that hasn't been granted a persisted permission
@@ skipping 35 matching lines @@
   RequestInjection(extension, UserScript::DOCUMENT_END);
   EXPECT_EQ(BLOCKED_ACTION_SCRIPT_OTHER,
             runner()->GetBlockedActions(extension));
   RequestInjection(extension, UserScript::DOCUMENT_IDLE);
   EXPECT_EQ(BLOCKED_ACTION_SCRIPT_OTHER,
             runner()->GetBlockedActions(extension));
   RequestInjection(extension, UserScript::DOCUMENT_START);
   EXPECT_EQ(BLOCKED_ACTION_SCRIPT_AT_START | BLOCKED_ACTION_SCRIPT_OTHER,
             runner()->GetBlockedActions(extension));
 
-  runner()->OnClicked(extension);
+  runner()->RunAction(extension, true);
   EXPECT_EQ(BLOCKED_ACTION_NONE, runner()->GetBlockedActions(extension));
 }
 
 TEST_F(ExtensionActionRunnerUnitTest, TestWebRequestBlocked) {
   const Extension* extension = AddExtension();
   ASSERT_TRUE(extension);
 
   NavigateAndCommit(GURL("https://www.foo.com"));
 
   EXPECT_EQ(BLOCKED_ACTION_NONE, runner()->GetBlockedActions(extension));
   EXPECT_FALSE(runner()->WantsToRun(extension));
 
   runner()->OnWebRequestBlocked(extension);
   EXPECT_EQ(BLOCKED_ACTION_WEB_REQUEST, runner()->GetBlockedActions(extension));
   EXPECT_TRUE(runner()->WantsToRun(extension));
 
   RequestInjection(extension);
   EXPECT_EQ(BLOCKED_ACTION_WEB_REQUEST | BLOCKED_ACTION_SCRIPT_OTHER,
             runner()->GetBlockedActions(extension));
   EXPECT_TRUE(runner()->WantsToRun(extension));
 
   NavigateAndCommit(GURL("https://www.bar.com"));
   EXPECT_EQ(BLOCKED_ACTION_NONE, runner()->GetBlockedActions(extension));
   EXPECT_FALSE(runner()->WantsToRun(extension));
 }
 
 }  // namespace extensions