Cleanup: Remove FileSystemFileUtil::{Directory,Path}Exists

webkit/fileapi/obfuscated_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 <algorithm>
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 202 matching lines @@
   }
 
   int64 SizeByQuotaUtil() {
     return test_helper_.GetCachedOriginUsage();
   }
 
   int64 SizeInUsageFile() {
     return FileSystemUsageCache::GetUsage(test_helper_.GetUsageCachePath());
   }
 
+  bool PathExists(const FileSystemURL& url) {
+    scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
+    return FileUtilHelper::PathExists(context.get(), ofu(), url);
+  }
+
+  bool DirectoryExists(const FileSystemURL& url) {
+    scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
+    return FileUtilHelper::DirectoryExists(context.get(), ofu(), url);
+  }
+
   int64 usage() const { return usage_; }
 
   FileSystemURL CreateURLFromUTF8(const std::string& path) {
     return test_helper_.CreateURLFromUTF8(path);
   }
 
   int64 PathCost(const FileSystemURL& url) {
     return ObfuscatedFileUtil::ComputeFilePathCost(url.path());
   }
 
@@ skipping 76 matching lines @@
       bool created = true;
       context.reset(NewContext(NULL));
       ASSERT_EQ(base::PLATFORM_FILE_OK,
           ofu()->EnsureFileExists(
               context.get(), root_url.WithPath(root_url.path().Append(*iter)),
               &created));
       ASSERT_FALSE(created);
     }
     for (iter = directories.begin(); iter != directories.end(); ++iter) {
       context.reset(NewContext(NULL));
-      EXPECT_TRUE(ofu()->DirectoryExists(context.get(),
+      EXPECT_TRUE(DirectoryExists(
           root_url.WithPath(root_url.path().Append(*iter))));
     }
   }
 
   class UsageVerifyHelper {
    public:
     UsageVerifyHelper(scoped_ptr<FileSystemOperationContext> context,
                       LocalFileSystemTestOriginHelper* test_helper,
                       int64 expected_usage)
         : context_(context.Pass()),
@@ skipping 175 matching lines @@
                 ofu()->CopyInForeignFile(context.get(),
                                          src_file_path, dest_url));
     }
 
     context.reset(NewContext(NULL));
     context->set_allowed_bytes_growth(path_cost + src_file_length);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->CopyInForeignFile(context.get(),
                                        src_file_path, dest_url));
 
-    context.reset(NewContext(NULL));
-    EXPECT_TRUE(ofu()->PathExists(context.get(), dest_url));
-    context.reset(NewContext(NULL));
-    EXPECT_FALSE(ofu()->DirectoryExists(context.get(), dest_url));
+    EXPECT_TRUE(PathExists(dest_url));
+    EXPECT_FALSE(DirectoryExists(dest_url));
+
     context.reset(NewContext(NULL));
     base::PlatformFileInfo file_info;
     FilePath data_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), dest_url, &file_info, &data_path));
     EXPECT_NE(data_path, src_file_path);
     EXPECT_TRUE(FileExists(data_path));
     EXPECT_EQ(src_file_length, GetSize(data_path));
 
     EXPECT_EQ(base::PLATFORM_FILE_OK,
@@ skipping 194 matching lines @@
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
       context.get(), url, 10));
   EXPECT_EQ(10, GetSize(local_path));
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
       context.get(), url, 1));
   EXPECT_EQ(1, GetSize(local_path));
 
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->PathExists(context.get(), url));
+  EXPECT_FALSE(DirectoryExists(url));
+  EXPECT_TRUE(PathExists(url));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestQuotaOnTruncation) {
   bool created = false;
   FileSystemURL url = CreateURLFromUTF8("file");
 
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->EnsureFileExists(
                 AllowUsageIncrease(PathCost(url))->context(),
                 url, &created));
@@ skipping 95 matching lines @@
   bool recursive = true;
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(),
       url.WithPath(url.path().DirName()),
       exclusive, recursive));
 
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->EnsureFileExists(context.get(), url, &created));
   ASSERT_TRUE(created);
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->PathExists(context.get(), url));
+  EXPECT_FALSE(DirectoryExists(url));
+  EXPECT_TRUE(PathExists(url));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   bool exclusive = false;
   bool recursive = false;
   FileSystemURL url = CreateURLFromUTF8("foo/bar");
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
       ofu()->DeleteSingleDirectory(context.get(), url));
 
   FileSystemURL root = CreateURLFromUTF8("");
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->PathExists(context.get(), url));
+  EXPECT_FALSE(DirectoryExists(url));
+  EXPECT_FALSE(PathExists(url));
   context.reset(NewContext(NULL));
   EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), root));
 
   context.reset(NewContext(NULL));
   exclusive = false;
   recursive = true;
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->PathExists(context.get(), url));
+  EXPECT_TRUE(DirectoryExists(url));
+  EXPECT_TRUE(PathExists(url));
+
   context.reset(NewContext(NULL));
   EXPECT_FALSE(ofu()->IsDirectoryEmpty(context.get(), root));
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->DirectoryExists(context.get(),
-                                     url.WithPath(url.path().DirName())));
+  EXPECT_TRUE(DirectoryExists(url.WithPath(url.path().DirName())));
+
   context.reset(NewContext(NULL));
   EXPECT_FALSE(ofu()->IsDirectoryEmpty(context.get(),
                                        url.WithPath(url.path().DirName())));
 
   // Can't remove a non-empty directory.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY,
       ofu()->DeleteSingleDirectory(context.get(),
                                    url.WithPath(url.path().DirName())));
 
