Remove TextDatabase from the history service.

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.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.h"
-#include "chrome/browser/history/text_database_manager.h"
 #include "chrome/browser/history/thumbnail_database.h"
 #include "chrome/common/chrome_notification_types.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace history {
 
 namespace {
 
@@ skipping 132 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,
-                                        TextDatabaseManager* text_db) {
+                                        ThumbnailDatabase* thumb_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 35 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)
-      file_util::Delete(file, false);
-  }
-}
-
 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