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;
 
+// Returns a deterministic value for the amount of available disk space.
+int64 GetAvailableDiskSpaceForTest(const FilePath&) {
+  return 13377331;
+}
+
 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)),
         mock_time_counter_(0) {
   }
 
   void SetUp() {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     mock_special_storage_policy_ = new MockSpecialStoragePolicy;
     quota_manager_ = new QuotaManager(
         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;
+    // Don't query the hard disk for remaining capacity.
+    quota_manager_->get_disk_space_fn_ = &GetAvailableDiskSpaceForTest;
     additional_callback_count_ = 0;
   }
 
   void TearDown() {
     // Make sure the quota manager cleans up correctly.
     quota_manager_ = NULL;
     MessageLoop::current()->RunAllPending();
   }
 
  protected:
   MockStorageClient* CreateClient(
       const MockOriginData* mock_data,
       size_t mock_data_size,
       QuotaClient::ID id) {
     return new MockStorageClient(quota_manager_->proxy(),
                                  mock_data, id, mock_data_size);
   }
 
   void RegisterClient(MockStorageClient* client) {
     quota_manager_->proxy()->RegisterClient(client);
   }
 
   void GetUsageInfo() {
     usage_info_.clear();
     quota_manager_->GetUsageInfo(
         base::Bind(&QuotaManagerTest::DidGetUsageInfo,
                    weak_factory_.GetWeakPtr()));
   }
 
-  void GetUsageAndQuota(const GURL& origin, StorageType type) {
+  void GetUsageAndQuota(const GURL& origin,
+                        StorageType type) {
     quota_status_ = kQuotaStatusUnknown;
     usage_ = -1;
     quota_ = -1;
     quota_manager_->GetUsageAndQuota(
-        origin, type,
-        base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
-                   weak_factory_.GetWeakPtr()));
+        origin, type, base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
+                                 weak_factory_.GetWeakPtr()));
   }
 
   void GetTemporaryGlobalQuota() {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->GetTemporaryGlobalQuota(
         base::Bind(&QuotaManagerTest::DidGetQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
@@ skipping 49 matching lines @@
   }
 
   void RunAdditionalUsageAndQuotaTask(const GURL& origin, StorageType type) {
     quota_manager_->GetUsageAndQuota(
         origin, type,
         base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaAdditional,
                    weak_factory_.GetWeakPtr()));
   }
 
   void DeleteClientOriginData(QuotaClient* client,
-                        const GURL& origin,
-                        StorageType type) {
+                              const GURL& origin,
+                              StorageType type) {
     DCHECK(client);
     quota_status_ = kQuotaStatusUnknown;
     client->DeleteOriginData(
         origin, type,
         base::Bind(&QuotaManagerTest::StatusCallback,
                    weak_factory_.GetWeakPtr()));
   }
 
   void EvictOriginData(const GURL& origin,
                        StorageType type) {
@@ skipping 411 matching lines @@
 
   GetUsageAndQuota(GURL("http://bar.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(5 + 7, usage());
   EXPECT_EQ(kPerHostQuota, quota());
 }
 
 TEST_F(QuotaManagerTest, GetUsage_MultipleClients) {
   static const MockOriginData kData1[] = {
-    { "http://foo.com/",     kTemp,  10 },
-    { "http://bar.com/",     kTemp,  20 },
+    { "http://foo.com/",     kTemp, 10 },
+    { "http://bar.com/",     kTemp, 20 },
     { "http://bar.com/",     kPerm, 50 },
-    { "http://unlimited/",   kPerm,  1 },
+    { "http://unlimited/",   kPerm, 1 },
+    { "http://installed/",   kPerm, 1 },
   };
   static const MockOriginData kData2[] = {
-    { "https://foo.com/",    kTemp,  30 },
+    { "https://foo.com/",    kTemp, 30 },
     { "http://example.com/", kPerm, 40 },
-    { "http://unlimited/",   kTemp,   1 },
+    { "http://unlimited/",   kTemp, 1 },
+    { "http://installed/",   kTemp, 1 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
+  mock_special_storage_policy()->AddInstalledApp(GURL("http://installed/"));
   RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
       QuotaClient::kFileSystem));
   RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
       QuotaClient::kDatabase));
 
   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());
 
   GetUsageAndQuota(GURL("http://unlimited/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(QuotaManager::kNoLimit, quota());
 
   GetUsageAndQuota(GURL("http://unlimited/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(QuotaManager::kNoLimit, quota());
+
+  GetAvailableSpace();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_LE(0, available_space());
+
+  GetUsageAndQuota(GURL("http://installed/"), kTemp);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(1, usage());
+  EXPECT_EQ(available_space(), quota());
+
+  GetUsageAndQuota(GURL("http://installed/"), kPerm);
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(1, usage());
+  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());
+  EXPECT_EQ(10 + 20 + 30 + 1 + 1, usage());
+  EXPECT_EQ(2, unlimited_usage());
 
   GetGlobalUsage(kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(40 + 50 + 1, usage());
-  EXPECT_EQ(1, unlimited_usage());
+  EXPECT_EQ(40 + 50 + 1 + 1, usage());
+  EXPECT_EQ(2, unlimited_usage());
 }
 
 void QuotaManagerTest::GetUsage_WithModifyTestBody(const StorageType type) {
   const MockOriginData data[] = {
     { "http://foo.com/",   type,  10 },
     { "http://foo.com:1/", type,  20 },
   };
   MockStorageClient* client = CreateClient(data, ARRAYSIZE_UNSAFE(data),
       QuotaClient::kFileSystem);
   RegisterClient(client);
@@ skipping 48 matching lines @@
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(kPerHostQuota, quota());
 
   set_additional_callback_count(0);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kTemp);
   GetUsageAndQuota(GURL("http://foo.com/"), kTemp);
-  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
-                                 kTemp);
+  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(kPerHostQuota, quota());
   EXPECT_EQ(2, additional_callback_count());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp, 10 },
@@ skipping 86 matching lines @@
   GetUsageAndQuota(GURL("http://usage50/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(50, usage());
   EXPECT_EQ(kPerHostQuotaFor1000, quota());
 
   GetUsageAndQuota(GURL("http://unlimited/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4000, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(QuotaManager::kNoLimit, quota());
 
   // Test when overbugdet.
   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());
 
   GetUsageAndQuota(GURL("http://unlimited/"), kTemp);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4000, usage());
-  EXPECT_EQ(kint64max, quota());
+  EXPECT_EQ(QuotaManager::kNoLimit, 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 119 matching lines @@
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(100, quota());
 
   set_additional_callback_count(0);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kPerm);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
-  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
-                                 kPerm);
+  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kPerm);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(2, additional_callback_count());
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_NukeManager) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm,  10 },
     { "http://foo.com:8080/",   kPerm,  20 },
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
       QuotaClient::kFileSystem));
   SetPersistentHostQuota("foo.com", 100);
 
   set_additional_callback_count(0);
   GetUsageAndQuota(GURL("http://foo.com/"), kPerm);
-  RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
-                                 kPerm);
-  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
-                                 kPerm);
+  RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"), kPerm);
+  RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kPerm);
 
   // Nuke before waiting for callbacks.
   set_quota_manager(NULL);
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(kQuotaErrorAbort, status());
 }
 
 TEST_F(QuotaManagerTest, GetUsage_Simple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kPerm,       1 },
@@ skipping 1005 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