Fix Acid3 Test 48: LINKTEST, Chromium side....

chrome/browser/history/expire_history_backend.cc

 // Copyright (c) 2006-2008 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/compiler_specific.h"
 #include "base/file_util.h"
 #include "chrome/browser/bookmarks/bookmark_service.h"
 #include "chrome/browser/history/archived_database.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/text_database_manager.h"
 #include "chrome/browser/history/thumbnail_database.h"
 #include "chrome/common/notification_type.h"
 
 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;
+
+// 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";
+
+    db->GetAllVisitsInRange(Time(), end_time, max_visits, visits);
+    // When we got the maximum number of visits we asked for, we say there could
+    // be additional things to expire now.
+    return static_cast<int>(visits->size()) == max_visits;
+  }
+};
+
+// Reads only AUTO_SUBFRAME visits, within a computed range. The range is
+// computed as follows:
+// * |begin_time| is read from the meta table. This value is updated whenever
+//   there are no more additional visits to expire by this reader.
+// * |end_time| is advanced forward by a constant (kEarlyExpirationAdvanceDay),
+//   but not past the current time.
+class AutoSubframeVisitsReader : 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";
+
+    Time begin_time = db->GetEarlyExpirationThreshold();
+    // Advance |end_time| to expire early.
+    Time early_end_time = end_time +
+        TimeDelta::FromDays(kEarlyExpirationAdvanceDays);
+
+    // We don't want to set the early expiration threshold to a time in the
+    // future.
+    Time now = Time::Now();
+    if (early_end_time > now)
+      early_end_time = now;
+
+    db->GetVisitsInRangeForTransition(begin_time, early_end_time,
+                                      max_visits,
+                                      PageTransition::AUTO_SUBFRAME,
+                                      visits);
+    bool more = static_cast<int>(visits->size()) == max_visits;
+    if (!more)
+      db->UpdateEarlyExpirationThreshold(early_end_time);
+
+    return more;
+  }
+};
+
 // Returns true if this visit is worth archiving. Otherwise, this visit is not
 // worth saving (for example, subframe navigations and redirects) and we can
 // just delete it when it gets old.
 bool ShouldArchiveVisit(const VisitRow& visit) {
   int no_qualifier = PageTransition::StripQualifier(visit.transition);
 
   // These types of transitions are always "important" and the user will want
   // to see them.
   if (no_qualifier == PageTransition::TYPED ||
       no_qualifier == PageTransition::AUTO_BOOKMARK ||
@@ skipping 14 matching lines @@
 }
 
 // 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;
 
 // 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 = 60;
+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;
 
 }  // namespace
 
 ExpireHistoryBackend::ExpireHistoryBackend(
@@ skipping 87 matching lines @@
 
   // Pick up any bits possibly left over.
   ParanoidExpireHistory();
 }
 
 void ExpireHistoryBackend::ArchiveHistoryBefore(Time end_time) {
   if (!main_db_)
     return;
 
   // Archive as much history as possible before the given date.
-  ArchiveSomeOldHistory(end_time, std::numeric_limits<size_t>::max());
+  ArchiveSomeOldHistory(end_time, GetAllVisitsReader(),
+                        std::numeric_limits<size_t>::max());
   ParanoidExpireHistory();
 }
 
+void ExpireHistoryBackend::InitWorkQueue() {
+  DCHECK(work_queue_.empty()) << "queue has to be empty prior to init";
+
+  for (size_t i = 0; i < readers_.size(); i++)
+    work_queue_.push(readers_[i]);
+}
+
+const ExpiringVisitsReader* ExpireHistoryBackend::GetAllVisitsReader() {
+  if (!all_visits_reader_.get())
+    all_visits_reader_.reset(new AllVisitsReader());
+  return all_visits_reader_.get();
+}
+
+const ExpiringVisitsReader*
+    ExpireHistoryBackend::GetAutoSubframeVisitsReader() {
+  if (!auto_subframe_visits_reader_.get())
+    auto_subframe_visits_reader_.reset(new AutoSubframeVisitsReader());
+  return auto_subframe_visits_reader_.get();
+}
+
 void ExpireHistoryBackend::StartArchivingOldStuff(
     TimeDelta expiration_threshold) {
   expiration_threshold_ = expiration_threshold;
-  ScheduleArchive(TimeDelta::FromSeconds(kExpirationDelaySec));
+
+  // Remove all readers, just in case this was method was called before.
+  readers_.clear();
+  // For now, we explicitly add all known readers. If we come up with more
+  // reader types (in case we want to expire different types of visits in
+  // different ways), we can make it be populated by creator/owner of
+  // ExpireHistoryBackend.
+  readers_.push_back(GetAllVisitsReader());
+  readers_.push_back(GetAutoSubframeVisitsReader());
+
+  // Initialize the queue with all tasks for the first set of iterations.
+  InitWorkQueue();
+  ScheduleArchive();
 }
 
 void ExpireHistoryBackend::DeleteFaviconsIfPossible(
     const std::set<FavIconID>& favicon_set) {
   if (!main_db_ || !thumb_db_)
     return;
 
   for (std::set<FavIconID>::const_iterator i = favicon_set.begin();
        i != favicon_set.end(); ++i) {
     if (!main_db_->IsFavIconUsed(*i))
@@ skipping 219 matching lines @@
     // not store referring visits since we delete many of the visits when
     // archiving.
     VisitRow cur_visit(visits[i]);
     cur_visit.url_id = main_id_to_archived_id[cur_visit.url_id];
     cur_visit.referring_visit = 0;
     archived_db_->AddVisit(&cur_visit);
     // Ignore failures, we will delete it from the main DB no matter what.
   }
 }
 
