Add FilePath to base namespace.

webkit/chromeos/fileapi/memory_file_util_unittest.cc

 // Copyright (c) 2011 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/message_loop.h"
 #include "base/platform_file.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/chromeos/fileapi/memory_file_util.h"
 
 namespace {
-const FilePath::CharType kRootPath[] = "/mnt/memory";
+const base::FilePath::CharType kRootPath[] = "/mnt/memory";
 const char kTestString[] = "A test string. A test string.";
 const char kTestStringLength = arraysize(kTestString) - 1;
 }  // namespace
 
 namespace fileapi {
 
 // This test is actually testing MemoryFileUtil — an async in-memory file
 // system, based on FileUtilAsync.
 class MemoryFileUtilTest : public testing::Test {
  public:
   MemoryFileUtilTest() : max_request_id_(0) {
   }
 
   ~MemoryFileUtilTest() {
     for (std::map<int, CallbackStatus>::iterator iter = status_map_.begin();
          iter != status_map_.end();
          ++iter) {
       delete iter->second.file_stream;
     }
   }
 
   void SetUp() {
-    file_util_.reset(new MemoryFileUtil(FilePath(kRootPath)));
+    file_util_.reset(new MemoryFileUtil(base::FilePath(kRootPath)));
   }
 
   MemoryFileUtil* file_util() {
     return file_util_.get();
   }
 
   enum CallbackType {
     CALLBACK_TYPE_ERROR,
     CALLBACK_TYPE_STATUS,
     CALLBACK_TYPE_GET_FILE_INFO,
@@ skipping 51 matching lines @@
                       request_id);
   }
 
   FileUtilAsync::ReadDirectoryCallback GetReadDirectoryCallback(
       int request_id) {
     return base::Bind(&MemoryFileUtilTest::ReadDirectoryCallback,
                       base::Unretained(this),
                       request_id);
   }
 
-  int CreateEmptyFile(const FilePath& file_path) {
+  int CreateEmptyFile(const base::FilePath& file_path) {
     int request_id = GetNextRequestId();
     file_util_->Create(file_path, GetStatusCallback(request_id));
     return request_id;
   }
 
-  int CreateNonEmptyFile(const FilePath& file_path,
+  int CreateNonEmptyFile(const base::FilePath& file_path,
                          const char* data,
                          int length) {
     int request_id = GetNextRequestId();
     file_util_->Open(
         file_path,
         base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE,
         base::Bind(&MemoryFileUtilTest::WriteToOpenedFile,
                    base::Unretained(this),
                    request_id, data, length));
     return request_id;
@@ skipping 102 matching lines @@
 
   scoped_ptr<MemoryFileUtil> file_util_;
   std::map<int, CallbackStatus> status_map_;
   int max_request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryFileUtilTest);
 };
 
 TEST_F(MemoryFileUtilTest, TestCreateGetFileInfo) {
   const int request_id1 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test.txt"),
                            GetGetFileInfoCallback(request_id1));
 
   // In case the file system is truely asynchronous, RunAllPending is not
   // enough to wait for answer. In that case the thread should be blocked
   // until the callback is called (ex. use Run() instead here, and call
   // Quit() from callback).
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id1));
   CallbackStatus status = GetStatus(request_id1);
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status.result);
 
   base::Time start_create = base::Time::Now();
 
   const int request_id2 = GetNextRequestId();
-  file_util()->Create(FilePath("/mnt/memory/test.txt"),
+  file_util()->Create(base::FilePath("/mnt/memory/test.txt"),
                       GetStatusCallback(request_id2));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(CALLBACK_TYPE_STATUS, GetStatusType(request_id2));
   status = GetStatus(request_id2);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
 
   const int request_id3 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test.txt"),
                            GetGetFileInfoCallback(request_id3));
   MessageLoop::current()->RunUntilIdle();
 
   base::Time end_create = base::Time::Now();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id3));
   status = GetStatus(request_id3);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(0, status.file_info.size);
   ASSERT_FALSE(status.file_info.is_directory);
   ASSERT_FALSE(status.file_info.is_symbolic_link);
   ASSERT_GE(status.file_info.last_modified, start_create);
   ASSERT_LE(status.file_info.last_modified, end_create);
   ASSERT_GE(status.file_info.creation_time, start_create);
   ASSERT_LE(status.file_info.creation_time, end_create);
 }
 
 TEST_F(MemoryFileUtilTest, TestReadWrite) {
   // Check that the file does not exist.
 
   const int request_id1 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test1.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test1.txt"),
                            GetGetFileInfoCallback(request_id1));
 
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id1));
   CallbackStatus status = GetStatus(request_id1);
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, status.result);
 
   // Create & open file for writing.
 
   base::Time start_create = base::Time::Now();
   const int request_id2 = GetNextRequestId();
