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 35 matching lines @@
                                        origin, score_provider->GetScore(origin),
                                        total_engagement_points, global_quota);
     if (overuse > max_overuse) {
       max_overuse = overuse;
       origin_to_evict = origin;
     }
   }
   return origin_to_evict;
 }
 
+SiteEngagementScoreProvider* GetSiteEngagementService(
+    content::BrowserContext* browser_context) {
+  Profile* profile = Profile::FromBrowserContext(browser_context);
+  return g_browser_process->profile_manager()->IsValidProfile(profile)
+             ? SiteEngagementService::Get(profile)
+             : nullptr;
+}
+
 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 =
+      g_test_score_provider_callback
+          ? g_test_score_provider_callback->Run(browser_context)
+          : GetSiteEngagementService(browser_context);

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

nit: how about we fold this logic into GetSiteEngagementService() so we can just
have have:
SiteEngagementScoreProvider* score_provider = GetScoreProvider();

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

I don't think that function was providing much value since I changed the way the
test callback works. Just inlined it here.

+
+  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* manager,
     content::BrowserContext* browser_context)
-    : browser_context_(browser_context) {}
+    : type_(type),
+      manager_(manager),

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

nit: perhaps call this quota_manager_ for clarity?

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

Done.

+      browser_context_(browser_context),
+      global_quota_(0),
+      remaining_tasks_(0),
+      weak_factory_(this) {}
 
 SiteEngagementEvictionPolicy::~SiteEngagementEvictionPolicy() {}

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

Should we fire eviction_origin_callback_ if we're destroyed prior to hearing
back from the quota_manager

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

Hmm. Well, the quota manager is the one receiving as well as the owner of this
policy. I don't think anything bad will happen if we don't.

 
 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.
+  manager_->GetUsageTracker(type_)->GetGlobalUsage(
+      base::Bind(&SiteEngagementEvictionPolicy::DidGetGlobalUsage,
+                 weak_factory_.GetWeakPtr(), type_));
+  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 = 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);
 }