-void ExpireHistoryBackend::ScheduleArchive(TimeDelta delay) {
+void ExpireHistoryBackend::ScheduleArchive() {
+  TimeDelta delay;
+  if (work_queue_.empty()) {
+    // If work queue is empty, reset the work queue to contain all tasks and
+    // schedule next iteration after a longer delay.
+    InitWorkQueue();
+    delay = TimeDelta::FromMinutes(kExpirationEmptyDelayMin);
+  } else {
+    delay = TimeDelta::FromSeconds(kExpirationDelaySec);
+  }
+
   factory_.RevokeAll();
   MessageLoop::current()->PostDelayedTask(FROM_HERE, factory_.NewRunnableMethod(
           &ExpireHistoryBackend::DoArchiveIteration), delay.InMilliseconds());
 }
 
 void ExpireHistoryBackend::DoArchiveIteration() {
-  DCHECK(expiration_threshold_ != TimeDelta()) << "threshold should be set";
-  Time threshold = Time::Now() - expiration_threshold_;
+  DCHECK(!work_queue_.empty()) << "queue has to be non-empty";
 
-  if (ArchiveSomeOldHistory(threshold, kNumExpirePerIteration)) {
-    // Possibly more items to delete now, schedule it sooner to happen again.
-    ScheduleArchive(TimeDelta::FromSeconds(kExpirationDelaySec));
-  } else {
-    // If we didn't find the maximum number of items to delete, wait longer
-    // before trying to delete more later.
-    ScheduleArchive(TimeDelta::FromMinutes(kExpirationEmptyDelayMin));
-  }
+  const ExpiringVisitsReader* reader = work_queue_.front();
+  bool more_to_expire = ArchiveSomeOldHistory(GetCurrentArchiveTime(), reader,
+                                              kNumExpirePerIteration);
+
+  work_queue_.pop();
+  // If there are more items to expire, add the reader back to the queue, thus
+  // creating a new task for future iterations.
+  if (more_to_expire)
+    work_queue_.push(reader);
+
+  ScheduleArchive();
 }
 
-bool ExpireHistoryBackend::ArchiveSomeOldHistory(Time time_threshold,
-                                                 int max_visits) {
+bool ExpireHistoryBackend::ArchiveSomeOldHistory(
+    base::Time end_time,
+    const ExpiringVisitsReader* reader,
+    int max_visits) {
   if (!main_db_)
     return false;
 
-  // Get all visits up to and including the threshold. This is a little tricky
-  // because GetAllVisitsInRange's end value is non-inclusive, so we have to
-  // increment the time by one unit to get the input value to be inclusive.
-  DCHECK(!time_threshold.is_null());
-  Time effective_threshold =
-      Time::FromInternalValue(time_threshold.ToInternalValue() + 1);
+  // Add an extra time unit to given end time, because
+  // GetAllVisitsInRange, et al. queries' end value is non-inclusive.
+  Time effective_end_time =
+      Time::FromInternalValue(end_time.ToInternalValue() + 1);
+
   VisitVector affected_visits;
-  main_db_->GetAllVisitsInRange(Time(), effective_threshold, max_visits,
-                                &affected_visits);
+  bool more_to_expire = reader->Read(effective_end_time, main_db_,
+                                     &affected_visits, max_visits);
 
   // Some visits we'll delete while others we'll archive.
   VisitVector deleted_visits, archived_visits;
   for (size_t i = 0; i < affected_visits.size(); i++) {
     if (ShouldArchiveVisit(affected_visits[i]))
       archived_visits.push_back(affected_visits[i]);
     else
       deleted_visits.push_back(affected_visits[i]);
   }
 
@@ skipping 22 matching lines @@
     affected_favicons.insert(*i);
   }
   DeleteFaviconsIfPossible(affected_favicons);
 
   // Send notifications for the stuff that was deleted. These won't normally be
   // in history views since they were subframes, but they will be in the visited
   // link system, which needs to be updated now. This function is smart enough
   // to not do anything if nothing was deleted.
   BroadcastDeleteNotifications(&deleted_dependencies);
 
-  // When we got the maximum number of visits we asked for, we say there could
-  // be additional things to expire now.
-  return static_cast<int>(affected_visits.size()) == max_visits;
+  return more_to_expire;
 }
 
 void ExpireHistoryBackend::ParanoidExpireHistory() {
   // FIXME(brettw): Bug 1067331: write this to clean up any errors.
 }
 
 BookmarkService* ExpireHistoryBackend::GetBookmarkService() {
   // 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