Eliminate the archived history database and clean up related code.

chrome/browser/history/history_backend.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.
 
 #include "chrome/browser/history/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 35 matching lines @@
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/history/android/android_provider_backend.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
-/* The HistoryBackend consists of a number of components:
+/* The HistoryBackend consists of two components:
 
     HistoryDatabase (stores past 3 months of history)
       URLDatabase (stores a list of URLs)
       DownloadDatabase (stores a list of downloads)
       VisitDatabase (stores a list of visits for the URLs)
       VisitSegmentDatabase (stores groups of URLs for the most visited view).
 
-    ArchivedDatabase (stores history older than 3 months)
-      URLDatabase (stores a list of URLs)
-      DownloadDatabase (stores a list of downloads)
-      VisitDatabase (stores a list of visits for the URLs)
-
-      (this does not store visit segments as they expire after 3 mos.)
-
-    ExpireHistoryBackend (manages moving things from HistoryDatabase to
-                          the ArchivedDatabase and deleting)
+    ExpireHistoryBackend (manages deleting things older than 3 months)
 */
 
 namespace history {
 
 // How long we keep segment data for in days. Currently 3 months.
 // This value needs to be greater or equal to
 // MostVisitedModel::kMostVisitedScope but we don't want to introduce a direct
 // dependency between MostVisitedModel and the history backend.
 const int kSegmentDataRetention = 90;
 
 // How long we'll wait to do a commit, so that things are batched together.
 const int kCommitIntervalSeconds = 10;
 
 // The amount of time before we re-fetch the favicon.
 const int kFaviconRefetchDays = 7;
 
 // The maximum number of items we'll allow in the redirect list before
 // deleting some.
 const int kMaxRedirectCount = 32;
 
 // The number of days old a history entry can be before it is considered "old"
-// and is archived.
-const int kArchiveDaysThreshold = 90;
+// and is deleted.
+const int kExpireDaysThreshold = 90;
 
 #if defined(OS_ANDROID)
 // The maximum number of top sites to track when recording top page visit stats.
 const size_t kPageVisitStatsMaxTopSites = 50;
 #endif
 
 // Converts from PageUsageData to MostVisitedURL. |redirects| is a
 // list of redirects for this URL. Empty list means no redirects.
 MostVisitedURL MakeMostVisitedURL(const PageUsageData& page_data,
                                   const RedirectList& redirects) {
@@ skipping 504 matching lines @@
   if (thumbnail_db_->Init(thumbnail_name) != sql::INIT_OK) {
     // Unlike the main database, we don't error out when the database is too
     // new because this error is much less severe. Generally, this shouldn't
     // happen since the thumbnail and main database versions should be in sync.
     // We'll just continue without thumbnails & favicons in this case or any
     // other error.
     LOG(WARNING) << "Could not initialize the thumbnail database.";
     thumbnail_db_.reset();
   }
 
-  // Archived database.
-  if (db_->needs_version_17_migration()) {
-    // See needs_version_17_migration() decl for more. In this case, we want
-    // to delete the archived database and need to do so before we try to
-    // open the file. We can ignore any error (maybe the file doesn't exist).
-    sql::Connection::Delete(archived_name);
-  }
-  archived_db_.reset(new ArchivedDatabase());
-  if (!archived_db_->Init(archived_name)) {
-    LOG(WARNING) << "Could not initialize the archived database.";
-    archived_db_.reset();
-  }
+  // Nuke any files corresponding to the legacy Archived History Database, which
+  // previously retained expired (> 3 months old) history entries, but, in the
+  // end, was not used for much, and consequently has been removed as of M37.
+  // TODO(engedy): Remove this code after the end of 2014.
+  sql::Connection::Delete(archived_name);
 
   // Generate the history and thumbnail database metrics only after performing
   // any migration work.
   if (base::RandInt(1, 100) == 50) {
     // Only do this computation sometimes since it can be expensive.
     db_->ComputeDatabaseMetrics(history_name);
     if (thumbnail_db_)
       thumbnail_db_->ComputeDatabaseMetrics();
   }
 
-  // Tell the expiration module about all the nice databases we made. This must
-  // happen before db_->Init() is called since the callback ForceArchiveHistory
-  // may need to expire stuff.
-  //
-  // *sigh*, this can all be cleaned up when that migration code is removed.
-  // The main DB initialization should intuitively be first (not that it
-  // actually matters) and the expirer should be set last.
-  expirer_.SetDatabases(db_.get(), archived_db_.get(), thumbnail_db_.get());
+  expirer_.SetDatabases(db_.get(), thumbnail_db_.get());
 
   // Open the long-running transaction.
   db_->BeginTransaction();
   if (thumbnail_db_)
     thumbnail_db_->BeginTransaction();
-  if (archived_db_)
-    archived_db_->BeginTransaction();
 
   // Get the first item in our database.
   db_->GetStartDate(&first_recorded_time_);
 
   // Start expiring old stuff.
-  expirer_.StartArchivingOldStuff(TimeDelta::FromDays(kArchiveDaysThreshold));
+  expirer_.StartExpiringOldStuff(TimeDelta::FromDays(kExpireDaysThreshold));
 
 #if defined(OS_ANDROID)
   if (thumbnail_db_) {
     android_provider_backend_.reset(
         new AndroidProviderBackend(GetAndroidCacheFileName(),
                                    db_.get(),
                                    thumbnail_db_.get(),
                                    history_client_,
                                    delegate_.get()));
   }
 #endif
 
   HISTOGRAM_TIMES("History.InitTime",
                   TimeTicks::Now() - beginning_time);
 }
 
 void HistoryBackend::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
   bool trim_aggressively = memory_pressure_level ==
       base::MemoryPressureListener::MEMORY_PRESSURE_CRITICAL;
   if (db_)
     db_->TrimMemory(trim_aggressively);
   if (thumbnail_db_)
     thumbnail_db_->TrimMemory(trim_aggressively);
-  if (archived_db_)
-    archived_db_->TrimMemory(trim_aggressively);
 }
 
 void HistoryBackend::CloseAllDatabases() {
   if (db_) {
     // Commit the long-running transaction.
     db_->CommitTransaction();
     db_.reset();
     // Forget the first recorded time since the database is closed.
     first_recorded_time_ = base::Time();
   }
   if (thumbnail_db_) {
     thumbnail_db_->CommitTransaction();
     thumbnail_db_.reset();
   }
-  if (archived_db_) {
-    archived_db_->CommitTransaction();
-    archived_db_.reset();
-  }
 }
 
 std::pair<URLID, VisitID> HistoryBackend::AddPageVisit(
     const GURL& url,
     Time time,
     VisitID referring_visit,
     content::PageTransition transition,
     VisitSource visit_source) {
   // Top-level frame navigations are visible, everything else is hidden
   bool new_hidden = !content::PageTransitionIsMainFrame(transition);
@@ skipping 81 matching lines @@
 
   return std::make_pair(url_id, visit_id);
 }
 
 void HistoryBackend::AddPagesWithDetails(const URLRows& urls,
                                          VisitSource visit_source) {
   if (!db_)
     return;
 
   scoped_ptr<URLsModifiedDetails> modified(new URLsModifiedDetails);
-  scoped_ptr<URLsModifiedDetails> modified_in_archive(new URLsModifiedDetails);
   for (URLRows::const_iterator i = urls.begin(); i != urls.end(); ++i) {
     DCHECK(!i->last_visit().is_null());
 
-    // We will add to either the archived database or the main one depending on
-    // the date of the added visit.
-    URLDatabase* url_database = NULL;
-    VisitDatabase* visit_database = NULL;
-    if (IsExpiredVisitTime(i->last_visit())) {
-      if (!archived_db_)
-        return;  // No archived database to save it to, just forget this.
-      url_database = archived_db_.get();
-      visit_database = archived_db_.get();
-    } else {
-      url_database = db_.get();
-      visit_database = db_.get();
-    }
+    // As of M37, we no longer maintain an archived database, ignore old visits.
+    if (IsExpiredVisitTime(i->last_visit()))
+      continue;
 
     URLRow existing_url;
-    URLID url_id = url_database->GetRowForURL(i->url(), &existing_url);
+    URLID url_id = db_->GetRowForURL(i->url(), &existing_url);
     if (!url_id) {
       // Add the page if it doesn't exist.
-      url_id = url_database->AddURL(*i);
+      url_id = db_->AddURL(*i);
       if (!url_id) {
         NOTREACHED() << "Could not add row to DB";
         return;
       }
 
       if (i->typed_count() > 0) {
-        // Collect expired URLs that belong to |archived_db_| separately; we
-        // want to fire NOTIFICATION_HISTORY_URLS_MODIFIED only for changes that
-        // take place in the main |db_|.
-        if (url_database == db_.get()) {
-          modified->changed_urls.push_back(*i);
-          modified->changed_urls.back().set_id(url_id);  // i->id_ is likely 0.
-        } else {
-          modified_in_archive->changed_urls.push_back(*i);
-          modified_in_archive->changed_urls.back().set_id(url_id);
-        }
+        modified->changed_urls.push_back(*i);
+        modified->changed_urls.back().set_id(url_id);  // i->id_ is likely 0.
       }
     }
 
     // Sync code manages the visits itself.
     if (visit_source != SOURCE_SYNCED) {
       // Make up a visit to correspond to the last visit to the page.
       VisitRow visit_info(url_id, i->last_visit(), 0,
                           content::PageTransitionFromInt(
                               content::PAGE_TRANSITION_LINK |
                               content::PAGE_TRANSITION_CHAIN_START |
                               content::PAGE_TRANSITION_CHAIN_END), 0);
-      if (!visit_database->AddVisit(&visit_info, visit_source)) {
+      if (!db_->AddVisit(&visit_info, visit_source)) {
         NOTREACHED() << "Adding visit failed.";
         return;
       }
       NotifyVisitObservers(visit_info);
 
       if (visit_info.visit_time < first_recorded_time_)
         first_recorded_time_ = visit_info.visit_time;
     }
   }
 
-  if (typed_url_syncable_service_.get()) {
-    typed_url_syncable_service_->OnUrlsModified(
-        &modified_in_archive->changed_urls);

[Andrew T Wilson (Slow), 2014/06/05 11:44:44]

Hmm, we're no longer notifying the sync subsystem of archived URLs. I actually
think this is OK since we ignore those anyway.

[engedy, 2014/06/05 12:17:59]

Thanks for looking into this!

+  if (typed_url_syncable_service_.get())
     typed_url_syncable_service_->OnUrlsModified(&modified->changed_urls);
-  }
 
   // Broadcast a notification for typed URLs that have been modified. This
   // will be picked up by the in-memory URL database on the main thread.
   //
   // TODO(brettw) bug 1140015: Add an "add page" notification so the history
   // views can keep in sync.
   BroadcastNotifications(chrome::NOTIFICATION_HISTORY_URLS_MODIFIED,
                          modified.PassAs<HistoryDetails>());
 
   ScheduleCommit();
 }
 
 bool HistoryBackend::IsExpiredVisitTime(const base::Time& time) {
-  return time < expirer_.GetCurrentArchiveTime();
+  return time < expirer_.GetCurrentExpirationTime();
 }
 
 void HistoryBackend::SetPageTitle(const GURL& url,
                                   const base::string16& title) {
   if (!db_)
     return;
 
   // Search for recent redirects which should get the same title. We make a
   // dummy list containing the exact URL visited if there are no redirects so
   // the processing below can be the same.
@@ skipping 225 matching lines @@
           new KeywordSearchUpdatedDetails(row, keyword_id, term)));
   ScheduleCommit();
 }
 
 void HistoryBackend::DeleteAllSearchTermsForKeyword(
     TemplateURLID keyword_id) {
   if (!db_)
     return;
 
   db_->DeleteAllSearchTermsForKeyword(keyword_id);
-  // TODO(sky): bug 1168470. Need to move from archive dbs too.
   ScheduleCommit();
 }
 
 void HistoryBackend::GetMostRecentKeywordSearchTerms(
     scoped_refptr<GetMostRecentKeywordSearchTermsRequest> request,
     TemplateURLID keyword_id,
     const base::string16& prefix,
     int max_count) {
   if (request->canceled())
     return;
@@ skipping 104 matching lines @@
                                   const base::string16& text_query,
                                   const QueryOptions& options) {
   if (request->canceled())
     return;
 
   TimeTicks beginning_time = TimeTicks::Now();
 
   if (db_) {
     if (text_query.empty()) {
       // Basic history query for the main database.
-      QueryHistoryBasic(db_.get(), db_.get(), options, &request->value);
-
-      // Now query the archived database. This is a bit tricky because we don't
-      // want to query it if the queried time range isn't going to find anything
-      // in it.
-      // TODO(brettw) bug 1171036: do blimpie querying for the archived database
-      // as well.
-      // if (archived_db_.get() &&
-      //     expirer_.GetCurrentArchiveTime() - TimeDelta::FromDays(7)) {
+      QueryHistoryBasic(options, &request->value);
     } else {
       // Text history query.
-      QueryHistoryText(db_.get(), db_.get(), text_query, options,
-                       &request->value);
-      if (archived_db_.get() &&
-          expirer_.GetCurrentArchiveTime() >= options.begin_time) {
-        QueryHistoryText(archived_db_.get(), archived_db_.get(), text_query,
-                         options, &request->value);
-      }
+      QueryHistoryText(text_query, options, &request->value);
     }
   }
 
   request->ForwardResult(request->handle(), &request->value);
 
   UMA_HISTOGRAM_TIMES("History.QueryHistory",
                       TimeTicks::Now() - beginning_time);
 }
 
 // Basic time-based querying of history.
