Add FilePath to base namespace.

webkit/fileapi/file_util_helper.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/file_util_helper.h"
 
 #include <stack>
 #include <utility>
 
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using base::PlatformFileError;
 
 namespace fileapi {
 
 namespace {
 
 // A helper class to delete a temporary file.
 class ScopedFileDeleter {
  public:
-  explicit ScopedFileDeleter(const FilePath& path) : path_(path) {}
+  explicit ScopedFileDeleter(const base::FilePath& path) : path_(path) {}
   ~ScopedFileDeleter() {
     file_util::Delete(path_, false /* recursive */);
   }
 
  private:
-  FilePath path_;
+  base::FilePath path_;
 };
 
 bool IsInRoot(const FileSystemURL& url) {
   // If path is in the root, path.DirName() will be ".",
   // since we use paths with no leading '/'.
-  FilePath parent = url.path().DirName();
-  return parent.empty() || parent == FilePath(FILE_PATH_LITERAL("."));
+  base::FilePath parent = url.path().DirName();
+  return parent.empty() || parent == base::FilePath(FILE_PATH_LITERAL("."));
 }
 
 // A helper class for cross-FileUtil Copy/Move operations.
 class CrossFileUtilHelper {
  public:
   enum Operation {
     OPERATION_COPY,
     OPERATION_MOVE
   };
 
@@ skipping 105 matching lines @@
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   typedef std::pair<FileSystemURL, base::Time> MovedDirectoryPair;
   typedef std::vector<MovedDirectoryPair> MovedDirectories;
   MovedDirectories directories;
 
   // Store modified timestamp of the root directory.
   if (operation_ == OPERATION_MOVE) {
     base::PlatformFileInfo file_info;
-    FilePath platform_file_path;
+    base::FilePath platform_file_path;
     error = src_util_->GetFileInfo(
         context_, src_url, &file_info, &platform_file_path);
     if (error != base::PLATFORM_FILE_OK)
       return error;
     directories.push_back(
         std::make_pair(dest_url, file_info.last_modified));
   }
 
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       src_util_->CreateFileEnumerator(context_,
                                       src_url,
                                       true /* recursive */));
-  FilePath src_file_path_each;
+  base::FilePath src_file_path_each;
   while (!(src_file_path_each = file_enum->Next()).empty()) {
-    FilePath dest_file_path_each(dest_url.path());
+    base::FilePath dest_file_path_each(dest_url.path());
     src_url.path().AppendRelativePath(
         src_file_path_each, &dest_file_path_each);
 
     if (file_enum->IsDirectory()) {
       error = dest_util_->CreateDirectory(
           context_,
           dest_url.WithPath(dest_file_path_each),
           true /* exclusive */, false /* recursive */);
       if (error != base::PLATFORM_FILE_OK)
         return error;
@@ skipping 33 matching lines @@
   if (same_file_system_) {
     DCHECK(src_util_ == dest_util_);
     // Source and destination are in the same FileSystemFileUtil; now we can
     // safely call FileSystemFileUtil method on src_util_ (== dest_util_).
     return src_util_->CopyOrMoveFile(context_, src_url, dest_url,
                                      operation_ == OPERATION_COPY);
   }
 
   // Resolve the src_url's underlying file path.
   base::PlatformFileInfo file_info;
-  FilePath platform_file_path;
+  base::FilePath platform_file_path;
   SnapshotFilePolicy snapshot_policy;
 
   PlatformFileError error = src_util_->CreateSnapshotFile(
       context_, src_url, &file_info, &platform_file_path, &snapshot_policy);
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   // For now we don't support non-snapshot file case.
   // TODO(kinuko): Address this case too.
   DCHECK(!platform_file_path.empty());
@@ skipping 15 matching lines @@
 }  // anonymous namespace
 
 // static
 bool FileUtilHelper::DirectoryExists(FileSystemOperationContext* context,
                                      FileSystemFileUtil* file_util,
                                      const FileSystemURL& url) {
   if (url.path().empty())
     return true;
 
   base::PlatformFileInfo file_info;
-  FilePath platform_path;
+  base::FilePath platform_path;
   PlatformFileError error = file_util->GetFileInfo(
       context, url, &file_info, &platform_path);
   return error == base::PLATFORM_FILE_OK && file_info.is_directory;
 }
 
 // static
 base::PlatformFileError FileUtilHelper::Copy(
     FileSystemOperationContext* context,
     FileSystemFileUtil* src_file_util,
     FileSystemFileUtil* dest_file_util,
@@ skipping 34 matching lines @@
 
 // static
 base::PlatformFileError FileUtilHelper::ReadDirectory(
     FileSystemOperationContext* context,
     FileSystemFileUtil* file_util,
     const FileSystemURL& url,
     std::vector<base::FileUtilProxy::Entry>* entries) {
   DCHECK(entries);
 
   base::PlatformFileInfo file_info;
-  FilePath platform_path;
+  base::FilePath platform_path;
   PlatformFileError error = file_util->GetFileInfo(
       context, url, &file_info, &platform_path);
   if (error != base::PLATFORM_FILE_OK)
     return error;
   if (!file_info.is_directory)
     return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
 
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       file_util->CreateFileEnumerator(context, url, false /* recursive */));
 
-  FilePath current;
+  base::FilePath current;
   while (!(current = file_enum->Next()).empty()) {
     base::FileUtilProxy::Entry entry;
     entry.is_directory = file_enum->IsDirectory();
     entry.name = VirtualPath::BaseName(current).value();
     entry.size = file_enum->Size();
     entry.last_modified_time = file_enum->LastModifiedTime();
     entries->push_back(entry);
   }
   return base::PLATFORM_FILE_OK;
 }
 
 // static
 base::PlatformFileError FileUtilHelper::DeleteDirectoryRecursive(
     FileSystemOperationContext* context,
     FileSystemFileUtil* file_util,
     const FileSystemURL& url) {
 
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       file_util->CreateFileEnumerator(context, url, true /* recursive */));
-  FilePath file_path_each;
-  std::stack<FilePath> directories;
+  base::FilePath file_path_each;
+  std::stack<base::FilePath> directories;
   while (!(file_path_each = file_enum->Next()).empty()) {
     if (file_enum->IsDirectory()) {
       directories.push(file_path_each);
     } else {
       PlatformFileError error = file_util->DeleteFile(
           context, url.WithPath(file_path_each));
       if (error != base::PLATFORM_FILE_ERROR_NOT_FOUND &&
           error != base::PLATFORM_FILE_OK)
         return error;
     }
   }
 
   while (!directories.empty()) {
     PlatformFileError error = file_util->DeleteDirectory(
         context, url.WithPath(directories.top()));
     if (error != base::PLATFORM_FILE_ERROR_NOT_FOUND &&
         error != base::PLATFORM_FILE_OK)
       return error;
     directories.pop();
   }
   return file_util->DeleteDirectory(context, url);
 }
 
 }  // namespace fileapi