Add FilePath to base namespace.

webkit/fileapi/external_mount_points_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 "webkit/fileapi/external_mount_points.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 12 matching lines @@
 namespace {
 
 TEST(ExternalMountPointsTest, AddMountPoint) {
   scoped_refptr<fileapi::ExternalMountPoints> mount_points(
       fileapi::ExternalMountPoints::CreateRefCounted());
 
   struct TestCase {
     // The mount point's name.
     const char* const name;
     // The mount point's path.
-    const FilePath::CharType* const path;
+    const base::FilePath::CharType* const path;
     // Whether the mount point registration should succeed.
     bool success;
     // Path returned by GetRegisteredPath. NULL if the method is expected to
     // fail.
-    const FilePath::CharType* const registered_path;
+    const base::FilePath::CharType* const registered_path;
   };
 
   const TestCase kTestCases[] = {
     // Valid mount point.
     { "test", DRIVE FPL("/foo/test"), true, DRIVE FPL("/foo/test") },
     // Valid mount point with only one path component.
     { "bbb", DRIVE FPL("/bbb"), true, DRIVE FPL("/bbb") },
     // Existing mount point path is substring of the mount points path.
     { "test11", DRIVE FPL("/foo/test11"), true, DRIVE FPL("/foo/test11") },
     // Path substring of an existing path.
@@ skipping 55 matching lines @@
     // Win separators, but relative path.
     { "win2", DRIVE FPL("try\\separators\\win2"), false, NULL },
   };
 
   // Test adding mount points.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     EXPECT_EQ(kTestCases[i].success,
               mount_points->RegisterFileSystem(
                   kTestCases[i].name,
                   fileapi::kFileSystemTypeNativeLocal,
-                  FilePath(kTestCases[i].path)))
+                  base::FilePath(kTestCases[i].path)))
         << "Adding mount point: " << kTestCases[i].name << " with path "
         << kTestCases[i].path;
   }
 
   // Test that final mount point presence state is as expected.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
-    FilePath found_path;
+    base::FilePath found_path;
     EXPECT_EQ(kTestCases[i].registered_path != NULL,
               mount_points->GetRegisteredPath(kTestCases[i].name, &found_path))
         << "Test case: " << i;
 
     if (kTestCases[i].registered_path) {
-      FilePath expected_path(kTestCases[i].registered_path);
+      base::FilePath expected_path(kTestCases[i].registered_path);
       EXPECT_EQ(expected_path.NormalizePathSeparators(), found_path);
     }
   }
 }
 
 TEST(ExternalMountPointsTest, GetVirtualPath) {
   scoped_refptr<fileapi::ExternalMountPoints> mount_points(
       fileapi::ExternalMountPoints::CreateRefCounted());
 
   mount_points->RegisterFileSystem("c",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(DRIVE FPL("/a/b/c")));
+                                   base::FilePath(DRIVE FPL("/a/b/c")));
   // Note that "/a/b/c" < "/a/b/c(1)" < "/a/b/c/".
   mount_points->RegisterFileSystem("c(1)",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(DRIVE FPL("/a/b/c(1)")));
+                                   base::FilePath(DRIVE FPL("/a/b/c(1)")));
   mount_points->RegisterFileSystem("x",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(DRIVE FPL("/z/y/x")));
+                                   base::FilePath(DRIVE FPL("/z/y/x")));
   mount_points->RegisterFileSystem("o",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(DRIVE FPL("/m/n/o")));
+                                   base::FilePath(DRIVE FPL("/m/n/o")));
   // A mount point whose name does not match its path base name.
   mount_points->RegisterFileSystem("mount",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(DRIVE FPL("/root/foo")));
+                                   base::FilePath(DRIVE FPL("/root/foo")));
   // A mount point with an empty path.
   mount_points->RegisterFileSystem("empty_path",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(FPL("")));
