Add FilePath to base namespace.

webkit/fileapi/obfuscated_file_util_unittest.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 <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 15 matching lines @@
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/test_file_set.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
 
 namespace {
 
-bool FileExists(const FilePath& path) {
+bool FileExists(const base::FilePath& path) {
   return file_util::PathExists(path) && !file_util::DirectoryExists(path);
 }
 
-int64 GetSize(const FilePath& path) {
+int64 GetSize(const base::FilePath& path) {
   int64 size;
   EXPECT_TRUE(file_util::GetFileSize(path, &size));
   return size;
 }
 
 // After a move, the dest exists and the source doesn't.
 // After a copy, both source and dest exist.
 struct CopyMoveTestCaseRecord {
   bool is_copy_not_move;
   const char source_path[64];
@@ skipping 133 matching lines @@
         new LocalFileSystemTestOriginHelper(origin, type);
 
     helper->SetUp(file_system_context_.get());
     return helper;
   }
 
   ObfuscatedFileUtil* ofu() {
     return static_cast<ObfuscatedFileUtil*>(test_helper_.file_util());
   }
 
-  const FilePath& test_directory() const {
+  const base::FilePath& test_directory() const {
     return data_dir_.path();
   }
 
   const GURL& origin() const {
     return origin_;
   }
 
   fileapi::FileSystemType type() const {
     return type_;
   }
@@ skipping 22 matching lines @@
   }
 
   int64 SizeInUsageFile() {
     MessageLoop::current()->RunUntilIdle();
     return FileSystemUsageCache::GetUsage(test_helper_.GetUsageCachePath());
   }
 
   bool PathExists(const FileSystemURL& url) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     base::PlatformFileInfo file_info;
-    FilePath platform_path;
+    base::FilePath platform_path;
     base::PlatformFileError error = ofu()->GetFileInfo(
         context.get(), url, &file_info, &platform_path);
     return error == base::PLATFORM_FILE_OK;
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     return FileUtilHelper::DirectoryExists(context.get(), ofu(), url);
   }
 
   int64 usage() const { return usage_; }
 
   FileSystemURL CreateURLFromUTF8(const std::string& path) {
     return test_helper_.CreateURLFromUTF8(path);
   }
 
   int64 PathCost(const FileSystemURL& url) {
     return ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   }
 
-  FileSystemURL CreateURL(const FilePath& path) {
+  FileSystemURL CreateURL(const base::FilePath& path) {
     return test_helper_.CreateURL(path);
   }
 
   void OnGetUsage(quota::QuotaStatusCode status, int64 usage, int64 unused) {
     EXPECT_EQ(quota::kQuotaStatusOk, status);
     quota_status_ = status;
     usage_ = usage;
   }
 
   void CheckFileAndCloseHandle(
       const FileSystemURL& url, base::PlatformFile file_handle) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
-    FilePath local_path;
+    base::FilePath local_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
         context.get(), url, &local_path));
 
     base::PlatformFileInfo file_info0;
-    FilePath data_path;
+    base::FilePath data_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), url, &file_info0, &data_path));
     EXPECT_EQ(data_path, local_path);
     EXPECT_TRUE(FileExists(data_path));
     EXPECT_EQ(0, GetSize(data_path));
 
     const char data[] = "test data";
     const int length = arraysize(data) - 1;
 
     if (base::kInvalidPlatformFileValue == file_handle) {
@@ skipping 32 matching lines @@
     EXPECT_EQ(length * 2, GetSize(data_path));
 
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
         context.get(), url, 0));
     EXPECT_EQ(0, GetSize(data_path));
   }
 
   void ValidateTestDirectory(
       const FileSystemURL& root_url,
-      const std::set<FilePath::StringType>& files,
-      const std::set<FilePath::StringType>& directories) {
+      const std::set<base::FilePath::StringType>& files,
+      const std::set<base::FilePath::StringType>& directories) {
     scoped_ptr<FileSystemOperationContext> context;
-    std::set<FilePath::StringType>::const_iterator iter;
+    std::set<base::FilePath::StringType>::const_iterator iter;
     for (iter = files.begin(); iter != files.end(); ++iter) {
       bool created = true;
       context.reset(NewContext(NULL));
       ASSERT_EQ(base::PLATFORM_FILE_OK,
           ofu()->EnsureFileExists(
               context.get(), root_url.WithPath(root_url.path().Append(*iter)),
               &created));
       ASSERT_FALSE(created);
     }
     for (iter = directories.begin(); iter != directories.end(); ++iter) {
@@ skipping 40 matching lines @@
   }
 
   scoped_ptr<UsageVerifyHelper> DisallowUsageIncrease(int64 requested_growth) {
     int64 usage = test_helper_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
         LimitedContext(requested_growth - 1), &test_helper_, usage));
   }
 
   void FillTestDirectory(
       const FileSystemURL& root_url,
-      std::set<FilePath::StringType>* files,
-      std::set<FilePath::StringType>* directories) {
+      std::set<base::FilePath::StringType>* files,
+      std::set<base::FilePath::StringType>* directories) {
     scoped_ptr<FileSystemOperationContext> context;
     context.reset(NewContext(NULL));
     std::vector<base::FileUtilProxy::Entry> entries;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               FileUtilHelper::ReadDirectory(
                   context.get(), ofu(), root_url, &entries));
     EXPECT_EQ(0UL, entries.size());
 
     files->clear();
     files->insert(FILE_PATH_LITERAL("first"));
     files->insert(FILE_PATH_LITERAL("second"));
     files->insert(FILE_PATH_LITERAL("third"));
     directories->clear();
     directories->insert(FILE_PATH_LITERAL("fourth"));
     directories->insert(FILE_PATH_LITERAL("fifth"));
     directories->insert(FILE_PATH_LITERAL("sixth"));
