QuotaManager: Return the remaining free disk space as quota.

webkit/quota/quota_manager_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 <sstream>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 15 matching lines @@
 using base::MessageLoopProxy;
 
 namespace quota {
 
 // For shorter names.
 const StorageType kTemp = kStorageTypeTemporary;
 const StorageType kPerm = kStorageTypePersistent;
 
 const int kAllClients = QuotaClient::kAllClientsMask;
 
+//
+class TestQuotaManager : public QuotaManager {
+ public:
+  TestQuotaManager(bool is_incognito,
+                   const FilePath& profile_path,
+                   base::SingleThreadTaskRunner* io_thread,
+                   base::SequencedTaskRunner* db_thread,
+                   SpecialStoragePolicy* special_storage_policy)
+      : QuotaManager(is_incognito, profile_path, io_thread, db_thread,
+                     special_storage_policy) {
+  }
+
+  // QuotaManager implementation.
+  virtual int64 GetAvailableDiskSpace() const {
+    return 13377331;
+  }
+
+ private:
+  ~TestQuotaManager() { printf("~TestQuotaManager\n"); };
+};
+
 class QuotaManagerTest : public testing::Test {
  protected:
   typedef QuotaManager::QuotaTableEntry QuotaTableEntry;
   typedef QuotaManager::QuotaTableEntries QuotaTableEntries;
   typedef QuotaManager::OriginInfoTableEntries OriginInfoTableEntries;
 
  public:
   QuotaManagerTest()
       : weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+        quota_status_(kQuotaStatusUnknown),
+        type_(kStorageTypeUnknown),
+        usage_(0),
+        unlimited_usage_(0),
+        quota_(0),
+        available_space_(0),
+        modified_origins_type_(kStorageTypeUnknown),
+        status_callback_count_(0),
+        additional_callback_count_(0),
         mock_time_counter_(0) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     mock_special_storage_policy_ = new MockSpecialStoragePolicy;
-    quota_manager_ = new QuotaManager(
+    quota_manager_ = new TestQuotaManager(
         false /* is_incognito */,
         data_dir_.path(),
         MessageLoopProxy::current(),
         MessageLoopProxy::current(),
         mock_special_storage_policy_);
     // Don't (automatically) start the eviction for testing.
     quota_manager_->eviction_disabled_ = true;
     additional_callback_count_ = 0;
   }
 
@@ skipping 213 matching lines @@
     quota_manager_->DumpOriginInfoTable(
         base::Bind(&QuotaManagerTest::DidDumpOriginInfoTable,
                    weak_factory_.GetWeakPtr()));
   }
 
   void DidGetUsageInfo(const UsageInfoEntries& entries) {
     usage_info_.insert(usage_info_.begin(), entries.begin(), entries.end());
   }
 
   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
+    printf("DidGetUsageAndQuota\n");
     quota_status_ = status;
     usage_ = usage;
     quota_ = quota;
   }
 
   void DidGetQuota(QuotaStatusCode status,
                    StorageType type,
                    int64 quota) {
     quota_status_ = status;
     type_ = type;
@@ skipping 63 matching lines @@
 
   void GetUsage_WithModifyTestBody(const StorageType type);
 
   void set_additional_callback_count(int c) { additional_callback_count_ = c; }
   int additional_callback_count() const { return additional_callback_count_; }
   void DidGetUsageAndQuotaAdditional(
       QuotaStatusCode status, int64 usage, int64 quota) {
     ++additional_callback_count_;
   }
 
-  QuotaManager* quota_manager() const { return quota_manager_.get(); }
-  void set_quota_manager(QuotaManager* quota_manager) {
+  TestQuotaManager* quota_manager() const { return /*quota_manager_.get();*/NULL; }
+  void set_quota_manager(TestQuotaManager* quota_manager) {
+    printf("set_quota_manager: %p\n", quota_manager);
     quota_manager_ = quota_manager;
   }
 
   MockSpecialStoragePolicy* mock_special_storage_policy() const {
     return mock_special_storage_policy_.get();
   }
 
   QuotaStatusCode status() const { return quota_status_; }
   const UsageInfoEntries& usage_info() const { return usage_info_; }
   const std::string& host() const { return host_; }
@@ skipping 16 matching lines @@
  private:
   base::Time IncrementMockTime() {
     ++mock_time_counter_;
     return base::Time::FromDoubleT(mock_time_counter_ * 10.0);
   }
 
   MessageLoop message_loop_;
   ScopedTempDir data_dir_;
   base::WeakPtrFactory<QuotaManagerTest> weak_factory_;
 
-  scoped_refptr<QuotaManager> quota_manager_;
+  scoped_refptr<TestQuotaManager> quota_manager_;
   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;
 
   QuotaStatusCode quota_status_;
   UsageInfoEntries usage_info_;
   std::string host_;
   StorageType type_;
   int64 usage_;
   int64 unlimited_usage_;
   int64 quota_;
   int64 available_space_;
@@ skipping 197 matching lines @@
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 30, usage());
 
   GetUsageAndQuota(GURL("http://bar.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(50, usage());
 
+  GetAvailableSpace();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_LE(0, available_space());
+
   GetUsageAndQuota(GURL("http://unlimited/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(available_space(), quota());
 
+  printf("before\n");
   GetUsageAndQuota(GURL("http://unlimited/"), kPerm);
   MessageLoop::current()->RunAllPending();
+  printf("after\n");
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(available_space(), quota());
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20 + 30 + 1, usage());
   EXPECT_EQ(1, unlimited_usage());
 
   GetGlobalUsage(kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
@@ skipping 140 matching lines @@
   static const MockOriginData kData[] = {
     { "http://usage10/",   kTemp,    10 },
     { "http://usage50/",   kTemp,    50 },
     { "http://unlimited/", kTemp,  4000 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
-  // Test when not overbugdet.
+  // Test when not over budget.
   SetTemporaryGlobalQuota(1000);
   MessageLoop::current()->RunAllPending();
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(10 + 50 + 4000, usage());
   EXPECT_EQ(4000, unlimited_usage());
 
   const int kPerHostQuotaFor1000 =
       1000 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuota(GURL("http://usage10/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(kPerHostQuotaFor1000, quota());
 
   GetUsageAndQuota(GURL("http://usage50/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(50, usage());
   EXPECT_EQ(kPerHostQuotaFor1000, quota());
 
+  GetAvailableSpace();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_LE(0, available_space());
+
   GetUsageAndQuota(GURL("http://unlimited/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4000, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(available_space(), quota());
 
-  // Test when overbugdet.
+  // Test when over budget.
   SetTemporaryGlobalQuota(100);
   MessageLoop::current()->RunAllPending();
 
   const int kPerHostQuotaFor100 =
       100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuota(GURL("http://usage10/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(kPerHostQuotaFor100, quota());
 
   GetUsageAndQuota(GURL("http://usage50/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(50, usage());
   EXPECT_EQ(kPerHostQuotaFor100, quota());
 
+  GetAvailableSpace();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_LE(0, available_space());
+
   GetUsageAndQuota(GURL("http://unlimited/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4000, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(available_space(), quota());
 
   // Revoke the unlimited rights and make sure the change is noticed.
   mock_special_storage_policy()->Reset();
   mock_special_storage_policy()->NotifyChanged();
 
   GetGlobalUsage(kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(10 + 50 + 4000, usage());
   EXPECT_EQ(0, unlimited_usage());
 
@@ skipping 1169 matching lines @@
   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
 
   DeleteHostData("foo.com", kTemp,
       QuotaClient::kDatabase | QuotaClient::kIndexedDatabase);
   MessageLoop::current()->RunAllPending();
   GetHostUsage("foo.com", kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
 }
 }  // namespace quota