Revert of Change how the quota system computes the total poolsize for temporary storage

content/browser/quota/quota_manager_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <set>
@@ skipping 26 matching lines @@
 using storage::kQuotaStatusOk;
 using storage::kQuotaStatusUnknown;
 using storage::kStorageTypePersistent;
 using storage::kStorageTypeSyncable;
 using storage::kStorageTypeTemporary;
 using storage::kStorageTypeUnknown;
 using storage::QuotaClient;
 using storage::QuotaManager;
 using storage::QuotaStatusCode;
 using storage::StorageType;
+using storage::UsageAndQuota;
 using storage::UsageInfo;
 using storage::UsageInfoEntries;
 
 namespace content {
 
 namespace {
 
 // For shorter names.
 const StorageType kTemp = kStorageTypeTemporary;
 const StorageType kPerm = kStorageTypePersistent;
 const StorageType kSync = kStorageTypeSyncable;
 
 const int kAllClients = QuotaClient::kAllClientsMask;
 
-// Values in bytes.
 const int64_t kAvailableSpaceForApp = 13377331U;
-const int64_t kMustRemainAvailableForSystem = kAvailableSpaceForApp / 2;
-const int64_t kDefaultPoolSize = 1000;
-const int64_t kDefaultPerHostQuota = 200;
+
+const int64_t kMinimumPreserveForSystem =
+    QuotaManager::kMinimumPreserveForSystem;
+const int kPerHostTemporaryPortion = QuotaManager::kPerHostTemporaryPortion;
 
 const GURL kTestEvictionOrigin = GURL("http://test.eviction.policy/result");
 
 // Returns a deterministic value for the amount of available disk space.
 int64_t GetAvailableDiskSpaceForTest() {
-  return kAvailableSpaceForApp + kMustRemainAvailableForSystem;
+  return kAvailableSpaceForApp + kMinimumPreserveForSystem;
 }
 
-std::pair<int64_t, int64_t> GetVolumeInfoForTests(
-    const base::FilePath& unused) {
-  int64_t available = static_cast<uint64_t>(GetAvailableDiskSpaceForTest());
-  int64_t total = available * 2;
-  return std::make_pair(total, available);
+bool GetVolumeInfoForTests(const base::FilePath&,
+                           uint64_t* available, uint64_t* total) {
+  *available = static_cast<uint64_t>(GetAvailableDiskSpaceForTest());
+  *total = *available * 2;
+  return true;
 }
 
+class TestEvictionPolicy : public storage::QuotaEvictionPolicy {
+ public:
+  TestEvictionPolicy() {}
+  ~TestEvictionPolicy() override {}
+
+  // Overridden from storage::QuotaEvictionPolicy:
+  void GetEvictionOrigin(const scoped_refptr<storage::SpecialStoragePolicy>&
+                             special_storage_policy,
+                         const std::set<GURL>& exceptions,
+                         const std::map<GURL, int64_t>& usage_map,
+                         int64_t global_quota,
+                         const storage::GetOriginCallback& callback) override {
+    callback.Run(kTestEvictionOrigin);
+  }
+};
+
 }  // namespace
 
 class QuotaManagerTest : public testing::Test {
  protected:
   typedef QuotaManager::QuotaTableEntry QuotaTableEntry;
   typedef QuotaManager::QuotaTableEntries QuotaTableEntries;
   typedef QuotaManager::OriginInfoTableEntries OriginInfoTableEntries;
 
  public:
   QuotaManagerTest()
@@ skipping 11 matching lines @@
     // Make sure the quota manager cleans up correctly.
     quota_manager_ = NULL;
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   void ResetQuotaManager(bool is_incognito) {
     quota_manager_ = new QuotaManager(is_incognito, data_dir_.GetPath(),
                                       base::ThreadTaskRunnerHandle::Get().get(),
                                       base::ThreadTaskRunnerHandle::Get().get(),
-                                      mock_special_storage_policy_.get(),
-                                      storage::GetQuotaSettingsFunc());
-    SetQuotaSettings(kDefaultPoolSize, kDefaultPerHostQuota,
-                     is_incognito ? INT64_C(0) : kMustRemainAvailableForSystem);
-
+                                      mock_special_storage_policy_.get());
     // 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_volume_info_fn_= &GetVolumeInfoForTests;
     additional_callback_count_ = 0;
   }
 
   MockStorageClient* CreateClient(
       const MockOriginData* mock_data,
       size_t mock_data_size,
@@ skipping 26 matching lines @@
   void GetUsageAndQuotaForStorageClient(const GURL& origin,
                                         StorageType type) {
     quota_status_ = kQuotaStatusUnknown;
     usage_ = -1;
     quota_ = -1;
     quota_manager_->GetUsageAndQuota(
         origin, type, base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
                                  weak_factory_.GetWeakPtr()));
   }
 
-  void SetQuotaSettings(int64_t pool_size,
-                        int64_t per_host_quota,
-                        int64_t must_remain_available) {
-    storage::QuotaSettings settings;
-    settings.pool_size = pool_size;
-    settings.per_host_quota = per_host_quota;
-    settings.must_remain_available = must_remain_available;
-    settings.refresh_interval = base::TimeDelta::Max();
-    quota_manager_->SetQuotaSettings(settings);
+  void GetTemporaryGlobalQuota() {
+    quota_status_ = kQuotaStatusUnknown;
+    quota_ = -1;
+    quota_manager_->GetTemporaryGlobalQuota(
+        base::Bind(&QuotaManagerTest::DidGetQuota,
+                   weak_factory_.GetWeakPtr()));
+  }
+
+  void SetTemporaryGlobalQuota(int64_t new_quota) {
+    quota_status_ = kQuotaStatusUnknown;
+    quota_ = -1;
+    quota_manager_->SetTemporaryGlobalOverrideQuota(
+        new_quota,
+        base::Bind(&QuotaManagerTest::DidGetQuota,
+                   weak_factory_.GetWeakPtr()));
   }
 
   void GetPersistentHostQuota(const std::string& host) {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->GetPersistentHostQuota(
         host,
         base::Bind(&QuotaManagerTest::DidGetHostQuota,
                    weak_factory_.GetWeakPtr()));
   }
@@ skipping 64 matching lines @@
   void DeleteHostData(const std::string& host,
                       StorageType type,
                       int quota_client_mask) {
     quota_status_ = kQuotaStatusUnknown;
     quota_manager_->DeleteHostData(
         host, type, quota_client_mask,
         base::Bind(&QuotaManagerTest::StatusCallback,
                    weak_factory_.GetWeakPtr()));
   }
 
-  void GetStorageCapacity() {
+  void GetAvailableSpace() {
+    quota_status_ = kQuotaStatusUnknown;
     available_space_ = -1;
-    total_space_ = -1;
-    quota_manager_->GetStorageCapacity(base::Bind(
-        &QuotaManagerTest::DidGetStorageCapacity, weak_factory_.GetWeakPtr()));
-  }
-
-  void GetEvictionRoundInfo() {
-    quota_status_ = kQuotaStatusUnknown;
-    settings_ = storage::QuotaSettings();
-    available_space_ = -1;
-    total_space_ = -1;
-    usage_ = -1;
-    quota_manager_->GetEvictionRoundInfo(
-        base::Bind(&QuotaManagerTest::DidGetEvictionRoundInfo,
+    quota_manager_->GetAvailableSpace(
+        base::Bind(&QuotaManagerTest::DidGetAvailableSpace,
                    weak_factory_.GetWeakPtr()));
   }
 
+  void GetUsageAndQuotaForEviction() {
+    quota_status_ = kQuotaStatusUnknown;
+    usage_ = -1;
+    unlimited_usage_ = -1;
+    quota_ = -1;
+    available_space_ = -1;
+    quota_manager_->GetUsageAndQuotaForEviction(
+        base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaForEviction,
+                   weak_factory_.GetWeakPtr()));
+  }
+
   void GetCachedOrigins(StorageType type, std::set<GURL>* origins) {
     ASSERT_TRUE(origins != NULL);
     origins->clear();
     quota_manager_->GetCachedOrigins(type, origins);
   }
 
+  bool GetVolumeInfo(const base::FilePath& path,
+                     uint64_t* available_space,
+                     uint64_t* total_size) {
+    return QuotaManager::GetVolumeInfo(path, available_space, total_size);
+  }
+
   void NotifyStorageAccessed(QuotaClient* client,
                              const GURL& origin,
                              StorageType type) {
     DCHECK(client);
     quota_manager_->NotifyStorageAccessedInternal(
         client->id(), origin, type, IncrementMockTime());
   }
 
   void DeleteOriginFromDatabase(const GURL& origin, StorageType type) {
     quota_manager_->DeleteOriginFromDatabase(origin, type, false);
@@ skipping 50 matching lines @@
     quota_status_ = status;
     usage_ = usage;
     quota_ = quota;
   }
 
   void DidGetQuota(QuotaStatusCode status, int64_t quota) {
     quota_status_ = status;
     quota_ = quota;
   }
 
-  void DidGetStorageCapacity(int64_t total_space, int64_t available_space) {
-    total_space_ = total_space;
+  void DidGetAvailableSpace(QuotaStatusCode status, int64_t available_space) {
+    quota_status_ = status;
     available_space_ = available_space;
   }
 
   void DidGetHostQuota(QuotaStatusCode status, int64_t quota) {
     quota_status_ = status;
     quota_ = quota;
   }
 
   void DidGetGlobalUsage(int64_t usage, int64_t unlimited_usage) {
     usage_ = usage;
     unlimited_usage_ = unlimited_usage;
   }
 
   void DidGetHostUsage(int64_t usage) { usage_ = usage; }
 
   void StatusCallback(QuotaStatusCode status) {
     ++status_callback_count_;
     quota_status_ = status;
   }
 
-  void DidGetEvictionRoundInfo(QuotaStatusCode status,
-                               const storage::QuotaSettings& settings,
-                               int64_t available_space,
-                               int64_t total_space,
-                               int64_t global_usage,
-                               bool global_usage_is_complete) {
+  void DidGetUsageAndQuotaForEviction(QuotaStatusCode status,
+                                      const UsageAndQuota& usage_and_quota) {
     quota_status_ = status;
-    settings_ = settings;
-    available_space_ = available_space;
-    total_space_ = total_space;
-    usage_ = global_usage;
+    limited_usage_ = usage_and_quota.global_limited_usage;
+    quota_ = usage_and_quota.quota;
+    available_space_ = usage_and_quota.available_disk_space;
   }
 
   void DidGetEvictionOrigin(const GURL& origin) {
     eviction_origin_ = origin;
   }
 
   void DidGetModifiedOrigins(const std::set<GURL>& origins, StorageType type) {
     modified_origins_ = origins;
     modified_origins_type_ = type;
   }
@@ skipping 24 matching lines @@
   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_; }
   int64_t usage() const { return usage_; }
   int64_t limited_usage() const { return limited_usage_; }
   int64_t unlimited_usage() const { return unlimited_usage_; }
   int64_t quota() const { return quota_; }
-  int64_t total_space() const { return total_space_; }
   int64_t available_space() const { return available_space_; }
   const GURL& eviction_origin() const { return eviction_origin_; }
   const std::set<GURL>& modified_origins() const { return modified_origins_; }
   StorageType modified_origins_type() const { return modified_origins_type_; }
   const QuotaTableEntries& quota_entries() const { return quota_entries_; }
   const OriginInfoTableEntries& origin_info_entries() const {
     return origin_info_entries_;
   }
-  const storage::QuotaSettings& settings() const { return settings_; }
   base::FilePath profile_path() const { return data_dir_.GetPath(); }
   int status_callback_count() const { return status_callback_count_; }
   void reset_status_callback_count() { status_callback_count_ = 0; }
 
  private:
   base::Time IncrementMockTime() {
     ++mock_time_counter_;
     return base::Time::FromDoubleT(mock_time_counter_ * 10.0);
   }
 
   base::MessageLoop message_loop_;
   base::ScopedTempDir data_dir_;
 
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;
 
   QuotaStatusCode quota_status_;
   UsageInfoEntries usage_info_;
   int64_t usage_;
   int64_t limited_usage_;
   int64_t unlimited_usage_;
   int64_t quota_;
-  int64_t total_space_;
   int64_t available_space_;
   GURL eviction_origin_;
   std::set<GURL> modified_origins_;
   StorageType modified_origins_type_;
   QuotaTableEntries quota_entries_;
   OriginInfoTableEntries origin_info_entries_;
-  storage::QuotaSettings settings_;
   int status_callback_count_;
 
   int additional_callback_count_;
 
   int mock_time_counter_;
 
   base::WeakPtrFactory<QuotaManagerTest> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManagerTest);
 };
@@ skipping 132 matching lines @@
     { "http://foo.com:8080/",   kTemp,  20 },
     { "http://bar.com/",        kTemp,   5 },
     { "https://bar.com/",       kTemp,   7 },
     { "http://baz.com/",        kTemp,  30 },
     { "http://foo.com/",        kPerm,  40 },
   };
   RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
 
   // This time explicitly sets a temporary global quota.
-  const int kPoolSize = 100;
-  const int kPerHostQuota = 20;
-  SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
+  SetTemporaryGlobalQuota(100);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(100, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
 
+  const int kPerHostQuota = 100 / kPerHostTemporaryPortion;
+
   // The host's quota should be its full portion of the global quota
-  // since there's plenty of diskspace.
+  // since global usage is under the global quota.
   EXPECT_EQ(kPerHostQuota, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   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, 1 },
     { "http://bar.com/",              kTemp, 2 },
     { "http://bar.com/",              kPerm, 4 },
     { "http://unlimited/",            kPerm, 8 },
+    { "http://installed/",            kPerm, 16 },
   };
   static const MockOriginData kData2[] = {
     { "https://foo.com/",             kTemp, 128 },
     { "http://example.com/",          kPerm, 256 },
     { "http://unlimited/",            kTemp, 512 },
+    { "http://installed/",            kTemp, 1024 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
+  mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
   RegisterClient(CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem));
   RegisterClient(CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase));
 
-  const int64_t kPoolSize = GetAvailableDiskSpaceForTest();
-  const int64_t kPerHostQuota = kPoolSize / 5;
-  SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
+  const int64_t kTempQuotaBase =
+      GetAvailableDiskSpaceForTest() / kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1 + 128, usage());
-  EXPECT_EQ(kPerHostQuota, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4, usage());
-  EXPECT_EQ(0, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(512, usage());
-  EXPECT_EQ(kAvailableSpaceForApp + usage(), quota());
+  EXPECT_EQ(std::min(kAvailableSpaceForApp, kTempQuotaBase) + usage(), quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(8, usage());
   EXPECT_EQ(kAvailableSpaceForApp + usage(), quota());
 
+  GetAvailableSpace();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_LE(0, available_space());
+
+  GetUsageAndQuotaForWebApps(GURL("http://installed/"), kTemp);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(1024, usage());
+  EXPECT_EQ(std::min(kAvailableSpaceForApp, kTempQuotaBase) + usage(), quota());
+
+  GetUsageAndQuotaForWebApps(GURL("http://installed/"), kPerm);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(16, usage());
+  EXPECT_EQ(usage(), quota());  // Over-budget case.
+
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(1 + 2 + 128 + 512, usage());
+  EXPECT_EQ(1 + 2 + 128 + 512 + 1024, usage());
   EXPECT_EQ(512, unlimited_usage());
 
   GetGlobalUsage(kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(4 + 8 + 256, usage());
+  EXPECT_EQ(4 + 8 + 16 + 256, usage());
   EXPECT_EQ(8, 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(data),
       QuotaClient::kFileSystem);
@@ skipping 32 matching lines @@
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_WithAdditionalTasks) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp, 10 },
     { "http://foo.com:8080/",   kTemp, 20 },
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
   RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
+  SetTemporaryGlobalQuota(100);
+  base::RunLoop().RunUntilIdle();
 
-  const int kPoolSize = 100;
-  const int kPerHostQuota = 20;
-  SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
+  const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(kPerHostQuota, quota());
 
   set_additional_callback_count(0);
@@ skipping 10 matching lines @@
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp, 10 },
     { "http://foo.com:8080/",   kTemp, 20 },
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
   RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
-  const int kPoolSize = 100;
-  const int kPerHostQuota = 20;
-  SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
+  SetTemporaryGlobalQuota(100);
+  base::RunLoop().RunUntilIdle();
 
   set_additional_callback_count(0);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kTemp);
   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
                                  kTemp);
 
   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
   DeleteOriginData(GURL("http://bar.com/"), kTemp, kAllClients);
 
   // Nuke before waiting for callbacks.
   set_quota_manager(NULL);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaErrorAbort, status());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Overbudget) {
   static const MockOriginData kData[] = {
     { "http://usage1/",    kTemp,   1 },
     { "http://usage10/",   kTemp,  10 },
     { "http://usage200/",  kTemp, 200 },
   };
   RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
-  const int kPoolSize = 100;
-  const int kPerHostQuota = 20;
-  SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
+  SetTemporaryGlobalQuota(100);
+  base::RunLoop().RunUntilIdle();
 
-  // Provided diskspace is not tight, global usage does not affect the
-  // quota calculations for an individual origin, so despite global usage
-  // in excess of our poolsize, we still get the nominal quota value.
-  GetStorageCapacity();
-  base::RunLoop().RunUntilIdle();
-  EXPECT_LE(kMustRemainAvailableForSystem, available_space());
+  const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://usage1/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1, usage());
-  EXPECT_EQ(kPerHostQuota, quota());
+  EXPECT_EQ(1, quota());  // should be clamped to our current usage
 
   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
-  EXPECT_EQ(kPerHostQuota, quota());
+  EXPECT_EQ(10, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://usage200/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(200, usage());
   EXPECT_EQ(kPerHostQuota, quota());  // should be clamped to the nominal quota
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Unlimited) {
   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(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   // Test when not overbugdet.
-  const int kPerHostQuotaFor1000 = 200;
-  SetQuotaSettings(1000, kPerHostQuotaFor1000, kMustRemainAvailableForSystem);
+  SetTemporaryGlobalQuota(1000);
+  base::RunLoop().RunUntilIdle();
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(10 + 50 + 4000, usage());
   EXPECT_EQ(4000, unlimited_usage());
 
+  const int kPerHostQuotaFor1000 =
+      1000 / QuotaManager::kPerHostTemporaryPortion;
+
   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(kPerHostQuotaFor1000, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://usage50/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(50, usage());
   EXPECT_EQ(kPerHostQuotaFor1000, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4000, usage());
   EXPECT_EQ(kAvailableSpaceForApp + usage(), quota());
 
   GetUsageAndQuotaForStorageClient(GURL("http://unlimited/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
   EXPECT_EQ(QuotaManager::kNoLimit, quota());
 
   // Test when overbugdet.
-  const int kPerHostQuotaFor100 = 20;
-  SetQuotaSettings(100, kPerHostQuotaFor100, kMustRemainAvailableForSystem);
+  SetTemporaryGlobalQuota(100);
+  base::RunLoop().RunUntilIdle();
+
+  const int kPerHostQuotaFor100 =
+      100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(kPerHostQuotaFor100, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://usage50/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
@@ skipping 18 matching lines @@
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(10 + 50 + 4000, usage());
   EXPECT_EQ(0, unlimited_usage());
 
   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
-  EXPECT_EQ(kPerHostQuotaFor100, quota());
+  EXPECT_EQ(10, quota());  // should be clamped to our current usage
 
   GetUsageAndQuotaForWebApps(GURL("http://usage50/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(50, usage());
   EXPECT_EQ(kPerHostQuotaFor100, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
@@ skipping 65 matching lines @@
   EXPECT_EQ(0, usage());
   EXPECT_EQ(0, quota());
 
   SetPersistentHostQuota("foo.com", 100);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
   EXPECT_EQ(100, quota());
 
-  // The actual space avaialble is given to 'unlimited' origins as their quota.
+  // For installed app GetUsageAndQuotaForWebApps returns the capped quota.
+  mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
+  SetPersistentHostQuota("installed", kAvailableSpaceForApp + 100);
+  GetUsageAndQuotaForWebApps(GURL("http://installed/"), kPerm);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kAvailableSpaceForApp, quota());
+
+  // Ditto for unlimited apps.
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kAvailableSpaceForApp, quota());
 
   // GetUsageAndQuotaForStorageClient should just return 0 usage and
   // kNoLimit quota.
   GetUsageAndQuotaForStorageClient(GURL("http://unlimited/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0, usage());
   EXPECT_EQ(QuotaManager::kNoLimit, quota());
 }
 
 TEST_F(QuotaManagerTest, GetSyncableQuota) {
   RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
 
   // Pre-condition check: available disk space (for testing) is less than
   // the default quota for syncable storage.
   EXPECT_LE(kAvailableSpaceForApp,
             QuotaManager::kSyncableStorageDefaultHostQuota);
 
-  // For unlimited origins the quota manager should return
+  // For installed apps the quota manager should return
   // kAvailableSpaceForApp as syncable quota (because of the pre-condition).
-  mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kSync);
+  mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
+  GetUsageAndQuotaForWebApps(GURL("http://installed/"), kSync);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
   EXPECT_EQ(kAvailableSpaceForApp, quota());
+
+  // If it's not installed (which shouldn't happen in real case) it
+  // should just return the default host quota for syncable.
+  GetUsageAndQuotaForWebApps(GURL("http://foo/"), kSync);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kQuotaStatusOk, status());
+  EXPECT_EQ(0, usage());
+  EXPECT_EQ(QuotaManager::kSyncableStorageDefaultHostQuota, quota());
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_MultiOrigins) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm, 10 },
     { "http://foo.com:8080/",   kPerm, 20 },
     { "https://foo.com/",       kPerm, 13 },
     { "https://foo.com:8081/",  kPerm, 19 },
     { "http://bar.com/",        kPerm,  5 },
     { "https://bar.com/",       kPerm,  7 },
@@ skipping 186 matching lines @@
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_host_tmp - 1, usage());
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_host_pers, usage());
 }
 
-TEST_F(QuotaManagerTest, GetStorageCapacity) {
-  GetStorageCapacity();
+TEST_F(QuotaManagerTest, GetAvailableSpaceTest) {
+  GetAvailableSpace();
   base::RunLoop().RunUntilIdle();
-  EXPECT_LE(0, total_space());
+  EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_LE(0, available_space());
 }
 
+TEST_F(QuotaManagerTest, SetTemporaryStorageEvictionPolicy) {
+  quota_manager()->SetTemporaryStorageEvictionPolicy(
+      base::WrapUnique(new TestEvictionPolicy));
+
+  GetEvictionOrigin(kTemp);
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(kTestEvictionOrigin, eviction_origin());
+}
+
 TEST_F(QuotaManagerTest, EvictOriginData) {
   static const MockOriginData kData1[] = {
     { "http://foo.com/",   kTemp,     1 },
     { "http://foo.com:1/", kTemp,    20 },
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 50000 },
     { "http://foo.com:1/", kTemp,  6000 },
@@ skipping 198 matching lines @@
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_host_tmp, usage());
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_host_pers, usage());
 }
 
-TEST_F(QuotaManagerTest, GetEvictionRoundInfo) {
+TEST_F(QuotaManagerTest, GetUsageAndQuotaForEviction) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,       1 },
     { "http://foo.com:1/", kTemp,      20 },
     { "http://foo.com/",   kPerm,     300 },
     { "http://unlimited/", kTemp,    4000 },
   };
 
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
-  const int kPoolSize = 10000000;
-  const int kPerHostQuota = kPoolSize / 5;
-  SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
+  SetTemporaryGlobalQuota(10000000);
+  base::RunLoop().RunUntilIdle();
 
-  GetEvictionRoundInfo();
+  GetUsageAndQuotaForEviction();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
-  EXPECT_EQ(21, usage());
-  EXPECT_EQ(kPoolSize, settings().pool_size);
+  EXPECT_EQ(21, limited_usage());
+  EXPECT_EQ(10000000, quota());
   EXPECT_LE(0, available_space());
 }
 
 TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
   };
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
@@ skipping 232 matching lines @@
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   // TODO(kinuko): Be careful when we add cache pruner.
 
   std::set<GURL> origins;
   GetCachedOrigins(kTemp, &origins);
   EXPECT_TRUE(origins.empty());
 
