Abstract history dependencies on bookmarks through HistoryClient

chrome/browser/history/history_service.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.
 
 // The history system runs on a background thread so that potentially slow
 // database operations don't delay the browser. This backend processing is
 // represented by HistoryBackend. The HistoryService's job is to dispatch to
 // that thread.
 //
 // Main thread                       History thread
@@ skipping 15 matching lines @@
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
-#include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/history/download_row.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/history/in_memory_database.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
 #include "chrome/browser/history/in_memory_url_index.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/history/visit_database.h"
 #include "chrome/browser/history/visit_filter.h"
 #include "chrome/browser/history/web_history_service.h"
 #include "chrome/browser/history/web_history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/profile_error_dialog.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/importer/imported_favicon_usage.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/url_constants.h"
-#include "components/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/history_client.h"
 #include "components/visitedlink/browser/visitedlink_master.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "sync/api/sync_error_factory.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
@@ skipping 119 matching lines @@
 
 // The history thread is intentionally not a BrowserThread because the
 // sync integration unit tests depend on being able to create more than one
 // history thread.
 HistoryService::HistoryService()
     : weak_ptr_factory_(this),
       thread_(new base::Thread(kHistoryThreadName)),
       history_client_(NULL),
       profile_(NULL),
       backend_loaded_(false),
-      bookmark_service_(NULL),
       no_db_(false) {
 }
 
 HistoryService::HistoryService(history::HistoryClient* client, Profile* profile)
     : weak_ptr_factory_(this),
       thread_(new base::Thread(kHistoryThreadName)),
       history_client_(client),
       profile_(profile),
       visitedlink_master_(new visitedlink::VisitedLinkMaster(
           profile, this, true)),
       backend_loaded_(false),
-      bookmark_service_(NULL),
       no_db_(false) {
   DCHECK(profile_);
   registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_TEMPLATE_URL_REMOVED,
                  content::Source<Profile>(profile_));
 }
 
 HistoryService::~HistoryService() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 102 matching lines @@
   return true;
 }
 
 history::TypedUrlSyncableService* HistoryService::GetTypedUrlSyncableService()
     const {
   return history_backend_->GetTypedUrlSyncableService();
 }
 
 void HistoryService::Shutdown() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // It's possible that bookmarks haven't loaded and history is waiting for
-  // bookmarks to complete loading. In such a situation history can't shutdown
-  // (meaning if we invoked history_service_->Cleanup now, we would
-  // deadlock). To break the deadlock we tell BookmarkModel it's about to be
-  // deleted so that it can release the signal history is waiting on, allowing
-  // history to shutdown (history_service_->Cleanup to complete). In such a
-  // scenario history sees an incorrect view of bookmarks, but it's better
-  // than a deadlock.
-  BookmarkModel* bookmark_model = static_cast<BookmarkModel*>(
-      BookmarkModelFactory::GetForProfileIfExists(profile_));
-  if (bookmark_model)
-    bookmark_model->Shutdown();
-
   Cleanup();
 }
 
 void HistoryService::SetKeywordSearchTermsForURL(const GURL& url,
                                                  TemplateURLID keyword_id,
                                                  const base::string16& term) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleAndForget(PRIORITY_UI,
                     &HistoryBackend::SetKeywordSearchTermsForURL,
                     url, keyword_id, term);
@@ skipping 547 matching lines @@
       NOTREACHED();
   }
 }
 
 void HistoryService::RebuildTable(
     const scoped_refptr<URLEnumerator>& enumerator) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::IterateURLs, enumerator);
 }
 
-bool HistoryService::Init(const base::FilePath& history_dir,
-                          BookmarkService* bookmark_service,
-                          bool no_db) {
+bool HistoryService::Init(const base::FilePath& history_dir, bool no_db) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!thread_->Start()) {
     Cleanup();
     return false;
   }
 
   history_dir_ = history_dir;
-  bookmark_service_ = bookmark_service;
   no_db_ = no_db;
 
   if (profile_) {
     std::string languages =
         profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
-    in_memory_url_index_.reset(
-        new history::InMemoryURLIndex(profile_, history_dir_, languages));
+    in_memory_url_index_.reset(new history::InMemoryURLIndex(
+        profile_, history_dir_, languages, history_client_));
     in_memory_url_index_->Init();
   }
 
   // Create the history backend.
   scoped_refptr<HistoryBackend> backend(
       new HistoryBackend(history_dir_,
                          new BackendDelegate(
                              weak_ptr_factory_.GetWeakPtr(),
                              base::ThreadTaskRunnerHandle::Get(),
                              profile_),
-                         bookmark_service_));
+                         history_client_));
   history_backend_.swap(backend);
 
   // There may not be a profile when unit testing.
   std::string languages;
   if (profile_) {
     PrefService* prefs = profile_->GetPrefs();
     languages = prefs->GetString(prefs::kAcceptLanguages);
   }
   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init, languages, no_db_);
 
@@ skipping 236 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   visit_database_observers_.RemoveObserver(observer);
 }
 
 void HistoryService::NotifyVisitDBObserversOnAddVisit(
     const history::BriefVisitInfo& info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(history::VisitDatabaseObserver, visit_database_observers_,
                     OnAddVisit(info));
 }