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

extensions/common/permissions/permissions_data.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 "extensions/common/permissions/permissions_data.h"
 
 #include "base/command_line.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
@@ skipping 65 matching lines @@
 }
 
 bool PermissionsData::ShouldSkipPermissionWarnings(
     const std::string& extension_id) {
   // See http://b/4946060 for more details.
   return extension_id == std::string("nckgahadagoaajjgafhacjanaoiihapd");
 }
 
 // static
 bool PermissionsData::IsRestrictedUrl(const GURL& document_url,
-                                      const GURL& top_frame_url,
                                       const Extension* extension,
                                       std::string* error) {
   if (extension && CanExecuteScriptEverywhere(extension))
     return false;
 
   // Check if the scheme is valid for extensions. If not, return.
   if (!URLPattern::IsValidSchemeForExtensions(document_url.scheme()) &&
       document_url.spec() != url::kAboutBlankURL) {
     if (error) {
       *error = ErrorUtils::FormatErrorMessage(
                    manifest_errors::kCannotAccessPage,
                    document_url.spec());
     }
     return true;
   }
 
   if (!ExtensionsClient::Get()->IsScriptableURL(document_url, error))
     return true;
 
   bool allow_on_chrome_urls = base::CommandLine::ForCurrentProcess()->HasSwitch(
                                   switches::kExtensionsOnChromeURLs);
   if (document_url.SchemeIs(content::kChromeUIScheme) &&
       !allow_on_chrome_urls) {
     if (error)
       *error = manifest_errors::kCannotAccessChromeUrl;
     return true;
   }
 
-  if (extension && top_frame_url.SchemeIs(kExtensionScheme) &&
-      top_frame_url.host() != extension->id() && !allow_on_chrome_urls) {
+  if (extension && document_url.SchemeIs(kExtensionScheme) &&
+      document_url.host() != extension->id() && !allow_on_chrome_urls) {
     if (error)
       *error = manifest_errors::kCannotAccessExtensionUrl;
     return true;
   }
 
   return false;
 }
 
 void PermissionsData::SetPermissions(
     const scoped_refptr<const PermissionSet>& active,
@@ skipping 93 matching lines @@
 
 bool PermissionsData::HasWithheldImpliedAllHosts() const {
   // Since we currently only withhold all_hosts, it's sufficient to check
   // that either set is not empty.
   return !withheld_permissions()->explicit_hosts().is_empty() ||
          !withheld_permissions()->scriptable_hosts().is_empty();
 }
 
 bool PermissionsData::CanAccessPage(const Extension* extension,
                                     const GURL& document_url,
-                                    const GURL& top_frame_url,
                                     int tab_id,
                                     int process_id,
                                     std::string* error) const {
   AccessType result = CanRunOnPage(extension,
                                    document_url,
-                                   top_frame_url,
                                    tab_id,
                                    process_id,
                                    active_permissions()->explicit_hosts(),
                                    withheld_permissions()->explicit_hosts(),
                                    error);
   // TODO(rdevlin.cronin) Update callers so that they only need ACCESS_ALLOWED.
   return result == ACCESS_ALLOWED || result == ACCESS_WITHHELD;
 }
 
 PermissionsData::AccessType PermissionsData::GetPageAccess(
     const Extension* extension,
     const GURL& document_url,
-    const GURL& top_frame_url,
     int tab_id,
     int process_id,
     std::string* error) const {
   return CanRunOnPage(extension,
                       document_url,
-                      top_frame_url,
                       tab_id,
                       process_id,
                       active_permissions()->explicit_hosts(),
                       withheld_permissions()->explicit_hosts(),
                       error);
 }
 
 bool PermissionsData::CanRunContentScriptOnPage(const Extension* extension,
                                                 const GURL& document_url,
-                                                const GURL& top_frame_url,
                                                 int tab_id,
                                                 int process_id,
                                                 std::string* error) const {
   AccessType result = CanRunOnPage(extension,
                                    document_url,
-                                   top_frame_url,
                                    tab_id,
                                    process_id,
                                    active_permissions()->scriptable_hosts(),
                                    withheld_permissions()->scriptable_hosts(),
                                    error);
   // TODO(rdevlin.cronin) Update callers so that they only need ACCESS_ALLOWED.
   return result == ACCESS_ALLOWED || result == ACCESS_WITHHELD;
 }
 
 PermissionsData::AccessType PermissionsData::GetContentScriptAccess(
     const Extension* extension,
     const GURL& document_url,
-    const GURL& top_frame_url,
     int tab_id,
     int process_id,
     std::string* error) const {
   return CanRunOnPage(extension,
                       document_url,
-                      top_frame_url,
                       tab_id,
                       process_id,
                       active_permissions()->scriptable_hosts(),
                       withheld_permissions()->scriptable_hosts(),
                       error);
 }
 
 bool PermissionsData::CanCaptureVisiblePage(int tab_id,
                                             std::string* error) const {
   const URLPattern all_urls(URLPattern::SCHEME_ALL,
@@ skipping 44 matching lines @@
         tab_permissions->explicit_hosts().MatchesSecurityOrigin(url)) {
       return true;
     }
   }
   return false;
 }
 
 PermissionsData::AccessType PermissionsData::CanRunOnPage(
     const Extension* extension,
     const GURL& document_url,
-    const GURL& top_frame_url,
     int tab_id,
     int process_id,
     const URLPatternSet& permitted_url_patterns,
     const URLPatternSet& withheld_url_patterns,
     std::string* error) const {
   if (g_policy_delegate &&
       !g_policy_delegate->CanExecuteScriptOnPage(
-          extension, document_url, top_frame_url, tab_id, process_id, error)) {
+          extension, document_url, tab_id, process_id, error)) {
     return ACCESS_DENIED;
   }
 
-  if (IsRestrictedUrl(document_url, top_frame_url, extension, error))
+  if (IsRestrictedUrl(document_url, extension, error))
     return ACCESS_DENIED;
 
-  if (HasTabSpecificPermissionToExecuteScript(tab_id, top_frame_url))
+  if (HasTabSpecificPermissionToExecuteScript(tab_id, document_url))
     return ACCESS_ALLOWED;
 
   if (permitted_url_patterns.MatchesURL(document_url))
     return ACCESS_ALLOWED;
 
   if (withheld_url_patterns.MatchesURL(document_url))
     return ACCESS_WITHHELD;
 
   if (error) {
     *error = ErrorUtils::FormatErrorMessage(manifest_errors::kCannotAccessPage,
                                             document_url.spec());
   }
   return ACCESS_DENIED;
 }
 
 }  // namespace extensions