-    std::set<FilePath::StringType>::iterator iter;
+    std::set<base::FilePath::StringType>::iterator iter;
     for (iter = files->begin(); iter != files->end(); ++iter) {
       bool created = false;
       context.reset(NewContext(NULL));
       ASSERT_EQ(base::PLATFORM_FILE_OK,
           ofu()->EnsureFileExists(
               context.get(),
               root_url.WithPath(root_url.path().Append(*iter)),
               &created));
       ASSERT_TRUE(created);
     }
     for (iter = directories->begin(); iter != directories->end(); ++iter) {
       bool exclusive = true;
       bool recursive = false;
       context.reset(NewContext(NULL));
       EXPECT_EQ(base::PLATFORM_FILE_OK,
           ofu()->CreateDirectory(
               context.get(), root_url.WithPath(root_url.path().Append(*iter)),
               exclusive, recursive));
     }
     ValidateTestDirectory(root_url, *files, *directories);
   }
 
   void TestReadDirectoryHelper(const FileSystemURL& root_url) {
-    std::set<FilePath::StringType> files;
-    std::set<FilePath::StringType> directories;
+    std::set<base::FilePath::StringType> files;
+    std::set<base::FilePath::StringType> directories;
     FillTestDirectory(root_url, &files, &directories);
 
     scoped_ptr<FileSystemOperationContext> context;
     std::vector<base::FileUtilProxy::Entry> entries;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               FileUtilHelper::ReadDirectory(
                   context.get(), ofu(), root_url, &entries));
     std::vector<base::FileUtilProxy::Entry>::iterator entry_iter;
     EXPECT_EQ(files.size() + directories.size(), entries.size());
     EXPECT_TRUE(change_observer()->HasNoChange());
     for (entry_iter = entries.begin(); entry_iter != entries.end();
         ++entry_iter) {
       const base::FileUtilProxy::Entry& entry = *entry_iter;
-      std::set<FilePath::StringType>::iterator iter = files.find(entry.name);
+      std::set<base::FilePath::StringType>::iterator iter = files.find(entry.name);
       if (iter != files.end()) {
         EXPECT_FALSE(entry.is_directory);
         files.erase(iter);
         continue;
       }
       iter = directories.find(entry.name);
       EXPECT_FALSE(directories.end() == iter);
       EXPECT_TRUE(entry.is_directory);
       directories.erase(iter);
     }
   }
 
   void TestTouchHelper(const FileSystemURL& url, bool is_file) {
     base::Time last_access_time = base::Time::Now();
     base::Time last_modified_time = base::Time::Now();
 
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->Touch(
                   context.get(), url, last_access_time, last_modified_time));
     // Currently we fire no change notifications for Touch.
     EXPECT_TRUE(change_observer()->HasNoChange());
