Add FilePath to base namespace.

webkit/fileapi/file_system_url_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 "webkit/fileapi/file_system_url.h"
 
 #include "base/file_path.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/fileapi/external_mount_points.h"
@@ skipping 23 matching lines @@
     case kFileSystemTypeIsolated:
       return IsolatedContext::GetInstance()->CreateCrackedFileSystemURL(
           url.origin(), url.type(), url.path());
     default:
       return url;
   }
 }
 
 FileSystemURL CreateExternalFileSystemURL(const GURL& origin,
                                           FileSystemType type,
-                                          const FilePath& path) {
+                                          const base::FilePath& path) {
   return ExternalMountPoints::GetSystemInstance()->CreateCrackedFileSystemURL(
       origin, type, path);
 }
 
-std::string NormalizedUTF8Path(const FilePath& path) {
+std::string NormalizedUTF8Path(const base::FilePath& path) {
   return path.NormalizePathSeparators().AsUTF8Unsafe();
 }
 
 }  // namespace
 
 TEST(FileSystemURLTest, ParsePersistent) {
   FileSystemURL url = CreateFileSystemURL(
      "filesystem:http://chromium.org/persistent/directory/file");
   ASSERT_TRUE(url.is_valid());
   EXPECT_EQ("http://chromium.org/", url.origin().spec());
@@ skipping 73 matching lines @@
   const FileSystemURL a = CreateFileSystemURL(
       "filesystem:http://chromium.org/temporary/dir a/file a");
   const FileSystemURL b = CreateFileSystemURL(
       "filesystem:http://chromium.org/persistent/dir a/file a");
   EXPECT_EQ(a.type() < b.type(), compare(a, b));
   EXPECT_EQ(b.type() < a.type(), compare(b, a));
 }
 
 TEST(FileSystemURLTest, WithPath) {
   const GURL kURL("filesystem:http://chromium.org/temporary/dir");
-  const FilePath::StringType paths[] = {
+  const base::FilePath::StringType paths[] = {
       FPL("dir a"),
       FPL("dir a/file 1"),
       FPL("dir a/dir b"),
       FPL("dir a/dir b/file 2"),
   };
 
   const FileSystemURL base = FileSystemURL::CreateForTest(kURL);
   for (size_t i = 0; i < arraysize(paths); ++i) {
-    const FileSystemURL url = base.WithPath(FilePath(paths[i]));
+    const FileSystemURL url = base.WithPath(base::FilePath(paths[i]));
     EXPECT_EQ(paths[i], url.path().value());
     EXPECT_EQ(base.origin().spec(), url.origin().spec());
     EXPECT_EQ(base.type(), url.type());
     EXPECT_EQ(base.mount_type(), url.mount_type());
     EXPECT_EQ(base.filesystem_id(), url.filesystem_id());
   }
 }
 
 TEST(FileSystemURLTest, WithPathForExternal) {
   const std::string kId = "foo";
-  ScopedExternalFileSystem scoped_fs(kId, kFileSystemTypeSyncable, FilePath());
-  const FilePath kVirtualRoot = scoped_fs.GetVirtualRootPath();
+  ScopedExternalFileSystem scoped_fs(kId, kFileSystemTypeSyncable, base::FilePath());
+  const base::FilePath kVirtualRoot = scoped_fs.GetVirtualRootPath();
 
-  const FilePath::CharType kBasePath[] = FPL("dir");
-  const FilePath::StringType paths[] = {
+  const base::FilePath::CharType kBasePath[] = FPL("dir");
+  const base::FilePath::StringType paths[] = {
       FPL("dir a"),
       FPL("dir a/file 1"),
       FPL("dir a/dir b"),
       FPL("dir a/dir b/file 2"),
   };
 
   const FileSystemURL base = FileSystemURL::CreateForTest(
       GURL("http://example.com/"),
       kFileSystemTypeExternal,
       kVirtualRoot.Append(kBasePath));
 
   for (size_t i = 0; i < arraysize(paths); ++i) {
-    const FileSystemURL url = base.WithPath(FilePath(paths[i]));
+    const FileSystemURL url = base.WithPath(base::FilePath(paths[i]));
     EXPECT_EQ(paths[i], url.path().value());
     EXPECT_EQ(base.origin().spec(), url.origin().spec());
     EXPECT_EQ(base.type(), url.type());
     EXPECT_EQ(base.mount_type(), url.mount_type());
     EXPECT_EQ(base.filesystem_id(), url.filesystem_id());
   }
 }
 
 TEST(FileSystemURLTest, IsParent) {
-  ScopedExternalFileSystem scoped1("foo", kFileSystemTypeSyncable, FilePath());
-  ScopedExternalFileSystem scoped2("bar", kFileSystemTypeSyncable, FilePath());
+  ScopedExternalFileSystem scoped1("foo", kFileSystemTypeSyncable, base::FilePath());
+  ScopedExternalFileSystem scoped2("bar", kFileSystemTypeSyncable, base::FilePath());
 
   const std::string root1 = GetFileSystemRootURI(
       GURL("http://example.com"), kFileSystemTypeTemporary).spec();
   const std::string root2 = GetSyncableFileSystemRootURI(
       GURL("http://example.com"), "foo").spec();
   const std::string root3 = GetSyncableFileSystemRootURI(
       GURL("http://example.com"), "bar").spec();
   const std::string root4 = GetFileSystemRootURI(
       GURL("http://chromium.org"), kFileSystemTypeTemporary).spec();
 
@@ skipping 23 matching lines @@
   EXPECT_FALSE(CreateFileSystemURL(root1 + parent).IsParent(
       CreateFileSystemURL(root3 + child)));
 
   // False case: different origins.
   EXPECT_FALSE(CreateFileSystemURL(root1 + parent).IsParent(
       CreateFileSystemURL(root4 + child)));
 }
 
 TEST(FileSystemURLTest, DebugString) {
   const GURL kOrigin("http://example.com");
-  const FilePath kPath(FPL("dir/file"));
+  const base::FilePath kPath(FPL("dir/file"));
 
   const FileSystemURL kURL1 = FileSystemURL::CreateForTest(
       kOrigin, kFileSystemTypeTemporary, kPath);
   EXPECT_EQ("filesystem:http://example.com/temporary/" +
             NormalizedUTF8Path(kPath),
             kURL1.DebugString());
 
-  const FilePath kRoot(DRIVE FPL("/root"));
+  const base::FilePath kRoot(DRIVE FPL("/root"));
   ScopedExternalFileSystem scoped_fs("foo",
                                      kFileSystemTypeNativeLocal,
                                      kRoot.NormalizePathSeparators());
   const FileSystemURL kURL2(CreateExternalFileSystemURL(
       kOrigin,
       kFileSystemTypeExternal,
       scoped_fs.GetVirtualRootPath().Append(kPath)));
   EXPECT_EQ("filesystem:http://example.com/external/" +
             NormalizedUTF8Path(scoped_fs.GetVirtualRootPath().Append(kPath)) +
             " (NativeLocal@foo:" +
             NormalizedUTF8Path(kRoot.Append(kPath)) + ")",
             kURL2.DebugString());
 }
 
 }  // namespace fileapi