Remove NOTIFICATION_HISTORY_URLS_DELETED

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/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/history/history_notifications.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/bookmarks/browser/bookmark_model.h"
 #include "components/history/core/browser/url_database.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_details.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/browser/notification_source.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.
 void DeleteCacheFile(const base::FilePath& path) {
   DCHECK(!content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   base::DeleteFile(path, false);
@@ skipping 65 matching lines @@
       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) {
   InitializeSchemeWhitelist(&scheme_whitelist_);
-  if (profile) {
-    // TODO(mrossetti): Register for language change notifications.
-    content::Source<Profile> source(profile);
-    registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED, source);
-  }
+  // 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),
@@ skipping 11 matching lines @@
   // 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();
-  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 21 matching lines @@
       languages_,
       history_client_);
 }
 
 // Updating --------------------------------------------------------------------
 
 void InMemoryURLIndex::DeleteURL(const GURL& url) {
   private_data_->DeleteURL(url);
 }
 
-void InMemoryURLIndex::Observe(int notification_type,
-                               const content::NotificationSource& source,
-                               const content::NotificationDetails& details) {
-  switch (notification_type) {
-    case chrome::NOTIFICATION_HISTORY_URLS_DELETED:
-      OnURLsDeleted(
-          content::Details<history::URLsDeletedDetails>(details).ptr());
-      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(HistoryService* history_service,
                                     ui::PageTransition transition,
                                     const URLRow& row,
                                     const RedirectList& redirects,
                                     base::Time visit_time) {
   DCHECK_EQ(history_service_, history_service);
   needs_to_be_cached_ |= private_data_->UpdateURL(history_service_,
                                                   row,
                                                   languages_,
                                                   scheme_whitelist_,
                                                   &private_data_tracker_);
 }
 
 void InMemoryURLIndex::OnURLsModified(HistoryService* history_service,
                                       const URLRows& changed_urls) {
   DCHECK_EQ(history_service_, history_service);
   for (const auto& row : changed_urls) {
     needs_to_be_cached_ |= private_data_->UpdateURL(history_service_,
                                                     row,
                                                     languages_,
                                                     scheme_whitelist_,
                                                     &private_data_tracker_);
   }
 }
 
-void InMemoryURLIndex::OnHistoryServiceLoaded(HistoryService* history_service) {
-  ScheduleRebuildFromHistory();
-}
-
-void InMemoryURLIndex::OnURLsDeleted(const URLsDeletedDetails* details) {
-  if (details->all_history) {
+void InMemoryURLIndex::OnURLsDeleted(HistoryService* history_service,
+                                     bool all_history,
+                                     bool expired,
+                                     const URLRows& deleted_rows,
+                                     const std::set<GURL>& favicon_urls) {
+  if (all_history) {
     ClearPrivateData();
     needs_to_be_cached_ = true;
   } else {
-    for (URLRows::const_iterator row = details->rows.begin();
-         row != details->rows.end(); ++row)
-      needs_to_be_cached_ |= private_data_->DeleteURL(row->url());
+    for (const auto& row : deleted_rows)
+      needs_to_be_cached_ |= private_data_->DeleteURL(row.url());
   }
   // If we made changes, destroy the previous cache.  Otherwise, if we go
   // through an unclean shutdown (and therefore fail to write a new cache file),
   // when Chrome restarts and we restore from the previous cache, we'll end up
   // searching over URLs that may be deleted.  This would be wrong, and
   // surprising to the user who bothered to delete some URLs from his/her
   // history.  In this situation, deleting the cache is a better solution than
   // writing a new cache (after deleting the URLs from the in-memory structure)
   // because deleting the cache forces it to be rebuilt from history upon
   // startup.  If we instead write a new, updated cache then at the time of next
   // startup (after an unclean shutdown) we will not rebuild the in-memory data
   // structures from history but rather use the cache.  This solution is
   // mediocre because this cache may not have the most-recently-visited URLs
   // in it (URLs visited after user deleted some URLs from history), which
   // would be odd and confusing.  It's better to force a rebuild.
   base::FilePath path;
   if (needs_to_be_cached_ && GetCacheFilePath(&path)) {
     content::BrowserThread::PostBlockingPoolTask(
         FROM_HERE, base::Bind(DeleteCacheFile, path));
   }
 }
 
+void InMemoryURLIndex::OnHistoryServiceLoaded(HistoryService* history_service) {
+  ScheduleRebuildFromHistory();
+}
+
 // Restoring from Cache --------------------------------------------------------
 
 void InMemoryURLIndex::PostRestoreFromCacheFileTask() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   TRACE_EVENT0("browser", "InMemoryURLIndex::PostRestoreFromCacheFileTask");
 
   base::FilePath path;
   if (!GetCacheFilePath(&path) || shutdown_) {
     restored_ = true;
     if (restore_cache_observer_)
@@ skipping 101 matching lines @@
         base::Bind(DeleteCacheFile, path));
   }
 }
 
 void InMemoryURLIndex::OnCacheSaveDone(bool succeeded) {
   if (save_cache_observer_)
     save_cache_observer_->OnCacheSaveFinished(succeeded);
 }
 
 }  // namespace history