Add FilePath to base namespace.

webkit/fileapi/file_system_mount_point_provider_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/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 70 matching lines @@
   const char* expected_path;
   const char* virtual_path;
 } kRootPathFileURITestCases[] = {
   { fileapi::kFileSystemTypeTemporary, "file:///",
     "000" PS "t", NULL },
   { fileapi::kFileSystemTypePersistent, "file:///",
     "000" PS "p", NULL },
 };
 
 const struct CheckValidPathTest {
-  FilePath::StringType path;
+  base::FilePath::StringType path;
   bool expected_valid;
 } kCheckValidPathTestCases[] = {
   { FILE_PATH_LITERAL("//tmp/foo.txt"), false, },
   { FILE_PATH_LITERAL("//etc/hosts"), false, },
   { FILE_PATH_LITERAL("foo.txt"), true, },
   { FILE_PATH_LITERAL("a/b/c"), true, },
   // Any paths that includes parent references are considered invalid.
   { FILE_PATH_LITERAL(".."), false, },
   { FILE_PATH_LITERAL("tmp/.."), false, },
   { FILE_PATH_LITERAL("a/b/../c/.."), false, },
 };
 
 const struct IsRestrictedNameTest {
-  FilePath::StringType name;
+  base::FilePath::StringType name;
   bool expected_dangerous;
 } kIsRestrictedNameTestCases[] = {
   // Names that contain strings that used to be restricted, but are now allowed.
   { FILE_PATH_LITERAL("con"), false, },
   { FILE_PATH_LITERAL("Con.txt"), false, },
   { FILE_PATH_LITERAL("Prn.png"), false, },
   { FILE_PATH_LITERAL("AUX"), false, },
   { FILE_PATH_LITERAL("nUl."), false, },
   { FILE_PATH_LITERAL("coM1"), false, },
   { FILE_PATH_LITERAL("COM3.com"), false, },
@@ skipping 70 matching lines @@
   { FILE_PATH_LITERAL(". "), false, },
   { FILE_PATH_LITERAL(" . "), false, },
   { FILE_PATH_LITERAL(" .."), false, },
   { FILE_PATH_LITERAL(".. "), false, },
   { FILE_PATH_LITERAL(" .. "), false, },
   { FILE_PATH_LITERAL("b."), false, },
   { FILE_PATH_LITERAL(".b"), false, },
 };
 
 // For External filesystem.
-const FilePath::CharType kMountPoint[] = FILE_PATH_LITERAL("/tmp/testing");
-const FilePath::CharType kRootPath[] = FILE_PATH_LITERAL("/tmp");
-const FilePath::CharType kVirtualPath[] = FILE_PATH_LITERAL("testing");
+const base::FilePath::CharType kMountPoint[] = FILE_PATH_LITERAL("/tmp/testing");
+const base::FilePath::CharType kRootPath[] = FILE_PATH_LITERAL("/tmp");
+const base::FilePath::CharType kVirtualPath[] = FILE_PATH_LITERAL("testing");
 
 }  // namespace
 
 class FileSystemMountPointProviderTest : public testing::Test {
  public:
   FileSystemMountPointProviderTest()
       : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     special_storage_policy_ = new quota::MockSpecialStoragePolicy;
   }
 
  protected:
   void SetupNewContext(const FileSystemOptions& options) {
     scoped_refptr<ExternalMountPoints> external_mount_points(
         ExternalMountPoints::CreateRefCounted());
     file_system_context_ = new FileSystemContext(
         FileSystemTaskRunners::CreateMockTaskRunners(),
         external_mount_points.get(),
         special_storage_policy_,
         NULL,
         data_dir_.path(),
         options);
 #if defined(OS_CHROMEOS)
-    FilePath mount_point_path = FilePath(kMountPoint);
+    base::FilePath mount_point_path = base::FilePath(kMountPoint);
     external_mount_points->RegisterFileSystem(
         mount_point_path.BaseName().AsUTF8Unsafe(),
         kFileSystemTypeNativeLocal,
         mount_point_path);
 #endif
   }
 
   FileSystemMountPointProvider* provider(FileSystemType type) {
     DCHECK(file_system_context_);
     return file_system_context_->GetMountPointProvider(type);
   }
 
   bool GetRootPath(const GURL& origin_url,
                    fileapi::FileSystemType type,
                    bool create,
-                   FilePath* root_path) {
-    FilePath virtual_path = FilePath();
+                   base::FilePath* root_path) {
+    base::FilePath virtual_path = base::FilePath();
     if (type == kFileSystemTypeExternal)
-      virtual_path = FilePath(kVirtualPath);
+      virtual_path = base::FilePath(kVirtualPath);
     FileSystemURL url = file_system_context_->CreateCrackedFileSystemURL(
         origin_url, type, virtual_path);
-    FilePath returned_root_path =
+    base::FilePath returned_root_path =
         provider(type)->GetFileSystemRootPathOnFileThread(url, create);
     if (root_path)
       *root_path = returned_root_path;
     return !returned_root_path.empty();
   }
 
