Replace FilePath with base::FilePath.

webkit/fileapi/local_file_system_cross_operation_unittest.cc

 // Copyright (c) 2013 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 <map>
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 32 matching lines @@
   ~CrossOperationTestHelper() {
     file_system_context_ = NULL;
     quota_manager_proxy_->SimulateQuotaManagerDestroyed();
     quota_manager_ = NULL;
     quota_manager_proxy_ = NULL;
     MessageLoop::current()->RunUntilIdle();
   }
 
   void SetUp() {
     ASSERT_TRUE(base_.CreateUniqueTempDir());
-    FilePath base_dir = base_.path();
+    base::FilePath base_dir = base_.path();
     quota_manager_ = new quota::MockQuotaManager(
         false /* is_incognito */, base_dir,
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
         NULL /* special storage policy */);
     quota_manager_proxy_ = new quota::MockQuotaManagerProxy(
         quota_manager_,
         base::MessageLoopProxy::current());
     file_system_context_ = new FileSystemContext(
         FileSystemTaskRunners::CreateMockTaskRunners(),
@@ skipping 31 matching lines @@
   }
 
   int64 GetDestUsage() {
     int64 usage = 0;
     GetUsageAndQuota(dest_type_, &usage, NULL);
     return usage;
   }
 
   FileSystemURL SourceURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
-        origin_, src_type_, FilePath::FromUTF8Unsafe(path));
+        origin_, src_type_, base::FilePath::FromUTF8Unsafe(path));
   }
 
   FileSystemURL DestURL(const std::string& path) {
     return file_system_context_->CreateCrackedFileSystemURL(
-        origin_, dest_type_, FilePath::FromUTF8Unsafe(path));
+        origin_, dest_type_, base::FilePath::FromUTF8Unsafe(path));
   }
 
   base::PlatformFileError Copy(const FileSystemURL& src,
                                const FileSystemURL& dest) {
     return AsyncFileTestHelper::Copy(file_system_context_, src, dest);
   }
 
   base::PlatformFileError Move(const FileSystemURL& src,
                                const FileSystemURL& dest) {
     return AsyncFileTestHelper::Move(file_system_context_, src, dest);
@@ skipping 18 matching lines @@
       if (result != base::PLATFORM_FILE_OK)
         return result;
     }
     return result;
   }
 
   void VerifyTestCaseFiles(
       const FileSystemURL& root,
       const test::TestCaseRecord* const test_cases,
       size_t test_case_size) {
-    std::map<FilePath, const test::TestCaseRecord*> test_case_map;
+    std::map<base::FilePath, const test::TestCaseRecord*> test_case_map;
     for (size_t i = 0; i < test_case_size; ++i)
-      test_case_map[FilePath(test_cases[i].path).NormalizePathSeparators()] =
-          &test_cases[i];
+      test_case_map[
+          base::FilePath(test_cases[i].path).NormalizePathSeparators()] =
+              &test_cases[i];
 
     std::queue<FileSystemURL> directories;
     FileEntryList entries;
     directories.push(root);
     while (!directories.empty()) {
       FileSystemURL dir = directories.front();
       directories.pop();
       ASSERT_EQ(base::PLATFORM_FILE_OK, ReadDirectory(dir, &entries));
       for (size_t i = 0; i < entries.size(); ++i) {
         FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
             dir.origin(),
             dir.mount_type(),
             dir.virtual_path().Append(entries[i].name));
-        FilePath relative;
+        base::FilePath relative;
         root.virtual_path().AppendRelativePath(url.virtual_path(), &relative);
         relative = relative.NormalizePathSeparators();
         ASSERT_TRUE(ContainsKey(test_case_map, relative));
         if (entries[i].is_directory) {
           EXPECT_TRUE(test_case_map[relative]->is_directory);
           directories.push(url);
         } else {
           EXPECT_FALSE(test_case_map[relative]->is_directory);
           EXPECT_TRUE(FileExists(url, test_case_map[relative]->data_file_size));
         }
@@ skipping 238 matching lines @@
                              test::kRegularTestCaseSize);
 
   int64 src_new_usage = helper.GetSourceUsage();
   ASSERT_EQ(src_initial_usage, src_new_usage);
 
   int64 dest_increase = helper.GetDestUsage() - dest_initial_usage;
   ASSERT_EQ(src_increase, dest_increase);
 }
 
 }  // namespace fileapi