Cleanup: merge MockQuotaManager in multiple places

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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.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/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/quota_manager.h"
+#include "webkit/quota/mock_quota_manager.h"
 
-using quota::QuotaClient;
 using quota::QuotaManager;
 using quota::QuotaManagerProxy;
-using quota::StorageType;
 using webkit_blob::ShareableFileReference;
 
 namespace fileapi {
 
 namespace {
 
 const int kFileOperationStatusNotSet = 1;
 
 void AssertFileErrorEq(base::PlatformFileError expected,
                        base::PlatformFileError actual) {
   ASSERT_EQ(expected, actual);
 }
 
-class MockQuotaManager : public QuotaManager {
- public:
-  MockQuotaManager(const FilePath& base_dir,
-                   const GURL& origin,
-                   StorageType type)
-    : QuotaManager(false /* is_incognito */, base_dir,
-                   base::MessageLoopProxy::current(),
-                   base::MessageLoopProxy::current(),
-                   NULL),
-      origin_(origin),
-      type_(type),
-      usage_(0),
-      quota_(kint64max),
-      accessed_(0) {}
-
-  virtual void GetUsageAndQuota(
-      const GURL& origin, quota::StorageType type,
-      const GetUsageAndQuotaCallback& callback) OVERRIDE {
-    EXPECT_EQ(origin_, origin);
-    EXPECT_EQ(type_, type);
-    callback.Run(quota::kQuotaStatusOk, usage_, quota_);
-  }
-
- protected:
-  virtual ~MockQuotaManager() {}
-
- private:
-  friend class MockQuotaManagerProxy;
-
-  void SetQuota(const GURL& origin, StorageType type, int64 quota) {
-    EXPECT_EQ(origin_, origin);
-    EXPECT_EQ(type_, type);
-    quota_ = quota;
-  }
-
-  void RecordStorageAccessed(const GURL& origin, StorageType type) {
-    EXPECT_EQ(origin_, origin);
-    EXPECT_EQ(type_, type);
-    ++accessed_;
-  }
-
-  void UpdateUsage(const GURL& origin, StorageType type, int64 delta) {
-    EXPECT_EQ(origin_, origin);
-    EXPECT_EQ(type_, type);
-    usage_ += delta;
-  }
-
-  const GURL& origin_;
-  const StorageType type_;
-  int64 usage_;
-  int64 quota_;
-  int accessed_;
-};
-
-class MockQuotaManagerProxy : public QuotaManagerProxy {
- public:
-  explicit MockQuotaManagerProxy(QuotaManager* quota_manager)
-      : QuotaManagerProxy(quota_manager,
-                          base::MessageLoopProxy::current()),
-        registered_client_(NULL) {
-  }
-
-  virtual void RegisterClient(QuotaClient* client) OVERRIDE {
-    EXPECT_FALSE(registered_client_);
-    registered_client_ = client;
-  }
-
-  void SimulateQuotaManagerDestroyed() {
-    if (registered_client_) {
-      // We cannot call this in the destructor as the client (indirectly)
-      // holds a refptr of the proxy.
-      registered_client_->OnQuotaManagerDestroyed();
-      registered_client_ = NULL;
-    }
-  }
-
-  // We don't mock them.
-  virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
-  virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
-
-  virtual void NotifyStorageAccessed(QuotaClient::ID client_id,
-                                     const GURL& origin,
-                                     StorageType type) OVERRIDE {
-    mock_manager()->RecordStorageAccessed(origin, type);
-  }
-
-  virtual void NotifyStorageModified(QuotaClient::ID client_id,
-                                     const GURL& origin,
-                                     StorageType type,
-                                     int64 delta) OVERRIDE {
-    mock_manager()->UpdateUsage(origin, type, delta);
-  }
-
-  int storage_accessed_count() const {
-    return mock_manager()->accessed_;
-  }
-
-  void SetQuota(const GURL& origin, StorageType type, int64 quota) {
-    mock_manager()->SetQuota(origin, type, quota);
-  }
-
- protected:
-  virtual ~MockQuotaManagerProxy() {
-    EXPECT_FALSE(registered_client_);
-  }
-
- private:
-  MockQuotaManager* mock_manager() const {
-    return static_cast<MockQuotaManager*>(quota_manager());
-  }
-
-  QuotaClient* registered_client_;
-};
-
 FilePath ASCIIToFilePath(const std::string& str) {
   return FilePath().AppendASCII(str);
 }
 
 }  // namespace (anonymous)
 
 // Test class for LocalFileSystemOperation.
 class LocalFileSystemOperationTest
     : public testing::Test,
       public base::SupportsWeakPtr<LocalFileSystemOperationTest> {
@@ skipping 17 matching lines @@
     return shareable_file_ref_;
   }
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
  protected:
   // Common temp base for nondestructive uses.
   ScopedTempDir base_;
 
-  MockQuotaManagerProxy* quota_manager_proxy() {
-    return static_cast<MockQuotaManagerProxy*>(quota_manager_proxy_.get());
+  quota::MockQuotaManager* quota_manager() {
+    return static_cast<quota::MockQuotaManager*>(quota_manager_.get());
+  }
+
+  quota::MockQuotaManagerProxy* quota_manager_proxy() {
+    return static_cast<quota::MockQuotaManagerProxy*>(
+        quota_manager_proxy_.get());
   }
 
   FileSystemFileUtil* file_util() {
     return test_helper_.file_util();
   }
 
   const ChangeObserverList& change_observers() const {
     return change_observers_;
   }
 
@@ skipping 156 matching lines @@
     MessageLoop::current()->RunAllPending();
 
     int64 total_usage;
     GetUsageAndQuota(&total_usage, NULL);
     *path_cost = total_usage - base_usage;
   }
 
   void GrantQuotaForCurrentUsage() {
     int64 usage;
     GetUsageAndQuota(&usage, NULL);
-    quota_manager_proxy()->SetQuota(test_helper_.origin(),
-                                    test_helper_.storage_type(),
-                                    usage);
+    quota_manager()->SetQuota(test_helper_.origin(),
+                              test_helper_.storage_type(),
+                              usage);
   }
 
   void AddQuota(int64 quota_delta) {
     int64 quota;
     GetUsageAndQuota(NULL, &quota);
-    quota_manager_proxy()->SetQuota(test_helper_.origin(),
-                                    test_helper_.storage_type(),
-                                    quota + quota_delta);
+    quota_manager()->SetQuota(test_helper_.origin(),
+                              test_helper_.storage_type(),
+                              quota + quota_delta);
   }
 
   // For post-operation status.
   int status_;
   base::PlatformFileInfo info_;
   FilePath path_;
   std::vector<base::FileUtilProxy::Entry> entries_;
   scoped_refptr<ShareableFileReference> shareable_file_ref_;
 
  private:
   MessageLoop message_loop_;
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
 
   MockFileChangeObserver change_observer_;
   ChangeObserverList change_observers_;
 
   int next_unique_path_suffix_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalFileSystemOperationTest);
 };
 
 void LocalFileSystemOperationTest::SetUp() {
   FilePath base_dir = base_.path().AppendASCII("filesystem");
-  quota_manager_ = new MockQuotaManager(
-      base_dir, test_helper_.origin(), test_helper_.storage_type());
-  quota_manager_proxy_ = new MockQuotaManagerProxy(quota_manager_.get());
+  quota_manager_ = new quota::MockQuotaManager(
+      false /* is_incognito */, base_dir,
+      base::MessageLoopProxy::current(),
+      base::MessageLoopProxy::current(),
+      NULL /* special storage policy */);
+  quota_manager_proxy_ = new quota::MockQuotaManagerProxy(
+      quota_manager(),
+      base::MessageLoopProxy::current());
   test_helper_.SetUp(base_dir,
                      false /* unlimited quota */,
                      quota_manager_proxy_.get(),
                      NULL);
 }
 
 void LocalFileSystemOperationTest::TearDown() {
   // Let the client go away before dropping a ref of the quota manager proxy.
   quota_manager_proxy()->SimulateQuotaManagerDestroyed();
   quota_manager_ = NULL;
@@ skipping 91 matching lines @@
   MessageLoop::current()->RunAllPending();
   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()->storage_accessed_count());
