Cleanup: Introduce AsyncFileTestHelper for testing with async file/quota operations

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 <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/fileapi/async_file_test_helper.h"
 #include "webkit/fileapi/external_mount_points.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_task_runners.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
-#include "webkit/fileapi/file_util_helper.h"
 #include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/fileapi/mock_file_change_observer.h"
 #include "webkit/fileapi/mock_file_system_options.h"
 #include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/test_file_set.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 namespace fileapi {
@@ skipping 169 matching lines @@
   fileapi::FileSystemType type() const {
     return type_;
   }
 
   int64 ComputeTotalFileSize() {
     return test_helper_.ComputeCurrentOriginUsage() -
         test_helper_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   void GetUsageFromQuotaManager() {
-    quota_manager_->GetUsageAndQuota(
-      origin(), test_helper_.storage_type(),
-      base::Bind(&ObfuscatedFileUtilTest::OnGetUsage,
-                 weak_factory_.GetWeakPtr()));
-    MessageLoop::current()->RunUntilIdle();
+    int64 quota = -1;
+    quota_status_ = AsyncFileTestHelper::GetUsageAndQuota(
+      quota_manager_, origin(), test_helper_.type(),
+      &usage_, &quota);
     EXPECT_EQ(quota::kQuotaStatusOk, quota_status_);
   }
 
   void RevokeUsageCache() {
     quota_manager_->ResetUsageTracker(test_helper_.storage_type());
     file_util::Delete(test_helper_.GetUsageCachePath(), false);
   }
 
   int64 SizeByQuotaUtil() {
     return test_helper_.GetCachedOriginUsage();
   }
 
   int64 SizeInUsageFile() {
     MessageLoop::current()->RunUntilIdle();
     return FileSystemUsageCache::GetUsage(test_helper_.GetUsageCachePath());
   }
 
   bool PathExists(const FileSystemURL& url) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     base::PlatformFileInfo file_info;
     base::FilePath platform_path;
     base::PlatformFileError error = ofu()->GetFileInfo(
         context.get(), url, &file_info, &platform_path);
     return error == base::PLATFORM_FILE_OK;
   }
 
   bool DirectoryExists(const FileSystemURL& url) {
-    scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
-    return FileUtilHelper::DirectoryExists(context.get(), ofu(), url);
+    return AsyncFileTestHelper::DirectoryExists(file_system_context(), 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());
   }
 
   FileSystemURL CreateURL(const base::FilePath& path) {
     return test_helper_.CreateURL(path);
   }
 
-  void OnGetUsage(quota::QuotaStatusCode status, int64 usage, int64 unused) {
-    EXPECT_EQ(quota::kQuotaStatusOk, status);
-    quota_status_ = status;
-    usage_ = usage;
-  }
-
   void CheckFileAndCloseHandle(
       const FileSystemURL& url, base::PlatformFile file_handle) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     base::FilePath local_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
         context.get(), url, &local_path));
 
     base::PlatformFileInfo file_info0;
     base::FilePath data_path;
     EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
@@ skipping 108 matching lines @@
     int64 usage = test_helper_.GetCachedOriginUsage();
     return scoped_ptr<UsageVerifyHelper>(new UsageVerifyHelper(
         LimitedContext(requested_growth - 1), &test_helper_, usage));
   }
 
   void FillTestDirectory(
       const FileSystemURL& root_url,
       std::set<base::FilePath::StringType>* files,
       std::set<base::FilePath::StringType>* directories) {
     scoped_ptr<FileSystemOperationContext> context;
-    context.reset(NewContext(NULL));
     std::vector<base::FileUtilProxy::Entry> entries;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-              FileUtilHelper::ReadDirectory(
-                  context.get(), ofu(), root_url, &entries));
+              AsyncFileTestHelper::ReadDirectory(
+                  file_system_context(), root_url, &entries));
     EXPECT_EQ(0UL, entries.size());
 
     files->clear();
     files->insert(FILE_PATH_LITERAL("first"));
     files->insert(FILE_PATH_LITERAL("second"));
     files->insert(FILE_PATH_LITERAL("third"));
     directories->clear();
     directories->insert(FILE_PATH_LITERAL("fourth"));
     directories->insert(FILE_PATH_LITERAL("fifth"));
     directories->insert(FILE_PATH_LITERAL("sixth"));
