Take 2 at implementing activeTab.

chrome/common/extensions/extension.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 #define CHROME_COMMON_EXTENSIONS_EXTENSION_H_
 #pragma once
 
 #include <algorithm>
 #include <map>
@@ skipping 476 matching lines @@
                           const gfx::Size& max_size) const;
 
   // Returns true if this 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 GURL& page_url,
+                              int tab_id,
                               const UserScript* script,
                               std::string* error) const;
 
   // Returns true if this extension is a COMPONENT extension, or if it is
   // on the whitelist of extensions that can script all pages.
   bool CanExecuteScriptEverywhere() const;
 
   // Returns true if this 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(const GURL& page_url, std::string* error) const;
+  bool CanCaptureVisiblePage(const GURL& page_url,
+                             int tab_id,
+                             std::string* error) const;
 
   // Returns true if this extension updates itself using the extension
   // gallery.
   bool UpdatesFromGallery() const;
 
   // Returns true if this extension or app includes areas within |origin|.
   bool OverlapsWithOrigin(const GURL& origin) const;
 
   // Returns the sync bucket to use for this extension.
   SyncType GetSyncType() const;
 
   // Returns true if the extension should be synced.
   bool IsSyncable() const;
 
   // Returns true if the extension should be displayed in the launcher.
   bool ShouldDisplayInLauncher() const;
 
   // Returns true if the extension should be displayed in the extension
   // settings page (i.e. chrome://extensions).
   bool ShouldDisplayInExtensionSettings() const;
 
   // Returns true if the extension has a content script declared at |url|.
   bool HasContentScriptAtURL(const GURL& url) const;
 
   // Returns an ExtensionAction representing the script badge that should be
   // shown for this extension in the location bar.
   ExtensionAction* GetScriptBadge() const;
 
+  // Gets the tab-specific host permissions of |tab_id|, or NULL if there
+  // aren't any.
+  //
+  // This is a weak pointer. Callers should create a copy before mutating any
+  // tab specific permissions.
+  const URLPatternSet* GetTabSpecificHostPermissions(int tab_id) const;
+
+  // Sets the tab-specific host permissions of |tab_id| to |permissions|.
+  void SetTabSpecificHostPermissions(int tab_id,
+                                     const URLPatternSet& permissions) const;
+
+  // Clears the tab-specific host permissions of |tab_id|.
+  void ClearTabSpecificHostPermissions(int tab_id) const;
+
   // Accessors:
 
   const FilePath& path() const { return path_; }
   const GURL& url() const { return extension_url_; }
   Location location() const;
   const std::string& id() const;
   const Version* version() const { return version_.get(); }
   const std::string VersionString() const;
   const std::string& name() const { return name_; }
   const std::string& non_localized_name() const { return non_localized_name_; }
@@ skipping 131 matching lines @@
 
   class RuntimeData {
    public:
     RuntimeData();
     explicit RuntimeData(const ExtensionPermissionSet* active);
     ~RuntimeData();
 
     void SetActivePermissions(const ExtensionPermissionSet* active);
     scoped_refptr<const ExtensionPermissionSet> GetActivePermissions() const;
 
+    const URLPatternSet* GetTabSpecificHostPermissions(int tab_id) const;
+    void SetTabSpecificHostPermissions(int tab_id,
+                                       const URLPatternSet& permissions);
+    void ClearTabSpecificHostPermissions(int tab_id);
+
    private:
     friend class base::RefCountedThreadSafe<RuntimeData>;
+
     scoped_refptr<const ExtensionPermissionSet> active_permissions_;
+
+    typedef std::map<int, linked_ptr<const URLPatternSet> >
+        TabHostPermissionsMap;
+    TabHostPermissionsMap tab_specific_host_permissions_;
   };
 
   // Chooses the extension ID for an extension based on a variety of criteria.
   // The chosen ID will be set in |manifest|.
   static bool InitExtensionID(extensions::Manifest* manifest,
                               const FilePath& path,
                               const std::string& explicit_id,
                               int creation_flags,
                               string16* error);
 
@@ skipping 435 matching lines @@
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
       const ExtensionPermissionSet* permissions,
       Reason reason);
 };
 
 } // namespace extensions
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_