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;

[raymes, 2015/09/22 06:08:49]

The storage people would be able to comment on whether it's better to expose the
UsageTracker directly or just to expose the usage map. What were your thoughts?

[calamity, 2015/09/23 01:46:24]

I thought it would pollute the QuotaManager API less to just expose the usage
tracker.

   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;

[raymes, 2015/09/22 06:08:49]

nit: is the :: necessary, I think the forward declaration above should be
enough?

[calamity, 2015/09/23 01:46:24]

Didn't seem to be.

C++, how does it work.

[raymes, 2015/09/23 01:56:14]

Agreed!

 
   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_