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

chrome/browser/ui/tab_contents/tab_contents_wrapper.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/ui/tab_contents/tab_contents_wrapper.h"
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "chrome/browser/autocomplete_history_manager.h"
 #include "chrome/browser/autofill/autofill_manager.h"
@@ skipping 29 matching lines @@
 #include "chrome/browser/tab_contents/simple_alert_infobar_delegate.h"
 #include "chrome/browser/tab_contents/tab_contents_ssl_helper.h"
 #include "chrome/browser/tab_contents/thumbnail_generator.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/bookmarks/bookmark_tab_helper.h"
 #include "chrome/browser/ui/download/download_tab_helper.h"
 #include "chrome/browser/ui/find_bar/find_tab_helper.h"
 #include "chrome/browser/ui/search_engines/search_engine_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper_delegate.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/common/notification_service.h"
 #include "content/common/view_messages.h"
@@ skipping 85 matching lines @@
   // Start the in-browser thumbnailing if the feature is enabled.
   if (switches::IsInBrowserThumbnailingEnabled()) {
     thumbnail_generation_observer_.reset(new ThumbnailGenerator);
     thumbnail_generation_observer_->StartThumbnailing(tab_contents_.get());
   }
 
   // Set-up the showing of the omnibox search infobar if applicable.
   if (OmniboxSearchHint::IsEnabled(contents->profile()))
     omnibox_search_hint_.reset(new OmniboxSearchHint(this));
 
-  registrar_.Add(this, NotificationType::GOOGLE_URL_UPDATED,
+  registrar_.Add(this, chrome::NOTIFICATION_GOOGLE_URL_UPDATED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::USER_STYLE_SHEET_UPDATED,
+  registrar_.Add(this, chrome::NOTIFICATION_USER_STYLE_SHEET_UPDATED,
                  NotificationService::AllSources());
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
-  registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
                  NotificationService::AllSources());
 #endif
 
   // Register for notifications about all interested prefs change.
   PrefService* prefs = profile()->GetPrefs();
   pref_change_registrar_.Init(prefs);
   if (prefs) {
     for (int i = 0; i < kPrefsToObserveLength; ++i)
       pref_change_registrar_.Add(kPrefsToObserve[i], this);
   }
@@ skipping 230 matching lines @@
   return handled;
 }
 
 void TabContentsWrapper::TabContentsDestroyed(TabContents* tab) {
   // Destruction of the TabContents should only be done by us from our
   // destructor. Otherwise it's very likely we (or one of the helpers we own)
   // will attempt to access the TabContents and we'll crash.
   DCHECK(in_destructor_);
 }
 
