Add a unified observer to replace NetworkManagerObserver

chrome/browser/chromeos/mobile/mobile_activator.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/chromeos/mobile/mobile_activator.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/observer_list_threadsafe.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/network_library.h"
+#include "chrome/browser/chromeos/net/connectivity_state_helper.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Cellular configuration file path.
 const char kCellularConfigPath[] =
     "/usr/share/chromeos-assets/mobile/mobile_config.json";
@@ skipping 126 matching lines @@
 
 void MobileActivator::TerminateActivation() {
   // We're exiting; don't continue with termination.
   if (!CrosLibrary::Get())
     return;
 
   state_duration_timer_.Stop();
   continue_reconnect_timer_.Stop();
   reconnect_timeout_timer_.Stop();
 
+  ConnectivityStateHelper::Get()->RemoveNetworkManagerObserver(this);
   NetworkLibrary* lib = GetNetworkLibrary();

[stevenjb, 2013/03/11 23:11:05]

I'd feel more comfortable converting all of this at once; depending on both
NetworkStateHandler and NetowrkLibrary might have consistency issues so I would
like to limit the places we do this.

[gauravsh, 2013/03/12 00:30:25]

This will still use the NetworkLibrary path in production.

The NetworkStateHandler path should only ever be used if the
--enable-new-network-change-notifier flag is set. We will not be turning on that
flag by default until all consumers have been converted to use the connectivity
state wrappers.

[stevenjb, 2013/03/12 15:53:34]

We will almost certainly want to turn on --enable-new-network-change-notifier
before we eliminate NetworkLibrary entirely, and I would like to minimize the
places where we use both in the same code. Given that this change is small and
not essential to this CL, I would really rather convert the entire file at once.

-  lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
   if (lib->IsLocked())
     lib->Unlock();
   ReEnableCertRevocationChecking();
   meid_.clear();
   iccid_.clear();
   service_path_.clear();
   state_ = PLAN_ACTIVATION_PAGE_LOADING;
   reenable_cert_check_ = false;
   terminated_ = true;
   // Release the previous cellular config and setup a new empty one.
   cellular_config_ = new CellularConfigDocument();
 }
 
-void MobileActivator::OnNetworkManagerChanged(NetworkLibrary* cros) {
+void MobileActivator::NetworkManagerChanged() {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
   EvaluateCellularNetwork(FindMatchingCellularNetwork(true));
 }
 
 void MobileActivator::OnNetworkChanged(NetworkLibrary* cros,
                                        const Network* network) {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
 
@@ skipping 164 matching lines @@
       error = kErrorNoDevice;
     else if (!lib->cellular_enabled())
       error = kErrorDisabled;
     else
       error = kErrorNoService;
     ChangeState(NULL, PLAN_ACTIVATION_ERROR, GetErrorMessage(error));
     return;
   }
 
   // Start monitoring network property changes.
-  lib->AddNetworkManagerObserver(this);
+  ConnectivityStateHelper::Get()->AddNetworkManagerObserver(this);
   if (network->activate_over_non_cellular_network()) {
     // Fast forward to payment portal loading if the activation is performed
     // over a non-cellular network.
     ChangeState(network,
                 (network->activation_state() == ACTIVATION_STATE_ACTIVATED) ?
                 PLAN_ACTIVATION_DONE :
                 PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING,
                 "");
   } else if (lib->HasRecentCellularPlanPayment() &&
              network->activation_state() ==
@@ skipping 346 matching lines @@
     case PLAN_ACTIVATION_RECONNECTING:
       return "RECONNECTING";
   }
   return "UNKNOWN";
 }
 
 
 void MobileActivator::CompleteActivation(
     CellularNetwork* network) {
   // Remove observers, we are done with this page.
+  ConnectivityStateHelper::Get()->RemoveNetworkManagerObserver(this);
   NetworkLibrary* lib = GetNetworkLibrary();
-  lib->RemoveNetworkManagerObserver(this);
   lib->RemoveObserverForAllNetworks(this);
   if (lib->IsLocked())
     lib->Unlock();
   // Reactivate other types of connections if we have
   // shut them down previously.
   ReEnableCertRevocationChecking();
 }
 
 bool MobileActivator::RunningActivation() const {
   return !(state_ == PLAN_ACTIVATION_DONE ||
@@ skipping 196 matching lines @@
 
 std::string MobileActivator::GetErrorMessage(const std::string& code) const {
   return cellular_config_->GetErrorMessage(code);
 }
 
 NetworkLibrary* MobileActivator::GetNetworkLibrary() const {
   return CrosLibrary::Get()->GetNetworkLibrary();
 }
 
 }  // namespace chromeos