@@ skipping 22 matching lines @@
 
   void TestReadDirectoryHelper(const FileSystemURL& root_url) {
     std::set<base::FilePath::StringType> files;
     std::set<base::FilePath::StringType> directories;
     FillTestDirectory(root_url, &files, &directories);
 
     scoped_ptr<FileSystemOperationContext> context;
     std::vector<base::FileUtilProxy::Entry> entries;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-              FileUtilHelper::ReadDirectory(
-                  context.get(), ofu(), root_url, &entries));
+              AsyncFileTestHelper::ReadDirectory(
+                  file_system_context(), root_url, &entries));
     std::vector<base::FileUtilProxy::Entry>::iterator entry_iter;
     EXPECT_EQ(files.size() + directories.size(), entries.size());
     EXPECT_TRUE(change_observer()->HasNoChange());
     for (entry_iter = entries.begin(); entry_iter != entries.end();
         ++entry_iter) {
       const base::FileUtilProxy::Entry& entry = *entry_iter;
       std::set<base::FilePath::StringType>::iterator iter = files.find(entry.name);
       if (iter != files.end()) {
         EXPECT_FALSE(entry.is_directory);
         files.erase(iter);
@@ skipping 173 matching lines @@
 
   int64 ComputeCurrentUsage() {
     return test_helper().ComputeCurrentOriginUsage() -
         test_helper().ComputeCurrentDirectoryDatabaseUsage();
   }
 
   const LocalFileSystemTestOriginHelper& test_helper() const {
     return test_helper_;
   }
 
+  FileSystemContext* file_system_context() {
+    return test_helper_.file_system_context();
+  }
+
  private:
   base::ScopedTempDir data_dir_;
   MessageLoop message_loop_;
   scoped_refptr<quota::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
   fileapi::FileSystemType type_;
   base::WeakPtrFactory<ObfuscatedFileUtilTest> weak_factory_;
   LocalFileSystemTestOriginHelper test_helper_;
   quota::QuotaStatusCode quota_status_;
@@ skipping 423 matching lines @@
 
 TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
   FileSystemURL url = CreateURLFromUTF8("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   bool created = false;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
       ofu()->EnsureFileExists(context.get(), url, &created));
   ASSERT_TRUE(created);
 
-  context.reset(NewContext(NULL));
   std::vector<base::FileUtilProxy::Entry> entries;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY,
-            FileUtilHelper::ReadDirectory(
-                context.get(), ofu(), url, &entries));
+            AsyncFileTestHelper::ReadDirectory(
+                file_system_context(), url, &entries));
 
   EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), url));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestTouch) {
   FileSystemURL url = CreateURLFromUTF8("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   base::Time last_access_time = base::Time::Now();
   base::Time last_modified_time = base::Time::Now();
@@ skipping 293 matching lines @@
   ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), src_url, exclusive, recursive));
 
   std::set<base::FilePath::StringType> files;
   std::set<base::FilePath::StringType> directories;
   FillTestDirectory(src_url, &files, &directories);
 
   FileSystemURL dest_url = CreateURLFromUTF8("destination dir");
 
   EXPECT_FALSE(DirectoryExists(dest_url));
-  context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            test_helper().SameFileUtilCopy(context.get(), src_url, dest_url));
+            AsyncFileTestHelper::Copy(
+                test_helper().file_system_context(), src_url, dest_url));
 
   ValidateTestDirectory(dest_url, files, directories);
   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));
+            AsyncFileTestHelper::Remove(
+                file_system_context(), dest_url, recursive));
   EXPECT_FALSE(DirectoryExists(dest_url));
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) {
   scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator>
       enumerator(ofu()->CreateOriginEnumerator());
   // The test helper starts out with a single filesystem.
   EXPECT_TRUE(enumerator.get());
   EXPECT_EQ(origin(), enumerator->Next());
   ASSERT_TRUE(type() == kFileSystemTypeTemporary);
@@ skipping 208 matching lines @@
   scoped_ptr<FileSystemOperationContext> context;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kPath); ++i) {
     bool created = false;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
               ofu()->EnsureFileExists(context.get(), kPath[i], &created));
     EXPECT_TRUE(created);
   }
 
-  context.reset(NewContext(NULL));
   std::vector<base::FileUtilProxy::Entry> entries;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            FileUtilHelper::ReadDirectory(
-                context.get(), ofu(), empty_path, &entries));
+            AsyncFileTestHelper::ReadDirectory(
+                file_system_context(), empty_path, &entries));
   EXPECT_EQ(3u, entries.size());
 
-  context.reset(NewContext(NULL));
   base::FilePath local_path;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->GetLocalFilePath(context.get(), kPath[0], &local_path));
   EXPECT_TRUE(file_util::Delete(local_path, false));
 
-  context.reset(NewContext(NULL));
   entries.clear();
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            FileUtilHelper::ReadDirectory(
-                context.get(), ofu(), empty_path, &entries));
+            AsyncFileTestHelper::ReadDirectory(
+                file_system_context(), empty_path, &entries));
   EXPECT_EQ(ARRAYSIZE_UNSAFE(kPath) - 1, entries.size());
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestDirectoryTimestampForCreation) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   const FileSystemURL dir_url = CreateURLFromUTF8("foo_dir");
 
   // Create working directory.
   EXPECT_EQ(base::PLATFORM_FILE_OK,
             ofu()->CreateDirectory(context.get(), dir_url, false, false));
@@ skipping 495 matching lines @@
                 dfile2, 120));
   ASSERT_EQ(1480, ComputeTotalFileSize());
 
   ASSERT_EQ(base::PLATFORM_FILE_OK,
             ofu()->DeleteFile(
                 AllowUsageIncrease(-PathCost(file) - 340)->context(),
                 file));
   ASSERT_EQ(1140, ComputeTotalFileSize());
 
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            FileUtilHelper::Delete(
-                AllowUsageIncrease(-PathCost(dir) -
-                                   PathCost(dfile1) -
-                                   PathCost(dfile2) -
-                                   1020 - 120)->context(),
-                ofu(), dir, true));
+            AsyncFileTestHelper::Remove(
+                file_system_context(), dir, true /* recursive */));
   ASSERT_EQ(0, ComputeTotalFileSize());
 }
 
 TEST_F(ObfuscatedFileUtilTest, TestQuotaOnOpen) {
   FileSystemURL file(CreateURLFromUTF8("file"));
   base::PlatformFile file_handle;
   bool created;
 
   // Creating a file.
   ASSERT_EQ(base::PLATFORM_FILE_OK,
@@ skipping 37 matching lines @@
   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));
 }
 
 }  // namespace fileapi