-    FilePath local_path;
+    base::FilePath local_path;
     base::PlatformFileInfo file_info;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), url, &file_info, &local_path));
     // We compare as time_t here to lower our resolution, to avoid false
     // negatives caused by conversion to the local filesystem's native
     // representation and back.
     EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT());
 
     context.reset(NewContext(NULL));
     last_modified_time += base::TimeDelta::FromHours(1);
     last_access_time += base::TimeDelta::FromHours(14);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->Touch(
                   context.get(), url, last_access_time, last_modified_time));
     EXPECT_TRUE(change_observer()->HasNoChange());
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), url, &file_info, &local_path));
     EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT());
     if (is_file)  // Directories in OFU don't support atime.
       EXPECT_EQ(file_info.last_accessed.ToTimeT(), last_access_time.ToTimeT());
   }
 
   void TestCopyInForeignFileHelper(bool overwrite) {
     base::ScopedTempDir source_dir;
     ASSERT_TRUE(source_dir.CreateUniqueTempDir());
-    FilePath root_file_path = source_dir.path();
-    FilePath src_file_path = root_file_path.AppendASCII("file_name");
+    base::FilePath root_file_path = source_dir.path();
+    base::FilePath src_file_path = root_file_path.AppendASCII("file_name");
     FileSystemURL dest_url = CreateURLFromUTF8("new file");
     int64 src_file_length = 87;
 
     base::PlatformFileError error_code;
     bool created = false;
     int file_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE;
     base::PlatformFile file_handle =
         base::CreatePlatformFile(
             src_file_path, file_flags, &created, &error_code);
     EXPECT_TRUE(created);
@@ skipping 30 matching lines @@
     context->set_allowed_bytes_growth(path_cost + src_file_length);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->CopyInForeignFile(context.get(),
                                        src_file_path, dest_url));
 
     EXPECT_TRUE(PathExists(dest_url));
     EXPECT_FALSE(DirectoryExists(dest_url));
 
     context.reset(NewContext(NULL));
     base::PlatformFileInfo file_info;
-    FilePath data_path;
+    base::FilePath data_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), dest_url, &file_info, &data_path));
     EXPECT_NE(data_path, src_file_path);
     EXPECT_TRUE(FileExists(data_path));
     EXPECT_EQ(src_file_length, GetSize(data_path));
 
     EXPECT_EQ(base::PLATFORM_FILE_OK,
         ofu()->DeleteFile(context.get(), dest_url));
   }
 
   void ClearTimestamp(const FileSystemURL& url) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->Touch(context.get(), url, base::Time(), base::Time()));
     EXPECT_EQ(base::Time(), GetModifiedTime(url));
   }
 
   base::Time GetModifiedTime(const FileSystemURL& url) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
-    FilePath data_path;
+    base::FilePath data_path;
     base::PlatformFileInfo file_info;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->GetFileInfo(context.get(), url, &file_info, &data_path));
     EXPECT_TRUE(change_observer()->HasNoChange());
     return file_info.last_modified;
   }
 
   void TestDirectoryTimestampHelper(const FileSystemURL& base_dir,
                                     bool copy,
@@ skipping 101 matching lines @@
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CreateOrOpen(
                 context.get(), url, file_flags, &file_handle, &created));
   ASSERT_TRUE(created);
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count());
   EXPECT_NE(base::kInvalidPlatformFileValue, file_handle);
 
   CheckFileAndCloseHandle(url, file_handle);
 
   context.reset(NewContext(NULL));
-  FilePath local_path;
+  base::FilePath local_path;
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
       context.get(), url, &local_path));
   EXPECT_TRUE(file_util::PathExists(local_path));
 
   // Verify that deleting a file isn't stopped by zero quota, and that it frees
   // up quote from its path.
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(0);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->DeleteFile(context.get(), url));
@@ skipping 47 matching lines @@
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
             ofu()->Truncate(context.get(), url, 4));
 
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
       ofu()->EnsureFileExists(context.get(), url, &created));
   ASSERT_TRUE(created);
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_count());
 
   context.reset(NewContext(NULL));
-  FilePath local_path;
+  base::FilePath local_path;
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
       context.get(), url, &local_path));
   EXPECT_EQ(0, GetSize(local_path));
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
       context.get(), url, 10));
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_EQ(10, GetSize(local_path));
 
@@ skipping 55 matching lines @@
   {
     scoped_ptr<UsageVerifyHelper> helper = AllowUsageIncrease(-1);
     helper->context()->set_allowed_bytes_growth(
         helper->context()->allowed_bytes_growth() - 1);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->Truncate(helper->context(), url, 1019));
     ASSERT_EQ(1019, ComputeTotalFileSize());
   }
 
   // Delete backing file to make following truncation fail.
