Remove NOTIFICATION_HISTORY_URLS_DELETED

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 12 matching lines @@
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.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/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/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/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 129 matching lines @@
                                    base::Bind(&HistoryService::NotifyURLVisited,
                                               history_service_,
                                               transition,
                                               row,
                                               redirects,
                                               visit_time));
   }
 
   void NotifyURLsModified(const history::URLRows& changed_urls) override {
     service_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&HistoryService::NotifyURLsModified,
+                              history_service_, changed_urls));
+  }
+
+  void NotifyURLsDeleted(bool all_history,
+                         bool expired,
+                         const history::URLRows& deleted_rows,
+                         const std::set<GURL>& favicon_urls) override {
+    service_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&HistoryService::NotifyURLsModified,
-                   history_service_,
-                   changed_urls));
+        base::Bind(&HistoryService::NotifyURLsDeleted, history_service_,
+                   all_history, expired, deleted_rows, favicon_urls));
   }
 
   void BroadcastNotifications(
       int type,
       scoped_ptr<history::HistoryDetails> details) override {
     // Send the notification on the history thread.
     if (content::NotificationService::current()) {
       content::Details<history::HistoryDetails> det(details.get());
       content::NotificationService::current()->Notify(
           type, content::Source<Profile>(profile_), det);
@@ skipping 32 matching lines @@
 HistoryService::HistoryService(history::HistoryClient* client, Profile* profile)
     : thread_(new base::Thread(kHistoryThreadName)),
       history_client_(client),
       profile_(profile),
       visitedlink_master_(new visitedlink::VisitedLinkMaster(
           profile, this, true)),
       backend_loaded_(false),
       no_db_(false),
       weak_ptr_factory_(this) {
   DCHECK(profile_);
-  registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED,
-                 content::Source<Profile>(profile_));
 }
 
 HistoryService::~HistoryService() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Shutdown the backend. This does nothing if Cleanup was already invoked.
   Cleanup();
 }
 
 bool HistoryService::BackendLoaded() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 679 matching lines @@
   }
 
   // Delete the thread, which joins with the background thread. We defensively
   // NULL the pointer before deleting it in case somebody tries to use it
   // during shutdown, but this shouldn't happen.
   base::Thread* thread = thread_;
   thread_ = NULL;
   delete thread;
 }
 
-void HistoryService::Observe(int type,
-                             const content::NotificationSource& source,
-                             const content::NotificationDetails& details) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  if (!thread_)
-    return;
-
-  switch (type) {
-    case chrome::NOTIFICATION_HISTORY_URLS_DELETED: {
-      // Update the visited link system for deleted URLs. We will update the
-      // visited link system for added URLs as soon as we get the add
-      // notification (we don't have to wait for the backend, which allows us to
-      // be faster to update the state).
-      //
-      // For deleted URLs, we don't typically know what will be deleted since
-      // delete notifications are by time. We would also like to be more
-      // respectful of privacy and never tell the user something is gone when it
-      // isn't. Therefore, we update the delete URLs after the fact.
-      if (visitedlink_master_) {
-        content::Details<history::URLsDeletedDetails> deleted_details(details);
-
-        if (deleted_details->all_history) {
-          visitedlink_master_->DeleteAllURLs();
-        } else {
-          URLIteratorFromURLRows iterator(deleted_details->rows);
-          visitedlink_master_->DeleteURLs(&iterator);
-        }
-      }
-      break;
-    }
-
-    default:
-      NOTREACHED();
-  }
-}
-
 void HistoryService::RebuildTable(
     const scoped_refptr<URLEnumerator>& enumerator) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
   ScheduleAndForget(PRIORITY_NORMAL, &HistoryBackend::IterateURLs, enumerator);
 }
 
 bool HistoryService::Init(const base::FilePath& history_dir, bool no_db) {
   DCHECK(thread_) << "History service being called after cleanup";
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 272 matching lines @@
                     OnURLVisited(this, transition, row, redirects, visit_time));
 }
 
 void HistoryService::NotifyURLsModified(const history::URLRows& changed_urls) {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(history::HistoryServiceObserver,
                     observers_,
                     OnURLsModified(this, changed_urls));
 }
 
+void HistoryService::NotifyURLsDeleted(bool all_history,
+                                       bool expired,
+                                       const history::URLRows& deleted_rows,
+                                       const std::set<GURL>& favicon_urls) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!thread_)
+    return;
+
+  // Update the visited link system for deleted URLs. We will update the
+  // visited link system for added URLs as soon as we get the add
+  // notification (we don't have to wait for the backend, which allows us to
+  // be faster to update the state).
+  //
+  // For deleted URLs, we don't typically know what will be deleted since
+  // delete notifications are by time. We would also like to be more
+  // respectful of privacy and never tell the user something is gone when it
+  // isn't. Therefore, we update the delete URLs after the fact.
+  if (visitedlink_master_) {
+    if (all_history) {
+      visitedlink_master_->DeleteAllURLs();
+    } else {
+      URLIteratorFromURLRows iterator(deleted_rows);
+      visitedlink_master_->DeleteURLs(&iterator);
+    }
+  }
+
+  FOR_EACH_OBSERVER(
+      history::HistoryServiceObserver, observers_,
+      OnURLsDeleted(this, all_history, expired, deleted_rows, favicon_urls));
+}
+
 void HistoryService::NotifyHistoryServiceLoaded() {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(history::HistoryServiceObserver, observers_,
                     OnHistoryServiceLoaded(this));
 }
 
 void HistoryService::NotifyHistoryServiceBeingDeleted() {
   DCHECK(thread_checker_.CalledOnValidThread());
   FOR_EACH_OBSERVER(history::HistoryServiceObserver, observers_,
                     HistoryServiceBeingDeleted(this));
 }
 
 scoped_ptr<base::CallbackList<void(const std::set<GURL>&)>::Subscription>
 HistoryService::AddFaviconChangedCallback(
     const HistoryService::OnFaviconChangedCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return favicon_changed_callback_list_.Add(callback);
 }
 
 void HistoryService::NotifyFaviconChanged(
     const std::set<GURL>& changed_favicons) {
   DCHECK(thread_checker_.CalledOnValidThread());
   favicon_changed_callback_list_.Notify(changed_favicons);
 }