Implement scriptBadge.requestToAct.

chrome/common/extensions/extension.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 3509 matching lines @@
 
   if (browser_action())
     ++num_surfaces;
 
   if (is_app())
     ++num_surfaces;
 
   return num_surfaces > 1;
 }
 
-bool Extension::CanExecuteScriptOnPage(const GURL& page_url,
-                                       int tab_id,
-                                       const UserScript* script,
-                                       std::string* error) const {
-  base::AutoLock auto_lock(runtime_data_lock_);
+bool Extension::IsPageTooSensitiveForScript(const GURL& page_url,
+                                            std::string* error) const {
   // The gallery is special-cased as a restricted URL for scripting to prevent
   // access to special JS bindings we expose to the gallery (and avoid things
   // like extensions removing the "report abuse" link).
   // TODO(erikkay): This seems like the wrong test.  Shouldn't we we testing
   // against the store app extent?
   GURL store_url(extension_urls::GetWebstoreLaunchURL());
   if ((page_url.host() == store_url.host()) &&
       !CanExecuteScriptEverywhere() &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAllowScriptingGallery)) {
     if (error)
       *error = errors::kCannotScriptGallery;
-    return false;
+    return true;
   }
 
   if (page_url.SchemeIs(chrome::kChromeUIScheme) &&
       !CanExecuteScriptEverywhere())
+    return true;
+
+  return false;
+}
+
+bool Extension::CanExecuteScriptOnPage(const GURL& page_url,
+                                       int tab_id,
+                                       const UserScript* script,
+                                       std::string* error) const {
+  if (IsPageTooSensitiveForScript(page_url, error))
     return false;
 
+  base::AutoLock auto_lock(runtime_data_lock_);
   // If a tab ID is specified, try the tab-specific permissions.
   if (tab_id >= 0) {
     const URLPatternSet* tab_permissions =
         runtime_data_.GetTabSpecificHostPermissions(tab_id);
     if (tab_permissions &&
         tab_permissions->MatchesSecurityOrigin(page_url)) {
       return true;
     }
   }
 
   // If a script is specified, use its matches.
   if (script)
     return script->MatchesURL(page_url);
 
   // Otherwise, see if this extension has permission to execute script
   // programmatically on pages.
   if (runtime_data_.GetActivePermissions()->HasExplicitAccessToOrigin(
           page_url))
     return true;
 
   if (error) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
                                                      page_url.spec());
   }
 
   return false;
 }
 
+bool Extension::CanRequestToActOnPage(const GURL& page_url,
+                                      int tab_id) const {
+  if (IsPageTooSensitiveForScript(page_url, NULL))

[Aaron Boodman, 2012/07/03 01:29:31]

I think this should just be IsPageTooSensitive... CanExecuteScript... shouldn't
be a factor.

[Jeffrey Yasskin, 2012/07/10 21:52:33]

Done.

+    return false;
+  return !CanExecuteScriptOnPage(page_url, tab_id, NULL, NULL);
+}
+
 bool Extension::ShowConfigureContextMenus() const {
   // Don't show context menu for component extensions. We might want to show
   // options for component extension button but now there is no component
   // extension with options. All other menu items like uninstall have
   // no sense for component extensions.
   return location() != Extension::COMPONENT;
 }
 
 bool Extension::CanSpecifyExperimentalPermission() const {
   if (location() == Extension::COMPONENT)
@@ skipping 283 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions