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 131 matching lines @@
       maximized_state_(MAXIMIZED_STATE_DEFAULT),
       method_factory_(this),
       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,
+  registrar_.Add(this, content::NOTIFICATION_SSL_VISIBLE_STATE_CHANGED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UPDATE_DISABLED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_LOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_UNINSTALLED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED,
                  NotificationService::AllSources());
   registrar_.Add(
-      this, NotificationType::BROWSER_THEME_CHANGED,
+      this, chrome::NOTIFICATION_BROWSER_THEME_CHANGED,
       Source<ThemeService>(ThemeServiceFactory::GetForProfile(profile_)));
-  registrar_.Add(this, NotificationType::TAB_CONTENT_SETTINGS_CHANGED,
+  registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENT_SETTINGS_CHANGED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_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::NOTIFICATION_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::NOTIFICATION_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::NOTIFICATION_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 1830 matching lines @@
   contents->restore_tab_helper()->SetWindowID(session_id());
 
   SyncHistoryWithTabs(index);
 
   // Make sure the loading state is updated correctly, otherwise the throbber
   // won't start if the page is loading.
   LoadingStateChanged(contents->tab_contents());
 
   // If the tab crashes in the beforeunload or unload handler, it won't be
   // able to ack. But we know we can close it.
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
                  Source<TabContents>(contents->tab_contents()));
 
-  registrar_.Add(this, NotificationType::INTERSTITIAL_ATTACHED,
+  registrar_.Add(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
                  Source<TabContents>(contents->tab_contents()));
 }
 
 void Browser::TabClosingAt(TabStripModel* tab_strip_model,
                            TabContentsWrapper* contents,
                            int index) {
   NotificationService::current()->Notify(
-      NotificationType::TAB_CLOSING,
+      content::NOTIFICATION_TAB_CLOSING,
       Source<NavigationController>(&contents->controller()),
       NotificationService::NoDetails());
 
   // Sever the TabContents' connection back to us.
   SetAsDelegate(contents, NULL);
 }
 
 void Browser::TabDetachedAt(TabContentsWrapper* contents, int index) {
   TabDetachedAtImpl(contents, index, DETACH_TYPE_DETACH);
 }
@@ skipping 208 matching lines @@
                    tabstrip_model()->GetWrapperIndex(source))
              : NULL;
   params.disposition = disposition;
   params.window_bounds = initial_pos;
   params.window_action = browser::NavigateParams::SHOW_WINDOW;
   params.user_gesture = user_gesture;
   browser::Navigate(&params);
 
   if (source) {
     NotificationService::current()->Notify(
-      NotificationType::TAB_ADDED,
+      content::NOTIFICATION_TAB_ADDED,
       Source<TabContentsDelegate>(source->delegate()),
       Details<TabContents>(source));
   }
 }
 
 void Browser::ActivateContents(TabContents* contents) {
   tab_handler_->GetTabStripModel()->ActivateTabAt(
       tab_handler_->GetTabStripModel()->GetWrapperIndex(contents), false);
   window_->Activate();
 }
@@ skipping 119 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::NOTIFICATION_FOCUS_RETURNED_TO_BROWSER,
       Source<Browser>(this),
       NotificationService::NoDetails());
   return false;
 }
 
 bool Browser::IsApplication() const {
   return is_app();
 }
 
 void Browser::ConvertContentsToApplication(TabContents* contents) {
@@ skipping 281 matching lines @@
 void Browser::FileSelected(const FilePath& path, int index, void* params) {
   profile_->set_last_selected_directory(path.DirName());
   GURL file_url = net::FilePathToFileURL(path);
   if (!file_url.is_empty())
     OpenURL(file_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, NotificationObserver implementation:
 
-void Browser::Observe(NotificationType type,
+void Browser::Observe(int type,
                       const NotificationSource& source,
                       const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::TAB_CONTENTS_DISCONNECTED:
+  switch (type) {
+    case content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED:
       if (is_attempting_to_close_browser_) {
         // Pass in false so that we delay processing. We need to delay the
         // processing as it may close the tab, which is currently on the call
         // stack above us.
         ClearUnloadState(Source<TabContents>(source).ptr(), false);
       }
       break;
 
-    case NotificationType::SSL_VISIBLE_STATE_CHANGED:
+    case content::NOTIFICATION_SSL_VISIBLE_STATE_CHANGED:
       // When the current tab's SSL state changes, we need to update the URL
       // bar to reflect the new state. Note that it's possible for the selected
       // 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::NOTIFICATION_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::NOTIFICATION_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::NOTIFICATION_EXTENSION_PROCESS_TERMINATED: {
       if (window()->GetLocationBar())
         window()->GetLocationBar()->InvalidatePageActions();
       break;
     }
 
-    case NotificationType::EXTENSION_UNINSTALLED:
-    case NotificationType::EXTENSION_LOADED:
+    case chrome::NOTIFICATION_EXTENSION_UNINSTALLED:
+    case chrome::NOTIFICATION_EXTENSION_LOADED:
       if (window()->GetLocationBar())
         window()->GetLocationBar()->UpdatePageActions();
       break;
 
-    case NotificationType::BROWSER_THEME_CHANGED:
+    case chrome::NOTIFICATION_BROWSER_THEME_CHANGED:
       window()->UserChangedTheme();
       break;
 
-    case NotificationType::EXTENSION_READY_FOR_INSTALL: {
+    case chrome::NOTIFICATION_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::NOTIFICATION_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::NOTIFICATION_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:
+    case content::NOTIFICATION_INTERSTITIAL_ATTACHED:
       UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
       break;
 
-    case NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED:
+    case chrome::NOTIFICATION_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 850 matching lines @@
   }
 
   if (is_attempting_to_close_browser_) {
     // If this is the last tab with unload handlers, then ProcessPendingTabs
     // would call back into the TabStripModel (which is invoking this method on
     // us). Avoid that by passing in false so that the call to
     // ProcessPendingTabs is delayed.
     ClearUnloadState(contents->tab_contents(), false);
   }
 
-  registrar_.Remove(this, NotificationType::INTERSTITIAL_ATTACHED,
+  registrar_.Remove(this, content::NOTIFICATION_INTERSTITIAL_ATTACHED,
                     Source<TabContents>(contents->tab_contents()));
-  registrar_.Remove(this, NotificationType::TAB_CONTENTS_DISCONNECTED,
+  registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED,
                     Source<TabContents>(contents->tab_contents()));
 }
 
 // static
 void Browser::RegisterAppPrefs(const std::string& app_name, Profile* profile) {
   // We need to register the window position pref.
   std::string window_pref(prefs::kBrowserWindowPlacement);
   window_pref.append("_");
   window_pref.append(app_name);
   PrefService* prefs = profile->GetPrefs();
@@ skipping 183 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);
 }