Add FilePath to base namespace.

webkit/fileapi/media/native_media_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 "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
@@ skipping 14 matching lines @@
 
 #define FPL(x) FILE_PATH_LITERAL(x)
 
 namespace fileapi {
 
 namespace {
 
 typedef FileSystemOperation::FileEntryList FileEntryList;
 
 struct FilteringTestCase {
-  const FilePath::CharType* path;
+  const base::FilePath::CharType* path;
   bool is_directory;
   bool visible;
 };
 
 const FilteringTestCase kFilteringTestCases[] = {
   // Directory should always be visible.
   { FPL("hoge"), true, true },
   { FPL("fuga.jpg"), true, true },
   { FPL("piyo.txt"), true, true },
   { FPL("moga.cod"), true, true },
 
   // File should be visible if it's a supported media file.
   { FPL("foo"), false, false },  // File without extension.
   { FPL("bar.jpg"), false, true },  // Supported media file.
   { FPL("baz.txt"), false, false },  // Non-media file.
   { FPL("foobar.cod"), false, false },  // Unsupported media file.
 };
 
 void ExpectEqHelper(const std::string& test_name,
                     base::PlatformFileError expected,
                     base::PlatformFileError actual) {
   EXPECT_EQ(expected, actual) << test_name;
 }
 
 void ExpectMetadataEqHelper(const std::string& test_name,
                             base::PlatformFileError expected,
                             bool expected_is_directory,
                             base::PlatformFileError actual,
                             const base::PlatformFileInfo& file_info,
-                            const FilePath& /*platform_path*/) {
+                            const base::FilePath& /*platform_path*/) {
   EXPECT_EQ(expected, actual) << test_name;
   if (actual == base::PLATFORM_FILE_OK)
     EXPECT_EQ(expected_is_directory, file_info.is_directory) << test_name;
 }
 
-void DidReadDirectory(std::set<FilePath::StringType>* content,
+void DidReadDirectory(std::set<base::FilePath::StringType>* content,
                       bool* completed,
                       base::PlatformFileError error,
                       const FileEntryList& file_list,
                       bool has_more) {
   EXPECT_TRUE(!*completed);
   *completed = !has_more;
   for (FileEntryList::const_iterator itr = file_list.begin();
        itr != file_list.end(); ++itr)
     EXPECT_TRUE(content->insert(itr->name).second);
 }
 
-void PopulateDirectoryWithTestCases(const FilePath& dir,
+void PopulateDirectoryWithTestCases(const base::FilePath& dir,
                                     const FilteringTestCase* test_cases,
                                     size_t n) {
   for (size_t i = 0; i < n; ++i) {
-    FilePath path = dir.Append(test_cases[i].path);
+    base::FilePath path = dir.Append(test_cases[i].path);
     if (test_cases[i].is_directory) {
       ASSERT_TRUE(file_util::CreateDirectory(path));
     } else {
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
                 NativeFileUtil::EnsureFileExists(path, &created));
       ASSERT_TRUE(created);
     }
   }
 }
@@ skipping 33 matching lines @@
   void TearDown() {
     isolated_context()->RemoveReference(filesystem_id_);
     file_system_context_ = NULL;
   }
 
  protected:
   FileSystemContext* file_system_context() {
     return file_system_context_.get();
   }
 
-  FileSystemURL CreateURL(const FilePath::CharType* test_case_path) {
+  FileSystemURL CreateURL(const base::FilePath::CharType* test_case_path) {
     return file_system_context_->CreateCrackedFileSystemURL(
         origin(),
         fileapi::kFileSystemTypeIsolated,
         GetVirtualPath(test_case_path));
   }
 
   IsolatedContext* isolated_context() {
     return IsolatedContext::GetInstance();
   }
 
-  FilePath root_path() {
+  base::FilePath root_path() {
     return data_dir_.path().Append(FPL("Media Directory"));
   }
 
-  FilePath GetVirtualPath(const FilePath::CharType* test_case_path) {
-    return FilePath::FromUTF8Unsafe(filesystem_id_).
+  base::FilePath GetVirtualPath(const base::FilePath::CharType* test_case_path) {
+    return base::FilePath::FromUTF8Unsafe(filesystem_id_).
                Append(FPL("Media Directory")).
-               Append(FilePath(test_case_path));
+               Append(base::FilePath(test_case_path));
   }
 
   FileSystemFileUtil* file_util() {
     return file_util_;
   }
 
   GURL origin() {
     return GURL("http://example.com");
   }
 
@@ skipping 42 matching lines @@
     }
     MessageLoop::current()->RunUntilIdle();
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, ReadDirectoryFiltering) {
   PopulateDirectoryWithTestCases(root_path(),
                                  kFilteringTestCases,
                                  arraysize(kFilteringTestCases));
 
-  std::set<FilePath::StringType> content;
+  std::set<base::FilePath::StringType> content;
   FileSystemURL url = CreateURL(FPL(""));
   bool completed = false;
   NewOperation(url)->ReadDirectory(
       url, base::Bind(&DidReadDirectory, &content, &completed));
   MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(completed);
   EXPECT_EQ(5u, content.size());
 
   for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
-    FilePath::StringType name =
-        FilePath(kFilteringTestCases[i].path).BaseName().value();
-    std::set<FilePath::StringType>::const_iterator found = content.find(name);
+    base::FilePath::StringType name =
+        base::FilePath(kFilteringTestCases[i].path).BaseName().value();
+    std::set<base::FilePath::StringType>::const_iterator found = content.find(name);
     EXPECT_EQ(kFilteringTestCases[i].visible, found != content.end());
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, CreateFileAndCreateDirectoryFiltering) {
   // Run the loop twice. The second loop attempts to create files that are
   // pre-existing. Though the result should be the same.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       FileSystemURL root_url = CreateURL(FPL(""));
@@ skipping 15 matching lines @@
       } else {
         operation->CreateFile(
             url, false, base::Bind(&ExpectEqHelper, test_name, expectation));
       }
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, CopySourceFiltering) {
-  FilePath dest_path = root_path().AppendASCII("dest");
+  base::FilePath dest_path = root_path().AppendASCII("dest");
   FileSystemURL dest_url = CreateURL(FPL("dest"));
 
   // Run the loop twice. The first run has no source files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
@@ skipping 32 matching lines @@
       // Reset the test directory between the two loops to remove old
       // directories and create new ones that should pre-exist.
       ASSERT_TRUE(file_util::Delete(root_path(), true));
       ASSERT_TRUE(file_util::CreateDirectory(root_path()));
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
 
     // Always create a dummy source data file.
-    FilePath src_path = root_path().AppendASCII("foo.jpg");
+    base::FilePath src_path = root_path().AppendASCII("foo.jpg");
     FileSystemURL src_url = CreateURL(FPL("foo.jpg"));
     static const char kDummyData[] = "dummy";
     ASSERT_TRUE(file_util::WriteFile(src_path, kDummyData, strlen(kDummyData)));
 
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       if (loop_count == 0 && kFilteringTestCases[i].is_directory) {
         // These directories do not exist in this case, so Copy() will not
         // treat them as directories. Thus invalidating these test cases.
         // Continue now to avoid creating a new |operation| below that goes
         // unused.
@@ skipping 31 matching lines @@
         }
       }
       operation->Copy(
           src_url, url, base::Bind(&ExpectEqHelper, test_name, expectation));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 TEST_F(NativeMediaFileUtilTest, MoveSourceFiltering) {
-  FilePath dest_path = root_path().AppendASCII("dest");
+  base::FilePath dest_path = root_path().AppendASCII("dest");
   FileSystemURL dest_url = CreateURL(FPL("dest"));
 
   // Run the loop twice. The first run has no source files. The second run does.
   for (int loop_count = 0; loop_count < 2; ++loop_count) {
     if (loop_count == 1) {
       PopulateDirectoryWithTestCases(root_path(),
                                      kFilteringTestCases,
                                      arraysize(kFilteringTestCases));
     }
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
@@ skipping 41 matching lines @@
     for (size_t i = 0; i < arraysize(kFilteringTestCases); ++i) {
       if (loop_count == 0 && kFilteringTestCases[i].is_directory) {
         // These directories do not exist in this case, so Copy() will not
         // treat them as directories. Thus invalidating these test cases.
         // Continue now to avoid creating a new |operation| below that goes
         // unused.
         continue;
       }
 
       // Create the source file for every test case because it might get moved.
-      FilePath src_path = root_path().AppendASCII("foo.jpg");
+      base::FilePath src_path = root_path().AppendASCII("foo.jpg");
       FileSystemURL src_url = CreateURL(FPL("foo.jpg"));
       static const char kDummyData[] = "dummy";
       ASSERT_TRUE(
           file_util::WriteFile(src_path, kDummyData, strlen(kDummyData)));
 
       FileSystemURL root_url = CreateURL(FPL(""));
       FileSystemOperation* operation = NewOperation(root_url);
 
       FileSystemURL url = CreateURL(kFilteringTestCases[i].path);
 
@@ skipping 144 matching lines @@
         expectation = base::PLATFORM_FILE_ERROR_FAILED;
       }
       operation->TouchFile(
           url, time, time, base::Bind(&ExpectEqHelper, test_name, expectation));
       MessageLoop::current()->RunUntilIdle();
     }
   }
 }
 
 }  // namespace fileapi