-  file_util()->Open(FilePath("/mnt/memory/test1.txt"),
+  file_util()->Open(base::FilePath("/mnt/memory/test1.txt"),
                     base::PLATFORM_FILE_CREATE_ALWAYS |
                     base::PLATFORM_FILE_WRITE,
                     GetOpenCallback(request_id2));
   MessageLoop::current()->RunUntilIdle();
 
   base::Time end_create = base::Time::Now();
 
   ASSERT_EQ(CALLBACK_TYPE_OPEN, GetStatusType(request_id2));
   status = GetStatus(request_id2);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
 
   AsyncFileStream* write_file_stream = status.file_stream;
 
   // Check that file was created and has 0 size.
 
   const int request_id3 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test1.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test1.txt"),
                            GetGetFileInfoCallback(request_id3));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id3));
   status = GetStatus(request_id3);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(0, status.file_info.size);
   ASSERT_FALSE(status.file_info.is_directory);
   ASSERT_FALSE(status.file_info.is_symbolic_link);
   ASSERT_GE(status.file_info.last_modified, start_create);
   ASSERT_LE(status.file_info.last_modified, end_create);
 
   // Write 10 bytes to file.
 
   const int request_id4 = GetNextRequestId();
   base::Time start_write = base::Time::Now();
   write_file_stream->Write(kTestString, 10,
                            GetReadWriteCallback(request_id4));
   MessageLoop::current()->RunUntilIdle();
   base::Time end_write = base::Time::Now();
 
   ASSERT_EQ(CALLBACK_TYPE_READ_WRITE, GetStatusType(request_id4));
   status = GetStatus(request_id4);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(10, status.length);
 
   // Check that the file has now size 10 and correct modification time.
 
   const int request_id5 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test1.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test1.txt"),
                            GetGetFileInfoCallback(request_id5));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id5));
   status = GetStatus(request_id5);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(10, status.file_info.size);
   ASSERT_GE(status.file_info.last_modified, start_write);
   ASSERT_LE(status.file_info.last_modified, end_write);
 
   // Write the rest of the string to file.
 
   const int request_id6 = GetNextRequestId();
   start_write = base::Time::Now();
   write_file_stream->Write(kTestString + 10,
                            kTestStringLength - 10,
                            GetReadWriteCallback(request_id6));
   MessageLoop::current()->RunUntilIdle();
   end_write = base::Time::Now();
 
   ASSERT_EQ(CALLBACK_TYPE_READ_WRITE, GetStatusType(request_id6));
   status = GetStatus(request_id6);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(static_cast<int64>(kTestStringLength) - 10, status.length);
 
   // Check the file size & modification time.
 
   const int request_id7 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test1.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test1.txt"),
                            GetGetFileInfoCallback(request_id7));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id7));
   status = GetStatus(request_id7);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(static_cast<int64>(kTestStringLength), status.file_info.size);
   ASSERT_GE(status.file_info.last_modified, start_write);
   ASSERT_LE(status.file_info.last_modified, end_write);
 
   // Open file for reading.
 
   const int request_id8 = GetNextRequestId();
