[Extensions] Use document url (not top url) for tab-specific permissions

chrome/common/extensions/permissions/permissions_data_unittest.cc

 // Copyright (c) 2013 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 <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 70 matching lines @@
   const GURL chrome_settings_url("chrome://settings/");
   const GURL chrome_extension_url("chrome-extension://foo/bar.html");
   const GURL google_url("https://www.google.com/");
   const GURL self_url("chrome-extension://" + extension->id() + "/foo.html");
   const GURL invalid_url("chrome-debugger://foo/bar.html");
 
   std::string error;
   EXPECT_EQ(block_chrome_urls,
             PermissionsData::IsRestrictedUrl(
                 chrome_settings_url,
-                chrome_settings_url,
                 extension,
                 &error)) << name;
   if (block_chrome_urls)
     EXPECT_EQ(manifest_errors::kCannotAccessChromeUrl, error) << name;
   else
     EXPECT_TRUE(error.empty()) << name;
 
   error.clear();
   EXPECT_EQ(block_chrome_urls,
             PermissionsData::IsRestrictedUrl(
                 chrome_extension_url,
-                chrome_extension_url,
                 extension,
                 &error)) << name;
   if (block_chrome_urls)
     EXPECT_EQ(manifest_errors::kCannotAccessExtensionUrl, error) << name;
   else
     EXPECT_TRUE(error.empty()) << name;
 
   // Google should never be a restricted url.
   error.clear();
   EXPECT_FALSE(PermissionsData::IsRestrictedUrl(
-      google_url, google_url, extension, &error)) << name;
+      google_url, extension, &error)) << name;
   EXPECT_TRUE(error.empty()) << name;
 
   // We should always be able to access our own extension pages.
   error.clear();
   EXPECT_FALSE(PermissionsData::IsRestrictedUrl(
-      self_url, self_url, extension, &error)) << name;
+      self_url, extension, &error)) << name;
   EXPECT_TRUE(error.empty()) << name;
 
   // We should only allow other schemes for extensions when it's a whitelisted
   // extension.
   error.clear();
   bool allow_on_other_schemes =
       PermissionsData::CanExecuteScriptEverywhere(extension);
   EXPECT_EQ(!allow_on_other_schemes,
             PermissionsData::IsRestrictedUrl(
-                invalid_url, invalid_url, extension, &error)) << name;
+                invalid_url, extension, &error)) << name;
   if (!allow_on_other_schemes) {
     EXPECT_EQ(ErrorUtils::FormatErrorMessage(
                   manifest_errors::kCannotAccessPage,
                   invalid_url.spec()),
               error) << name;
   } else {
     EXPECT_TRUE(error.empty());
   }
 }
 
@@ skipping 265 matching lines @@
     urls_.insert(https_url);
     urls_.insert(file_url);
     urls_.insert(favicon_url);
     urls_.insert(extension_url);
     urls_.insert(settings_url);
     urls_.insert(about_url);
     // Ignore the policy delegate for this test.
     PermissionsData::SetPolicyDelegate(NULL);
   }
 
-  bool AllowedScript(const Extension* extension, const GURL& url,
-                     const GURL& top_url) {
-    return AllowedScript(extension, url, top_url, -1);
+  bool AllowedScript(const Extension* extension, const GURL& url) {
+    return AllowedScript(extension, url, -1);
   }
 
-  bool AllowedScript(const Extension* extension, const GURL& url,
-                     const GURL& top_url, int tab_id) {
+  bool AllowedScript(const Extension* extension, const GURL& url, int tab_id) {
     return extension->permissions_data()->CanAccessPage(
-        extension, url, top_url, tab_id, -1, NULL);
+        extension, url, tab_id, -1, NULL);
   }
 
-  bool BlockedScript(const Extension* extension, const GURL& url,
-                     const GURL& top_url) {
+  bool BlockedScript(const Extension* extension, const GURL& url) {
     return !extension->permissions_data()->CanAccessPage(
-        extension, url, top_url, -1, -1, NULL);
+        extension, url, -1, -1, NULL);
   }
 
   bool Allowed(const Extension* extension, const GURL& url) {
     return Allowed(extension, url, -1);
   }
 
   bool Allowed(const Extension* extension, const GURL& url, int tab_id) {
     return (extension->permissions_data()->CanAccessPage(
-                extension, url, url, tab_id, -1, NULL) &&
+                extension, url, tab_id, -1, NULL) &&
             extension->permissions_data()->CanCaptureVisiblePage(tab_id, NULL));
   }
 
   bool CaptureOnly(const Extension* extension, const GURL& url) {
     return CaptureOnly(extension, url, -1);
   }
 
   bool CaptureOnly(const Extension* extension, const GURL& url, int tab_id) {
     return !extension->permissions_data()->CanAccessPage(
-               extension, url, url, tab_id, -1, NULL) &&
+               extension, url, tab_id, -1, NULL) &&
            extension->permissions_data()->CanCaptureVisiblePage(tab_id, NULL);
   }
 
