Moving notification types which are chrome specific to a new header file chrome_notification_type...

chrome/browser/history/history.cc

 // Copyright (c) 2011 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 26 matching lines @@
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/history/in_memory_database.h"
 #include "chrome/browser/history/in_memory_history_backend.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/profile_error_dialog.h"
 #include "chrome/browser/visitedlink/visitedlink_master.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using base::Time;
@@ skipping 23 matching lines @@
   }
 
   virtual void SetInMemoryBackend(
       history::InMemoryHistoryBackend* backend) OVERRIDE {
     // Send the backend to the history service on the main thread.
     message_loop_->PostTask(FROM_HERE, NewRunnableMethod(history_service_.get(),
         &HistoryService::SetInMemoryBackend, backend));
   }
 
   virtual void BroadcastNotifications(
-      NotificationType type,
+      int type,
       history::HistoryDetails* details) OVERRIDE {
     // Send the notification on the history thread.
     if (NotificationService::current()) {
       Details<history::HistoryDetails> det(details);
       NotificationService::current()->Notify(type,
                                              NotificationService::AllSources(),
                                              det);
     }
     // Send the notification to the history service on the main thread.
     message_loop_->PostTask(FROM_HERE, NewRunnableMethod(history_service_.get(),
@@ skipping 28 matching lines @@
 }
 
 HistoryService::HistoryService(Profile* profile)
     : thread_(new base::Thread(kHistoryThreadName)),
       profile_(profile),
       backend_loaded_(false),
       bookmark_service_(NULL),
       no_db_(false),
       needs_top_sites_migration_(false) {
   DCHECK(profile_);
-  registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
+  registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED,
                  Source<Profile>(profile_));
-  registrar_.Add(this, NotificationType::TEMPLATE_URL_REMOVED,
+  registrar_.Add(this, chrome::NOTIFICATION_TEMPLATE_URL_REMOVED,
                  Source<Profile>(profile_));
 }
 
 HistoryService::~HistoryService() {
   // Shutdown the backend. This does nothing if Cleanup was already invoked.
   Cleanup();
 }
 
 bool HistoryService::BackendLoaded() {
   // NOTE: We start the backend loading even though it completes asynchronously
@@ skipping 459 matching lines @@
     int result_count,
     int days_back,
     CancelableRequestConsumerBase* consumer,
     QueryMostVisitedURLsCallback* callback) {
   return Schedule(PRIORITY_NORMAL, &HistoryBackend::QueryMostVisitedURLs,
                   consumer,
                   new history::QueryMostVisitedURLsRequest(callback),
                   result_count, days_back);
 }
 
-void HistoryService::Observe(NotificationType type,
+void HistoryService::Observe(int type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   if (!thread_)
     return;
 
-  switch (type.value) {
-    case NotificationType::HISTORY_URLS_DELETED: {
+  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 (!profile_)
         return;  // No profile, probably unit testing.
       Details<history::URLsDeletedDetails> deleted_details(details);
       VisitedLinkMaster* visited_links = profile_->GetVisitedLinkMaster();
       if (!visited_links)
         return;  // Nobody to update.
       if (deleted_details->all_history)
         visited_links->DeleteAllURLs();
       else  // Delete individual ones.
         visited_links->DeleteURLs(deleted_details->urls);
       break;
     }
 
-    case NotificationType::TEMPLATE_URL_REMOVED:
+    case chrome::NOTIFICATION_TEMPLATE_URL_REMOVED:
       DeleteAllSearchTermsForKeyword(*(Details<TemplateURLID>(details).ptr()));
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 bool HistoryService::Init(const FilePath& history_dir,
                           BookmarkService* bookmark_service,
@@ skipping 73 matching lines @@
     CancelableRequestConsumerBase* consumer,
     ExpireHistoryCallback* callback) {
 
   // We will update the visited links when we observe the delete notifications.
   Schedule(PRIORITY_UI, &HistoryBackend::ExpireHistoryBetween, consumer,
            new history::ExpireHistoryRequest(callback),
            restrict_urls, begin_time, end_time);
 }
 
 void HistoryService::BroadcastNotifications(
-    NotificationType type,
+    int type,
     history::HistoryDetails* details_deleted) {
   // We take ownership of the passed-in pointer and delete it. It was made for
   // us on another thread, so the caller doesn't know when we will handle it.
   scoped_ptr<history::HistoryDetails> details(details_deleted);
   // 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;
 
@@ skipping 26 matching lines @@
   std::string languages;
   if (profile_) {
     PrefService* prefs = profile_->GetPrefs();
     languages = prefs->GetString(prefs::kAcceptLanguages);
   }
   ScheduleAndForget(PRIORITY_UI, &HistoryBackend::Init, languages, no_db_);
 }
 
 void HistoryService::OnDBLoaded() {
   backend_loaded_ = true;
-  NotificationService::current()->Notify(NotificationType::HISTORY_LOADED,
+  NotificationService::current()->Notify(chrome::NOTIFICATION_HISTORY_LOADED,
                                          Source<Profile>(profile_),
                                          Details<HistoryService>(this));
   if (thread_ && profile_) {
     // We don't want to force creation of TopSites.
     history::TopSites* ts = profile_->GetTopSitesWithoutCreating();
     if (ts)
       ts->HistoryLoaded();
   }
 }
 
 void HistoryService::StartTopSitesMigration() {
   needs_top_sites_migration_ = true;
   if (thread_ && profile_) {
     // We don't want to force creation of TopSites.
     history::TopSites* ts = profile_->GetTopSitesWithoutCreating();
     if (ts)
       ts->MigrateFromHistory();
   }
 }
 
 void HistoryService::OnTopSitesReady() {
   ScheduleAndForget(PRIORITY_NORMAL,
                     &HistoryBackend::MigrateThumbnailsDatabase);
 }