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

chrome/browser/sessions/session_restore.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_restore.h"
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/stringprintf.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "content/browser/renderer_host/render_widget_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/common/notification_registrar.h"
 #include "content/common/notification_service.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/boot_times_loader.h"
@@ skipping 39 matching lines @@
   typedef std::set<NavigationController*> TabsLoading;
   typedef std::list<NavigationController*> TabsToLoad;
   typedef std::set<RenderWidgetHost*> RenderWidgetHostSet;
 
   // Loads the next tab. If there are no more tabs to load this deletes itself,
   // otherwise |force_load_timer_| is restarted.
   void LoadNextTab();
 
   // NotificationObserver method. Removes the specified tab and loads the next
   // tab.
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Removes the listeners from the specified tab and removes the tab from
   // the set of tabs to load and list of tabs we're waiting to get a load
   // from.
   void RemoveTab(NavigationController* tab);
 
   // Invoked from |force_load_timer_|. Doubles |force_load_delay_| and invokes
   // |LoadNextTab| to load the next tab
@@ skipping 71 matching lines @@
   DCHECK(find(tabs_loading_.begin(), tabs_loading_.end(), controller) ==
          tabs_loading_.end());
   tabs_loading_.insert(controller);
   RenderWidgetHost* render_widget_host = GetRenderWidgetHost(controller);
   DCHECK(render_widget_host);
   render_widget_hosts_loading_.insert(render_widget_host);
   RegisterForNotifications(controller);
 }
 
 void TabLoader::StartLoading() {
-  registrar_.Add(this, NotificationType::RENDER_WIDGET_HOST_DID_PAINT,
+  registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
                  NotificationService::AllSources());
 #if defined(OS_CHROMEOS)
   if (chromeos::NetworkStateNotifier::is_connected()) {
     loading_ = true;
     LoadNextTab();
   } else {
     // Start listening to network state notification now.
-    registrar_.Add(this, NotificationType::NETWORK_STATE_CHANGED,
+    registrar_.Add(this, chrome::NETWORK_STATE_CHANGED,
                    NotificationService::AllSources());
   }
 #else
   loading_ = true;
   LoadNextTab();
 #endif
 }
 
 void TabLoader::LoadNextTab() {
   if (!tabs_to_load_.empty()) {
@@ skipping 21 matching lines @@
   if (!tabs_to_load_.empty()) {
     force_load_timer_.Stop();
     // Each time we load a tab we also set a timer to force us to start loading
     // the next tab if this one doesn't load quickly enough.
     force_load_timer_.Start(
         base::TimeDelta::FromMilliseconds(force_load_delay_),
         this, &TabLoader::ForceLoadTimerFired);
   }
 }
 
-void TabLoader::Observe(NotificationType type,
+void TabLoader::Observe(int type,
                         const NotificationSource& source,
                         const NotificationDetails& details) {
-  switch (type.value) {
+  switch (type) {
 #if defined(OS_CHROMEOS)
-    case NotificationType::NETWORK_STATE_CHANGED: {
+    case chrome::NETWORK_STATE_CHANGED: {
       chromeos::NetworkStateDetails* state_details =
           Details<chromeos::NetworkStateDetails>(details).ptr();
       switch (state_details->state()) {
         case chromeos::NetworkStateDetails::CONNECTED:
           if (!loading_) {
             loading_ = true;
             LoadNextTab();
           }
           // Start loading
           break;
         case chromeos::NetworkStateDetails::CONNECTING:
         case chromeos::NetworkStateDetails::DISCONNECTED:
           // Disconnected while loading. Set loading_ false so
           // that it stops trying to load next tab.
           loading_ = false;
           break;
         default:
           NOTREACHED() << "Unknown nework state notification:"
                        << state_details->state();
       }
       break;
     }
 #endif
-    case NotificationType::LOAD_START: {
+    case content::NOTIFICATION_LOAD_START: {
       // Add this render_widget_host to the set of those we're waiting for
       // paints on. We want to only record stats for paints that occur after
       // a load has finished.
       NavigationController* tab = Source<NavigationController>(source).ptr();
       RenderWidgetHost* render_widget_host = GetRenderWidgetHost(tab);
       DCHECK(render_widget_host);
       render_widget_hosts_loading_.insert(render_widget_host);
       break;
     }
-    case NotificationType::TAB_CONTENTS_DESTROYED: {
+    case content::NOTIFICATION_TAB_CONTENTS_DESTROYED: {
       TabContents* tab_contents = Source<TabContents>(source).ptr();
       if (!got_first_paint_) {
         RenderWidgetHost* render_widget_host =
             GetRenderWidgetHost(&tab_contents->controller());
         render_widget_hosts_loading_.erase(render_widget_host);
       }
       HandleTabClosedOrLoaded(&tab_contents->controller());
       break;
     }
-    case NotificationType::LOAD_STOP: {
+    case content::NOTIFICATION_LOAD_STOP: {
       NavigationController* tab = Source<NavigationController>(source).ptr();
       render_widget_hosts_to_paint_.insert(GetRenderWidgetHost(tab));
       HandleTabClosedOrLoaded(tab);
       break;
     }
-    case NotificationType::RENDER_WIDGET_HOST_DID_PAINT: {
+    case content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT: {
       if (!got_first_paint_) {
         RenderWidgetHost* render_widget_host =
             Source<RenderWidgetHost>(source).ptr();
         if (render_widget_hosts_to_paint_.find(render_widget_host) !=
             render_widget_hosts_to_paint_.end()) {
           // Got a paint for one of our renderers, so record time.
           got_first_paint_ = true;
           base::TimeDelta time_to_paint =
               base::TimeTicks::Now() - restore_started_;
           UMA_HISTOGRAM_CUSTOM_TIMES(
@@ skipping 20 matching lines @@
           // If this is a host for a tab we're not loading some other tab
           // has rendered and there's no point tracking the time. This could
           // happen because the user opened a different tab or restored tabs
           // to an already existing browser and an existing tab painted.
           got_first_paint_ = true;
         }
       }
       break;
     }
     default:
-      NOTREACHED() << "Unknown notification received:" << type.value;
+      NOTREACHED() << "Unknown notification received:" << type;
   }
   // Delete ourselves when we're not waiting for any more notifications.
   if ((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
       tabs_loading_.empty() && tabs_to_load_.empty())
     delete this;
 }
 
 void TabLoader::RemoveTab(NavigationController* tab) {
-  registrar_.Remove(this, NotificationType::TAB_CONTENTS_DESTROYED,
+  registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                     Source<TabContents>(tab->tab_contents()));
-  registrar_.Remove(this, NotificationType::LOAD_STOP,
+  registrar_.Remove(this, content::NOTIFICATION_LOAD_STOP,
                     Source<NavigationController>(tab));
-  registrar_.Remove(this, NotificationType::LOAD_START,
+  registrar_.Remove(this, content::NOTIFICATION_LOAD_START,
                     Source<NavigationController>(tab));
 
   TabsLoading::iterator i = tabs_loading_.find(tab);
   if (i != tabs_loading_.end())
     tabs_loading_.erase(i);
 
   TabsToLoad::iterator j =
       find(tabs_to_load_.begin(), tabs_to_load_.end(), tab);
   if (j != tabs_to_load_.end())
     tabs_to_load_.erase(j);
 }
 
 void TabLoader::ForceLoadTimerFired() {
   force_load_delay_ *= 2;
   LoadNextTab();
 }
 
 RenderWidgetHost* TabLoader::GetRenderWidgetHost(NavigationController* tab) {
   TabContents* tab_contents = tab->tab_contents();
   if (tab_contents) {
     RenderWidgetHostView* render_widget_host_view =
         tab_contents->GetRenderWidgetHostView();
     if (render_widget_host_view)
       return render_widget_host_view->GetRenderWidgetHost();
   }
   return NULL;
 }
 
 void TabLoader::RegisterForNotifications(NavigationController* controller) {
-  registrar_.Add(this, NotificationType::TAB_CONTENTS_DESTROYED,
+  registrar_.Add(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                  Source<TabContents>(controller->tab_contents()));
-  registrar_.Add(this, NotificationType::LOAD_STOP,
+  registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
                  Source<NavigationController>(controller));
-  registrar_.Add(this, NotificationType::LOAD_START,
+  registrar_.Add(this, content::NOTIFICATION_LOAD_START,
                  Source<NavigationController>(controller));
   ++tab_count_;
 }
 
 void TabLoader::HandleTabClosedOrLoaded(NavigationController* tab) {
   RemoveTab(tab);
   if (loading_)
     LoadNextTab();
   if (tabs_loading_.empty() && tabs_to_load_.empty()) {
     base::TimeDelta time_to_load =
@@ skipping 56 matching lines @@
       bool old_state = MessageLoop::current()->NestableTasksAllowed();
       MessageLoop::current()->SetNestableTasksAllowed(true);
       MessageLoop::current()->Run();
       MessageLoop::current()->SetNestableTasksAllowed(old_state);
       Browser* browser = ProcessSessionWindows(&windows_);
       delete this;
       return browser;
     }
 
     if (browser_) {
-      registrar_.Add(this, NotificationType::BROWSER_CLOSED,
+      registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
                      Source<Browser>(browser_));
     }
 
     return browser_;
   }
 
   // Restore window(s) from a foreign session.
   void RestoreForeignSession(
       std::vector<SessionWindow*>::const_iterator begin,
       std::vector<SessionWindow*>::const_iterator end) {
@@ skipping 31 matching lines @@
                                        current_browser->tab_count());
     FinishedTabCreation(true, true);
   }
 
   ~SessionRestoreImpl() {
     STLDeleteElements(&windows_);
     restoring = false;
     g_browser_process->ReleaseModule();
   }
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
-    switch (type.value) {
-      case NotificationType::BROWSER_CLOSED:
+    switch (type) {
+      case chrome::NOTIFICATION_BROWSER_CLOSED:
         delete this;
         return;
 
       default:
         NOTREACHED();
         break;
     }
   }
 
  private:
@@ skipping 312 matching lines @@
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile,
       static_cast<Browser*>(NULL), true, false, true, gurls);
   restorer.RestoreForeignTab(tab);
 }
 
 // static
 bool SessionRestore::IsRestoring() {
   return restoring;
 }