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

content/browser/quota/quota_temporary_storage_evictor_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 <stdint.h>
 
 #include <list>
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "content/public/test/mock_storage_client.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/browser/quota/quota_temporary_storage_evictor.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using storage::QuotaTemporaryStorageEvictor;
 using storage::StorageType;
-using storage::UsageAndQuota;
 
 namespace content {
 
 class QuotaTemporaryStorageEvictorTest;
 
 namespace {
 
 class MockQuotaEvictionHandler : public storage::QuotaEvictionHandler {
  public:
-  explicit MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest *test)
-      : quota_(0),
-        available_space_(0),
+  explicit MockQuotaEvictionHandler(QuotaTemporaryStorageEvictorTest* test)
+      : available_space_(0),
         error_on_evict_origin_data_(false),
         error_on_get_usage_and_quota_(false) {}
 
   void EvictOriginData(const GURL& origin,
                        StorageType type,
-                       const EvictOriginDataCallback& callback) override {
+                       const storage::StatusCallback& callback) override {
     if (error_on_evict_origin_data_) {
       callback.Run(storage::kQuotaErrorInvalidModification);
       return;
     }
     int64_t origin_usage = EnsureOriginRemoved(origin);
     if (origin_usage >= 0)
       available_space_ += origin_usage;
     callback.Run(storage::kQuotaStatusOk);
   }
 
-  void AsyncGetVolumeInfo(const VolumeInfoCallback& callback) override {
-    uint64_t available = static_cast<uint64_t>(available_space_);
-    uint64_t total = (1024 * 1024 * 1024) + (2 * available);  // 1G plus some.
-    callback.Run(true, available, total);
-  }
-
-  void GetUsageAndQuotaForEviction(
-      const UsageAndQuotaCallback& callback) override {
+  void GetEvictionRoundInfo(
+      const EvictionRoundInfoCallback& callback) override {
     if (error_on_get_usage_and_quota_) {
-      callback.Run(storage::kQuotaErrorInvalidAccess, UsageAndQuota());
+      callback.Run(storage::kQuotaErrorAbort, storage::QuotaSettings(), 0, 0, 0,
+                   false);
       return;
     }
     if (!task_for_get_usage_and_quota_.is_null())
       task_for_get_usage_and_quota_.Run();
-    UsageAndQuota quota_and_usage(-1, GetUsage(), quota_, available_space_);
-    callback.Run(storage::kQuotaStatusOk, quota_and_usage);
+    callback.Run(storage::kQuotaStatusOk, settings_, available_space_,
+                 available_space_ * 2, GetUsage(), true);
   }
 
   void GetEvictionOrigin(StorageType type,
                          const std::set<GURL>& exceptions,
                          int64_t global_quota,
                          const storage::GetOriginCallback& callback) override {
     if (origin_order_.empty())
       callback.Run(GURL());
     else
       callback.Run(GURL(origin_order_.front()));
   }
 
   int64_t GetUsage() const {
     int64_t total_usage = 0;
     for (std::map<GURL, int64_t>::const_iterator p = origins_.begin();
          p != origins_.end(); ++p)
       total_usage += p->second;
     return total_usage;
   }
 
-  void set_quota(int64_t quota) { quota_ = quota; }
+  const storage::QuotaSettings& settings() const { return settings_; }
+  void SetPoolSize(int64_t pool_size) {
+    settings_.pool_size = pool_size;
+    settings_.per_host_quota = pool_size / 5;
+    settings_.must_remain_available = pool_size / 5;
+    settings_.refresh_interval = base::TimeDelta::Max();
+  }
   void set_available_space(int64_t available_space) {
     available_space_ = available_space;
   }
   void set_task_for_get_usage_and_quota(const base::Closure& task) {
     task_for_get_usage_and_quota_= task;
   }
   void set_error_on_evict_origin_data(bool error_on_evict_origin_data) {
     error_on_evict_origin_data_ = error_on_evict_origin_data;
   }
   void set_error_on_get_usage_and_quota(bool error_on_get_usage_and_quota) {
@@ skipping 23 matching lines @@
     if (origins_.find(origin) == origins_.end())
       return -1;
     else
       origin_usage = origins_[origin];
 
     origins_.erase(origin);
     origin_order_.remove(origin);
     return origin_usage;
   }
 
-  int64_t quota_;
+  storage::QuotaSettings settings_;
   int64_t available_space_;
   std::list<GURL> origin_order_;
   std::map<GURL, int64_t> origins_;
   bool error_on_evict_origin_data_;
   bool error_on_get_usage_and_quota_;
 
   base::Closure task_for_get_usage_and_quota_;
 };
 
 }  // namespace
@@ skipping 18 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   void TaskForRepeatedEvictionTest(
       const std::pair<GURL, int64_t>& origin_to_be_added,
       const GURL& origin_to_be_accessed,
       int expected_usage_after_first,
       int expected_usage_after_second) {
     EXPECT_GE(4, num_get_usage_and_quota_for_eviction_);
     switch (num_get_usage_and_quota_for_eviction_) {
-    case 2:
-      EXPECT_EQ(expected_usage_after_first,
-                quota_eviction_handler()->GetUsage());
-      if (!origin_to_be_added.first.is_empty())
-        quota_eviction_handler()->AddOrigin(origin_to_be_added.first,
-                                            origin_to_be_added.second);
-      if (!origin_to_be_accessed.is_empty())
-        quota_eviction_handler()->AccessOrigin(origin_to_be_accessed);
-      break;
-    case 3:
-      EXPECT_EQ(expected_usage_after_second,
-                quota_eviction_handler()->GetUsage());
-      temporary_storage_evictor()->set_repeated_eviction(false);
-      break;
+      case 2:
+        EXPECT_EQ(expected_usage_after_first,
+                  quota_eviction_handler()->GetUsage());
+        if (!origin_to_be_added.first.is_empty())
+          quota_eviction_handler()->AddOrigin(origin_to_be_added.first,
+                                              origin_to_be_added.second);
+        if (!origin_to_be_accessed.is_empty())
+          quota_eviction_handler()->AccessOrigin(origin_to_be_accessed);
+        break;
+      case 3:
+        EXPECT_EQ(expected_usage_after_second,
+                  quota_eviction_handler()->GetUsage());
+        temporary_storage_evictor()->timer_disabled_for_testing_ = true;
+        break;
     }
     ++num_get_usage_and_quota_for_eviction_;
   }
 
  protected:
   MockQuotaEvictionHandler* quota_eviction_handler() const {
     return static_cast<MockQuotaEvictionHandler*>(
         quota_eviction_handler_.get());
   }
 
   QuotaTemporaryStorageEvictor* temporary_storage_evictor() const {
     return temporary_storage_evictor_.get();
   }
 
   const QuotaTemporaryStorageEvictor::Statistics& statistics() const {
     return temporary_storage_evictor()->statistics_;
   }
 
-  void set_repeated_eviction(bool repeated_eviction) const {
-    return temporary_storage_evictor_->set_repeated_eviction(repeated_eviction);
+  void disable_timer_for_testing() const {
+    temporary_storage_evictor_->timer_disabled_for_testing_ = true;
   }
 
   int num_get_usage_and_quota_for_eviction() const {
     return num_get_usage_and_quota_for_eviction_;
   }
 
-  int64_t default_min_available_disk_space_to_start_eviction() const {
-    return 1000 * 1000 * 500;
-  }
-
-  void set_min_available_disk_space_to_start_eviction(int64_t value) const {
-    temporary_storage_evictor_->set_min_available_disk_space_to_start_eviction(
-        value);
-  }
-
-  void reset_min_available_disk_space_to_start_eviction() const {
-    temporary_storage_evictor_->
-        reset_min_available_disk_space_to_start_eviction();
-  }
-
   base::MessageLoop message_loop_;
   std::unique_ptr<MockQuotaEvictionHandler> quota_eviction_handler_;
   std::unique_ptr<QuotaTemporaryStorageEvictor> temporary_storage_evictor_;
-
   int num_get_usage_and_quota_for_eviction_;
-
   base::WeakPtrFactory<QuotaTemporaryStorageEvictorTest> weak_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(QuotaTemporaryStorageEvictorTest);
 };
 
 TEST_F(QuotaTemporaryStorageEvictorTest, SimpleEvictionTest) {
   quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 3000);
   quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 200);
   quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 500);
