Revert 212459 "Remove TextDatabase from the history service."

trunk/src/chrome/browser/history/expire_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/expire_history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "chrome/browser/bookmarks/bookmark_service.h"
 #include "chrome/browser/chrome_notification_types.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.h"
+#include "chrome/browser/history/text_database_manager.h"
 #include "chrome/browser/history/thumbnail_database.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace history {
 
 namespace {
 
 // The number of days by which the expiration threshold is advanced for items
@@ skipping 131 matching lines @@
   URLRows deleted_urls;
 
   // The list of all favicon IDs that the affected URLs had. Favicons will be
   // shared between all URLs with the same favicon, so this is the set of IDs
   // that we will need to check when the delete operations are complete.
   std::set<chrome::FaviconID> affected_favicons;
 
   // The list of all favicon urls that were actually deleted from the thumbnail
   // db.
   std::set<GURL> expired_favicons;
+
+  // Tracks the set of databases that have changed so we can optimize when
+  // when we're done.
+  TextDatabaseManager::ChangeSet text_db_changes;
 };
 
 ExpireHistoryBackend::ExpireHistoryBackend(
     BroadcastNotificationDelegate* delegate,
     BookmarkService* bookmark_service)
     : delegate_(delegate),
       main_db_(NULL),
       archived_db_(NULL),
       thumb_db_(NULL),
+      text_db_(NULL),
       weak_factory_(this),
       bookmark_service_(bookmark_service) {
 }
 
 ExpireHistoryBackend::~ExpireHistoryBackend() {
 }
 
 void ExpireHistoryBackend::SetDatabases(HistoryDatabase* main_db,
                                         ArchivedDatabase* archived_db,
-                                        ThumbnailDatabase* thumb_db) {
+                                        ThumbnailDatabase* thumb_db,
+                                        TextDatabaseManager* text_db) {
   main_db_ = main_db;
   archived_db_ = archived_db;
   thumb_db_ = thumb_db;
+  text_db_ = text_db;
 }
 
 void ExpireHistoryBackend::DeleteURL(const GURL& url) {
   DeleteURLs(std::vector<GURL>(1, url));
 }
 
 void ExpireHistoryBackend::DeleteURLs(const std::vector<GURL>& urls) {
   if (!main_db_)
     return;
 
@@ skipping 21 matching lines @@
     BookmarkService* bookmark_service = GetBookmarkService();
     bool is_bookmarked =
         (bookmark_service && bookmark_service->IsBookmarked(*url));
 
     DeleteOneURL(url_row, is_bookmarked, &dependencies);
   }
 
   DeleteFaviconsIfPossible(dependencies.affected_favicons,
                            &dependencies.expired_favicons);
 
