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

webkit/fileapi/local_file_system_operation_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/fileapi/local_file_system_operation.h"
 
 #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/string_number_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/blob/shareable_file_reference.h"
+#include "webkit/fileapi/async_file_test_helper.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_util.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/quota/mock_quota_manager.h"
 #include "webkit/quota/quota_manager.h"
 
 using quota::QuotaManager;
 using quota::QuotaManagerProxy;
 using webkit_blob::ShareableFileReference;
 
 namespace fileapi {
@@ skipping 71 matching lines @@
   FileSystemURL URLForPath(const base::FilePath& path) const {
     return test_helper_.CreateURL(path);
   }
 
   base::FilePath PlatformPath(const base::FilePath& virtual_path) {
     return test_helper_.GetLocalPath(virtual_path);
   }
 
   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 && !file_info.is_directory;
+    return AsyncFileTestHelper::FileExists(
+        test_helper_.file_system_context(), url,
+        AsyncFileTestHelper::kDontCheckSize);
   }
 
   bool DirectoryExists(const base::FilePath& virtual_path) {
     FileSystemURL url = test_helper_.CreateURL(virtual_path);
-    scoped_ptr<FileSystemOperationContext> context(NewContext());
-    return FileUtilHelper::DirectoryExists(context.get(), file_util(), url);
+    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 66 matching lines @@
       base::PlatformFileError status,
       const base::PlatformFileInfo& info,
       const base::FilePath& platform_path,
       const scoped_refptr<ShareableFileReference>& shareable_file_ref) {
     info_ = info;
     path_ = platform_path;
     status_ = status;
     shareable_file_ref_ = shareable_file_ref;
   }
 
-  static void DidGetUsageAndQuota(quota::QuotaStatusCode* status_out,
-                           int64* usage_out,
-                           int64* quota_out,
-                           quota::QuotaStatusCode status,
-                           int64 usage,
-                           int64 quota) {
-    if (status_out)
-      *status_out = status;
-
-    if (usage_out)
-      *usage_out = usage;
-
-    if (quota_out)
-      *quota_out = quota;
-  }
-
   void GetUsageAndQuota(int64* usage, int64* quota) {
-    quota::QuotaStatusCode status = quota::kQuotaStatusUnknown;
-    quota_manager_->GetUsageAndQuota(
-        test_helper_.origin(),
-        test_helper_.storage_type(),
-        base::Bind(&LocalFileSystemOperationTest::DidGetUsageAndQuota,
-                   &status, usage, quota));
+    quota::QuotaStatusCode status =
+        AsyncFileTestHelper::GetUsageAndQuota(
+            quota_manager_, test_helper_.origin(), test_helper_.type(),
+            usage, quota);
     MessageLoop::current()->RunUntilIdle();
     ASSERT_EQ(quota::kQuotaStatusOk, status);
   }
 
   void GenerateUniquePathInDir(const base::FilePath& dir,
                                base::FilePath* file_path,
                                int64* path_cost) {
     int64 base_usage;
     GetUsageAndQuota(&base_usage, NULL);
     *file_path = CreateUniqueFileInDir(dir);
@@ skipping 155 matching lines @@
   operation()->Move(URLForPath(src_file_path), URLForPath(dest_file_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(FileExists(dest_file_path));
 
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
-  // Move is considered 'write' access (for both side), and won't be counted
-  // as read access.
-  EXPECT_EQ(0, quota_manager_proxy()->notify_storage_accessed_count());
+  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestMoveSuccessSrcFileAndNew) {
   base::FilePath src_dir_path(CreateUniqueDir());
   base::FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   base::FilePath dest_dir_path(CreateUniqueDir());
   base::FilePath dest_file_path(dest_dir_path.Append(FILE_PATH_LITERAL("NewFile")));
 
   operation()->Move(URLForPath(src_file_path), URLForPath(dest_file_path),
                     RecordStatusCallback());
@@ skipping 179 matching lines @@
   base::FilePath src_dir_path(CreateUniqueDir());
   base::FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   base::FilePath dest_dir_path(CreateUniqueDir());
   base::FilePath dest_file_path(CreateUniqueFileInDir(dest_dir_path));
 
   operation()->Copy(URLForPath(src_file_path), URLForPath(dest_file_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(FileExists(dest_file_path));
-  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
+  EXPECT_EQ(2, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_modify_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcFileAndNew) {
   base::FilePath src_dir_path(CreateUniqueDir());
   base::FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   base::FilePath dest_dir_path(CreateUniqueDir());
-  base::FilePath dest_file_path(dest_dir_path.Append(FILE_PATH_LITERAL("NewFile")));
+  base::FilePath dest_file_path(dest_dir_path.Append(
+      FILE_PATH_LITERAL("NewFile")));
 
   operation()->Copy(URLForPath(src_file_path), URLForPath(dest_file_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(FileExists(dest_file_path));
-  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
+  EXPECT_EQ(2, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcDirAndOverwrite) {
   base::FilePath src_dir_path(CreateUniqueDir());
   base::FilePath dest_dir_path(CreateUniqueDir());
 
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_dir_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
 
   // Make sure we've overwritten but not copied the source under the |dest_dir|.
   EXPECT_TRUE(DirectoryExists(dest_dir_path));
   EXPECT_FALSE(DirectoryExists(
       dest_dir_path.Append(VirtualPath::BaseName(src_dir_path))));
-  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
+  EXPECT_EQ(3, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcDirAndNew) {
   base::FilePath src_dir_path(CreateUniqueDir());
   base::FilePath dest_parent_dir_path(CreateUniqueDir());
   base::FilePath dest_child_dir_path(dest_parent_dir_path.
       Append(FILE_PATH_LITERAL("NewDirectory")));
 
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_child_dir_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(DirectoryExists(dest_child_dir_path));
-  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
+  EXPECT_EQ(2, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(1, change_observer()->get_and_reset_create_directory_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestCopySuccessSrcDirRecursive) {
   base::FilePath src_dir_path(CreateUniqueDir());
   base::FilePath child_dir_path(CreateUniqueDirInDir(src_dir_path));
   base::FilePath grandchild_file_path(
       CreateUniqueFileInDir(child_dir_path));
@@ skipping 528 matching lines @@
   EXPECT_FALSE(info().is_directory);
   EXPECT_EQ(PlatformPath(file_path), path());
   EXPECT_TRUE(change_observer()->HasNoChange());
 
   // The FileSystemOpration implementation does not create a
   // shareable file reference.
   EXPECT_EQ(NULL, shareable_file_ref());
 }
 
 }  // namespace fileapi