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/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/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"
 #include "chrome/common/importer/imported_favicon_usage.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/dom_distiller/core/url_constants.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/history/core/browser/history_client.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/history/core/browser/in_memory_database.h"
 #include "components/history/core/browser/keyword_search_term.h"
 #include "components/history/core/browser/visit_database.h"
 #include "components/history/core/browser/visit_filter.h"
 #include "components/history/core/common/thumbnail_score.h"
 #include "components/visitedlink/browser/visitedlink_master.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
-#include "content/public/browser/notification_service.h"
 #include "sync/api/sync_error_factory.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using base::Time;
 using history::HistoryBackend;
 using history::KeywordID;
 
 namespace {
 
 static const char* kHistoryThreadName = "Chrome_HistoryThread";
@@ skipping 52 matching lines @@
 }  // namespace
 
 // Sends messages from the backend to us on the main thread. This must be a
 // separate class from the history service so that it can hold a reference to
 // the history service (otherwise we would have to manually AddRef and
 // Release when the Backend has a reference to us).
 class HistoryService::BackendDelegate : public HistoryBackend::Delegate {
  public:
   BackendDelegate(
       const base::WeakPtr<HistoryService>& history_service,
-      const scoped_refptr<base::SequencedTaskRunner>& service_task_runner,
-      Profile* profile)
+      const scoped_refptr<base::SequencedTaskRunner>& service_task_runner)
       : history_service_(history_service),
-        service_task_runner_(service_task_runner),
-        profile_(profile) {
-  }
+        service_task_runner_(service_task_runner) {}
 
   void NotifyProfileError(sql::InitStatus init_status) override {
     // Send to the history service on the main thread.
     service_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&HistoryService::NotifyProfileError, history_service_,
                    init_status));
   }
 
   void SetInMemoryBackend(
@@ skipping 27 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 NotifyKeywordSearchTermUpdated(const history::URLRow& row,
                                       KeywordID keyword_id,
                                       const base::string16& term) override {
     service_task_runner_->PostTask(
         FROM_HERE, base::Bind(&HistoryService::NotifyKeywordSearchTermUpdated,
                               history_service_, row, keyword_id, term));
   }
 
   void NotifyKeywordSearchTermDeleted(history::URLID url_id) override {
     service_task_runner_->PostTask(
         FROM_HERE, base::Bind(&HistoryService::NotifyKeywordSearchTermDeleted,
                               history_service_, url_id));
   }
 
-  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);
-    }
-    // Send the notification to the history service on the main thread.
-    service_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&HistoryService::BroadcastNotificationsHelper,
-                   history_service_, type, base::Passed(&details)));
-  }
-
   void DBLoaded() override {
     service_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&HistoryService::OnDBLoaded, history_service_));
   }
 
  private:
   const base::WeakPtr<HistoryService> history_service_;
   const scoped_refptr<base::SequencedTaskRunner> service_task_runner_;
-  Profile* const profile_;
 };
 
 // The history thread is intentionally not a BrowserThread because the
 // sync integration unit tests depend on being able to create more than one
 // history thread.
 HistoryService::HistoryService()
     : thread_(new base::Thread(kHistoryThreadName)),
       history_client_(NULL),
       profile_(NULL),
       backend_loaded_(false),
       no_db_(false),
       weak_ptr_factory_(this) {
 }
 
 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(
     bool no_db,
     const history::HistoryDatabaseParams& history_database_params) {
@@ skipping 11 matching lines @@
 
   if (profile_) {
     std::string languages =
         profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
     in_memory_url_index_.reset(new history::InMemoryURLIndex(
         profile_, this, history_dir_, languages, history_client_));
     in_memory_url_index_->Init();
   }
 
   // Create the history backend.
-  scoped_refptr<HistoryBackend> backend(
-      new HistoryBackend(history_dir_,
-                         new BackendDelegate(
-                             weak_ptr_factory_.GetWeakPtr(),
-                             base::ThreadTaskRunnerHandle::Get(),
-                             profile_),
-                         history_client_));
+  scoped_refptr<HistoryBackend> backend(new HistoryBackend(
+      history_dir_, new BackendDelegate(weak_ptr_factory_.GetWeakPtr(),
+                                        base::ThreadTaskRunnerHandle::Get()),
+      history_client_));
   history_backend_.swap(backend);
 
   // There may not be a profile when unit testing.
   std::string languages;
   if (profile_) {
     PrefService* prefs = profile_->GetPrefs();
     languages = prefs->GetString(prefs::kAcceptLanguages);
   }
 
   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init, languages, no_db_,
@@ skipping 93 matching lines @@
       delete_directive);
 }
 
 void HistoryService::SetInMemoryBackend(
     scoped_ptr<history::InMemoryHistoryBackend> mem_backend) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!in_memory_backend_) << "Setting mem DB twice";
   in_memory_backend_.reset(mem_backend.release());
 
   // The database requires additional initialization once we own it.
-  in_memory_backend_->AttachToHistoryService(profile_, this);
+  in_memory_backend_->AttachToHistoryService(this);
 }
 
 void HistoryService::NotifyProfileError(sql::InitStatus init_status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (history_client_)
     history_client_->NotifyProfileError(init_status);
 }
 
 void HistoryService::DeleteURL(const GURL& url) {
   DCHECK(thread_) << "History service being called after cleanup";
@@ skipping 64 matching lines @@
     //
     // TODO(davidben): |callback| should not run until this operation completes
     // too.
     web_history->ExpireHistoryBetween(
         restrict_urls, begin_time, end_time,
         base::Bind(&ExpireWebHistoryComplete));
   }
   ExpireHistoryBetween(restrict_urls, begin_time, end_time, callback, tracker);
 }
 
-void HistoryService::BroadcastNotificationsHelper(
-    int type,
-    scoped_ptr<history::HistoryDetails> details) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  // TODO(evanm): this is currently necessitated by generate_profile, which
-  // runs without a browser process. generate_profile should really create
-  // a browser process, at which point this check can then be nuked.
-  if (!g_browser_process)
-    return;
-
-  if (!thread_)
-    return;
-
-  // The source of all of our notifications is the profile. Note that this
-  // pointer is NULL in unit tests.
-  content::Source<Profile> source(profile_);
-
-  // The details object just contains the pointer to the object that the
-  // backend has allocated for us. The receiver of the notification will cast
-  // this to the proper type.
-  content::Details<history::HistoryDetails> det(details.get());
-
-  content::NotificationService::current()->Notify(type, source, det);
-}
-
 void HistoryService::OnDBLoaded() {
   DCHECK(thread_checker_.CalledOnValidThread());
   backend_loaded_ = true;
   NotifyHistoryServiceLoaded();
 }
 
 bool HistoryService::GetRowForURL(const GURL& url, history::URLRow* url_row) {
   DCHECK(thread_checker_.CalledOnValidThread());
   history::URLDatabase* db = InMemoryDatabase();
   return db && (db->GetRowForURL(url, url_row) != 0);
@@ skipping 15 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));
@@ skipping 19 matching lines @@
     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);
 }