Remove NOTIFICATION_HISTORY_URLS_DELETED

chrome/browser/history/history_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_
 #define CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "base/time/time.h"
 #include "chrome/browser/history/delete_directive_handler.h"
 #include "chrome/browser/history/typed_url_syncable_service.h"
 #include "chrome/common/ref_counted_util.h"
 #include "components/favicon_base/favicon_callback.h"
 #include "components/history/core/browser/history_client.h"
 #include "components/history/core/browser/keyword_id.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/visitedlink/browser/visitedlink_delegate.h"
 #include "content/public/browser/download_manager_delegate.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 #include "sql/init_status.h"
 #include "sync/api/syncable_service.h"
 #include "ui/base/page_transition_types.h"
 
 #if defined(OS_ANDROID)
 class AndroidHistoryProviderService;
 #endif
 
 class GURL;
 class PageUsageData;
@@ skipping 21 matching lines @@
 class HistoryQueryTest;
 class HistoryServiceObserver;
 class HistoryTest;
 class InMemoryHistoryBackend;
 class InMemoryURLIndex;
 class InMemoryURLIndexTest;
 class URLDatabase;
 class VisitFilter;
 struct DownloadRow;
 struct HistoryAddPageArgs;
-struct HistoryDetails;
 struct KeywordSearchTermVisit;
 
 }  // namespace history
 
 // The history service records page titles, and visit times, as well as
 // (eventually) information about autocomplete.
 //
 // This service is thread safe. Each request callback is invoked in the
 // thread that made the request.
-class HistoryService : public content::NotificationObserver,
-                       public syncer::SyncableService,
+class HistoryService : public syncer::SyncableService,
                        public KeyedService,
                        public visitedlink::VisitedLinkDelegate {
  public:
   // Miscellaneous commonly-used types.
   typedef std::vector<PageUsageData*> PageUsageDataList;
 
   // Must call Init after construction. The |history::HistoryClient| object
   // must be valid for the whole lifetime of |HistoryService|.
   explicit HistoryService(history::HistoryClient* client, Profile* profile);
   // The empty constructor is provided only for testing.
@@ skipping 451 matching lines @@
   // will release pointers to it. No other functions should be called once
   // cleanup has happened that may dispatch to the history thread (because it
   // will be NULL).
   //
   // In practice, this will be called by the service manager (BrowserProcess)
   // when it is being destroyed. Because that reference is being destroyed, it
   // should be impossible for anybody else to call the service, even if it is
   // still in memory (pending requests may be holding a reference to us).
   void Cleanup();
 
-  // Implementation of content::NotificationObserver.
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
-
   // Implementation of visitedlink::VisitedLinkDelegate.
   void RebuildTable(const scoped_refptr<URLEnumerator>& enumerator) override;
 
   // Low-level Init().  Same as the public version, but adds a |no_db| parameter
   // that is only set by unittests which causes the backend to not init its DB.
   bool Init(bool no_db,
             const history::HistoryDatabaseParams& history_database_params);
 
   // Called by the HistoryURLProvider class to schedule an autocomplete, it
   // will be called back on the internal history thread with the history
   // database so it can query. See history_autocomplete.cc for a diagram.
   void ScheduleAutocomplete(const base::Callback<
       void(history::HistoryBackend*, history::URLDatabase*)>& callback);
 
-  // Broadcasts the given notification. This is called by the backend so that
-  // the notification will be broadcast on the main thread.
-  void BroadcastNotificationsHelper(
-      int type,
-      scoped_ptr<history::HistoryDetails> details);
-
   // Notification from the backend that it has finished loading. Sends
   // notification (NOTIFY_HISTORY_LOADED) and sets backend_loaded_ to true.
   void OnDBLoaded();
 
   // Helper function for getting URL information.
   // Reads a URLRow from in-memory database. Returns false if database is not
   // available or the URL does not exist.
   bool GetRowForURL(const GURL& url, history::URLRow* url_row);
 
   // Observers ----------------------------------------------------------------
 
   // Notify all Observers registered that the VisitDatabase was changed.
   void NotifyAddVisit(const history::BriefVisitInfo& info);
 
   // Notify all HistoryServiceObservers registered that user is visiting a URL.
   // The |row| ID will be set to the value that is currently in effect in the
   // main history database. |redirects| is the list of redirects leading up to
   // the URL. If we have a redirect chain A -> B -> C and user is visiting C,
   // then |redirects[0]=B| and |redirects[1]=A|. If there are no redirects,
   // |redirects| is an empty vector.
   void NotifyURLVisited(ui::PageTransition transition,
                         const history::URLRow& row,
                         const history::RedirectList& redirects,
                         base::Time visit_time);
 
   // Notify all HistoryServiceObservers registered that URLs have been added or
   // modified. |changed_urls| contains the list of affects URLs.
   void NotifyURLsModified(const history::URLRows& changed_urls);
 
+  // Notify all HistoryServiceObservers registered that URLs have been deleted.
+  // |all_history| is set to true, if all the URLs are deleted.
+  //               When set to true, |deleted_rows| and |favicon_urls| are
+  //               undefined.
+  // |expired| is set to true, if the URL deletion is due to expiration.
+  // |deleted_rows| list of the deleted URLs.
+  // |favicon_urls| list of favicon URLs that correspond to the deleted URLs.
+  void NotifyURLsDeleted(bool all_history,
+                         bool expired,
+                         const history::URLRows& deleted_rows,
+                         const std::set<GURL>& favicon_urls);
+
   // Notify all HistoryServiceObservers registered that the
   // HistoryService has finished loading.
   void NotifyHistoryServiceLoaded();
 
-  // HistoryService is being deleted.
+  // Notify all HistoryServiceObservers registered that HistoryService is being
+  // deleted.
   void NotifyHistoryServiceBeingDeleted();
 
   // Notify all HistoryServiceObservers registered that a keyword search term
   // has been updated. |row| contains the URL information for search |term|.
   // |keyword_id| associated with a URL and search term.
   void NotifyKeywordSearchTermUpdated(const history::URLRow& row,
                                       history::KeywordID keyword_id,
                                       const base::string16& term);
 
   // Notify all HistoryServiceObservers registered that keyword search term is
@@ skipping 233 matching lines @@
                          const ArgD& d,
                          const ArgE& e) {
     DCHECK(thread_) << "History service being called after cleanup";
     DCHECK(thread_checker_.CalledOnValidThread());
     ScheduleTask(priority, base::Bind(func, history_backend_.get(),
                                       a, b, c, d, e));
   }
 
   base::ThreadChecker thread_checker_;
 
-  content::NotificationRegistrar registrar_;
-
   // The thread used by the history service to run complicated operations.
   // |thread_| is NULL once |Cleanup| is NULL.
   base::Thread* thread_;
 
   // This class has most of the implementation and runs on the 'thread_'.
   // You MUST communicate with this class ONLY through the thread_'s
   // message_loop().
   //
   // This pointer will be NULL once Cleanup() has been called, meaning no
   // more calls should be made to the history thread.
@@ skipping 35 matching lines @@
 
   history::DeleteDirectiveHandler delete_directive_handler_;
 
   // All vended weak pointers are invalidated in Cleanup().
   base::WeakPtrFactory<HistoryService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HistoryService);
 };
 
 #endif  // CHROME_BROWSER_HISTORY_HISTORY_SERVICE_H_