Removed chromeos::NetworkStateNotifier and redirected all related code to use

chrome/browser/chromeos/offline/offline_load_page.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/chromeos/offline/offline_load_page.h"
 
 #include "base/i18n/rtl.h"
 #include "base/metrics/histogram.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
@@ skipping 32 matching lines @@
 }
 
 }  // namespace
 
 namespace chromeos {
 
 // static
 void OfflineLoadPage::Show(int process_host_id, int render_view_id,
                            const GURL& url, Delegate* delegate) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (NetworkStateNotifier::is_connected()) {
+  if (!net::NetworkChangeNotifier::IsOffline()) {
     // Check again in UI thread and proceed if it's connected.
     delegate->OnBlockingPageComplete(true);
   } else {
     TabContents* tab_contents =
         tab_util::GetTabContentsByID(process_host_id, render_view_id);
     // There is a chance that the tab is closed after we decided to show
     // offline and before we actually show the offline page.
     if (!tab_contents)
       return;
     (new OfflineLoadPage(tab_contents, url, delegate))->Show();
   }
 }
 
 OfflineLoadPage::OfflineLoadPage(TabContents* tab_contents,
                                  const GURL& url,
                                  Delegate* delegate)
     : ChromeInterstitialPage(tab_contents, true, url),
       delegate_(delegate),
       proceeded_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       in_test_(false) {
-  registrar_.Add(this, chrome::NOTIFICATION_NETWORK_STATE_CHANGED,
-                 NotificationService::AllSources());
+  net::NetworkChangeNotifier::AddOnlineStateObserver(this);
 }
 
-OfflineLoadPage::~OfflineLoadPage() {}
+OfflineLoadPage::~OfflineLoadPage() {
+  net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
+}
 
 std::string OfflineLoadPage::GetHTMLContents() {
   DictionaryValue strings;
-  int64 time_to_wait = std::max(
-      static_cast<int64>(0),
-      kMaxBlankPeriod -
-      NetworkStateNotifier::GetOfflineDuration().InMilliseconds());
+  int64 time_to_wait = 0;  // kMaxBlankPeriod
   // Set the timeout to show the page.
   strings.SetInteger("time_to_wait", static_cast<int>(time_to_wait));
   // Button labels
   SetString(&strings, "heading", IDS_OFFLINE_LOAD_HEADLINE);
   SetString(&strings, "try_loading", IDS_OFFLINE_TRY_LOADING);
   SetString(&strings, "network_settings", IDS_OFFLINE_NETWORK_SETTINGS);
 
   // Activation
   strings.SetBoolean("show_activation", ShowActivationMessage());
 
@@ skipping 95 matching lines @@
 }
 
 void OfflineLoadPage::DontProceed() {
   // Inogre if it's already proceeded.
   if (proceeded_)
     return;
   delegate_->OnBlockingPageComplete(false);
   InterstitialPage::DontProceed();
 }
 
-void OfflineLoadPage::Observe(int type,
-                              const NotificationSource& source,
-                              const NotificationDetails& details) {
-  if (type == chrome::NOTIFICATION_NETWORK_STATE_CHANGED) {
-    chromeos::NetworkStateDetails* state_details =
-        Details<chromeos::NetworkStateDetails>(details).ptr();
-    DVLOG(1) << "NetworkStateChanaged notification received: state="
-             << state_details->state();
-    if (state_details->state() ==
-        chromeos::NetworkStateDetails::CONNECTED) {
-      registrar_.Remove(this, chrome::NOTIFICATION_NETWORK_STATE_CHANGED,
-                        NotificationService::AllSources());
-      Proceed();
-    }
-  } else {
-    ChromeInterstitialPage::Observe(type, source, details);
+void OfflineLoadPage::OnOnlineStateChanged(bool online) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DVLOG(1) << "OnlineStateObserver notification received: state="
+           << (online ? "online" : "offline");
+  if (online) {
+    net::NetworkChangeNotifier::RemoveOnlineStateObserver(this);
+    Proceed();
   }
 }
 
 bool OfflineLoadPage::ShowActivationMessage() {
   CrosLibrary* cros = CrosLibrary::Get();
   if (!cros || !cros->GetNetworkLibrary()->cellular_available())
     return false;
 
   const CellularNetworkVector& cell_networks =
       cros->GetNetworkLibrary()->cellular_networks();
   for (size_t i = 0; i < cell_networks.size(); ++i) {
     chromeos::ActivationState activation_state =
         cell_networks[i]->activation_state();
     if (activation_state == ACTIVATION_STATE_ACTIVATED)
       return false;
   }
   return true;
 }
 
 }  // namespace chromeos