Move base/values.h into the base namespace.

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>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.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/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"
 
-class DictionaryValue;
 class ExtensionAction;
 class ExtensionResource;
 class ExtensionSidebarDefaults;
 class FileBrowserHandler;
-class ListValue;
 class SkBitmap;
 class Version;
 
+namespace base {
+class DictionaryValue;
+class ListValue;
+}
+
 // Represents a Chrome extension.
 class Extension : public base::RefCountedThreadSafe<Extension> {
  public:
   typedef std::map<const std::string, GURL> URLOverrideMap;
   typedef std::vector<std::string> ScriptingWhitelist;
   typedef std::vector<linked_ptr<FileBrowserHandler> > FileBrowserHandlerList;
 
   // What an extension was loaded from.
   // NOTE: These values are stored as integers in the preferences and used
   // in histograms so don't remove or reorder existing items.  Just append
@@ skipping 122 matching lines @@
     STRICT_ERROR_CHECKS = 1 << 1,
 
     // |ALLOW_FILE_ACCESS| indicates that the user is allowing this extension
     // to have file access. If it's not present, then permissions and content
     // scripts that match file:/// URLs will be filtered out.
     ALLOW_FILE_ACCESS = 1 << 2,
   };
 
   static scoped_refptr<Extension> Create(const FilePath& path,
                                          Location location,
-                                         const DictionaryValue& value,
+                                         const base::DictionaryValue& value,
                                          int flags,
                                          std::string* error);
 
   // In a few special circumstances, we want to create an Extension and give it
   // an explicit id. Most consumers should just use the plain Create() method.
-  static scoped_refptr<Extension> CreateWithId(const FilePath& path,
-                                               Location location,
-                                               const DictionaryValue& value,
-                                               int flags,
-                                               const std::string& explicit_id,
-                                               std::string* error);
+  static scoped_refptr<Extension> CreateWithId(
+      const FilePath& path,
+      Location location,
+      const base::DictionaryValue& value,
+      int flags,
+      const std::string& explicit_id,
+      std::string* error);
 
   // Return the update url used by gallery/webstore extensions.
   static GURL GalleryUpdateUrl(bool secure);
 
   // Given two install sources, return the one which should take priority
   // over the other. If an extension is installed from two sources A and B,
   // its install source should be set to GetHigherPriorityLocation(A, B).
   static Location GetHigherPriorityLocation(Location loc1, Location loc2);
 
   // Returns the full list of permission messages that this extension
@@ skipping 279 matching lines @@
   }
   const GURL& background_url() const { return background_url_; }
   const GURL& options_url() const { return options_url_; }
   const GURL& devtools_url() const { return devtools_url_; }
   const std::vector<GURL>& toolstrips() const { return toolstrips_; }
   const ExtensionPermissionSet* permission_set() const {
     return permission_set_.get();
   }
   const GURL& update_url() const { return update_url_; }
   const ExtensionIconSet& icons() const { return icons_; }
-  const DictionaryValue* manifest_value() const {
+  const base::DictionaryValue* 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_; }
   const std::vector<TtsVoice>& tts_voices() const { return tts_voices_; }
 
@@ skipping 12 matching lines @@
   const std::string& launch_local_path() const { return launch_local_path_; }
   const std::string& launch_web_url() const { return launch_web_url_; }
   extension_misc::LaunchContainer launch_container() const {
     return launch_container_;
   }
   int launch_width() const { return launch_width_; }
   int launch_height() const { return launch_height_; }
 
   // Theme-related.
   bool is_theme() const { return is_theme_; }
