Abstract history dependencies on bookmarks through HistoryClient

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/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/thumbnail_database.h"
-#include "components/bookmarks/browser/bookmark_service.h"
+#include "components/history/core/browser/history_client.h"
 
 namespace history {
 
 // Helpers --------------------------------------------------------------------
 
 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.
 //
@@ skipping 115 matching lines @@
 }
 
 ExpireHistoryBackend::DeleteEffects::~DeleteEffects() {
 }
 
 
 // ExpireHistoryBackend -------------------------------------------------------
 
 ExpireHistoryBackend::ExpireHistoryBackend(
     BroadcastNotificationDelegate* delegate,
-    BookmarkService* bookmark_service)
+    HistoryClient* history_client)
     : delegate_(delegate),
       main_db_(NULL),
       archived_db_(NULL),
       thumb_db_(NULL),
       weak_factory_(this),
-      bookmark_service_(bookmark_service) {
+      history_client_(history_client) {
 }
 
 ExpireHistoryBackend::~ExpireHistoryBackend() {
 }
 
 void ExpireHistoryBackend::SetDatabases(HistoryDatabase* main_db,
                                         ArchivedDatabase* archived_db,
                                         ThumbnailDatabase* thumb_db) {
   main_db_ = main_db;
   archived_db_ = archived_db;
   thumb_db_ = thumb_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;
 
   DeleteEffects effects;
+  HistoryClient* history_client = GetHistoryClient();
   for (std::vector<GURL>::const_iterator url = urls.begin(); url != urls.end();
        ++url) {
     URLRow url_row;
     if (!main_db_->GetRowForURL(*url, &url_row))
       continue;  // Nothing to delete.
 
     // Collect all the visits and delete them. Note that we don't give
     // up if there are no visits, since the URL could still have an
     // entry that we should delete.  TODO(brettw): bug 1171148: We
     // should also delete from the archived DB.
     VisitVector visits;
     main_db_->GetVisitsForURL(url_row.id(), &visits);
 
     DeleteVisitRelatedInfo(visits, &effects);
 
     // We skip ExpireURLsForVisits (since we are deleting from the
     // URL, and not starting with visits in a given time range). We
     // therefore need to call the deletion and favicon update
     // functions manually.
-    BookmarkService* bookmark_service = GetBookmarkService();
     DeleteOneURL(url_row,
-                 bookmark_service && bookmark_service->IsBookmarked(*url),
+                 history_client && history_client->IsBookmarked(*url),
                  &effects);
   }
 
   DeleteFaviconsIfPossible(&effects);
 
   BroadcastNotifications(&effects, DELETION_USER_INITIATED);
 }
 
 void ExpireHistoryBackend::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls,
@@ skipping 238 matching lines @@
         content::PageTransitionStripQualifier(visits[i].transition);
     if (transition != content::PAGE_TRANSITION_RELOAD)
       cur.visit_count++;
     if ((transition == content::PAGE_TRANSITION_TYPED &&
         !content::PageTransitionIsRedirect(visits[i].transition)) ||
         transition == content::PAGE_TRANSITION_KEYWORD_GENERATED)
       cur.typed_count++;
   }
 
   // Check each unique URL with deleted visits.
-  BookmarkService* bookmark_service = GetBookmarkService();
+  HistoryClient* history_client = GetHistoryClient();
   for (std::map<URLID, ChangedURL>::const_iterator i = changed_urls.begin();
        i != changed_urls.end(); ++i) {
     // The unique URL rows should already be filled in.
     URLRow& url_row = effects->affected_urls[i->first];
     if (!url_row.id())
       continue;  // URL row doesn't exist in the database.
 
     // Check if there are any other visits for this URL and update the time
     // (the time change may not actually be synced to disk below when we're
     // archiving).
     VisitRow last_visit;
     if (main_db_->GetMostRecentVisitForURL(url_row.id(), &last_visit))
       url_row.set_last_visit(last_visit.visit_time);
     else
       url_row.set_last_visit(base::Time());
 
     // Don't delete URLs with visits still in the DB, or bookmarked.
     bool is_bookmarked =
-        (bookmark_service && bookmark_service->IsBookmarked(url_row.url()));
+        (history_client && history_client->IsBookmarked(url_row.url()));
     if (!is_bookmarked && url_row.last_visit().is_null()) {
       // Not bookmarked and no more visits. Nuke the url.
       DeleteOneURL(url_row, is_bookmarked, effects);
     } else {
       // NOTE: The calls to std::max() below are a backstop, but they should
       // never actually be needed unless the database is corrupt (I think).
       url_row.set_visit_count(
           std::max(0, url_row.visit_count() - i->second.visit_count));
       url_row.set_typed_count(
           std::max(0, url_row.typed_count() - i->second.typed_count));
@@ skipping 124 matching lines @@
   DeleteFaviconsIfPossible(&deleted_effects);
   BroadcastNotifications(&deleted_effects, DELETION_ARCHIVED);
 
   return more_to_expire;
 }
 
 void ExpireHistoryBackend::ParanoidExpireHistory() {
   // TODO(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_;
+HistoryClient* ExpireHistoryBackend::GetHistoryClient() {
+  // We use the history client to determine if a URL is bookmarked. The data is
+  // loaded on a separate thread and may not be done by the time we get here.
+  // We therefore block until the bookmarks have finished loading.
+  if (history_client_)
+    history_client_->BlockTillBookmarksLoaded();
+  return history_client_;
 }
 
 }  // namespace history