Add FilePath to base namespace.

webkit/chromeos/fileapi/memory_file_util.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 "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "webkit/chromeos/fileapi/memory_file_util.h"
 
 namespace {
@@ skipping 116 matching lines @@
   base::WeakPtrFactory<MemoryFileUtilAsyncFileStream> weak_ptr_factory_;
 };
 
 MemoryFileUtil::FileEntry::FileEntry()
     : is_directory(false) {
 }
 
 MemoryFileUtil::FileEntry::~FileEntry() {
 }
 
-MemoryFileUtil::MemoryFileUtil(const FilePath& root_path)
+MemoryFileUtil::MemoryFileUtil(const base::FilePath& root_path)
     : read_directory_buffer_size_(kDefaultReadDirectoryBufferSize) {
   FileEntry root;
   root.is_directory = true;
   root.last_modified = base::Time::Now();
 
   files_[root_path] = root;
 }
 
 MemoryFileUtil::~MemoryFileUtil() {
 }
@@ skipping 24 matching lines @@
 // - OpenVerifiedFile   OR   Create
 //                           DidCreateOrTruncateForOpen
 //                           OpenVerifiedFile
 //
 // PLATFORM_FILE_OPEN_TRUNCATED:
 // - Truncate
 // - DidCreateOrTruncateForOpen
 // - OpenVerifiedFile
 //
 void MemoryFileUtil::Open(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     int flags,
     const OpenCallback& callback) {
   int create_flag = flags & (base::PLATFORM_FILE_OPEN |
                              base::PLATFORM_FILE_CREATE |
                              base::PLATFORM_FILE_OPEN_ALWAYS |
                              base::PLATFORM_FILE_CREATE_ALWAYS |
                              base::PLATFORM_FILE_OPEN_TRUNCATED);
   switch (create_flag) {
     case base::PLATFORM_FILE_OPEN:
     case base::PLATFORM_FILE_OPEN_ALWAYS:
@@ skipping 30 matching lines @@
     default:
       MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback,
                      base::PLATFORM_FILE_ERROR_INVALID_OPERATION,
                      static_cast<AsyncFileStream*>(NULL)));
   }
 }
 
 void MemoryFileUtil::GetFileInfo(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     const GetFileInfoCallback& callback) {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MemoryFileUtil::DoGetFileInfo, base::Unretained(this),
                  file_path.StripTrailingSeparators(), callback));
 }
 
 void MemoryFileUtil::Create(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     const StatusCallback& callback) {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MemoryFileUtil::DoCreate, base::Unretained(this),
                  file_path.StripTrailingSeparators(), false, callback));
 }
 
 void MemoryFileUtil::Truncate(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     int64 length,
     const StatusCallback& callback) {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MemoryFileUtil::DoTruncate, base::Unretained(this),
                  file_path.StripTrailingSeparators(), length, callback));
 }
 
 void MemoryFileUtil::Touch(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MemoryFileUtil::DoTouch, base::Unretained(this),
                  file_path.StripTrailingSeparators(),
                  last_modified_time, callback));
 }
 
 void MemoryFileUtil::Remove(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     bool recursive,
     const StatusCallback& callback) {
   if (recursive) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MemoryFileUtil::DoRemoveRecursive,
                    base::Unretained(this), file_path.StripTrailingSeparators(),
                    callback));
   } else {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MemoryFileUtil::DoRemoveSingleFile,
                    base::Unretained(this), file_path.StripTrailingSeparators(),
                    callback));
   }
 }
 
 void MemoryFileUtil::CreateDirectory(
-    const FilePath& dir_path,
+    const base::FilePath& dir_path,
     const StatusCallback& callback) {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MemoryFileUtil::DoCreate,
                  base::Unretained(this), dir_path.StripTrailingSeparators(),
                  true, callback));
 }
 
 void MemoryFileUtil::ReadDirectory(
-    const FilePath& dir_path,
+    const base::FilePath& dir_path,
     const ReadDirectoryCallback& callback) {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MemoryFileUtil::DoReadDirectory,
                  base::Unretained(this), dir_path.StripTrailingSeparators(),
-                 FilePath(), callback));
+                 base::FilePath(), callback));
 }
 