-  FilePath local_path;
+  base::FilePath local_path;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetLocalFilePath(
                 UnlimitedContext().get(),
                 url, &local_path));
   ASSERT_FALSE(local_path.empty());
   ASSERT_TRUE(file_util::Delete(local_path, false));
 
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
             ofu()->Truncate(
                 LimitedContext(1234).get(),
@@ skipping 96 matching lines @@
                                        url.WithPath(url.path().DirName())));
 
   // Can't remove a non-empty directory.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY,
       ofu()->DeleteDirectory(context.get(),
                              url.WithPath(url.path().DirName())));
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   base::PlatformFileInfo file_info;
-  FilePath local_path;
+  base::FilePath local_path;
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
       context.get(), url, &file_info, &local_path));
   EXPECT_TRUE(local_path.empty());
   EXPECT_TRUE(file_info.is_directory);
   EXPECT_FALSE(file_info.is_symbolic_link);
 
   // Same create again should succeed, since exclusive is false.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
@@ skipping 163 matching lines @@
   EXPECT_EQ(base::PLATFORM_FILE_OK,
       ofu()->EnsureFileExists(context.get(), url, &created));
   EXPECT_TRUE(created);
   int64 path_cost = ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth());
 
   context->set_allowed_bytes_growth(1024);
   bool exclusive = true;
   bool recursive = true;
   url = CreateURLFromUTF8("directory/to/use");
-  std::vector<FilePath::StringType> components;
+  std::vector<base::FilePath::StringType> components;
   url.path().GetComponents(&components);
   path_cost = 0;
-  for (std::vector<FilePath::StringType>::iterator iter = components.begin();
+  for (std::vector<base::FilePath::StringType>::iterator iter = components.begin();
       iter != components.end(); ++iter) {
     path_cost += ObfuscatedFileUtil::ComputeFilePathCost(
-        FilePath(*iter));
+        base::FilePath(*iter));
   }
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(1024);
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
   EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth());
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) {
   FileSystemURL source_url = CreateURLFromUTF8("path0.txt");
@@ skipping 85 matching lines @@
       ASSERT_EQ(base::PLATFORM_FILE_OK,
                 ofu()->Truncate(context.get(), dest_url, kDestLength));
     }
 
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CopyOrMoveFile(context.get(),
         source_url, dest_url, test_case.is_copy_not_move));
 
     if (test_case.is_copy_not_move) {
       base::PlatformFileInfo file_info;
-      FilePath local_path;
+      base::FilePath local_path;
       context.reset(NewContext(NULL));
       EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
           context.get(), source_url, &file_info, &local_path));
       EXPECT_EQ(kSourceLength, file_info.size);
       EXPECT_EQ(base::PLATFORM_FILE_OK,
                 ofu()->DeleteFile(context.get(), source_url));
     } else {
       base::PlatformFileInfo file_info;
-      FilePath local_path;
+      base::FilePath local_path;
       context.reset(NewContext(NULL));
       EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->GetFileInfo(
           context.get(), source_url, &file_info, &local_path));
     }
     base::PlatformFileInfo file_info;
-    FilePath local_path;
+    base::FilePath local_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), dest_url, &file_info, &local_path));
     EXPECT_EQ(kSourceLength, file_info.size);
 
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->DeleteFile(context.get(), dest_url));
   }
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) {
@@ skipping 103 matching lines @@
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestEnumerator) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   FileSystemURL src_url = CreateURLFromUTF8("source dir");
   bool exclusive = true;
   bool recursive = false;
   ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), src_url, exclusive, recursive));
 
-  std::set<FilePath::StringType> files;
-  std::set<FilePath::StringType> directories;
+  std::set<base::FilePath::StringType> files;
+  std::set<base::FilePath::StringType> directories;
   FillTestDirectory(src_url, &files, &directories);
 
   FileSystemURL dest_url = CreateURLFromUTF8("destination dir");
 
   EXPECT_FALSE(DirectoryExists(dest_url));
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             test_helper().SameFileUtilCopy(context.get(), src_url, dest_url));
 
   ValidateTestDirectory(dest_url, files, directories);
