Make ActiveTabPermissionManager also grant the tabs permission.

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 3420 matching lines @@
     if (CanExecuteScriptEverywhere())
       return true;
 
     return false;
   }
 
   // Otherwise, the valid schemes were handled by URLPattern.
   return true;
 }
 
-bool Extension::HasAPIPermission(
-    APIPermission::ID permission) const {
+bool Extension::HasAPIPermission(APIPermission::ID permission) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->HasAPIPermission(permission);
 }
 
-bool Extension::HasAPIPermission(
-    const std::string& function_name) const {
+bool Extension::HasAPIPermission(const std::string& function_name) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->
       HasAccessToFunction(function_name);
 }
 
+bool Extension::HasAPIPermissionForTab(int tab_id,
+                                       APIPermission::ID permission) const {
+  base::AutoLock auto_lock(runtime_data_lock_);
+  if (runtime_data_.GetActivePermissions()->HasAPIPermission(permission))
+    return true;
+  scoped_refptr<const PermissionSet> tab_specific_permissions =
+      runtime_data_.GetTabSpecificPermissions(tab_id);
+  return tab_specific_permissions.get() &&
+         tab_specific_permissions->HasAPIPermission(permission);
+}
+
 const URLPatternSet& Extension::GetEffectiveHostPermissions() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->effective_hosts();
 }
 
 bool Extension::HasHostPermission(const GURL& url) const {
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
       url.host() != chrome::kChromeUIFaviconHost &&
       url.host() != chrome::kChromeUIThumbnailHost &&
       location() != Extension::COMPONENT) {
@@ skipping 77 matching lines @@
       *error = errors::kCannotScriptGallery;
     return false;
   }
 
   if (page_url.SchemeIs(chrome::kChromeUIScheme) &&
       !CanExecuteScriptEverywhere())
     return false;
 
   // 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)) {
+    scoped_refptr<const PermissionSet> tab_permissions =
+        runtime_data_.GetTabSpecificPermissions(tab_id);
+    if (tab_permissions.get() &&
+        tab_permissions->explicit_hosts().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.
@@ skipping 49 matching lines @@
     }
   }
 
   return false;
 }
 
 bool Extension::CanCaptureVisiblePage(const GURL& page_url,
                                       int tab_id,
                                       std::string *error) const {
   if (tab_id >= 0) {
-    const URLPatternSet* tab_permissions =
-        GetTabSpecificHostPermissions(tab_id);
-    if (tab_permissions &&
-        tab_permissions->MatchesSecurityOrigin(page_url)) {
+    scoped_refptr<const PermissionSet> tab_permissions =
+        GetTabSpecificPermissions(tab_id);
+    if (tab_permissions.get() &&
+        tab_permissions->explicit_hosts().MatchesSecurityOrigin(page_url)) {
       return true;
     }
   }
 
   if (HasHostPermission(page_url) || page_url.GetOrigin() == url())
     return true;
 
   if (error) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
                                                      page_url.spec());
@@ skipping 138 matching lines @@
 
 bool Extension::HasContentScriptAtURL(const GURL& url) const {
   for (UserScriptList::const_iterator it = content_scripts_.begin();
       it != content_scripts_.end(); ++it) {
     if (it->MatchesURL(url))
       return true;
   }
   return false;
 }
 
-const URLPatternSet* Extension::GetTabSpecificHostPermissions(
+scoped_refptr<const PermissionSet> Extension::GetTabSpecificPermissions(
     int tab_id) const {
   base::AutoLock auto_lock(runtime_data_lock_);
-  return runtime_data_.GetTabSpecificHostPermissions(tab_id);
+  return runtime_data_.GetTabSpecificPermissions(tab_id);
 }
 
-void Extension::SetTabSpecificHostPermissions(
+void Extension::UpdateTabSpecificPermissions(
     int tab_id,
-    const URLPatternSet& permissions) const {
+    const PermissionSet* permissions) const {
   base::AutoLock auto_lock(runtime_data_lock_);
-  runtime_data_.SetTabSpecificHostPermissions(tab_id, permissions);
+  runtime_data_.UpdateTabSpecificPermissions(tab_id, permissions);
 }
 
-void Extension::ClearTabSpecificHostPermissions(int tab_id) const {
+void Extension::ClearTabSpecificPermissions(int tab_id) const {
   base::AutoLock auto_lock(runtime_data_lock_);
-  runtime_data_.ClearTabSpecificHostPermissions(tab_id);
+  runtime_data_.ClearTabSpecificPermissions(tab_id);
 }
 
 bool Extension::CheckPlatformAppFeatures(std::string* utf8_error) {
   if (!is_platform_app())
     return true;
 
   if (!has_background_page()) {
     *utf8_error = errors::kBackgroundRequiredForPlatformApps;
     return false;
   }
@@ skipping 21 matching lines @@
 scoped_refptr<const PermissionSet>
     Extension::RuntimeData::GetActivePermissions() const {
   return active_permissions_;
 }
 
 void Extension::RuntimeData::SetActivePermissions(
     const PermissionSet* active) {
   active_permissions_ = active;
 }
 
-const URLPatternSet*
-    Extension::RuntimeData::GetTabSpecificHostPermissions(int tab_id) const {
+scoped_refptr<const PermissionSet>
+    Extension::RuntimeData::GetTabSpecificPermissions(int tab_id) const {
   CHECK_GE(tab_id, 0);
-  TabHostPermissionsMap::const_iterator it =
-      tab_specific_host_permissions_.find(tab_id);
-  return (it != tab_specific_host_permissions_.end()) ? it->second.get() : NULL;
+  TabPermissionsMap::const_iterator it = tab_specific_permissions_.find(tab_id);
+  return (it != tab_specific_permissions_.end()) ? it->second : NULL;
 }
 
-void Extension::RuntimeData::SetTabSpecificHostPermissions(
+void Extension::RuntimeData::UpdateTabSpecificPermissions(
     int tab_id,
-    const URLPatternSet& hosts) {
+    const PermissionSet* permissions) {
   CHECK_GE(tab_id, 0);
-  tab_specific_host_permissions_[tab_id] =
-      make_linked_ptr(new URLPatternSet(hosts));
+  if (tab_specific_permissions_.count(tab_id)) {
+    tab_specific_permissions_[tab_id] = PermissionSet::CreateUnion(
+        tab_specific_permissions_[tab_id],
+        permissions);
+  } else {
+    tab_specific_permissions_[tab_id] = permissions;
+  }
 }
 
-void Extension::RuntimeData::ClearTabSpecificHostPermissions(int tab_id) {
+void Extension::RuntimeData::ClearTabSpecificPermissions(int tab_id) {
   CHECK_GE(tab_id, 0);
-  tab_specific_host_permissions_.erase(tab_id);
+  tab_specific_permissions_.erase(tab_id);
 }
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     extension_misc::UnloadedExtensionReason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions