Remove dependencies of InMemoryURLIndex on Profile

chrome/browser/history/in_memory_url_index.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/in_memory_url_index.h"
 
 #include "base/debug/trace_event.h"
 #include "base/files/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/history/history_service.h"
-#include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/url_index_private_data.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "components/history/core/browser/url_database.h"
 #include "content/public/browser/browser_thread.h"
 
 using in_memory_url_index::InMemoryURLIndexCacheItem;
 
 namespace history {
 
 // Called by DoSaveToCacheFile to delete any old cache file at |path| when
 // there is no private data to save. Runs on the FILE thread.
@@ skipping 50 matching lines @@
     DoneRunOnMainThread() {
   index_->DoneRebuidingPrivateDataFromHistoryDB(succeeded_, data_);
 }
 
 InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask::
     ~RebuildPrivateDataFromHistoryDBTask() {
 }
 
 // InMemoryURLIndex ------------------------------------------------------------
 
-InMemoryURLIndex::InMemoryURLIndex(Profile* profile,
-                                   HistoryService* history_service,
+InMemoryURLIndex::InMemoryURLIndex(HistoryService* history_service,
                                    const base::FilePath& history_dir,
                                    const std::string& languages,
                                    HistoryClient* history_client)
-    : profile_(profile),
-      history_service_(history_service),
+    : history_service_(history_service),
       history_client_(history_client),
       history_dir_(history_dir),
       languages_(languages),
       private_data_(new URLIndexPrivateData),
       restore_cache_observer_(NULL),
       save_cache_observer_(NULL),
       shutdown_(false),
       restored_(false),
-      needs_to_be_cached_(false),
-      history_service_observer_(this) {
+      needs_to_be_cached_(false) {
   InitializeSchemeWhitelist(&scheme_whitelist_);
   // TODO(mrossetti): Register for language change notifications.
   if (history_service_)
-    history_service_observer_.Add(history_service_);
-}
-
-// Called only by unit tests.
-InMemoryURLIndex::InMemoryURLIndex()
-    : profile_(NULL),
-      history_service_(nullptr),
-      history_client_(NULL),
-      private_data_(new URLIndexPrivateData),
-      restore_cache_observer_(NULL),
-      save_cache_observer_(NULL),
-      shutdown_(false),
-      restored_(false),
-      needs_to_be_cached_(false),
-      history_service_observer_(this) {
-  InitializeSchemeWhitelist(&scheme_whitelist_);
+    history_service_->AddObserver(this);
 }
 
 InMemoryURLIndex::~InMemoryURLIndex() {
   // If there was a history directory (which there won't be for some unit tests)
   // then insure that the cache has already been saved.
   DCHECK(history_dir_.empty() || !needs_to_be_cached_);
 }
 
 void InMemoryURLIndex::Init() {
   PostRestoreFromCacheFileTask();
 }
 
 void InMemoryURLIndex::ShutDown() {
-  history_service_observer_.RemoveAll();
+  if (history_service_) {
+    history_service_->RemoveObserver(this);

[droger, 2015/01/27 09:32:32]

What happens if ShutDown is never called, is the observer leaked?
Or if ShutDown must be called, can we DCHECK (shutdown_) in the destructor?

[sdefresne, 2015/01/27 10:13:56]

Yes, the observer would have been leaked. I added the DCHECK(). It is okay since
the only client code is the HistoryService itself (which does call ShutDown())
and from unit tests that I fixed.

+    history_service_ = nullptr;
+  }
   cache_reader_tracker_.TryCancelAll();
   shutdown_ = true;
   base::FilePath path;
   if (!GetCacheFilePath(&path))
     return;
   private_data_tracker_.TryCancelAll();
   URLIndexPrivateData::WritePrivateDataToCacheFileTask(private_data_, path);
   needs_to_be_cached_ = false;
 }
 
@@ skipping 112 matching lines @@
 }
 
 void InMemoryURLIndex::OnCacheLoadDone(
     scoped_refptr<URLIndexPrivateData> private_data) {
   if (private_data.get() && !private_data->Empty()) {
     private_data_tracker_.TryCancelAll();
     private_data_ = private_data;
     restored_ = true;
     if (restore_cache_observer_)
       restore_cache_observer_->OnCacheRestoreFinished(true);
-  } else if (profile_) {
+  } else if (history_service_) {
     // When unable to restore from the cache file delete the cache file, if
     // it exists, and then rebuild from the history database if it's available,
     // otherwise wait until the history database loaded and then rebuild.
     base::FilePath path;
     if (!GetCacheFilePath(&path) || shutdown_)
       return;
     content::BrowserThread::PostBlockingPoolTask(
         FROM_HERE, base::Bind(DeleteCacheFile, path));
-    HistoryService* service =
-        HistoryServiceFactory::GetForProfileWithoutCreating(profile_);
-    if (service) {
-      if (!service->backend_loaded()) {
-        if (!history_service_observer_.IsObserving(service))
-          history_service_observer_.Add(service);
-      } else {
-        ScheduleRebuildFromHistory();
-      }
+    if (history_service_->backend_loaded()) {
+      ScheduleRebuildFromHistory();
     }
   }
 }
 
 // Restoring from the History DB -----------------------------------------------
 
 void InMemoryURLIndex::ScheduleRebuildFromHistory() {
-  HistoryService* service = HistoryServiceFactory::GetForProfile(
-      profile_, ServiceAccessType::EXPLICIT_ACCESS);
-  service->ScheduleDBTask(
+  DCHECK(history_service_);
+  history_service_->ScheduleDBTask(
       scoped_ptr<history::HistoryDBTask>(
           new InMemoryURLIndex::RebuildPrivateDataFromHistoryDBTask(
               this, languages_, scheme_whitelist_)),
       &cache_reader_tracker_);
 }
 
 void InMemoryURLIndex::DoneRebuidingPrivateDataFromHistoryDB(
     bool succeeded,
     scoped_refptr<URLIndexPrivateData> private_data) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
@@ skipping 43 matching lines @@
         base::Bind(DeleteCacheFile, path));
   }
 }
 
 void InMemoryURLIndex::OnCacheSaveDone(bool succeeded) {
   if (save_cache_observer_)
     save_cache_observer_->OnCacheSaveFinished(succeeded);
 }
 
 }  // namespace history