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

chrome/browser/sessions/session_service.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/sessions/session_service.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/sessions/session_backend.h"
 #include "chrome/browser/sessions/session_command.h"
 #include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_init.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/browser/tab_contents/navigation_details.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/app_controller_cppsafe_mac.h"
 #endif
@@ skipping 397 matching lines @@
         new InternalSessionRequest(
             NewCallback(this, &SessionService::OnGotSessionCommands),
             callback), consumer);
   }
 }
 
 void SessionService::Save() {
   bool had_commands = !pending_commands().empty();
   BaseSessionService::Save();
   if (had_commands) {
-    RecordSessionUpdateHistogramData(NotificationType::SESSION_SERVICE_SAVED,
+    RecordSessionUpdateHistogramData(
+        chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
         &last_updated_save_time_);
     NotificationService::current()->Notify(
-        NotificationType::SESSION_SERVICE_SAVED,
+        chrome::NOTIFICATION_SESSION_SERVICE_SAVED,
         Source<Profile>(profile()),
         NotificationService::NoDetails());
   }
 }
 
 void SessionService::Init() {
   // Register for the notifications we're interested in.
-  registrar_.Add(this, NotificationType::TAB_PARENTED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_PARENTED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::TAB_CLOSED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CLOSED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::NAV_LIST_PRUNED,
+  registrar_.Add(this, content::NOTIFICATION_NAV_LIST_PRUNED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::NAV_ENTRY_CHANGED,
+  registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_CHANGED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
+  registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BROWSER_OPENED,
+  registrar_.Add(this, chrome::NOTIFICATION_BROWSER_OPENED,
                  NotificationService::AllSources());
-  registrar_.Add(this,
-                 NotificationType::TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
-                 NotificationService::AllSources());
+  registrar_.Add(
+      this, chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
+      NotificationService::AllSources());
 }
 
 bool SessionService::RestoreIfNecessary(const std::vector<GURL>& urls_to_open,
                                         Browser* browser) {
   if (!has_open_trackable_browsers_ && !BrowserInit::InProcessStartup() &&
       !SessionRestore::IsRestoring()
 #if defined(OS_MACOSX)
       // OSX has a fairly different idea of application lifetime than the
       // other platforms. We need to check that we aren't opening a window
       // from the dock or the menubar.
@@ skipping 12 matching lines @@
       SessionRestore::RestoreSession(
           profile(), browser,
           browser ? 0 : SessionRestore::ALWAYS_CREATE_TABBED_BROWSER,
           urls_to_open);
       return true;
     }
   }
   return false;
 }
 
-void SessionService::Observe(NotificationType type,
+void SessionService::Observe(int type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   // All of our messages have the NavigationController as the source.
-  switch (type.value) {
-    case NotificationType::BROWSER_OPENED: {
+  switch (type) {
+    case chrome::NOTIFICATION_BROWSER_OPENED: {
       Browser* browser = Source<Browser>(source).ptr();
       if (browser->profile() != profile() ||
           !should_track_changes_for_browser_type(browser->type())) {
         return;
       }
 
       RestoreIfNecessary(std::vector<GURL>(), browser);
       SetWindowType(browser->session_id(), browser->type());
       break;
     }
 
-    case NotificationType::TAB_PARENTED: {
+    case content::NOTIFICATION_TAB_PARENTED: {
       TabContentsWrapper* tab = Source<TabContentsWrapper>(source).ptr();
       SetTabWindow(tab->restore_tab_helper()->window_id(),
                    tab->restore_tab_helper()->session_id());
       if (tab->extension_tab_helper()->extension_app()) {
         SetTabExtensionAppID(
             tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             tab->extension_tab_helper()->extension_app()->id());
       }
       break;
     }
 
-    case NotificationType::TAB_CLOSED: {
+    case content::NOTIFICATION_TAB_CLOSED: {
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
               Source<NavigationController>(source).ptr()->tab_contents());
       if (!tab)
         break;
       TabClosed(tab->restore_tab_helper()->window_id(),
                 tab->restore_tab_helper()->session_id(),
                 tab->tab_contents()->closed_by_user_gesture());
-      RecordSessionUpdateHistogramData(NotificationType::TAB_CLOSED,
+      RecordSessionUpdateHistogramData(content::NOTIFICATION_TAB_CLOSED,
           &last_updated_tab_closed_time_);
       break;
     }
 
-    case NotificationType::NAV_LIST_PRUNED: {
+    case content::NOTIFICATION_NAV_LIST_PRUNED: {
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
               Source<NavigationController>(source).ptr()->tab_contents());
       if (!tab)
         break;
       Details<content::PrunedDetails> pruned_details(details);
       if (pruned_details->from_front) {
         TabNavigationPathPrunedFromFront(
             tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             pruned_details->count);
       } else {
         TabNavigationPathPrunedFromBack(
             tab->restore_tab_helper()->window_id(),
             tab->restore_tab_helper()->session_id(),
             tab->controller().entry_count());
       }
-      RecordSessionUpdateHistogramData(NotificationType::NAV_LIST_PRUNED,
+      RecordSessionUpdateHistogramData(content::NOTIFICATION_NAV_LIST_PRUNED,
           &last_updated_nav_list_pruned_time_);
       break;
     }
 
-    case NotificationType::NAV_ENTRY_CHANGED: {
+    case content::NOTIFICATION_NAV_ENTRY_CHANGED: {
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
               Source<NavigationController>(source).ptr()->tab_contents());
       if (!tab)
         break;
       Details<content::EntryChangedDetails> changed(details);
       UpdateTabNavigation(
           tab->restore_tab_helper()->window_id(),
           tab->restore_tab_helper()->session_id(),
           changed->index, *changed->changed_entry);
       break;
     }
 
-    case NotificationType::NAV_ENTRY_COMMITTED: {
+    case content::NOTIFICATION_NAV_ENTRY_COMMITTED: {
       TabContentsWrapper* tab =
           TabContentsWrapper::GetCurrentWrapperForContents(
               Source<NavigationController>(source).ptr()->tab_contents());
       if (!tab)
         break;
       int current_entry_index = tab->controller().GetCurrentEntryIndex();
       SetSelectedNavigationIndex(tab->restore_tab_helper()->window_id(),
                                  tab->restore_tab_helper()->session_id(),
                                  current_entry_index);
       UpdateTabNavigation(
           tab->restore_tab_helper()->window_id(),
           tab->restore_tab_helper()->session_id(),
           current_entry_index,
           *tab->controller().GetEntryAtIndex(current_entry_index));
       Details<content::LoadCommittedDetails> changed(details);
       if (changed->type == NavigationType::NEW_PAGE ||
         changed->type == NavigationType::EXISTING_PAGE) {
-        RecordSessionUpdateHistogramData(NotificationType::NAV_ENTRY_COMMITTED,
+        RecordSessionUpdateHistogramData(
+            content::NOTIFICATION_NAV_ENTRY_COMMITTED,
             &last_updated_nav_entry_commit_time_);
       }
       break;
     }
 
-    case NotificationType::TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED: {
+    case chrome::NOTIFICATION_TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED: {
       ExtensionTabHelper* extension_tab_helper =
           Source<ExtensionTabHelper>(source).ptr();
       if (extension_tab_helper->extension_app()) {
         RestoreTabHelper* helper =
             extension_tab_helper->tab_contents_wrapper()->restore_tab_helper();
         SetTabExtensionAppID(helper->window_id(),
                              helper->session_id(),
                              extension_tab_helper->extension_app()->id());
       }
       break;
@@ skipping 722 matching lines @@
 Browser::Type SessionService::BrowserTypeForWindowType(WindowType type) {
   switch (type) {
     case TYPE_POPUP:
       return Browser::TYPE_POPUP;
     case TYPE_TABBED:
     default:
       return Browser::TYPE_TABBED;
   }
 }
 
-void SessionService::RecordSessionUpdateHistogramData(NotificationType type,
+void SessionService::RecordSessionUpdateHistogramData(int type,
     base::TimeTicks* last_updated_time) {
   if (!last_updated_time->is_null()) {
     base::TimeDelta delta = base::TimeTicks::Now() - *last_updated_time;
     // We're interested in frequent updates periods longer than
     // 10 minutes.
     bool use_long_period = false;
     if (delta >= save_delay_in_mins_) {
       use_long_period = true;
     }
-    switch (type.value) {
-      case NotificationType::SESSION_SERVICE_SAVED :
+    switch (type) {
+      case chrome::NOTIFICATION_SESSION_SERVICE_SAVED :
         RecordUpdatedSaveTime(delta, use_long_period);
         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
         break;
-      case NotificationType::TAB_CLOSED:
+      case content::NOTIFICATION_TAB_CLOSED:
         RecordUpdatedTabClosed(delta, use_long_period);
         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
         break;
-      case NotificationType::NAV_LIST_PRUNED:
+      case content::NOTIFICATION_NAV_LIST_PRUNED:
         RecordUpdatedNavListPruned(delta, use_long_period);
         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
         break;
-      case NotificationType::NAV_ENTRY_COMMITTED:
+      case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
         RecordUpdatedNavEntryCommit(delta, use_long_period);
         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
         break;
       default:
         NOTREACHED() << "Bad type sent to RecordSessionUpdateHistogramData";
         break;
     }
   }
   (*last_updated_time) = base::TimeTicks::Now();
 }
@@ skipping 85 matching lines @@
       50);
   if (use_long_period) {
     std::string long_name_("SessionRestore.SaveLongPeriod");
     UMA_HISTOGRAM_CUSTOM_TIMES(long_name_,
         delta,
         save_delay_in_mins_,
         save_delay_in_hrs_,
         50);
   }
 }