+  EXPECT_EQ(0, quota_manager_proxy()->notify_storage_accessed_count());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestMoveSuccessSrcFileAndNew) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateUniqueDir());
   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 @@
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateUniqueDir());
   FilePath dest_file_path(CreateUniqueFileInDir(dest_dir_path));
 
   operation()->Copy(URLForPath(src_file_path), URLForPath(dest_file_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(FileExists(dest_file_path));
-  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(1, 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) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath src_file_path(CreateUniqueFileInDir(src_dir_path));
   FilePath dest_dir_path(CreateUniqueDir());
   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()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(FileExists(dest_file_path));
-  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(1, 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) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_dir_path(CreateUniqueDir());
 
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_dir_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunAllPending();
   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()->storage_accessed_count());
+  EXPECT_EQ(1, 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) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath dest_parent_dir_path(CreateUniqueDir());
   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()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(DirectoryExists(dest_child_dir_path));
-  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(1, 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) {
   FilePath src_dir_path(CreateUniqueDir());
   FilePath child_dir_path(CreateUniqueDirInDir(src_dir_path));
   FilePath grandchild_file_path(
       CreateUniqueFileInDir(child_dir_path));
 
   FilePath dest_dir_path(CreateUniqueDir());
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_dir_path),
                     RecordStatusCallback());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(DirectoryExists(dest_dir_path.Append(
       VirtualPath::BaseName(child_dir_path))));
   EXPECT_TRUE(FileExists(dest_dir_path.Append(
       VirtualPath::BaseName(child_dir_path)).Append(
       VirtualPath::BaseName(grandchild_file_path))));
