Add FilePath to base namespace.

webkit/plugins/npapi/plugin_list.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 WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_
 #define WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_
 
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 53 matching lines @@
   static bool SupportsType(const webkit::WebPluginInfo& plugin,
                            const std::string& mime_type,
                            bool allow_wildcard);
 
   // Cause the plugin list to refresh next time they are accessed, regardless
   // of whether they are already loaded.
   void RefreshPlugins();
 
   // Add/Remove an extra plugin to load when we actually do the loading.  Must
   // be called before the plugins have been loaded.
-  void AddExtraPluginPath(const FilePath& plugin_path);
-  void RemoveExtraPluginPath(const FilePath& plugin_path);
+  void AddExtraPluginPath(const base::FilePath& plugin_path);
+  void RemoveExtraPluginPath(const base::FilePath& plugin_path);
 
   // Same as above, but specifies a directory in which to search for plugins.
-  void AddExtraPluginDir(const FilePath& plugin_dir);
+  void AddExtraPluginDir(const base::FilePath& plugin_dir);
 
   // Get the ordered list of directories from which to load plugins
-  void GetPluginDirectories(std::vector<FilePath>* plugin_dirs);
+  void GetPluginDirectories(std::vector<base::FilePath>* plugin_dirs);
 
   // Register an internal plugin with the specified plugin information.
   // An internal plugin must be registered before it can
   // be loaded using PluginList::LoadPlugin().
   // If |add_at_beginning| is true the plugin will be added earlier in
   // the list so that it can override the MIME types of older registrations.
   void RegisterInternalPlugin(const webkit::WebPluginInfo& info,
                               bool add_at_beginning);
 
   // This second version is for "plugins" that have been compiled directly into
   // the binary -- callers must provide the plugin information and the entry
   // points.
   void RegisterInternalPluginWithEntryPoints(
       const webkit::WebPluginInfo& info,
       bool add_at_beginning,
       const PluginEntryPoints& entry_points);
 
   // Removes a specified internal plugin from the list. The search will match
   // on the path from the version info previously registered.
   //
   // This is generally only necessary for tests.
-  void UnregisterInternalPlugin(const FilePath& path);
+  void UnregisterInternalPlugin(const base::FilePath& path);
 
   // Gets a list of all the registered internal plugins.
   void GetInternalPlugins(std::vector<webkit::WebPluginInfo>* plugins);
 
   // Creates a WebPluginInfo structure given a plugin's path.  On success
   // returns true, with the information being put into "info".  If it's an
   // internal plugin, "entry_points" is filled in as well with a
   // internally-owned PluginEntryPoints pointer.
   // Returns false if the library couldn't be found, or if it's not a plugin.
-  bool ReadPluginInfo(const FilePath& filename,
+  bool ReadPluginInfo(const base::FilePath& filename,
                       webkit::WebPluginInfo* info,
                       const PluginEntryPoints** entry_points);
 
   // In Windows plugins, the mime types are passed as a specially formatted list
   // of strings. This function parses those strings into a WebPluginMimeType
   // vector.
   // TODO(evan): move this code into plugin_list_win.
   static bool ParseMimeTypes(
       const std::string& mime_types,
       const std::string& file_extensions,
@@ skipping 22 matching lines @@
   // will be true iff the plug-in list was stale.
   void GetPluginInfoArray(const GURL& url,
                           const std::string& mime_type,
                           bool allow_wildcard,
                           bool* use_stale,
                           std::vector<webkit::WebPluginInfo>* info,
                           std::vector<std::string>* actual_mime_types);
 
   // Load a specific plugin with full path. Return true iff loading the plug-in
   // was successful.
-  bool LoadPluginIntoPluginList(const FilePath& filename,
+  bool LoadPluginIntoPluginList(const base::FilePath& filename,
                                 std::vector<webkit::WebPluginInfo>* plugins,
                                 webkit::WebPluginInfo* plugin_info);
 
   // The following functions are used to support probing for WebPluginInfo
   // using a different instance of this class.
 
   // Computes a list of all plugins to potentially load from all sources.
-  void GetPluginPathsToLoad(std::vector<FilePath>* plugin_paths);
+  void GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths);
 
   // Clears the internal list of Plugins and copies them from the vector.
   void SetPlugins(const std::vector<webkit::WebPluginInfo>& plugins);
 
   void set_will_load_plugins_callback(const base::Closure& callback);
 
   virtual ~PluginList();
 
  protected:
   // Constructors are private for singletons but we expose this one
@@ skipping 18 matching lines @@
   // Implements all IO dependent operations of the LoadPlugins method so that
   // test classes can mock these out.
   virtual void LoadPluginsIntoPluginListInternal(
       std::vector<webkit::WebPluginInfo>* plugins);
 
   // Load all plugins from the default plugins directory.
   void LoadPlugins();
 
   // Walks a directory and produces a list of all the plugins to potentially
   // load in that directory.
-  void GetPluginsInDir(const FilePath& path, std::vector<FilePath>* plugins);
+  void GetPluginsInDir(const base::FilePath& path,
+                       std::vector<base::FilePath>* plugins);
 
   // Returns true if we should load the given plugin, or false otherwise.
   // |plugins| is the list of plugins we have crawled in the current plugin
   // loading run.
   bool ShouldLoadPluginUsingPluginList(
       const webkit::WebPluginInfo& info,
       std::vector<webkit::WebPluginInfo>* plugins);
 
   // Returns true if the given plugin supports a given file extension.
   // |extension| should be all lower case. If |mime_type| is not NULL, it will
@@ skipping 13 matching lines @@
   //
   // Command-line switches
   //
 
 #if defined(OS_WIN)
   // true if we shouldn't load the new WMP plugin.
   bool dont_load_new_wmp_;
 
   // Gets plugin paths registered under HKCU\Software\MozillaPlugins and
   // HKLM\Software\MozillaPlugins.
-  void GetPluginPathsFromRegistry(std::vector<FilePath>* plugins);
+  void GetPluginPathsFromRegistry(std::vector<base::FilePath>* plugins);
 #endif
 
   //
   // Internals
   //
 
   // States whether we will load the plug-in list the next time we try to access
   // it, whether we are currently in the process of loading it, or whether we
   // consider it up-to-date.
   LoadingState loading_state_;
 
   // Extra plugin paths that we want to search when loading.
-  std::vector<FilePath> extra_plugin_paths_;
+  std::vector<base::FilePath> extra_plugin_paths_;
 
   // Extra plugin directories that we want to search when loading.
-  std::vector<FilePath> extra_plugin_dirs_;
+  std::vector<base::FilePath> extra_plugin_dirs_;
 
   // Holds information about internal plugins.
   std::vector<InternalPlugin> internal_plugins_;
 
   // A list holding all plug-ins.
   std::vector<webkit::WebPluginInfo> plugins_list_;
 
   // Callback that is invoked whenever the PluginList will reload the plugins.
   base::Closure will_load_plugins_callback_;
 
   // Need synchronization for the above members since this object can be
   // accessed on multiple threads.
   base::Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(PluginList);
 };
 
 }  // namespace npapi
 }  // namespace webkit
 
 #endif  // WEBKIT_PLUGINS_NPAPI_PLUGIN_LIST_H_