-  file_util()->Open(FilePath("/mnt/memory/test1.txt"),
+  file_util()->Open(base::FilePath("/mnt/memory/test1.txt"),
                     base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
                     GetOpenCallback(request_id8));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_OPEN, GetStatusType(request_id8));
   status = GetStatus(request_id8);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
 
   AsyncFileStream* read_file_stream = status.file_stream;
 
   // Read the whole file
   char buffer[1024];
   const int request_id9 = GetNextRequestId();
   read_file_stream->Read(buffer, 1023, GetReadWriteCallback(request_id9));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_READ_WRITE, GetStatusType(request_id9));
   status = GetStatus(request_id9);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(static_cast<int64>(kTestStringLength), status.length);
 
   buffer[status.length] = '\0';
   std::string result_string(buffer);
   ASSERT_EQ(kTestString, result_string);
 
   // Check that size & modification time have not changed.
 
   const int request_id10 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test1.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test1.txt"),
                            GetGetFileInfoCallback(request_id10));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id10));
   status = GetStatus(request_id10);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(static_cast<int64>(kTestStringLength), status.file_info.size);
   ASSERT_GE(status.file_info.last_modified, start_write);
   ASSERT_LE(status.file_info.last_modified, end_write);
 
   // Open once more for writing.
 
   const int request_id11 = GetNextRequestId();
-  file_util()->Open(FilePath("/mnt/memory/test1.txt"),
+  file_util()->Open(base::FilePath("/mnt/memory/test1.txt"),
                     base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE,
                     GetOpenCallback(request_id11));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_OPEN, GetStatusType(request_id11));
   status = GetStatus(request_id11);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
 
   AsyncFileStream* write_file_stream2 = status.file_stream;
 
   // Check that the size has not changed.
 
   const int request_id12 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test1.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test1.txt"),
                            GetGetFileInfoCallback(request_id12));
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_GET_FILE_INFO, GetStatusType(request_id12));
   status = GetStatus(request_id12);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(static_cast<int64>(kTestStringLength), status.file_info.size);
 
   // Seek beyond the end of file. Should return error.
 
@@ skipping 27 matching lines @@
                             kTestStringLength,
                             GetReadWriteCallback(request_id16));
   MessageLoop::current()->RunUntilIdle();
   status = GetStatus(request_id16);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(static_cast<int64>(kTestStringLength), status.length);
 
   // Check size.
 
   const int request_id17 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/test1.txt"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/test1.txt"),
                            GetGetFileInfoCallback(request_id17));
   MessageLoop::current()->RunUntilIdle();
   status = GetStatus(request_id17);
   ASSERT_EQ(base::PLATFORM_FILE_OK, status.result);
   ASSERT_EQ(static_cast<int64>(kTestStringLength) + 10,
             status.file_info.size);
 
   // Read from 10th byte.
   const int request_id18 = GetNextRequestId();
   read_file_stream->Seek(10, GetStatusCallback(request_id18));
@@ skipping 21 matching lines @@
 // /mnt/memory/b/e         0
 // /mnt/memory/b/f         kTestStringLength
 // /mnt/memory/b/g/
 // /mnt/memory/b/g/h       0
 // /mnt/memory/b/i         kTestStringLength
 // /mnt/memory/c/
 // /mnt/memory/longer_file_name.txt kTestStringLength
 TEST_F(MemoryFileUtilTest, TestDirectoryOperations) {
   // Check the directory is empty.
   const int request_id0 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory/"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory/"),
                              GetReadDirectoryCallback(request_id0));
 
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(CALLBACK_TYPE_READ_DIRECTORY, GetStatusType(request_id0));
   CallbackStatus& status = GetStatus(request_id0);
   ASSERT_TRUE(status.completed);
   ASSERT_FALSE(status.called_after_completed);
   ASSERT_EQ(1, status.called);
   ASSERT_EQ(0u, status.entries.size());
 
   // Create /mnt/memory/a, /mnt/memory/b/, /mnt/memory/longer_file_name.txt,
   // /mnt/memory/c/ asyncronously (i.e. we do not wait for each operation to
   // complete before starting the next one.
 
   base::Time start_create = base::Time::Now();
-  CreateEmptyFile(FilePath("/mnt/memory/a"));
+  CreateEmptyFile(base::FilePath("/mnt/memory/a"));
 
   int request_id1 = GetNextRequestId();
