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

extensions/common/permissions/permissions_data.h

 // 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.
 
 #ifndef EXTENSIONS_COMMON_PERMISSIONS_PERMISSIONS_DATA_H_
 #define EXTENSIONS_COMMON_PERMISSIONS_PERMISSIONS_DATA_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 31 matching lines @@
   // Delegate class to allow different contexts (e.g. browser vs renderer) to
   // have control over policy decisions.
   class PolicyDelegate {
    public:
     virtual ~PolicyDelegate() {}
 
     // Returns false if script access should be blocked on this page.
     // Otherwise, default policy should decide.
     virtual bool CanExecuteScriptOnPage(const Extension* extension,
                                         const GURL& document_url,
-                                        const GURL& top_document_url,
                                         int tab_id,
                                         int process_id,
                                         std::string* error) = 0;
   };
 
   static void SetPolicyDelegate(PolicyDelegate* delegate);
 
   PermissionsData(const Extension* extension);
   virtual ~PermissionsData();
 
@@ skipping 10 matching lines @@
       const PermissionSet* permissions);
 
   // Returns true if we should skip the permissions warning for the extension
   // with the given |extension_id|.
   static bool ShouldSkipPermissionWarnings(const std::string& extension_id);
 
   // Returns true if the given |url| is restricted for the given |extension|,
   // as is commonly the case for chrome:// urls.
   // NOTE: You probably want to use CanAccessPage().
   static bool IsRestrictedUrl(const GURL& document_url,
-                              const GURL& top_frame_url,
                               const Extension* extension,
                               std::string* error);
 
   // Sets the runtime permissions of the given |extension| to |active| and
   // |withheld|.
   void SetPermissions(const scoped_refptr<const PermissionSet>& active,
                       const scoped_refptr<const PermissionSet>& withheld) const;
 
   // Updates the tab-specific permissions of |tab_id| to include those from
   // |permissions|.
@@ skipping 57 matching lines @@
   // something close to it), but has had it withheld.
   bool HasWithheldImpliedAllHosts() const;
 
   // Returns true if the |extension| has permission to access and interact with
   // the specified page, in order to do things like inject scripts or modify
   // the content.
   // If this returns false and |error| is non-NULL, |error| will be popualted
   // with the reason the extension cannot access the page.
   bool CanAccessPage(const Extension* extension,
                      const GURL& document_url,
-                     const GURL& top_document_url,
                      int tab_id,
                      int process_id,
                      std::string* error) const;
   // Like CanAccessPage, but also takes withheld permissions into account.
   // TODO(rdevlin.cronin) We shouldn't have two functions, but not all callers
   // know how to wait for permission.
   AccessType GetPageAccess(const Extension* extension,
                            const GURL& document_url,
-                           const GURL& top_document_url,
                            int tab_id,
                            int process_id,
                            std::string* error) const;
 
   // Returns true if the |extension| has permission to inject a content script
   // on the page.
   // If this returns false and |error| is non-NULL, |error| will be popualted
   // with the reason the extension cannot script the page.
   // NOTE: You almost certainly want to use CanAccessPage() instead of this
   // method.
   bool CanRunContentScriptOnPage(const Extension* extension,
                                  const GURL& document_url,
-                                 const GURL& top_document_url,
                                  int tab_id,
                                  int process_id,
                                  std::string* error) const;
   // Like CanRunContentScriptOnPage, but also takes withheld permissions into
   // account.
   // TODO(rdevlin.cronin) We shouldn't have two functions, but not all callers
   // know how to wait for permission.
   AccessType GetContentScriptAccess(const Extension* extension,
                                     const GURL& document_url,
-                                    const GURL& top_document_url,
                                     int tab_id,
                                     int process_id,
                                     std::string* error) const;
 
   // Returns true if extension is allowed to obtain the contents of a page as
   // an image. Since a page may contain sensitive information, this is
   // restricted to the extension's host permissions as well as the extension
   // page itself.
   bool CanCaptureVisiblePage(int tab_id, std::string* error) const;
 
@@ skipping 30 matching lines @@
   // Note that if this returns false, it doesn't mean the extension can't run on
   // the given tab, only that it does not have tab-specific permission to do so.
   bool HasTabSpecificPermissionToExecuteScript(int tab_id,
                                                const GURL& url) const;
 
   // Returns whether or not the extension is permitted to run on the given page,
   // checking against |permitted_url_patterns| in addition to blocking special
   // sites (like the webstore or chrome:// urls).
   AccessType CanRunOnPage(const Extension* extension,
                           const GURL& document_url,
-                          const GURL& top_document_url,
                           int tab_id,
                           int process_id,
                           const URLPatternSet& permitted_url_patterns,
                           const URLPatternSet& withheld_url_patterns,
                           std::string* error) const;
 
   // The associated extension's id.
   std::string extension_id_;
 
   // The associated extension's manifest type.
@@ skipping 16 matching lines @@
   mutable scoped_refptr<const PermissionSet> withheld_permissions_unsafe_;
 
   mutable TabPermissionsMap tab_specific_permissions_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionsData);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_PERMISSIONS_PERMISSIONS_DATA_H_