+                                   base::FilePath(FPL("")));
 
   struct TestCase {
-    const FilePath::CharType* const local_path;
+    const base::FilePath::CharType* const local_path;
     bool success;
-    const FilePath::CharType* const virtual_path;
+    const base::FilePath::CharType* const virtual_path;
   };
 
   const TestCase kTestCases[] = {
     // Empty path.
     { FPL(""), false, FPL("") },
     // No registered mount point (but is parent to a mount point).
     { DRIVE FPL("/a/b"), false, FPL("") },
     // No registered mount point (but is parent to a mount point).
     { DRIVE FPL("/z/y"), false, FPL("") },
     // No registered mount point (but is parent to a mount point).
@@ skipping 29 matching lines @@
     // separator's.
     { DRIVE FPL("/a/b/c(1)/d/e"), true, FPL("c(1)/d/e") },
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
     // Path with win separators mixed in.
     { DRIVE FPL("/a\\b\\c/d"), true, FPL("c/d") },
 #endif
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     // Initialize virtual path with a value.
-    FilePath virtual_path(DRIVE FPL("/mount"));
-    FilePath local_path(kTestCases[i].local_path);
+    base::FilePath virtual_path(DRIVE FPL("/mount"));
+    base::FilePath local_path(kTestCases[i].local_path);
     EXPECT_EQ(kTestCases[i].success,
               mount_points->GetVirtualPath(local_path, &virtual_path))
         << "Resolving " << kTestCases[i].local_path;
 
     // There are no guarantees for |virtual_path| value if |GetVirtualPath|
     // fails.
     if (!kTestCases[i].success)
       continue;
 
-    FilePath expected_virtual_path(kTestCases[i].virtual_path);
+    base::FilePath expected_virtual_path(kTestCases[i].virtual_path);
     EXPECT_EQ(expected_virtual_path.NormalizePathSeparators(), virtual_path)
         << "Resolving " << kTestCases[i].local_path;
   }
 }
 
 TEST(ExternalMountPointsTest, HandlesFileSystemMountType) {
   scoped_refptr<fileapi::ExternalMountPoints> mount_points(
       fileapi::ExternalMountPoints::CreateRefCounted());
 
   const GURL test_origin("http://chromium.org");
-  const FilePath test_path(FPL("/mount"));
+  const base::FilePath test_path(FPL("/mount"));
 
   // Should handle External File System.
   EXPECT_TRUE(mount_points->HandlesFileSystemMountType(
       fileapi::kFileSystemTypeExternal));
 
   // Shouldn't handle the rest.
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
       fileapi::kFileSystemTypeIsolated));
   EXPECT_FALSE(mount_points->HandlesFileSystemMountType(
       fileapi::kFileSystemTypeTemporary));