-  quota_eviction_handler()->set_quota(4000);
+  quota_eviction_handler()->SetPoolSize(4000);
   quota_eviction_handler()->set_available_space(1000000000);
   EXPECT_EQ(3000 + 200 + 500, quota_eviction_handler()->GetUsage());
-  set_repeated_eviction(false);
+  disable_timer_for_testing();
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(200 + 500, quota_eviction_handler()->GetUsage());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(1, statistics().num_evicted_origins);
   EXPECT_EQ(1, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, MultipleEvictionTest) {
   quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 20);
   quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 2900);
   quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 450);
   quota_eviction_handler()->AddOrigin(GURL("http://www.w.com"), 400);
-  quota_eviction_handler()->set_quota(4000);
+  quota_eviction_handler()->SetPoolSize(4000);
   quota_eviction_handler()->set_available_space(1000000000);
   EXPECT_EQ(20 + 2900 + 450 + 400, quota_eviction_handler()->GetUsage());
-  set_repeated_eviction(false);
+  disable_timer_for_testing();
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(450 + 400, quota_eviction_handler()->GetUsage());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(2, statistics().num_evicted_origins);
   EXPECT_EQ(1, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, RepeatedEvictionTest) {
   const int64_t a_size = 400;
   const int64_t b_size = 150;
   const int64_t c_size = 120;
   const int64_t d_size = 292;
   const int64_t initial_total_size = a_size + b_size + c_size + d_size;
   const int64_t e_size = 275;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
-  quota_eviction_handler()->set_quota(1000);
+  quota_eviction_handler()->SetPoolSize(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
       base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
                  weak_factory_.GetWeakPtr(),
                  std::make_pair(GURL("http://www.e.com"), e_size), GURL(),
                  initial_total_size - d_size,
                  initial_total_size - d_size + e_size - c_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
@@ skipping 12 matching lines @@
   const int64_t a_size = 400;
   const int64_t b_size = 150;
   const int64_t c_size = 120;
   const int64_t d_size = 292;
   const int64_t initial_total_size = a_size + b_size + c_size + d_size;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
-  quota_eviction_handler()->set_quota(1000);
+  quota_eviction_handler()->SetPoolSize(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
       base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
                  weak_factory_.GetWeakPtr(), std::make_pair(GURL(), 0), GURL(),
                  initial_total_size - d_size, initial_total_size - d_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
-  set_repeated_eviction(true);
+  // disable_timer_for_testing();
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(initial_total_size - d_size, quota_eviction_handler()->GetUsage());
   EXPECT_EQ(4, num_get_usage_and_quota_for_eviction());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(1, statistics().num_evicted_origins);
   EXPECT_EQ(3, statistics().num_eviction_rounds);
   EXPECT_EQ(2, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, RepeatedEvictionWithAccessOriginTest) {
   const int64_t a_size = 400;
   const int64_t b_size = 150;
   const int64_t c_size = 120;
   const int64_t d_size = 292;
   const int64_t initial_total_size = a_size + b_size + c_size + d_size;
   const int64_t e_size = 275;
 
   quota_eviction_handler()->AddOrigin(GURL("http://www.d.com"), d_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.c.com"), c_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.b.com"), b_size);
   quota_eviction_handler()->AddOrigin(GURL("http://www.a.com"), a_size);
-  quota_eviction_handler()->set_quota(1000);
+  quota_eviction_handler()->SetPoolSize(1000);
   quota_eviction_handler()->set_available_space(1000000000);
   quota_eviction_handler()->set_task_for_get_usage_and_quota(
       base::Bind(&QuotaTemporaryStorageEvictorTest::TaskForRepeatedEvictionTest,
                  weak_factory_.GetWeakPtr(),
                  std::make_pair(GURL("http://www.e.com"), e_size),
                  GURL("http://www.c.com"),
                  initial_total_size - d_size,
                  initial_total_size - d_size + e_size - b_size));
   EXPECT_EQ(initial_total_size, quota_eviction_handler()->GetUsage());
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(initial_total_size - d_size + e_size - b_size - a_size,
             quota_eviction_handler()->GetUsage());
   EXPECT_EQ(5, num_get_usage_and_quota_for_eviction());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(3, statistics().num_evicted_origins);
   EXPECT_EQ(2, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, DiskSpaceNonEvictionTest) {
-  quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 414);
-  quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 450);
-  quota_eviction_handler()->set_quota(10000);
+  // If we're using so little that evicting all of it wouldn't
+  // do enough to alleviate a diskspace shortage, we don't evict.
+  quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 10);
+  quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 20);
+  quota_eviction_handler()->SetPoolSize(10000);
   quota_eviction_handler()->set_available_space(
-      default_min_available_disk_space_to_start_eviction() - 350);
-  EXPECT_EQ(414 + 450, quota_eviction_handler()->GetUsage());
-  reset_min_available_disk_space_to_start_eviction();
-  set_repeated_eviction(false);
+      quota_eviction_handler()->settings().must_remain_available - 350);
+  EXPECT_EQ(10 + 20, quota_eviction_handler()->GetUsage());
+  disable_timer_for_testing();
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(414 + 450, quota_eviction_handler()->GetUsage());
+  EXPECT_EQ(10 + 20, quota_eviction_handler()->GetUsage());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(0, statistics().num_evicted_origins);
   EXPECT_EQ(1, statistics().num_eviction_rounds);
   EXPECT_EQ(1, statistics().num_skipped_eviction_rounds);
 }
 
 TEST_F(QuotaTemporaryStorageEvictorTest, DiskSpaceEvictionTest) {
   quota_eviction_handler()->AddOrigin(GURL("http://www.z.com"), 294);
   quota_eviction_handler()->AddOrigin(GURL("http://www.y.com"), 120);
   quota_eviction_handler()->AddOrigin(GURL("http://www.x.com"), 150);
   quota_eviction_handler()->AddOrigin(GURL("http://www.w.com"), 300);
-  quota_eviction_handler()->set_quota(10000);
+  quota_eviction_handler()->SetPoolSize(10000);
   quota_eviction_handler()->set_available_space(
-      default_min_available_disk_space_to_start_eviction() - 350);
+      quota_eviction_handler()->settings().must_remain_available - 350);
   EXPECT_EQ(294 + 120 + 150 + 300, quota_eviction_handler()->GetUsage());
-  set_min_available_disk_space_to_start_eviction(
-      default_min_available_disk_space_to_start_eviction());
-  set_repeated_eviction(false);
+  disable_timer_for_testing();
   temporary_storage_evictor()->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(150 + 300, quota_eviction_handler()->GetUsage());
 
   EXPECT_EQ(0, statistics().num_errors_on_evicting_origin);
   EXPECT_EQ(0, statistics().num_errors_on_getting_usage_and_quota);
   EXPECT_EQ(2, statistics().num_evicted_origins);
   EXPECT_EQ(1, statistics().num_eviction_rounds);
   EXPECT_EQ(0, statistics().num_skipped_eviction_rounds);
 }
 
 }  // namespace content