NOT FOR SUBMIT: Remove NetworkLibrary

chrome/browser/chromeos/cros/network_library.h

Index: chrome/browser/chromeos/cros/network_library.h
diff --git a/chrome/browser/chromeos/cros/network_library.h b/chrome/browser/chromeos/cros/network_library.h
deleted file mode 100644
index e4ebbb01a0d481f9ec3565a8b787eca3b0daabff..0000000000000000000000000000000000000000
--- a/chrome/browser/chromeos/cros/network_library.h
+++ /dev/null
@@ -1,1590 +0,0 @@
-// 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.
-
-#ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
-#define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
-
-#include <map>
-#include <string>
-#include <vector>
-
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/singleton.h"
-#include "base/memory/weak_ptr.h"
-#include "base/observer_list.h"
-#include "base/timer/timer.h"
-#include "base/values.h"
-#include "chrome/browser/chromeos/cros/network_constants.h"
-#include "chromeos/network/network_ip_config.h"
-#include "chromeos/network/network_ui_data.h"
-#include "chromeos/network/network_util.h"
-#include "chromeos/network/onc/onc_constants.h"
-
-namespace chromeos {
-
-class CertificatePattern;
-class EnrollmentDelegate;
-class NetworkDeviceParser;
-class NetworkParser;
-
-// This is the list of all implementation classes that are allowed
-// access to the internals of the network library classes.
-#define NETWORK_LIBRARY_IMPL_FRIENDS            \
-  friend class NetworkLibraryImplBase;          \
-  friend class NetworkLibraryImplCros;          \
-  friend class NetworkLibraryImplStub;
-
-
-// Simple wrapper for property Cellular.FoundNetworks.
-struct FoundCellularNetwork {
-  FoundCellularNetwork();
-  ~FoundCellularNetwork();
-
-  std::string status;
-  std::string network_id;
-  std::string short_name;
-  std::string long_name;
-  std::string technology;
-};
-typedef std::vector<FoundCellularNetwork> CellularNetworkList;
-
-struct CellularApn {
-  std::string apn;
-  std::string network_id;
-  std::string username;
-  std::string password;
-  std::string name;
-  std::string localized_name;
-  std::string language;
-
-  CellularApn();
-  CellularApn(const std::string& apn, const std::string& network_id,
-      const std::string& username, const std::string& password);
-  ~CellularApn();
-  void Set(const base::DictionaryValue& dict);
-};
-typedef std::vector<CellularApn> CellularApnList;
-
-// The value of priority if it is not set.
-const int kPriorityNotSet = 0;
-// The value of priority if network is preferred.
-const int kPriorityPreferred = 1;
-
-// Contains data related to the shill.Device interface,
-// e.g. ethernet, wifi, cellular.
-// TODO(dpolukhin): refactor to make base class and device specific derivatives.
-class NetworkDevice {
- public:
-  explicit NetworkDevice(const std::string& device_path);
-  ~NetworkDevice();
-
-  NetworkDeviceParser* device_parser() { return device_parser_.get(); }
-  void SetNetworkDeviceParser(NetworkDeviceParser* parser);
-
-  // Device info.
-  const std::string& device_path() const { return device_path_; }
-  const std::string& name() const { return name_; }
-  const std::string& unique_id() const { return unique_id_; }
-  ConnectionType type() const { return type_; }
-  bool scanning() const { return scanning_; }
-  const std::string& meid() const { return meid_; }
-  const std::string& iccid() const { return iccid_; }
-  const std::string& imei() const { return imei_; }
-  const std::string& imsi() const { return imsi_; }
-  const std::string& esn() const { return esn_; }
-  const std::string& mdn() const { return mdn_; }
-  const std::string& min() const { return min_; }
-  const std::string& model_id() const { return model_id_; }
-  const std::string& manufacturer() const { return manufacturer_; }
-  SimLockState sim_lock_state() const { return sim_lock_state_; }
-  bool is_sim_locked() const {
-    return sim_lock_state_ == SIM_LOCKED_PIN ||
-        sim_lock_state_ == SIM_LOCKED_PUK;
-  }
-  // Returns true if GSM modem and SIM as absent, otherwise
-  // returns false: GSM modem and SIM card is present or CDMA modem.
-  bool is_sim_absent() const {
-    return technology_family() == TECHNOLOGY_FAMILY_GSM &&
-           !is_sim_locked() && !sim_present_;
-  }
-  int sim_retries_left() const { return sim_retries_left_; }
-  SimPinRequire sim_pin_required() const { return sim_pin_required_; }
-  bool powered() const { return powered_; }
-  const std::string& firmware_revision() const { return firmware_revision_; }
-  const std::string& hardware_revision() const { return hardware_revision_; }
-  const unsigned int prl_version() const { return prl_version_; }
-  const std::string& home_provider_code() const { return home_provider_code_; }
-  const std::string& home_provider_country() const {
-    return home_provider_country_;
-  }
-  const std::string& home_provider_id() const { return home_provider_id_; }
-  const std::string& home_provider_name() const { return home_provider_name_; }
-  const bool provider_requires_roaming() const {
-    return provider_requires_roaming_;
-  }
-  const std::string& selected_cellular_network() const {
-    return selected_cellular_network_;
-  }
-  const CellularNetworkList& found_cellular_networks() const {
-    return found_cellular_networks_;
-  }
-  bool data_roaming_allowed() const { return data_roaming_allowed_; }
-  bool support_network_scan() const { return support_network_scan_; }
-  std::string carrier() const { return carrier_; }
-  base::ListValue* supported_carriers() const {
-    return supported_carriers_.get();
-  }
-  enum TechnologyFamily technology_family() const { return technology_family_; }
-  const CellularApnList& provider_apn_list() const {
-    return provider_apn_list_;
-  }
-
-  // Updates the property specified by |key| with the contents of
-  // |value|.  Returns false on failure.  Upon success, returns the
-  // PropertyIndex that was updated in |index|.  |index| may be NULL
-  // if not needed.
-  bool UpdateStatus(const std::string& key,
-                    const base::Value& value,
-                    PropertyIndex* index);
-
- protected:
-  void set_unique_id(const std::string& unique_id) { unique_id_ = unique_id; }
-
- private:
-  // This allows NetworkDeviceParser and its subclasses access to
-  // device privates so that they can be reconstituted during parsing.
-  // The parsers only access things through the private set_ functions
-  // so that this class can evolve without having to change all the
-  // parsers.
-  friend class NativeNetworkDeviceParser;
-
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  // Use these functions at your peril.  They are used by the various
-  // parsers to set state, and really shouldn't be used by anyone
-  // else.
-  void set_device_path(const std::string& device_path) {
-    device_path_ = device_path;
-  }
-  void set_name(const std::string& name) { name_ = name; }
-  void set_type(ConnectionType type) { type_ = type; }
-  void set_scanning(bool scanning) { scanning_ = scanning; }
-  void set_meid(const std::string& meid) { meid_ = meid; }
-  void set_iccid(const std::string& iccid) { iccid_ = iccid; }
-  void set_imei(const std::string& imei) { imei_ = imei; }
-  void set_imsi(const std::string& imsi) { imsi_ = imsi; }
-  void set_esn(const std::string& esn) { esn_ = esn; }
-  void set_mdn(const std::string& mdn) { mdn_ = mdn; }
-  void set_min(const std::string& min) { min_ = min; }
-  void set_technology_family(TechnologyFamily technology_family) {
-    technology_family_ = technology_family;
-  }
-  void set_carrier(const std::string& carrier) { carrier_ = carrier; }
-  void set_supported_carriers(const base::ListValue& supported_carriers) {
-    supported_carriers_.reset(supported_carriers.DeepCopy());
-  }
-  void set_home_provider_code(const std::string& home_provider_code) {
-    home_provider_code_ = home_provider_code;
-  }
-  void set_home_provider_country(const std::string& home_provider_country) {
-    home_provider_country_ = home_provider_country;
-  }
-  void set_home_provider_id(const std::string& home_provider_id) {
-    home_provider_id_ = home_provider_id;
-  }
-  void set_home_provider_name(const std::string& home_provider_name) {
-    home_provider_name_ = home_provider_name;
-  }
-  void set_provider_requires_roaming(bool provider_requires_roaming) {
-    provider_requires_roaming_ = provider_requires_roaming;
-  }
-  void set_model_id(const std::string& model_id) { model_id_ = model_id; }
-  void set_manufacturer(const std::string& manufacturer) {
-    manufacturer_ = manufacturer;
-  }
-  void set_prl_version(int prl_version) {
-    prl_version_ = prl_version;
-  }
-  void set_sim_lock_state(SimLockState sim_lock_state) {
-    sim_lock_state_ = sim_lock_state;
-  }
-  void set_sim_retries_left(int sim_retries_left) {
-    sim_retries_left_ = sim_retries_left;
-  }
-  void set_sim_pin_required(SimPinRequire sim_pin_required) {
-    sim_pin_required_ = sim_pin_required;
-  }
-  void set_sim_present(bool sim_present) {
-    sim_present_ = sim_present;
-  }
-  void set_powered(bool powered) {
-    powered_ = powered;
-  }
-  void set_firmware_revision(const std::string& firmware_revision) {
-    firmware_revision_ = firmware_revision;
-  }
-  void set_hardware_revision(const std::string& hardware_revision) {
-    hardware_revision_ = hardware_revision;
-  }
-  void set_selected_cellular_network(
-      const std::string& selected_cellular_network) {
-    selected_cellular_network_ = selected_cellular_network;
-  }
-  void set_found_cellular_networks(
-      const CellularNetworkList& found_cellular_networks) {
-    found_cellular_networks_ = found_cellular_networks;
-  }
-  void set_data_roaming_allowed(bool data_roaming_allowed) {
-    data_roaming_allowed_ = data_roaming_allowed;
-  }
-  void set_support_network_scan(bool support_network_scan) {
-    support_network_scan_ = support_network_scan;
-  }
-  void set_provider_apn_list(const CellularApnList& provider_apn_list) {
-    provider_apn_list_ = provider_apn_list;
-  }
-
-  void ParseInfo(const base::DictionaryValue& info);
-
-  // General device info.
-  std::string device_path_;
-  std::string name_;
-  std::string unique_id_;
-  ConnectionType type_;
-  bool scanning_;
-  // Cellular specific device info.
-  TechnologyFamily technology_family_;
-  std::string carrier_;
-  scoped_ptr<base::ListValue> supported_carriers_;
-  std::string home_provider_code_;
-  std::string home_provider_country_;
-  std::string home_provider_id_;
-  std::string home_provider_name_;
-  bool provider_requires_roaming_;
-  std::string meid_;
-  std::string imei_;
-  std::string iccid_;
-  std::string imsi_;
-  std::string esn_;
-  std::string mdn_;
-  std::string min_;
-  std::string model_id_;
-  std::string manufacturer_;
-  SimLockState sim_lock_state_;
-  int sim_retries_left_;
-  SimPinRequire sim_pin_required_;
-  bool sim_present_;
-  bool powered_;
-  std::string firmware_revision_;
-  std::string hardware_revision_;
-  int prl_version_;
-  std::string selected_cellular_network_;
-  CellularNetworkList found_cellular_networks_;
-  bool data_roaming_allowed_;
-  bool support_network_scan_;
-  CellularApnList provider_apn_list_;
-
-  // This is the parser we use to parse messages from the native
-  // network layer.
-  scoped_ptr<NetworkDeviceParser> device_parser_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetworkDevice);
-};
-
-// Contains data common to all network service types.
-class Network {
- public:
-  virtual ~Network();
-
-  // Test API for accessing setters in tests.
-  class TestApi {
-   public:
-    explicit TestApi(Network* network) : network_(network) {}
-    void SetConnected() {
-      network_->set_connected();
-    }
-    void SetConnecting() {
-      network_->set_connecting();
-    }
-    void SetDisconnected() {
-      network_->set_disconnected();
-    }
-    void SetUserConnectState(UserConnectState user_connect_state) {
-      network_->set_user_connect_state(user_connect_state);
-    }
-
-   private:
-    Network* network_;
-  };
-  friend class TestApi;
-
-  const std::string& service_path() const { return service_path_; }
-  const std::string& name() const { return name_; }
-  const std::string& device_path() const { return device_path_; }
-  const std::string& ip_address() const { return ip_address_; }
-  ConnectionType type() const { return type_; }
-  ConnectionState connection_state() const { return state_; }
-  bool connecting() const { return IsConnectingState(state_); }
-  bool configuring() const { return state_ == STATE_CONFIGURATION; }
-  bool connected() const { return IsConnectedState(state_); }
-  bool connecting_or_connected() const { return connecting() || connected(); }
-  // True when a user-initiated connection attempt is in progress
-  bool connection_started() const {
-    return user_connect_state_ == USER_CONNECT_STARTED;
-  }
-  UserConnectState user_connect_state() const { return user_connect_state_; }
-  bool failed() const { return state_ == STATE_FAILURE; }
-  bool disconnected() const { return IsDisconnectedState(state_); }
-  bool online() const { return state_ == STATE_ONLINE; }
-  bool restricted_pool() const { return state_ == STATE_PORTAL; }
-  ConnectionError error() const { return error_; }
-  ConnectionState state() const { return state_; }
-  // Is this network connectable. Currently, this is mainly used by 802.1x
-  // networks to specify that the network is not configured yet.
-  bool connectable() const { return connectable_; }
-  // Is this the active network, i.e, the one through which
-  // network traffic is being routed? A network can be connected,
-  // but not be carrying traffic.
-  bool is_active() const { return is_active_; }
-  bool preferred() const { return priority_ != kPriorityNotSet; }
-  bool auto_connect() const { return auto_connect_; }
-  bool save_credentials() const { return save_credentials_; }
-
-  bool added() const { return added_; }
-  bool notify_failure() const { return notify_failure_; }
-  const std::string& profile_path() const { return profile_path_; }
-  NetworkProfileType profile_type() const { return profile_type_; }
-
-  const std::string& unique_id() const { return unique_id_; }
-  int priority_order() const { return priority_order_; }
-
-  const NetworkUIData& ui_data() const { return ui_data_; }
-
-  void set_notify_failure(bool state) { notify_failure_ = state; }
-
-  void SetPreferred(bool preferred);
-
-  void SetAutoConnect(bool auto_connect);
-
-  void SetName(const std::string& name);
-
-  void SetSaveCredentials(bool save_credentials);
-
-  void ClearUIData();
-
-  // This will resolve any automatic configuration that has to occur
-  // (provisioning certificates, etc.) before attempting to connect to the
-  // network.  When configuration is complete, calls the closure to finish the
-  // connection or show the config dialog to collect user-supplied info.
-  virtual void AttemptConnection(const base::Closure& connect);
-
-  // Return a string representation of the state code.
-  std::string GetStateString() const;
-
-  // Return a string representation of the error code.
-  std::string GetErrorString() const;
-
-  // Return true if the network must be in the user profile (e.g. has certs).
-  virtual bool RequiresUserProfile() const;
-
-  // Copy any credentials from a remembered network that are unset in |this|.
-  virtual void CopyCredentialsFromRemembered(Network* remembered);
-
-  // Static helper functions.
-  static bool IsConnectedState(ConnectionState state) {
-    return (state == STATE_READY ||
-            state == STATE_ONLINE ||
-            state == STATE_PORTAL);
-  }
-  static bool IsConnectingState(ConnectionState state) {
-    return (state == STATE_CONNECT_REQUESTED ||
-            state == STATE_ASSOCIATION ||
-            state == STATE_CONFIGURATION ||
-            state == STATE_CARRIER);
-  }
-  static bool IsDisconnectedState(ConnectionState state) {
-    return (state == STATE_UNKNOWN ||
-            state == STATE_IDLE ||
-            state == STATE_DISCONNECT ||
-            state == STATE_FAILURE ||
-            state == STATE_ACTIVATION_FAILURE);
-  }
-
-  // Adopts the given enrollment handler to handle any certificate enrollment
-  // URIs encountered during network connection.
-  void SetEnrollmentDelegate(EnrollmentDelegate* delegate);
-
-  virtual bool UpdateStatus(const std::string& key,
-                            const base::Value& value,
-                            PropertyIndex* index);
-
-  // Creates a Network object for the given type for testing.
-  static Network* CreateForTesting(ConnectionType type);
-
- protected:
-  Network(const std::string& service_path,
-          ConnectionType type);
-
-  NetworkParser* network_parser() { return network_parser_.get(); }
-  void SetNetworkParser(NetworkParser* parser);
-
-  // Set the state and update flags if necessary.
-  void SetState(ConnectionState state);
-
-  // Set the error state and update notify_failure_
-  void SetError(ConnectionError error);
-
-  // Parse name/value pairs from libcros.
-  virtual void ParseInfo(const base::DictionaryValue& info);
-
-  // Erase cached credentials, used when "Save password" is unchecked.
-  virtual void EraseCredentials();
-
-  // Calculate a unique identifier for the network.
-  virtual void CalculateUniqueId();
-
-  // Methods to asynchronously set network service properties
-  virtual void SetStringProperty(const char* prop, const std::string& str,
-                                 std::string* dest);
-  virtual void SetBooleanProperty(const char* prop, bool b, bool* dest);
-  virtual void SetIntegerProperty(const char* prop, int i, int* dest);
-  virtual void SetValueProperty(const char* prop, const base::Value& val);
-  virtual void ClearProperty(const char* prop);
-
-  // This will clear the property if string is empty. Otherwise, it will set it.
-  virtual void SetOrClearStringProperty(const char* prop,
-                                        const std::string& str,
-                                        std::string* dest);
-
-  void set_unique_id(const std::string& unique_id) { unique_id_ = unique_id; }
-  const CertificatePattern& client_cert_pattern() const {
-    return ui_data_.certificate_pattern();
-  }
-
-  ClientCertType client_cert_type() const {
-    return ui_data_.certificate_type();
-  }
-
-  EnrollmentDelegate* enrollment_delegate() const {
-    return enrollment_delegate_.get();
-  }
-
- private:
-  // This allows NetworkParser and its subclasses access to device
-  // privates so that they can be reconstituted during parsing.  The
-  // parsers only access things through the private set_ functions so
-  // that this class can evolve without having to change all the
-  // parsers.
-  friend class NetworkParser;
-  friend class NativeNetworkParser;
-  friend class NativeVirtualNetworkParser;
-  // We reach directly into the network for testing purposes.
-  friend class MobileActivatorTest;
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  // Use these functions at your peril.  They are used by the various
-  // parsers to set state, and really shouldn't be used by anything else
-  // because they don't do the error checking and sending to the
-  // network layer that the other setters do.
-  void set_device_path(const std::string& device_path) {
-    device_path_ = device_path;
-  }
-  void set_name(const std::string& name) { name_ = name; }
-  void set_connecting();
-  void set_behind_portal() {
-    state_ = STATE_PORTAL;
-  }
-  void set_connected() {
-    state_ = STATE_ONLINE;
-  }
-  void set_disconnected() {
-    state_ = STATE_IDLE;
-  }
-  void set_connectable(bool connectable) { connectable_ = connectable; }
-  void set_user_connect_state(UserConnectState user_connect_state) {
-    user_connect_state_ = user_connect_state;
-  }
-  void set_is_active(bool is_active) { is_active_ = is_active; }
-  void set_added(bool added) { added_ = added; }
-  void set_auto_connect(bool auto_connect) { auto_connect_ = auto_connect; }
-  void set_save_credentials(bool save_credentials) {
-    save_credentials_ = save_credentials;
-  }
-  void set_profile_path(const std::string& path) { profile_path_ = path; }
-  void set_profile_type(NetworkProfileType type) { profile_type_ = type; }
-  void set_ui_data(const NetworkUIData& ui_data) {
-    ui_data_ = ui_data;
-  }
-  void set_client_cert_pattern(const CertificatePattern& pattern) {
-    ui_data_.set_certificate_pattern(pattern);
-  }
-  void set_client_cert_type(ClientCertType type) {
-    ui_data_.set_certificate_type(type);
-  }
-
-  // Set the profile path and update the flimflam property.
-  void SetProfilePath(const std::string& profile_path);
-
-  // Trigger an asynchronous initialization the IP address field.
-  void InitIPAddress();
-
-  // Initialize the IP address field.
-  static void InitIPAddressCallback(
-      const std::string& service_path,
-      const NetworkIPConfigVector& ip_configs,
-      const std::string& hardware_address);
-
-  std::string device_path_;
-  std::string name_;
-  std::string ip_address_;
-  ConnectionState state_;
-  ConnectionError error_;
-  bool connectable_;
-  UserConnectState user_connect_state_;
-  bool is_active_;
-  int priority_;  // determines order in network list.
-  bool auto_connect_;
-  bool save_credentials_;  // save passphrase and EAP credentials to disk.
-  scoped_ptr<EnrollmentDelegate> enrollment_delegate_;
-
-  // Unique identifier, set the first time the network is parsed.
-  std::string unique_id_;
-
-  // Priority value, corresponds to index in list from shill (0 = first)
-  int priority_order_;
-
-  // Set to true if the UI requested this as a new network.
-  bool added_;
-
-  // Set to true when a new connection failure occurs; cleared when observers
-  // are notified.
-  bool notify_failure_;
-
-  // Profile path for networks.
-  std::string profile_path_;
-
-  // Set to profile type based on profile_path_.
-  NetworkProfileType profile_type_;
-
-  // These must not be modified after construction.
-  std::string service_path_;
-  ConnectionType type_;
-
-  // UI-level state that is opaque to the connection manager. The value is
-  // stored in JSON-serialized from in the connection manager.
-  NetworkUIData ui_data_;
-
-  // This is the parser we use to parse messages from the native
-  // network layer.
-  scoped_ptr<NetworkParser> network_parser_;
-
-  DISALLOW_COPY_AND_ASSIGN(Network);
-};
-
-// Class for networks of TYPE_ETHERNET.
-class EthernetNetwork : public Network {
- public:
-  explicit EthernetNetwork(const std::string& service_path);
- private:
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  DISALLOW_COPY_AND_ASSIGN(EthernetNetwork);
-};
-
-// Class for networks of TYPE_VPN.
-class VirtualNetwork : public Network {
- public:
-  explicit VirtualNetwork(const std::string& service_path);
-  virtual ~VirtualNetwork();
-
-  const std::string& server_hostname() const { return server_hostname_; }
-  ProviderType provider_type() const { return provider_type_; }
-  const std::string& ca_cert_pem() const { return ca_cert_pem_; }
-  const std::string& psk_passphrase() const { return psk_passphrase_; }
-  const std::string& client_cert_id() const { return client_cert_id_; }
-  const std::string& username() const { return username_; }
-  const std::string& user_passphrase() const { return user_passphrase_; }
-  const std::string& group_name() const { return group_name_; }
-
-  // Sets the well-known PKCS#11 slot and PIN for accessing certificates.
-  void SetCertificateSlotAndPin(
-      const std::string& slot, const std::string& pin);
-
-  // Network overrides.
-  virtual bool RequiresUserProfile() const OVERRIDE;
-  virtual void CopyCredentialsFromRemembered(Network* remembered) OVERRIDE;
-  virtual void AttemptConnection(const base::Closure& connect) OVERRIDE;
-
-  // Public getters.
-  bool NeedMoreInfoToConnect() const;
-  std::string GetProviderTypeString() const;
-  // Returns true if a PSK passphrase is required to connect.
-  bool IsPSKPassphraseRequired() const;
-  // Returns true if a user passphrase is required to connect.
-  bool IsUserPassphraseRequired() const;
-
-  // Public setters.
-  void SetCACertPEM(const std::string& ca_cert_pem);
-  void SetL2TPIPsecPSKCredentials(const std::string& psk_passphrase,
-                                  const std::string& username,
-                                  const std::string& user_passphrase,
-                                  const std::string& group_name);
-  void SetL2TPIPsecCertCredentials(const std::string& client_cert_id,
-                                   const std::string& username,
-                                   const std::string& user_passphrase,
-                                   const std::string& group_name);
-  void SetOpenVPNCredentials(const std::string& client_cert_id,
-                             const std::string& username,
-                             const std::string& user_passphrase,
-                             const std::string& otp);
-  void SetServerHostname(const std::string& server_hostname);
-
- private:
-  // This allows NetworkParser and its subclasses access to
-  // device privates so that they can be reconstituted during parsing.
-  // The parsers only access things through the private set_ functions
-  // so that this class can evolve without having to change all the
-  // parsers.
-  friend class NativeNetworkParser;
-  friend class NativeVirtualNetworkParser;
-
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  // Use these functions at your peril.  They are used by the various
-  // parsers to set state, and really shouldn't be used by anything else
-  // because they don't do the error checking and sending to the
-  // network layer that the other setters do.
-  void set_server_hostname(const std::string& server_hostname) {
-    server_hostname_ = server_hostname;
-  }
-  void set_provider_type(ProviderType provider_type) {
-    provider_type_ = provider_type;
-  }
-  void set_ca_cert_pem(const std::string& ca_cert_pem) {
-    ca_cert_pem_ = ca_cert_pem;
-  }
-  void set_psk_passphrase(const std::string& psk_passphrase) {
-    psk_passphrase_ = psk_passphrase;
-  }
-  void set_psk_passphrase_required(bool psk_passphrase_required) {
-    psk_passphrase_required_ = psk_passphrase_required;
-  }
-  void set_client_cert_id(const std::string& client_cert_id) {
-    client_cert_id_ = client_cert_id;
-  }
-  void set_username(const std::string& username) { username_ = username; }
-  void set_user_passphrase(const std::string& user_passphrase) {
-    user_passphrase_ = user_passphrase;
-  }
-  void set_user_passphrase_required(bool user_passphrase_required) {
-    user_passphrase_required_ = user_passphrase_required;
-  }
-  void set_group_name(const std::string& group_name) {
-    group_name_ = group_name;
-  }
-
-  // Matches the client certificate pattern by checking to see if a certificate
-  // exists that meets the pattern criteria. If it finds one, it sets the
-  // appropriate network property. If not, it passes |connect| to the
-  // EnrollmentDelegate to do something with the enrollment URI (e.g. launch a
-  // dialog) to install the certificate, and then invoke |connect|. If
-  // |allow_enroll| is false, then the enrollment handler will not be invoked in
-  // the case of a missing certificate.
-  void MatchCertificatePattern(bool allow_enroll, const base::Closure& connect);
-
- // Network overrides.
-  virtual void EraseCredentials() OVERRIDE;
-  virtual void CalculateUniqueId() OVERRIDE;
-
-  std::string server_hostname_;
-  ProviderType provider_type_;
-  std::string ca_cert_pem_;
-  std::string psk_passphrase_;
-  bool psk_passphrase_required_;
-  // PKCS#11 ID for client certificate.
-  std::string client_cert_id_;
-  std::string username_;
-  std::string user_passphrase_;
-  bool user_passphrase_required_;
-  std::string group_name_;
-
-  // Weak pointer factory for wrapping pointers to this network in callbacks.
-  base::WeakPtrFactory<VirtualNetwork> weak_pointer_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(VirtualNetwork);
-};
-typedef std::vector<VirtualNetwork*> VirtualNetworkVector;
-
-// Base class for networks of TYPE_WIFI or TYPE_CELLULAR.
-class WirelessNetwork : public Network {
- public:
-  // Test API for accessing setters in tests.
-  class TestApi {
-   public:
-    explicit TestApi(WirelessNetwork* network) : network_(network) {}
-    void SetStrength(int strength) { network_->set_strength(strength); }
-   private:
-    WirelessNetwork* network_;
-  };
-  friend class TestApi;
-
-  int strength() const { return strength_; }
-
- protected:
-  WirelessNetwork(const std::string& service_path,
-                  ConnectionType type)
-      : Network(service_path, type), strength_(0) {}
-
- private:
-  // This allows NativeWirelessNetworkParser access to device privates
-  // so that they can be reconstituted during parsing.  The parsers
-  // only access things through the private set_ functions so that
-  // this class can evolve without having to change all the parsers.
-  friend class NativeWirelessNetworkParser;
-
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  // The friend parsers use this.
-  void set_strength(int strength) { strength_ = strength; }
-
-  int strength_;  // 0-100
-
-  DISALLOW_COPY_AND_ASSIGN(WirelessNetwork);
-};
-
-// Class for networks of TYPE_CELLULAR.
-class CellularNetwork : public WirelessNetwork {
- public:
-  // Test API for accessing setters in tests.
-  class TestApi {
-   public:
-    explicit TestApi(CellularNetwork* network) : network_(network) {}
-    void SetRoamingState(NetworkRoamingState roaming_state) {
-      network_->set_roaming_state(roaming_state);
-    }
-   private:
-    CellularNetwork* network_;
-  };
-  friend class TestApi;
-
-  explicit CellularNetwork(const std::string& service_path);
-  virtual ~CellularNetwork();
-
-  // Starts device activation process. Returns false if the device state does
-  // not permit activation.
-  virtual bool StartActivation();
-  virtual void CompleteActivation();
-
-  bool activate_over_non_cellular_network() const {
-    return activate_over_non_cellular_network_;
-  }
-  const ActivationState activation_state() const { return activation_state_; }
-  bool activated() const {
-    return activation_state() == ACTIVATION_STATE_ACTIVATED;
-  }
-  const NetworkTechnology network_technology() const {
-    return network_technology_;
-  }
-  const NetworkRoamingState roaming_state() const { return roaming_state_; }
-  const std::string& operator_name() const { return operator_name_; }
-  const std::string& operator_code() const { return operator_code_; }
-  const std::string& operator_country() const { return operator_country_; }
-  bool out_of_credits() const { return out_of_credits_; }
-  const std::string& payment_url() const { return payment_url_; }
-  const std::string& usage_url() const { return usage_url_; }
-  const std::string& post_data() const { return post_data_; }
-  const bool using_post() const { return using_post_; }
-  const CellularApn& apn() const { return apn_; }
-  const CellularApn& last_good_apn() const { return last_good_apn_; }
-
-  // Sets the APN to use in establishing data connections. Only
-  // the fields of the APN that are needed for making connections
-  // are passed to shill. The name, localized_name, and language
-  // fields are ignored.
-  void SetApn(const CellularApn& apn);
-
-  // Returns true if network supports activation.
-  bool SupportsActivation() const;
-
-  // Returns whether the network needs to be activated.
-  bool NeedsActivation() const;
-
-  // Return a string representation of network technology.
-  std::string GetNetworkTechnologyString() const;
-  // Return a string representation of activation state.
-  std::string GetActivationStateString() const;
-  // Return a string representation of roaming state.
-  std::string GetRoamingStateString() const;
-
-  // Return a string representation of |activation_state|.
-  static std::string ActivationStateToString(ActivationState activation_state);
-
- private:
-  // This allows NativeCellularNetworkParser access to device privates
-  // so that they can be reconstituted during parsing.  The parsers
-  // only access things through the private set_ functions so that
-  // this class can evolve without having to change all the parsers.
-  friend class NativeCellularNetworkParser;
-  // We reach directly into the network for testing purposes.
-  friend class MobileActivatorTest;
-
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  // Use these functions at your peril.  They are used by the various
-  // parsers to set state, and really shouldn't be used by anything else
-  // because they don't do the error checking and sending to the
-  // network layer that the other setters do.
-  void set_activate_over_non_cellular_network(bool value) {
-    activate_over_non_cellular_network_ = value;
-  }
-  void set_activation_state(ActivationState activation_state) {
-    activation_state_ = activation_state;
-  }
-  void set_network_technology(NetworkTechnology network_technology) {
-    network_technology_ = network_technology;
-  }
-  void set_roaming_state(NetworkRoamingState roaming_state) {
-    roaming_state_ = roaming_state;
-  }
-  void set_operator_name(const std::string& operator_name) {
-    operator_name_ = operator_name;
-  }
-  void set_operator_code(const std::string& operator_code) {
-    operator_code_ = operator_code;
-  }
-  void set_operator_country(const std::string& operator_country) {
-    operator_country_ = operator_country;
-  }
-  void set_out_of_credits(bool out_of_credits) {
-    out_of_credits_ = out_of_credits;
-  }
-  void set_payment_url(const std::string& payment_url) {
-    payment_url_ = payment_url;
-  }
-  void set_post_data(const std::string& post_data) {
-    post_data_ = post_data;
-  }
-  void set_using_post(bool using_post) {
-    using_post_ = using_post;
-  }
-  void set_usage_url(const std::string& usage_url) { usage_url_ = usage_url; }
-  void set_apn(const base::DictionaryValue& apn) { apn_.Set(apn); }
-  void set_last_good_apn(const base::DictionaryValue& last_good_apn) {
-    last_good_apn_.Set(last_good_apn);
-  }
-
-  bool activate_over_non_cellular_network_;
-  bool out_of_credits_;
-  ActivationState activation_state_;
-  NetworkTechnology network_technology_;
-  NetworkRoamingState roaming_state_;
-  // Carrier Info
-  std::string operator_name_;
-  std::string operator_code_;
-  std::string operator_country_;
-  std::string payment_url_;
-  std::string usage_url_;
-  std::string post_data_;
-  bool using_post_;
-  // Cached values
-  CellularApn apn_;
-  CellularApn last_good_apn_;
-
-  DISALLOW_COPY_AND_ASSIGN(CellularNetwork);
-};
-typedef std::vector<CellularNetwork*> CellularNetworkVector;
-
-// Class for networks of TYPE_WIFI.
-class WifiNetwork : public WirelessNetwork {
- public:
-  // Test API for accessing setters in tests.
-  class TestApi {
-   public:
-    explicit TestApi(WifiNetwork* network) : network_(network) {}
-    void SetEncryption(ConnectionSecurity encryption) {
-      network_->set_encryption(encryption);
-    }
-    void SetSsid(const std::string& ssid) {
-      network_->SetSsid(ssid);
-    }
-    void SetHexSsid(const std::string& ssid_hex) {
-      network_->SetHexSsid(ssid_hex);
-    }
-   private:
-    WifiNetwork* network_;
-  };
-  friend class TestApi;
-
-  explicit WifiNetwork(const std::string& service_path);
-  virtual ~WifiNetwork();
-
-  bool encrypted() const { return encryption_ != SECURITY_NONE; }
-  ConnectionSecurity encryption() const { return encryption_; }
-  const std::string& passphrase() const { return passphrase_; }
-  const std::string& identity() const { return identity_; }
-  bool passphrase_required() const { return passphrase_required_; }
-  bool hidden_ssid() const { return hidden_ssid_; }
-  const std::string& bssid() const { return bssid_; }
-  int frequency() const { return frequency_; }
-
-  EAPMethod eap_method() const { return eap_method_; }
-  EAPPhase2Auth eap_phase_2_auth() const { return eap_phase_2_auth_; }
-  const std::string& eap_server_ca_cert_pem() const {
-    return eap_server_ca_cert_pem_; }
-  const std::string& eap_client_cert_pkcs11_id() const {
-    return eap_client_cert_pkcs11_id_; }
-  const bool eap_use_system_cas() const { return eap_use_system_cas_; }
-  const std::string& eap_identity() const { return eap_identity_; }
-  const std::string& eap_anonymous_identity() const {
-    return eap_anonymous_identity_;
-  }
-  const std::string& eap_passphrase() const { return eap_passphrase_; }
-  const bool eap_save_credentials() const { return eap_save_credentials_; }
-
-  const std::string& GetPassphrase() const;
-
-  // Set property and call SetNetworkServiceProperty:
-
-  void SetPassphrase(const std::string& passphrase);
-
-  // 802.1x properties
-  void SetEAPMethod(EAPMethod method);
-  void SetEAPPhase2Auth(EAPPhase2Auth auth);
-  void SetEAPServerCaCertPEM(const std::string& ca_cert_pem);
-  void SetEAPClientCertPkcs11Id(const std::string& pkcs11_id);
-  void SetEAPUseSystemCAs(bool use_system_cas);
-  void SetEAPIdentity(const std::string& identity);
-  void SetEAPAnonymousIdentity(const std::string& identity);
-  void SetEAPPassphrase(const std::string& passphrase);
-
-  // Sets the well-known PKCS#11 PIN for accessing certificates.
-  void SetCertificatePin(const std::string& pin);
-
-  // Network overrides.
-  virtual bool RequiresUserProfile() const OVERRIDE;
-  virtual void AttemptConnection(const base::Closure& connect) OVERRIDE;
-
-  // Return a string representation of the encryption code.
-  // This not translated and should be only used for debugging purposes.
-  std::string GetEncryptionString() const;
-
-  // Return true if a passphrase or other input is required to connect.
-  bool IsPassphraseRequired() const;
-
- protected:
-   // This allows NativeWifiNetworkParser access to device privates so
-  // that they can be reconstituted during parsing.  The parsers only
-  // access things through the private set_ functions so that this
-  // class can evolve without having to change all the parsers.
-  friend class NativeWifiNetworkParser;
-
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  // Use these functions at your peril.  They are used by the various
-  // parsers to set state, and really shouldn't be used by anything else
-  // because they don't do the error checking and sending to the
-  // network layer that the other setters do.
-
-  bool SetSsid(const std::string& ssid);
-  bool SetHexSsid(const std::string& ssid_hex);
-
-  void set_encryption(ConnectionSecurity encryption) {
-    encryption_ = encryption;
-  }
-  void set_passphrase(const std::string& passphrase) {
-    passphrase_ = passphrase;
-    user_passphrase_ = passphrase;
-  }
-  void set_passphrase_required(bool passphrase_required) {
-    passphrase_required_ = passphrase_required;
-  }
-  void set_identity(const std::string& identity) {
-    identity_ = identity;
-  }
-  void set_hidden_ssid(bool hidden_ssid) {
-    hidden_ssid_ = hidden_ssid;
-  }
-  void set_bssid(const std::string& bssid) { bssid_ = bssid; }
-  void set_frequency(int frequency) { frequency_ = frequency; }
-  void set_eap_method(EAPMethod eap_method) { eap_method_ = eap_method; }
-  void set_eap_phase_2_auth(EAPPhase2Auth eap_phase_2_auth) {
-    eap_phase_2_auth_ = eap_phase_2_auth;
-  }
-  void set_eap_server_ca_cert_pem(const std::string& eap_server_ca_cert_pem) {
-    eap_server_ca_cert_pem_ = eap_server_ca_cert_pem;
-  }
-  void set_eap_client_cert_pkcs11_id(
-      const std::string& eap_client_cert_pkcs11_id) {
-    eap_client_cert_pkcs11_id_ = eap_client_cert_pkcs11_id;
-  }
-  void set_eap_use_system_cas(bool eap_use_system_cas) {
-    eap_use_system_cas_ = eap_use_system_cas;
-  }
-  void set_eap_identity(const std::string& eap_identity) {
-    eap_identity_ = eap_identity;
-  }
-  void set_eap_anonymous_identity(const std::string& eap_anonymous_identity) {
-    eap_anonymous_identity_ = eap_anonymous_identity;
-  }
-  void set_eap_passphrase(const std::string& eap_passphrase) {
-    eap_passphrase_ = eap_passphrase;
-  }
-  void set_eap_save_credentials(bool save_credentials) {
-    eap_save_credentials_ = save_credentials;
-  }
-
-  // Matches the client certificate pattern by checking to see if a certificate
-  // exists that meets the pattern criteria. If it finds one, it sets the
-  // appropriate network property. If not, it passes |connect| to the
-  // EnrollmentDelegate to do something with the enrollment URI (e.g. launch a
-  // dialog) to install the certificate, and then invoke |connect|. If
-  // |allow_enroll| is false, then the enrollment handler will not be invoked in
-  // the case of a missing certificate.
-  void MatchCertificatePattern(bool allow_enroll, const base::Closure& connect);
-
-  // Network overrides.
-  virtual void EraseCredentials() OVERRIDE;
-  virtual void CalculateUniqueId() OVERRIDE;
-
-  ConnectionSecurity encryption_;
-  std::string passphrase_;
-  bool passphrase_required_;
-  std::string identity_;
-  bool hidden_ssid_;
-  std::string bssid_;
-  int frequency_;
-
-  EAPMethod eap_method_;
-  EAPPhase2Auth eap_phase_2_auth_;
-  std::string eap_server_ca_cert_pem_;
-  std::string eap_client_cert_pkcs11_id_;
-  bool eap_use_system_cas_;
-  std::string eap_identity_;
-  std::string eap_anonymous_identity_;
-  std::string eap_passphrase_;
-  bool eap_save_credentials_;
-
-  // Internal state (not stored in shill).
-  // Passphrase set by user (stored for UI).
-  std::string user_passphrase_;
-
-  // Weak pointer factory for wrapping pointers to this network in callbacks.
-  base::WeakPtrFactory<WifiNetwork> weak_pointer_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(WifiNetwork);
-};
-
-typedef std::vector<WifiNetwork*> WifiNetworkVector;
-
-
-// Class for networks of TYPE_WIMAX.
-class WimaxNetwork : public WirelessNetwork {
- public:
-  explicit WimaxNetwork(const std::string& service_path);
-  virtual ~WimaxNetwork();
-
-  bool passphrase_required() const { return passphrase_required_; }
-  const std::string& eap_identity() const { return eap_identity_; }
-  const std::string& eap_passphrase() const { return eap_passphrase_; }
-
-  void SetEAPIdentity(const std::string& identity);
-  void SetEAPPassphrase(const std::string& passphrase);
-
- protected:
-  // This allows NativeWimaxNetworkParser access to device privates so
-  // that they can be reconstituted during parsing.  The parsers only
-  // access things through the private set_ functions so that this
-  // class can evolve without having to change all the parsers.
-  friend class NativeWimaxNetworkParser;
-
-  // This allows the implementation classes access to privates.
-  NETWORK_LIBRARY_IMPL_FRIENDS;
-
-  void set_eap_identity(const std::string& identity) {
-    eap_identity_ = identity;
-  }
-  void set_eap_passphrase(const std::string& passphrase) {
-    eap_passphrase_ = passphrase;
-  }
-  void set_passphrase_required(bool passphrase_required) {
-    passphrase_required_ = passphrase_required;
-  }
-
-  // Network overrides.
-  virtual void EraseCredentials() OVERRIDE;
-  virtual void CalculateUniqueId() OVERRIDE;
-
-  bool passphrase_required_;
-  std::string eap_identity_;
-  std::string eap_passphrase_;
-
-  DISALLOW_COPY_AND_ASSIGN(WimaxNetwork);
-};
-
-typedef std::vector<WimaxNetwork*> WimaxNetworkVector;
-
-// Geolocation data.
-struct CellTower {
-  CellTower();
-
-  enum RadioType {
-    RADIOTYPE_GSM,
-    RADIOTYPE_CDMA,
-    RADIOTYPE_WCDMA,
-  } radio_type;                   // GSM/WCDMA     CDMA
-  int mobile_country_code;        //   MCC          MCC
-  int mobile_network_code;        //   MNC          SID
-  int location_area_code;         //   LAC          NID
-  int cell_id;                    //   CID          BID
-  base::Time timestamp;  // Timestamp when this cell was primary
-  int signal_strength;   // Radio signal strength measured in dBm.
-  int timing_advance;    // Represents the distance from the cell tower.
-                         // Each unit is roughly 550 meters.
-};
-
-typedef std::vector<CellTower> CellTowerVector;
-
-// This class handles the interaction with the ChromeOS network library APIs.
-// Classes can add themselves as observers. Users can get an instance of the
-// library like this: chromeos::NetworkLibrary::Get()
-class NetworkLibrary {
- public:
-  enum HardwareAddressFormat {
-    FORMAT_RAW_HEX,
-    FORMAT_COLON_SEPARATED_HEX
-  };
-
-  // Used to configure which IP parameters will be specified by DHCP and which
-  // will be set by the user.
-  enum UseDHCP {
-    USE_DHCP_ADDRESS      = 0x1,
-    USE_DHCP_NETMASK      = 0x1 << 1,
-    USE_DHCP_GATEWAY      = 0x1 << 2,
-    USE_DHCP_NAME_SERVERS = 0x1 << 3,
-    USE_DHCP_ALL_ROUTING_INFO =
-        (USE_DHCP_ADDRESS |
-         USE_DHCP_NETMASK |
-         USE_DHCP_GATEWAY),
-  };
-
-  class NetworkProfileObserver {
-   public:
-    // Called when the list of network profiles was changed.
-    virtual void OnProfileListChanged() = 0;
-   protected:
-    virtual ~NetworkProfileObserver() {}
-  };
-
-  class NetworkManagerObserver {
-   public:
-    // Called when the state of the network manager has changed,
-    // for example, networks have appeared or disappeared.
-    virtual void OnNetworkManagerChanged(NetworkLibrary* obj) = 0;
-   protected:
-    virtual ~NetworkManagerObserver() {}
-  };
-
-  class NetworkObserver {
-   public:
-    // Called when the state of a single network has changed,
-    // for example signal strength or connection state.
-    virtual void OnNetworkChanged(NetworkLibrary* cros,
-                                  const Network* network) = 0;
-   protected:
-    virtual ~NetworkObserver() {}
-  };
-
-  class NetworkDeviceObserver {
-   public:
-    // Called when |device| got notification about new networks available.
-    virtual void OnNetworkDeviceFoundNetworks(NetworkLibrary* cros,
-                                              const NetworkDevice* device) {}
-
-    // Called when |device| got notification about SIM lock change.
-    virtual void OnNetworkDeviceSimLockChanged(NetworkLibrary* cros,
-                                               const NetworkDevice* device) {}
-   protected:
-    virtual ~NetworkDeviceObserver() {}
-  };
-
-  class PinOperationObserver {
-   public:
-    // Called when pin async operation has completed.
-    // Network is NULL when we don't have an associated Network object.
-    virtual void OnPinOperationCompleted(NetworkLibrary* cros,
-                                         PinOperationError error) = 0;
-   protected:
-    virtual ~PinOperationObserver() {}
-  };
-
-  virtual ~NetworkLibrary() {}
-
-  virtual void Init() = 0;
-
-  // Returns true if libcros was loaded instead of stubbed out.
-  virtual bool IsCros() const = 0;
-
-  virtual void AddNetworkProfileObserver(NetworkProfileObserver* observer) = 0;
-  virtual void RemoveNetworkProfileObserver(
-      NetworkProfileObserver* observer) = 0;
-
-  virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) = 0;
-  virtual void RemoveNetworkManagerObserver(
-      NetworkManagerObserver* observer) = 0;
-
-  // An attempt to add an observer that has already been added for a
-  // give service path will be ignored.
-  virtual void AddNetworkObserver(const std::string& service_path,
-                                  NetworkObserver* observer) = 0;
-  // Remove an observer of a single network
-  virtual void RemoveNetworkObserver(const std::string& service_path,
-                                     NetworkObserver* observer) = 0;
-  // Stop |observer| from observing any networks
-  virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) = 0;
-
-  // Add an observer for a single network device.
-  virtual void AddNetworkDeviceObserver(const std::string& device_path,
-                                        NetworkDeviceObserver* observer) = 0;
-  // Remove an observer for a single network device.
-  virtual void RemoveNetworkDeviceObserver(const std::string& device_path,
-                                           NetworkDeviceObserver* observer) = 0;
-
-  virtual void AddPinOperationObserver(PinOperationObserver* observer) = 0;
-  virtual void RemovePinOperationObserver(PinOperationObserver* observer) = 0;
-
-  // Return the active or default Ethernet network (or NULL if none).
-  virtual const EthernetNetwork* ethernet_network() const = 0;
-  virtual bool ethernet_connecting() const = 0;
-  virtual bool ethernet_connected() const = 0;
-
-  // Return the active Wifi network (or NULL if none active).
-  virtual const WifiNetwork* wifi_network() const = 0;
-  virtual bool wifi_connecting() const = 0;
-  virtual bool wifi_connected() const = 0;
-
-  // Return the active Cellular network (or NULL if none active).
-  virtual const CellularNetwork* cellular_network() const = 0;
-  virtual bool cellular_connecting() const = 0;
-  virtual bool cellular_connected() const = 0;
-
-  // Return the active Wimax network (or NULL if none active).
-  virtual const WimaxNetwork* wimax_network() const = 0;
-  virtual bool wimax_connecting() const = 0;
-  virtual bool wimax_connected() const = 0;
-
-  // Return the active virtual network (or NULL if none active).
-  virtual const VirtualNetwork* virtual_network() const = 0;
-  virtual bool virtual_network_connecting() const = 0;
-  virtual bool virtual_network_connected() const = 0;
-
-  // Return true if any network is currently connected.
-  virtual bool Connected() const = 0;
-
-  // Return true if any network is currently connecting.
-  virtual bool Connecting() const = 0;
-
-  // Returns the current list of wifi networks.
-  virtual const WifiNetworkVector& wifi_networks() const = 0;
-
-  // Returns the list of remembered wifi networks.
-  virtual const WifiNetworkVector& remembered_wifi_networks() const = 0;
-
-  // Returns the current list of cellular networks.
-  virtual const CellularNetworkVector& cellular_networks() const = 0;
-
-  // Returns the current list of Wimax networks.
-  virtual const WimaxNetworkVector& wimax_networks() const = 0;
-
-  // Returns the current list of virtual networks.
-  virtual const VirtualNetworkVector& virtual_networks() const = 0;
-
-  // Returns the current list of virtual networks.
-  virtual const VirtualNetworkVector& remembered_virtual_networks() const = 0;
-
-  virtual const Network* active_network() const = 0;
-  virtual const Network* active_nonvirtual_network() const = 0;
-  virtual const Network* connected_network() const = 0;
-  virtual const Network* connecting_network() const = 0;
-
-  virtual bool ethernet_available() const = 0;
-  virtual bool wifi_available() const = 0;
-  virtual bool wimax_available() const = 0;
-  virtual bool cellular_available() const = 0;
-
-  virtual bool ethernet_enabled() const = 0;
-  virtual bool wifi_enabled() const = 0;
-  virtual bool wimax_enabled() const = 0;
-  virtual bool cellular_enabled() const = 0;
-
-  virtual bool wifi_scanning() const = 0;
-  virtual bool cellular_initializing() const = 0;
-
-  // Return a pointer to the device, if it exists, or NULL.
-  virtual const NetworkDevice* FindNetworkDeviceByPath(
-      const std::string& path) const = 0;
-
-  // Returns device with TYPE_CELLULAR or TYPE_WIMAX.
-  // Returns NULL if none exists.
-  virtual const NetworkDevice* FindMobileDevice() const = 0;
-
-  // Returns device with TYPE_CELLULAR. Returns NULL if none exists.
-  virtual const NetworkDevice* FindCellularDevice() const = 0;
-
-  // Return a pointer to the network, if it exists, or NULL.
-  // NOTE: Never store these results, store service paths instead.
-  // The pattern for doing an operation on a Network is:
-  // Network* network = cros->FindNetworkByPath(service_path);
-  // network->SetFoo();
-  // network->Connect();
-  // As long as this is done in sequence on the UI thread it will be safe;
-  // the network list only gets updated on the UI thread.
-  virtual Network* FindNetworkByPath(const std::string& path) const = 0;
-  virtual Network* FindNetworkByUniqueId(
-      const std::string& unique_id) const = 0;
-  virtual WifiNetwork* FindWifiNetworkByPath(const std::string& path) const = 0;
-  virtual CellularNetwork* FindCellularNetworkByPath(
-      const std::string& path) const = 0;
-  virtual WimaxNetwork* FindWimaxNetworkByPath(
-      const std::string& path) const = 0;
-  virtual VirtualNetwork* FindVirtualNetworkByPath(
-      const std::string& path) const = 0;
-
-  // Return a pointer to the remembered network, if it exists, or NULL.
-  virtual Network* FindRememberedNetworkByPath(
-      const std::string& path) const = 0;
-
-  // Return a pointer to the ONC dictionary for a network identified by unique
-  // ID. Returns NULL if there is no ONC dictionary available for that network.
-  // The ONC dictionary is usually only present for policy-configure networks
-  // which get reconfigured at startup.
-  virtual const base::DictionaryValue* FindOncForNetwork(
-      const std::string& unique_id) const = 0;
-
-  // Records information that cellular plan payment has happened.
-  virtual void SignalCellularPlanPayment() = 0;
-
-  // Returns true if cellular plan payment has been recorded recently.
-  virtual bool HasRecentCellularPlanPayment() = 0;
-
-  // Returns home carrier ID if available, otherwise empty string is returned.
-  // Carrier ID format: <carrier name> (country). Ex.: "Verizon (us)".
-  virtual const std::string& GetCellularHomeCarrierId() const = 0;
-
-  // Checks if the current cellular device should be activated by directly
-  // calling it's activate function instead of going through the activation
-  // process.
-  // Note: Currently Sprint is the only carrier using direct activation.
-  virtual bool CellularDeviceUsesDirectActivation() const = 0;
-
-  // Passes |old_pin|, |new_pin| to change SIM card PIM.
-  virtual void ChangePin(const std::string& old_pin,
-                         const std::string& new_pin) = 0;
-
-  // Passes |pin|, |require_pin| value to change SIM card RequirePin setting.
-  virtual void ChangeRequirePin(bool require_pin,
-                                const std::string& pin) = 0;
-
-  // Passes |pin| to unlock SIM card.
-  virtual void EnterPin(const std::string& pin) = 0;
-
-  // Passes |puk|, |new_pin| to unblock SIM card.
-  virtual void UnblockPin(const std::string& puk,
-                          const std::string& new_pin) = 0;
-
-  // Request a scan for available cellular networks.
-  virtual void RequestCellularScan() = 0;
-
-  // Request a register in cellular network with |network_id|.
-  virtual void RequestCellularRegister(const std::string& network_id) = 0;
-
-  // Change data roaming restriction for current cellular device.
-  virtual void SetCellularDataRoamingAllowed(bool new_value) = 0;
-
-  // Changes the active cellular carrier to the one provided, calls the closure
-  // once the transition is complete.
-  virtual void SetCarrier(const std::string& carrier,
-                          const NetworkOperationCallback& completed) = 0;
-
-  // Return true if GSM SIM card can work only with enabled roaming.
-  virtual bool IsCellularAlwaysInRoaming() = 0;
-
-  // Request a scan for new wifi networks.
-  virtual void RequestNetworkScan() = 0;
-
-  // TODO(joth): Add GetCellTowers to retrieve a CellTowerVector.
-
-  // Returns false if there is no way to connect to this network, even with
-  // user input (e.g. it requires a user profile but none is available).
-  virtual bool CanConnectToNetwork(const Network* network) const = 0;
-
-  // Connect to the specified wireless network.
-  virtual void ConnectToWifiNetwork(WifiNetwork* network) = 0;
-
-  // Connect to the specified wireless network and set its profile
-  // to SHARED if |shared| is true, otherwise to USER.
-  virtual void ConnectToWifiNetwork(WifiNetwork* network, bool shared) = 0;
-
-  // Connect to the specified cellular network.
-  virtual void ConnectToCellularNetwork(CellularNetwork* network) = 0;
-
-  // Connect to the specified WiMAX network.
-  virtual void ConnectToWimaxNetwork(WimaxNetwork* network) = 0;
-
-  // Connect to the specified WiMAX network and set its profile
-  // to SHARED if |shared| is true, otherwise to USER.
-  virtual void ConnectToWimaxNetwork(WimaxNetwork* network, bool shared) = 0;
-
-  // Connect to the specified virtual network.
-  virtual void ConnectToVirtualNetwork(VirtualNetwork* network) = 0;
-
-  // Connect to an unconfigured network with given SSID, security, passphrase,
-  // and optional EAP configuration. If |security| is SECURITY_8021X,
-  // |eap_config| must be provided.
-  struct EAPConfigData {
-    EAPConfigData();
-    ~EAPConfigData();
-    EAPMethod method;
-    EAPPhase2Auth auth;
-    std::string server_ca_cert_pem;
-    bool use_system_cas;
-    std::string client_cert_pkcs11_id;
-    std::string identity;
-    std::string anonymous_identity;
-  };
-  virtual void ConnectToUnconfiguredWifiNetwork(
-      const std::string& ssid,
-      ConnectionSecurity security,
-      const std::string& passphrase,
-      const EAPConfigData* eap_config,
-      bool save_credentials,
-      bool shared) = 0;
-
-  // Connect to the specified virtual network with service name.
-  // VPNConfigData must be provided.
-  struct VPNConfigData {
-    VPNConfigData();
-    ~VPNConfigData();
-    std::string psk;
-    std::string server_ca_cert_pem;
-    std::string client_cert_pkcs11_id;
-    std::string username;
-    std::string user_passphrase;
-    std::string otp;
-    std::string group_name;
-    bool save_credentials;
-  };
-  virtual void ConnectToUnconfiguredVirtualNetwork(
-      const std::string& service_name,
-      const std::string& server_hostname,
-      ProviderType provider_type,
-      const VPNConfigData& config) = 0;
-
-  // Disconnect from the specified network.
-  virtual void DisconnectFromNetwork(const Network* network) = 0;
-
-  // Forget the network corresponding to service_path.
-  virtual void ForgetNetwork(const std::string& service_path) = 0;
-
-  // Enables/disables the ethernet network device.
-  virtual void EnableEthernetNetworkDevice(bool enable) = 0;
-
-  // Enables/disables the wifi network device.
-  virtual void EnableWifiNetworkDevice(bool enable) = 0;
-
-  // Enables/disables the wimax network device.
-  virtual void EnableWimaxNetworkDevice(bool enable) = 0;
-
-  // Enables/disables the cellular network device.
-  virtual void EnableCellularNetworkDevice(bool enable) = 0;
-
-  // Fetches IP configs and hardware address for a given device_path and returns
-  // them via the given callback.
-  virtual void GetIPConfigs(const std::string& device_path,
-                            HardwareAddressFormat format,
-                            const NetworkGetIPConfigsCallback& callback) = 0;
-
-  // Sets the configuration of the IP parameters. This is called when user
-  // changes IP settings from dhcp to static or vice versa or when user changes
-  // the ip config info. If nothing is changed, this method does nothing.
-  // |dhcp_usage_mask| is a bitmask composed of items from the UseDHCP enum, and
-  // indicates which of the supplied values are overridden by values given by
-  // the default IP acquisition technique for the service (DHCP, usually).
-  virtual void SetIPParameters(const std::string& service_path,
-                               const std::string& address,
-                               const std::string& netmask,
-                               const std::string& gateway,
-                               const std::string& name_servers,
-                               int dhcp_usage_mask) = 0;
-
-  // Requests the service properties associated with |service_path|. Calls
-  // |callback| with the properties when competed.
-  typedef base::Callback<void(const std::string& service_path,
-                              const base::DictionaryValue* properties)>
-      NetworkServicePropertiesCallback;
-  virtual void RequestNetworkServiceProperties(
-      const std::string& service_path,
-      const NetworkServicePropertiesCallback& callback) = 0;
-
-  // Load networks from a list of NetworkConfigurations of ONC.
-  virtual void LoadOncNetworks(const base::ListValue& network_configs,
-                               onc::ONCSource source) = 0;
-
-  // This sets the active network for the network type. Note: priority order
-  // is unchanged (i.e. if a wifi network is set to active, but an ethernet
-  // network is still active, active_network() will still return the ethernet
-  // network). Other networks of the same type will become inactive.
-  // Used for testing.
-  virtual bool SetActiveNetwork(ConnectionType type,
-                                const std::string& service_path) = 0;
-
-  // Factory function, creates a new instance and returns ownership.
-  // For normal usage, access the singleton via NetworkLibrary::Get().
-  static NetworkLibrary* GetImpl(bool stub);
-
-  // Initializes the global instance.
-  static void Initialize(bool use_stub);
-
-  // Destroys the global instance. Must be called before AtExitManager is
-  // destroyed to ensure a clean shutdown.
-  static void Shutdown();
-
-  // Gets the global instance. Returns NULL if Initialize() has not been
-  // called (or Shutdown() has been called).
-  static NetworkLibrary* Get();
-
-  // Sets the network library to be returned from Get(). The existing network
-  // library will be deleted.
-  static void SetForTesting(NetworkLibrary* network_library);
-};
-
-// The class is used for enabling the stub libcros, and cleaning it up at
-// the end of the object lifetime. Useful for testing.
-class ScopedStubNetworkLibraryEnabler {
- public:
-  ScopedStubNetworkLibraryEnabler() {
-    NetworkLibrary::Initialize(true);
-  }
-
-  ~ScopedStubNetworkLibraryEnabler() {
-    NetworkLibrary::Shutdown();
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedStubNetworkLibraryEnabler);
-};
-
-}  // namespace chromeos
-
-#endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_