@@ skipping 13 matching lines @@
 }
 
 TEST(ExternalMountPointsTest, CreateCrackedFileSystemURL) {
   scoped_refptr<fileapi::ExternalMountPoints> mount_points(
       fileapi::ExternalMountPoints::CreateRefCounted());
 
   const GURL kTestOrigin("http://chromium.org");
 
   mount_points->RegisterFileSystem("c",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(DRIVE FPL("/a/b/c")));
+                                   base::FilePath(DRIVE FPL("/a/b/c")));
   mount_points->RegisterFileSystem("c(1)",
                                    fileapi::kFileSystemTypeDrive,
-                                   FilePath(DRIVE FPL("/a/b/c(1)")));
+                                   base::FilePath(DRIVE FPL("/a/b/c(1)")));
   mount_points->RegisterFileSystem("empty_path",
                                    fileapi::kFileSystemTypeSyncable,
-                                   FilePath(FPL("")));
+                                   base::FilePath(FPL("")));
   mount_points->RegisterFileSystem("mount",
                                    fileapi::kFileSystemTypeDrive,
-                                   FilePath(DRIVE FPL("/root")));
+                                   base::FilePath(DRIVE FPL("/root")));
 
   // Try cracking invalid GURL.
   FileSystemURL invalid = mount_points->CrackURL(GURL("http://chromium.og"));
   EXPECT_FALSE(invalid.is_valid());
 
   // Try cracking isolated path.
   FileSystemURL isolated = mount_points->CreateCrackedFileSystemURL(
-      kTestOrigin, fileapi::kFileSystemTypeIsolated, FilePath(FPL("c")));
+      kTestOrigin, fileapi::kFileSystemTypeIsolated, base::FilePath(FPL("c")));
   EXPECT_FALSE(isolated.is_valid());
 
   // Try native local which is not cracked.
   FileSystemURL native_local = mount_points->CreateCrackedFileSystemURL(
-      kTestOrigin, fileapi::kFileSystemTypeNativeLocal, FilePath(FPL("c")));
+      kTestOrigin, fileapi::kFileSystemTypeNativeLocal, base::FilePath(FPL("c")));
   EXPECT_FALSE(native_local.is_valid());
 
   struct TestCase {
-    const FilePath::CharType* const path;
+    const base::FilePath::CharType* const path;
     bool expect_valid;
     fileapi::FileSystemType expect_type;
-    const FilePath::CharType* const expect_path;
+    const base::FilePath::CharType* const expect_path;
     const char* const expect_fs_id;
   };
 
   const TestCase kTestCases[] = {
     { FPL("c/d/e"),
       true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
     { FPL("c(1)/d/e"),
       true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)/d/e"), "c(1)" },
     { FPL("c(1)"),
       true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"), "c(1)" },
@@ skipping 28 matching lines @@
       true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
     { FPL("mount\\a\\b"),
       true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" },
 #endif
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     FileSystemURL cracked = mount_points->CreateCrackedFileSystemURL(
         kTestOrigin,
         fileapi::kFileSystemTypeExternal,
-        FilePath(kTestCases[i].path));
+        base::FilePath(kTestCases[i].path));
 
     EXPECT_EQ(kTestCases[i].expect_valid, cracked.is_valid())
         << "Test case index: " << i;
 
     if (!kTestCases[i].expect_valid)
       continue;
 
     EXPECT_EQ(kTestOrigin, cracked.origin())
         << "Test case index: " << i;
     EXPECT_EQ(kTestCases[i].expect_type, cracked.type())
         << "Test case index: " << i;
-    EXPECT_EQ(FilePath(kTestCases[i].expect_path).NormalizePathSeparators(),
+    EXPECT_EQ(base::FilePath(kTestCases[i].expect_path).NormalizePathSeparators(),
                        cracked.path())
         << "Test case index: " << i;
-    EXPECT_EQ(FilePath(kTestCases[i].path).NormalizePathSeparators(),
+    EXPECT_EQ(base::FilePath(kTestCases[i].path).NormalizePathSeparators(),
                        cracked.virtual_path())
         << "Test case index: " << i;
     EXPECT_EQ(kTestCases[i].expect_fs_id, cracked.filesystem_id())
         << "Test case index: " << i;
     EXPECT_EQ(fileapi::kFileSystemTypeExternal, cracked.mount_type())
         << "Test case index: " << i;
   }
 }
 
 TEST(ExternalMountPointsTest, CrackVirtualPath) {
   scoped_refptr<fileapi::ExternalMountPoints> mount_points(
       fileapi::ExternalMountPoints::CreateRefCounted());
 
   const GURL kTestOrigin("http://chromium.org");
 
   mount_points->RegisterFileSystem("c",
                                    fileapi::kFileSystemTypeNativeLocal,
-                                   FilePath(DRIVE FPL("/a/b/c")));
+                                   base::FilePath(DRIVE FPL("/a/b/c")));
   mount_points->RegisterFileSystem("c(1)",
                                    fileapi::kFileSystemTypeDrive,
-                                   FilePath(DRIVE FPL("/a/b/c(1)")));
+                                   base::FilePath(DRIVE FPL("/a/b/c(1)")));
   mount_points->RegisterFileSystem("empty_path",
                                    fileapi::kFileSystemTypeSyncable,
-                                   FilePath(FPL("")));
+                                   base::FilePath(FPL("")));
   mount_points->RegisterFileSystem("mount",
                                    fileapi::kFileSystemTypeDrive,
-                                   FilePath(DRIVE FPL("/root")));
+                                   base::FilePath(DRIVE FPL("/root")));
 
   struct TestCase {
-    const FilePath::CharType* const path;
+    const base::FilePath::CharType* const path;
     bool expect_valid;
     fileapi::FileSystemType expect_type;
-    const FilePath::CharType* const expect_path;
+    const base::FilePath::CharType* const expect_path;
     const char* const expect_name;
   };
 
   const TestCase kTestCases[] = {
     { FPL("c/d/e"),
       true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
     { FPL("c(1)/d/e"),
       true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)/d/e"), "c(1)" },
     { FPL("c(1)"),
       true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/a/b/c(1)"), "c(1)" },
@@ skipping 27 matching lines @@
     { FPL("c/d\\e"),
       true, fileapi::kFileSystemTypeNativeLocal, DRIVE FPL("/a/b/c/d/e"), "c" },
     { FPL("mount\\a\\b"),
       true, fileapi::kFileSystemTypeDrive, DRIVE FPL("/root/a/b"), "mount" },
 #endif
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     std::string cracked_name;
     fileapi::FileSystemType cracked_type;
-    FilePath cracked_path;
+    base::FilePath cracked_path;
     EXPECT_EQ(kTestCases[i].expect_valid,
-              mount_points->CrackVirtualPath(FilePath(kTestCases[i].path),
+              mount_points->CrackVirtualPath(base::FilePath(kTestCases[i].path),
                   &cracked_name, &cracked_type, &cracked_path))
         << "Test case index: " << i;
 
     if (!kTestCases[i].expect_valid)
       continue;
 
     EXPECT_EQ(kTestCases[i].expect_type, cracked_type)
         << "Test case index: " << i;
-    EXPECT_EQ(FilePath(kTestCases[i].expect_path).NormalizePathSeparators(),
+    EXPECT_EQ(base::FilePath(kTestCases[i].expect_path).NormalizePathSeparators(),
                        cracked_path)
         << "Test case index: " << i;
     EXPECT_EQ(kTestCases[i].expect_name, cracked_name)
         << "Test case index: " << i;
   }
 }
 
 }  // namespace