@@ skipping 20 matching lines @@
   // frees up quota from its path.
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(0);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
       ofu()->DeleteSingleDirectory(context.get(), url));
   EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(url.path()),
       context->allowed_bytes_growth());
 
   url = CreateURLFromUTF8("foo/bop");
 
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->PathExists(context.get(), url));
+  EXPECT_FALSE(DirectoryExists(url));
+  EXPECT_FALSE(PathExists(url));
+
   context.reset(NewContext(NULL));
   EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), url));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->GetFileInfo(
       context.get(), url, &file_info, &local_path));
 
   // Verify that file creation requires sufficient quota for the path.
   exclusive = true;
   recursive = false;
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
       ObfuscatedFileUtil::ComputeFilePathCost(url.path()) - 1);
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
       ObfuscatedFileUtil::ComputeFilePathCost(url.path()));
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->PathExists(context.get(), url));
+  EXPECT_TRUE(DirectoryExists(url));
+  EXPECT_TRUE(PathExists(url));
 
   exclusive = true;
   recursive = false;
+  context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 
   exclusive = true;
   recursive = false;
   url = CreateURLFromUTF8("foo");
+  context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 
   url = CreateURLFromUTF8("blah");
 
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->PathExists(context.get(), url));
+  EXPECT_FALSE(DirectoryExists(url));
+  EXPECT_FALSE(PathExists(url));
 
   exclusive = true;
   recursive = false;
+  context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), url));
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->PathExists(context.get(), url));
+  EXPECT_TRUE(DirectoryExists(url));
+  EXPECT_TRUE(PathExists(url));
 
   exclusive = true;
   recursive = false;
+  context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory(
       context.get(), url, exclusive, recursive));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestReadDirectory) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   bool exclusive = true;
   bool recursive = true;
   FileSystemURL url = CreateURLFromUTF8("directory/to/use");
   EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
@@ skipping 322 matching lines @@
   bool recursive = false;
   ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), src_url, exclusive, recursive));
 
   std::set<FilePath::StringType> files;
   std::set<FilePath::StringType> directories;
   FillTestDirectory(src_url, &files, &directories);
 
   FileSystemURL dest_url = CreateURLFromUTF8("destination dir");
 
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), dest_url));
+  EXPECT_FALSE(DirectoryExists(dest_url));
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             test_helper().SameFileUtilCopy(context.get(), src_url, dest_url));
 
   ValidateTestDirectory(dest_url, files, directories);
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), src_url));
-  context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), dest_url));
+  EXPECT_TRUE(DirectoryExists(src_url));
+  EXPECT_TRUE(DirectoryExists(dest_url));
   context.reset(NewContext(NULL));
   recursive = true;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             FileUtilHelper::Delete(context.get(), ofu(),
                                    dest_url, recursive));
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), dest_url));
+  EXPECT_FALSE(DirectoryExists(dest_url));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestMigration) {
   ScopedTempDir source_dir;
   ASSERT_TRUE(source_dir.CreateUniqueTempDir());
   FilePath root_path = source_dir.path().AppendASCII("chrome-pLmnMWXE7NzTFRsn");
   ASSERT_TRUE(file_util::CreateDirectory(root_path));
 
   test::SetUpRegularTestCases(root_path);
 
@@ skipping 185 matching lines @@
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetFileInfo(
                 context.get(), kPath1, &file_info, &data_path));
   EXPECT_EQ(10, file_info.size);
 
   // Destroy database to make inconsistency between database and filesystem.
   ofu()->DestroyDirectoryDatabase(origin(), type());
 
   // Try to get file info of broken file.
-  context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofu()->PathExists(context.get(), kPath1));
+  EXPECT_FALSE(PathExists(kPath1));
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->EnsureFileExists(context.get(), kPath1, &created));
   EXPECT_TRUE(created);
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetFileInfo(
                 context.get(), kPath1, &file_info, &data_path));
   EXPECT_EQ(0, file_info.size);
 
@@ skipping 640 matching lines @@
 
   // Opening it with TRUNCATED flag, which should truncate the file size.
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CreateOrOpen(
                 AllowUsageIncrease(-length)->context(), file,
                 base::PLATFORM_FILE_OPEN_TRUNCATED | base::PLATFORM_FILE_WRITE,
                 &file_handle, &created));
   ASSERT_EQ(0, ComputeTotalFileSize());
   EXPECT_TRUE(base::ClosePlatformFile(file_handle));
 }