Reland restrict extension features based on the extension type.

chrome/common/extensions/extension.h

 // Copyright (c) 2011 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 <map>
 #include <set>
@@ skipping 12 matching lines @@
 #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/gfx/size.h"
 #include "webkit/glue/web_intent_service_data.h"
 
 class ExtensionAction;
 class ExtensionResource;
 class ExtensionSidebarDefaults;
+class ManifestValue;
 class FileBrowserHandler;
 class SkBitmap;
 class Version;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 // Represents a Chrome extension.
@@ skipping 318 matching lines @@
 
   // Returns the base extension url for a given |extension_id|.
   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|
   // in the manifest |source|.
-  bool ParsePermissions(const base::DictionaryValue* source,
+  bool ParsePermissions(const ManifestValue* source,
                         const char* key,
                         int flags,
                         std::string* error,
                         ExtensionAPIPermissionSet* api_permissions,
                         URLPatternSet* host_permissions);
 
   bool HasAPIPermission(ExtensionAPIPermission::ID permission) const;
   bool HasAPIPermission(const std::string& function_name) const;
 
   const URLPatternSet& GetEffectiveHostPermissions() const;
@@ skipping 136 matching lines @@
   const GURL& options_url() const { return options_url_; }
   const GURL& devtools_url() const { return devtools_url_; }
   const ExtensionPermissionSet* optional_permission_set() const {
     return optional_permission_set_.get();
   }
   const ExtensionPermissionSet* required_permission_set() const {
     return required_permission_set_.get();
   }
   const GURL& update_url() const { return update_url_; }
   const ExtensionIconSet& icons() const { return icons_; }
-  const base::DictionaryValue* manifest_value() const {
+  const ManifestValue* manifest_value() const {
     return manifest_value_.get();
   }
   const std::string default_locale() const { return default_locale_; }
   const URLOverrideMap& GetChromeURLOverrides() const {
     return chrome_url_overrides_;
   }
   const std::string omnibox_keyword() const { return omnibox_keyword_; }
   bool incognito_split_mode() const { return incognito_split_mode_; }
   bool offline_enabled() const { return offline_enabled_; }
   const std::vector<TtsVoice>& tts_voices() const { return tts_voices_; }
@@ skipping 62 matching lines @@
   // sure the drive letter is uppercase.
   static FilePath MaybeNormalizePath(const FilePath& path);
 
   // Returns true if this extension id is from a trusted provider.
   static bool IsTrustedId(const std::string& id);
 
   Extension(const FilePath& path, Location location);
   ~Extension();
 
   // Initialize the extension from a parsed manifest.
-  bool InitFromValue(const base::DictionaryValue& value, int flags,
+  bool InitFromValue(const ManifestValue& value, int flags,
                      std::string* error);
 
   // Helper function for implementing HasCachedImage/GetCachedImage. A return
   // value of NULL means there is no matching image cached (we allow caching an
   // empty SkBitmap).
   SkBitmap* GetCachedImageImpl(const ExtensionResource& source,
                                const gfx::Size& max_size) const;
 
   // Helper method that loads a UserScript object from a
   // dictionary in the content_script list of the manifest.
   bool LoadUserScriptHelper(const base::DictionaryValue* content_script,
                             int definition_index,
                             int flags,
                             std::string* error,
                             UserScript* result);
 
   // Helper method that loads either the include_globs or exclude_globs list
   // from an entry in the content_script lists of the manifest.
   bool LoadGlobsHelper(const base::DictionaryValue* content_script,
                        int content_script_index,
                        const char* globs_property_name,
                        std::string* error,
                        void(UserScript::*add_method)(const std::string& glob),
                        UserScript *instance);
 
   // Helpers to load various chunks of the manifest.
-  bool LoadIsApp(const base::DictionaryValue* manifest, std::string* error);
-  bool LoadExtent(const base::DictionaryValue* manifest,
+  bool LoadIsApp(const ManifestValue* manifest, std::string* error);
+  bool LoadExtent(const ManifestValue* manifest,
                   const char* key,
                   URLPatternSet* extent,
                   const char* list_error,
                   const char* value_error,
                   URLPattern::ParseOption parse_strictness,
                   std::string* error);
-  bool LoadLaunchContainer(const base::DictionaryValue* manifest,
+  bool LoadLaunchContainer(const ManifestValue* manifest,
                            std::string* error);
-  bool LoadLaunchURL(const base::DictionaryValue* manifest,
+  bool LoadLaunchURL(const ManifestValue* manifest,
                      std::string* error);
-  bool LoadAppIsolation(const base::DictionaryValue* manifest,
+  bool LoadAppIsolation(const ManifestValue* manifest,
                         std::string* error);
-  bool LoadWebIntentServices(const base::DictionaryValue& manifest,
+  bool LoadWebIntentServices(const ManifestValue& manifest,
                              std::string* error);
-  bool EnsureNotHybridApp(const base::DictionaryValue* manifest,
-                          std::string* error);
 
   // Helper method to load an ExtensionAction from the page_action or
   // browser_action entries in the manifest.
   ExtensionAction* LoadExtensionActionHelper(
       const base::DictionaryValue* extension_action, std::string* error);
 
   // Helper method to load an FileBrowserHandlerList from the manifest.
   FileBrowserHandlerList* LoadFileBrowserHandlers(
       const base::ListValue* extension_actions, std::string* error);
   // Helper method to load an FileBrowserHandler from manifest.
   FileBrowserHandler* LoadFileBrowserHandler(
       const base::DictionaryValue* file_browser_handlers, std::string* error);
 
   // Helper method to load an ExtensionSidebarDefaults from the sidebar manifest
   // entry.
   ExtensionSidebarDefaults* LoadExtensionSidebarDefaults(
       const base::DictionaryValue* sidebar, std::string* error);
 
   // Returns true if the extension has more than one "UI surface". For example,
   // an extension that has a browser action and a page action.
   bool HasMultipleUISurfaces() const;
 
-  // Figures out if a source contains keys not associated with themes - we
-  // don't want to allow scripts and such to be bundled with themes.
-  bool ContainsNonThemeKeys(const base::DictionaryValue& source) const;
-
   // Updates the launch URL and extents for the extension using the given
   // |override_url|.
   void OverrideLaunchUrl(const GURL& override_url);
 
   // Returns true if this extension can specify |api|.
   bool CanSpecifyAPIPermission(const ExtensionAPIPermission* api,
                                std::string* error) const;
   bool CanSpecifyComponentOnlyPermission() const;
   bool CanSpecifyExperimentalPermission() const;
   bool CanSpecifyPermissionForHostedApp(
@@ skipping 126 matching lines @@
   bool is_theme_;
 
   // The homepage for this extension. Useful if it is not hosted by Google and
   // therefore does not have a Gallery URL.
   GURL homepage_url_;
 
   // URL for fetching an update manifest
   GURL update_url_;
 
   // A copy of the manifest that this extension was created from.
-  scoped_ptr<base::DictionaryValue> manifest_value_;
+  scoped_ptr<ManifestValue> manifest_value_;
 
   // A map of chrome:// hostnames (newtab, downloads, etc.) to Extension URLs
   // which override the handling of those URLs. (see ExtensionOverrideUI).
   URLOverrideMap chrome_url_overrides_;
 
   // Whether this extension uses app features.
   bool is_app_;
 
   // Whether this app uses platform features.
   bool is_platform_app_;
@@ skipping 101 matching lines @@
   // only contain the removed permissions.
   const ExtensionPermissionSet* permissions;
 
   UpdatedExtensionPermissionsInfo(
       const Extension* extension,
       const ExtensionPermissionSet* permissions,
       Reason reason);
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_