+  // No matter how we make queries the quota manager tries to cache all
+  // the origins at startup.
   GetHostUsage("a.com", kTemp);
   base::RunLoop().RunUntilIdle();
   GetCachedOrigins(kTemp, &origins);
-  EXPECT_EQ(2U, origins.size());
+  EXPECT_EQ(3U, origins.size());
 
   GetHostUsage("b.com", kTemp);
   base::RunLoop().RunUntilIdle();
   GetCachedOrigins(kTemp, &origins);
-  EXPECT_EQ(2U, origins.size());
-
-  GetHostUsage("c.com", kTemp);
-  base::RunLoop().RunUntilIdle();
-  GetCachedOrigins(kTemp, &origins);
   EXPECT_EQ(3U, origins.size());
 
   GetCachedOrigins(kPerm, &origins);
   EXPECT_TRUE(origins.empty());
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   GetCachedOrigins(kTemp, &origins);
   EXPECT_EQ(3U, origins.size());
 
@@ skipping 436 matching lines @@
 TEST_F(QuotaManagerTest, GetUsageAndQuota_Incognito) {
   ResetQuotaManager(true);
 
   static const MockOriginData kData[] = {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
   RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
 
-  // Query global usage to warmup the usage tracker caching.
-  GetGlobalUsage(kTemp);
-  GetGlobalUsage(kPerm);
-  base::RunLoop().RunUntilIdle();
-
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
   EXPECT_EQ(0, quota());
 
-  const int kPoolSize = 1000;
-  const int kPerHostQuota = kPoolSize / 5;
-  SetQuotaSettings(kPoolSize, kPerHostQuota, INT64_C(0));
-
-  GetStorageCapacity();
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(kPoolSize, total_space());
-  EXPECT_EQ(kPoolSize - 80 - 10, available_space());
-
+  SetTemporaryGlobalQuota(100);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
-  EXPECT_LE(kPerHostQuota, quota());
+  EXPECT_LE(std::min(static_cast<int64_t>(100 / kPerHostTemporaryPortion),
+                     QuotaManager::kIncognitoDefaultQuotaLimit),
+            quota());
 
   mock_special_storage_policy()->AddUnlimited(GURL("http://foo.com/"));
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
-  EXPECT_EQ(available_space() + usage(), quota());
+  EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
-  EXPECT_EQ(available_space() + usage(), quota());
+  EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
+}
+
+TEST_F(QuotaManagerTest, GetVolumeInfo) {
+  // We aren't actually testing that it's correct, just that it's sane.
+  base::FilePath tmp_dir;
+  ASSERT_TRUE(base::GetTempDir(&tmp_dir));
+  uint64_t available_space = 0;
+  uint64_t total_size = 0;
+  EXPECT_TRUE(GetVolumeInfo(tmp_dir, &available_space, &total_size));
+  EXPECT_GT(available_space, 0u) << tmp_dir.value();
+  EXPECT_GT(total_size, 0u) << tmp_dir.value();
 }
 
 }  // namespace content