Separate PermissionsData::CanExecuteScriptOnPage into two functions

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 29 matching lines @@
   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,
-                                        const UserScript* script,
                                         int process_id,
                                         std::string* error) = 0;
   };
 
   static void SetPolicyDelegate(PolicyDelegate* delegate);
 
   PermissionsData(const Extension* extension);
   virtual ~PermissionsData();
 
   // Returns true if the |extension| can silently increase its permission level.
@@ skipping 57 matching lines @@
   PermissionMessages GetPermissionMessages() const;
 
   // Returns the full list of permission messages that should display at install
   // time as strings.
   std::vector<base::string16> GetPermissionMessageStrings() const;
 
   // Returns the full list of permission details for messages that should
   // display at install time as strings.
   std::vector<base::string16> GetPermissionMessageDetailsStrings() const;
 
-  // Returns true if the given |extension| can execute script on a page. If a
-  // UserScript object is passed, permission to run that specific script is
-  // checked (using its matches list). Otherwise, permission to execute script
-  // programmatically is checked (using the extension's host permission).
-  //
-  // This method is also aware of certain special pages that extensions are
-  // usually not allowed to run script on.
-  bool CanExecuteScriptOnPage(const Extension* extension,
-                              const GURL& document_url,
-                              const GURL& top_document_url,
-                              int tab_id,
-                              const UserScript* script,
-                              int process_id,
-                              std::string* error) 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;
+
+  // 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.

[not at google - send to devlin, 2014/06/06 18:46:52]

"CanContentScriptPage" ... still looks a little bit too much like
"CanExecuteScriptOnPage" -- and we definitely want to discourage people from
using this vs CanAccessPage.

I would do a couple of things here:
- note that callers "almost certainly want to use CanAccessPage not
CanContentScriptPage" in a comment.
- fix the grammar nit that "content script" is a noun not a verb, so
CanRunContentScriptOnPage (or more technically "CanRunUserScriptOnPage") is
better and wordier .: people are even less likely to naively call it.

[Devlin, 2014/06/06 19:25:02]

Done and done.

+  bool CanContentScriptPage(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;
 
   // Returns true if the user should be alerted that the |extension| is running
   // a script. If |tab_id| and |url| are included, this also considers tab-
   // specific permissions.
@@ skipping 22 matching lines @@
   scoped_refptr<const PermissionSet> GetTabSpecificPermissions(
       int tab_id) const;
 
   // Returns true if the |extension| has tab-specific permission to operate on
   // the tab specified by |tab_id| with the given |url|.
   // 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 true if 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).
+  bool CanRunOnPage(const Extension* extension,
+                    const GURL& document_url,
+                    const GURL& top_document_url,
+                    int tab_id,
+                    int process_id,
+                    const URLPatternSet& permitted_url_patterns,
+                    std::string* error) const;
+
   // The associated extension's id.
   std::string extension_id_;
 
   // The associated extension's manifest type.
   Manifest::Type manifest_type_;
 
   mutable base::Lock runtime_lock_;
 
   // The permission's which are currently active on the extension during
   // runtime.
   // Unsafe indicates that we must lock anytime this is directly accessed.
   // Unless you need to change |active_permissions_unsafe_|, use the (safe)
   // active_permissions() accessor.
   mutable scoped_refptr<const PermissionSet> active_permissions_unsafe_;
 
   mutable TabPermissionsMap tab_specific_permissions_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionsData);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_PERMISSIONS_PERMISSIONS_DATA_H_