-void TabContentsWrapper::Observe(NotificationType type,
+void TabContentsWrapper::Observe(int type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::NAV_ENTRY_COMMITTED: {
+  switch (type) {
+    case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
       DCHECK(&tab_contents_->controller() ==
              Source<NavigationController>(source).ptr());
 
       content::LoadCommittedDetails& committed_details =
           *(Details<content::LoadCommittedDetails>(details).ptr());
 
       // NOTE: It is not safe to change the following code to count upwards or
       // use iterators, as the RemoveInfoBar() call synchronously modifies our
       // delegate list.
       for (size_t i = infobars_.size(); i > 0; --i) {
         InfoBarDelegate* delegate = GetInfoBarDelegateAt(i - 1);
         if (delegate->ShouldExpire(committed_details))
           RemoveInfoBar(delegate);
       }
 
       break;
     }
-    case NotificationType::GOOGLE_URL_UPDATED:
+    case chrome::NOTIFICATION_GOOGLE_URL_UPDATED:
       UpdateAlternateErrorPageURL(render_view_host());
       break;
-    case NotificationType::USER_STYLE_SHEET_UPDATED:
+    case chrome::NOTIFICATION_USER_STYLE_SHEET_UPDATED:
       UpdateWebPreferences();
       break;
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
-    case NotificationType::BROWSER_THEME_CHANGED: {
+    case chrome::NOTIFICATION_BROWSER_THEME_CHANGED: {
       UpdateRendererPreferences();
       break;
     }
 #endif
-    case NotificationType::PREF_CHANGED: {
+    case chrome::NOTIFICATION_PREF_CHANGED: {
       std::string* pref_name_in = Details<std::string>(details).ptr();
       DCHECK(Source<PrefService>(source).ptr() == profile()->GetPrefs());
       if (*pref_name_in == prefs::kAlternateErrorPagesEnabled) {
         UpdateAlternateErrorPageURL(render_view_host());
       } else if ((*pref_name_in == prefs::kDefaultCharset) ||
                  StartsWithASCII(*pref_name_in, "webkit.webprefs.", true)) {
         UpdateWebPreferences();
       } else if (*pref_name_in == prefs::kDefaultZoomLevel) {
         Send(new ViewMsg_SetZoomLevel(
             routing_id(), tab_contents()->GetZoomLevel()));
@@ skipping 17 matching lines @@
 
   for (size_t i = 0; i < infobars_.size(); ++i) {
     if (GetInfoBarDelegateAt(i)->EqualsDelegate(delegate)) {
       delegate->InfoBarClosed();
       return;
     }
   }
 
   infobars_.push_back(delegate);
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_INFOBAR_ADDED,
+      chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
       Source<TabContentsWrapper>(this), Details<InfoBarAddedDetails>(delegate));
 
   // Add ourselves as an observer for navigations the first time a delegate is
   // added. We use this notification to expire InfoBars that need to expire on
   // page transitions.
   if (infobars_.size() == 1) {
-    registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+    registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                    Source<NavigationController>(&tab_contents_->controller()));
   }
 }
 
 void TabContentsWrapper::RemoveInfoBar(InfoBarDelegate* delegate) {
   RemoveInfoBarInternal(delegate, true);
 }
 
 void TabContentsWrapper::ReplaceInfoBar(InfoBarDelegate* old_delegate,
                                         InfoBarDelegate* new_delegate) {
   if (!infobars_enabled_) {
     AddInfoBar(new_delegate);  // Deletes the delegate.
     return;
   }
 
   size_t i;
   for (i = 0; i < infobars_.size(); ++i) {
     if (GetInfoBarDelegateAt(i) == old_delegate)
       break;
   }
   DCHECK_LT(i, infobars_.size());
 
   infobars_.insert(infobars_.begin() + i, new_delegate);
 
   InfoBarReplacedDetails replaced_details(old_delegate, new_delegate);
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_INFOBAR_REPLACED,
+      chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REPLACED,
       Source<TabContentsWrapper>(this),
       Details<InfoBarReplacedDetails>(&replaced_details));
 
   infobars_.erase(infobars_.begin() + i + 1);
 }
 
 InfoBarDelegate* TabContentsWrapper::GetInfoBarDelegateAt(size_t index) {
   return infobars_[index];
 }
 
@@ skipping 26 matching lines @@
   if (!handler.IsEmpty() &&
       registry->CanSchemeBeOverridden(handler.protocol())) {
     AddInfoBar(new RegisterProtocolHandlerInfoBarDelegate(tab_contents(),
                                                           registry,
                                                           handler));
   }
 }
 
 void TabContentsWrapper::OnSnapshot(const SkBitmap& bitmap) {
   NotificationService::current()->Notify(
-      NotificationType::TAB_SNAPSHOT_TAKEN,
+      chrome::NOTIFICATION_TAB_SNAPSHOT_TAKEN,
       Source<TabContentsWrapper>(this),
       Details<const SkBitmap>(&bitmap));
 }
 
 void TabContentsWrapper::OnPDFHasUnsupportedFeature() {
   PDFHasUnsupportedFeature(this);
 }
 
 void TabContentsWrapper::OnDidBlockDisplayingInsecureContent() {
   // At most one infobar and do not supersede the stronger running content bar.
@@ skipping 63 matching lines @@
   size_t i;
   for (i = 0; i < infobars_.size(); ++i) {
     if (GetInfoBarDelegateAt(i) == delegate)
       break;
   }
   DCHECK_LT(i, infobars_.size());
   InfoBarDelegate* infobar = infobars_[i];
 
   InfoBarRemovedDetails removed_details(infobar, animate);
   NotificationService::current()->Notify(
-      NotificationType::TAB_CONTENTS_INFOBAR_REMOVED,
+      chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
       Source<TabContentsWrapper>(this),
       Details<InfoBarRemovedDetails>(&removed_details));
 
   infobars_.erase(infobars_.begin() + i);
   // Remove ourselves as an observer if we are tracking no more InfoBars.
   if (infobars_.empty()) {
-    registrar_.Remove(this, NotificationType::NAV_ENTRY_COMMITTED,
+    registrar_.Remove(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         Source<NavigationController>(&tab_contents_->controller()));
   }
 }
 
 void TabContentsWrapper::RemoveAllInfoBars(bool animate) {
   while (!infobars_.empty())
     RemoveInfoBarInternal(GetInfoBarDelegateAt(infobar_count() - 1), animate);
 }