API for connection type (Ethernet/WIFI/WWAN ...) in NetworkChangeNotifier.

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2012 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 <string>
@@ skipping 62 matching lines @@
 // doubled.
 //
 // TabLoader keeps a reference to itself when it's loading. When it has finished
 // loading, it drops the reference. If another profile is restored while the
 // TabLoader is loading, it will schedule its tabs to get loaded by the same
 // TabLoader. When doing the scheduling, it holds a reference to the TabLoader.
 //
 // This is not part of SessionRestoreImpl so that synchronous destruction
 // of SessionRestoreImpl doesn't have timing problems.
 class TabLoader : public content::NotificationObserver,
-                  public net::NetworkChangeNotifier::OnlineStateObserver,
+                  public net::NetworkChangeNotifier::ConnectionTypeObserver,
                   public base::RefCounted<TabLoader> {
  public:
   // Retrieves a pointer to the TabLoader instance shared between profiles, or
   // creates a new TabLoader if it doesn't exist. If a TabLoader is created, its
   // starting timestamp is set to |restore_started|.
   static TabLoader* GetTabLoader(base::TimeTicks restore_started);
 
   // Schedules a tab for loading.
   void ScheduleLoad(NavigationController* controller);
 
@@ skipping 19 matching lines @@
   // 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 content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
-  // net::NetworkChangeNotifier::OnlineStateObserver overrides.
-  virtual void OnOnlineStateChanged(bool online) OVERRIDE;
+  // net::NetworkChangeNotifier::ConnectionTypeObserver overrides.
+  virtual void OnConnectionTypeChanged(
+      net::NetworkChangeNotifier::ConnectionType type) 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 84 matching lines @@
   if (loading_)
     return;
   registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
                  content::NotificationService::AllSources());
   this_retainer_ = this;
 #if defined(OS_CHROMEOS)
   if (!net::NetworkChangeNotifier::IsOffline()) {
     loading_ = true;
     LoadNextTab();
   } else {
-    net::NetworkChangeNotifier::AddOnlineStateObserver(this);
+    net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   }
 #else
   loading_ = true;
   LoadNextTab();
 #endif
 }
 
 TabLoader::TabLoader(base::TimeTicks restore_started)
     : force_load_delay_(kInitialDelayTimerMS),
       loading_(false),
       got_first_paint_(false),
       tab_count_(0),
       restore_started_(restore_started),
       max_parallel_tab_loads_(0) {
 }
 
 TabLoader::~TabLoader() {
   DCHECK((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
           tabs_loading_.empty() && tabs_to_load_.empty());
-  net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
+  net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   shared_tab_loader = NULL;
 }
 
 void TabLoader::LoadNextTab() {
   if (!tabs_to_load_.empty()) {
     NavigationController* tab = tabs_to_load_.front();
     DCHECK(tab);
     tabs_loading_.insert(tab);
     if (tabs_loading_.size() > max_parallel_tab_loads_)
       max_parallel_tab_loads_ = tabs_loading_.size();
@@ skipping 102 matching lines @@
   }
   // Delete ourselves when we're not waiting for any more notifications. If this
   // was not the last reference, a SessionRestoreImpl holding a reference will
   // eventually call StartLoading (which assigns this_retainer_), or drop the
   // reference without initiating a load.
   if ((got_first_paint_ || render_widget_hosts_to_paint_.empty()) &&
       tabs_loading_.empty() && tabs_to_load_.empty())
     this_retainer_ = NULL;
 }
 
-void TabLoader::OnOnlineStateChanged(bool online) {
-  if (online) {
+void TabLoader::OnConnectionTypeChanged(
+    net::NetworkChangeNotifier::ConnectionType type) {
+  if (type != net::NetworkChangeNotifier::CONNECTION_NONE) {
     if (!loading_) {
       loading_ = true;
       LoadNextTab();
     }
   } else {
     loading_ = false;
   }
 }
 
 void TabLoader::RemoveTab(NavigationController* tab) {
@@ skipping 694 matching lines @@
   if (active_session_restorers == NULL)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
        it != active_session_restorers->end(); ++it) {
     if ((*it)->profile() == profile)
       return true;
   }
   return false;
 }