-void MemoryFileUtil::DoGetFileInfo(const FilePath& file_path,
+void MemoryFileUtil::DoGetFileInfo(const base::FilePath& file_path,
                                    const GetFileInfoCallback& callback) {
   base::PlatformFileInfo file_info;
 
   FileIterator file_it = files_.find(file_path);
 
   if (file_it == files_.end()) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND, file_info);
     return;
   }
   const FileEntry& file_entry = file_it->second;
 
   file_info.size = file_entry.contents.size();
   file_info.is_directory = file_entry.is_directory;
   file_info.is_symbolic_link = false;
 
   // In this file system implementation we store only one datetime. Many
   // popular file systems do the same.
   file_info.last_modified = file_entry.last_modified;
   file_info.last_accessed = file_entry.last_modified;
   file_info.creation_time = file_entry.last_modified;
 
   callback.Run(base::PLATFORM_FILE_OK, file_info);
 }
 
 void MemoryFileUtil::DoCreate(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     bool is_directory,
     const StatusCallback& callback) {
   if (FileExists(file_path)) {
     callback.Run(base::PLATFORM_FILE_ERROR_EXISTS);
     return;
   }
 
   if (!IsDirectory(file_path.DirName())) {
     callback.Run(base::PLATFORM_FILE_ERROR_FAILED);
     return;
   }
 
   FileEntry file;
   file.is_directory = is_directory;
   file.last_modified = base::Time::Now();
 
   files_[file_path] = file;
   callback.Run(base::PLATFORM_FILE_OK);
 }
 
 void MemoryFileUtil::DoTruncate(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     int64 length,
     const StatusCallback& callback) {
   FileIterator file_it = files_.find(file_path);
   if (file_it == files_.end()) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   FileEntry& file = file_it->second;
 
   // Fill the extended part with 0 if |length| is larger than the original
   // contents size.
   file.contents.resize(length, 0);
   callback.Run(base::PLATFORM_FILE_OK);
 }
 
 void MemoryFileUtil::DoTouch(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   FileIterator file_it = files_.find(file_path);
   if (file_it == files_.end()) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   FileEntry& file = file_it->second;
 
   file.last_modified = last_modified_time;
   callback.Run(base::PLATFORM_FILE_OK);
 }
 
 void MemoryFileUtil::DoRemoveSingleFile(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     const StatusCallback& callback) {
   FileIterator file_it = files_.find(file_path);
   if (file_it == files_.end()) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   FileEntry& file = file_it->second;
   if (file.is_directory) {
     // Check if the directory is empty. This can be done by checking if
     // the next file is present under the directory. Note that |files_| is
     // a map hence the file names are sorted by names.
     FileIterator tmp_it = file_it;
     ++tmp_it;
     if (tmp_it != files_.end() && file_path.IsParent(tmp_it->first)) {
       callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_FILE);
       return;
     }
   }
 
   files_.erase(file_it);
   callback.Run(base::PLATFORM_FILE_OK);
 }
 
 void MemoryFileUtil::DoRemoveRecursive(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     const StatusCallback& callback) {
   FileIterator file_it = files_.find(file_path);
   if (file_it == files_.end()) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   FileEntry& file = file_it->second;
   if (!file.is_directory) {
     files_.erase(file_it);
     callback.Run(base::PLATFORM_FILE_OK);
     return;
   }
 
   // Remove the directory itself.
   files_.erase(file_it++);
   // Remove files under the directory.
   while (file_it != files_.end()) {
     if (file_path.IsParent(file_it->first)) {
       files_.erase(file_it++);
     } else {
       break;
     }
   }
   callback.Run(base::PLATFORM_FILE_OK);
 }
 
 void MemoryFileUtil::DoReadDirectory(
-    const FilePath& dir_path,
-    const FilePath& in_from,
+    const base::FilePath& dir_path,
+    const base::FilePath& in_from,
     const ReadDirectoryCallback& callback) {
-  FilePath from = in_from;
+  base::FilePath from = in_from;
   read_directory_buffer_.clear();
 
   if (!FileExists(dir_path)) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND,
                  read_directory_buffer_, true);
     return;
   }
 
   if (!IsDirectory(dir_path)) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
@@ skipping 41 matching lines @@
   if (!completed) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&MemoryFileUtil::DoReadDirectory,
                    base::Unretained(this), dir_path,
                    from, callback));
   }
 }
 
 void MemoryFileUtil::OpenVerifiedFile(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     int flags,
     const OpenCallback& callback) {
   FileIterator file_it = files_.find(file_path);
   // The existence of the file is guranteed here.
   DCHECK(file_it != files_.end());
 
   FileEntry* file_entry = &file_it->second;
   callback.Run(base::PLATFORM_FILE_OK,
                new MemoryFileUtilAsyncFileStream(file_entry, flags));
 }
 
 void MemoryFileUtil::DidGetFileInfoForOpen(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     int flags,
     const OpenCallback& callback,
     PlatformFileError get_info_result,
     const base::PlatformFileInfo& file_info) {
   if (get_info_result == base::PLATFORM_FILE_OK && file_info.is_directory) {
     callback.Run(base::PLATFORM_FILE_ERROR_NOT_A_FILE, NULL);
     return;
   }
 
   if (get_info_result == base::PLATFORM_FILE_OK) {
     OpenVerifiedFile(file_path, flags, callback);
     return;
   }
 
   if (get_info_result == base::PLATFORM_FILE_ERROR_NOT_FOUND &&
       flags & base::PLATFORM_FILE_CREATE_ALWAYS) {
     Create(file_path,
            base::Bind(&MemoryFileUtil::DidCreateOrTruncateForOpen,
                       base::Unretained(this), file_path, flags, 0, callback));
     return;
   }
 
   callback.Run(get_info_result, NULL);
 }
 
 void MemoryFileUtil::OpenTruncatedFileOrCreate(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     int flags,
     const OpenCallback& callback,
     PlatformFileError result) {
   if (result == base::PLATFORM_FILE_OK) {
     OpenVerifiedFile(file_path, flags, callback);
     return;
   }
 
   if (result == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
     Create(
         file_path,
         base::Bind(&MemoryFileUtil::DidCreateOrTruncateForOpen,
                    base::Unretained(this), file_path, flags, 0, callback));
     return;
   }
 
   callback.Run(result, NULL);
 }
 
 void MemoryFileUtil::DidCreateOrTruncateForOpen(
-    const FilePath& file_path,
+    const base::FilePath& file_path,
     int flags,
     int64 size,
     const OpenCallback& callback,
     PlatformFileError result) {
   if (result != base::PLATFORM_FILE_OK) {
     callback.Run(result, NULL);
     return;
   }
 
   OpenVerifiedFile(file_path, flags, callback);
 }
 
 }  // namespace fileapi