-void HistoryBackend::QueryHistoryBasic(URLDatabase* url_db,
-                                       VisitDatabase* visit_db,
-                                       const QueryOptions& options,
+void HistoryBackend::QueryHistoryBasic(const QueryOptions& options,
                                        QueryResults* result) {
   // First get all visits.
   VisitVector visits;
-  bool has_more_results = visit_db->GetVisibleVisitsInRange(options, &visits);
+  bool has_more_results = db_->GetVisibleVisitsInRange(options, &visits);
   DCHECK(static_cast<int>(visits.size()) <= options.EffectiveMaxCount());
 
   // Now add them and the URL rows to the results.
   URLResult url_result;
   for (size_t i = 0; i < visits.size(); i++) {
     const VisitRow visit = visits[i];
 
     // Add a result row for this visit, get the URL info from the DB.
-    if (!url_db->GetURLRow(visit.url_id, &url_result)) {
+    if (!db_->GetURLRow(visit.url_id, &url_result)) {
       VLOG(0) << "Failed to get id " << visit.url_id
               << " from history.urls.";
       continue;  // DB out of sync and URL doesn't exist, try to recover.
     }
 
     if (!url_result.url().is_valid()) {
       VLOG(0) << "Got invalid URL from history.urls with id "
               << visit.url_id << ":  "
               << url_result.url().possibly_invalid_spec();
       continue;  // Don't report invalid URLs in case of corruption.
     }
 
-    // The archived database may be out of sync with respect to starring,
-    // titles, last visit date, etc. Therefore, we query the main DB if the
-    // current URL database is not the main one.
-    if (url_db == db_.get()) {
-      // Currently querying the archived DB, update with the main database to
-      // catch any interesting stuff. This will update it if it exists in the
-      // main DB, and do nothing otherwise.
-      db_->GetRowForURL(url_result.url(), &url_result);
-    }
-
     url_result.set_visit_time(visit.visit_time);
 
     // Set whether the visit was blocked for a managed user by looking at the
     // transition type.
     url_result.set_blocked_visit(
         (visit.transition & content::PAGE_TRANSITION_BLOCKED) != 0);
 
     // We don't set any of the query-specific parts of the URLResult, since
     // snippets and stuff don't apply to basic querying.
     result->AppendURLBySwapping(&url_result);
   }
 
   if (!has_more_results && options.begin_time <= first_recorded_time_)
     result->set_reached_beginning(true);
 }
 
 // Text-based querying of history.
-void HistoryBackend::QueryHistoryText(URLDatabase* url_db,
-                                      VisitDatabase* visit_db,
-                                      const base::string16& text_query,
+void HistoryBackend::QueryHistoryText(const base::string16& text_query,
                                       const QueryOptions& options,
                                       QueryResults* result) {
   URLRows text_matches;
-  url_db->GetTextMatches(text_query, &text_matches);
+  db_->GetTextMatches(text_query, &text_matches);
 
   std::vector<URLResult> matching_visits;
   VisitVector visits;    // Declare outside loop to prevent re-construction.
   for (size_t i = 0; i < text_matches.size(); i++) {
     const URLRow& text_match = text_matches[i];
     // Get all visits for given URL match.
-    visit_db->GetVisibleVisitsForURL(text_match.id(), options, &visits);
+    db_->GetVisibleVisitsForURL(text_match.id(), options, &visits);
     for (size_t j = 0; j < visits.size(); j++) {
       URLResult url_result(text_match);
       url_result.set_visit_time(visits[j].visit_time);
       matching_visits.push_back(url_result);
     }
   }
 
   std::sort(matching_visits.begin(), matching_visits.end(),
             URLResult::CompareVisitTime);
 
@@ skipping 1109 matching lines @@
   db_->CommitTransaction();
   DCHECK(db_->transaction_nesting() == 0) << "Somebody left a transaction open";
   db_->BeginTransaction();
 
   if (thumbnail_db_) {
     thumbnail_db_->CommitTransaction();
     DCHECK(thumbnail_db_->transaction_nesting() == 0) <<
         "Somebody left a transaction open";
     thumbnail_db_->BeginTransaction();
   }
-
-  if (archived_db_) {
-    archived_db_->CommitTransaction();
-    archived_db_->BeginTransaction();
-  }
 }
 
 void HistoryBackend::ScheduleCommit() {
   if (scheduled_commit_.get())
     return;
   scheduled_commit_ = new CommitLaterTask(this);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CommitLaterTask::RunCommit, scheduled_commit_.get()),
       base::TimeDelta::FromSeconds(kCommitIntervalSeconds));
@@ skipping 106 matching lines @@
       << times.begin()->ToJsTime() << " v.s. " << begin_time.ToJsTime();
   DCHECK(*times.rbegin() < end_time)
       << "Max time is after end time: "
       << times.rbegin()->ToJsTime() << " v.s. " << end_time.ToJsTime();
 
   history::QueryOptions options;
   options.begin_time = begin_time;
   options.end_time = end_time;
   options.duplicate_policy = QueryOptions::KEEP_ALL_DUPLICATES;
   QueryResults results;
-  QueryHistoryBasic(db_.get(), db_.get(), options, &results);
+  QueryHistoryBasic(options, &results);
 
   // 1st pass: find URLs that are visited at one of |times|.
   std::set<GURL> urls;
   for (size_t i = 0; i < results.size(); ++i) {
     if (times.count(results[i].visit_time()) > 0)
       urls.insert(results[i].url());
   }
   if (urls.empty())
     return;
 
@@ skipping 84 matching lines @@
   bool success = db_->Raze();
   UMA_HISTOGRAM_BOOLEAN("History.KillHistoryDatabaseResult", success);
 
 #if defined(OS_ANDROID)
   // Release AndroidProviderBackend before other objects.
   android_provider_backend_.reset();
 #endif
 
   // The expirer keeps tabs on the active databases. Tell it about the
   // databases which will be closed.
-  expirer_.SetDatabases(NULL, NULL, NULL);
+  expirer_.SetDatabases(NULL, NULL);
 
   // Reopen a new transaction for |db_| for the sake of CloseAllDatabases().
   db_->BeginTransaction();
   CloseAllDatabases();
 }
 
 void HistoryBackend::ProcessDBTask(
     scoped_refptr<HistoryDBTaskRequest> request) {
   DCHECK(request.get());
   if (request->canceled())
@@ skipping 18 matching lines @@
   if (delegate_)
     delegate_->BroadcastNotifications(type, details.Pass());
 }
 
 void HistoryBackend::NotifySyncURLsModified(URLRows* rows) {
   if (typed_url_syncable_service_.get())
     typed_url_syncable_service_->OnUrlsModified(rows);
 }
 
 void HistoryBackend::NotifySyncURLsDeleted(bool all_history,
-                                           bool archived,
+                                           bool expired,
                                            URLRows* rows) {
   if (typed_url_syncable_service_.get())
-    typed_url_syncable_service_->OnUrlsDeleted(all_history, archived, rows);
+    typed_url_syncable_service_->OnUrlsDeleted(all_history, expired, rows);
 }
 
 // Deleting --------------------------------------------------------------------
 
 void HistoryBackend::DeleteAllHistory() {
   // Our approach to deleting all history is:
   //  1. Copy the bookmarks and their dependencies to new tables with temporary
   //     names.
   //  2. Delete the original tables. Since tables can not share pages, we know
   //     that any data we don't want to keep is now in an unused page.
@@ skipping 31 matching lines @@
     // history, we should delete as much as we can.
   }
 
   // ClearAllMainHistory will change the IDs of the URLs in kept_urls.
   // Therefore, we clear the list afterwards to make sure nobody uses this
   // invalid data.
   if (!ClearAllMainHistory(kept_urls))
     LOG(ERROR) << "Main history could not be cleared";
   kept_urls.clear();
 
-  // Delete archived history.
-  if (archived_db_) {
-    // Close the database and delete the file.
-    archived_db_.reset();
-    base::FilePath archived_file_name = GetArchivedFileName();
-    sql::Connection::Delete(archived_file_name);
-
-    // Now re-initialize the database (which may fail).
-    archived_db_.reset(new ArchivedDatabase());
-    if (!archived_db_->Init(archived_file_name)) {
-      LOG(WARNING) << "Could not initialize the archived database.";
-      archived_db_.reset();
-    } else {
-      // Open our long-running transaction on this database.
-      archived_db_->BeginTransaction();
-    }
-  }
-
   db_->GetStartDate(&first_recorded_time_);
 
   // Send out the notification that history is cleared. The in-memory database
   // will pick this up and clear itself.
   scoped_ptr<URLsDeletedDetails> details(new URLsDeletedDetails);
   details->all_history = true;
   NotifySyncURLsDeleted(true, false, NULL);
   BroadcastNotifications(chrome::NOTIFICATION_HISTORY_URLS_DELETED,
                          details.PassAs<HistoryDetails>());
 }
@@ skipping 110 matching lines @@
   int rank = kPageVisitStatsMaxTopSites;
   std::map<GURL, int>::const_iterator it = most_visited_urls_map_.find(url);
   if (it != most_visited_urls_map_.end())
     rank = (*it).second;
   UMA_HISTOGRAM_ENUMERATION("History.TopSitesVisitsByRank",
                             rank, kPageVisitStatsMaxTopSites + 1);
 }
 #endif
 
 }  // namespace history