Integrate SiteEngagementEvictionPolicy with QuotaManager.

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 <algorithm>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 40 matching lines @@
 const StorageType kPerm = kStorageTypePersistent;
 const StorageType kSync = kStorageTypeSyncable;
 
 const int kAllClients = QuotaClient::kAllClientsMask;
 
 const int64 kAvailableSpaceForApp = 13377331U;
 
 const int64 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 GetAvailableDiskSpaceForTest(const base::FilePath&) {
   return kAvailableSpaceForApp + kMinimumPreserveForSystem;
 }
 
+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::map<GURL, int64>& usage_map,
+                         int64 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 194 matching lines @@
                              StorageType type) {
     DCHECK(client);
     quota_manager_->NotifyStorageAccessedInternal(
         client->id(), origin, type, IncrementMockTime());
   }
 
   void DeleteOriginFromDatabase(const GURL& origin, StorageType type) {
     quota_manager_->DeleteOriginFromDatabase(origin, type);
   }
 
-  void GetLRUOrigin(StorageType type) {
-    lru_origin_ = GURL();
-    quota_manager_->GetLRUOrigin(
-        type,
-        base::Bind(&QuotaManagerTest::DidGetLRUOrigin,
-                   weak_factory_.GetWeakPtr()));
+  void GetEvictionOrigin(StorageType type) {
+    eviction_origin_ = GURL();
+    // The quota manager's default eviction policy is to use an LRU eviction
+    // policy.
+    quota_manager_->GetEvictionOrigin(
+        type, 0, base::Bind(&QuotaManagerTest::DidGetEvictionOrigin,
+                            weak_factory_.GetWeakPtr()));
   }
 
   void NotifyOriginInUse(const GURL& origin) {
     quota_manager_->NotifyOriginInUse(origin);
   }
 
   void NotifyOriginNoLongerInUse(const GURL& origin) {
     quota_manager_->NotifyOriginNoLongerInUse(origin);
   }
 
@@ skipping 63 matching lines @@
   }
 
   void DidGetUsageAndQuotaForEviction(QuotaStatusCode status,
                                       const UsageAndQuota& usage_and_quota) {
     quota_status_ = status;
     limited_usage_ = usage_and_quota.global_limited_usage;
     quota_ = usage_and_quota.quota;
     available_space_ = usage_and_quota.available_disk_space;
   }
 
-  void DidGetLRUOrigin(const GURL& origin) {
-    lru_origin_ = origin;
+  void DidGetEvictionOrigin(const GURL& origin) {
+    eviction_origin_ = origin;
   }
 
   void DidGetModifiedOrigins(const std::set<GURL>& origins, StorageType type) {
     modified_origins_ = origins;
     modified_origins_type_ = type;
   }
 
   void DidDumpQuotaTable(const QuotaTableEntries& entries) {
     quota_entries_ = entries;
   }
@@ skipping 20 matching lines @@
     return mock_special_storage_policy_.get();
   }
 
   QuotaStatusCode status() const { return quota_status_; }
   const UsageInfoEntries& usage_info() const { return usage_info_; }
   int64 usage() const { return usage_; }
   int64 limited_usage() const { return limited_usage_; }
   int64 unlimited_usage() const { return unlimited_usage_; }
   int64 quota() const { return quota_; }
   int64 available_space() const { return available_space_; }
-  const GURL& lru_origin() const { return lru_origin_; }
+  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_;
   }
   base::FilePath profile_path() const { return data_dir_.path(); }
   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 usage_;
   int64 limited_usage_;
   int64 unlimited_usage_;
   int64 quota_;
   int64 available_space_;
-  GURL lru_origin_;
+  GURL eviction_origin_;
   std::set<GURL> modified_origins_;
   StorageType modified_origins_type_;
   QuotaTableEntries quota_entries_;
   OriginInfoTableEntries origin_info_entries_;
   int status_callback_count_;
 
   int additional_callback_count_;
 
   int mock_time_counter_;
 
@@ skipping 804 matching lines @@
   EXPECT_EQ(predelete_host_pers, usage());
 }
 
 TEST_F(QuotaManagerTest, GetAvailableSpaceTest) {
   GetAvailableSpace();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_LE(0, available_space());
 }
 
