Add FilePath to base namespace.

webkit/plugins/npapi/plugin_list.cc

 // 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.
 
 #include "webkit/plugins/npapi/plugin_list.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 68 matching lines @@
 bool PluginList::DebugPluginLoading() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDebugPluginLoading);
 }
 
 void PluginList::RefreshPlugins() {
   base::AutoLock lock(lock_);
   loading_state_ = LOADING_STATE_NEEDS_REFRESH;
 }
 
-void PluginList::AddExtraPluginPath(const FilePath& plugin_path) {
+void PluginList::AddExtraPluginPath(const base::FilePath& plugin_path) {
   if (!NPAPIPluginsSupported()) {
     // TODO(jam): remove and just have CHECK once we're sure this doesn't get
     // triggered.
     DLOG(INFO) << "NPAPI plugins not supported";
     return;
   }
 
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   base::AutoLock lock(lock_);
   extra_plugin_paths_.push_back(plugin_path);
 #endif
 }
 
-void PluginList::RemoveExtraPluginPath(const FilePath& plugin_path) {
+void PluginList::RemoveExtraPluginPath(const base::FilePath& plugin_path) {
   base::AutoLock lock(lock_);
-  std::vector<FilePath>::iterator it =
+  std::vector<base::FilePath>::iterator it =
       std::find(extra_plugin_paths_.begin(), extra_plugin_paths_.end(),
                 plugin_path);
   if (it != extra_plugin_paths_.end())
     extra_plugin_paths_.erase(it);
 }
 
-void PluginList::AddExtraPluginDir(const FilePath& plugin_dir) {
+void PluginList::AddExtraPluginDir(const base::FilePath& plugin_dir) {
   // Chrome OS only loads plugins from /opt/google/chrome/plugins.
 #if !defined(OS_CHROMEOS)
   base::AutoLock lock(lock_);
   extra_plugin_dirs_.push_back(plugin_dir);
 #endif
 }
 
 void PluginList::RegisterInternalPlugin(const webkit::WebPluginInfo& info,
                                         bool add_at_beginning) {
   PluginEntryPoints entry_points = {0};
@@ skipping 17 matching lines @@
   internal_plugins_.push_back(plugin);
   if (add_at_beginning) {
     // Newer registrations go earlier in the list so they can override the MIME
     // types of older registrations.
     extra_plugin_paths_.insert(extra_plugin_paths_.begin(), info.path);
   } else {
     extra_plugin_paths_.push_back(info.path);
   }
 }
 
-void PluginList::UnregisterInternalPlugin(const FilePath& path) {
+void PluginList::UnregisterInternalPlugin(const base::FilePath& path) {
   base::AutoLock lock(lock_);
   for (size_t i = 0; i < internal_plugins_.size(); i++) {
     if (internal_plugins_[i].info.path == path) {
       internal_plugins_.erase(internal_plugins_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
 void PluginList::GetInternalPlugins(
     std::vector<webkit::WebPluginInfo>* internal_plugins) {
   base::AutoLock lock(lock_);
 
   for (std::vector<InternalPlugin>::iterator it = internal_plugins_.begin();
        it != internal_plugins_.end();
        ++it) {
     internal_plugins->push_back(it->info);
   }
 }
 
-bool PluginList::ReadPluginInfo(const FilePath& filename,
+bool PluginList::ReadPluginInfo(const base::FilePath& filename,
                                 webkit::WebPluginInfo* info,
                                 const PluginEntryPoints** entry_points) {
   {
     base::AutoLock lock(lock_);
     for (size_t i = 0; i < internal_plugins_.size(); ++i) {
       if (filename == internal_plugins_[i].info.path) {
         *entry_points = &internal_plugins_[i].entry_points;
         *info = internal_plugins_[i].info;
         return true;
       }
@@ skipping 61 matching lines @@
 void PluginList::LoadPluginsIntoPluginListInternal(
     std::vector<webkit::WebPluginInfo>* plugins) {
   base::Closure will_load_callback;
   {
     base::AutoLock lock(lock_);
     will_load_callback = will_load_plugins_callback_;
   }
   if (!will_load_callback.is_null())
     will_load_callback.Run();
 
-  std::vector<FilePath> plugin_paths;
+  std::vector<base::FilePath> plugin_paths;
   GetPluginPathsToLoad(&plugin_paths);
 
-  for (std::vector<FilePath>::const_iterator it = plugin_paths.begin();
+  for (std::vector<base::FilePath>::const_iterator it = plugin_paths.begin();
        it != plugin_paths.end();
        ++it) {
     WebPluginInfo plugin_info;
     LoadPluginIntoPluginList(*it, plugins, &plugin_info);
   }
 }
 
 void PluginList::LoadPlugins() {
   {
     base::AutoLock lock(lock_);
@@ skipping 10 matching lines @@
   base::AutoLock lock(lock_);
   plugins_list_.swap(new_plugins);
 
   // If we haven't been invalidated in the mean time, mark the plug-in list as
   // up-to-date.
   if (loading_state_ != LOADING_STATE_NEEDS_REFRESH)
     loading_state_ = LOADING_STATE_UP_TO_DATE;
 }
 
 bool PluginList::LoadPluginIntoPluginList(
-    const FilePath& path,
+    const base::FilePath& path,
     std::vector<webkit::WebPluginInfo>* plugins,
     WebPluginInfo* plugin_info) {
   LOG_IF(ERROR, PluginList::DebugPluginLoading())
       << "Loading plugin " << path.value();
   const PluginEntryPoints* entry_points;
 
   if (!ReadPluginInfo(path, plugin_info, &entry_points))
     return false;
 
   if (!ShouldLoadPluginUsingPluginList(*plugin_info, plugins))
     return false;
 
 #if defined(OS_WIN) && !defined(NDEBUG)
   if (path.BaseName().value() != L"npspy.dll")  // Make an exception for NPSPY
 #endif
   {
     for (size_t i = 0; i < plugin_info->mime_types.size(); ++i) {
       // TODO: don't load global handlers for now.
       // WebKit hands to the Plugin before it tries
       // to handle mimeTypes on its own.
       const std::string &mime_type = plugin_info->mime_types[i].mime_type;
       if (mime_type == "*")
         return false;
     }
   }
   plugins->push_back(*plugin_info);
   return true;
 }
 
-void PluginList::GetPluginPathsToLoad(std::vector<FilePath>* plugin_paths) {
+void PluginList::GetPluginPathsToLoad(std::vector<base::FilePath>* plugin_paths) {
   // Don't want to hold the lock while loading new plugins, so we don't block
   // other methods if they're called on other threads.
-  std::vector<FilePath> extra_plugin_paths;
-  std::vector<FilePath> extra_plugin_dirs;
+  std::vector<base::FilePath> extra_plugin_paths;
+  std::vector<base::FilePath> extra_plugin_dirs;
   {
     base::AutoLock lock(lock_);
     extra_plugin_paths = extra_plugin_paths_;
     extra_plugin_dirs = extra_plugin_dirs_;
   }
 
   for (size_t i = 0; i < extra_plugin_paths.size(); ++i) {
-    const FilePath& path = extra_plugin_paths[i];
+    const base::FilePath& path = extra_plugin_paths[i];
     if (std::find(plugin_paths->begin(), plugin_paths->end(), path) !=
         plugin_paths->end()) {
       continue;
     }
     plugin_paths->push_back(path);
   }
 
   if (NPAPIPluginsSupported()) {
     // A bit confusingly, this function is used to load Pepper plugins as well.
     // Those are all internal plugins so we have to use extra_plugin_paths.
     for (size_t i = 0; i < extra_plugin_dirs.size(); ++i)
       GetPluginsInDir(extra_plugin_dirs[i], plugin_paths);
 
-    std::vector<FilePath> directories_to_scan;
+    std::vector<base::FilePath> directories_to_scan;
     GetPluginDirectories(&directories_to_scan);
     for (size_t i = 0; i < directories_to_scan.size(); ++i)
       GetPluginsInDir(directories_to_scan[i], plugin_paths);
 
 #if defined(OS_WIN)
   GetPluginPathsFromRegistry(plugin_paths);
 #endif
   }
 }
 
@@ skipping 38 matching lines @@
 
   if (!use_stale)
     LoadPlugins();
   base::AutoLock lock(lock_);
   if (use_stale)
     *use_stale = (loading_state_ != LOADING_STATE_UP_TO_DATE);
   info->clear();
   if (actual_mime_types)
     actual_mime_types->clear();
 
-  std::set<FilePath> visited_plugins;
+  std::set<base::FilePath> visited_plugins;
 
   // Add in plugins by mime type.
   for (size_t i = 0; i < plugins_list_.size(); ++i) {
     if (SupportsType(plugins_list_[i], mime_type, allow_wildcard)) {
-      FilePath path = plugins_list_[i].path;
+      base::FilePath path = plugins_list_[i].path;
       if (visited_plugins.insert(path).second) {
         info->push_back(plugins_list_[i]);
         if (actual_mime_types)
           actual_mime_types->push_back(mime_type);
       }
     }
   }
 
   // Add in plugins by url.
   std::string path = url.path();
   std::string::size_type last_dot = path.rfind('.');
   if (last_dot != std::string::npos) {
     std::string extension = StringToLowerASCII(std::string(path, last_dot+1));
     std::string actual_mime_type;
     for (size_t i = 0; i < plugins_list_.size(); ++i) {
       if (SupportsExtension(plugins_list_[i], extension, &actual_mime_type)) {
-        FilePath path = plugins_list_[i].path;
+        base::FilePath path = plugins_list_[i].path;
         if (visited_plugins.insert(path).second &&
             AllowMimeTypeMismatch(mime_type, actual_mime_type)) {
           info->push_back(plugins_list_[i]);
           if (actual_mime_types)
             actual_mime_types->push_back(actual_mime_type);
         }
       }
     }
   }
 }
@@ skipping 31 matching lines @@
   }
   return false;
 }
 
 PluginList::~PluginList() {
 }
 
 
 }  // namespace npapi
 }  // namespace webkit