-  DictionaryValue* GetThemeImages() const { return theme_images_.get(); }
-  DictionaryValue* GetThemeColors() const {return theme_colors_.get(); }
-  DictionaryValue* GetThemeTints() const { return theme_tints_.get(); }
-  DictionaryValue* GetThemeDisplayProperties() const {
+  base::DictionaryValue* GetThemeImages() const { return theme_images_.get(); }
+  base::DictionaryValue* GetThemeColors() const {return theme_colors_.get(); }
+  base::DictionaryValue* GetThemeTints() const { return theme_tints_.get(); }
+  base::DictionaryValue* GetThemeDisplayProperties() const {
     return theme_display_properties_.get();
   }
 
  private:
   friend class base::RefCountedThreadSafe<Extension>;
 
   // 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;
@@ skipping 19 matching lines @@
   static std::vector<std::string> GetDistinctHosts(
       const URLPatternList& host_patterns, bool include_rcd);
 
   // 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 DictionaryValue& value, int flags,
+  bool InitFromValue(const base::DictionaryValue& 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 DictionaryValue* content_script,
+  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 DictionaryValue* content_script,
+  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 DictionaryValue* manifest, std::string* error);
-  bool LoadExtent(const DictionaryValue* manifest,
+  bool LoadIsApp(const base::DictionaryValue* manifest, std::string* error);
+  bool LoadExtent(const base::DictionaryValue* manifest,
                   const char* key,
                   URLPatternSet* extent,
                   const char* list_error,
                   const char* value_error,
                   URLPattern::ParseOption parse_strictness,
                   std::string* error);
-  bool LoadLaunchContainer(const DictionaryValue* manifest, std::string* error);
-  bool LoadLaunchURL(const DictionaryValue* manifest, std::string* error);
-  bool LoadAppIsolation(const DictionaryValue* manifest, std::string* error);
-  bool EnsureNotHybridApp(const DictionaryValue* manifest, std::string* error);
+  bool LoadLaunchContainer(const base::DictionaryValue* manifest,
+                           std::string* error);
+  bool LoadLaunchURL(const base::DictionaryValue* manifest,
+                     std::string* error);
+  bool LoadAppIsolation(const base::DictionaryValue* 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 DictionaryValue* extension_action, std::string* error);
+      const base::DictionaryValue* extension_action, std::string* error);
 
   // Helper method to load an FileBrowserHandlerList from the manifest.
   FileBrowserHandlerList* LoadFileBrowserHandlers(
-      const ListValue* extension_actions, std::string* error);
+      const base::ListValue* extension_actions, std::string* error);
   // Helper method to load an FileBrowserHandler from manifest.
   FileBrowserHandler* LoadFileBrowserHandler(
-      const DictionaryValue* file_browser_handlers, std::string* error);
+      const base::DictionaryValue* file_browser_handlers, std::string* error);
 
   // Helper method to load an ExtensionSidebarDefaults from the sidebar manifest
   // entry.
   ExtensionSidebarDefaults* LoadExtensionSidebarDefaults(
-      const DictionaryValue* sidebar, std::string* error);
+      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 DictionaryValue& source) const;
+  bool ContainsNonThemeKeys(const base::DictionaryValue& source) const;
 
   // Only allow the experimental API permission if the command line
   // flag is present.
   bool IsDisallowedExperimentalPermission(
       ExtensionAPIPermission::ID permission) const;
 
   // Returns true if this is a component, or we are not attempting to access a
   // component-private permission.
   bool IsComponentOnlyPermission(const ExtensionAPIPermission* api) const;
 
@@ skipping 82 matching lines @@
   // Optional URL to a devtools extension page.
   GURL devtools_url_;
 
   // Optional list of toolstrips and associated properties.
   std::vector<GURL> toolstrips_;
 
   // The public key used to sign the contents of the crx package.
   std::string public_key_;
 
   // A map of resource id's to relative file paths.
-  scoped_ptr<DictionaryValue> theme_images_;
+  scoped_ptr<base::DictionaryValue> theme_images_;
 
   // A map of color names to colors.
-  scoped_ptr<DictionaryValue> theme_colors_;
+  scoped_ptr<base::DictionaryValue> theme_colors_;
 
   // A map of color names to colors.
-  scoped_ptr<DictionaryValue> theme_tints_;
+  scoped_ptr<base::DictionaryValue> theme_tints_;
 
   // A map of display properties.
-  scoped_ptr<DictionaryValue> theme_display_properties_;
+  scoped_ptr<base::DictionaryValue> theme_display_properties_;
 
   // Whether the extension is a theme.
   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<DictionaryValue> manifest_value_;
+  scoped_ptr<base::DictionaryValue> 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 extension requests isolated storage.
   bool is_storage_isolated_;
@@ skipping 39 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(TabStripModelTest, Apps);
 
   DISALLOW_COPY_AND_ASSIGN(Extension);
 };
 
 typedef std::vector< scoped_refptr<const Extension> > ExtensionList;
 typedef std::set<std::string> ExtensionIdSet;
 
 // Handy struct to pass core extension info around.
 struct ExtensionInfo {
-  ExtensionInfo(const DictionaryValue* manifest,
+  ExtensionInfo(const base::DictionaryValue* manifest,
                 const std::string& id,
                 const FilePath& path,
                 Extension::Location location);
   ~ExtensionInfo();
 
-  scoped_ptr<DictionaryValue> extension_manifest;
+  scoped_ptr<base::DictionaryValue> extension_manifest;
   std::string extension_id;
   FilePath extension_path;
   Extension::Location extension_location;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionInfo);
 };
 
 // Struct used for the details of the EXTENSION_UNINSTALLED
 // notification.
@@ skipping 23 matching lines @@
   // Was the extension already disabled?
   bool already_disabled;
 
   // The extension being unloaded - this should always be non-NULL.
   const Extension* extension;
 
   UnloadedExtensionInfo(const Extension* extension, Reason reason);
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_EXTENSION_H_