-  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(2, change_observer()->get_and_reset_create_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_create_file_from_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestCopyInForeignFileSuccess) {
   FilePath src_local_disk_file_path;
   file_util::CreateTemporaryFile(&src_local_disk_file_path);
@@ skipping 33 matching lines @@
   const char test_data[] = "foo";
   file_util::WriteFile(src_local_disk_file_path, test_data,
                        ARRAYSIZE_UNSAFE(test_data));
 
   FilePath dest_dir_path(CreateUniqueDir());
   FilePath dest_file_path(dest_dir_path.Append(
       src_local_disk_file_path.BaseName()));
   FileSystemURL dest_file_url = URLForPath(dest_file_path);
 
   // Set quota of 0 which should force copy to fail by quota.
-  quota_manager_proxy()->SetQuota(dest_file_url.origin(),
-                                  test_helper_.storage_type(),
-                                  static_cast<int64>(0));
+  quota_manager()->SetQuota(dest_file_url.origin(),
+                            test_helper_.storage_type(),
+                            static_cast<int64>(0));
   operation()->CopyInForeignFile(src_local_disk_file_path,
                                  dest_file_url,
                                  RecordStatusCallback());
   MessageLoop::current()->RunAllPending();
 
   EXPECT_TRUE(!FileExists(dest_file_path));
   EXPECT_EQ(0, change_observer()->create_file_count());
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, status());
 }
 
@@ skipping 158 matching lines @@
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   ++read_access;
 
   operation()->GetMetadata(URLForPath(file_path), RecordMetadataCallback());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_FALSE(info().is_directory);
   EXPECT_EQ(PlatformPath(file_path), path());
   ++read_access;
 
-  EXPECT_EQ(read_access, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(read_access,
+            quota_manager_proxy()->notify_storage_accessed_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestTypeMismatchErrors) {
   FilePath dir_path(CreateUniqueDir());
   operation()->FileExists(URLForPath(dir_path), RecordStatusCallback());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE, status());
 
   FilePath file_path(CreateUniqueFileInDir(dir_path));
@@ skipping 42 matching lines @@
 
   for (size_t i = 0; i < entries().size(); ++i) {
     if (entries()[i].is_directory) {
       EXPECT_EQ(VirtualPath::BaseName(child_dir_path).value(),
                 entries()[i].name);
     } else {
       EXPECT_EQ(VirtualPath::BaseName(child_file_path).value(),
                 entries()[i].name);
     }
   }
-  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestRemoveFailure) {
   // Path doesn't exist.
   FilePath nonexisting_path(FilePath(
       FILE_PATH_LITERAL("NonExistingDir")));
   file_util::EnsureEndsWithSeparator(&nonexisting_path);
 
   operation()->Remove(URLForPath(nonexisting_path), false /* recursive */,
@@ skipping 43 matching lines @@
   FilePath child_dir_path(CreateUniqueDirInDir(parent_dir_path));
   ASSERT_FALSE(child_dir_path.empty());
 
   operation()->Remove(URLForPath(parent_dir_path), true /* recursive */,
                       RecordStatusCallback());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_FALSE(DirectoryExists(parent_dir_path));
 
   // Remove is not a 'read' access.
-  EXPECT_EQ(0, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(0, quota_manager_proxy()->notify_storage_accessed_count());
 
   EXPECT_EQ(2, change_observer()->get_and_reset_remove_directory_count());
   EXPECT_EQ(1, change_observer()->get_and_reset_remove_file_count());
   EXPECT_TRUE(change_observer()->HasNoChange());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestTruncate) {
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(CreateUniqueFileInDir(dir_path));
 
@@ skipping 45 matching lines @@
 
   // Check that its length is now 3 and that it contains only bits of test data.
   EXPECT_TRUE(file_util::GetFileInfo(PlatformPath(file_path), &info));
   EXPECT_EQ(length, info.size);
   EXPECT_EQ(length, file_util::ReadFile(PlatformPath(file_path), data, length));
   for (int i = 0; i < length; ++i)
     EXPECT_EQ(test_data[i], data[i]);
 
   // Truncate is not a 'read' access.  (Here expected access count is 1
   // since we made 1 read access for GetMetadata.)
-  EXPECT_EQ(1, quota_manager_proxy()->storage_accessed_count());
+  EXPECT_EQ(1, quota_manager_proxy()->notify_storage_accessed_count());
 }
 
 TEST_F(LocalFileSystemOperationTest, TestTruncateFailureByQuota) {
   base::PlatformFileInfo info;
 
   FilePath dir_path(CreateUniqueDir());
   FilePath file_path(CreateUniqueFileInDir(dir_path));
 
   GrantQuotaForCurrentUsage();
   AddQuota(10);
@@ skipping 71 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