-  bool ScriptOnly(const Extension* extension, const GURL& url,
-                  const GURL& top_url) {
-    return ScriptOnly(extension, url, top_url, -1);
+  bool ScriptOnly(const Extension* extension, const GURL& url) {
+    return ScriptOnly(extension, url, -1);
   }
 
-  bool ScriptOnly(const Extension* extension, const GURL& url,
-                  const GURL& top_url, int tab_id) {
-    return AllowedScript(extension, url, top_url, tab_id) &&
+  bool ScriptOnly(const Extension* extension, const GURL& url, int tab_id) {
+    return AllowedScript(extension, url, tab_id) &&
            !extension->permissions_data()->CanCaptureVisiblePage(tab_id, NULL);
   }
 
   bool Blocked(const Extension* extension, const GURL& url) {
     return Blocked(extension, url, -1);
   }
 
   bool Blocked(const Extension* extension, const GURL& url, int tab_id) {
     return !(extension->permissions_data()->CanAccessPage(
-                 extension, url, url, tab_id, -1, NULL) ||
+                 extension, url, tab_id, -1, NULL) ||
              extension->permissions_data()->CanCaptureVisiblePage(tab_id,
                                                                   NULL));
   }
 
   bool ScriptAllowedExclusivelyOnTab(
       const Extension* extension,
       const std::set<GURL>& allowed_urls,
       int tab_id) {
     bool result = true;
     for (std::set<GURL>::iterator it = urls_.begin(); it != urls_.end(); ++it) {
       const GURL& url = *it;
       if (allowed_urls.count(url))
-        result &= AllowedScript(extension, url, url, tab_id);
+        result &= AllowedScript(extension, url, tab_id);
       else
         result &= Blocked(extension, url, tab_id);
     }
     return result;
   }
 
   // URLs that are "safe" to provide scripting and capture visible tab access
   // to if the permissions allow it.
   const GURL http_url;
   const GURL http_url_with_path;
@@ skipping 22 matching lines @@
   EXPECT_TRUE(Allowed(extension.get(), http_url));
   EXPECT_TRUE(Allowed(extension.get(), https_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), file_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), settings_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), favicon_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), about_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), extension_url));
 
   // Test access to iframed content.
   GURL within_extension_url = extension->GetResourceURL("page.html");
-  EXPECT_TRUE(AllowedScript(extension.get(), http_url, http_url_with_path));
-  EXPECT_TRUE(AllowedScript(extension.get(), https_url, http_url_with_path));
-  EXPECT_TRUE(AllowedScript(extension.get(), http_url, within_extension_url));
-  EXPECT_TRUE(AllowedScript(extension.get(), https_url, within_extension_url));
-  EXPECT_TRUE(BlockedScript(extension.get(), http_url, extension_url));
-  EXPECT_TRUE(BlockedScript(extension.get(), https_url, extension_url));
+  EXPECT_TRUE(AllowedScript(extension.get(), http_url));
+  EXPECT_TRUE(AllowedScript(extension.get(), http_url_with_path));
+  EXPECT_TRUE(AllowedScript(extension.get(), https_url));
+  EXPECT_TRUE(BlockedScript(extension.get(), within_extension_url));
+  EXPECT_TRUE(BlockedScript(extension.get(), extension_url));
 
   EXPECT_FALSE(extension->permissions_data()->HasHostPermission(settings_url));
   EXPECT_FALSE(extension->permissions_data()->HasHostPermission(about_url));
   EXPECT_TRUE(extension->permissions_data()->HasHostPermission(favicon_url));
 
   // Test * for scheme, which implies just the http/https schemes.
   extension = LoadManifestStrict("script_and_capture",
       "extension_wildcard.json");
