Use the site engagement eviction policy for temporary storage eviction.

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 489 matching lines @@
 
  private:
   void AddEntries(StorageType type, UsageTracker* tracker) {
     std::map<std::string, int64> host_usage;
     tracker->GetCachedHostsUsage(&host_usage);
     for (std::map<std::string, int64>::const_iterator iter = host_usage.begin();
          iter != host_usage.end();
          ++iter) {
       entries_.push_back(UsageInfo(iter->first, type, iter->second));
     }
+
     if (--remaining_trackers_ == 0)
       CallCompleted();
   }
 
   void DidGetGlobalUsage(StorageType type, int64, int64) {
     DCHECK(manager()->GetUsageTracker(type));
     AddEntries(type, manager()->GetUsageTracker(type));
   }
 
   QuotaManager* manager() const {
     return static_cast<QuotaManager*>(observer());
   }
 
   GetUsageInfoCallback callback_;
   UsageInfoEntries entries_;
   int remaining_trackers_;
   base::WeakPtrFactory<GetUsageInfoTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GetUsageInfoTask);
 };
 
+class QuotaManager::GetTemporaryEvictionOriginTask : public QuotaTask {
+ public:
+  GetTemporaryEvictionOriginTask(
+      QuotaManager* manager,
+      scoped_refptr<SpecialStoragePolicy> special_storage_policy,
+      QuotaEvictionPolicy* eviction_policy,
+      const GetOriginCallback& callback)
+      : QuotaTask(manager),
+        special_storage_policy_(special_storage_policy),
+        eviction_policy_(eviction_policy),
+        callback_(callback),
+        weak_factory_(this) {}
+
+ protected:
+  void Run() override {
+    remaining_tasks_ = 2;
+    // This will populate cached hosts and usage info.
+    manager()
+        ->GetUsageTracker(kStorageTypeTemporary)
+        ->GetGlobalUsage(
+            base::Bind(&GetTemporaryEvictionOriginTask::DidGetGlobalUsage,
+                       weak_factory_.GetWeakPtr(), kStorageTypeTemporary));
+    manager()->GetTemporaryGlobalQuota(
+        base::Bind(&GetTemporaryEvictionOriginTask::DidGetTemporaryGlobalQuota,
+                   weak_factory_.GetWeakPtr()));
+  }
+
+  void Completed() override {
+    eviction_policy_->GetEvictionOrigin(special_storage_policy_.get(),
+                                        usage_map_, global_quota_, callback_);
+    DeleteSoon();
+  }
+
+  void Aborted() override {
+    callback_.Run(GURL());
+    DeleteSoon();
+  }
+
+ private:
+  void DidGetGlobalUsage(StorageType type, int64, int64) {
+    DCHECK(manager()->GetUsageTracker(type));
+    manager()->GetUsageTracker(type)->GetCachedOriginsUsage(&usage_map_);
+    if (--remaining_tasks_ == 0)
+      CallCompleted();
+  }
+
+  void DidGetTemporaryGlobalQuota(QuotaStatusCode status, int64 quota) {
+    if (status == kQuotaStatusOk)
+      global_quota_ = quota;
+
+    if (--remaining_tasks_ == 0)
+      CallCompleted();
+  }
+
+  QuotaManager* manager() const {
+    return static_cast<QuotaManager*>(observer());
+  }
+
+  int64 global_quota_;
+  scoped_refptr<SpecialStoragePolicy> special_storage_policy_;
+  QuotaEvictionPolicy* eviction_policy_;
+  GetOriginCallback callback_;
+  std::map<GURL, int64> usage_map_;
+  int remaining_tasks_;
+  base::WeakPtrFactory<GetTemporaryEvictionOriginTask> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetTemporaryEvictionOriginTask);
+};
+
 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 251 matching lines @@
   OriginInfoTableEntries entries_;
 };
 
 // QuotaManager ---------------------------------------------------------------
 
 QuotaManager::QuotaManager(
     bool is_incognito,
     const base::FilePath& profile_path,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
     const scoped_refptr<base::SequencedTaskRunner>& db_thread,
-    const scoped_refptr<SpecialStoragePolicy>& special_storage_policy)
+    const scoped_refptr<SpecialStoragePolicy>& special_storage_policy,
+    QuotaEvictionPolicy* temporary_storage_eviction_policy)
     : is_incognito_(is_incognito),
       profile_path_(profile_path),
       proxy_(new QuotaManagerProxy(this, io_thread)),
       db_disabled_(false),
       eviction_disabled_(false),
       io_thread_(io_thread),
       db_thread_(db_thread),
+      temporary_storage_eviction_policy_(temporary_storage_eviction_policy),
       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) {
-}
+      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 607 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) {
+  LazyInitialize();
+  if (type == kStorageTypeTemporary && temporary_storage_eviction_policy_) {
+    GetTemporaryEvictionOriginTask* task = new GetTemporaryEvictionOriginTask(
+        this, special_storage_policy_, temporary_storage_eviction_policy_,
+        callback);
+    task->Start();
+    return;
+  }
+
   GetLRUOrigin(type, callback);
 }
 
 void QuotaManager::EvictOriginData(const GURL& origin,
                                    StorageType type,
                                    const EvictOriginDataCallback& callback) {
   DCHECK(io_thread_->BelongsToCurrentThread());
   DCHECK_EQ(type, kStorageTypeTemporary);
 
   eviction_context_.evicted_origin = origin;
@@ skipping 170 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