-  FilePath data_path() const { return data_dir_.path(); }
-  FilePath file_system_path() const {
+  base::FilePath data_path() const { return data_dir_.path(); }
+  base::FilePath file_system_path() const {
     return data_dir_.path().Append(
         SandboxMountPointProvider::kFileSystemDirectory);
   }
   FileSystemContext* file_system_context() const {
     return file_system_context_.get();
   }
 
  private:
   base::ScopedTempDir data_dir_;
   MessageLoop message_loop_;
   base::WeakPtrFactory<FileSystemMountPointProviderTest> weak_factory_;
 
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
   scoped_refptr<FileSystemContext> file_system_context_;
 
   DISALLOW_COPY_AND_ASSIGN(FileSystemMountPointProviderTest);
 };
 
 TEST_F(FileSystemMountPointProviderTest, GetRootPathCreateAndExamine) {
-  std::vector<FilePath> returned_root_path(
+  std::vector<base::FilePath> returned_root_path(
       ARRAYSIZE_UNSAFE(kRootPathTestCases));
   SetupNewContext(CreateAllowFileAccessOptions());
 
   // Create a new root directory.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (create) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
 
-    FilePath root_path;
+    base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
                             true /* create */, &root_path));
 
     if (kRootPathTestCases[i].type != kFileSystemTypeExternal) {
-      FilePath expected = file_system_path().AppendASCII(
+      base::FilePath expected = file_system_path().AppendASCII(
           kRootPathTestCases[i].expected_path);
       EXPECT_EQ(expected.value(), root_path.value());
       EXPECT_TRUE(file_util::DirectoryExists(root_path));
     } else {
       // External file system root path is virtual one and does not match
       // anything from the actual file system.
       EXPECT_EQ(kRootPath, root_path.value());
     }
     ASSERT_TRUE(returned_root_path.size() > i);
     returned_root_path[i] = root_path;
   }
 
   // Get the root directory with create=false and see if we get the
   // same directory.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (get) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
 
-    FilePath root_path;
+    base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
                             false /* create */, &root_path));
     ASSERT_TRUE(returned_root_path.size() > i);
     EXPECT_EQ(returned_root_path[i].value(), root_path.value());
   }
 }
 
 TEST_F(FileSystemMountPointProviderTest,
        GetRootPathCreateAndExamineWithNewProvider) {
-  std::vector<FilePath> returned_root_path(
+  std::vector<base::FilePath> returned_root_path(
       ARRAYSIZE_UNSAFE(kRootPathTestCases));
   SetupNewContext(CreateAllowFileAccessOptions());
 
   GURL origin_url("http://foo.com:1/");
 
-  FilePath root_path1;
+  base::FilePath root_path1;
   EXPECT_TRUE(GetRootPath(origin_url,
                           kFileSystemTypeTemporary, true, &root_path1));
 
   SetupNewContext(CreateDisallowFileAccessOptions());
-  FilePath root_path2;
+  base::FilePath root_path2;
   EXPECT_TRUE(GetRootPath(origin_url,
                           kFileSystemTypeTemporary, false, &root_path2));
 
   EXPECT_EQ(root_path1.value(), root_path2.value());
 }
 
 TEST_F(FileSystemMountPointProviderTest, GetRootPathGetWithoutCreate) {
   SetupNewContext(CreateDisallowFileAccessOptions());
 
   // Try to get a root directory without creating.
@@ skipping 34 matching lines @@
                              kRootPathFileURITestCases[i].type,
                              true /* create */, NULL));
   }
 }
 
 TEST_F(FileSystemMountPointProviderTest, GetRootPathFileURIWithAllowFlag) {
   SetupNewContext(CreateAllowFileAccessOptions());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPathFileURI (allow) #"
                  << i << " " << kRootPathFileURITestCases[i].expected_path);
-    FilePath root_path;
+    base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
                             kRootPathFileURITestCases[i].type,
                             true /* create */, &root_path));
-    FilePath expected = file_system_path().AppendASCII(
+    base::FilePath expected = file_system_path().AppendASCII(
         kRootPathFileURITestCases[i].expected_path);
     EXPECT_EQ(expected.value(), root_path.value());
     EXPECT_TRUE(file_util::DirectoryExists(root_path));
   }
 }
 
 TEST_F(FileSystemMountPointProviderTest, IsRestrictedName) {
   SetupNewContext(CreateDisallowFileAccessOptions());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kIsRestrictedNameTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "IsRestrictedName #" << i << " "
                  << kIsRestrictedNameTestCases[i].name);
-    FilePath name(kIsRestrictedNameTestCases[i].name);
+    base::FilePath name(kIsRestrictedNameTestCases[i].name);
     EXPECT_EQ(kIsRestrictedNameTestCases[i].expected_dangerous,
               provider(kFileSystemTypeTemporary)->IsRestrictedFileName(name));
   }
 }
 
 }  // namespace fileapi