-  file_util()->CreateDirectory(FilePath("/mnt/memory/b"),
+  file_util()->CreateDirectory(base::FilePath("/mnt/memory/b"),
                                GetStatusCallback(request_id1));
 
-  CreateNonEmptyFile(FilePath("/mnt/memory/longer_file_name.txt"),
+  CreateNonEmptyFile(base::FilePath("/mnt/memory/longer_file_name.txt"),
                      kTestString,
                      kTestStringLength);
 
   int request_id2 = GetNextRequestId();
-  file_util()->CreateDirectory(FilePath("/mnt/memory/c"),
+  file_util()->CreateDirectory(base::FilePath("/mnt/memory/c"),
                                GetStatusCallback(request_id2));
 
   MessageLoop::current()->RunUntilIdle();
   base::Time end_create = base::Time::Now();
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id2).result);
 
   // ReadDirectory /mnt/memory, /mnt/memory/a (not a dir), /mnt/memory/b/,
   // /mnt/memory/d (not found)
 
   set_read_directory_buffer_size(5);  // Should complete in one go.
 
   request_id1 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory"),
                              GetReadDirectoryCallback(request_id1));
   request_id2 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory/a"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory/a"),
                              GetReadDirectoryCallback(request_id2));
   const int request_id3 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory/b/"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory/b/"),
                              GetReadDirectoryCallback(request_id3));
   const int request_id4 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory/d/"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory/d/"),
                              GetReadDirectoryCallback(request_id4));
 
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
   status = GetStatus(request_id1);
   ASSERT_TRUE(status.completed);
   ASSERT_FALSE(status.called_after_completed);
   ASSERT_EQ(1, status.called);  // Because the number of entries < 5.
   ASSERT_EQ(4u, status.entries.size());
 
-  std::set<FilePath::StringType> seen;
+  std::set<base::FilePath::StringType> seen;
 
   for (FileUtilAsync::FileList::const_iterator it = status.entries.begin();
        it != status.entries.end();
        ++it) {
     ASSERT_LE(start_create, it->last_modified_time);
     ASSERT_GE(end_create, it->last_modified_time);
 
     ASSERT_EQ(seen.end(), seen.find(it->name));
     seen.insert(it->name);
 
@@ skipping 28 matching lines @@
   // /mnt/memory/b/c         kTestStringLength
   // /mnt/memory/b/d/
   // /mnt/memory/b/e         0
   // /mnt/memory/b/f         kTestStringLength
   // /mnt/memory/b/g/
   // /mnt/memory/b/i         kTestStringLength
   //
   // /mnt/memory/b/g/h       0
 
   start_create = base::Time::Now();
-  CreateNonEmptyFile(FilePath("/mnt/memory/b/c"),
+  CreateNonEmptyFile(base::FilePath("/mnt/memory/b/c"),
                      kTestString,
                      kTestStringLength);
   request_id1 = GetNextRequestId();
-  file_util()->CreateDirectory(FilePath("/mnt/memory/b/d"),
+  file_util()->CreateDirectory(base::FilePath("/mnt/memory/b/d"),
                                GetStatusCallback(request_id1));
-  CreateEmptyFile(FilePath("/mnt/memory/b/e"));
-  CreateNonEmptyFile(FilePath("/mnt/memory/b/f"),
+  CreateEmptyFile(base::FilePath("/mnt/memory/b/e"));
+  CreateNonEmptyFile(base::FilePath("/mnt/memory/b/f"),
                      kTestString,
                      kTestStringLength);
   request_id2 = GetNextRequestId();
-  file_util()->CreateDirectory(FilePath("/mnt/memory/b/g"),
+  file_util()->CreateDirectory(base::FilePath("/mnt/memory/b/g"),
                                GetStatusCallback(request_id1));
-  CreateNonEmptyFile(FilePath("/mnt/memory/b/i"),
+  CreateNonEmptyFile(base::FilePath("/mnt/memory/b/i"),
                      kTestString,
                      kTestStringLength);
 
   MessageLoop::current()->RunUntilIdle();
 
-  CreateEmptyFile(FilePath("/mnt/memory/b/g/h"));
+  CreateEmptyFile(base::FilePath("/mnt/memory/b/g/h"));
 
   MessageLoop::current()->RunUntilIdle();
   end_create = base::Time::Now();
 
   // Read /mnt/memory and check that the number of entries is unchanged.
 
   request_id1 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory"),
                              GetReadDirectoryCallback(request_id1));
 
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
   status = GetStatus(request_id1);
   ASSERT_TRUE(status.completed);
   ASSERT_FALSE(status.called_after_completed);
   ASSERT_EQ(1, status.called);  // Because the number of entries < 5.
   ASSERT_EQ(4u, status.entries.size());
 
   // Read /mnt/memory/b
 
   request_id1 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory/b"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory/b"),
                              GetReadDirectoryCallback(request_id1));
 
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
   status = GetStatus(request_id1);
   ASSERT_TRUE(status.completed);
   ASSERT_FALSE(status.called_after_completed);
   ASSERT_EQ(2, status.called);  // Because the number of entries > 5.
   ASSERT_EQ(6u, status.entries.size());
@@ skipping 34 matching lines @@
       ASSERT_EQ(static_cast<int64>(kTestStringLength), it->size);
     } else {
       LOG(ERROR) << "Unexpected file: " << it->name;
       ASSERT_TRUE(false);
     }
   }
 
   // Remove single file: /mnt/memory/b/f
 
   request_id1 = GetNextRequestId();
-  file_util()->Remove(FilePath("/mnt/memory/b/f"), false /* recursive */,
+  file_util()->Remove(base::FilePath("/mnt/memory/b/f"), false /* recursive */,
                       GetStatusCallback(request_id1));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
 
   // Check the number of files in b/
 
   request_id1 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory/b"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory/b"),
                              GetReadDirectoryCallback(request_id1));
 
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
   status = GetStatus(request_id1);
   ASSERT_TRUE(status.completed);
   ASSERT_FALSE(status.called_after_completed);
   ASSERT_EQ(5u, status.entries.size());
 
   // Try remove /mnt/memory/b non-recursively (error)
 
   request_id1 = GetNextRequestId();