+  if (text_db_)
+    text_db_->OptimizeChangedDatabases(dependencies.text_db_changes);
+
   BroadcastDeleteNotifications(&dependencies, DELETION_USER_INITIATED);
 }
 
 void ExpireHistoryBackend::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls, Time begin_time, Time end_time) {
   if (!main_db_)
     return;
 
+  // There may be stuff in the text database manager's temporary cache.
+  if (text_db_)
+    text_db_->DeleteFromUncommitted(restrict_urls, begin_time, end_time);
+
   // Find the affected visits and delete them.
   // TODO(brettw): bug 1171164: We should query the archived database here, too.
   VisitVector visits;
   main_db_->GetAllVisitsInRange(begin_time, end_time, 0, &visits);
   if (!restrict_urls.empty()) {
     std::set<URLID> url_ids;
     for (std::set<GURL>::const_iterator url = restrict_urls.begin();
         url != restrict_urls.end(); ++url)
       url_ids.insert(main_db_->GetRowForURL(*url, NULL));
     VisitVector all_visits;
@@ skipping 13 matching lines @@
   // duplicates, i.e. each member must be earlier than the one before
   // it.
   DCHECK(
       std::adjacent_find(
           times.begin(), times.end(), std::less_equal<base::Time>()) ==
       times.end());
 
   if (!main_db_)
     return;
 
+  // There may be stuff in the text database manager's temporary cache.
+  if (text_db_)
+    text_db_->DeleteFromUncommittedForTimes(times);
+
   // Find the affected visits and delete them.
   // TODO(brettw): bug 1171164: We should query the archived database here, too.
   VisitVector visits;
   main_db_->GetVisitsForTimes(times, &visits);
   ExpireVisits(visits);
 }
 
 void ExpireHistoryBackend::ExpireVisits(const VisitVector& visits) {
   if (visits.empty())
     return;
@@ skipping 54 matching lines @@
   // 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();
+  ScheduleExpireHistoryIndexFiles();
 }
 
 void ExpireHistoryBackend::DeleteFaviconsIfPossible(
     const std::set<chrome::FaviconID>& favicon_set,
     std::set<GURL>* expired_favicons) {
   if (!thumb_db_)
     return;
 
   for (std::set<chrome::FaviconID>::const_iterator i = favicon_set.begin();
        i != favicon_set.end(); ++i) {
@@ skipping 33 matching lines @@
 void ExpireHistoryBackend::DeleteVisitRelatedInfo(
     const VisitVector& visits,
     DeleteDependencies* dependencies) {
   for (size_t i = 0; i < visits.size(); i++) {
     // Delete the visit itself.
     main_db_->DeleteVisit(visits[i]);
 
     // Add the URL row to the affected URL list.
     std::map<URLID, URLRow>::const_iterator found =
         dependencies->affected_urls.find(visits[i].url_id);
+    const URLRow* cur_row = NULL;
     if (found == dependencies->affected_urls.end()) {
       URLRow row;
       if (!main_db_->GetURLRow(visits[i].url_id, &row))
         continue;
       dependencies->affected_urls[visits[i].url_id] = row;
+      cur_row = &dependencies->affected_urls[visits[i].url_id];
+    } else {
+      cur_row = &found->second;
+    }
+
+    // Delete any associated full-text indexed data.
+    if (visits[i].is_indexed && text_db_) {
+      text_db_->DeletePageData(visits[i].visit_time, cur_row->url(),
+                               &dependencies->text_db_changes);
     }
   }
 }
 
 void ExpireHistoryBackend::DeleteOneURL(
     const URLRow& url_row,
     bool is_bookmarked,
     DeleteDependencies* dependencies) {
   main_db_->DeleteSegmentForURL(url_row.id());
 
+  // The URL may be in the text database manager's temporary cache.
+  if (text_db_) {
+    std::set<GURL> restrict_urls;
+    restrict_urls.insert(url_row.url());
+    text_db_->DeleteFromUncommitted(restrict_urls, base::Time(), base::Time());
+  }
+
   if (!is_bookmarked) {
     dependencies->deleted_urls.push_back(url_row);
 
     // Delete stuff that references this URL.
     if (thumb_db_) {
       thumb_db_->DeleteThumbnail(url_row.id());
 
       // Collect shared information.
       std::vector<IconMapping> icon_mappings;
       if (thumb_db_->GetIconMappingsForPageURL(url_row.url(), &icon_mappings)) {
@@ skipping 248 matching lines @@
   // to not do anything if nothing was deleted.
   BroadcastDeleteNotifications(&deleted_dependencies, DELETION_ARCHIVED);
 
   return more_to_expire;
 }
 
 void ExpireHistoryBackend::ParanoidExpireHistory() {
   // TODO(brettw): Bug 1067331: write this to clean up any errors.
 }
 
+void ExpireHistoryBackend::ScheduleExpireHistoryIndexFiles() {
+  if (!text_db_) {
+    // Can't expire old history index files because we
+    // don't know where they're located.
+    return;
+  }
+
+  TimeDelta delay = TimeDelta::FromMinutes(kIndexExpirationDelayMin);
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&ExpireHistoryBackend::DoExpireHistoryIndexFiles,
+                 weak_factory_.GetWeakPtr()),
+      delay);
+}
+
+void ExpireHistoryBackend::DoExpireHistoryIndexFiles() {
+  if (!text_db_) {
+    // The text database may have been closed since the task was scheduled.
+    return;
+  }
+
+  Time::Exploded exploded;
+  Time::Now().LocalExplode(&exploded);
+  int cutoff_month =
+      exploded.year * 12 + exploded.month - kStoreHistoryIndexesForMonths;
+  TextDatabase::DBIdent cutoff_id =
+      (cutoff_month / 12) * 100 + (cutoff_month % 12);
+
+  base::FilePath::StringType history_index_files_pattern =
+      TextDatabase::file_base();
+  history_index_files_pattern.append(FILE_PATH_LITERAL("*"));
+  base::FileEnumerator file_enumerator(
+      text_db_->GetDir(), false, base::FileEnumerator::FILES,
+      history_index_files_pattern);
+  for (base::FilePath file = file_enumerator.Next(); !file.empty();
+       file = file_enumerator.Next()) {
+    TextDatabase::DBIdent file_id = TextDatabase::FileNameToID(file);
+    if (file_id < cutoff_id)
+      sql::Connection::Delete(file);
+  }
+}
+
 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