Add a non-const APIPermissionSet to Extension to be manipulated during initialization.

chrome/common/extensions/extension.h

 // Copyright (c) 2013 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_
 
 #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 "base/threading/thread_checker.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/permissions/api_permission.h"
-#include "chrome/common/extensions/permissions/api_permission_set.h"
 #include "chrome/common/extensions/permissions/permission_message.h"
 #include "chrome/common/extensions/user_script.h"
 #include "extensions/common/install_warning.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/gurl.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/gfx/size.h"
 
 class ExtensionAction;
 class ExtensionResource;
 class SkBitmap;
 class Version;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace gfx {
 class ImageSkia;
 }
 
 FORWARD_DECLARE_TEST(TabStripModelTest, Apps);
 
 namespace extensions {
 struct ActionInfo;
+class APIPermissionSet;
 class PermissionSet;
 
 // Represents a Chrome extension.
 class Extension : public base::RefCountedThreadSafe<Extension> {
  public:
   struct ManifestData;
 
   typedef std::vector<std::string> ScriptingWhitelist;
   typedef std::map<const std::string, linked_ptr<ManifestData> >
       ManifestDataMap;
@@ skipping 456 matching lines @@
   }
   bool has_lazy_background_page() const {
     return has_background_page() && !background_page_is_persistent_;
   }
   const PermissionSet* optional_permission_set() const {
     return optional_permission_set_.get();
   }
   const PermissionSet* required_permission_set() const {
     return required_permission_set_.get();
   }
+  // Returns the temporary APIPermissionSet used in initialization.
+  // (NULL after initialization is completed.)
+  APIPermissionSet* initial_api_permissions() {
+    return initial_api_permissions_.get();
+  }
   // Appends |new_warning[s]| to install_warnings_.
   void AddInstallWarning(const InstallWarning& new_warning);
   void AddInstallWarnings(const std::vector<InstallWarning>& new_warnings);
   const std::vector<InstallWarning>& install_warnings() const {
     return install_warnings_;
   }
   const ExtensionIconSet& icons() const { return icons_; }
   const extensions::Manifest* manifest() const {
     return manifest_.get();
   }
@@ skipping 93 matching lines @@
   // TODO(aa): Rename to just Init()? There's no Value here anymore.
   // 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 LoadAppIsolation(const APIPermissionSet& api_permissions,
-                        string16* error);
+  bool LoadAppIsolation(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 APIPermissionSet& api_permissions,
-                          string16* error);
+  bool LoadSharedFeatures(string16* error);
   bool LoadDescription(string16* error);
   bool LoadManifestVersion(string16* error);
   bool LoadIcons(string16* error);
   bool LoadPlugins(string16* error);
   bool LoadNaClModules(string16* error);
   bool LoadSandboxedPages(string16* error);
   // Must be called after LoadPlugins().
   bool LoadRequirements(string16* error);
   bool LoadOfflineEnabled(string16* error);
   bool LoadBackgroundScripts(string16* error);
   bool LoadBackgroundScripts(const std::string& key, string16* error);
-  bool LoadBackgroundPage(const APIPermissionSet& api_permissions,
+  bool LoadBackgroundPage(string16* error);
+  bool LoadBackgroundPage(const std::string& key,
                           string16* error);
-  bool LoadBackgroundPage(const std::string& key,
-                          const APIPermissionSet& api_permissions,
-                          string16* error);
-  bool LoadBackgroundPersistent(
-      const APIPermissionSet& api_permissions,
-      string16* error);
-  bool LoadBackgroundAllowJSAccess(
-      const APIPermissionSet& api_permissions,
-      string16* error);
-  bool LoadExtensionFeatures(APIPermissionSet* api_permissions,
-                             string16* error);
+  bool LoadBackgroundPersistent(string16* error);
+  bool LoadBackgroundAllowJSAccess(string16* error);
+  bool LoadExtensionFeatures(string16* error);
   bool LoadContentScripts(string16* error);
   bool LoadBrowserAction(string16* error);
-  bool LoadSystemIndicator(APIPermissionSet* api_permissions, string16* error);
+  bool LoadSystemIndicator(string16* error);
   bool LoadTextToSpeechVoices(string16* error);
   bool LoadIncognitoMode(string16* error);
   bool LoadContentSecurityPolicy(string16* error);
   bool LoadManagedModeFeatures(string16* error);
   bool LoadManagedModeSites(
       const base::DictionaryValue* content_pack_value,
       string16* error);
   bool LoadManagedModeConfigurations(
       const base::DictionaryValue* content_pack_value,
       string16* error);
@@ skipping 22 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 APIPermissionSet& permissions) const;
+                                const APIPermissionSet& permissions) const;
 
   bool CheckMinimumChromeVersion(string16* error) const;
 
   // Check that platform app features are valid. Called after InitFromValue.
   bool CheckPlatformAppFeatures(std::string* utf8_error) const;
 
   // Check that features don't conflict. Called after InitFromValue.
   bool CheckConflictingFeatures(std::string* utf8_error) const;
 
   // The extension's human-readable name. Name is used for display purpose. It
@@ skipping 27 matching lines @@
   // Whether the extension or app should be enabled when offline.
   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 API permission set; used during extension initialization.
+  // Cleared after permissions are finalized by SetActivePermissions.
+  scoped_ptr<APIPermissionSet> initial_api_permissions_;
+
   // The set of permissions the extension can request at runtime.
   scoped_refptr<const PermissionSet> optional_permission_set_;
 
   // The extension's required / default set of permissions.
   scoped_refptr<const PermissionSet> required_permission_set_;
 
   // Any warnings that occurred when trying to create/parse the extension.
   std::vector<InstallWarning> install_warnings_;
 
   // The icons for the extension.
@@ skipping 171 matching lines @@
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
       const PermissionSet* permissions,
       Reason reason);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_