Integrate SiteEngagementEvictionPolicy with QuotaManager.

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>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/containers/scoped_ptr_map.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "storage/browser/quota/quota_callbacks.h"
 #include "storage/browser/quota/quota_client.h"
 #include "storage/browser/quota/quota_database.h"
 #include "storage/browser/quota/quota_task.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "storage/browser/quota/storage_observer.h"
 #include "storage/browser/storage_browser_export.h"
 
+class SiteEngagementEvictionPolicyWithQuotaManagerTest;
+
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 class SingleThreadTaskRunner;
 }
 
 namespace quota_internals {
 class QuotaInternalsProxy;
 }
 
@@ skipping 22 matching lines @@
   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.
+// An interface for deciding which origin's storage should be evicted when the
+// quota is exceeded.
 class STORAGE_EXPORT QuotaEvictionPolicy {
  public:
+  virtual ~QuotaEvictionPolicy() {}
+
   // Returns the next origin to evict.  It might return an empty GURL when there
   // are no evictable origins.
   virtual void GetEvictionOrigin(
       const scoped_refptr<SpecialStoragePolicy>& special_storage_policy,
-      const std::map<GURL, int64>& usage_map,
-      int64 global_quota,
       const GetOriginCallback& callback) = 0;
 };
 
 // An interface called by QuotaTemporaryStorageEvictor.
 class STORAGE_EXPORT QuotaEvictionHandler {
  public:
   typedef StatusCallback EvictOriginDataCallback;
   typedef base::Callback<void(QuotaStatusCode status,
                               const UsageAndQuota& usage_and_quota)>
       UsageAndQuotaCallback;
@@ skipping 94 matching lines @@
   void NotifyOriginNoLongerInUse(const GURL& origin);
   bool IsOriginInUse(const GURL& origin) const {
     return origins_in_use_.find(origin) != origins_in_use_.end();
   }
 
   void SetUsageCacheEnabled(QuotaClient::ID client_id,
                             const GURL& origin,
                             StorageType type,
                             bool enabled);
 
+  // Set the eviction policy to use when choosing an origin to evict.
+  void SetQuotaEvictionPolicy(StorageType type,
+                              scoped_ptr<QuotaEvictionPolicy> policy);
+
   // DeleteOriginData and DeleteHostData (surprisingly enough) delete data of a
   // particular StorageType associated with either a specific origin or set of
   // origins. Each method additionally requires a |quota_client_mask| which
   // specifies the types of QuotaClients to delete from the origin. This is
   // specified by the caller as a bitmask built from QuotaClient::IDs. Setting
   // the mask to QuotaClient::kAllClientsMask will remove all clients from the
   // origin, regardless of type.
   virtual void DeleteOriginData(const GURL& origin,
                                 StorageType type,
                                 int quota_client_mask,
@@ skipping 31 matching lines @@
 
   bool CanQueryDiskSize(const GURL& origin) const {
     return special_storage_policy_.get() &&
            special_storage_policy_->CanQueryDiskSize(origin);
   }
 
   virtual void GetOriginsModifiedSince(StorageType type,
                                        base::Time modified_since,
                                        const GetOriginsCallback& callback);
 
+  UsageTracker* GetUsageTracker(StorageType type) const;

[michaeln, 2015/09/23 20:33:50]

I don't think we should expose the UsageTracker in this way. We are planning to
revamp the quota system and exposing this internal class would prohibit
significant changes. (In the revamped system, that class may not be there at
all?)

I'd like to codify the contract in the eviction policy class and pass into it
data that the quota system has that may be relevant to eviction.

[calamity, 2015/09/29 07:09:16]

Done.

   bool ResetUsageTracker(StorageType type);
 
   // Used to register/deregister observers that wish to monitor storage events.
   void AddStorageObserver(StorageObserver* observer,
                           const StorageObserver::MonitorParams& params);
   void RemoveStorageObserver(StorageObserver* observer);
   void RemoveStorageObserverForFilter(StorageObserver* observer,
                                       const StorageObserver::Filter& filter);
 
   // Determines the portion of the temp pool that can be
@@ skipping 21 matching lines @@
   friend class base::DeleteHelper<QuotaManager>;
   friend class base::RefCountedThreadSafe<QuotaManager, QuotaManagerDeleter>;
   friend class content::QuotaManagerTest;
   friend class content::StorageMonitorTest;
   friend class content::MockQuotaManager;
   friend class content::MockStorageClient;
   friend class quota_internals::QuotaInternalsProxy;
   friend class QuotaManagerProxy;
   friend class QuotaTemporaryStorageEvictor;
   friend struct QuotaManagerDeleter;
+  friend class ::SiteEngagementEvictionPolicyWithQuotaManagerTest;
 
   class GetUsageInfoTask;
 
   class OriginDataDeleter;
   class HostDataDeleter;
 
   class GetModifiedSinceHelper;
   class DumpQuotaTableHelper;
   class DumpOriginInfoTableHelper;
 
@@ skipping 33 matching lines @@
   // when the first quota manager API is called.
   // Initialize must be called after all quota clients are added to the
   // manager by RegisterStorage.
   void LazyInitialize();
 
   // Called by clients via proxy.
   // Registers a quota client to the manager.
   // The client must remain valid until OnQuotaManagerDestored is called.
   void RegisterClient(QuotaClient* client);
 
-  UsageTracker* GetUsageTracker(StorageType type) const;
-
   // Extract cached origins list from the usage tracker.
   // (Might return empty list if no origin is tracked by the tracker.)
   void GetCachedOrigins(StorageType type, std::set<GURL>* origins);
 
   // These internal methods are separately defined mainly for testing.
   void NotifyStorageAccessedInternal(
       QuotaClient::ID client_id,
       const GURL& origin,
       StorageType type,
       base::Time accessed_time);
@@ skipping 12 matching lines @@
   void DeleteOriginFromDatabase(const GURL& origin, StorageType type);
 
   void DidOriginDataEvicted(QuotaStatusCode status);
 
   void ReportHistogram();
   void DidGetTemporaryGlobalUsageForHistogram(int64 usage,
                                               int64 unlimited_usage);
   void DidGetPersistentGlobalUsageForHistogram(int64 usage,
                                                int64 unlimited_usage);
 
+  void DidGetEvictionOrigin(const GetOriginCallback& callback,
+                            const GURL& origin);
+
   // QuotaEvictionHandler.
   void GetEvictionOrigin(StorageType type,
                          const GetOriginCallback& callback) override;
   void EvictOriginData(const GURL& origin,
                        StorageType type,
                        const EvictOriginDataCallback& callback) override;
   void GetUsageAndQuotaForEviction(
       const UsageAndQuotaCallback& callback) override;
 
   void GetLRUOrigin(StorageType type, const GetOriginCallback& callback);
@@ skipping 68 matching lines @@
 
   base::RepeatingTimer<QuotaManager> histogram_timer_;
 
   // Pointer to the function used to get the available disk space. This is
   // overwritten by QuotaManagerTest in order to attain a deterministic reported
   // value. The default value points to base::SysInfo::AmountOfFreeDiskSpace.
   GetAvailableDiskSpaceFn get_disk_space_fn_;
 
   scoped_ptr<StorageMonitor> storage_monitor_;
 
+  base::ScopedPtrMap<StorageType, scoped_ptr<QuotaEvictionPolicy>>
+      eviction_policy_map_;
+
+  bool is_getting_eviction_origin_;
+
   base::WeakPtrFactory<QuotaManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuotaManager);
 };
 
 struct QuotaManagerDeleter {
   static void Destruct(const QuotaManager* manager) {
     manager->DeleteOnCorrectThread();
   }
 };
 
 }  // namespace storage
 
 #endif  // STORAGE_BROWSER_QUOTA_QUOTA_MANAGER_H_