Create withheld permissions

chrome/browser/extensions/active_script_controller_unittest.cc

Index: chrome/browser/extensions/active_script_controller_unittest.cc
diff --git a/chrome/browser/extensions/active_script_controller_unittest.cc b/chrome/browser/extensions/active_script_controller_unittest.cc
index 0b40328c14329891aeb22953d731e3e46710b495..6cc521e1e0f0e3445741a2b11189f5d06f593cc5 100644
--- a/chrome/browser/extensions/active_script_controller_unittest.cc
+++ b/chrome/browser/extensions/active_script_controller_unittest.cc
@@ -15,6 +15,7 @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/feature_switch.h"
@@ -43,19 +44,28 @@ class ActiveScriptControllerUnitTest : public ChromeRenderViewHostTestHarness {
   // Creates an extension with all hosts permission and adds it to the registry.
   const Extension* AddExtension();
 
-  // Returns the current page id.
-  int GetPageId();
+  // Returns true if the |extension| requires user consent before injecting
+  // a script.
+  bool RequiresUserConsent(const Extension* extension) const;
 
-  // Returns a closure to use as a script execution for a given extension.
-  base::Closure GetExecutionCallbackForExtension(
-      const std::string& extension_id);
+  // Request an injection for the given |extension|.
+  void RequestInjection(const Extension* extension);
 
   // Returns the number of times a given extension has had a script execute.
   size_t GetExecutionCountForExtension(const std::string& extension_id) const;
 
-  ActiveScriptController* controller() { return active_script_controller_; }
+  ActiveScriptController* controller() const {
+    return active_script_controller_;
+  }
 
  private:
+  // Returns the current page id.
+  int GetPageId();
+
+  // Returns a closure to use as a script execution for a given extension.
+  base::Closure GetExecutionCallbackForExtension(
+      const std::string& extension_id);
+
   // Increment the number of executions for the given |extension_id|.
   void IncrementExecutionCount(const std::string& extension_id);
 
@@ -101,6 +111,33 @@ const Extension* ActiveScriptControllerUnitTest::AddExtension() {
   return extension;
 }
 
+bool ActiveScriptControllerUnitTest::RequiresUserConsent(
+    const Extension* extension) const {
+  PermissionsData::AccessType access_type =
+      controller()->RequiresUserConsentForScriptInjectionForTesting(
+          extension, extension_misc::PROGRAMMATIC_SCRIPT);
+  // We should never downright refuse access in these tests.
+  DCHECK_NE(PermissionsData::DENY_ACCESS, access_type);
+  return access_type == PermissionsData::REQUEST_ACCESS;
+}
+
+void ActiveScriptControllerUnitTest::RequestInjection(
+    const Extension* extension) {
+  controller()->RequestScriptInjectionForTesting(
+      extension,
+      GetPageId(),
+      GetExecutionCallbackForExtension(extension->id()));
+}
+
+size_t ActiveScriptControllerUnitTest::GetExecutionCountForExtension(
+    const std::string& extension_id) const {
+  std::map<std::string, int>::const_iterator iter =
+      extension_executions_.find(extension_id);
+  if (iter != extension_executions_.end())
+    return iter->second;
+  return 0u;
+}
+
 int ActiveScriptControllerUnitTest::GetPageId() {
   content::NavigationEntry* navigation_entry =
       web_contents()->GetController().GetVisibleEntry();
@@ -117,15 +154,6 @@ base::Closure ActiveScriptControllerUnitTest::GetExecutionCallbackForExtension(
                     extension_id);
 }
 
-size_t ActiveScriptControllerUnitTest::GetExecutionCountForExtension(
-    const std::string& extension_id) const {
-  std::map<std::string, int>::const_iterator iter =
-      extension_executions_.find(extension_id);
-  if (iter != extension_executions_.end())
-    return iter->second;
-  return 0u;
-}
-
 void ActiveScriptControllerUnitTest::IncrementExecutionCount(
     const std::string& extension_id) {
   ++extension_executions_[extension_id];
@@ -157,14 +185,10 @@ TEST_F(ActiveScriptControllerUnitTest, RequestPermissionAndExecute) {
   ASSERT_FALSE(controller()->GetActionForExtension(extension));
 
   // Since the extension requests all_hosts, we should require user consent.
-  EXPECT_TRUE(
-      controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_TRUE(RequiresUserConsent(extension));
 
   // Request an injection. There should be an action visible, but no executions.
-  controller()->RequestScriptInjection(
-      extension,
-      GetPageId(),
-      GetExecutionCallbackForExtension(extension->id()));
+  RequestInjection(extension);
   EXPECT_TRUE(controller()->GetActionForExtension(extension));
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
@@ -177,28 +201,22 @@ TEST_F(ActiveScriptControllerUnitTest, RequestPermissionAndExecute) {
 
   // Since we already executed on the given page, we shouldn't need permission
   // for a second time.
-  EXPECT_FALSE(
-      controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_FALSE(RequiresUserConsent(extension));
 
   // Reloading should clear those permissions, and we should again require user
   // consent.
   Reload();
-  EXPECT_TRUE(
-      controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_TRUE(RequiresUserConsent(extension));
 
   // Grant access.
-  controller()->RequestScriptInjection(
-      extension,
-      GetPageId(),
-      GetExecutionCallbackForExtension(extension->id()));
+  RequestInjection(extension);
   controller()->OnClicked(extension);
   EXPECT_EQ(2u, GetExecutionCountForExtension(extension->id()));
   EXPECT_FALSE(controller()->GetActionForExtension(extension));
 
   // Navigating to another site should also clear the permissions.
   NavigateAndCommit(GURL("https://www.foo.com"));
-  EXPECT_TRUE(
-      controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_TRUE(RequiresUserConsent(extension));
 }
 
 // Test that injections that are not executed by the time the user navigates are
@@ -212,10 +230,7 @@ TEST_F(ActiveScriptControllerUnitTest, PendingInjectionsRemovedAtNavigation) {
   ASSERT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   // Request an injection. There should be an action visible, but no executions.
-  controller()->RequestScriptInjection(
-      extension,
-      GetPageId(),
-      GetExecutionCallbackForExtension(extension->id()));
+  RequestInjection(extension);
   EXPECT_TRUE(controller()->GetActionForExtension(extension));
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
@@ -226,10 +241,7 @@ TEST_F(ActiveScriptControllerUnitTest, PendingInjectionsRemovedAtNavigation) {
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   // Request and accept a new injection.
-  controller()->RequestScriptInjection(
-      extension,
-      GetPageId(),
-      GetExecutionCallbackForExtension(extension->id()));
+  RequestInjection(extension);
   controller()->OnClicked(extension);
 
   // The extension should only have executed once, even though a grand total
@@ -249,12 +261,9 @@ TEST_F(ActiveScriptControllerUnitTest, MultiplePendingInjection) {
 
   const size_t kNumInjections = 3u;
   // Queue multiple pending injections.
-  for (size_t i = 0u; i < kNumInjections; ++i) {
-    controller()->RequestScriptInjection(
-        extension,
-        GetPageId(),
-        GetExecutionCallbackForExtension(extension->id()));
-  }
+  for (size_t i = 0u; i < kNumInjections; ++i)
+    RequestInjection(extension);
+
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
   controller()->OnClicked(extension);
@@ -278,17 +287,14 @@ TEST_F(ActiveScriptControllerUnitTest, ActiveScriptsUseActiveTabPermissions) {
 
   // Since we have active tab permissions, we shouldn't need user consent
   // anymore.
-  EXPECT_FALSE(controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_FALSE(RequiresUserConsent(extension));
 
   // Also test that granting active tab runs any pending tasks.
   Reload();
   // Navigating should mean we need permission again.
-  EXPECT_TRUE(controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_TRUE(RequiresUserConsent(extension));
 
-  controller()->RequestScriptInjection(
-      extension,
-      GetPageId(),
-      GetExecutionCallbackForExtension(extension->id()));
+  RequestInjection(extension);
   EXPECT_TRUE(controller()->GetActionForExtension(extension));
   EXPECT_EQ(0u, GetExecutionCountForExtension(extension->id()));
 
@@ -306,23 +312,23 @@ TEST_F(ActiveScriptControllerUnitTest, ActiveScriptsCanHaveAllUrlsPref) {
   ASSERT_TRUE(extension);
 
   NavigateAndCommit(GURL("https://www.google.com"));
-  EXPECT_TRUE(controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_TRUE(RequiresUserConsent(extension));
 
   // Enable the extension on all urls.
   util::SetAllowedScriptingOnAllUrls(extension->id(), profile(), true);
 
-  EXPECT_FALSE(controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_FALSE(RequiresUserConsent(extension));
   // This should carry across navigations, and websites.
   NavigateAndCommit(GURL("http://www.foo.com"));
-  EXPECT_FALSE(controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_FALSE(RequiresUserConsent(extension));
 
   // Turning off the preference should have instant effect.
   util::SetAllowedScriptingOnAllUrls(extension->id(), profile(), false);
-  EXPECT_TRUE(controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_TRUE(RequiresUserConsent(extension));
 
   // And should also persist across navigations and websites.
   NavigateAndCommit(GURL("http://www.bar.com"));
-  EXPECT_TRUE(controller()->RequiresUserConsentForScriptInjection(extension));
+  EXPECT_TRUE(RequiresUserConsent(extension));
 }
 
 }  // namespace extensions