Quota: Implement QuotaBackendImpl

webkit/browser/fileapi/quota/quota_reservation_manager_unittest.cc

 // Copyright 2013 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/browser/fileapi/quota/quota_reservation_manager.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/quota/open_file_handle.h"
 #include "webkit/browser/fileapi/quota/quota_reservation.h"
 
 namespace fileapi {
 
 namespace {
 
 const char kOrigin[] = "http://example.com";
 const FileSystemType kType = kFileSystemTypeTemporary;
 const int64 kInitialFileSize = 30;
 
 typedef QuotaReservationManager::ReserveQuotaCallback ReserveQuotaCallback;
-typedef QuotaReservationManager::StatusCallback StatusCallback;
 
 class FakeBackend : public QuotaReservationManager::QuotaBackend {
  public:
   FakeBackend()
       : on_memory_usage_(0),
         on_disk_usage_(0) {}
   virtual ~FakeBackend() {}
 
   virtual void ReserveQuota(const GURL& origin,
                             FileSystemType type,
@@ skipping 11 matching lines @@
                                     FileSystemType type,
                                     int64 size) OVERRIDE {
     EXPECT_LE(0, size);
     EXPECT_EQ(GURL(kOrigin), origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ -= size;
   }
 
   virtual void CommitQuotaUsage(const GURL& origin,
                                 FileSystemType type,
-                                int64 delta,
-                                const StatusCallback& callback) OVERRIDE {
+                                int64 delta) OVERRIDE {
     EXPECT_EQ(GURL(kOrigin), origin);
     EXPECT_EQ(kType, type);
     on_disk_usage_ += delta;
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE, base::Bind(callback, base::PLATFORM_FILE_OK));
   }
 
-  virtual void IncreaseDirtyCount(const GURL& origin,
-                                  FileSystemType type) OVERRIDE {}
-  virtual void DecreaseDirtyCount(const GURL& origin,
-                                  FileSystemType type) OVERRIDE {}
+  virtual void IncrementDirtyCount(const GURL& origin,
+                                   FileSystemType type) OVERRIDE {}
+  virtual void DecrementDirtyCount(const GURL& origin,
+                                   FileSystemType type) OVERRIDE {}
 
   int64 on_memory_usage() { return on_memory_usage_; }
   int64 on_disk_usage() { return on_disk_usage_; }
 
  private:
   int64 on_memory_usage_;
   int64 on_disk_usage_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeBackend);
 };
@@ skipping 18 matching lines @@
 class QuotaReservationManagerTest : public testing::Test {
  public:
   QuotaReservationManagerTest() {}
   virtual ~QuotaReservationManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(work_dir_.CreateUniqueTempDir());
     file_path_ = work_dir_.path().Append(FILE_PATH_LITERAL("hoge"));
     SetFileSize(kInitialFileSize);
 
-    fake_backend_.reset(new FakeBackend);
-    reservation_manager_.reset(new QuotaReservationManager(
-        fake_backend_.get()));
+    scoped_ptr<QuotaReservationManager::QuotaBackend> backend(new FakeBackend);
+    reservation_manager_.reset(new QuotaReservationManager(backend.Pass()));
   }
 
   virtual void TearDown() OVERRIDE {
     reservation_manager_.reset();
-    fake_backend_.reset();
   }
 
   int64 GetFileSize() {
     int64 size = 0;
     file_util::GetFileSize(file_path_, &size);
     return size;
   }
 
   void SetFileSize(int64 size) {
     bool created = false;
     base::PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
     base::PlatformFile file = CreatePlatformFile(
         file_path_,
         base::PLATFORM_FILE_OPEN_ALWAYS | base::PLATFORM_FILE_WRITE,
         &created, &error);
     ASSERT_EQ(base::PLATFORM_FILE_OK, error);
     ASSERT_TRUE(base::TruncatePlatformFile(file, size));
     ASSERT_TRUE(base::ClosePlatformFile(file));
   }
 
   void ExtendFileTo(int64 size) {
     if (GetFileSize() < size)
       SetFileSize(size);
   }
 
   FakeBackend* fake_backend() {
-    return fake_backend_.get();
+    return static_cast<FakeBackend*>(reservation_manager_->backend_.get());
   }
 
   QuotaReservationManager* reservation_manager() {
     return reservation_manager_.get();
   }
 
   const base::FilePath& file_path() const {
     return file_path_;
   }
 
  private:
   base::MessageLoop message_loop_;
   base::ScopedTempDir work_dir_;
   base::FilePath file_path_;
-  scoped_ptr<FakeBackend> fake_backend_;
   scoped_ptr<QuotaReservationManager> reservation_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaReservationManagerTest);
 };
 
 TEST_F(QuotaReservationManagerTest, BasicTest) {
   GURL origin(kOrigin);
   FileSystemType type = kType;
 
   // Create Reservation channel for the origin and type.
@@ skipping 187 matching lines @@
 
   EXPECT_EQ(400, GetFileSize());
   EXPECT_EQ(0, fake_backend()->on_memory_usage());
   EXPECT_EQ(400 - kInitialFileSize, fake_backend()->on_disk_usage());
 }
 
 // TODO(tzik): Add Truncate test.
 // TODO(tzik): Add PluginCrash test and DropReservationManager test.
 
 }  // namespace fileapi