Integrate SiteEngagementEvictionPolicy with QuotaManager.

storage/browser/quota/quota_manager.cc

 // 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.
 
 #include "storage/browser/quota/quota_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/bind.h"
@@ skipping 299 matching lines @@
     int64 usage,
     int64 global_limited_usage,
     int64 quota,
     int64 available_disk_space)
     : usage(usage),
       global_limited_usage(global_limited_usage),
       quota(quota),
       available_disk_space(available_disk_space) {
 }
 
+QuotaEvictionPolicy::Info::Info() {}
+QuotaEvictionPolicy::Info::~Info() {}
+
+bool QuotaEvictionPolicy::NeedsOriginUsageMap() {
+  return false;
+}
+
+bool QuotaEvictionPolicy::NeedsGlobalQuota() {
+  return false;
+}
+
 class UsageAndQuotaCallbackDispatcher
     : public QuotaTask,
       public base::SupportsWeakPtr<UsageAndQuotaCallbackDispatcher> {
  public:
   explicit UsageAndQuotaCallbackDispatcher(QuotaManager* manager)
       : QuotaTask(manager),
         has_usage_(false),
         has_global_limited_usage_(false),
         has_quota_(false),
         has_available_disk_space_(false),
@@ skipping 191 matching lines @@
   }
 
   GetUsageInfoCallback callback_;
   UsageInfoEntries entries_;
   int remaining_trackers_;
   base::WeakPtrFactory<GetUsageInfoTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GetUsageInfoTask);
 };
 
