Rename FileSystemMountPointProvider::ValidateFileSystemRoot to OpenFileSystem

webkit/browser/fileapi/sandbox_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 "webkit/browser/fileapi/sandbox_mount_point_provider.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
@@ skipping 53 matching lines @@
   { fileapi::kFileSystemTypePersistent, "file:///",
     "000" PS "p", NULL },
 };
 
 FileSystemURL CreateFileSystemURL(const char* path) {
   const GURL kOrigin("http://foo/");
   return FileSystemURL::CreateForTest(
       kOrigin, kFileSystemTypeTemporary, base::FilePath::FromUTF8Unsafe(path));
 }
 
-void DidValidateFileSystemRoot(base::PlatformFileError* error_out,
-                               base::PlatformFileError error) {
+void DidOpenFileSystem(base::PlatformFileError* error_out,
+                       base::PlatformFileError error) {
   *error_out = error;
 }
 
 }  // namespace
 
 class SandboxMountPointProviderTest : public testing::Test {
  protected:
   virtual void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
   }
@@ skipping 15 matching lines @@
   void CreateOriginTypeDirectory(const GURL& origin,
                                  fileapi::FileSystemType type) {
     base::FilePath target = provider_->
         GetBaseDirectoryForOriginAndType(origin, type, true);
     ASSERT_TRUE(!target.empty());
     ASSERT_TRUE(file_util::DirectoryExists(target));
   }
 
   bool GetRootPath(const GURL& origin_url,
                    fileapi::FileSystemType type,
-                   bool create,
+                   OpenFileSystemMode mode,
                    base::FilePath* root_path) {
     base::PlatformFileError* error = new base::PlatformFileError(
         base::PLATFORM_FILE_OK);
-    provider_->ValidateFileSystemRoot(
-        origin_url, type, create,
-        base::Bind(&DidValidateFileSystemRoot, error));
+    provider_->OpenFileSystem(
+        origin_url, type, mode,
+        base::Bind(&DidOpenFileSystem, error));
     base::MessageLoop::current()->RunUntilIdle();
     if (*error != base::PLATFORM_FILE_OK)
       return false;
     base::FilePath returned_root_path =
         provider_->GetBaseDirectoryForOriginAndType(
             origin_url, type, false /* create */);
     if (root_path)
       *root_path = returned_root_path;
     return !returned_root_path.empty();
   }
@@ skipping 150 matching lines @@
   SetUpNewProvider(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);
 
     base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
-                            true /* create */, &root_path));
+                            OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                            &root_path));
 
     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));
     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);
 
     base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                             kRootPathTestCases[i].type,
-                            false /* create */, &root_path));
+                            OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+                            &root_path));
     ASSERT_TRUE(returned_root_path.size() > i);
     EXPECT_EQ(returned_root_path[i].value(), root_path.value());
   }
 }
 
 TEST_F(SandboxMountPointProviderTest,
        GetRootPathCreateAndExamineWithNewProvider) {
   std::vector<base::FilePath> returned_root_path(
       ARRAYSIZE_UNSAFE(kRootPathTestCases));
   SetUpNewProvider(CreateAllowFileAccessOptions());
 
   GURL origin_url("http://foo.com:1/");
 
   base::FilePath root_path1;
-  EXPECT_TRUE(GetRootPath(origin_url,
-                          kFileSystemTypeTemporary, true, &root_path1));
+  EXPECT_TRUE(GetRootPath(origin_url, kFileSystemTypeTemporary,
+                          OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                          &root_path1));
 
   SetUpNewProvider(CreateDisallowFileAccessOptions());
   base::FilePath root_path2;
-  EXPECT_TRUE(GetRootPath(origin_url,
-                          kFileSystemTypeTemporary, false, &root_path2));
+  EXPECT_TRUE(GetRootPath(origin_url, kFileSystemTypeTemporary,
+                          OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+                          &root_path2));
 
   EXPECT_EQ(root_path1.value(), root_path2.value());
 }
 
 TEST_F(SandboxMountPointProviderTest, GetRootPathGetWithoutCreate) {
   SetUpNewProvider(CreateDisallowFileAccessOptions());
 
   // Try to get a root directory without creating.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (create=false) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
     EXPECT_FALSE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
                              kRootPathTestCases[i].type,
-                             false /* create */, NULL));
+                             OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT,
+                             NULL));
   }
 }
 
 TEST_F(SandboxMountPointProviderTest, GetRootPathInIncognito) {
   SetUpNewProvider(CreateIncognitoFileSystemOptions());
 
   // Try to get a root directory.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPath (incognito) #" << i << " "
                  << kRootPathTestCases[i].expected_path);
-    EXPECT_FALSE(GetRootPath(GURL(kRootPathTestCases[i].origin_url),
-                             kRootPathTestCases[i].type,
-                             true /* create */, NULL));
+    EXPECT_FALSE(
+        GetRootPath(GURL(kRootPathTestCases[i].origin_url),
+                    kRootPathTestCases[i].type,
+                    OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                    NULL));
   }
 }
 
 TEST_F(SandboxMountPointProviderTest, GetRootPathFileURI) {
   SetUpNewProvider(CreateDisallowFileAccessOptions());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPathFileURI (disallow) #"
                  << i << " " << kRootPathFileURITestCases[i].expected_path);
-    EXPECT_FALSE(GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
-                             kRootPathFileURITestCases[i].type,
-                             true /* create */, NULL));
+    EXPECT_FALSE(
+        GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
+                    kRootPathFileURITestCases[i].type,
+                    OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                    NULL));
   }
 }
 
 TEST_F(SandboxMountPointProviderTest, GetRootPathFileURIWithAllowFlag) {
   SetUpNewProvider(CreateAllowFileAccessOptions());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kRootPathFileURITestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "RootPathFileURI (allow) #"
                  << i << " " << kRootPathFileURITestCases[i].expected_path);
     base::FilePath root_path;
     EXPECT_TRUE(GetRootPath(GURL(kRootPathFileURITestCases[i].origin_url),
                             kRootPathFileURITestCases[i].type,
-                            true /* create */, &root_path));
+                            OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
+                            &root_path));
     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));
   }
 }
 
 }  // namespace fileapi