-  EXPECT_TRUE(ScriptOnly(extension.get(), http_url, http_url));
-  EXPECT_TRUE(ScriptOnly(extension.get(), https_url, https_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), http_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), https_url));
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
   EXPECT_TRUE(Blocked(extension.get(), about_url));
   EXPECT_TRUE(Blocked(extension.get(), file_url));
   EXPECT_TRUE(Blocked(extension.get(), favicon_url));
   extension =
       LoadManifest("script_and_capture", "extension_wildcard_settings.json");
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
 
   // Having chrome://*/ should not work for regular extensions. Note that
   // for favicon access, we require the explicit pattern chrome://favicon/*.
@@ skipping 33 matching lines @@
   EXPECT_TRUE(Allowed(extension.get(), https_url));
   EXPECT_TRUE(Allowed(extension.get(), settings_url));
   EXPECT_TRUE(Allowed(extension.get(), about_url));
   EXPECT_TRUE(Allowed(extension.get(), favicon_url));
   EXPECT_TRUE(extension->permissions_data()->HasHostPermission(favicon_url));
 
   // Component extensions should only get access to what they ask for.
   extension = LoadManifest("script_and_capture",
       "extension_component_google.json", Manifest::COMPONENT,
       Extension::NO_FLAGS);
-  EXPECT_TRUE(ScriptOnly(extension.get(), http_url, http_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), http_url));
   EXPECT_TRUE(Blocked(extension.get(), https_url));
   EXPECT_TRUE(Blocked(extension.get(), file_url));
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
   EXPECT_TRUE(Blocked(extension.get(), favicon_url));
   EXPECT_TRUE(Blocked(extension.get(), about_url));
   EXPECT_TRUE(Blocked(extension.get(), extension_url));
   EXPECT_FALSE(extension->permissions_data()->HasHostPermission(settings_url));
 }
 
 TEST_F(ExtensionScriptAndCaptureVisibleTest, PermissionsWithChromeURLsEnabled) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kExtensionsOnChromeURLs);
 
   scoped_refptr<Extension> extension;
 
   // Test <all_urls> for regular extensions.
   extension = LoadManifestStrict("script_and_capture",
       "extension_regular_all.json");
   EXPECT_TRUE(Allowed(extension.get(), http_url));
   EXPECT_TRUE(Allowed(extension.get(), https_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), file_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), settings_url));
   EXPECT_TRUE(Allowed(extension.get(), favicon_url));  // chrome:// requested
   EXPECT_TRUE(CaptureOnly(extension.get(), about_url));
   EXPECT_TRUE(CaptureOnly(extension.get(), extension_url));
 
   // Test access to iframed content.
   GURL within_extension_url = extension->GetResourceURL("page.html");
-  EXPECT_TRUE(AllowedScript(extension.get(), http_url, http_url_with_path));
-  EXPECT_TRUE(AllowedScript(extension.get(), https_url, http_url_with_path));
-  EXPECT_TRUE(AllowedScript(extension.get(), http_url, within_extension_url));
-  EXPECT_TRUE(AllowedScript(extension.get(), https_url, within_extension_url));
-  EXPECT_TRUE(AllowedScript(extension.get(), http_url, extension_url));
-  EXPECT_TRUE(AllowedScript(extension.get(), https_url, extension_url));
+  EXPECT_TRUE(AllowedScript(extension.get(), http_url));
+  EXPECT_TRUE(AllowedScript(extension.get(), http_url_with_path));
+  EXPECT_TRUE(AllowedScript(extension.get(), https_url));
+  EXPECT_TRUE(BlockedScript(extension.get(), within_extension_url));
+  EXPECT_TRUE(BlockedScript(extension.get(), extension_url));
 
   const PermissionsData* permissions_data = extension->permissions_data();
   EXPECT_FALSE(permissions_data->HasHostPermission(settings_url));
   EXPECT_FALSE(permissions_data->HasHostPermission(about_url));
   EXPECT_TRUE(permissions_data->HasHostPermission(favicon_url));
 
   // Test * for scheme, which implies just the http/https schemes.
   extension = LoadManifestStrict("script_and_capture",
       "extension_wildcard.json");
