Exclude in-use origins from storage evictions for all QuotaEvictionPolicies.

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"
@@ skipping 16 matching lines @@
       global_quota /
       std::max(kExpectedEngagementSites * SiteEngagementScore::kMaxPoints,
                static_cast<double>(total_engagement_points));
 
   return score * quota_per_point;
 }
 
 GURL DoCalculateEvictionOrigin(
     const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
     SiteEngagementScoreProvider* score_provider,
+    const std::set<GURL>& exceptions,
     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) {
+    if (overuse > max_overuse && exceptions.count(origin) == 0) {
       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::set<GURL>& exceptions,
     const std::map<GURL, int64>& usage_map,
     int64 global_quota) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   SiteEngagementScoreProvider* score_provider =
       g_test_score_provider_callback
           ? g_test_score_provider_callback->Run(browser_context)
           : GetSiteEngagementService(browser_context);
 
   if (!score_provider)
     return GURL();
 
   return DoCalculateEvictionOrigin(special_storage_policy, score_provider,
-                                   usage_map, global_quota);
+                                   exceptions, usage_map, global_quota);
 }
 
 }  // namespace
 
 SiteEngagementEvictionPolicy::SiteEngagementEvictionPolicy(
     storage::StorageType type,
     storage::QuotaManager* manager,
     content::BrowserContext* browser_context)
     : type_(type),
       manager_(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::set<GURL>& exceptions,
     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,
@@ skipping 25 matching lines @@
   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_),
+                 special_storage_policy_, browser_context_, exceptions_,
+                 usage_map_, global_quota_),
       eviction_origin_callback_);
 }
 
 // static
 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::set<GURL>& exceptions,
     const std::map<GURL, int64>& usage_map,
     int64 global_quota) {
   return DoCalculateEvictionOrigin(special_storage_policy, score_provider,
-                                   usage_map, global_quota);
+                                   exceptions, usage_map, global_quota);
 }