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

chrome/browser/ui/browser.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/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 81 matching lines @@
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/tabs/dock_info.h"
 #include "chrome/browser/ui/tabs/tab_menu_model.h"
 #include "chrome/browser/ui/web_applications/web_app_ui.h"
 #include "chrome/browser/ui/webui/bug_report_ui.h"
 #include "chrome/browser/ui/webui/options/content_settings_handler.h"
 #include "chrome/browser/ui/window_sizer.h"
 #include "chrome/browser/upgrade_detector.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/profiling.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/web_apps.h"
 #include "content/browser/debugger/devtools_manager.h"
 #include "content/browser/debugger/devtools_toggle_action.h"
 #include "content/browser/debugger/devtools_window.h"
@@ skipping 133 matching lines @@
       block_command_execution_(false),
       last_blocked_command_id_(-1),
       last_blocked_command_disposition_(CURRENT_TAB),
       pending_web_app_action_(NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_restore_service_delegate_(
               new BrowserTabRestoreServiceDelegate(this))),
       bookmark_bar_state_(BookmarkBar::HIDDEN) {
   registrar_.Add(this, NotificationType::SSL_VISIBLE_STATE_CHANGED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
+  registrar_.Add(this, chrome::EXTENSION_UNLOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UNINSTALLED,
+  registrar_.Add(this, chrome::EXTENSION_UNINSTALLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
+  registrar_.Add(this, chrome::EXTENSION_PROCESS_TERMINATED,
                  NotificationService::AllSources());
   registrar_.Add(
-      this, NotificationType::BROWSER_THEME_CHANGED,
+      this, chrome::BROWSER_THEME_CHANGED,
       Source<ThemeService>(ThemeServiceFactory::GetForProfile(profile_)));
-  registrar_.Add(this, NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+  registrar_.Add(this, chrome::TAB_CONTENT_SETTINGS_CHANGED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
+  registrar_.Add(this, chrome::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                  NotificationService::AllSources());
 
   // Need to know when to alert the user of theme install delay.
-  registrar_.Add(this, NotificationType::EXTENSION_READY_FOR_INSTALL,
+  registrar_.Add(this, chrome::EXTENSION_READY_FOR_INSTALL,
                  NotificationService::AllSources());
 
   PrefService* local_state = g_browser_process->local_state();
   if (local_state) {
     local_pref_registrar_.Init(local_state);
     local_pref_registrar_.Add(prefs::kPrintingEnabled, this);
     local_pref_registrar_.Add(prefs::kAllowFileSelectionDialogs, this);
   }
 
   profile_pref_registrar_.Init(profile_->GetPrefs());
@@ skipping 175 matching lines @@
     // name.  See http://crbug.com/7028.
     ui::win::SetAppIdForWindow(
         is_app() ?
         ShellIntegration::GetAppId(UTF8ToWide(app_name_), profile_->GetPath()) :
         ShellIntegration::GetChromiumAppId(profile_->GetPath()),
         window()->GetNativeHandle());
   }
 #endif
 
   NotificationService::current()->Notify(
-      NotificationType::BROWSER_WINDOW_READY,
+      chrome::BROWSER_WINDOW_READY,
       Source<Browser>(this),
       NotificationService::NoDetails());
 
   if (use_compact_navigation_bar_.GetValue()) {
     // This enables the compact navigation bar host.
     UseCompactNavigationBarChanged();
   }
 
   // Show the First Run information bubble if we've been told to.
   PrefService* local_state = g_browser_process->local_state();
@@ skipping 513 matching lines @@
   if (session_service)
     session_service->WindowClosing(session_id());
 
   TabRestoreService* tab_restore_service =
       TabRestoreServiceFactory::GetForProfile(profile());
   if (tab_restore_service && is_type_tabbed() && tab_count())
     tab_restore_service->BrowserClosing(tab_restore_service_delegate());
 
   // TODO(sky): convert session/tab restore to use notification.
   NotificationService::current()->Notify(
-      NotificationType::BROWSER_CLOSING,
+      chrome::BROWSER_CLOSING,
       Source<Browser>(this),
       Details<bool>(&exiting));
 
   CloseAllTabs();
 }
 
 void Browser::OnWindowActivated() {
   // On some platforms we want to automatically reload tabs that are
   // killed when the user selects them.
   TabContents* contents = GetSelectedTabContents();
@@ skipping 2210 matching lines @@
   }
   tabstrip_model()->SetTabBlocked(index, blocked);
 }
 
 void Browser::TabContentsFocused(TabContents* tab_content) {
   window_->TabContentsFocused(tab_content);
 }
 
 bool Browser::TakeFocus(bool reverse) {
   NotificationService::current()->Notify(
-      NotificationType::FOCUS_RETURNED_TO_BROWSER,
+      chrome::FOCUS_RETURNED_TO_BROWSER,
       Source<Browser>(this),
       NotificationService::NoDetails());
   return false;
 }
 
 bool Browser::IsApplication() const {
   return is_app();
 }
 
 void Browser::ConvertContentsToApplication(TabContents* contents) {
@@ skipping 307 matching lines @@
       // tab contents to be NULL. This is because we listen for all sources
       // (NavigationControllers) for convenience, so the notification could
       // actually be for a different window while we're doing asynchronous
       // closing of this one.
       if (GetSelectedTabContents() &&
           &GetSelectedTabContents()->controller() ==
           Source<NavigationController>(source).ptr())
         UpdateToolbar(false);
       break;
 
-    case NotificationType::EXTENSION_UPDATE_DISABLED: {
+    case chrome::EXTENSION_UPDATE_DISABLED: {
       // Show the UI if the extension was disabled for escalated permissions.
       Profile* profile = Source<Profile>(source).ptr();
       if (profile_->IsSameProfile(profile)) {
         ExtensionService* service = profile->GetExtensionService();
         DCHECK(service);
         const Extension* extension = Details<const Extension>(details).ptr();
         if (service->extension_prefs()->DidExtensionEscalatePermissions(
                 extension->id()))
           ShowExtensionDisabledUI(service, profile_, extension);
       }
       break;
     }
 
-    case NotificationType::EXTENSION_UNLOADED: {
+    case chrome::EXTENSION_UNLOADED: {
       if (window()->GetLocationBar())
         window()->GetLocationBar()->UpdatePageActions();
 
       // Close any tabs from the unloaded extension.
       const Extension* extension =
           Details<UnloadedExtensionInfo>(details)->extension;
       TabStripModel* model = tab_handler_->GetTabStripModel();
       for (int i = model->count() - 1; i >= 0; --i) {
         TabContents* tc = model->GetTabContentsAt(i)->tab_contents();
         if (tc->GetURL().SchemeIs(chrome::kExtensionScheme) &&
             tc->GetURL().host() == extension->id()) {
           CloseTabContents(tc);
         }
       }
 
       break;
     }
 
-    case NotificationType::EXTENSION_PROCESS_TERMINATED: {
+    case chrome::EXTENSION_PROCESS_TERMINATED: {
       if (window()->GetLocationBar())
         window()->GetLocationBar()->InvalidatePageActions();
       break;
     }
 
-    case NotificationType::EXTENSION_UNINSTALLED:
-    case NotificationType::EXTENSION_LOADED:
+    case chrome::EXTENSION_UNINSTALLED:
+    case chrome::EXTENSION_LOADED:
       if (window()->GetLocationBar())
         window()->GetLocationBar()->UpdatePageActions();
       break;
 
-    case NotificationType::BROWSER_THEME_CHANGED:
+    case chrome::BROWSER_THEME_CHANGED:
       window()->UserChangedTheme();
       break;
 
-    case NotificationType::EXTENSION_READY_FOR_INSTALL: {
+    case chrome::EXTENSION_READY_FOR_INSTALL: {
       // Handle EXTENSION_READY_FOR_INSTALL for last active tabbed browser.
       if (BrowserList::FindTabbedBrowser(profile(), true) != this)
         break;
 
       // We only want to show the loading dialog for themes, but we don't want
       // to wait until unpack to find out an extension is a theme, so we test
       // the download_url GURL instead. This means that themes in the extensions
       // gallery won't get the loading dialog.
       GURL download_url = *(Details<GURL>(details).ptr());
       if (ExtensionService::IsDownloadFromMiniGallery(download_url))
         window()->ShowThemeInstallBubble();
       break;
     }
 
-    case NotificationType::PREF_CHANGED: {
+    case chrome::PREF_CHANGED: {
       const std::string& pref_name = *Details<std::string>(details).ptr();
       if (pref_name == prefs::kUseVerticalTabs) {
         UseVerticalTabsChanged();
       } else if (pref_name == prefs::kUseCompactNavigationBar) {
         UseCompactNavigationBarChanged();
       } else if (pref_name == prefs::kPrintingEnabled) {
         UpdatePrintingState(GetContentRestrictionsForSelectedTab());
       } else if (pref_name == prefs::kInstantEnabled) {
         if (!InstantController::IsEnabled(profile())) {
           if (instant()) {
@@ skipping 16 matching lines @@
         UpdateCommandsForBookmarkEditing();
       } else if (pref_name == prefs::kAllowFileSelectionDialogs) {
         UpdateSaveAsState(GetContentRestrictionsForSelectedTab());
         UpdateOpenFileState();
       } else {
         NOTREACHED();
       }
       break;
     }
 
-    case NotificationType::TAB_CONTENT_SETTINGS_CHANGED: {
+    case chrome::TAB_CONTENT_SETTINGS_CHANGED: {
       TabContents* tab_contents = Source<TabContents>(source).ptr();
       if (tab_contents == GetSelectedTabContents()) {
         LocationBar* location_bar = window()->GetLocationBar();
         if (location_bar)
           location_bar->UpdateContentSettingsIcons();
       }
       break;
     }
 
     case NotificationType::INTERSTITIAL_ATTACHED:
       UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
       break;
 
-    case NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED:
+    case chrome::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED:
       UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_PREF_CHANGE);
       break;
 
     default:
       NOTREACHED() << "Got a notification we didn't register for.";
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, ProfileSyncServiceObserver implementation:
@@ skipping 1056 matching lines @@
     // end up querying state once they process the tab switch.
     return;
   }
 
   BookmarkBar::AnimateChangeType animate_type =
       (reason == BOOKMARK_BAR_STATE_CHANGE_PREF_CHANGE) ?
       BookmarkBar::ANIMATE_STATE_CHANGE :
       BookmarkBar::DONT_ANIMATE_STATE_CHANGE;
   window_->BookmarkBarStateChanged(animate_type);
 }