-  file_util()->Remove(FilePath("/mnt/memory/b"), false /* recursive */,
+  file_util()->Remove(base::FilePath("/mnt/memory/b"), false /* recursive */,
                       GetStatusCallback(request_id1));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE,
             GetStatus(request_id1).result);
 
   // Non-recursively remove empty directory.
 
   request_id1 = GetNextRequestId();
-  file_util()->Remove(FilePath("/mnt/memory/b/d"), false /* recursive */,
+  file_util()->Remove(base::FilePath("/mnt/memory/b/d"), false /* recursive */,
                       GetStatusCallback(request_id1));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
 
   request_id1 = GetNextRequestId();
-  file_util()->GetFileInfo(FilePath("/mnt/memory/b/d"),
+  file_util()->GetFileInfo(base::FilePath("/mnt/memory/b/d"),
                            GetGetFileInfoCallback(request_id1));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, GetStatus(request_id1).result);
 
   // Remove /mnt/memory/b recursively.
 
   request_id1 = GetNextRequestId();
-  file_util()->Remove(FilePath("/mnt/memory/b"), true /* recursive */,
+  file_util()->Remove(base::FilePath("/mnt/memory/b"), true /* recursive */,
                       GetStatusCallback(request_id1));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
 
   // ReadDirectory /mnt/memory/b -> not found
 
   request_id1 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory/b"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory/b"),
                              GetReadDirectoryCallback(request_id1));
   MessageLoop::current()->RunUntilIdle();
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, GetStatus(request_id1).result);
 
   // ReadDirectory /mnt/memory
 
   request_id1 = GetNextRequestId();
-  file_util()->ReadDirectory(FilePath("/mnt/memory"),
+  file_util()->ReadDirectory(base::FilePath("/mnt/memory"),
                              GetReadDirectoryCallback(request_id1));
 
   MessageLoop::current()->RunUntilIdle();
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, GetStatus(request_id1).result);
   status = GetStatus(request_id1);
   ASSERT_TRUE(status.completed);
   ASSERT_FALSE(status.called_after_completed);
   ASSERT_EQ(3u, status.entries.size());
 
@@ skipping 14 matching lines @@
       ASSERT_FALSE(it->is_directory);
       ASSERT_EQ(static_cast<int64>(kTestStringLength), it->size);
     } else {
       LOG(ERROR) << "Unexpected file: " << it->name;
       ASSERT_TRUE(false);
     }
   }
 }
 
 }  // namespace fileapi