Add FilePath to base namespace.

webkit/fileapi/isolated_context.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/fileapi/isolated_context.h"
 
 #include "base/file_path.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "webkit/fileapi/file_system_url.h"
 
 namespace fileapi {
 
 namespace {
 
-FilePath::StringType GetRegisterNameForPath(const FilePath& path) {
+base::FilePath::StringType GetRegisterNameForPath(const base::FilePath& path) {
   // If it's not a root path simply return a base name.
   if (path.DirName() != path)
     return path.BaseName().value();
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
-  FilePath::StringType name;
+  base::FilePath::StringType name;
   for (size_t i = 0;
-        i < path.value().size() && !FilePath::IsSeparator(path.value()[i]);
+        i < path.value().size() && !base::FilePath::IsSeparator(path.value()[i]);
         ++i) {
     if (path.value()[i] == L':') {
       name.append(L"_drive");
       break;
     }
     name.append(1, path.value()[i]);
   }
   return name;
 #else
   return FILE_PATH_LITERAL("<root>");
@@ skipping 20 matching lines @@
 
 static base::LazyInstance<IsolatedContext>::Leaky g_isolated_context =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 IsolatedContext::FileInfoSet::FileInfoSet() {}
 IsolatedContext::FileInfoSet::~FileInfoSet() {}
 
 bool IsolatedContext::FileInfoSet::AddPath(
-    const FilePath& path, std::string* registered_name) {
+    const base::FilePath& path, std::string* registered_name) {
   // The given path should not contain any '..' and should be absolute.
   if (path.ReferencesParent() || !path.IsAbsolute())
     return false;
-  FilePath::StringType name = GetRegisterNameForPath(path);
-  std::string utf8name = FilePath(name).AsUTF8Unsafe();
-  FilePath normalized_path = path.NormalizePathSeparators();
+  base::FilePath::StringType name = GetRegisterNameForPath(path);
+  std::string utf8name = base::FilePath(name).AsUTF8Unsafe();
+  base::FilePath normalized_path = path.NormalizePathSeparators();
   bool inserted =
       fileset_.insert(MountPointInfo(utf8name, normalized_path)).second;
   if (!inserted) {
     int suffix = 1;
-    std::string basepart = FilePath(name).RemoveExtension().AsUTF8Unsafe();
-    std::string ext = FilePath(FilePath(name).Extension()).AsUTF8Unsafe();
+    std::string basepart = base::FilePath(name).RemoveExtension().AsUTF8Unsafe();
+    std::string ext = base::FilePath(base::FilePath(name).Extension()).AsUTF8Unsafe();
     while (!inserted) {
       utf8name = base::StringPrintf("%s (%d)", basepart.c_str(), suffix++);
       if (!ext.empty())
         utf8name.append(ext);
       inserted =
           fileset_.insert(MountPointInfo(utf8name, normalized_path)).second;
     }
   }
   if (registered_name)
     *registered_name = utf8name;
   return true;
 }
 
 bool IsolatedContext::FileInfoSet::AddPathWithName(
-    const FilePath& path, const std::string& name) {
+    const base::FilePath& path, const std::string& name) {
   // The given path should not contain any '..' and should be absolute.
   if (path.ReferencesParent() || !path.IsAbsolute())
     return false;
   return fileset_.insert(
       MountPointInfo(name, path.NormalizePathSeparators())).second;
 }
 
 //--------------------------------------------------------------------------
 
 class IsolatedContext::Instance {
@@ skipping 11 matching lines @@
   ~Instance();
 
   FileSystemType type() const { return type_; }
   const MountPointInfo& file_info() const { return file_info_; }
   const std::set<MountPointInfo>& files() const { return files_; }
   int ref_counts() const { return ref_counts_; }
 
   void AddRef() { ++ref_counts_; }
   void RemoveRef() { --ref_counts_; }
 
-  bool ResolvePathForName(const std::string& name, FilePath* path) const;
+  bool ResolvePathForName(const std::string& name, base::FilePath* path) const;
 
   // Returns true if the instance is a single-path instance.
   bool IsSinglePathInstance() const;
 
  private:
   const FileSystemType type_;
 
   // For single-path instance.
   const MountPointInfo file_info_;
 
@@ skipping 19 matching lines @@
                                     const std::set<MountPointInfo>& files)
     : type_(type),
       files_(files),
       ref_counts_(0) {
   DCHECK(!IsSinglePathIsolatedFileSystem(type_));
 }
 
 IsolatedContext::Instance::~Instance() {}
 
 bool IsolatedContext::Instance::ResolvePathForName(const std::string& name,
-                                                   FilePath* path) const {
+                                                   base::FilePath* path) const {
   if (IsSinglePathIsolatedFileSystem(type_)) {
     *path = file_info_.path;
     return file_info_.name == name;
   }
   std::set<MountPointInfo>::const_iterator found = files_.find(
-      MountPointInfo(name, FilePath()));
+      MountPointInfo(name, base::FilePath()));
   if (found == files_.end())
     return false;
   *path = found->path;
   return true;
 }
 
 bool IsolatedContext::Instance::IsSinglePathInstance() const {
   return IsSinglePathIsolatedFileSystem(type_);
 }
 
@@ skipping 13 matching lines @@
     const FileInfoSet& files) {
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
   instance_map_[filesystem_id] = new Instance(
       kFileSystemTypeDragged, files.fileset());
   return filesystem_id;
 }
 
 std::string IsolatedContext::RegisterFileSystemForPath(
     FileSystemType type,
-    const FilePath& path_in,
+    const base::FilePath& path_in,
     std::string* register_name) {
-  FilePath path(path_in.NormalizePathSeparators());
+  base::FilePath path(path_in.NormalizePathSeparators());
   DCHECK(!path.ReferencesParent() && path.IsAbsolute());
   std::string name;
   if (register_name && !register_name->empty()) {
     name = *register_name;
   } else {
-    name = FilePath(GetRegisterNameForPath(path)).AsUTF8Unsafe();
+    name = base::FilePath(GetRegisterNameForPath(path)).AsUTF8Unsafe();
     if (register_name)
       register_name->assign(name);
   }
 
   base::AutoLock locker(lock_);
   std::string filesystem_id = GetNewFileSystemId();
   instance_map_[filesystem_id] = new Instance(type, MountPointInfo(name, path));
   path_to_id_map_[path].insert(filesystem_id);
   return filesystem_id;
 }
 
 bool IsolatedContext::HandlesFileSystemMountType(FileSystemType type) const {
   return type == kFileSystemTypeIsolated;
 }
 
 bool IsolatedContext::RevokeFileSystem(const std::string& filesystem_id) {
   base::AutoLock locker(lock_);
   return UnregisterFileSystem(filesystem_id);
 }
 
 bool IsolatedContext::GetRegisteredPath(
-    const std::string& filesystem_id, FilePath* path) const {
+    const std::string& filesystem_id, base::FilePath* path) const {
   DCHECK(path);
   base::AutoLock locker(lock_);
   IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() || !found->second->IsSinglePathInstance())
     return false;
   *path = found->second->file_info().path;
   return true;
 }
 
-bool IsolatedContext::CrackVirtualPath(const FilePath& virtual_path,
+bool IsolatedContext::CrackVirtualPath(const base::FilePath& virtual_path,
                                         std::string* id_or_name,
                                         FileSystemType* type,
-                                        FilePath* path) const {
+                                        base::FilePath* path) const {
   DCHECK(id_or_name);
   DCHECK(path);
 
   // This should not contain any '..' references.
   if (virtual_path.ReferencesParent())
     return false;
 
   // The virtual_path should comprise <id_or_name> and <relative_path> parts.
-  std::vector<FilePath::StringType> components;
+  std::vector<base::FilePath::StringType> components;
   virtual_path.GetComponents(&components);
   if (components.size() < 1)
     return false;
-  std::vector<FilePath::StringType>::iterator component_iter =
+  std::vector<base::FilePath::StringType>::iterator component_iter =
       components.begin();
-  std::string fsid = FilePath(*component_iter++).MaybeAsASCII();
+  std::string fsid = base::FilePath(*component_iter++).MaybeAsASCII();
   if (fsid.empty())
     return false;
 
-  FilePath cracked_path;
+  base::FilePath cracked_path;
   {
     base::AutoLock locker(lock_);
     IDToInstance::const_iterator found_instance = instance_map_.find(fsid);
     if (found_instance == instance_map_.end())
       return false;
     *id_or_name = fsid;
     const Instance* instance = found_instance->second;
     if (type)
       *type = instance->type();
 
     if (component_iter == components.end()) {
       // The virtual root case.
       path->clear();
       return true;
     }
 
     // *component_iter should be a name of the registered path.
-    std::string name = FilePath(*component_iter++).AsUTF8Unsafe();
+    std::string name = base::FilePath(*component_iter++).AsUTF8Unsafe();
     if (!instance->ResolvePathForName(name, &cracked_path))
       return false;
   }
 
   for (; component_iter != components.end(); ++component_iter)
     cracked_path = cracked_path.Append(*component_iter);
   *path = cracked_path;
   return true;
 }
 
 FileSystemURL IsolatedContext::CrackURL(const GURL& url) const {
   FileSystemURL filesystem_url = FileSystemURL(url);
   if (!filesystem_url.is_valid())
     return FileSystemURL();
   return CreateCrackedFileSystemURL(filesystem_url.origin(),
                                     filesystem_url.mount_type(),
                                     filesystem_url.path());
 }
 
 FileSystemURL IsolatedContext::CreateCrackedFileSystemURL(
     const GURL& origin,
     FileSystemType type,
-    const FilePath& path) const {
+    const base::FilePath& path) const {
   if (!HandlesFileSystemMountType(type))
     return FileSystemURL();
 
   std::string mount_name;
   FileSystemType cracked_type;
-  FilePath cracked_path;
+  base::FilePath cracked_path;
   if (!CrackVirtualPath(path, &mount_name, &cracked_type, &cracked_path))
     return FileSystemURL();
 
   return FileSystemURL(origin, type, path,
                        mount_name, cracked_type, cracked_path);
 }
 
-void IsolatedContext::RevokeFileSystemByPath(const FilePath& path_in) {
+void IsolatedContext::RevokeFileSystemByPath(const base::FilePath& path_in) {
   base::AutoLock locker(lock_);
-  FilePath path(path_in.NormalizePathSeparators());
+  base::FilePath path(path_in.NormalizePathSeparators());
   PathToID::iterator ids_iter = path_to_id_map_.find(path);
   if (ids_iter == path_to_id_map_.end())
     return;
   std::set<std::string>& ids = ids_iter->second;
   for (std::set<std::string>::iterator iter = ids.begin();
        iter != ids.end(); ++iter) {
     IDToInstance::iterator found = instance_map_.find(*iter);
     if (found != instance_map_.end()) {
       delete found->second;
       instance_map_.erase(found);
@@ skipping 31 matching lines @@
   base::AutoLock locker(lock_);
   IDToInstance::const_iterator found = instance_map_.find(filesystem_id);
   if (found == instance_map_.end() ||
       found->second->type() != kFileSystemTypeDragged)
     return false;
   files->assign(found->second->files().begin(),
                 found->second->files().end());
   return true;
 }
 
-FilePath IsolatedContext::CreateVirtualRootPath(
+base::FilePath IsolatedContext::CreateVirtualRootPath(
     const std::string& filesystem_id) const {
-  return FilePath().AppendASCII(filesystem_id);
+  return base::FilePath().AppendASCII(filesystem_id);
 }
 
 IsolatedContext::IsolatedContext() {
 }
 
 IsolatedContext::~IsolatedContext() {
   STLDeleteContainerPairSecondPointers(instance_map_.begin(),
                                        instance_map_.end());
 }
 
@@ skipping 22 matching lines @@
   uint32 random_data[4];
   std::string id;
   do {
     base::RandBytes(random_data, sizeof(random_data));
     id = base::HexEncode(random_data, sizeof(random_data));
   } while (instance_map_.find(id) != instance_map_.end());
   return id;
 }
 
 }  // namespace fileapi