Add a SiteEngagementEvictionPolicy.

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"
+
+namespace {
+
+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,
+               static_cast<double>(total_engagement_points));
+
+  return score * quota_per_point;

[michaeln, 2015/07/29 00:46:45]

Upon a first visit to a site, score is expected to be 1, is that right, is that
the lowest 'score' possible? I see max is 100.

1G quota --> 50k quota-per-point  --> 5M max softquota for the most engaged site
100G quota --> 5M quota-per-point  --> 500M max softquota

Those 5M and 500M numbers look very low to my eye for a nominal amount of
storage that the least and most important sites can use. I'd like to get some
other opinions about this strategy of computing this soft quota number prior to
committing it.

[calamity, 2015/07/29 05:00:36]

Yes for now, but this may change. Even if it ends up as a minimum score of 0, it
won't prevent sites from using temporary storage outright.
Acknowledged. FYI UMA suggests that <10% of users have >100M total temporary
storage usage and 99% have <100 temporary storage origins.

+}
+
+GURL DoCalculateEvictionOrigin(
+    scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,

[michaeln, 2015/07/29 00:46:46]

ditto

[calamity, 2015/07/29 05:00:36]

Done.

+    SiteEngagementScoreProvider* score_provider,
+    const std::map<GURL, int64>& usage_map,
+    int64 global_quota) {
+  // TODO(calamity): Integrate storage access frequency as an input to this
+  // heuristic.
+
+  // This heuristic is intended to optimize for two criteria:
+  // - evict the site that the user cares about least
+  // - evict the least number of sites to get under the quota limit
+  //
+  // The heuristic for deciding the next eviction origin calculates a soft
+  // quota for each origin which is the amount the origin should be allowed to
+  // use based on its engagement and the global quota. The origin that most
+  // exceeds its soft quota is chosen.
+  GURL origin_to_evict;
+  int64 max_overuse = std::numeric_limits<int64>::min();
+  int total_engagement_points = score_provider->GetTotalEngagementPoints();
+
+  for (const auto& usage : usage_map) {
+    GURL origin = usage.first;
+    if (special_storage_policy &&
+        (special_storage_policy->IsStorageUnlimited(origin) ||
+         special_storage_policy->IsStorageDurable(origin))) {
+      continue;
+    }
+
+    // |overuse| can be negative if the soft quota exceeds the usage.
+    int64 overuse =
+        usage.second - GetSoftQuotaForOrigin(
+                           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;
+}
+
+GURL GetSiteEngagementEvictionOriginOnUIThread(
+    scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,

[michaeln, 2015/07/29 00:46:46]

ditto const ref

[calamity, 2015/07/29 05:00:36]

Done.

+    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)
+    return GURL();
+
+  return DoCalculateEvictionOrigin(special_storage_policy, service, usage_map,
+                                   global_quota);
+}
+
+}  // namespace
+
+SiteEngagementEvictionPolicy::SiteEngagementEvictionPolicy(
+    content::BrowserContext* browser_context)
+    : browser_context_(browser_context) {
+}
+
+SiteEngagementEvictionPolicy::~SiteEngagementEvictionPolicy() {
+}
+
+void SiteEngagementEvictionPolicy::GetEvictionOrigin(
+    scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,

[michaeln, 2015/07/29 00:46:46]

how about using const scoped_refptr<T>& here  instead of passing by value

[calamity, 2015/07/29 05:00:36]

Done.

+    const std::map<GURL, int64>& usage_map,
+    int64 global_quota,
+    const storage::GetOriginCallback& callback) {
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&GetSiteEngagementEvictionOriginOnUIThread,
+                 special_storage_policy, browser_context_, usage_map,
+                 global_quota),
+      callback);
+}
+
+// static
+GURL SiteEngagementEvictionPolicy::CalculateEvictionOrigin(
+    scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,

[michaeln, 2015/07/29 00:46:46]

ditto

[calamity, 2015/07/29 05:00:36]

Done.

+    SiteEngagementScoreProvider* score_provider,
+    const std::map<GURL, int64>& usage_map,
+    int64 global_quota) {
+  return DoCalculateEvictionOrigin(special_storage_policy, score_provider,
+                                   usage_map, global_quota);
+}