+class QuotaManager::GetEvictionOriginTask : public QuotaTask {

[michaeln, 2015/10/06 00:35:09]

This task may not bee needed?

At the start of an eviction round, the QuotaTemporaryStorageEvictor class
gathers data needed for the round. All of the data this tasks gathers is readily
available when GetUsageAndQuotaForEviction completes w/o any additional async
steps. I think you can populate an origin map at that time prior to calling
GetEvictionOrigin.

[calamity, 2015/10/07 02:42:46]

Ah ok, cool. Deleted this.

+ public:
+  GetEvictionOriginTask(
+      QuotaManager* manager,
+      scoped_refptr<SpecialStoragePolicy> special_storage_policy,
+      QuotaEvictionPolicy* eviction_policy,
+      const GetOriginCallback& callback)
+      : QuotaTask(manager),
+        eviction_info_(new QuotaEvictionPolicy::Info()),
+        special_storage_policy_(special_storage_policy),
+        eviction_policy_(eviction_policy),
+        callback_(callback),
+        remaining_tasks_(0),
+        weak_factory_(this) {}
+
+ protected:
+  void Run() override {
+    if (eviction_policy_->NeedsOriginUsageMap()) {
+      // This will populate cached hosts and usage info.
+      manager()
+          ->GetUsageTracker(kStorageTypeTemporary)
+          ->GetGlobalUsage(base::Bind(&GetEvictionOriginTask::DidGetGlobalUsage,

[michaeln, 2015/10/06 00:35:09]

The base::BarrierClosure (barrier_closure.h) class exists to handle this pattern
where a final done closure in invoked after a number of invocations of the
barrier.

I think this method can complete immediately and may call DidGetGlobalUsage
prior to return. So remaining_tasks_ could be set to -1 then get incremented
back to 0 below which is probably not what you had in mind.
GetTemporaryGlobalQuota method can complete immediately too.

[calamity, 2015/10/07 02:42:46]

Acknowledged.

+                                      weak_factory_.GetWeakPtr(),
+                                      kStorageTypeTemporary));
+      ++remaining_tasks_;
+    }
+
+    if (eviction_policy_->NeedsGlobalQuota()) {
+      manager()->GetTemporaryGlobalQuota(
+          base::Bind(&GetEvictionOriginTask::DidGetTemporaryGlobalQuota,
+                     weak_factory_.GetWeakPtr()));
+      ++remaining_tasks_;
+    }
+
+    if (remaining_tasks_ == 0)
+      CallCompleted();
+  }
+
+  void Completed() override {
+    eviction_policy_->GetEvictionOrigin(
+        eviction_info_.Pass(), special_storage_policy_.get(), callback_);
+    DeleteSoon();
+  }
+
+  void Aborted() override {
+    callback_.Run(GURL());
+    DeleteSoon();
+  }
+
+ private:
+  void DidGetGlobalUsage(StorageType type, int64, int64) {
+    DCHECK(manager()->GetUsageTracker(type));
+    manager()->GetUsageTracker(type)->GetCachedOriginsUsage(
+        &eviction_info_->origin_usage_map);
+
+    if (--remaining_tasks_ == 0)
+      CallCompleted();
+  }
+
+  void DidGetTemporaryGlobalQuota(QuotaStatusCode status, int64 quota) {
+    if (status == kQuotaStatusOk)
+      eviction_info_->global_quota = quota;
+
+    if (--remaining_tasks_ == 0)
+      CallCompleted();
+  }
+
+  QuotaManager* manager() const {
+    return static_cast<QuotaManager*>(observer());
+  }
+
+  scoped_ptr<QuotaEvictionPolicy::Info> eviction_info_;
+  scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
+  QuotaEvictionPolicy* eviction_policy_;
+  GetOriginCallback callback_;
+  int remaining_tasks_;
+  base::WeakPtrFactory<GetEvictionOriginTask> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetEvictionOriginTask);
+};
+
 class QuotaManager::OriginDataDeleter : public QuotaTask {
  public:
   OriginDataDeleter(QuotaManager* manager,
                     const GURL& origin,
                     StorageType type,
                     int quota_client_mask,
                     const StatusCallback& callback)
       : QuotaTask(manager),
         origin_(origin),
         type_(type),
@@ skipping 265 matching lines @@
       db_disabled_(false),
       eviction_disabled_(false),
       io_thread_(io_thread),
       db_thread_(db_thread),
       temporary_quota_initialized_(false),
       temporary_quota_override_(-1),
       desired_available_space_(-1),
       special_storage_policy_(special_storage_policy),
       get_disk_space_fn_(&CallSystemGetAmountOfFreeDiskSpace),
       storage_monitor_(new StorageMonitor(this)),
-      weak_factory_(this) {
-}
+      is_getting_eviction_origin_(false),
+      weak_factory_(this) {}
 
 void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
   LazyInitialize();
   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
   get_usage_info->Start();
 }
 
 void QuotaManager::GetUsageAndQuotaForWebApps(
     const GURL& origin,
     StorageType type,
@@ skipping 90 matching lines @@
 
 void QuotaManager::SetUsageCacheEnabled(QuotaClient::ID client_id,
                                         const GURL& origin,
                                         StorageType type,
                                         bool enabled) {
   LazyInitialize();
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->SetUsageCacheEnabled(client_id, origin, enabled);
 }
 
+void QuotaManager::SetQuotaEvictionPolicy(
+    StorageType type,
+    scoped_ptr<QuotaEvictionPolicy> policy) {
+  eviction_policy_map_.set(type, policy.Pass());
+}
+
 void QuotaManager::DeleteOriginData(
     const GURL& origin, StorageType type, int quota_client_mask,
     const StatusCallback& callback) {
   LazyInitialize();
 
   if (origin.is_empty() || clients_.empty()) {
     callback.Run(kQuotaStatusOk);
     return;
   }
 
@@ skipping 342 matching lines @@
   LazyInitialize();
   DCHECK(GetUsageTracker(type));
   GetUsageTracker(type)->GetCachedOrigins(origins);
 }
 
 void QuotaManager::NotifyStorageAccessedInternal(
     QuotaClient::ID client_id,
     const GURL& origin, StorageType type,
     base::Time accessed_time) {
   LazyInitialize();
-  if (type == kStorageTypeTemporary && !lru_origin_callback_.is_null()) {
+  if (type == kStorageTypeTemporary && is_getting_eviction_origin_) {
     // Record the accessed origins while GetLRUOrigin task is runing
     // to filter out them from eviction.
     access_notified_origins_.insert(origin);
   }
 
   if (db_disabled_)
     return;
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&UpdateAccessTimeOnDBThread, origin, type, accessed_time),
@@ skipping 134 matching lines @@
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfPersistentStorageOrigins",
                        num_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedPersistentStorageOrigins",
                        protected_origins);
   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedPersistentStorageOrigins",
                        unlimited_origins);
 }
 
 void QuotaManager::GetEvictionOrigin(StorageType type,
                                      const GetOriginCallback& callback) {
-  GetLRUOrigin(type, callback);
+  LazyInitialize();
+  // This must not be called while there's an in-flight task.
+  DCHECK(!is_getting_eviction_origin_);
+  is_getting_eviction_origin_ = true;
+
+  GetOriginCallback did_get_origin_callback =
+      base::Bind(&QuotaManager::DidGetEvictionOrigin,
+                 weak_factory_.GetWeakPtr(), callback);
+
+  auto eviction_policy = eviction_policy_map_.find(type);
+  if (eviction_policy != eviction_policy_map_.end()) {
+    GetEvictionOriginTask* task = new GetEvictionOriginTask(
+        this, special_storage_policy_, eviction_policy->second,
+        did_get_origin_callback);
+    task->Start();
+    return;
+  }
+
+  // TODO(calamity): convert LRU origin retrieval into a QuotaEvictionPolicy.
+  GetLRUOrigin(type, did_get_origin_callback);
+}
+
+void QuotaManager::DidGetEvictionOrigin(const GetOriginCallback& callback,
+                                        const GURL& origin) {
+  callback.Run(origin);
+
+  is_getting_eviction_origin_ = false;
 }
 
 void QuotaManager::EvictOriginData(const GURL& origin,
                                    StorageType type,
                                    const EvictOriginDataCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK_EQ(type, kStorageTypeTemporary);
 
   eviction_context_.evicted_origin = origin;
   eviction_context_.evicted_type = type;
@@ skipping 23 matching lines @@
   LazyInitialize();
   // This must not be called while there's an in-flight task.
   DCHECK(lru_origin_callback_.is_null());
   lru_origin_callback_ = callback;
   if (db_disabled_) {
     lru_origin_callback_.Run(GURL());
     lru_origin_callback_.Reset();
     return;
   }
 
+  // TODO(calamity): make all QuotaEvictionPolicies aware of these exceptions.
   std::set<GURL>* exceptions = new std::set<GURL>;
   for (std::map<GURL, int>::const_iterator p = origins_in_use_.begin();
        p != origins_in_use_.end();
        ++p) {
     if (p->second > 0)
       exceptions->insert(p->first);
   }
   for (std::map<GURL, int>::const_iterator p = origins_in_error_.begin();
        p != origins_in_error_.end();
        ++p) {
@@ skipping 126 matching lines @@
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 }  // namespace storage