Add a SiteEngagementEvictionPolicy.

storage/browser/quota/quota_manager.h

 // Copyright 2013 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.
 
 #ifndef STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_
 #define STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_
 
 #include <deque>
 #include <list>
 #include <map>
@@ skipping 51 matching lines @@
   int64 quota;
   int64 available_disk_space;
 
   UsageAndQuota();
   UsageAndQuota(int64 usage,
                 int64 global_limited_usage,
                 int64 quota,
                 int64 available_disk_space);
 };
 
+// TODO(calamity): Use this in the temporary storage eviction path.
+// An interface for deciding which origin's temporary storage should be evicted
+// when the quota is exceeded.
+class STORAGE_EXPORT TemporaryStorageEvictionPolicy {

[michaeln, 2015/07/23 02:26:18]

I'd vote for a simpler name, QuotaEvictionPolicy.

[calamity, 2015/07/28 01:07:59]

Done.

+ public:
+  // Returns the next origin to evict.  It might return an empty GURL when there
+  // are no evictable origins.
+  virtual void GetEvictionOrigin(const std::map<GURL, int64>& usage_map,

[michaeln, 2015/07/23 02:22:32]

I think we need to add SpecialStoragePolicy* to the inputs here. And consider
adding lastaccess times too?

[calamity, 2015/07/28 01:07:59]

I think the last access time is an improvement to the heuristic that can be
added later. I added the SpecialStoragePolicy stuff since that would affect the
correctness of this patch. Test added too.

+                                 int64 global_quota,
+                                 const GetEvictionOriginCallback& callback) = 0;
+
+ protected:
+  ~TemporaryStorageEvictionPolicy() {}
+};
+
 // An interface called by QuotaTemporaryStorageEvictor.
 class STORAGE_EXPORT QuotaEvictionHandler {
  public:
-  typedef base::Callback<void(const GURL&)> GetLRUOriginCallback;
   typedef StatusCallback EvictOriginDataCallback;
   typedef base::Callback<void(QuotaStatusCode status,
                               const UsageAndQuota& usage_and_quota)>
       UsageAndQuotaCallback;
 
-  // Returns the least recently used origin.  It might return empty
-  // GURL when there are no evictable origins.
-  virtual void GetLRUOrigin(
-      StorageType type,
-      const GetLRUOriginCallback& callback) = 0;
+  // Returns next origin to evict.  It might return an empty GURL when there are
+  // no evictable origins.
+  virtual void GetEvictionOrigin(StorageType type,
+                                 const GetEvictionOriginCallback& callback) = 0;
 
   virtual void EvictOriginData(
       const GURL& origin,
       StorageType type,
       const EvictOriginDataCallback& callback) = 0;
 
   virtual void GetUsageAndQuotaForEviction(
       const UsageAndQuotaCallback& callback) = 0;
 
  protected:
@@ skipping 259 matching lines @@
 
   void DidOriginDataEvicted(QuotaStatusCode status);
 
   void ReportHistogram();
   void DidGetTemporaryGlobalUsageForHistogram(int64 usage,
                                               int64 unlimited_usage);
   void DidGetPersistentGlobalUsageForHistogram(int64 usage,
                                                int64 unlimited_usage);
 
   // QuotaEvictionHandler.
-  void GetLRUOrigin(StorageType type,
-                    const GetLRUOriginCallback& callback) override;
+  void GetEvictionOrigin(StorageType type,
+                         const GetEvictionOriginCallback& callback) override;
   void EvictOriginData(const GURL& origin,
                        StorageType type,
                        const EvictOriginDataCallback& callback) override;
   void GetUsageAndQuotaForEviction(
       const UsageAndQuotaCallback& callback) override;
 
+  void GetLRUOrigin(StorageType type,
+                    const GetEvictionOriginCallback& callback);
+
   void DidSetTemporaryGlobalOverrideQuota(const QuotaCallback& callback,
                                           const int64* new_quota,
                                           bool success);
   void DidGetPersistentHostQuota(const std::string& host,
                                  const int64* quota,
                                  bool success);
   void DidSetPersistentHostQuota(const std::string& host,
                                  const QuotaCallback& callback,
                                  const int64* new_quota,
                                  bool success);
@@ skipping 18 matching lines @@
   const bool is_incognito_;
   const base::FilePath profile_path_;
 
   scoped_refptr<QuotaManagerProxy> proxy_;
   bool db_disabled_;
   bool eviction_disabled_;
   scoped_refptr<base::SingleThreadTaskRunner> io_thread_;
   scoped_refptr<base::SequencedTaskRunner> db_thread_;
   mutable scoped_ptr<QuotaDatabase> database_;
 
-  GetLRUOriginCallback lru_origin_callback_;
+  GetEvictionOriginCallback lru_origin_callback_;
   std::set<GURL> access_notified_origins_;
 
   QuotaClientList clients_;
 
   scoped_ptr<UsageTracker> temporary_usage_tracker_;
   scoped_ptr<UsageTracker> persistent_usage_tracker_;
   scoped_ptr<UsageTracker> syncable_usage_tracker_;
   // TODO(michaeln): Need a way to clear the cache, drop and
   // reinstantiate the trackers when they're not handling requests.
 
@@ skipping 32 matching lines @@
 
 struct QuotaManagerDeleter {
   static void Destruct(const QuotaManager* manager) {
     manager->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_