Move each permission classes to its own files in extensions/permissions

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 <iosfwd>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/hash_tables.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "chrome/common/extensions/command.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
-#include "chrome/common/extensions/extension_permission_set.h"
+#include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/extensions/url_pattern_set.h"
 #include "googleurl/src/gurl.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/gfx/size.h"
 
 class ExtensionResource;
 class FileBrowserHandler;
 class SkBitmap;
@@ skipping 134 matching lines @@
     std::string lang;
     std::string gender;
     std::set<std::string> event_types;
   };
 
   // OAuth2 info included in the extension.
   struct OAuth2Info {
     OAuth2Info();
     ~OAuth2Info();
 
-    ExtensionOAuth2Scopes GetScopesAsSet();
+    OAuth2Scopes GetScopesAsSet();
 
     std::string client_id;
     std::vector<std::string> scopes;
   };
 
   struct InstallWarning {
     enum Format {
       // IMPORTANT: Do not build HTML strings from user or developer-supplied
       // input.
       FORMAT_TEXT,
@@ skipping 231 matching lines @@
   static GURL GetBaseURLFromExtensionId(const std::string& extension_id);
 
   // Adds an extension to the scripting whitelist. Used for testing only.
   static void SetScriptingWhitelist(const ScriptingWhitelist& whitelist);
   static const ScriptingWhitelist* GetScriptingWhitelist();
 
   // Parses the host and api permissions from the specified permission |key|
   // from |manifest_|.
   bool ParsePermissions(const char* key,
                         string16* error,
-                        ExtensionAPIPermissionSet* api_permissions,
+                        APIPermissionSet* api_permissions,
                         URLPatternSet* host_permissions);
 
-  bool HasAPIPermission(ExtensionAPIPermission::ID permission) const;
+  bool HasAPIPermission(APIPermission::ID permission) const;
   bool HasAPIPermission(const std::string& function_name) const;
 
   const URLPatternSet& GetEffectiveHostPermissions() const;
 
   // Returns true if the extension can silently increase its permission level.
   // Users must approve permissions for unpacked and packed extensions in the
   // following situations:
   //  - when installing or upgrading packed extensions
   //  - when installing unpacked extensions that have NPAPI plugins
   //  - when either type of extension requests optional permissions
   bool CanSilentlyIncreasePermissions() const;
 
   // Whether the extension has access to the given URL.
   bool HasHostPermission(const GURL& url) const;
 
   // Whether the extension has effective access to all hosts. This is true if
   // there is a content script that matches all hosts, if there is a host
   // permission grants access to all hosts (like <all_urls>) or an api
   // permission that effectively grants access to all hosts (e.g. proxy,
   // network, etc.)
   bool HasEffectiveAccessToAllHosts() const;
 
   // Whether the extension effectively has all permissions (for example, by
   // having an NPAPI plugin).
   bool HasFullPermissions() const;
 
   // Returns the full list of permission messages that this extension
   // should display at install time.
-  ExtensionPermissionMessages GetPermissionMessages() const;
+  PermissionMessages GetPermissionMessages() const;
 
   // Returns the full list of permission messages that this extension
   // should display at install time. The messages are returned as strings
   // for convenience.
   std::vector<string16> GetPermissionMessageStrings() const;
 
   // Sets the active |permissions|.
-  void SetActivePermissions(const ExtensionPermissionSet* permissions) const;
+  void SetActivePermissions(const PermissionSet* permissions) const;
 
   // Gets the extension's active permission set.
-  scoped_refptr<const ExtensionPermissionSet> GetActivePermissions() const;
+  scoped_refptr<const PermissionSet> GetActivePermissions() const;
 
   // Whether context menu should be shown for page and browser actions.
   bool ShowConfigureContextMenus() const;
 
   // Returns the Homepage URL for this extension. If homepage_url was not
   // specified in the manifest, this returns the Google Gallery URL. For
   // third-party extensions, this returns a blank GURL.
   GURL GetHomepageURL() const;
 
   // Returns a list of paths (relative to the extension dir) for images that
@@ skipping 142 matching lines @@
     return background_scripts_;
   }
   bool has_persistent_background_page() const {
     return has_background_page() && background_page_is_persistent_;
   }
   bool has_lazy_background_page() const {
     return has_background_page() && !background_page_is_persistent_;
   }
   const GURL& options_url() const { return options_url_; }
   const GURL& devtools_url() const { return devtools_url_; }
-  const ExtensionPermissionSet* optional_permission_set() const {
+  const PermissionSet* optional_permission_set() const {
     return optional_permission_set_.get();
   }
-  const ExtensionPermissionSet* required_permission_set() const {
+  const PermissionSet* required_permission_set() const {
     return required_permission_set_.get();
   }
   // Appends |new_warnings| to install_warnings().
   void AddInstallWarnings(const InstallWarningVector& new_warnings);
   const InstallWarningVector& install_warnings() const {
     return install_warnings_;
   }
   const GURL& update_url() const { return update_url_; }
   const ExtensionIconSet& icons() const { return icons_; }
   const extensions::Manifest* manifest() const {
@@ skipping 51 matching lines @@
 
   // We keep a cache of images loaded from extension resources based on their
   // path and a string representation of a size that may have been used to
   // scale it (or the empty string if the image is at its original size).
   typedef std::pair<FilePath, std::string> ImageCacheKey;
   typedef std::map<ImageCacheKey, SkBitmap> ImageCache;
 
   class RuntimeData {
    public:
     RuntimeData();
-    explicit RuntimeData(const ExtensionPermissionSet* active);
+    explicit RuntimeData(const PermissionSet* active);
     ~RuntimeData();
 
-    void SetActivePermissions(const ExtensionPermissionSet* active);
-    scoped_refptr<const ExtensionPermissionSet> GetActivePermissions() const;
+    void SetActivePermissions(const PermissionSet* active);
+    scoped_refptr<const PermissionSet> 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_;
+    scoped_refptr<const PermissionSet> 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,
@@ skipping 16 matching lines @@
   // TODO(aa): It is really weird the way this class essentially contains a copy
   // of the underlying DictionaryValue in its members. We should decide to
   // either wrap the DictionaryValue and go with that only, or we should parse
   // into strong types and discard the value. But doing both is bad.
   bool InitFromValue(int flags, string16* error);
 
   // The following are helpers for InitFromValue to load various features of the
   // extension from the manifest.
 
   bool CheckMinimumChromeVersion(string16* error);
-  bool LoadAppIsolation(const ExtensionAPIPermissionSet& api_permissions,
+  bool LoadAppIsolation(const APIPermissionSet& api_permissions,
                         string16* error);
 
   bool LoadRequiredFeatures(string16* error);
   bool LoadName(string16* error);
   bool LoadVersion(string16* error);
 
   bool LoadAppFeatures(string16* error);
   bool LoadExtent(const char* key,
                   URLPatternSet* extent,
                   const char* list_error,
                   const char* value_error,
                   string16* error);
   bool LoadLaunchContainer(string16* error);
   bool LoadLaunchURL(string16* error);
 
-  bool LoadSharedFeatures(const ExtensionAPIPermissionSet& api_permissions,
+  bool LoadSharedFeatures(const APIPermissionSet& api_permissions,
                           string16* error);
   bool LoadDescription(string16* error);
   bool LoadManifestVersion(string16* error);
   bool LoadHomepageURL(string16* error);
   bool LoadUpdateURL(string16* error);
   bool LoadIcons(string16* error);
   bool LoadCommands(string16* error);
   bool LoadPlugins(string16* error);
   bool LoadNaClModules(string16* error);
   bool LoadWebAccessibleResources(string16* error);
   bool LoadSandboxedPages(string16* error);
   bool CheckRequirements(string16* error);
   bool LoadDefaultLocale(string16* error);
   bool LoadOfflineEnabled(string16* error);
   bool LoadOptionsPage(string16* error);
   bool LoadBackgroundScripts(string16* error);
   bool LoadBackgroundScripts(const std::string& key, string16* error);
-  bool LoadBackgroundPage(const ExtensionAPIPermissionSet& api_permissions,
+  bool LoadBackgroundPage(const APIPermissionSet& api_permissions,
                           string16* error);
   bool LoadBackgroundPage(const std::string& key,
-                          const ExtensionAPIPermissionSet& api_permissions,
+                          const APIPermissionSet& api_permissions,
                           string16* error);
   bool LoadBackgroundPersistent(
-      const ExtensionAPIPermissionSet& api_permissions,
+      const APIPermissionSet& api_permissions,
       string16* error);
   bool LoadBackgroundAllowJSAccess(
-      const ExtensionAPIPermissionSet& api_permissions,
+      const APIPermissionSet& api_permissions,
       string16* error);
   // Parses a single action in the manifest.
   bool LoadWebIntentAction(const std::string& action_name,
                            const base::DictionaryValue& intent_service,
                            string16* error);
   bool LoadWebIntentServices(string16* error);
-  bool LoadExtensionFeatures(const ExtensionAPIPermissionSet& api_permissions,
+  bool LoadExtensionFeatures(const APIPermissionSet& api_permissions,
                              string16* error);
   bool LoadDevToolsPage(string16* error);
-  bool LoadInputComponents(const ExtensionAPIPermissionSet& api_permissions,
+  bool LoadInputComponents(const APIPermissionSet& api_permissions,
                            string16* error);
   bool LoadContentScripts(string16* error);
   bool LoadPageAction(string16* error);
   bool LoadBrowserAction(string16* error);
   bool LoadScriptBadge(string16* error);
   bool LoadFileBrowserHandlers(string16* error);
   // Helper method to load a FileBrowserHandlerList from the manifest.
   FileBrowserHandlerList* LoadFileBrowserHandlersHelper(
       const base::ListValue* extension_actions, string16* error);
   // Helper method to load an FileBrowserHandler from manifest.
@@ skipping 55 matching lines @@
   // |override_url|.
   void OverrideLaunchUrl(const GURL& override_url);
 
   // Custom checks for the experimental permission that can't be expressed in
   // _permission_features.json.
   bool CanSpecifyExperimentalPermission() const;
 
   // Checks whether the host |pattern| is allowed for this extension, given API
   // permissions |permissions|.
   bool CanSpecifyHostPermission(const URLPattern& pattern,
-      const ExtensionAPIPermissionSet& permissions) const;
+      const APIPermissionSet& permissions) const;
 
   // Check that platform app features are valid. Called after InitFromValue.
   bool CheckPlatformAppFeatures(std::string* utf8_error);
 
   // Check that features don't conflict. Called after InitFromValue.
   bool CheckConflictingFeatures(std::string* utf8_error);
 
   // Cached images for this extension. This should only be touched on the UI
   // thread.
   mutable ImageCache image_cache_;
@@ skipping 30 matching lines @@
   bool offline_enabled_;
 
   // Defines the set of URLs in the extension's web content.
   URLPatternSet extent_;
 
   // The extension runtime data.
   mutable base::Lock runtime_data_lock_;
   mutable RuntimeData runtime_data_;
 
   // The set of permissions the extension can request at runtime.
-  scoped_refptr<const ExtensionPermissionSet> optional_permission_set_;
+  scoped_refptr<const PermissionSet> optional_permission_set_;
 
   // The extension's required / default set of permissions.
-  scoped_refptr<const ExtensionPermissionSet> required_permission_set_;
+  scoped_refptr<const PermissionSet> required_permission_set_;
 
   // Any warnings that occurred when trying to create/parse the extension.
   InstallWarningVector install_warnings_;
 
   // The icons for the extension.
   ExtensionIconSet icons_;
 
   // The base extension url for the extension.
   GURL extension_url_;
 
@@ skipping 207 matching lines @@
   };
 
   Reason reason;
 
   // The extension who's permissions have changed.
   const Extension* extension;
 
   // The permissions that have changed. For Reason::ADDED, this would contain
   // only the permissions that have added, and for Reason::REMOVED, this would
   // only contain the removed permissions.
-  const ExtensionPermissionSet* permissions;
+  const PermissionSet* permissions;
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
-      const ExtensionPermissionSet* permissions,
+      const PermissionSet* permissions,
       Reason reason);
 };
 
 } // namespace extensions
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_