Eliminate NOTIFICATION_HISTORY_LOADED notification

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/file_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
@@ skipping 119 matching lines @@
   // 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() {
+  HistoryService* service =
+      HistoryServiceFactory::GetForProfileWithoutCreating(profile_);
+  if (service)
+    service->RemoveHistoryServiceObserver(this);

[sdefresne, 2014/10/20 13:15:42]

You can use ScopedObserver<> to simplify the code.

   registrar_.RemoveAll();
   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 37 matching lines @@
       OnURLVisited(content::Details<URLVisitedDetails>(details).ptr());
       break;
     case chrome::NOTIFICATION_HISTORY_URLS_MODIFIED:
       OnURLsModified(
           content::Details<history::URLsModifiedDetails>(details).ptr());
       break;
     case chrome::NOTIFICATION_HISTORY_URLS_DELETED:
       OnURLsDeleted(
           content::Details<history::URLsDeletedDetails>(details).ptr());
       break;
-    case chrome::NOTIFICATION_HISTORY_LOADED:
-      registrar_.Remove(this, chrome::NOTIFICATION_HISTORY_LOADED,
-                        content::Source<Profile>(profile_));
-      ScheduleRebuildFromHistory();
-      break;
     default:
       // For simplicity, the unit tests send us all notifications, even when
       // we haven't registered for them, so don't assert here.
       break;
   }
 }
 
 void InMemoryURLIndex::OnURLVisited(const URLVisitedDetails* details) {
   HistoryService* service =
       HistoryServiceFactory::GetForProfile(profile_,
@@ skipping 80 matching lines @@
     // 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 && service->backend_loaded()) {

[sdefresne, 2014/10/20 13:15:41]

|service| can only be NULL if running tests, so rewrite as

if (service) {
  if (!service->backend_loaded()) {
    service->AddObserver(this);
  } else {
    ScheduleRebuildFromHistory();
  }
}

[nshaik, 2014/10/29 08:43:39]

Done.

       ScheduleRebuildFromHistory();
     } else {
-      registrar_.Add(this, chrome::NOTIFICATION_HISTORY_LOADED,
-                     content::Source<Profile>(profile_));
+      service->AddHistoryServiceObserver(this);
     }
   }
 }
 
 // Restoring from the History DB -----------------------------------------------
 
 void InMemoryURLIndex::ScheduleRebuildFromHistory() {
   HistoryService* service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            Profile::EXPLICIT_ACCESS);
@@ skipping 53 matching lines @@
         FROM_HERE,
         base::Bind(DeleteCacheFile, path));
   }
 }
 
 void InMemoryURLIndex::OnCacheSaveDone(bool succeeded) {
   if (save_cache_observer_)
     save_cache_observer_->OnCacheSaveFinished(succeeded);
 }
 
+void InMemoryURLIndex::HistoryServiceLoaded(HistoryService* history_service) {
+  ScheduleRebuildFromHistory();
+  history_service->RemoveHistoryServiceObserver(this);
+}
+
 }  // namespace history