Show offline interstitial page when offline and reload when reconnected to network.

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2010 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 <vector>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_types.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 
+#if defined(OS_CHROMEOS)
+#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;
 
@@ skipping 81 matching lines @@
                    Source<NavigationController>(controller));
     registrar_.Add(this, NotificationType::LOAD_STOP,
                    Source<NavigationController>(controller));
   } else {
     // Should never get a NULL tab.
     NOTREACHED();
   }
 }
 
 void TabLoader::StartLoading() {
+#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,
+                   NotificationService::AllSources());
+  }
+#else
   loading_ = true;
   LoadNextTab();
+#endif
 }
 
 void TabLoader::LoadNextTab() {
   if (!tabs_to_load_.empty()) {
     NavigationController* tab = tabs_to_load_.front();
+    DCHECK(tab);
     tabs_loading_.insert(tab);
     tabs_to_load_.pop_front();
     tab->LoadIfNecessary();
-    if (tab && tab->tab_contents()) {
+    if (tab->tab_contents()) {
       int tab_index;
       Browser* browser = Browser::GetBrowserForController(tab, &tab_index);
       if (browser && browser->selected_index() != tab_index) {
         // By default tabs are marked as visible. As only the selected tab is
         // visible we need to explicitly tell non-selected tabs they are hidden.
         // Without this call non-selected tabs are not marked as backgrounded.
         //
         // NOTE: We need to do this here rather than when the tab is added to
         // the Browser as at that time not everything has been created, so that
         // the call would do nothing.
@@ skipping 11 matching lines @@
   if (force_load_timer_.IsRunning())
     force_load_timer_.Stop();
   force_load_timer_.Start(
       base::TimeDelta::FromMilliseconds(force_load_delay_),
       this, &TabLoader::ForceLoadTimerFired);
 }
 
 void TabLoader::Observe(NotificationType type,
                         const NotificationSource& source,
                         const NotificationDetails& details) {
-  DCHECK(type == NotificationType::TAB_CLOSED ||
-         type == NotificationType::LOAD_STOP);
-  NavigationController* tab = Source<NavigationController>(source).ptr();
-  RemoveTab(tab);
-  if (loading_) {
-    LoadNextTab();
-    // WARNING: if there are no more tabs to load, we have been deleted.
+  switch (type.value) {
+#if defined(OS_CHROMEOS)
+    case NotificationType::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:
+          // keep it going
+          break;
+        case chromeos::NetworkStateDetails::DISCONNECTED:
+          // disconnected while loading. set loaing_ 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::TAB_CLOSED:
+    case NotificationType::LOAD_STOP: {
+      NavigationController* tab = Source<NavigationController>(source).ptr();
+      RemoveTab(tab);
+      if (loading_) {
+        LoadNextTab();
+        // WARNING: if there are no more tabs to load, we have been deleted.
+      } else if (tabs_to_load_.empty()) {
+        tabs_loading_.clear();
+        delete this;
+        return;
+      }
+      break;
+    }
+    default:
+      NOTREACHED() << "Unknown notification received:" << type.value;
   }
 }
 
 void TabLoader::RemoveTab(NavigationController* tab) {
   registrar_.Remove(this, NotificationType::TAB_CLOSED,
                     Source<NavigationController>(tab));
   registrar_.Remove(this, NotificationType::LOAD_STOP,
                     Source<NavigationController>(tab));
 
   TabsLoading::iterator i = tabs_loading_.find(tab);
@@ skipping 375 matching lines @@
 void SessionRestore::RestoreSessionSynchronously(
     Profile* profile,
     const std::vector<GURL>& urls_to_open) {
   Restore(profile, NULL, true, false, true, urls_to_open);
 }
 
 // static
 bool SessionRestore::IsRestoring() {
   return restoring;
 }