+TEST_F(QuotaManagerTest, SetTemporaryStorageEvictionPolicy) {
+  quota_manager()->SetTemporaryStorageEvictionPolicy(
+      make_scoped_ptr(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 104 matching lines @@
     if (itr->type == kTemp &&
         GURL("http://foo.com/") == itr->origin) {
       found_origin_in_database = true;
       break;
     }
   }
   // The origin "http://foo.com/" should be in the database.
   EXPECT_TRUE(found_origin_in_database);
 
   for (size_t i = 0; i < kNumberOfTemporaryOrigins - 1; ++i) {
-    GetLRUOrigin(kTemp);
+    GetEvictionOrigin(kTemp);
     base::RunLoop().RunUntilIdle();
-    EXPECT_FALSE(lru_origin().is_empty());
+    EXPECT_FALSE(eviction_origin().is_empty());
     // The origin "http://foo.com/" should not be in the LRU list.
-    EXPECT_NE(std::string("http://foo.com/"), lru_origin().spec());
-    DeleteOriginFromDatabase(lru_origin(), kTemp);
+    EXPECT_NE(std::string("http://foo.com/"), eviction_origin().spec());
+    DeleteOriginFromDatabase(eviction_origin(), kTemp);
     base::RunLoop().RunUntilIdle();
   }
 
   // Now the LRU list must be empty.
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lru_origin().is_empty());
+  EXPECT_TRUE(eviction_origin().is_empty());
 
   // Deleting origins from the database should not affect the results of the
   // following checks.
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_global_tmp, usage());
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_host_tmp, usage());
@@ skipping 308 matching lines @@
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GURL origin;
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lru_origin().is_empty());
+  EXPECT_TRUE(eviction_origin().is_empty());
 
   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ("http://a.com/", lru_origin().spec());
+  EXPECT_EQ("http://a.com/", eviction_origin().spec());
 
   NotifyStorageAccessed(client, GURL("http://b.com/"), kPerm);
   NotifyStorageAccessed(client, GURL("https://a.com/"), kTemp);
   NotifyStorageAccessed(client, GURL("http://c.com/"), kTemp);
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ("http://a.com/", lru_origin().spec());
+  EXPECT_EQ("http://a.com/", eviction_origin().spec());
 
-  DeleteOriginFromDatabase(lru_origin(), kTemp);
-  GetLRUOrigin(kTemp);
+  DeleteOriginFromDatabase(eviction_origin(), kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ("https://a.com/", lru_origin().spec());
+  EXPECT_EQ("https://a.com/", eviction_origin().spec());
 
-  DeleteOriginFromDatabase(lru_origin(), kTemp);
-  GetLRUOrigin(kTemp);
+  DeleteOriginFromDatabase(eviction_origin(), kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ("http://c.com/", lru_origin().spec());
+  EXPECT_EQ("http://c.com/", eviction_origin().spec());
 }
 
 TEST_F(QuotaManagerTest, GetLRUOriginWithOriginInUse) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GURL origin;
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(lru_origin().is_empty());
+  EXPECT_TRUE(eviction_origin().is_empty());
 
   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
   NotifyStorageAccessed(client, GURL("http://b.com/"), kPerm);
   NotifyStorageAccessed(client, GURL("https://a.com/"), kTemp);
   NotifyStorageAccessed(client, GURL("http://c.com/"), kTemp);
 
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ("http://a.com/", lru_origin().spec());
+  EXPECT_EQ("http://a.com/", eviction_origin().spec());
 
   // Notify origin http://a.com is in use.
   NotifyOriginInUse(GURL("http://a.com/"));
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ("https://a.com/", lru_origin().spec());
+  EXPECT_EQ("https://a.com/", eviction_origin().spec());
 
-  // Notify origin https://a.com is in use while GetLRUOrigin is running.
-  GetLRUOrigin(kTemp);
+  // Notify origin https://a.com is in use while GetEvictionOrigin is running.
+  GetEvictionOrigin(kTemp);
   NotifyOriginInUse(GURL("https://a.com/"));
   base::RunLoop().RunUntilIdle();
   // Post-filtering must have excluded the returned origin, so we will
   // see empty result here.
-  EXPECT_TRUE(lru_origin().is_empty());
+  EXPECT_TRUE(eviction_origin().is_empty());
 
-  // Notify access for http://c.com while GetLRUOrigin is running.
-  GetLRUOrigin(kTemp);
+  // Notify access for http://c.com while GetEvictionOrigin is running.
+  GetEvictionOrigin(kTemp);
   NotifyStorageAccessed(client, GURL("http://c.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   // Post-filtering must have excluded the returned origin, so we will
   // see empty result here.
-  EXPECT_TRUE(lru_origin().is_empty());
+  EXPECT_TRUE(eviction_origin().is_empty());
 
   NotifyOriginNoLongerInUse(GURL("http://a.com/"));
   NotifyOriginNoLongerInUse(GURL("https://a.com/"));
-  GetLRUOrigin(kTemp);
+  GetEvictionOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
-  EXPECT_EQ("http://a.com/", lru_origin().spec());
+  EXPECT_EQ("http://a.com/", eviction_origin().spec());
 }
 
 TEST_F(QuotaManagerTest, GetOriginsModifiedSince) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
@@ skipping 356 matching lines @@
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 }
 
 }  // namespace content