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

webkit/fileapi/local_file_system_quota_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.
 
 // This test checks the entire behavior of FileSystem usage and quota, such as:
 // 1) the actual size of files on disk,
 // 2) the described size in .usage, and
 // 3) the result of QuotaManager::GetUsageAndQuota.
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "base/string_number_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "webkit/fileapi/async_file_test_helper.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/file_util_helper.h"
 #include "webkit/fileapi/local_file_system_operation.h"
 #include "webkit/fileapi/local_file_system_test_helper.h"
 #include "webkit/quota/quota_manager.h"
 
 namespace fileapi {
 
 const int kFileOperationStatusNotSet = 1;
 
 namespace {
 
@@ skipping 19 matching lines @@
   LocalFileSystemOperation* operation();
 
   int status() const { return status_; }
   quota::QuotaStatusCode quota_status() const { return quota_status_; }
   int64 usage() { return usage_; }
   int64 quota() { return quota_; }
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
-  void OnGetUsageAndQuota(
-      quota::QuotaStatusCode status, int64 usage, int64 quota);
-
  protected:
   FileSystemFileUtil* file_util() {
     return test_helper_.file_util();
   }
 
   FileSystemOperationContext* NewContext() {
     FileSystemOperationContext* context = test_helper_.NewOperationContext();
     context->set_allowed_bytes_growth(10000000);
     return context;
   }
@@ skipping 12 matching lines @@
     return test_helper_.ComputeCurrentOriginUsage() -
         test_helper_.ComputeCurrentDirectoryDatabaseUsage();
   }
 
   int64 SizeByQuotaUtil() {
     MessageLoop::current()->RunUntilIdle();
     return test_helper_.GetCachedOriginUsage();
   }
 
   void GetUsageAndQuotaFromQuotaManager() {
-    quota_manager_->GetUsageAndQuota(
-        test_helper_.origin(), test_helper_.storage_type(),
-        base::Bind(&LocalFileSystemQuotaTest::OnGetUsageAndQuota,
-                   weak_factory_.GetWeakPtr()));
+    quota_status_ = AsyncFileTestHelper::GetUsageAndQuota(
+            quota_manager_, test_helper_.origin(), test_helper_.type(),
+            &usage_, &quota_);
     MessageLoop::current()->RunUntilIdle();
   }
 
   bool FileExists(const base::FilePath& virtual_path) {
     FileSystemURL url = test_helper_.CreateURL(virtual_path);
-    base::PlatformFileInfo file_info;
-    base::FilePath platform_path;
-    scoped_ptr<FileSystemOperationContext> context(NewContext());
-    base::PlatformFileError error = file_util()->GetFileInfo(
-        context.get(), url, &file_info, &platform_path);
-    return error == base::PLATFORM_FILE_OK;
+    return AsyncFileTestHelper::FileExists(
+        test_helper_.file_system_context(), url,
+        AsyncFileTestHelper::kDontCheckSize);
   }
 
   bool DirectoryExists(const base::FilePath& virtual_path) {
-    FileSystemURL path = test_helper_.CreateURL(virtual_path);
-    scoped_ptr<FileSystemOperationContext> context(NewContext());
-    return FileUtilHelper::DirectoryExists(context.get(), file_util(), path);
+    FileSystemURL url = test_helper_.CreateURL(virtual_path);
+    return AsyncFileTestHelper::DirectoryExists(
+        test_helper_.file_system_context(), url);
   }
 
   base::FilePath CreateUniqueFileInDir(const base::FilePath& virtual_dir_path) {
     base::FilePath file_name = base::FilePath::FromUTF8Unsafe(
         "tmpfile-" + base::IntToString(next_unique_path_suffix_++));
     FileSystemURL url = test_helper_.CreateURL(
         virtual_dir_path.Append(file_name));
 
     scoped_ptr<FileSystemOperationContext> context(NewContext());
     bool created;
@@ skipping 76 matching lines @@
 
 void LocalFileSystemQuotaTest::TearDown() {
   quota_manager_ = NULL;
   test_helper_.TearDown();
 }
 
 LocalFileSystemOperation* LocalFileSystemQuotaTest::operation() {
   return test_helper_.NewOperation();
 }
 
-void LocalFileSystemQuotaTest::OnGetUsageAndQuota(
-    quota::QuotaStatusCode status, int64 usage, int64 quota) {
-  quota_status_ = status;
-  usage_ = usage;
-  quota_ = quota;
-}
-
 void LocalFileSystemQuotaTest::PrepareFileSet(const base::FilePath& virtual_path) {
   int64 usage = SizeByQuotaUtil();
   child_dir_path_ = CreateUniqueDirInDir(virtual_path);
   child_file1_path_ = CreateUniqueFileInDir(virtual_path);
   child_file2_path_ = CreateUniqueFileInDir(virtual_path);
   child_path_cost_ = SizeByQuotaUtil() - usage;
   usage += child_path_cost_;
 
   grandchild_file1_path_ = CreateUniqueFileInDir(child_dir_path_);
   grandchild_file2_path_ = CreateUniqueFileInDir(child_dir_path_);
@@ skipping 114 matching lines @@
 
   EXPECT_EQ(2 * child_file_size + 3 * grandchild_file_size, ActualFileSize());
   EXPECT_EQ(expected_usage, SizeByQuotaUtil());
   GetUsageAndQuotaFromQuotaManager();
   EXPECT_EQ(quota::kQuotaStatusOk, quota_status());
   EXPECT_EQ(expected_usage, usage());
   ASSERT_LT(expected_usage, quota());
 }
 
 }  // namespace fileapi