Make history expiration more aggressive.

chrome/browser/history/expire_history_backend.cc

 // Copyright (c) 2011 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 "chrome/browser/history/expire_history_backend.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 
 using base::Time;
 using base::TimeDelta;
 
 namespace history {
 
 namespace {
 
 // The number of days by which the expiration threshold is advanced for items
 // that we want to expire early, such as those of AUTO_SUBFRAME transition type.
-const int kEarlyExpirationAdvanceDays = 30;
+//
+// Early expiration stuff is kept around only for edge cases, as subframes
+// don't appear in history and the vast majority of them are ads anyway. The
+// main use case for these is if you're on a site with links to different
+// frames, you'll be able to see those links as visited, and we'll also be
+// able to get redirect information for those URLs.
+//
+// But since these uses are most valuable when you're actually on the site,
+// and because these can take up the bulk of your history, we get a lot of
+// space savings by deleting them quickly.
+const int kEarlyExpirationAdvanceDays = 3;
 
 // Reads all types of visits starting from beginning of time to the given end
 // time. This is the most general reader.
 class AllVisitsReader : public ExpiringVisitsReader {
  public:
   virtual bool Read(Time end_time, HistoryDatabase* db,
                     VisitVector* visits, int max_visits) const {
     DCHECK(db) << "must have a database to operate upon";
     DCHECK(visits) << "visit vector has to exist in order to populate it";
 
@@ skipping 61 matching lines @@
        no_qualifier == content::PAGE_TRANSITION_GENERATED) &&
       visit.transition & content::PAGE_TRANSITION_CHAIN_END)
     return true;
 
   // The transition types we ignore are AUTO_SUBFRAME and MANUAL_SUBFRAME.
   return false;
 }
 
 // The number of visits we will expire very time we check for old items. This
 // Prevents us from doing too much work any given time.
-const int kNumExpirePerIteration = 10;
+const int kNumExpirePerIteration = 32;
 
 // The number of seconds between checking for items that should be expired when
 // we think there might be more items to expire. This timeout is used when the
 // last expiration found at least kNumExpirePerIteration and we want to check
 // again "soon."
 const int kExpirationDelaySec = 30;
 
 // The number of minutes between checking, as with kExpirationDelaySec, but
 // when we didn't find enough things to expire last time. If there was no
 // history to expire last iteration, it's likely there is nothing next
 // iteration, so we want to wait longer before checking to avoid wasting CPU.
 const int kExpirationEmptyDelayMin = 5;
 
 // The number of minutes that we wait for before scheduling a task to
 // delete old history index files.
 const int kIndexExpirationDelayMin = 2;
 
 // The number of the most recent months for which we do not want to delete
 // the history index files.
-const int kStoreHistoryIndexesForMonths = 12;
+const int kStoreHistoryIndexesForMonths = 3;
 
 }  // namespace
 
 struct ExpireHistoryBackend::DeleteDependencies {
   // The time range affected. These can be is_null() to be unbounded in one
   // or both directions.
   base::Time begin_time, end_time;
 
   // ----- Filled by DeleteVisitRelatedInfo or manually if a function doesn't
   //       call that function. -----
@@ skipping 552 matching lines @@
   // We use the bookmark service to determine if a URL is bookmarked. The
   // bookmark service is loaded on a separate thread and may not be done by the
   // time we get here. We therefor block until the bookmarks have finished
   // loading.
   if (bookmark_service_)
     bookmark_service_->BlockTillLoaded();
   return bookmark_service_;
 }
 
 }  // namespace history