Merge requested by sheriff kliegs to fix chromeos test redness.

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>
@@ skipping 16 matching lines @@
 #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"
+#include "net/base/network_change_notifier.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/boot_times_loader.h"
-#include "chrome/browser/chromeos/network_state_notifier.h"
 #endif
 
 // Are we in the process of restoring?
 static bool restoring = false;
 
 namespace {
 
 // TabLoader ------------------------------------------------------------------
 
 // Initial delay (see class decription for details).
 static const int kInitialDelayTimerMS = 100;
 
 // TabLoader is responsible for loading tabs after session restore creates
 // tabs. New tabs are loaded after the current tab finishes loading, or a delay
 // is reached (initially kInitialDelayTimerMS). If the delay is reached before
 // a tab finishes loading a new tab is loaded and the time of the delay
 // doubled. When all tabs are loading TabLoader deletes itself.
 //
 // This is not part of SessionRestoreImpl so that synchronous destruction
 // of SessionRestoreImpl doesn't have timing problems.
-class TabLoader : public NotificationObserver {
+class TabLoader : public NotificationObserver,
+                  public net::NetworkChangeNotifier::OnlineStateObserver {
  public:
   explicit TabLoader(base::TimeTicks restore_started);
-  ~TabLoader();
+  virtual ~TabLoader();
 
   // Schedules a tab for loading.
   void ScheduleLoad(NavigationController* controller);
 
   // Notifies the loader that a tab has been scheduled for loading through
   // some other mechanism.
   void TabIsLoading(NavigationController* controller);
 
   // Invokes |LoadNextTab| to load a tab.
   //
   // This must be invoked once to start loading.
   void StartLoading();
 
  private:
   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(int type,
                        const NotificationSource& source,
-                       const NotificationDetails& details);
+                       const NotificationDetails& details) OVERRIDE;
+
+  // net::NetworkChangeNotifier::OnlineStateObserver overrides.
+  virtual void OnOnlineStateChanged(bool online) OVERRIDE;
 
   // 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
   void ForceLoadTimerFired();
 
@@ skipping 47 matching lines @@
     : force_load_delay_(kInitialDelayTimerMS),
       loading_(false),
       got_first_paint_(false),
       tab_count_(0),
       restore_started_(restore_started) {
 }
 
 TabLoader::~TabLoader() {
   DCHECK((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
           tabs_loading_.empty() && tabs_to_load_.empty());
+  net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
 }
 
 void TabLoader::ScheduleLoad(NavigationController* controller) {
   DCHECK(controller);
   DCHECK(find(tabs_to_load_.begin(), tabs_to_load_.end(), controller) ==
          tabs_to_load_.end());
   tabs_to_load_.push_back(controller);
   RegisterForNotifications(controller);
 }
 
 void TabLoader::TabIsLoading(NavigationController* controller) {
   DCHECK(controller);
   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, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
                  NotificationService::AllSources());
 #if defined(OS_CHROMEOS)
-  if (chromeos::NetworkStateNotifier::is_connected()) {
+  if (!net::NetworkChangeNotifier::IsOffline()) {
     loading_ = true;
     LoadNextTab();
   } else {
-    // Start listening to network state notification now.
-    registrar_.Add(this, chrome::NOTIFICATION_NETWORK_STATE_CHANGED,
-                   NotificationService::AllSources());
+    net::NetworkChangeNotifier::AddOnlineStateObserver(this);
   }
 #else
   loading_ = true;
   LoadNextTab();
 #endif
 }
 
 void TabLoader::LoadNextTab() {
   if (!tabs_to_load_.empty()) {
     NavigationController* tab = tabs_to_load_.front();
@@ skipping 24 matching lines @@
     force_load_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(force_load_delay_),
         this, &TabLoader::ForceLoadTimerFired);
   }
 }
 
 void TabLoader::Observe(int type,
                         const NotificationSource& source,
                         const NotificationDetails& details) {
   switch (type) {
-#if defined(OS_CHROMEOS)
-    case chrome::NOTIFICATION_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 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;
     }
@@ skipping 55 matching lines @@
     }
     default:
       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::OnOnlineStateChanged(bool online) {
+  if (online) {
+    if (!loading_) {
+      loading_ = true;
+      LoadNextTab();
+    }
+  } else {
+    loading_ = false;
+  }
+}
+
 void TabLoader::RemoveTab(NavigationController* tab) {
   registrar_.Remove(this, content::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                     Source<TabContents>(tab->tab_contents()));
   registrar_.Remove(this, content::NOTIFICATION_LOAD_STOP,
                     Source<NavigationController>(tab));
   registrar_.Remove(this, content::NOTIFICATION_LOAD_START,
                     Source<NavigationController>(tab));
 
   TabsLoading::iterator i = tabs_loading_.find(tab);
   if (i != tabs_loading_.end())
@@ skipping 524 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;
 }