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

chrome/browser/google/google_url_tracker.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.
 
 #include "chrome/browser/google/google_url_tracker.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "ui/base/l10n/l10n_util.h"
 
@@ skipping 223 matching lines @@
 
   need_to_prompt_ = true;
 }
 
 void GoogleURLTracker::AcceptGoogleURL(const GURL& new_google_url) {
   google_url_ = new_google_url;
   g_browser_process->local_state()->SetString(prefs::kLastKnownGoogleURL,
                                               google_url_.spec());
   g_browser_process->local_state()->SetString(prefs::kLastPromptedGoogleURL,
                                               google_url_.spec());
-  NotificationService::current()->Notify(NotificationType::GOOGLE_URL_UPDATED,
-                                         NotificationService::AllSources(),
-                                         NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      chrome::NOTIFICATION_GOOGLE_URL_UPDATED,
+      NotificationService::AllSources(),
+      NotificationService::NoDetails());
   need_to_prompt_ = false;
 }
 
 void GoogleURLTracker::CancelGoogleURL(const GURL& new_google_url) {
   g_browser_process->local_state()->SetString(prefs::kLastPromptedGoogleURL,
                                               new_google_url.spec());
   need_to_prompt_ = false;
 }
 
 void GoogleURLTracker::InfoBarClosed() {
   registrar_.RemoveAll();
   controller_ = NULL;
   infobar_ = NULL;
   search_url_ = GURL();
 }
 
 void GoogleURLTracker::RedoSearch() {
   //  Re-do the user's search on the new domain.
   DCHECK(controller_);
   url_canon::Replacements<char> replacements;
   replacements.SetHost(google_url_.host().data(),
                        url_parse::Component(0, google_url_.host().length()));
   GURL new_search_url(search_url_.ReplaceComponents(replacements));
   if (new_search_url.is_valid())
     controller_->tab_contents()->OpenURL(new_search_url, GURL(), CURRENT_TAB,
                                          PageTransition::GENERATED);
 }
 
-void GoogleURLTracker::Observe(NotificationType type,
+void GoogleURLTracker::Observe(int type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::NAV_ENTRY_PENDING: {
+  switch (type) {
+    case content::NOTIFICATION_NAV_ENTRY_PENDING: {
       NavigationController* controller =
           Source<NavigationController>(source).ptr();
       OnNavigationPending(source, controller->pending_entry()->url());
       break;
     }
 
-    case NotificationType::NAV_ENTRY_COMMITTED:
-    case NotificationType::TAB_CLOSED:
+    case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
+    case content::NOTIFICATION_TAB_CLOSED:
       OnNavigationCommittedOrTabClosed(
           Source<NavigationController>(source).ptr()->tab_contents(),
-          type.value);
+          type);
       break;
 
     default:
-      NOTREACHED() << "Unknown notification received:" << type.value;
+      NOTREACHED() << "Unknown notification received:" << type;
   }
 }
 
 void GoogleURLTracker::OnIPAddressChanged() {
   already_fetched_ = false;
   StartFetchIfDesirable();
 }
 
 void GoogleURLTracker::SearchCommitted() {
   if (registrar_.IsEmpty() && (need_to_prompt_ || fetcher_.get())) {
     // This notification will fire a bit later in the same call chain we're
     // currently in.
-    registrar_.Add(this, NotificationType::NAV_ENTRY_PENDING,
+    registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
                    NotificationService::AllSources());
   }
 }
 
 void GoogleURLTracker::OnNavigationPending(const NotificationSource& source,
                                            const GURL& pending_url) {
   controller_ = Source<NavigationController>(source).ptr();
   search_url_ = pending_url;
-  registrar_.Remove(this, NotificationType::NAV_ENTRY_PENDING,
+  registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
                     NotificationService::AllSources());
   // Start listening for the commit notification. We also need to listen for the
   // tab close command since that means the load will never commit.
-  registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+  registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(controller_));
-  registrar_.Add(this, NotificationType::TAB_CLOSED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CLOSED,
                  Source<NavigationController>(controller_));
 }
 
 void GoogleURLTracker::OnNavigationCommittedOrTabClosed(
     TabContents* tab_contents,
-    NotificationType::Type type) {
+    int type) {
   registrar_.RemoveAll();
 
-  if (type == NotificationType::NAV_ENTRY_COMMITTED) {
+  if (type == content::NOTIFICATION_NAV_ENTRY_COMMITTED) {
     ShowGoogleURLInfoBarIfNecessary(tab_contents);
   } else {
     controller_ = NULL;
     infobar_ = NULL;
   }
 }
 
 void GoogleURLTracker::ShowGoogleURLInfoBarIfNecessary(
     TabContents* tab_contents) {
   if (!need_to_prompt_)
     return;
   DCHECK(!fetched_google_url_.is_empty());
 
   infobar_ = (*infobar_creator_)(tab_contents, this, fetched_google_url_);
 }