@@ skipping 94 matching lines @@
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   int64 expected_quota = 0;
 
   for (size_t i = 0; i < test::kRegularTestCaseSize; ++i) {
     SCOPED_TRACE(testing::Message() << "Creating kRegularTestCase " << i);
     const test::TestCaseRecord& test_case = test::kRegularTestCases[i];
-    FilePath file_path(test_case.path);
+    base::FilePath file_path(test_case.path);
     expected_quota += ObfuscatedFileUtil::ComputeFilePathCost(file_path);
     if (test_case.is_directory) {
       bool exclusive = true;
       bool recursive = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
           ofu()->CreateDirectory(context.get(), CreateURL(file_path),
                                  exclusive, recursive));
     } else {
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
@@ skipping 24 matching lines @@
   EXPECT_EQ(expected_quota, usage());
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestInconsistency) {
   const FileSystemURL kPath1 = CreateURLFromUTF8("hoge");
   const FileSystemURL kPath2 = CreateURLFromUTF8("fuga");
 
   scoped_ptr<FileSystemOperationContext> context;
   base::PlatformFile file;
   base::PlatformFileInfo file_info;
-  FilePath data_path;
+  base::FilePath data_path;
   bool created = false;
 
   // Create a non-empty file.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->EnsureFileExists(context.get(), kPath1, &created));
   EXPECT_TRUE(created);
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->Truncate(context.get(), kPath1, 10));
@@ skipping 54 matching lines @@
   EXPECT_EQ(0, file_info.size);
   EXPECT_TRUE(base::ClosePlatformFile(file));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) {
   const FileSystemURL kPath[] = {
     CreateURLFromUTF8("foo"),
     CreateURLFromUTF8("bar"),
     CreateURLFromUTF8("baz")
   };
-  const FileSystemURL empty_path = CreateURL(FilePath());
+  const FileSystemURL empty_path = CreateURL(base::FilePath());
   scoped_ptr<FileSystemOperationContext> context;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPath); ++i) {
     bool created = false;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->EnsureFileExists(context.get(), kPath[i], &created));
     EXPECT_TRUE(created);
   }
 
   context.reset(NewContext(NULL));
   std::vector<base::FileUtilProxy::Entry> entries;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             FileUtilHelper::ReadDirectory(
                 context.get(), ofu(), empty_path, &entries));
   EXPECT_EQ(3u, entries.size());
 
   context.reset(NewContext(NULL));
-  FilePath local_path;
+  base::FilePath local_path;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetLocalFilePath(context.get(), kPath[0], &local_path));
   EXPECT_TRUE(file_util::Delete(local_path, false));
 
   context.reset(NewContext(NULL));
   entries.clear();
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             FileUtilHelper::ReadDirectory(
                 context.get(), ofu(), empty_path, &entries));
   EXPECT_EQ(ARRAYSIZE_UNSAFE(kPath) - 1, entries.size());
@@ skipping 115 matching lines @@
   EXPECT_EQ(base::Time(), GetModifiedTime(dir_url));
 
   // CopyInForeignFile, create case.
   url = dir_url.WithPath(dir_url.path().AppendASCII("CopyInForeignFile_file"));
   FileSystemURL src_path = dir_url.WithPath(
       dir_url.path().AppendASCII("CopyInForeignFile_src_file"));
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->EnsureFileExists(context.get(), src_path, &created));
   EXPECT_TRUE(created);
-  FilePath src_local_path;
+  base::FilePath src_local_path;
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetLocalFilePath(context.get(), src_path, &src_local_path));
 
   ClearTimestamp(dir_url);
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CopyInForeignFile(context.get(),
                                      src_local_path,
                                      url));
@@ skipping 82 matching lines @@
   bool created = false;
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->EnsureFileExists(context.get(), url1, &created));
   EXPECT_TRUE(created);
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CreateDirectory(context.get(), url2, false, false));
 
-  FilePath file_path;
+  base::FilePath file_path;
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetLocalFilePath(context.get(), url1, &file_path));
   EXPECT_FALSE(file_path.empty());
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->Touch(context.get(), url1,
                          base::Time::Now() + base::TimeDelta::FromHours(1),
                          base::Time()));
 
   context.reset(NewContext(NULL));
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       ofu()->CreateFileEnumerator(context.get(), dir, false));
 
   int count = 0;
-  FilePath file_path_each;
+  base::FilePath file_path_each;
   while (!(file_path_each = file_enum->Next()).empty()) {
     context.reset(NewContext(NULL));
     base::PlatformFileInfo file_info;
-    FilePath file_path;
+    base::FilePath file_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->GetFileInfo(context.get(),
                                  dir.WithPath(file_path_each),
                                  &file_info, &file_path));
     EXPECT_EQ(file_info.is_directory, file_enum->IsDirectory());
     EXPECT_EQ(file_info.last_modified, file_enum->LastModifiedTime());
     EXPECT_EQ(file_info.size, file_enum->Size());
     ++count;
   }
   EXPECT_EQ(2, count);
@@ skipping 307 matching lines @@
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CreateOrOpen(
                 AllowUsageIncrease(-length)->context(), file,
                 base::PLATFORM_FILE_OPEN_TRUNCATED | base::PLATFORM_FILE_WRITE,
                 &file_handle, &created));
   ASSERT_EQ(0, ComputeTotalFileSize());
   EXPECT_TRUE(base::ClosePlatformFile(file_handle));
 }
 
 }  // namespace fileapi