Integrate SiteEngagementEvictionPolicy with QuotaManager.

chrome/browser/engagement/site_engagement_eviction_policy.cc

 // Copyright 2015 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 "base/barrier_closure.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/engagement/site_engagement_eviction_policy.h"
 #include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "content/public/browser/browser_thread.h"
+#include "storage/browser/quota/usage_tracker.h"
 
 namespace {
 
+base::Callback<SiteEngagementScoreProvider*(content::BrowserContext*)>*
+    g_test_score_provider_callback = nullptr;
+
 const int kExpectedEngagementSites = 200;
 
 // Gets the quota that an origin deserves based on its site engagement.
 int64 GetSoftQuotaForOrigin(const GURL& origin,
                             int score,
                             int total_engagement_points,
                             int64 global_quota) {
   double quota_per_point =
       global_quota /
       std::max(kExpectedEngagementSites * SiteEngagementScore::kMaxPoints,
@@ skipping 41 matching lines @@
   }
   return origin_to_evict;
 }
 
 GURL GetSiteEngagementEvictionOriginOnUIThread(
     const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
     content::BrowserContext* browser_context,
     const std::map<GURL, int64>& usage_map,
     int64 global_quota) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  Profile* profile = Profile::FromBrowserContext(browser_context);
-  SiteEngagementService* service =
-      g_browser_process->profile_manager()->IsValidProfile(profile)
-          ? SiteEngagementService::Get(profile)
-          : nullptr;
-  if (!service)
+
+  SiteEngagementScoreProvider* score_provider = nullptr;
+  if (g_test_score_provider_callback) {
+    score_provider = g_test_score_provider_callback->Run(browser_context);
+  } else {
+    Profile* profile = Profile::FromBrowserContext(browser_context);
+    score_provider =
+        g_browser_process->profile_manager()->IsValidProfile(profile)
+            ? SiteEngagementService::Get(profile)
+            : nullptr;
+  }
+
+  if (!score_provider)
     return GURL();
 
-  return DoCalculateEvictionOrigin(special_storage_policy, service, usage_map,
-                                   global_quota);
+  return DoCalculateEvictionOrigin(special_storage_policy, score_provider,
+                                   usage_map, global_quota);
 }
 
 }  // namespace
 
 SiteEngagementEvictionPolicy::SiteEngagementEvictionPolicy(
+    storage::StorageType type,
+    storage::QuotaManager* quota_manager,
     content::BrowserContext* browser_context)
-    : browser_context_(browser_context) {}
+    : type_(type),
+      quota_manager_(quota_manager),
+      browser_context_(browser_context),
+      global_quota_(0),
+      remaining_tasks_(0),
+      weak_factory_(this) {}
 
 SiteEngagementEvictionPolicy::~SiteEngagementEvictionPolicy() {}
 
 void SiteEngagementEvictionPolicy::GetEvictionOrigin(
     const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
-    const std::map<GURL, int64>& usage_map,
-    int64 global_quota,
     const storage::GetOriginCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  DCHECK_EQ(0, remaining_tasks_);
+
+  remaining_tasks_ = 2;
+  eviction_origin_callback_ = callback;
+
+  // This will populate cached hosts and usage info.
+  quota_manager_->GetUsageTracker(type_)->GetGlobalUsage(
+      base::Bind(&SiteEngagementEvictionPolicy::DidGetGlobalUsage,
+                 weak_factory_.GetWeakPtr(), type_));
+  quota_manager_->GetTemporaryGlobalQuota(
+      base::Bind(&SiteEngagementEvictionPolicy::DidGetGlobalQuota,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void SiteEngagementEvictionPolicy::DidGetGlobalUsage(storage::StorageType type,
+                                                     int64,
+                                                     int64) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  storage::UsageTracker* tracker = quota_manager_->GetUsageTracker(type);
+  DCHECK(tracker);
+  tracker->GetCachedOriginsUsage(&usage_map_);
+
+  if (--remaining_tasks_ == 0)
+    OnQuotaTasksCompleted();
+}
+
+void SiteEngagementEvictionPolicy::DidGetGlobalQuota(
+    storage::QuotaStatusCode status,
+    int64 quota) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+  if (status == storage::kQuotaStatusOk)
+    global_quota_ = quota;
+
+  if (--remaining_tasks_ == 0)
+    OnQuotaTasksCompleted();
+}
+
+void SiteEngagementEvictionPolicy::OnQuotaTasksCompleted() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&GetSiteEngagementEvictionOriginOnUIThread,
-                 special_storage_policy, browser_context_, usage_map,
-                 global_quota),
-      callback);
+                 special_storage_policy_, browser_context_, usage_map_,
+                 global_quota_),
+      eviction_origin_callback_);
 }
 
 // static
-GURL SiteEngagementEvictionPolicy::CalculateEvictionOrigin(
+void SiteEngagementEvictionPolicy::
+    SetSiteEngagementScoreProviderCallbackForTests(
+        base::Callback<SiteEngagementScoreProvider*(content::BrowserContext*)>*
+            callback) {
+  g_test_score_provider_callback = callback;
+}
+
+// static
+GURL SiteEngagementEvictionPolicy::CalculateEvictionOriginForTests(
     const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
     SiteEngagementScoreProvider* score_provider,
     const std::map<GURL, int64>& usage_map,
     int64 global_quota) {
   return DoCalculateEvictionOrigin(special_storage_policy, score_provider,
                                    usage_map, global_quota);
 }