Switch over MobileActivator to use Network*Handler

Add a NetworkActivationHandler for handling cellular activation calls to Shill.

BUG=188753
TEST=tested Verizon LTE (on link) and Verizon 3g (on Lumpy) activation

Review URL: https://chromiumcodereview.appspot.com/22611005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@220463 0039d316-1c4b-4281-b951-d872f2087c98

ash/system/chromeos/network/network_connect.cc

@@ -15,6 +15,7 @@
 #include "base/values.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
+#include "chromeos/network/network_activation_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_event_log.h"
@@ -358,7 +359,7 @@ void ActivateCellular(const std::string& service_path) {
     return;
   }
 
-  NetworkHandler::Get()->network_connection_handler()->ActivateNetwork(
+  NetworkHandler::Get()->network_activation_handler()->Activate(
       service_path,
       "",  // carrier
       base::Bind(&OnActivateSucceeded, service_path),

chrome/browser/chromeos/mobile/mobile_activator.h

@@ -9,14 +9,22 @@
 #include <string>
 
 #include "base/files/file_path.h"
+#include "base/gtest_prod_util.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
-#include "chrome/browser/chromeos/cros/network_library.h"
+#include "base/timer/timer.h"
+#include "chromeos/network/network_handler_callbacks.h"
+#include "chromeos/network/network_state_handler_observer.h"
 #include "content/public/browser/browser_thread.h"
 
+namespace base {
+class DictionaryValue;
+}
+
 namespace chromeos {
 
+class NetworkState;
 class TestMobileActivator;
 
 // Cellular plan config document.
@@ -48,9 +56,8 @@ class CellularConfigDocument
 
 // This class performs mobile plan activation process.
 class MobileActivator
-  : public NetworkLibrary::NetworkManagerObserver,
-    public NetworkLibrary::NetworkObserver,
-    public base::SupportsWeakPtr<MobileActivator> {
+    : public base::SupportsWeakPtr<MobileActivator>,
+      public NetworkStateHandlerObserver {
  public:
   // Activation state.
   enum PlanActivationState {
@@ -91,7 +98,7 @@ class MobileActivator
    public:
     // Signals activation |state| change for given |network|.
     virtual void OnActivationStateChanged(
-        CellularNetwork* network,
+        const NetworkState* network,
         PlanActivationState state,
         const std::string& error_description) = 0;
 
@@ -133,11 +140,9 @@ class MobileActivator
   MobileActivator();
   virtual ~MobileActivator();
 
-  // NetworkLibrary::NetworkManagerObserver overrides.
-  virtual void OnNetworkManagerChanged(NetworkLibrary* obj) OVERRIDE;
-  // NetworkLibrary::NetworkObserver overrides.
-  virtual void OnNetworkChanged(NetworkLibrary* obj,
-                                const Network* network) OVERRIDE;
+  // NetworkStateHandlerObserver overrides.
+  virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE;
+  virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE;
 
   // Continue activation after inital setup (config load).
   void ContinueActivation();
@@ -161,32 +166,57 @@ class MobileActivator
   // Called when an OTASP attempt times out.
   void HandleOTASPTimeout();
   // Forces disconnect / reconnect when we detect portal connectivity issues.
-  void ForceReconnect(CellularNetwork* network, PlanActivationState next_state);
+  void ForceReconnect(const NetworkState* network,
+                      PlanActivationState next_state);
   // Called when ForceReconnect takes too long to reconnect.
   void ReconnectTimedOut();
+
+  // Called on default network changes to update cellular network activation
+  // state.
+  void RefreshCellularNetworks();
+
+  // Helper to get network state corresponding to service path. Provided
+  // for easy mocking in unit tests.
+  virtual const NetworkState* GetNetworkState(const std::string& service_path);
+
   // Verify the state of cellular network and modify internal state.
-  virtual void EvaluateCellularNetwork(CellularNetwork* network);
+  virtual void EvaluateCellularNetwork(const NetworkState* network);
   // PickNextState selects the desired state based on the current state of the
   // modem and the activator.  It does not transition to this state however.
-  PlanActivationState PickNextState(CellularNetwork* network,
+  PlanActivationState PickNextState(const NetworkState* network,
                                     std::string* error_description) const;
   // One of PickNext*State are called in PickNextState based on whether the
   // modem is online or not.
-  PlanActivationState PickNextOnlineState(CellularNetwork* network) const;
-  PlanActivationState PickNextOfflineState(CellularNetwork* network) const;
+  PlanActivationState PickNextOnlineState(const NetworkState* network) const;
+  PlanActivationState PickNextOfflineState(const NetworkState* network) const;
   // Check the current cellular network for error conditions.
-  bool GotActivationError(CellularNetwork* network,
+  bool GotActivationError(const NetworkState* network,
                           std::string* error) const;
   // Sends status updates to WebUI page.
-  void UpdatePage(CellularNetwork* network,
+  void UpdatePage(const NetworkState* network,
                   const std::string& error_description);
+
+  // Callback used to handle an activation error.
+  void HandleActivationFailure(
+      const std::string& service_path,
+      PlanActivationState new_state,
+      const std::string& error_name,
+      scoped_ptr<base::DictionaryValue> error_data);
+
+  // Request cellular activation for |network|.
+  // On success, |success_callback| will be called.
+  // On failure, |error_callback| will be called.
+  virtual void RequestCellularActivation(
+      const NetworkState* network,
+      const base::Closure& success_callback,
+      const network_handler::ErrorCallback& error_callback);
+
   // Changes internal state.
-  virtual void ChangeState(CellularNetwork* network,
+  virtual void ChangeState(const NetworkState* network,
                            PlanActivationState new_state,
                            const std::string& error_description);
   // Resets network devices after cellular activation process.
-  // |network| should be NULL if the activation process failed.
-  void CompleteActivation(CellularNetwork* network);
+  void CompleteActivation();
   // Disables SSL certificate revocation checking mechanism. In the case
   // where captive portal connection is the only one present, such revocation
   // checks could prevent payment portal page from loading.
@@ -196,9 +226,6 @@ class MobileActivator
   // Return error message for a given code.
   std::string GetErrorMessage(const std::string& code) const;
 
-  // Converts the currently active CellularNetwork device into a JS object.
-  static void GetDeviceInfo(CellularNetwork* network,
-                            DictionaryValue* value);
   static bool ShouldReportDeviceState(std::string* state, std::string* error);
 
   // Performs activation state cellular device evaluation.
@@ -207,16 +234,17 @@ class MobileActivator
   static bool EvaluateCellularDeviceState(bool* report_status,
                                           std::string* state,
                                           std::string* error);
-  // Finds cellular network that matches |meid_| or |iccid_|, reattach network
-  // change observer if |reattach_observer| flag is set.
-  virtual CellularNetwork* FindMatchingCellularNetwork(bool reattach_observer);
   // Starts the OTASP timeout timer.  If the timer fires, we'll force a
   // disconnect/reconnect cycle on this network.
   virtual void StartOTASPTimer();
 
-  static const char* GetStateDescription(PlanActivationState state);
+  // Records information that cellular plan payment has happened.
+  virtual void SignalCellularPlanPayment();
 
-  virtual NetworkLibrary* GetNetworkLibrary() const;
+  // Returns true if cellular plan payment has been recorded recently.
+  virtual bool HasRecentCellularPlanPayment() const;
+
+  static const char* GetStateDescription(PlanActivationState state);
 
   scoped_refptr<CellularConfigDocument> cellular_config_;
   // Internal handler state.
@@ -228,11 +256,18 @@ class MobileActivator
   // Service path of network being activated. Note that the path can change
   // during the activation process while still representing the same service.
   std::string service_path_;
+  // Device on which the network service is activated. While the service path
+  // can change during activation due to modem resets, the device path stays
+  // the same.
+  std::string device_path_;
   // Flags that controls if cert_checks needs to be restored
   // after the activation of cellular network.
   bool reenable_cert_check_;
   // True if activation process has been terminated.
   bool terminated_;
+  // True if an asynchronous activation request was dispatched to Shill
+  // but the succcess or failure of the request is yet unknown.
+  bool pending_activation_request_;
   // Connection retry counter.
   int connection_retry_count_;
   // Counters for how many times we've tried each OTASP step.
@@ -250,7 +285,8 @@ class MobileActivator
   base::RepeatingTimer<MobileActivator> continue_reconnect_timer_;
   // Called when the reconnect attempt times out.
   base::OneShotTimer<MobileActivator> reconnect_timeout_timer_;
-
+  // Cellular plan payment time.
+  base::Time cellular_plan_payment_time_;
 
   ObserverList<Observer> observers_;
 

chrome/browser/ui/webui/chromeos/mobile_setup_dialog.cc

@@ -23,15 +23,13 @@
 #include "ui/views/widget/widget.h"
 #include "ui/web_dialogs/web_dialog_delegate.h"
 
-using chromeos::CellularNetwork;
 using chromeos::MobileActivator;
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 using ui::WebDialogDelegate;
 
-class MobileSetupDialogDelegate : public WebDialogDelegate,
-                                  public MobileActivator::Observer {
+class MobileSetupDialogDelegate : public WebDialogDelegate {
  public:
   static MobileSetupDialogDelegate* GetInstance();
   void ShowDialog(const std::string& service_path);
@@ -62,12 +60,6 @@ class MobileSetupDialogDelegate : public WebDialogDelegate,
   virtual bool HandleContextMenu(
       const content::ContextMenuParams& params) OVERRIDE;
 
-  // MobileActivator::Observer overrides.
-  virtual void OnActivationStateChanged(
-      CellularNetwork* network,
-      MobileActivator::PlanActivationState state,
-      const std::string& error_description) OVERRIDE;
-
  private:
   gfx::NativeWindow dialog_window_;
   // Cellular network service path.
@@ -91,7 +83,6 @@ MobileSetupDialogDelegate::MobileSetupDialogDelegate() : dialog_window_(NULL) {
 }
 
 MobileSetupDialogDelegate::~MobileSetupDialogDelegate() {
-  MobileActivator::GetInstance()->RemoveObserver(this);
 }
 
 void MobileSetupDialogDelegate::ShowDialog(const std::string& service_path) {
@@ -142,12 +133,10 @@ std::string MobileSetupDialogDelegate::GetDialogArgs() const {
 
 void MobileSetupDialogDelegate::OnDialogShown(
     content::WebUI* webui, content::RenderViewHost* render_view_host) {
-  MobileActivator::GetInstance()->AddObserver(this);
 }
 
 
 void MobileSetupDialogDelegate::OnDialogClosed(const std::string& json_retval) {
-  MobileActivator::GetInstance()->RemoveObserver(this);
   dialog_window_ = NULL;
 }
 
@@ -178,9 +167,3 @@ bool MobileSetupDialogDelegate::HandleContextMenu(
     const content::ContextMenuParams& params) {
   return true;
 }
-
-void MobileSetupDialogDelegate::OnActivationStateChanged(
-    CellularNetwork* network,
-    MobileActivator::PlanActivationState state,
-    const std::string& error_description) {
-}

chromeos/chromeos.gyp

@@ -233,6 +233,8 @@
         'network/managed_network_configuration_handler_impl.h',
         'network/managed_state.cc',
         'network/managed_state.h',
+	'network/network_activation_handler.cc',
+	'network/network_activation_handler.h',
         'network/network_cert_migrator.cc',
         'network/network_cert_migrator.h',
         'network/network_change_notifier_chromeos.cc',

chromeos/network/network_activation_handler.cc

+// Copyright 2013 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 "chromeos/network/network_activation_handler.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_service_client.h"
+#include "chromeos/network/network_event_log.h"
+#include "chromeos/network/network_handler.h"
+#include "dbus/object_proxy.h"
+
+namespace chromeos {
+
+// static
+const char NetworkActivationHandler::kErrorShillError[] = "shill-error";
+
+NetworkActivationHandler::NetworkActivationHandler() {}
+NetworkActivationHandler::~NetworkActivationHandler() {}
+
+void NetworkActivationHandler::Activate(
+    const std::string& service_path,
+    const std::string& carrier,
+    const base::Closure& success_callback,
+    const network_handler::ErrorCallback& error_callback) {
+  NET_LOG_USER("ActivateNetwork", service_path);
+  CallShillActivate(service_path, carrier, success_callback, error_callback);
+}
+
+void NetworkActivationHandler::CompleteActivation(
+    const std::string& service_path,
+    const base::Closure& success_callback,
+    const network_handler::ErrorCallback& error_callback) {
+  NET_LOG_USER("CompleteActivation", service_path);
+  CallShillCompleteActivation(service_path, success_callback, error_callback);
+}
+
+void NetworkActivationHandler::CallShillActivate(
+    const std::string& service_path,
+    const std::string& carrier,
+    const base::Closure& success_callback,
+    const network_handler::ErrorCallback& error_callback) {
+  NET_LOG_USER("Activation Request", service_path + ": '" + carrier + "'");
+  DBusThreadManager::Get()->GetShillServiceClient()->ActivateCellularModem(
+      dbus::ObjectPath(service_path),
+      carrier,
+      base::Bind(&NetworkActivationHandler::HandleShillSuccess,
+                 AsWeakPtr(), service_path, success_callback),
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kErrorShillError, service_path, error_callback));
+}
+
+void NetworkActivationHandler::CallShillCompleteActivation(
+    const std::string& service_path,
+    const base::Closure& success_callback,
+    const network_handler::ErrorCallback& error_callback) {
+  NET_LOG_USER("CompleteActivation Request", service_path);
+  DBusThreadManager::Get()->GetShillServiceClient()->CompleteCellularActivation(
+      dbus::ObjectPath(service_path),
+      base::Bind(&NetworkActivationHandler::HandleShillSuccess,
+                 AsWeakPtr(), service_path, success_callback),
+      base::Bind(&network_handler::ShillErrorCallbackFunction,
+                 kErrorShillError, service_path, error_callback));
+}
+
+void NetworkActivationHandler::HandleShillSuccess(
+    const std::string& service_path,
+    const base::Closure& success_callback) {
+  if (!success_callback.is_null())
+    success_callback.Run();
+}
+
+}  // namespace chromeos

chromeos/network/network_activation_handler.h

+// Copyright 2013 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.
+
+#ifndef CHROMEOS_NETWORK_NETWORK_ACTIVATION_HANDLER_H_
+#define CHROMEOS_NETWORK_NETWORK_ACTIVATION_HANDLER_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/memory/weak_ptr.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/network/network_handler_callbacks.h"
+
+namespace chromeos {
+
+// The NetworkActivationHandler class allows making service specific
+// calls required for activation on mobile networks.
+class CHROMEOS_EXPORT NetworkActivationHandler
+    : public base::SupportsWeakPtr<NetworkActivationHandler> {
+ public:
+  // Constants for |error_name| from |error_callback|.
+  // TODO(gauravsh): Merge various error constants from Network*Handlers into
+  // a single place. crbug.com/272554
+  static const char kErrorNotFound[];
+  static const char kErrorShillError[];
+
+  virtual ~NetworkActivationHandler();
+
+  // ActivateNetwork() will start an asynchronous activation attempt.
+  // |carrier| may be empty or may specify a carrier to activate.
+  // On success, |success_callback| will be called.
+  // On failure, |error_callback| will be called with |error_name| one of:
+  //  kErrorNotFound if no network matching |service_path| is found.
+  //  kErrorShillError if a DBus or Shill error occurred.
+  void Activate(const std::string& service_path,
+                const std::string& carrier,
+                const base::Closure& success_callback,
+                const network_handler::ErrorCallback& error_callback);
+
+  // CompleteActivation() will start an asynchronous activation completion
+  // attempt.
+  // On success, |success_callback| will be called.
+  // On failure, |error_callback| will be called with |error_name| one of:
+  //  kErrorNotFound if no network matching |service_path| is found.
+  //  kErrorShillError if a DBus or Shill error occurred.
+  void CompleteActivation(const std::string& service_path,
+                          const base::Closure& success_callback,
+                          const network_handler::ErrorCallback& error_callback);
+
+ private:
+  friend class NetworkHandler;
+
+  NetworkActivationHandler();
+
+  // Calls Shill.Service.ActivateCellularModem asynchronously.
+  void CallShillActivate(const std::string& service_path,
+                         const std::string& carrier,
+                         const base::Closure& success_callback,
+                         const network_handler::ErrorCallback& error_callback);
+
+  // Calls Shill.Service.CompleteCellularActivation asynchronously.
+  void CallShillCompleteActivation(
+      const std::string& service_path,
+      const base::Closure& success_callback,
+      const network_handler::ErrorCallback& error_callback);
+
+  // Handle success from Shill.Service.ActivateCellularModem or
+  // Shill.Service.CompleteCellularActivation.
+  void HandleShillSuccess(const std::string& service_path,
+                          const base::Closure& success_callback);
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkActivationHandler);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_NETWORK_NETWORK_ACTIVATION_HANDLER_H_

chromeos/network/network_connection_handler.cc

@@ -314,21 +314,6 @@ void NetworkConnectionHandler::DisconnectNetwork(
   CallShillDisconnect(service_path, success_callback, error_callback);
 }
 
-void NetworkConnectionHandler::ActivateNetwork(
-    const std::string& service_path,
-    const std::string& carrier,
-    const base::Closure& success_callback,
-    const network_handler::ErrorCallback& error_callback) {
-  NET_LOG_USER("DisconnectNetwork", service_path);
-  const NetworkState* network =
-      network_state_handler_->GetNetworkState(service_path);
-  if (!network) {
-    InvokeErrorCallback(service_path, error_callback, kErrorNotFound);
-    return;
-  }
-  CallShillActivate(service_path, carrier, success_callback, error_callback);
-}
-
 bool NetworkConnectionHandler::HasConnectingNetwork(
     const std::string& service_path) {
   return pending_requests_.count(service_path) != 0;
@@ -696,29 +681,4 @@ void NetworkConnectionHandler::HandleShillDisconnectSuccess(
     success_callback.Run();
 }
 
-// Activate
-
-void NetworkConnectionHandler::CallShillActivate(
-    const std::string& service_path,
-    const std::string& carrier,
-    const base::Closure& success_callback,
-    const network_handler::ErrorCallback& error_callback) {
-  NET_LOG_USER("Activate Request", service_path + ": '" + carrier + "'");
-  DBusThreadManager::Get()->GetShillServiceClient()->ActivateCellularModem(
-      dbus::ObjectPath(service_path),
-      carrier,
-      base::Bind(&NetworkConnectionHandler::HandleShillActivateSuccess,
-                 AsWeakPtr(), service_path, success_callback),
-      base::Bind(&network_handler::ShillErrorCallbackFunction,
-                 kErrorShillError, service_path, error_callback));
-}
-
-void NetworkConnectionHandler::HandleShillActivateSuccess(
-    const std::string& service_path,
-    const base::Closure& success_callback) {
-  NET_LOG_EVENT("Activate Request Sent", service_path);
-  if (!success_callback.is_null())
-    success_callback.Run();
-}
-
 }  // namespace chromeos

chromeos/network/network_connection_handler.h

@@ -101,18 +101,6 @@ class CHROMEOS_EXPORT NetworkConnectionHandler
                          const base::Closure& success_callback,
                          const network_handler::ErrorCallback& error_callback);
 
-  // ActivateNetwork() will start an asynchronous activation attempt.
-  // |carrier| may be empty or may specify a carrier to activate.
-  // On success, |success_callback| will be called.
-  // On failure, |error_callback| will be called with |error_name| one of:
-  //  kErrorNotFound if no network matching |service_path| is found.
-  //  kErrorShillError if a DBus or Shill error occurred.
-  // TODO(stevenjb/armansito): Move this to a separate NetworkActivationHandler.
-  void ActivateNetwork(const std::string& service_path,
-                       const std::string& carrier,
-                       const base::Closure& success_callback,
-                       const network_handler::ErrorCallback& error_callback);
-
   // Returns true if ConnectToNetwork has been called with |service_path| and
   // has not completed (i.e. success or error callback has been called).
   bool HasConnectingNetwork(const std::string& service_path);
@@ -187,16 +175,6 @@ class CHROMEOS_EXPORT NetworkConnectionHandler
   void HandleShillDisconnectSuccess(const std::string& service_path,
                                     const base::Closure& success_callback);
 
-  // Calls Shill.Manager.Activate asynchronously.
-  void CallShillActivate(
-      const std::string& service_path,
-      const std::string& carrier,
-      const base::Closure& success_callback,
-      const network_handler::ErrorCallback& error_callback);
-
-  // Handle success from Shill.Service.ActivateCellularModem.
-  void HandleShillActivateSuccess(const std::string& service_path,
-                                  const base::Closure& success_callback);
 
   // Local references to the associated handler instances.
   CertLoader* cert_loader_;

chromeos/network/network_handler.cc

@@ -9,6 +9,7 @@
 #include "chromeos/network/client_cert_resolver.h"
 #include "chromeos/network/geolocation_handler.h"
 #include "chromeos/network/managed_network_configuration_handler_impl.h"
+#include "chromeos/network/network_activation_handler.h"
 #include "chromeos/network/network_cert_migrator.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
@@ -40,6 +41,7 @@ NetworkHandler::NetworkHandler()
     network_cert_migrator_.reset(new NetworkCertMigrator());
     client_cert_resolver_.reset(new ClientCertResolver());
   }
+  network_activation_handler_.reset(new NetworkActivationHandler());
   network_connection_handler_.reset(new NetworkConnectionHandler());
   network_sms_handler_.reset(new NetworkSmsHandler());
   geolocation_handler_.reset(new GeolocationHandler());
@@ -116,6 +118,10 @@ NetworkHandler::managed_network_configuration_handler() {
   return managed_network_configuration_handler_.get();
 }
 
+NetworkActivationHandler* NetworkHandler::network_activation_handler() {
+  return network_activation_handler_.get();
+}
+
 NetworkConnectionHandler* NetworkHandler::network_connection_handler() {
   return network_connection_handler_.get();
 }

chromeos/network/network_handler.h

@@ -17,6 +17,7 @@ class ClientCertResolver;
 class GeolocationHandler;
 class ManagedNetworkConfigurationHandler;
 class ManagedNetworkConfigurationHandlerImpl;
+class NetworkActivationHandler;
 class NetworkCertMigrator;
 class NetworkConfigurationHandler;
 class NetworkConnectionHandler;
@@ -54,6 +55,7 @@ class CHROMEOS_EXPORT NetworkHandler {
   NetworkProfileHandler* network_profile_handler();
   NetworkConfigurationHandler* network_configuration_handler();
   ManagedNetworkConfigurationHandler* managed_network_configuration_handler();
+  NetworkActivationHandler* network_activation_handler();
   NetworkConnectionHandler* network_connection_handler();
   NetworkSmsHandler* network_sms_handler();
   GeolocationHandler* geolocation_handler();
@@ -74,6 +76,7 @@ class CHROMEOS_EXPORT NetworkHandler {
       managed_network_configuration_handler_;
   scoped_ptr<NetworkCertMigrator> network_cert_migrator_;
   scoped_ptr<ClientCertResolver> client_cert_resolver_;
+  scoped_ptr<NetworkActivationHandler> network_activation_handler_;
   scoped_ptr<NetworkConnectionHandler> network_connection_handler_;
   scoped_ptr<NetworkSmsHandler> network_sms_handler_;
   scoped_ptr<GeolocationHandler> geolocation_handler_;

chromeos/network/network_state.h

@@ -116,6 +116,7 @@ class CHROMEOS_EXPORT NetworkState : public ManagedState {
       const base::DictionaryValue& properties);
 
  private:
+  friend class MobileActivatorTest;
   friend class NetworkStateHandler;
   friend class NetworkChangeNotifierChromeosUpdateTest;
 

chromeos/network/network_state_handler.cc

@@ -278,6 +278,11 @@ std::string NetworkStateHandler::FormattedHardwareAddressForType(
 }
 
 void NetworkStateHandler::GetNetworkList(NetworkStateList* list) const {
+  GetNetworkListByType(kMatchTypeDefault, list);
+}
+
+void NetworkStateHandler::GetNetworkListByType(const std::string& type,
+                                               NetworkStateList* list) const {
   DCHECK(list);
   list->clear();
   for (ManagedStateList::const_iterator iter = network_list_.begin();
@@ -286,7 +291,8 @@ void NetworkStateHandler::GetNetworkList(NetworkStateList* list) const {
       continue;
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
-    list->push_back(network);
+    if (ManagedStateMatchesType(network, type))
+      list->push_back(network);
   }
 }
 

chromeos/network/network_state_handler.h

@@ -150,6 +150,10 @@ class CHROMEOS_EXPORT NetworkStateHandler
   // only on the UI thread).
   void GetNetworkList(NetworkStateList* list) const;
 
+  // Like GetNetworkList() but only returns networks with matching |type|.
+  void GetNetworkListByType(const std::string& type,
+                            NetworkStateList* list) const;
+
   // Sets |list| to contain the list of devices.  The returned list contains
   // a copy of DeviceState pointers which should not be stored or used beyond
   // the scope of the calling function (i.e. they may later become invalid, but