Add a centralized mechanism for whitelisting access to extension permissions.

chrome/common/extensions/extension_permission_set.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_PERMISSION_SET_H_
 #define CHROME_COMMON_EXTENSIONS_EXTENSION_PERMISSION_SET_H_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/string16.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 
+// TODO(jstritar): Move each class to its own file in extensions/permissions.
+
 class Extension;
 class ExtensionPermissionsInfo;
 
 // When prompting the user to install or approve permissions, we display
 // messages describing the effects of the permissions rather than listing the
 // permissions themselves. Each ExtensionPermissionMessage represents one of the
 // messages shown to the user.
 class ExtensionPermissionMessage {
  public:
   // Do not reorder this enumeration. If you need to add a new enum, add it just
@@ skipping 109 matching lines @@
   enum Flag {
     kFlagNone = 0,
 
     // Indicates if the permission implies full access (native code).
     kFlagImpliesFullAccess = 1 << 0,
 
     // Indicates if the permission implies full URL access.
     kFlagImpliesFullURLAccess = 1 << 1,
 
     // Indicates that the permission is private to COMPONENT extensions.
-    kFlagComponentOnly = 1 << 2,
+    // Depcrecated: please use the whitelist.
+    kFlagComponentOnly_Deprecated = 1 << 2,

[Aaron Boodman, 2012/02/02 18:17:31]

Sorry another nit here:

I think it is fine to have the component-only bit in addition to the whitelist.
It is more flexible than a whitelist. I think we really only need the whitelist
in cases where the extension we want to restrict to is _not_ a component
extension.

[jstritar, 2012/02/03 14:33:17]

Done.

 
     // Indicates that extensions cannot specify the permission as optional.
-    kFlagCannotBeOptional = 1 << 3,
+    kFlagCannotBeOptional = 1 << 3
   };
 
   // Flags for specifying what extension types can use the permission.
   enum TypeRestriction {
     kTypeNone = 0,
 
     // Extension::TYPE_EXTENSION and Extension::TYPE_USER_SCRIPT
     kTypeExtension = 1 << 0,
 
     // Extension::TYPE_HOSTED_APP
@@ skipping 39 matching lines @@
   }
 
   // Returns true if this permission implies full URL access.
   bool implies_full_url_access() const {
     return (flags_ & kFlagImpliesFullURLAccess) != 0;
   }
 
   // Returns true if this permission can only be acquired by COMPONENT
   // extensions.
   bool is_component_only() const {
-    return (flags_ & kFlagComponentOnly) != 0;
+    return (flags_ & kFlagComponentOnly_Deprecated) != 0;
   }
 
+  // Returns true if access to this permission is restricted by a whitelist.
+  bool HasWhitelist() const;
+
+  // Returns true if |extension_id| is whitelisted. The return value is only
+  // relevant if this permission has a whitelist.
+  bool IsWhitelisted(const std::string& extension_id) const;
+
   // Returns true if regular extensions can specify this permission.
   bool supports_extensions() const {
     return (type_restrictions_ & kTypeExtension) != 0;
   }
 
   // Returns true if hosted apps can specify this permission.
   bool supports_hosted_apps() const {
     return (type_restrictions_ & kTypeHostedApp) != 0;
   }
 
@@ skipping 18 matching lines @@
     return (type_restrictions_ & type) != 0;
   }
 
  private:
   // Instances should only be constructed from within ExtensionPermissionsInfo.
   friend class ExtensionPermissionsInfo;
 
   // Register ALL the permissions!
   static void RegisterAllPermissions(ExtensionPermissionsInfo* info);
 
+  typedef std::set<std::string> ExtensionWhitelist;
+
   explicit ExtensionAPIPermission(
       ID id,
       const char* name,
       int l10n_message_id,
       ExtensionPermissionMessage::ID message_id,
       int flags,
       int type_restrictions);
 
+  // Adds |extension_id| to the whitelist for this permission.
+  void AddToWhitelist(const std::string& extension_id);
+
   ID id_;
   const char* name_;
   int flags_;
   int type_restrictions_;
   int l10n_message_id_;
   ExtensionPermissionMessage::ID message_id_;
+  ExtensionWhitelist whitelist_;
 };
 
 typedef std::set<ExtensionAPIPermission::ID> ExtensionAPIPermissionSet;
 
 // Singleton that holds the extension permission instances and provides static
 // methods for accessing them.
 class ExtensionPermissionsInfo {
  public:
   // Returns a pointer to the singleton instance.
   static ExtensionPermissionsInfo* GetInstance();
@@ skipping 18 matching lines @@
  private:
   friend class ExtensionAPIPermission;
 
   ~ExtensionPermissionsInfo();
   ExtensionPermissionsInfo();
 
   // Registers an |alias| for a given permission |name|.
   void RegisterAlias(const char* name, const char* alias);
 
   // Registers a permission with the specified attributes and flags.
-  void RegisterPermission(
+  ExtensionAPIPermission* RegisterPermission(
       ExtensionAPIPermission::ID id,
       const char* name,
       int l10n_message_id,
       ExtensionPermissionMessage::ID message_id,
       int flags,
       int type_restrictions);
 
   // Maps permission ids to permissions.
   typedef std::map<ExtensionAPIPermission::ID, ExtensionAPIPermission*> IDMap;
 
@@ skipping 112 matching lines @@
 
   const ExtensionAPIPermissionSet& apis() const { return apis_; }
 
   const URLPatternSet& effective_hosts() const { return effective_hosts_; }
 
   const URLPatternSet& explicit_hosts() const { return explicit_hosts_; }
 
   const URLPatternSet& scriptable_hosts() const { return scriptable_hosts_; }
 
  private:
-  FRIEND_TEST_ALL_PREFIXES(ExtensionPermissionSetTest,
+  FRIEND_TEST_ALL_PREFIXES(ExtensionPermissionsTest,
                            HasLessHostPrivilegesThan);
 
   friend class base::RefCountedThreadSafe<ExtensionPermissionSet>;
 
   static std::set<std::string> GetDistinctHosts(
       const URLPatternSet& host_patterns,
       bool include_rcd,
       bool exclude_file_scheme);
 
   // Initializes the set based on |extension|'s manifest data.
@@ skipping 25 matching lines @@
 
   // The list of hosts that can be scripted by content scripts.
   // TODO(jstritar): Rename to "user_script_hosts_"?
   URLPatternSet scriptable_hosts_;
 
   // The list of hosts this effectively grants access to.
   URLPatternSet effective_hosts_;
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_PERMISSION_SET_H_