Promote the priority aware cookie eviction algorithm from experimental status.

net/cookies/cookie_monster.cc

 // Copyright (c) 2012 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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 312 matching lines @@
 
 CookieMonster::CookieMonster(PersistentCookieStore* store, Delegate* delegate)
     : initialized_(false),
       loaded_(false),
       store_(store),
       last_access_threshold_(
           TimeDelta::FromSeconds(kDefaultAccessUpdateThresholdSeconds)),
       delegate_(delegate),
       last_statistic_record_time_(Time::Now()),
       keep_expired_cookies_(false),
-      persist_session_cookies_(false),
-      priority_aware_garbage_collection_(false) {
+      persist_session_cookies_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
 
 CookieMonster::CookieMonster(PersistentCookieStore* store,
                              Delegate* delegate,
                              int last_access_threshold_milliseconds)
     : initialized_(false),
       loaded_(false),
       store_(store),
       last_access_threshold_(base::TimeDelta::FromMilliseconds(
           last_access_threshold_milliseconds)),
       delegate_(delegate),
       last_statistic_record_time_(base::Time::Now()),
       keep_expired_cookies_(false),
-      persist_session_cookies_(false),
-      priority_aware_garbage_collection_(false) {
+      persist_session_cookies_(false) {
   InitializeHistograms();
   SetDefaultCookieableSchemes();
 }
 
 
 // Task classes for queueing the coming request.
 
 class CookieMonster::CookieMonsterTask
     : public base::RefCountedThreadSafe<CookieMonsterTask> {
  public:
@@ skipping 1050 matching lines @@
 CookieMonster* CookieMonster::GetCookieMonster() {
   return this;
 }
 
 // This function must be called before the CookieMonster is used.
 void CookieMonster::SetPersistSessionCookies(bool persist_session_cookies) {
   DCHECK(!initialized_);
   persist_session_cookies_ = persist_session_cookies;
 }
 
-// This function must be called before the CookieMonster is used.
-void CookieMonster::SetPriorityAwareGarbageCollection(
-    bool priority_aware_garbage_collection) {
-  DCHECK(!initialized_);
-  priority_aware_garbage_collection_ = priority_aware_garbage_collection;
-}
-
 void CookieMonster::SetForceKeepSessionState() {
   if (store_.get()) {
     store_->SetForceKeepSessionState();
   }
 }
 
 CookieMonster::~CookieMonster() {
   DeleteAll(false);
 }
 
@@ skipping 522 matching lines @@
       // Round 1: consider low-priority cookies only: evict least-recently
       //   accessed, while protecting quota[0] of these from deletion.
       // Round 2: consider {low, medium}-priority cookies, evict least-recently
       //   accessed, while protecting quota[0] + quota[1].
       // Round 3: consider all cookies, evict least-recently accessed.
       size_t accumulated_quota = 0;
       CookieItVector::iterator it_purge_begin = it_bdd[0];
       for (int i = 0; i < 3 && purge_goal > 0; ++i) {
         accumulated_quota += quota[i];
 
-        // If we are not using priority, only do Round 3. This reproduces the
-        // old way of indiscriminately purging least-recently accessed cookies.
-        if (!priority_aware_garbage_collection_ && i < 2)
-          continue;
-
         size_t num_considered = it_bdd[i + 1] - it_purge_begin;
         if (num_considered <= accumulated_quota)
           continue;
 
         // Number of cookies that will be purged in this round.
         size_t round_goal =
             std::min(purge_goal, num_considered - accumulated_quota);
         purge_goal -= round_goal;
 
         SortLeastRecentlyAccessed(it_purge_begin, it_bdd[i + 1], round_goal);
@@ skipping 284 matching lines @@
 
 // The system resolution is not high enough, so we can have multiple
 // set cookies that result in the same system time.  When this happens, we
 // increment by one Time unit.  Let's hope computers don't get too fast.
 Time CookieMonster::CurrentTime() {
   return std::max(Time::Now(),
       Time::FromInternalValue(last_time_seen_.ToInternalValue() + 1));
 }
 
 }  // namespace net