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::SESSION_SERVICE_SAVED,
         &last_updated_save_time_);
     NotificationService::current()->Notify(
-        NotificationType::SESSION_SERVICE_SAVED,
+        chrome::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,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::TAB_CLOSED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::NAV_LIST_PRUNED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::NAV_ENTRY_CHANGED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                  NotificationService::AllSources());
-  registrar_.Add(this, NotificationType::BROWSER_OPENED,
+  registrar_.Add(this, chrome::BROWSER_OPENED,
                  NotificationService::AllSources());
   registrar_.Add(this,
-                 NotificationType::TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED,
+                 chrome::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
@@ skipping 18 matching lines @@
     }
   }
   return false;
 }
 
 void SessionService::Observe(NotificationType type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
   // All of our messages have the NavigationController as the source.
   switch (type.value) {
-    case NotificationType::BROWSER_OPENED: {
+    case chrome::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;
     }
@@ skipping 79 matching lines @@
           *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,
             &last_updated_nav_entry_commit_time_);
       }
       break;
     }
 
-    case NotificationType::TAB_CONTENTS_APPLICATION_EXTENSION_CHANGED: {
+    case chrome::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 733 matching lines @@
     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 :
+      case chrome::SESSION_SERVICE_SAVED :
         RecordUpdatedSaveTime(delta, use_long_period);
         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
         break;
       case NotificationType::TAB_CLOSED:
         RecordUpdatedTabClosed(delta, use_long_period);
         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
         break;
       case NotificationType::NAV_LIST_PRUNED:
         RecordUpdatedNavListPruned(delta, use_long_period);
         RecordUpdatedSessionNavigationOrTab(delta, use_long_period);
@@ skipping 97 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);
   }
 }