-  EXPECT_TRUE(ScriptOnly(extension.get(), http_url, http_url));
-  EXPECT_TRUE(ScriptOnly(extension.get(), https_url, https_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), http_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), https_url));
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
   EXPECT_TRUE(Blocked(extension.get(), about_url));
   EXPECT_TRUE(Blocked(extension.get(), file_url));
   EXPECT_TRUE(Blocked(extension.get(), favicon_url));
   extension =
       LoadManifest("script_and_capture", "extension_wildcard_settings.json");
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
 
   // Having chrome://*/ should work for regular extensions with the flag
   // enabled.
   std::string error;
   extension = LoadManifestUnchecked("script_and_capture",
                                     "extension_wildcard_chrome.json",
                                     Manifest::INTERNAL, Extension::NO_FLAGS,
                                     &error);
   EXPECT_FALSE(extension.get() == NULL);
   EXPECT_TRUE(Blocked(extension.get(), http_url));
   EXPECT_TRUE(Blocked(extension.get(), https_url));
-  EXPECT_TRUE(ScriptOnly(extension.get(), settings_url, settings_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), settings_url));
   EXPECT_TRUE(Blocked(extension.get(), about_url));
   EXPECT_TRUE(Blocked(extension.get(), file_url));
-  EXPECT_TRUE(ScriptOnly(extension.get(), favicon_url, favicon_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), favicon_url));
 
   // Having chrome://favicon/* should not give you chrome://*
   extension = LoadManifestStrict("script_and_capture",
       "extension_chrome_favicon_wildcard.json");
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
-  EXPECT_TRUE(ScriptOnly(extension.get(), favicon_url, favicon_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), favicon_url));
   EXPECT_TRUE(Blocked(extension.get(), about_url));
   EXPECT_TRUE(extension->permissions_data()->HasHostPermission(favicon_url));
 
   // Having http://favicon should not give you chrome://favicon
   extension = LoadManifestStrict("script_and_capture",
       "extension_http_favicon.json");
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
   EXPECT_TRUE(Blocked(extension.get(), favicon_url));
 
   // Component extensions with <all_urls> should get everything.
   extension = LoadManifest("script_and_capture", "extension_component_all.json",
       Manifest::COMPONENT, Extension::NO_FLAGS);
   EXPECT_TRUE(Allowed(extension.get(), http_url));
   EXPECT_TRUE(Allowed(extension.get(), https_url));
   EXPECT_TRUE(Allowed(extension.get(), settings_url));
   EXPECT_TRUE(Allowed(extension.get(), about_url));
   EXPECT_TRUE(Allowed(extension.get(), favicon_url));
   EXPECT_TRUE(extension->permissions_data()->HasHostPermission(favicon_url));
 
   // Component extensions should only get access to what they ask for.
   extension = LoadManifest("script_and_capture",
       "extension_component_google.json", Manifest::COMPONENT,
       Extension::NO_FLAGS);
-  EXPECT_TRUE(ScriptOnly(extension.get(), http_url, http_url));
+  EXPECT_TRUE(ScriptOnly(extension.get(), http_url));
   EXPECT_TRUE(Blocked(extension.get(), https_url));
   EXPECT_TRUE(Blocked(extension.get(), file_url));
   EXPECT_TRUE(Blocked(extension.get(), settings_url));
   EXPECT_TRUE(Blocked(extension.get(), favicon_url));
   EXPECT_TRUE(Blocked(extension.get(), about_url));
   EXPECT_TRUE(Blocked(extension.get(), extension_url));
   EXPECT_FALSE(extension->permissions_data()->HasHostPermission(settings_url));
 }
 
 TEST_F(ExtensionScriptAndCaptureVisibleTest, TabSpecific) {
@@ skipping 82 matching lines @@
 
   permissions_data->ClearTabSpecificPermissions(1);
   EXPECT_FALSE(permissions_data->GetTabSpecificPermissionsForTesting(1).get());
 
   EXPECT_TRUE(ScriptAllowedExclusivelyOnTab(extension.get(), no_urls, 0));
   EXPECT_TRUE(ScriptAllowedExclusivelyOnTab(extension.get(), no_urls, 1));
   EXPECT_TRUE(ScriptAllowedExclusivelyOnTab(extension.get(), no_urls, 2));
 }
 
 }  // namespace extensions