This factors out all of the parsing code from the network library

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/cros/network_library.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/utf_string_conversion_utils.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/native_network_constants.h"
+#include "chrome/browser/chromeos/cros/native_network_parser.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/network_login_observer.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/common/time_format.h"
 #include "content/browser/browser_thread.h"
 #include "crypto/nss_util.h"  // crypto::GetTPMTokenInfo() for 802.1X and VPN.
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/bytes_formatting.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementation notes.
 // NetworkLibraryImpl manages a series of classes that describe network devices
 // and services:
 //
 // NetworkDevice: e.g. ethernet, wifi modem, cellular modem
-//  device_map_: canonical map<path,NetworkDevice*> for devices
+//  device_map_: canonical map<path, NetworkDevice*> for devices
 //
 // Network: a network service ("network").
-//  network_map_: canonical map<path,Network*> for all visible networks.
+//  network_map_: canonical map<path, Network*> for all visible networks.
 //  EthernetNetwork
 //   ethernet_: EthernetNetwork* to the active ethernet network in network_map_.
 //  WirelessNetwork: a WiFi or Cellular Network.
 //  WifiNetwork
 //   active_wifi_: WifiNetwork* to the active wifi network in network_map_.
 //   wifi_networks_: ordered vector of WifiNetwork* entries in network_map_,
 //       in descending order of importance.
 //  CellularNetwork
 //   active_cellular_: Cellular version of wifi_.
 //   cellular_networks_: Cellular version of wifi_.
-// network_unique_id_map_: map<unique_id,Network*> for visible networks.
-// remembered_network_map_: a canonical map<path,Network*> for all networks
+// network_unique_id_map_: map<unique_id, Network*> for visible networks.
+// remembered_network_map_: a canonical map<path, Network*> for all networks
 //     remembered in the active Profile ("favorites").
 // remembered_wifi_networks_: ordered vector of WifiNetwork* entries in
 //     remembered_network_map_, in descending order of preference.
 // remembered_virtual_networks_: ordered vector of VirtualNetwork* entries in
 //     remembered_network_map_, in descending order of preference.
 //
 // network_manager_monitor_: a handle to the libcros network Manager handler.
 // NetworkManagerStatusChanged: This handles all messages from the Manager.
 //   Messages are parsed here and the appropriate updates are then requested.
 //
@@ skipping 28 matching lines @@
 const int kNetworkNotifyDelayMs = 50;
 
 // How long we should remember that cellular plan payment was received.
 const int kRecentPlanPaymentHours = 6;
 
 // Default value of the SIM unlock retries count. It is updated to the real
 // retries count once cellular device with SIM card is initialized.
 // If cellular device doesn't have SIM card, then retries are never used.
 const int kDefaultSimUnlockRetriesCount = 999;
 
-// Format of the Carrier ID: <carrier name> (<carrier country>).
-const char kCarrierIdFormat[] = "%s (%s)";
-
-// Path of the default (shared) flimflam profile.
-const char kSharedProfilePath[] = "/profile/default";
-
-// Type of a pending SIM operation.
-enum SimOperationType {
-  SIM_OPERATION_NONE               = 0,
-  SIM_OPERATION_CHANGE_PIN         = 1,
-  SIM_OPERATION_CHANGE_REQUIRE_PIN = 2,
-  SIM_OPERATION_ENTER_PIN          = 3,
-  SIM_OPERATION_UNBLOCK_PIN        = 4,
-};
-
-// D-Bus interface string constants.
-
-// Flimflam manager properties.
-const char kAvailableTechnologiesProperty[] = "AvailableTechnologies";
-const char kEnabledTechnologiesProperty[] = "EnabledTechnologies";
-const char kConnectedTechnologiesProperty[] = "ConnectedTechnologies";
-const char kDefaultTechnologyProperty[] = "DefaultTechnology";
-const char kOfflineModeProperty[] = "OfflineMode";
-const char kActiveProfileProperty[] = "ActiveProfile";
-const char kProfilesProperty[] = "Profiles";
-const char kServicesProperty[] = "Services";
-const char kServiceWatchListProperty[] = "ServiceWatchList";
-const char kDevicesProperty[] = "Devices";
-const char kPortalURLProperty[] = "PortalURL";
-const char kCheckPortalListProperty[] = "CheckPortalList";
-
-// Flimflam service properties.
-const char kSecurityProperty[] = "Security";
-const char kPassphraseProperty[] = "Passphrase";
-const char kIdentityProperty[] = "Identity";
-const char kPassphraseRequiredProperty[] = "PassphraseRequired";
-const char kSaveCredentialsProperty[] = "SaveCredentials";
-const char kSignalStrengthProperty[] = "Strength";
-const char kNameProperty[] = "Name";
-const char kStateProperty[] = "State";
-const char kTypeProperty[] = "Type";
-const char kDeviceProperty[] = "Device";
-const char kProfileProperty[] = "Profile";
-const char kTechnologyFamilyProperty[] = "Cellular.Family";
-const char kActivationStateProperty[] = "Cellular.ActivationState";
-const char kNetworkTechnologyProperty[] = "Cellular.NetworkTechnology";
-const char kRoamingStateProperty[] = "Cellular.RoamingState";
-const char kOperatorNameProperty[] = "Cellular.OperatorName";
-const char kOperatorCodeProperty[] = "Cellular.OperatorCode";
-const char kServingOperatorProperty[] = "Cellular.ServingOperator";
-const char kPaymentURLProperty[] = "Cellular.OlpUrl";
-const char kUsageURLProperty[] = "Cellular.UsageUrl";
-const char kCellularApnProperty[] = "Cellular.APN";
-const char kCellularLastGoodApnProperty[] = "Cellular.LastGoodAPN";
-const char kCellularApnListProperty[] = "Cellular.APNList";
-const char kWifiHexSsid[] = "WiFi.HexSSID";
-const char kWifiFrequency[] = "WiFi.Frequency";
-const char kWifiHiddenSsid[] = "WiFi.HiddenSSID";
-const char kWifiPhyMode[] = "WiFi.PhyMode";
-const char kWifiAuthMode[] = "WiFi.AuthMode";
-const char kFavoriteProperty[] = "Favorite";
-const char kConnectableProperty[] = "Connectable";
-const char kPriorityProperty[] = "Priority";
-const char kAutoConnectProperty[] = "AutoConnect";
-const char kIsActiveProperty[] = "IsActive";
-const char kModeProperty[] = "Mode";
-const char kErrorProperty[] = "Error";
-const char kEntriesProperty[] = "Entries";
-const char kProviderProperty[] = "Provider";
-const char kHostProperty[] = "Host";
-const char kProxyConfigProperty[] = "ProxyConfig";
-
-// Flimflam property names for SIMLock status.
-const char kSIMLockStatusProperty[] = "Cellular.SIMLockStatus";
-const char kSIMLockTypeProperty[] = "LockType";
-const char kSIMLockRetriesLeftProperty[] = "RetriesLeft";
-
-// Flimflam property names for Cellular.FoundNetworks.
-const char kLongNameProperty[] = "long_name";
-const char kStatusProperty[] = "status";
-const char kShortNameProperty[] = "short_name";
-const char kTechnologyProperty[] = "technology";
-const char kNetworkIdProperty[] = "network_id";
-
-// Flimflam SIMLock status types.
-const char kSIMLockPin[] = "sim-pin";
-const char kSIMLockPuk[] = "sim-puk";
-
-// APN info property names.
-const char kApnProperty[] = "apn";
-const char kApnNetworkIdProperty[] = "network_id";
-const char kApnUsernameProperty[] = "username";
-const char kApnPasswordProperty[] = "password";
-const char kApnNameProperty[] = "name";
-const char kApnLocalizedNameProperty[] = "localized_name";
-const char kApnLanguageProperty[] = "language";
-
-// Operator info property names.
-const char kOperatorNameKey[] = "name";
-const char kOperatorCodeKey[] = "code";
-const char kOperatorCountryKey[] = "country";
-
-// Flimflam device info property names.
-const char kScanningProperty[] = "Scanning";
-const char kPoweredProperty[] = "Powered";
-const char kNetworksProperty[] = "Networks";
-const char kCarrierProperty[] = "Cellular.Carrier";
-const char kCellularAllowRoamingProperty[] = "Cellular.AllowRoaming";
-const char kHomeProviderProperty[] = "Cellular.HomeProvider";
-const char kMeidProperty[] = "Cellular.MEID";
-const char kImeiProperty[] = "Cellular.IMEI";
-const char kImsiProperty[] = "Cellular.IMSI";
-const char kEsnProperty[] = "Cellular.ESN";
-const char kMdnProperty[] = "Cellular.MDN";
-const char kMinProperty[] = "Cellular.MIN";
-const char kModelIDProperty[] = "Cellular.ModelID";
-const char kManufacturerProperty[] = "Cellular.Manufacturer";
-const char kFirmwareRevisionProperty[] = "Cellular.FirmwareRevision";
-const char kHardwareRevisionProperty[] = "Cellular.HardwareRevision";
-const char kPRLVersionProperty[] = "Cellular.PRLVersion"; // (INT16)
-const char kSelectedNetworkProperty[] = "Cellular.SelectedNetwork";
-const char kSupportNetworkScanProperty[] = "Cellular.SupportNetworkScan";
-const char kFoundNetworksProperty[] = "Cellular.FoundNetworks";
-
-// Flimflam ip config property names.
-const char kAddressProperty[] = "Address";
-const char kPrefixlenProperty[] = "Prefixlen";
-const char kGatewayProperty[] = "Gateway";
-const char kNameServersProperty[] = "NameServers";
-
-// Flimflam type options.
-const char kTypeEthernet[] = "ethernet";
-const char kTypeWifi[] = "wifi";
-const char kTypeWimax[] = "wimax";
-const char kTypeBluetooth[] = "bluetooth";
-const char kTypeCellular[] = "cellular";
-const char kTypeVPN[] = "vpn";
-
-// Flimflam mode options.
-const char kModeManaged[] = "managed";
-const char kModeAdhoc[] = "adhoc";
-
-// Flimflam security options.
-const char kSecurityWpa[] = "wpa";
-const char kSecurityWep[] = "wep";
-const char kSecurityRsn[] = "rsn";
-const char kSecurity8021x[] = "802_1x";
-const char kSecurityPsk[] = "psk";
-const char kSecurityNone[] = "none";
-
-// Flimflam L2TPIPsec property names.
-const char kL2TPIPSecCACertNSSProperty[] = "L2TPIPsec.CACertNSS";
-const char kL2TPIPSecClientCertIDProperty[] = "L2TPIPsec.ClientCertID";
-const char kL2TPIPSecClientCertSlotProp[] = "L2TPIPsec.ClientCertSlot";
-const char kL2TPIPSecPINProperty[] = "L2TPIPsec.PIN";
-const char kL2TPIPSecPSKProperty[] = "L2TPIPsec.PSK";
-const char kL2TPIPSecUserProperty[] = "L2TPIPsec.User";
-const char kL2TPIPSecPasswordProperty[] = "L2TPIPsec.Password";
-
-// Flimflam EAP property names.
-// See src/third_party/flimflam/doc/service-api.txt.
-const char kEapIdentityProperty[] = "EAP.Identity";
-const char kEapMethodProperty[] = "EAP.EAP";
-const char kEapPhase2AuthProperty[] = "EAP.InnerEAP";
-const char kEapAnonymousIdentityProperty[] = "EAP.AnonymousIdentity";
-const char kEapClientCertProperty[] = "EAP.ClientCert";  // path
-const char kEapCertIDProperty[] = "EAP.CertID";  // PKCS#11 ID
-const char kEapClientCertNssProperty[] = "EAP.ClientCertNSS";  // NSS nickname
-const char kEapPrivateKeyProperty[] = "EAP.PrivateKey";
-const char kEapPrivateKeyPasswordProperty[] = "EAP.PrivateKeyPassword";
-const char kEapKeyIDProperty[] = "EAP.KeyID";
-const char kEapCaCertProperty[] = "EAP.CACert";  // server CA cert path
-const char kEapCaCertIDProperty[] = "EAP.CACertID";  // server CA PKCS#11 ID
-const char kEapCaCertNssProperty[] = "EAP.CACertNSS";  // server CA NSS nickname
-const char kEapUseSystemCAsProperty[] = "EAP.UseSystemCAs";
-const char kEapPinProperty[] = "EAP.PIN";
-const char kEapPasswordProperty[] = "EAP.Password";
-const char kEapKeyMgmtProperty[] = "EAP.KeyMgmt";
-
-// Flimflam EAP method options.
-const char kEapMethodPEAP[] = "PEAP";
-const char kEapMethodTLS[] = "TLS";
-const char kEapMethodTTLS[] = "TTLS";
-const char kEapMethodLEAP[] = "LEAP";
-
-// Flimflam EAP phase 2 auth options.
-const char kEapPhase2AuthPEAPMD5[] = "auth=MD5";
-const char kEapPhase2AuthPEAPMSCHAPV2[] = "auth=MSCHAPV2";
-const char kEapPhase2AuthTTLSMD5[] = "autheap=MD5";
-const char kEapPhase2AuthTTLSMSCHAPV2[] = "autheap=MSCHAPV2";
-const char kEapPhase2AuthTTLSMSCHAP[] = "autheap=MSCHAP";
-const char kEapPhase2AuthTTLSPAP[] = "autheap=PAP";
-const char kEapPhase2AuthTTLSCHAP[] = "autheap=CHAP";
-
-// Flimflam VPN provider types.
-const char kProviderL2tpIpsec[] = "l2tpipsec";
-const char kProviderOpenVpn[] = "openvpn";
-
-
-// Flimflam state options.
-const char kStateIdle[] = "idle";
-const char kStateCarrier[] = "carrier";
-const char kStateAssociation[] = "association";
-const char kStateConfiguration[] = "configuration";
-const char kStateReady[] = "ready";
-const char kStatePortal[] = "portal";
-const char kStateOnline[] = "online";
-const char kStateDisconnect[] = "disconnect";
-const char kStateFailure[] = "failure";
-const char kStateActivationFailure[] = "activation-failure";
-
-// Flimflam network technology options.
-const char kNetworkTechnology1Xrtt[] = "1xRTT";
-const char kNetworkTechnologyEvdo[] = "EVDO";
-const char kNetworkTechnologyGprs[] = "GPRS";
-const char kNetworkTechnologyEdge[] = "EDGE";
-const char kNetworkTechnologyUmts[] = "UMTS";
-const char kNetworkTechnologyHspa[] = "HSPA";
-const char kNetworkTechnologyHspaPlus[] = "HSPA+";
-const char kNetworkTechnologyLte[] = "LTE";
-const char kNetworkTechnologyLteAdvanced[] = "LTE Advanced";
-const char kNetworkTechnologyGsm[] = "GSM";
-
-// Flimflam roaming state options
-const char kRoamingStateHome[] = "home";
-const char kRoamingStateRoaming[] = "roaming";
-const char kRoamingStateUnknown[] = "unknown";
-
-// Flimflam activation state options
-const char kActivationStateActivated[] = "activated";
-const char kActivationStateActivating[] = "activating";
-const char kActivationStateNotActivated[] = "not-activated";
-const char kActivationStatePartiallyActivated[] = "partially-activated";
-const char kActivationStateUnknown[] = "unknown";
-
-// FlimFlam technology family options
-const char kTechnologyFamilyCdma[] = "CDMA";
-const char kTechnologyFamilyGsm[] = "GSM";
-
-// Flimflam error options.
-const char kErrorOutOfRange[] = "out-of-range";
-const char kErrorPinMissing[] = "pin-missing";
-const char kErrorDhcpFailed[] = "dhcp-failed";
-const char kErrorConnectFailed[] = "connect-failed";
-const char kErrorBadPassphrase[] = "bad-passphrase";
-const char kErrorBadWEPKey[] = "bad-wepkey";
-const char kErrorActivationFailed[] = "activation-failed";
-const char kErrorNeedEvdo[] = "need-evdo";
-const char kErrorNeedHomeNetwork[] = "need-home-network";
-const char kErrorOtaspFailed[] = "otasp-failed";
-const char kErrorAaaFailed[] = "aaa-failed";
-const char kErrorInternal[] = "internal-error";
-const char kErrorDNSLookupFailed[] = "dns-lookup-failed";
-const char kErrorHTTPGetFailed[] = "http-get-failed";
-
-// Flimflam error messages.
-const char kErrorPassphraseRequiredMsg[] = "Passphrase required";
-const char kErrorIncorrectPinMsg[] = "org.chromium.flimflam.Error.IncorrectPin";
-const char kErrorPinBlockedMsg[] = "org.chromium.flimflam.Error.PinBlocked";
-const char kErrorPinRequiredMsg[] = "org.chromium.flimflam.Error.PinRequired";
-
-const char kUnknownString[] = "UNKNOWN";
-
-////////////////////////////////////////////////////////////////////////////
-
-static const char* ConnectionTypeToString(ConnectionType type) {
-  switch (type) {
-    case TYPE_UNKNOWN:
-      break;
-    case TYPE_ETHERNET:
-      return kTypeEthernet;
-    case TYPE_WIFI:
-      return kTypeWifi;
-    case TYPE_WIMAX:
-      return kTypeWimax;
-    case TYPE_BLUETOOTH:
-      return kTypeBluetooth;
-    case TYPE_CELLULAR:
-      return kTypeCellular;
-    case TYPE_VPN:
-      return kTypeVPN;
-  }
-  LOG(ERROR) << "ConnectionTypeToString called with unknown type: " << type;
-  return kUnknownString;
-}
-
-static const char* SecurityToString(ConnectionSecurity security) {
-  switch (security) {
-    case SECURITY_NONE:
-      return kSecurityNone;
-    case SECURITY_WEP:
-      return kSecurityWep;
-    case SECURITY_WPA:
-      return kSecurityWpa;
-    case SECURITY_RSN:
-      return kSecurityRsn;
-    case SECURITY_8021X:
-      return kSecurity8021x;
-    case SECURITY_PSK:
-      return kSecurityPsk;
-    case SECURITY_UNKNOWN:
-      break;
-  }
-  LOG(ERROR) << "SecurityToString called with unknown type: " << security;
-  return kUnknownString;
-}
-
-static const char* ProviderTypeToString(VirtualNetwork::ProviderType type) {
-  switch (type) {
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
-      return kProviderL2tpIpsec;
-    case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
-      return kProviderOpenVpn;
-    case VirtualNetwork::PROVIDER_TYPE_MAX:
-      break;
-  }
-  LOG(ERROR) << "ProviderTypeToString called with unknown type: " << type;
-  return kUnknownString;
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-// Helper class to cache maps of strings to enums.
-template <typename Type>
-class StringToEnum {
- public:
-  struct Pair {
-    const char* key;
-    const Type value;
-  };
-
-  StringToEnum(const Pair* list, size_t num_entries, Type unknown)
-      : unknown_value_(unknown) {
-    for (size_t i = 0; i < num_entries; ++i, ++list)
-      enum_map_[list->key] = list->value;
-  }
-
-  Type Get(const std::string& type) const {
-    EnumMapConstIter iter = enum_map_.find(type);
-    if (iter != enum_map_.end())
-      return iter->second;
-    return unknown_value_;
-  }
-
- private:
-  typedef typename std::map<std::string, Type> EnumMap;
-  typedef typename std::map<std::string, Type>::const_iterator EnumMapConstIter;
-  EnumMap enum_map_;
-  Type unknown_value_;
-  DISALLOW_COPY_AND_ASSIGN(StringToEnum);
-};
-
-////////////////////////////////////////////////////////////////////////////
-
-enum PropertyIndex {
-  PROPERTY_INDEX_ACTIVATION_STATE,
-  PROPERTY_INDEX_ACTIVE_PROFILE,
-  PROPERTY_INDEX_AUTO_CONNECT,
-  PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES,
-  PROPERTY_INDEX_CARRIER,
-  PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING,
-  PROPERTY_INDEX_CELLULAR_APN,
-  PROPERTY_INDEX_CELLULAR_APN_LIST,
-  PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN,
-  PROPERTY_INDEX_CHECK_PORTAL_LIST,
-  PROPERTY_INDEX_CONNECTABLE,
-  PROPERTY_INDEX_CONNECTED_TECHNOLOGIES,
-  PROPERTY_INDEX_CONNECTIVITY_STATE,
-  PROPERTY_INDEX_DEFAULT_TECHNOLOGY,
-  PROPERTY_INDEX_DEVICE,
-  PROPERTY_INDEX_DEVICES,
-  PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY,
-  PROPERTY_INDEX_EAP_CA_CERT,
-  PROPERTY_INDEX_EAP_CA_CERT_ID,
-  PROPERTY_INDEX_EAP_CA_CERT_NSS,
-  PROPERTY_INDEX_EAP_CERT_ID,
-  PROPERTY_INDEX_EAP_CLIENT_CERT,
-  PROPERTY_INDEX_EAP_CLIENT_CERT_NSS,
-  PROPERTY_INDEX_EAP_IDENTITY,
-  PROPERTY_INDEX_EAP_KEY_ID,
-  PROPERTY_INDEX_EAP_KEY_MGMT,
-  PROPERTY_INDEX_EAP_METHOD,
-  PROPERTY_INDEX_EAP_PASSWORD,
-  PROPERTY_INDEX_EAP_PHASE_2_AUTH,
-  PROPERTY_INDEX_EAP_PIN,
-  PROPERTY_INDEX_EAP_PRIVATE_KEY,
-  PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD,
-  PROPERTY_INDEX_EAP_USE_SYSTEM_CAS,
-  PROPERTY_INDEX_ENABLED_TECHNOLOGIES,
-  PROPERTY_INDEX_ERROR,
-  PROPERTY_INDEX_ESN,
-  PROPERTY_INDEX_FAVORITE,
-  PROPERTY_INDEX_FIRMWARE_REVISION,
-  PROPERTY_INDEX_FOUND_NETWORKS,
-  PROPERTY_INDEX_HARDWARE_REVISION,
-  PROPERTY_INDEX_HOME_PROVIDER,
-  PROPERTY_INDEX_HOST,
-  PROPERTY_INDEX_IDENTITY,
-  PROPERTY_INDEX_IMEI,
-  PROPERTY_INDEX_IMSI,
-  PROPERTY_INDEX_IS_ACTIVE,
-  PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS,
-  PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID,
-  PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT,
-  PROPERTY_INDEX_L2TPIPSEC_PASSWORD,
-  PROPERTY_INDEX_L2TPIPSEC_PIN,
-  PROPERTY_INDEX_L2TPIPSEC_PSK,
-  PROPERTY_INDEX_L2TPIPSEC_USER,
-  PROPERTY_INDEX_MANUFACTURER,
-  PROPERTY_INDEX_MDN,
-  PROPERTY_INDEX_MEID,
-  PROPERTY_INDEX_MIN,
-  PROPERTY_INDEX_MODE,
-  PROPERTY_INDEX_MODEL_ID,
-  PROPERTY_INDEX_NAME,
-  PROPERTY_INDEX_NETWORKS,
-  PROPERTY_INDEX_NETWORK_TECHNOLOGY,
-  PROPERTY_INDEX_OFFLINE_MODE,
-  PROPERTY_INDEX_OPERATOR_CODE,
-  PROPERTY_INDEX_OPERATOR_NAME,
-  PROPERTY_INDEX_PASSPHRASE,
-  PROPERTY_INDEX_PASSPHRASE_REQUIRED,
-  PROPERTY_INDEX_PAYMENT_URL,
-  PROPERTY_INDEX_PORTAL_URL,
-  PROPERTY_INDEX_POWERED,
-  PROPERTY_INDEX_PRIORITY,
-  PROPERTY_INDEX_PRL_VERSION,
-  PROPERTY_INDEX_PROFILE,
-  PROPERTY_INDEX_PROFILES,
-  PROPERTY_INDEX_PROVIDER,
-  PROPERTY_INDEX_PROXY_CONFIG,
-  PROPERTY_INDEX_ROAMING_STATE,
-  PROPERTY_INDEX_SAVE_CREDENTIALS,
-  PROPERTY_INDEX_SCANNING,
-  PROPERTY_INDEX_SECURITY,
-  PROPERTY_INDEX_SELECTED_NETWORK,
-  PROPERTY_INDEX_SERVICES,
-  PROPERTY_INDEX_SERVICE_WATCH_LIST,
-  PROPERTY_INDEX_SERVING_OPERATOR,
-  PROPERTY_INDEX_SIGNAL_STRENGTH,
-  PROPERTY_INDEX_SIM_LOCK,
-  PROPERTY_INDEX_STATE,
-  PROPERTY_INDEX_SUPPORT_NETWORK_SCAN,
-  PROPERTY_INDEX_TECHNOLOGY_FAMILY,
-  PROPERTY_INDEX_TYPE,
-  PROPERTY_INDEX_UNKNOWN,
-  PROPERTY_INDEX_USAGE_URL,
-  PROPERTY_INDEX_WIFI_AUTH_MODE,
-  PROPERTY_INDEX_WIFI_FREQUENCY,
-  PROPERTY_INDEX_WIFI_HEX_SSID,
-  PROPERTY_INDEX_WIFI_HIDDEN_SSID,
-  PROPERTY_INDEX_WIFI_PHY_MODE,
-};
-
-StringToEnum<PropertyIndex>::Pair property_index_table[] =  {
-  { kActivationStateProperty, PROPERTY_INDEX_ACTIVATION_STATE },
-  { kActiveProfileProperty, PROPERTY_INDEX_ACTIVE_PROFILE },
-  { kAutoConnectProperty, PROPERTY_INDEX_AUTO_CONNECT },
-  { kAvailableTechnologiesProperty, PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES },
-  { kCarrierProperty, PROPERTY_INDEX_CARRIER },
-  { kCellularAllowRoamingProperty, PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING },
-  { kCellularApnListProperty, PROPERTY_INDEX_CELLULAR_APN_LIST },
-  { kCellularApnProperty, PROPERTY_INDEX_CELLULAR_APN },
-  { kCellularLastGoodApnProperty, PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN },
-  { kCheckPortalListProperty, PROPERTY_INDEX_CHECK_PORTAL_LIST },
-  { kConnectableProperty, PROPERTY_INDEX_CONNECTABLE },
-  { kConnectedTechnologiesProperty, PROPERTY_INDEX_CONNECTED_TECHNOLOGIES },
-  { kDefaultTechnologyProperty, PROPERTY_INDEX_DEFAULT_TECHNOLOGY },
-  { kDeviceProperty, PROPERTY_INDEX_DEVICE },
-  { kDevicesProperty, PROPERTY_INDEX_DEVICES },
-  { kEapAnonymousIdentityProperty, PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY },
-  { kEapCaCertIDProperty, PROPERTY_INDEX_EAP_CA_CERT_ID },
-  { kEapCaCertNssProperty, PROPERTY_INDEX_EAP_CA_CERT_NSS },
-  { kEapCaCertProperty, PROPERTY_INDEX_EAP_CA_CERT },
-  { kEapCertIDProperty, PROPERTY_INDEX_EAP_CERT_ID },
-  { kEapClientCertNssProperty, PROPERTY_INDEX_EAP_CLIENT_CERT_NSS },
-  { kEapClientCertProperty, PROPERTY_INDEX_EAP_CLIENT_CERT },
-  { kEapIdentityProperty, PROPERTY_INDEX_EAP_IDENTITY },
-  { kEapKeyIDProperty, PROPERTY_INDEX_EAP_KEY_ID },
-  { kEapKeyMgmtProperty, PROPERTY_INDEX_EAP_KEY_MGMT },
-  { kEapMethodProperty, PROPERTY_INDEX_EAP_METHOD },
-  { kEapPasswordProperty, PROPERTY_INDEX_EAP_PASSWORD },
-  { kEapPhase2AuthProperty, PROPERTY_INDEX_EAP_PHASE_2_AUTH },
-  { kEapPinProperty, PROPERTY_INDEX_EAP_PIN },
-  { kEapPrivateKeyPasswordProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD },
-  { kEapPrivateKeyProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY },
-  { kEapUseSystemCAsProperty, PROPERTY_INDEX_EAP_USE_SYSTEM_CAS },
-  { kEnabledTechnologiesProperty, PROPERTY_INDEX_ENABLED_TECHNOLOGIES },
-  { kErrorProperty, PROPERTY_INDEX_ERROR },
-  { kEsnProperty, PROPERTY_INDEX_ESN },
-  { kFavoriteProperty, PROPERTY_INDEX_FAVORITE },
-  { kFirmwareRevisionProperty, PROPERTY_INDEX_FIRMWARE_REVISION },
-  { kFoundNetworksProperty, PROPERTY_INDEX_FOUND_NETWORKS },
-  { kHardwareRevisionProperty, PROPERTY_INDEX_HARDWARE_REVISION },
-  { kHomeProviderProperty, PROPERTY_INDEX_HOME_PROVIDER },
-  { kHostProperty, PROPERTY_INDEX_HOST },
-  { kIdentityProperty, PROPERTY_INDEX_IDENTITY },
-  { kImeiProperty, PROPERTY_INDEX_IMEI },
-  { kImsiProperty, PROPERTY_INDEX_IMSI },
-  { kIsActiveProperty, PROPERTY_INDEX_IS_ACTIVE },
-  { kL2TPIPSecCACertNSSProperty, PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS },
-  { kL2TPIPSecClientCertIDProperty, PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID },
-  { kL2TPIPSecClientCertSlotProp, PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT },
-  { kL2TPIPSecPasswordProperty, PROPERTY_INDEX_L2TPIPSEC_PASSWORD },
-  { kL2TPIPSecPINProperty, PROPERTY_INDEX_L2TPIPSEC_PIN },
-  { kL2TPIPSecPSKProperty, PROPERTY_INDEX_L2TPIPSEC_PSK },
-  { kL2TPIPSecUserProperty, PROPERTY_INDEX_L2TPIPSEC_USER },
-  { kManufacturerProperty, PROPERTY_INDEX_MANUFACTURER },
-  { kMdnProperty, PROPERTY_INDEX_MDN },
-  { kMeidProperty, PROPERTY_INDEX_MEID },
-  { kMinProperty, PROPERTY_INDEX_MIN },
-  { kModeProperty, PROPERTY_INDEX_MODE },
-  { kModelIDProperty, PROPERTY_INDEX_MODEL_ID },
-  { kNameProperty, PROPERTY_INDEX_NAME },
-  { kNetworkTechnologyProperty, PROPERTY_INDEX_NETWORK_TECHNOLOGY },
-  { kNetworksProperty, PROPERTY_INDEX_NETWORKS },
-  { kOfflineModeProperty, PROPERTY_INDEX_OFFLINE_MODE },
-  { kOperatorCodeProperty, PROPERTY_INDEX_OPERATOR_CODE },
-  { kOperatorNameProperty, PROPERTY_INDEX_OPERATOR_NAME },
-  { kPRLVersionProperty, PROPERTY_INDEX_PRL_VERSION },
-  { kPassphraseProperty, PROPERTY_INDEX_PASSPHRASE },
-  { kPassphraseRequiredProperty, PROPERTY_INDEX_PASSPHRASE_REQUIRED },
-  { kPaymentURLProperty, PROPERTY_INDEX_PAYMENT_URL },
-  { kPortalURLProperty, PROPERTY_INDEX_PORTAL_URL },
-  { kPoweredProperty, PROPERTY_INDEX_POWERED },
-  { kPriorityProperty, PROPERTY_INDEX_PRIORITY },
-  { kProfileProperty, PROPERTY_INDEX_PROFILE },
-  { kProfilesProperty, PROPERTY_INDEX_PROFILES },
-  { kProviderProperty, PROPERTY_INDEX_PROVIDER },
-  { kProxyConfigProperty, PROPERTY_INDEX_PROXY_CONFIG },
-  { kRoamingStateProperty, PROPERTY_INDEX_ROAMING_STATE },
-  { kSIMLockStatusProperty, PROPERTY_INDEX_SIM_LOCK },
-  { kSaveCredentialsProperty, PROPERTY_INDEX_SAVE_CREDENTIALS },
-  { kScanningProperty, PROPERTY_INDEX_SCANNING },
-  { kSecurityProperty, PROPERTY_INDEX_SECURITY },
-  { kSelectedNetworkProperty, PROPERTY_INDEX_SELECTED_NETWORK },
-  { kServiceWatchListProperty, PROPERTY_INDEX_SERVICE_WATCH_LIST },
-  { kServicesProperty, PROPERTY_INDEX_SERVICES },
-  { kServingOperatorProperty, PROPERTY_INDEX_SERVING_OPERATOR },
-  { kSignalStrengthProperty, PROPERTY_INDEX_SIGNAL_STRENGTH },
-  { kStateProperty, PROPERTY_INDEX_STATE },
-  { kSupportNetworkScanProperty, PROPERTY_INDEX_SUPPORT_NETWORK_SCAN },
-  { kTechnologyFamilyProperty, PROPERTY_INDEX_TECHNOLOGY_FAMILY },
-  { kTypeProperty, PROPERTY_INDEX_TYPE },
-  { kUsageURLProperty, PROPERTY_INDEX_USAGE_URL },
-  { kWifiAuthMode, PROPERTY_INDEX_WIFI_AUTH_MODE },
-  { kWifiFrequency, PROPERTY_INDEX_WIFI_FREQUENCY },
-  { kWifiHexSsid, PROPERTY_INDEX_WIFI_HEX_SSID },
-  { kWifiHiddenSsid, PROPERTY_INDEX_WIFI_HIDDEN_SSID },
-  { kWifiPhyMode, PROPERTY_INDEX_WIFI_PHY_MODE },
-};
-
-StringToEnum<PropertyIndex>& property_index_parser() {
-  static StringToEnum<PropertyIndex> parser(property_index_table,
-                                            arraysize(property_index_table),
-                                            PROPERTY_INDEX_UNKNOWN);
-  return parser;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// Parse strings from libcros.
-
-// Network.
-static ConnectionType ParseType(const std::string& type) {
-  static StringToEnum<ConnectionType>::Pair table[] = {
-    { kTypeEthernet, TYPE_ETHERNET },
-    { kTypeWifi, TYPE_WIFI },
-    { kTypeWimax, TYPE_WIMAX },
-    { kTypeBluetooth, TYPE_BLUETOOTH },
-    { kTypeCellular, TYPE_CELLULAR },
-    { kTypeVPN, TYPE_VPN },
-  };
-  static StringToEnum<ConnectionType> parser(
-      table, arraysize(table), TYPE_UNKNOWN);
-  return parser.Get(type);
-}
-
-ConnectionType ParseTypeFromDictionary(const DictionaryValue* info) {
-  std::string type_string;
-  info->GetString(kTypeProperty, &type_string);
-  return ParseType(type_string);
-}
-
-static ConnectionMode ParseMode(const std::string& mode) {
-  static StringToEnum<ConnectionMode>::Pair table[] = {
-    { kModeManaged, MODE_MANAGED },
-    { kModeAdhoc, MODE_ADHOC },
-  };
-  static StringToEnum<ConnectionMode> parser(
-      table, arraysize(table), MODE_UNKNOWN);
-  return parser.Get(mode);
-}
-
-static ConnectionState ParseState(const std::string& state) {
-  static StringToEnum<ConnectionState>::Pair table[] = {
-    { kStateIdle, STATE_IDLE },
-    { kStateCarrier, STATE_CARRIER },
-    { kStateAssociation, STATE_ASSOCIATION },
-    { kStateConfiguration, STATE_CONFIGURATION },
-    { kStateReady, STATE_READY },
-    { kStateDisconnect, STATE_DISCONNECT },
-    { kStateFailure, STATE_FAILURE },
-    { kStateActivationFailure, STATE_ACTIVATION_FAILURE },
-    { kStatePortal, STATE_PORTAL },
-    { kStateOnline, STATE_ONLINE },
-  };
-  static StringToEnum<ConnectionState> parser(
-      table, arraysize(table), STATE_UNKNOWN);
-  return parser.Get(state);
-}
-
-static ConnectionError ParseError(const std::string& error) {
-  static StringToEnum<ConnectionError>::Pair table[] = {
-    { kErrorOutOfRange, ERROR_OUT_OF_RANGE },
-    { kErrorPinMissing, ERROR_PIN_MISSING },
-    { kErrorDhcpFailed, ERROR_DHCP_FAILED },
-    { kErrorConnectFailed, ERROR_CONNECT_FAILED },
-    { kErrorBadPassphrase, ERROR_BAD_PASSPHRASE },
-    { kErrorBadWEPKey, ERROR_BAD_WEPKEY },
-    { kErrorActivationFailed, ERROR_ACTIVATION_FAILED },
-    { kErrorNeedEvdo, ERROR_NEED_EVDO },
-    { kErrorNeedHomeNetwork, ERROR_NEED_HOME_NETWORK },
-    { kErrorOtaspFailed, ERROR_OTASP_FAILED },
-    { kErrorAaaFailed, ERROR_AAA_FAILED },
-    { kErrorInternal, ERROR_INTERNAL },
-    { kErrorDNSLookupFailed, ERROR_DNS_LOOKUP_FAILED },
-    { kErrorHTTPGetFailed, ERROR_HTTP_GET_FAILED },
-  };
-  static StringToEnum<ConnectionError> parser(
-      table, arraysize(table), ERROR_NO_ERROR);
-  return parser.Get(error);
-}
-
-// VirtualNetwork
-static VirtualNetwork::ProviderType ParseProviderType(const std::string& mode) {
-  static StringToEnum<VirtualNetwork::ProviderType>::Pair table[] = {
-    { kProviderL2tpIpsec, VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK },
-    { kProviderOpenVpn, VirtualNetwork::PROVIDER_TYPE_OPEN_VPN },
-  };
-  static StringToEnum<VirtualNetwork::ProviderType> parser(
-      table, arraysize(table), VirtualNetwork::PROVIDER_TYPE_MAX);
-  return parser.Get(mode);
-}
-
-// CellularNetwork.
-static ActivationState ParseActivationState(const std::string& state) {
-  static StringToEnum<ActivationState>::Pair table[] = {
-    { kActivationStateActivated, ACTIVATION_STATE_ACTIVATED },
-    { kActivationStateActivating, ACTIVATION_STATE_ACTIVATING },
-    { kActivationStateNotActivated, ACTIVATION_STATE_NOT_ACTIVATED },
-    { kActivationStatePartiallyActivated, ACTIVATION_STATE_PARTIALLY_ACTIVATED},
-    { kActivationStateUnknown, ACTIVATION_STATE_UNKNOWN},
-  };
-  static StringToEnum<ActivationState> parser(
-      table, arraysize(table), ACTIVATION_STATE_UNKNOWN);
-  return parser.Get(state);
-}
-
-static NetworkTechnology ParseNetworkTechnology(const std::string& technology) {
-  static StringToEnum<NetworkTechnology>::Pair table[] = {
-    { kNetworkTechnology1Xrtt, NETWORK_TECHNOLOGY_1XRTT },
-    { kNetworkTechnologyEvdo, NETWORK_TECHNOLOGY_EVDO },
-    { kNetworkTechnologyGprs, NETWORK_TECHNOLOGY_GPRS },
-    { kNetworkTechnologyEdge, NETWORK_TECHNOLOGY_EDGE },
-    { kNetworkTechnologyUmts, NETWORK_TECHNOLOGY_UMTS },
-    { kNetworkTechnologyHspa, NETWORK_TECHNOLOGY_HSPA },
-    { kNetworkTechnologyHspaPlus, NETWORK_TECHNOLOGY_HSPA_PLUS },
-    { kNetworkTechnologyLte, NETWORK_TECHNOLOGY_LTE },
-    { kNetworkTechnologyLteAdvanced, NETWORK_TECHNOLOGY_LTE_ADVANCED },
-    { kNetworkTechnologyGsm, NETWORK_TECHNOLOGY_GSM },
-  };
-  static StringToEnum<NetworkTechnology> parser(
-      table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN);
-  return parser.Get(technology);
-}
-
-static SIMLockState ParseSimLockState(const std::string& state) {
-  static StringToEnum<SIMLockState>::Pair table[] = {
-    { "", SIM_UNLOCKED },
-    { kSIMLockPin, SIM_LOCKED_PIN },
-    { kSIMLockPuk, SIM_LOCKED_PUK },
-  };
-  static StringToEnum<SIMLockState> parser(
-      table, arraysize(table), SIM_UNKNOWN);
-  SIMLockState parsed_state = parser.Get(state);
-  DCHECK_NE(parsed_state, SIM_UNKNOWN) << "Unknown SIMLock state encountered";
-  return parsed_state;
-}
-
-static bool ParseSimLockStateFromDictionary(const DictionaryValue* info,
-                                            SIMLockState* out_state,
-                                            int* out_retries) {
-  std::string state_string;
-  if (!info->GetString(kSIMLockTypeProperty, &state_string) ||
-      !info->GetInteger(kSIMLockRetriesLeftProperty, out_retries)) {
-    LOG(ERROR) << "Error parsing SIMLock state";
-    return false;
-  }
-  *out_state = ParseSimLockState(state_string);
-  return true;
-}
-
-static bool ParseFoundNetworksFromList(const ListValue* list,
-                                       CellularNetworkList* found_networks_) {
-  found_networks_->clear();
-  found_networks_->reserve(list->GetSize());
-  for (ListValue::const_iterator it = list->begin(); it != list->end(); ++it) {
-    if ((*it)->IsType(Value::TYPE_DICTIONARY)) {
-      found_networks_->resize(found_networks_->size() + 1);
-      const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it);
-      dict->GetStringWithoutPathExpansion(
-          kStatusProperty, &found_networks_->back().status);
-      dict->GetStringWithoutPathExpansion(
-          kNetworkIdProperty, &found_networks_->back().network_id);
-      dict->GetStringWithoutPathExpansion(
-          kShortNameProperty, &found_networks_->back().short_name);
-      dict->GetStringWithoutPathExpansion(
-          kLongNameProperty, &found_networks_->back().long_name);
-      dict->GetStringWithoutPathExpansion(
-          kTechnologyProperty, &found_networks_->back().technology);
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-static bool ParseApnList(const ListValue* list,
-                         CellularApnList* apn_list) {
-  apn_list->clear();
-  apn_list->reserve(list->GetSize());
-  for (ListValue::const_iterator it = list->begin(); it != list->end(); ++it) {
-    if ((*it)->IsType(Value::TYPE_DICTIONARY)) {
-      apn_list->resize(apn_list->size() + 1);
-      apn_list->back().Set(*static_cast<const DictionaryValue*>(*it));
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-static NetworkRoamingState ParseRoamingState(const std::string& roaming_state) {
-  static StringToEnum<NetworkRoamingState>::Pair table[] = {
-    { kRoamingStateHome, ROAMING_STATE_HOME },
-    { kRoamingStateRoaming, ROAMING_STATE_ROAMING },
-    { kRoamingStateUnknown, ROAMING_STATE_UNKNOWN },
-  };
-  static StringToEnum<NetworkRoamingState> parser(
-      table, arraysize(table), ROAMING_STATE_UNKNOWN);
-  return parser.Get(roaming_state);
-}
-
-// WifiNetwork
-static ConnectionSecurity ParseSecurity(const std::string& security) {
-  static StringToEnum<ConnectionSecurity>::Pair table[] = {
-    { kSecurityNone, SECURITY_NONE },
-    { kSecurityWep, SECURITY_WEP },
-    { kSecurityWpa, SECURITY_WPA },
-    { kSecurityRsn, SECURITY_RSN },
-    { kSecurityPsk, SECURITY_PSK },
-    { kSecurity8021x, SECURITY_8021X },
-  };
-  static StringToEnum<ConnectionSecurity> parser(
-      table, arraysize(table), SECURITY_UNKNOWN);
-  return parser.Get(security);
-}
-
-static EAPMethod ParseEAPMethod(const std::string& method) {
-  static StringToEnum<EAPMethod>::Pair table[] = {
-    { kEapMethodPEAP, EAP_METHOD_PEAP },
-    { kEapMethodTLS, EAP_METHOD_TLS },
-    { kEapMethodTTLS, EAP_METHOD_TTLS },
-    { kEapMethodLEAP, EAP_METHOD_LEAP },
-  };
-  static StringToEnum<EAPMethod> parser(
-      table, arraysize(table), EAP_METHOD_UNKNOWN);
-  return parser.Get(method);
-}
-
-static EAPPhase2Auth ParseEAPPhase2Auth(const std::string& auth) {
-  static StringToEnum<EAPPhase2Auth>::Pair table[] = {
-    { kEapPhase2AuthPEAPMD5, EAP_PHASE_2_AUTH_MD5 },
-    { kEapPhase2AuthPEAPMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
-    { kEapPhase2AuthTTLSMD5, EAP_PHASE_2_AUTH_MD5 },
-    { kEapPhase2AuthTTLSMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
-    { kEapPhase2AuthTTLSMSCHAP, EAP_PHASE_2_AUTH_MSCHAP },
-    { kEapPhase2AuthTTLSPAP, EAP_PHASE_2_AUTH_PAP },
-    { kEapPhase2AuthTTLSCHAP, EAP_PHASE_2_AUTH_CHAP },
-  };
-  static StringToEnum<EAPPhase2Auth> parser(
-      table, arraysize(table), EAP_PHASE_2_AUTH_AUTO);
-  return parser.Get(auth);
-}
-
-// NetworkDevice
-static TechnologyFamily ParseTechnologyFamily(const std::string& family) {
-  static StringToEnum<TechnologyFamily>::Pair table[] = {
-    { kTechnologyFamilyCdma, TECHNOLOGY_FAMILY_CDMA },
-    { kTechnologyFamilyGsm, TECHNOLOGY_FAMILY_GSM },
-  };
-  static StringToEnum<TechnologyFamily> parser(
-      table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN);
-  return parser.Get(family);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Misc.
 
 // Safe string constructor since we can't rely on non NULL pointers
 // for string values from libcros.
 static std::string SafeString(const char* s) {
   return s ? std::string(s) : std::string();
 }
 
 // Erase the memory used by a string, then clear it.
@@ skipping 40 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkDevice
 
 NetworkDevice::NetworkDevice(const std::string& device_path)
     : device_path_(device_path),
       type_(TYPE_UNKNOWN),
       scanning_(false),
       sim_lock_state_(SIM_UNKNOWN),
       sim_retries_left_(kDefaultSimUnlockRetriesCount),
       sim_pin_required_(SIM_PIN_REQUIRE_UNKNOWN),
-      PRL_version_(0),
+      prl_version_(0),
       data_roaming_allowed_(false),
-      support_network_scan_(false) {
+      support_network_scan_(false),
+      device_parser_(new NativeNetworkDeviceParser) {
 }
 
 NetworkDevice::~NetworkDevice() {}
 
-bool NetworkDevice::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_TYPE: {
-      std::string type_string;
-      if (value->GetAsString(&type_string)) {
-        type_ = ParseType(type_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_NAME:
-      return value->GetAsString(&name_);
-    case PROPERTY_INDEX_CARRIER:
-      return value->GetAsString(&carrier_);
-    case PROPERTY_INDEX_SCANNING:
-      return value->GetAsBoolean(&scanning_);
-    case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING:
-      return value->GetAsBoolean(&data_roaming_allowed_);
-    case PROPERTY_INDEX_CELLULAR_APN_LIST:
-      if (value->IsType(Value::TYPE_LIST)) {
-        return ParseApnList(static_cast<const ListValue*>(value),
-                            &provider_apn_list_);
-      }
-      break;
-    case PROPERTY_INDEX_NETWORKS:
-      if (value->IsType(Value::TYPE_LIST)) {
-        // Ignored.
-        return true;
-      }
-      break;
-    case PROPERTY_INDEX_FOUND_NETWORKS:
-      if (value->IsType(Value::TYPE_LIST)) {
-        return ParseFoundNetworksFromList(
-            static_cast<const ListValue*>(value),
-            &found_cellular_networks_);
-      }
-      break;
-    case PROPERTY_INDEX_HOME_PROVIDER: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        const DictionaryValue* dict =
-            static_cast<const DictionaryValue*>(value);
-        home_provider_code_.clear();
-        home_provider_country_.clear();
-        home_provider_name_.clear();
-        dict->GetStringWithoutPathExpansion(kOperatorCodeKey,
-                                            &home_provider_code_);
-        dict->GetStringWithoutPathExpansion(kOperatorCountryKey,
-                                            &home_provider_country_);
-        dict->GetStringWithoutPathExpansion(kOperatorNameKey,
-                                            &home_provider_name_);
-        if (!home_provider_name_.empty() && !home_provider_country_.empty()) {
-          home_provider_id_ = base::StringPrintf(
-              kCarrierIdFormat,
-              home_provider_name_.c_str(),
-              home_provider_country_.c_str());
-        } else {
-          home_provider_id_ = home_provider_code_;
-          LOG(WARNING) << "Carrier ID not defined, using code instead: "
-                       << home_provider_id_;
-        }
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_MEID:
-      return value->GetAsString(&MEID_);
-    case PROPERTY_INDEX_IMEI:
-      return value->GetAsString(&IMEI_);
-    case PROPERTY_INDEX_IMSI:
-      return value->GetAsString(&IMSI_);
-    case PROPERTY_INDEX_ESN:
-      return value->GetAsString(&ESN_);
-    case PROPERTY_INDEX_MDN:
-      return value->GetAsString(&MDN_);
-    case PROPERTY_INDEX_MIN:
-      return value->GetAsString(&MIN_);
-    case PROPERTY_INDEX_MODEL_ID:
-      return value->GetAsString(&model_id_);
-    case PROPERTY_INDEX_MANUFACTURER:
-      return value->GetAsString(&manufacturer_);
-    case PROPERTY_INDEX_SIM_LOCK:
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        bool result = ParseSimLockStateFromDictionary(
-            static_cast<const DictionaryValue*>(value),
-            &sim_lock_state_,
-            &sim_retries_left_);
-        // Initialize PinRequired value only once.
-        // See SIMPinRequire enum comments.
-        if (sim_pin_required_ == SIM_PIN_REQUIRE_UNKNOWN) {
-          if (sim_lock_state_ == SIM_UNLOCKED) {
-            sim_pin_required_ = SIM_PIN_NOT_REQUIRED;
-          } else if (sim_lock_state_ == SIM_LOCKED_PIN ||
-                     sim_lock_state_ == SIM_LOCKED_PUK) {
-            sim_pin_required_ = SIM_PIN_REQUIRED;
-          }
-        }
-        return result;
-      }
-      break;
-    case PROPERTY_INDEX_FIRMWARE_REVISION:
-      return value->GetAsString(&firmware_revision_);
-    case PROPERTY_INDEX_HARDWARE_REVISION:
-      return value->GetAsString(&hardware_revision_);
-    case PROPERTY_INDEX_POWERED:
-      // we don't care about the value, just the fact that it changed
-      return true;
-    case PROPERTY_INDEX_PRL_VERSION:
-      return value->GetAsInteger(&PRL_version_);
-    case PROPERTY_INDEX_SELECTED_NETWORK:
-      return value->GetAsString(&selected_cellular_network_);
-    case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN:
-      return value->GetAsBoolean(&support_network_scan_);
-    case PROPERTY_INDEX_TECHNOLOGY_FAMILY: {
-      std::string technology_family_string;
-      if (value->GetAsString(&technology_family_string)) {
-        technology_family_ = ParseTechnologyFamily(technology_family_string);
-        return true;
-      }
-      break;
-    }
-    default:
-      break;
-  }
-  return false;
+void NetworkDevice::ParseInfo(const DictionaryValue& info) {
+  if (device_parser_.get())
+    device_parser_->UpdateDeviceFromInfo(info, this);
 }
 
-void NetworkDevice::ParseInfo(const DictionaryValue* info) {
-  for (DictionaryValue::key_iterator iter = info->begin_keys();
-       iter != info->end_keys(); ++iter) {
-    const std::string& key = *iter;
-    Value* value;
-    bool res = info->GetWithoutPathExpansion(key, &value);
-    DCHECK(res);
-    if (res) {
-      int index = property_index_parser().Get(key);
-      if (!ParseValue(index, value))
-        VLOG(1) << "NetworkDevice: Unhandled key: " << key;
-    }
-  }
+bool NetworkDevice::UpdateStatus(const std::string& key,
+                                 const Value& value,
+                                 PropertyIndex* index) {
+  if (device_parser_.get())
+    return device_parser_->UpdateStatus(key, value, this, index);
+  return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Network
 
-Network::Network(const std::string& service_path, ConnectionType type)
+Network::Network(const std::string& service_path,
+                 ConnectionType type,
+                 NativeNetworkParser* parser)
     : state_(STATE_UNKNOWN),
       error_(ERROR_NO_ERROR),
       connectable_(true),
       is_active_(false),
       priority_(kPriorityNotSet),
       auto_connect_(false),
       save_credentials_(false),
       priority_order_(0),
       added_(false),
       notify_failure_(false),
       profile_type_(PROFILE_NONE),
       service_path_(service_path),
-      type_(type) {
+      type_(type),
+      network_parser_(parser) {
 }
 
 Network::~Network() {}
 
 void Network::SetState(ConnectionState new_state) {
   if (new_state == state_)
     return;
   ConnectionState old_state = state_;
   state_ = new_state;
   if (new_state == STATE_FAILURE) {
     if (old_state != STATE_UNKNOWN) {
       // New failure, the user needs to be notified.
       notify_failure_ = true;
     }
   } else {
     // State changed, so refresh IP address.
     // Note: blocking DBus call. TODO(stevenjb): refactor this.
     InitIPAddress();
   }
   VLOG(1) << name() << ".State = " << GetStateString();
 }
 
 void Network::SetName(const std::string& name) {
   std::string name_utf8;
   ValidateUTF8(name, &name_utf8);
   set_name(name_utf8);
 }
 
-bool Network::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_TYPE: {
-      std::string type_string;
-      if (value->GetAsString(&type_string)) {
-        ConnectionType type = ParseType(type_string);
-        LOG_IF(ERROR, type != type_)
-            << "Network with mismatched type: " << service_path_
-            << " " << type << " != " << type_;
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_DEVICE:
-      return value->GetAsString(&device_path_);
-    case PROPERTY_INDEX_NAME: {
-      std::string name;
-      if (value->GetAsString(&name)) {
-        SetName(name);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PROFILE:
-      // Note: currently this is only provided for non remembered networks.
-      return value->GetAsString(&profile_path_);
-    case PROPERTY_INDEX_STATE: {
-      std::string state_string;
-      if (value->GetAsString(&state_string)) {
-        SetState(ParseState(state_string));
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_MODE: {
-      std::string mode_string;
-      if (value->GetAsString(&mode_string)) {
-        mode_ = ParseMode(mode_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_ERROR: {
-      std::string error_string;
-      if (value->GetAsString(&error_string)) {
-        error_ = ParseError(error_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_CONNECTABLE:
-      return value->GetAsBoolean(&connectable_);
-    case PROPERTY_INDEX_IS_ACTIVE:
-      return value->GetAsBoolean(&is_active_);
-    case PROPERTY_INDEX_FAVORITE:
-      // Not used currently.
-      return true;
-    case PROPERTY_INDEX_PRIORITY:
-      return value->GetAsInteger(&priority_);
-    case PROPERTY_INDEX_AUTO_CONNECT:
-      return value->GetAsBoolean(&auto_connect_);
-    case PROPERTY_INDEX_SAVE_CREDENTIALS:
-      return value->GetAsBoolean(&save_credentials_);
-    case PROPERTY_INDEX_PROXY_CONFIG:
-      return value->GetAsString(&proxy_config_);
-    default:
-      break;
-  }
-  return false;
-}
-
-void Network::ParseInfo(const DictionaryValue* info) {
-  // Set default values for properties that may not exist in the dictionary.
-  priority_ = kPriorityNotSet;
-
-  for (DictionaryValue::key_iterator iter = info->begin_keys();
-       iter != info->end_keys(); ++iter) {
-    const std::string& key = *iter;
-    Value* value;
-    bool res = info->GetWithoutPathExpansion(key, &value);
-    DCHECK(res);
-    if (res) {
-      int index = property_index_parser().Get(key);
-      if (!ParseValue(index, value))  // virtual.
-        VLOG(1) << "Network: " << name()
-                << " Type: " << ConnectionTypeToString(type())
-                << " Unhandled key: " << key;
-    }
-  }
-  CalculateUniqueId();
+void Network::ParseInfo(const DictionaryValue& info) {
+  if (network_parser_.get())
+    network_parser_->UpdateNetworkFromInfo(info, this);
 }
 
 void Network::EraseCredentials() {
 }
 
 void Network::CalculateUniqueId() {
   unique_id_ = name_;
 }
 
 bool Network::RequiresUserProfile() const {
@@ skipping 165 matching lines @@
         if (strlen(ipconfig.address) > 0) {
           ip_address_ = ipconfig.address;
           break;
         }
       }
       chromeos::FreeIPConfigStatus(ipconfig_status);
     }
   }
 }
 
+bool Network::UpdateStatus(const std::string& key,
+                           const Value& value,
+                           PropertyIndex* index) {
+  if (network_parser_.get())
+    return network_parser_->UpdateStatus(key, value, this, index);
+  return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// EthernetNetwork
+
+EthernetNetwork::EthernetNetwork(const std::string& service_path)
+    : Network(service_path, TYPE_ETHERNET, new NativeEthernetNetworkParser) {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // VirtualNetwork
 
 VirtualNetwork::VirtualNetwork(const std::string& service_path)
-    : Network(service_path, TYPE_VPN),
+    : Network(service_path, TYPE_VPN, new NativeVirtualNetworkParser),
       provider_type_(PROVIDER_TYPE_L2TP_IPSEC_PSK) {
 }
 
 VirtualNetwork::~VirtualNetwork() {}
 
-bool VirtualNetwork::ParseProviderValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_HOST:
-      return value->GetAsString(&server_hostname_);
-    case PROPERTY_INDEX_NAME:
-      // Note: shadows Network::name_ property.
-      return value->GetAsString(&name_);
-    case PROPERTY_INDEX_TYPE: {
-      std::string provider_type_string;
-      if (value->GetAsString(&provider_type_string)) {
-        provider_type_ = ParseProviderType(provider_type_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS:
-      return value->GetAsString(&ca_cert_nss_);
-    case PROPERTY_INDEX_L2TPIPSEC_PIN:
-      // Ignore PIN property.
-      return true;
-    case PROPERTY_INDEX_L2TPIPSEC_PSK:
-      return value->GetAsString(&psk_passphrase_);
-    case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID:
-      return value->GetAsString(&client_cert_id_);
-    case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT:
-      // Ignore ClientCertSlot property.
-      return true;
-    case PROPERTY_INDEX_L2TPIPSEC_USER:
-      return value->GetAsString(&username_);
-    case PROPERTY_INDEX_L2TPIPSEC_PASSWORD:
-      return value->GetAsString(&user_passphrase_);
-    default:
-      break;
-  }
-  return false;
-}
-
-bool VirtualNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_PROVIDER: {
-      DCHECK_EQ(value->GetType(), Value::TYPE_DICTIONARY);
-      const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
-      for (DictionaryValue::key_iterator iter = dict->begin_keys();
-           iter != dict->end_keys(); ++iter) {
-        const std::string& key = *iter;
-        Value* v;
-        bool res = dict->GetWithoutPathExpansion(key, &v);
-        DCHECK(res);
-        if (res) {
-          int index = property_index_parser().Get(key);
-          if (!ParseProviderValue(index, v))
-            VLOG(1) << name() << ": Provider unhandled key: " << key
-                    << " Type: " << v->GetType();
-        }
-      }
-      return true;
-    }
-    default:
-      return Network::ParseValue(index, value);
-      break;
-  }
-  return false;
-}
-
-void VirtualNetwork::ParseInfo(const DictionaryValue* info) {
-  Network::ParseInfo(info);
-  VLOG(1) << "VPN: " << name()
-          << " Server: " << server_hostname()
-          << " Type: " << ProviderTypeToString(provider_type());
-  if (provider_type_ == PROVIDER_TYPE_L2TP_IPSEC_PSK) {
-    if (!client_cert_id_.empty())
-      provider_type_ = PROVIDER_TYPE_L2TP_IPSEC_USER_CERT;
-  }
-}
-
 void VirtualNetwork::EraseCredentials() {
   WipeString(&ca_cert_nss_);
   WipeString(&psk_passphrase_);
   WipeString(&client_cert_id_);
   WipeString(&user_passphrase_);
 }
 
 void VirtualNetwork::CalculateUniqueId() {
   std::string provider_type(ProviderTypeToString(provider_type_));
-  unique_id_ = provider_type + "|" + server_hostname_;
+  set_unique_id(provider_type + "|" + server_hostname_);
 }
 
 bool VirtualNetwork::RequiresUserProfile() const {
   return true;
 }
 
 void VirtualNetwork::CopyCredentialsFromRemembered(Network* remembered) {
   DCHECK_EQ(remembered->type(), TYPE_VPN);
   VirtualNetwork* remembered_vpn = static_cast<VirtualNetwork*>(remembered);
   VLOG(1) << "Copy VPN credentials: " << name()
@@ skipping 44 matching lines @@
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_OPEN_VPN);
       break;
     default:
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN);
       break;
   }
 }
 
 void VirtualNetwork::SetCACertNSS(const std::string& ca_cert_nss) {
-  SetStringProperty(kL2TPIPSecCACertNSSProperty, ca_cert_nss, &ca_cert_nss_);
+  SetStringProperty(kL2tpIpsecCaCertNssProperty, ca_cert_nss, &ca_cert_nss_);
 }
 
 void VirtualNetwork::SetPSKPassphrase(const std::string& psk_passphrase) {
-  SetStringProperty(kL2TPIPSecPSKProperty, psk_passphrase,
+  SetStringProperty(kL2tpIpsecPskProperty, psk_passphrase,
                            &psk_passphrase_);
 }
 
 void VirtualNetwork::SetClientCertID(const std::string& cert_id) {
-  SetStringProperty(kL2TPIPSecClientCertIDProperty, cert_id, &client_cert_id_);
+  SetStringProperty(kL2tpIpsecClientCertIdProperty, cert_id, &client_cert_id_);
 }
 
 void VirtualNetwork::SetUsername(const std::string& username) {
-  SetStringProperty(kL2TPIPSecUserProperty, username, &username_);
+  SetStringProperty(kL2tpIpsecUserProperty, username, &username_);
 }
 
 void VirtualNetwork::SetUserPassphrase(const std::string& user_passphrase) {
-  SetStringProperty(kL2TPIPSecPasswordProperty, user_passphrase,
+  SetStringProperty(kL2tpIpsecPasswordProperty, user_passphrase,
                     &user_passphrase_);
 }
 
 void VirtualNetwork::SetCertificateSlotAndPin(
     const std::string& slot, const std::string& pin) {
-  SetOrClearStringProperty(kL2TPIPSecClientCertSlotProp, slot, NULL);
-  SetOrClearStringProperty(kL2TPIPSecPINProperty, pin, NULL);
+  SetOrClearStringProperty(kL2tpIpsecClientCertSlotProp, slot, NULL);
+  SetOrClearStringProperty(kL2tpIpsecPinProperty, pin, NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WirelessNetwork
 
-bool WirelessNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_SIGNAL_STRENGTH:
-      return value->GetAsInteger(&strength_);
-    default:
-      return Network::ParseValue(index, value);
-      break;
-  }
-  return false;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // CellularDataPlan
 
 CellularDataPlan::CellularDataPlan()
     : plan_name("Unknown"),
       plan_type(CELLULAR_DATA_PLAN_UNLIMITED),
       plan_data_bytes(0),
       data_bytes_used(0) {
 }
 
@@ skipping 227 matching lines @@
                                           &localized_name))
     localized_name.clear();
   if (!dict.GetStringWithoutPathExpansion(kApnLanguageProperty, &language))
     language.clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CellularNetwork
 
 CellularNetwork::CellularNetwork(const std::string& service_path)
-    : WirelessNetwork(service_path, TYPE_CELLULAR),
+    : WirelessNetwork(service_path, TYPE_CELLULAR,
+                      new NativeCellularNetworkParser),
       activation_state_(ACTIVATION_STATE_UNKNOWN),
       network_technology_(NETWORK_TECHNOLOGY_UNKNOWN),
       roaming_state_(ROAMING_STATE_UNKNOWN),
       data_left_(DATA_UNKNOWN) {
 }
 
 CellularNetwork::~CellularNetwork() {
 }
 
-bool CellularNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_ACTIVATION_STATE: {
-      std::string activation_state_string;
-      if (value->GetAsString(&activation_state_string)) {
-        ActivationState prev_state = activation_state_;
-        activation_state_ = ParseActivationState(activation_state_string);
-        if (activation_state_ != prev_state)
-          RefreshDataPlansIfNeeded();
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_CELLULAR_APN: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        apn_.Set(*static_cast<const DictionaryValue*>(value));
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        last_good_apn_.Set(*static_cast<const DictionaryValue*>(value));
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_NETWORK_TECHNOLOGY: {
-      std::string network_technology_string;
-      if (value->GetAsString(&network_technology_string)) {
-        network_technology_ = ParseNetworkTechnology(network_technology_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_ROAMING_STATE: {
-      std::string roaming_state_string;
-      if (value->GetAsString(&roaming_state_string)) {
-        roaming_state_ = ParseRoamingState(roaming_state_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_OPERATOR_NAME:
-      return value->GetAsString(&operator_name_);
-    case PROPERTY_INDEX_OPERATOR_CODE:
-      return value->GetAsString(&operator_code_);
-    case PROPERTY_INDEX_SERVING_OPERATOR: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        const DictionaryValue* dict =
-            static_cast<const DictionaryValue*>(value);
-        operator_code_.clear();
-        operator_country_.clear();
-        operator_name_.clear();
-        dict->GetStringWithoutPathExpansion(kOperatorNameKey,
-                                            &operator_name_);
-        dict->GetStringWithoutPathExpansion(kOperatorCodeKey,
-                                            &operator_code_);
-        dict->GetStringWithoutPathExpansion(kOperatorCountryKey,
-                                            &operator_country_);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PAYMENT_URL:
-      return value->GetAsString(&payment_url_);
-    case PROPERTY_INDEX_USAGE_URL:
-      return value->GetAsString(&usage_url_);
-    case PROPERTY_INDEX_STATE: {
-      // Save previous state before calling WirelessNetwork::ParseValue.
-      ConnectionState prev_state = state_;
-      if (WirelessNetwork::ParseValue(index, value)) {
-        if (state_ != prev_state)
-          RefreshDataPlansIfNeeded();
-        return true;
-      }
-      break;
-    }
-    default:
-      return WirelessNetwork::ParseValue(index, value);
-  }
-  return false;
-}
-
 bool CellularNetwork::StartActivation() const {
   if (!EnsureCrosLoaded())
     return false;
   return chromeos::ActivateCellularModem(service_path().c_str(), NULL);
 }
 
 void CellularNetwork::RefreshDataPlansIfNeeded() const {
   if (!EnsureCrosLoaded())
     return;
   if (connected() && activated())
@@ skipping 108 matching lines @@
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_NETWORK_ROAMING_STATE_UNKNOWN);
       break;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WifiNetwork
 
 WifiNetwork::WifiNetwork(const std::string& service_path)
-    : WirelessNetwork(service_path, TYPE_WIFI),
+    : WirelessNetwork(service_path, TYPE_WIFI, new NativeWifiNetworkParser),
       encryption_(SECURITY_NONE),
       passphrase_required_(false),
       eap_method_(EAP_METHOD_UNKNOWN),
       eap_phase_2_auth_(EAP_PHASE_2_AUTH_AUTO),
       eap_use_system_cas_(true) {
 }
 
 WifiNetwork::~WifiNetwork() {}
 
 void WifiNetwork::CalculateUniqueId() {
   ConnectionSecurity encryption = encryption_;
   // Flimflam treats wpa and rsn as psk internally, so convert those types
   // to psk for unique naming.
   if (encryption == SECURITY_WPA || encryption == SECURITY_RSN)
     encryption = SECURITY_PSK;
   std::string security = std::string(SecurityToString(encryption));
-  unique_id_ = security + "|" + name_;
+  set_unique_id(security + "|" + name());
 }
 
 bool WifiNetwork::SetSsid(const std::string& ssid) {
   // Detects encoding and convert to UTF-8.
   std::string ssid_utf8;
   if (!IsStringUTF8(ssid)) {
     std::string encoding;
     if (base::DetectEncoding(ssid, &encoding)) {
       if (!base::ConvertToUtf8AndNormalize(ssid, encoding, &ssid_utf8)) {
         ssid_utf8.clear();
@@ skipping 14 matching lines @@
   std::vector<uint8> ssid_raw;
   if (!base::HexStringToBytes(ssid_hex, &ssid_raw)) {
     LOG(ERROR) << "Illegal hex char is found in WiFi.HexSSID.";
     ssid_raw.clear();
     return false;
   }
 
   return SetSsid(std::string(ssid_raw.begin(), ssid_raw.end()));
 }
 
-bool WifiNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_WIFI_HEX_SSID: {
-      std::string ssid_hex;
-      if (!value->GetAsString(&ssid_hex))
-        return false;
-
-      SetHexSsid(ssid_hex);
-      return true;
-    }
-    case PROPERTY_INDEX_WIFI_AUTH_MODE:
-    case PROPERTY_INDEX_WIFI_PHY_MODE:
-    case PROPERTY_INDEX_WIFI_HIDDEN_SSID:
-    case PROPERTY_INDEX_WIFI_FREQUENCY:
-      // These properties are currently not used in the UI.
-      return true;
-    case PROPERTY_INDEX_NAME: {
-      // Does not change network name when it was already set by WiFi.HexSSID.
-      if (!name().empty())
-        return true;
-      else
-        return WirelessNetwork::ParseValue(index, value);
-    }
-    case PROPERTY_INDEX_SECURITY: {
-      std::string security_string;
-      if (value->GetAsString(&security_string)) {
-        encryption_ = ParseSecurity(security_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PASSPHRASE: {
-      std::string passphrase;
-      if (value->GetAsString(&passphrase)) {
-        // Only store the passphrase if we are the owner.
-        // TODO(stevenjb): Remove this when chromium-os:12948 is resolved.
-        if (chromeos::UserManager::Get()->current_user_is_owner())
-          passphrase_ = passphrase;
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PASSPHRASE_REQUIRED:
-      return value->GetAsBoolean(&passphrase_required_);
-    case PROPERTY_INDEX_IDENTITY:
-      return value->GetAsString(&identity_);
-    case PROPERTY_INDEX_EAP_IDENTITY:
-      return value->GetAsString(&eap_identity_);
-    case PROPERTY_INDEX_EAP_METHOD: {
-      std::string method;
-      if (value->GetAsString(&method)) {
-        eap_method_ = ParseEAPMethod(method);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_EAP_PHASE_2_AUTH: {
-      std::string auth;
-      if (value->GetAsString(&auth)) {
-        eap_phase_2_auth_ = ParseEAPPhase2Auth(auth);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY:
-      return value->GetAsString(&eap_anonymous_identity_);
-    case PROPERTY_INDEX_EAP_CERT_ID:
-      return value->GetAsString(&eap_client_cert_pkcs11_id_);
-    case PROPERTY_INDEX_EAP_CA_CERT_NSS:
-      return value->GetAsString(&eap_server_ca_cert_nss_nickname_);
-    case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS:
-      return value->GetAsBoolean(&eap_use_system_cas_);
-    case PROPERTY_INDEX_EAP_PASSWORD:
-      return value->GetAsString(&eap_passphrase_);
-    case PROPERTY_INDEX_EAP_CLIENT_CERT:
-    case PROPERTY_INDEX_EAP_CLIENT_CERT_NSS:
-    case PROPERTY_INDEX_EAP_PRIVATE_KEY:
-    case PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD:
-    case PROPERTY_INDEX_EAP_KEY_ID:
-    case PROPERTY_INDEX_EAP_CA_CERT:
-    case PROPERTY_INDEX_EAP_CA_CERT_ID:
-    case PROPERTY_INDEX_EAP_PIN:
-    case PROPERTY_INDEX_EAP_KEY_MGMT:
-      // These properties are currently not used in the UI.
-      return true;
-    default:
-      return WirelessNetwork::ParseValue(index, value);
-  }
-  return false;
-}
-
 const std::string& WifiNetwork::GetPassphrase() const {
   if (!user_passphrase_.empty())
     return user_passphrase_;
   return passphrase_;
 }
 
 void WifiNetwork::SetPassphrase(const std::string& passphrase) {
   // Set the user_passphrase_ only; passphrase_ stores the flimflam value.
   // If the user sets an empty passphrase, restore it to the passphrase
   // remembered by flimflam.
@@ skipping 20 matching lines @@
 }
 
 void WifiNetwork::SetIdentity(const std::string& identity) {
   SetStringProperty(kIdentityProperty, identity, &identity_);
 }
 
 void WifiNetwork::SetEAPMethod(EAPMethod method) {
   eap_method_ = method;
   switch (method) {
     case EAP_METHOD_PEAP:
-      SetStringProperty(kEapMethodProperty, kEapMethodPEAP, NULL);
+      SetStringProperty(kEapMethodProperty, kEapMethodPeap, NULL);
       break;
     case EAP_METHOD_TLS:
-      SetStringProperty(kEapMethodProperty, kEapMethodTLS, NULL);
+      SetStringProperty(kEapMethodProperty, kEapMethodTls, NULL);
       break;
     case EAP_METHOD_TTLS:
-      SetStringProperty(kEapMethodProperty, kEapMethodTTLS, NULL);
+      SetStringProperty(kEapMethodProperty, kEapMethodTtls, NULL);
       break;
     case EAP_METHOD_LEAP:
-      SetStringProperty(kEapMethodProperty, kEapMethodLEAP, NULL);
+      SetStringProperty(kEapMethodProperty, kEapMethodLeap, NULL);
       break;
     default:
       ClearProperty(kEapMethodProperty);
       break;
   }
 }
 
 void WifiNetwork::SetEAPPhase2Auth(EAPPhase2Auth auth) {
   eap_phase_2_auth_ = auth;
   bool is_peap = (eap_method_ == EAP_METHOD_PEAP);
   switch (auth) {
     case EAP_PHASE_2_AUTH_AUTO:
       ClearProperty(kEapPhase2AuthProperty);
       break;
     case EAP_PHASE_2_AUTH_MD5:
       SetStringProperty(kEapPhase2AuthProperty,
-                        is_peap ? kEapPhase2AuthPEAPMD5
-                                : kEapPhase2AuthTTLSMD5,
+                        is_peap ? kEapPhase2AuthPeapMd5
+                                : kEapPhase2AuthTtlsMd5,
                         NULL);
       break;
     case EAP_PHASE_2_AUTH_MSCHAPV2:
       SetStringProperty(kEapPhase2AuthProperty,
-                        is_peap ? kEapPhase2AuthPEAPMSCHAPV2
-                                : kEapPhase2AuthTTLSMSCHAPV2,
+                        is_peap ? kEapPhase2AuthPeapMschap2
+                                : kEapPhase2AuthTtlsMschapV2,
                         NULL);
       break;
     case EAP_PHASE_2_AUTH_MSCHAP:
-      SetStringProperty(kEapPhase2AuthProperty, kEapPhase2AuthTTLSMSCHAP, NULL);
+      SetStringProperty(kEapPhase2AuthProperty, kEapPhase2AuthTtlsMschap, NULL);
       break;
     case EAP_PHASE_2_AUTH_PAP:
-      SetStringProperty(kEapPhase2AuthProperty, kEapPhase2AuthTTLSPAP, NULL);
+      SetStringProperty(kEapPhase2AuthProperty, kEapPhase2AuthTtlsPap, NULL);
       break;
     case EAP_PHASE_2_AUTH_CHAP:
-      SetStringProperty(kEapPhase2AuthProperty, kEapPhase2AuthTTLSCHAP, NULL);
+      SetStringProperty(kEapPhase2AuthProperty, kEapPhase2AuthTtlsChap, NULL);
       break;
   }
 }
 
 void WifiNetwork::SetEAPServerCaCertNssNickname(
     const std::string& nss_nickname) {
   VLOG(1) << "SetEAPServerCaCertNssNickname " << nss_nickname;
   SetOrClearStringProperty(kEapCaCertNssProperty, nss_nickname,
                            &eap_server_ca_cert_nss_nickname_);
 }
 
 void WifiNetwork::SetEAPClientCertPkcs11Id(const std::string& pkcs11_id) {
   VLOG(1) << "SetEAPClientCertPkcs11Id " << pkcs11_id;
-  SetOrClearStringProperty(kEapCertIDProperty, pkcs11_id,
+  SetOrClearStringProperty(kEapCertIdProperty, pkcs11_id,
                            &eap_client_cert_pkcs11_id_);
   // flimflam requires both CertID and KeyID for TLS connections, despite
   // the fact that by convention they are the same ID.
-  SetOrClearStringProperty(kEapKeyIDProperty, pkcs11_id, NULL);
+  SetOrClearStringProperty(kEapKeyIdProperty, pkcs11_id, NULL);
 }
 
 void WifiNetwork::SetEAPUseSystemCAs(bool use_system_cas) {
-  SetBooleanProperty(kEapUseSystemCAsProperty, use_system_cas,
+  SetBooleanProperty(kEapUseSystemCasProperty, use_system_cas,
                      &eap_use_system_cas_);
 }
 
 void WifiNetwork::SetEAPIdentity(const std::string& identity) {
   SetOrClearStringProperty(kEapIdentityProperty, identity, &eap_identity_);
 }
 
 void WifiNetwork::SetEAPAnonymousIdentity(const std::string& identity) {
   SetOrClearStringProperty(kEapAnonymousIdentityProperty, identity,
                            &eap_anonymous_identity_);
@@ skipping 37 matching lines @@
     }
     case SECURITY_PSK:
       return "PSK";
   }
   return "Unknown";
 }
 
 bool WifiNetwork::IsPassphraseRequired() const {
   // TODO(stevenjb): Remove error_ tests when fixed in flimflam
   // (http://crosbug.com/10135).
-  if (error_ == ERROR_BAD_PASSPHRASE || error_ == ERROR_BAD_WEPKEY)
+  if (error() == ERROR_BAD_PASSPHRASE || error() == ERROR_BAD_WEPKEY)
     return true;
   // For 802.1x networks, configuration is required if connectable is false.
   if (encryption_ == SECURITY_8021X)
-    return !connectable_;
+    return !connectable();
   return passphrase_required_;
 }
 
 bool WifiNetwork::RequiresUserProfile() const {
   // 8021X requires certificates which are only stored for individual users.
   if (encryption_ == SECURITY_8021X &&
       (eap_method_ == EAP_METHOD_TLS ||
        !eap_client_cert_pkcs11_id().empty()))
     return true;
   return false;
@@ skipping 22 matching lines @@
 
   // Called from ConnectToWifiNetwork.
   // Calls ConnectToWifiNetworkUsingConnectData if network request succeeds.
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) = 0;
   // Called from ConnectToVirtualNetwork*.
   // Calls ConnectToVirtualNetworkUsingConnectData if network request succeeds.
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
-      VirtualNetwork::ProviderType provider_type) = 0;
+      ProviderType provider_type) = 0;
   // Called from NetworkConnectStart.
   // Calls NetworkConnectCompleted when the connection attept completes.
   virtual void CallConnectToNetwork(Network* network) = 0;
   // Called from DeleteRememberedNetwork.
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path, const std::string& service_path) = 0;
 
   // Called from Enable*NetworkDevice.
   // Asynchronously enables or disables the specified device type.
   virtual void CallEnableNetworkDeviceType(
@@ skipping 280 matching lines @@
   CellularNetwork::DataLeft GetDataLeft(CellularDataPlanVector* data_plans);
   void UpdateCellularDataPlan(const std::string& service_path,
                               const CellularDataPlanList* data_plan_list);
 
   // Network list management functions.
   void UpdateActiveNetwork(Network* network);
   void AddNetwork(Network* network);
   void DeleteNetwork(Network* network);
   void AddRememberedNetwork(Network* network);
   void DeleteRememberedNetwork(const std::string& service_path);
-  Network* CreateNewNetwork(
-      ConnectionType type, const std::string& service_path);
   void ClearNetworks();
   void ClearRememberedNetworks();
   void DeleteNetworks();
   void DeleteRememberedNetworks();
   void DeleteDevice(const std::string& device_path);
   void DeleteDeviceFromDeviceObserversMap(const std::string& device_path);
 
   // Profile management functions.
   void SetProfileType(Network* network, NetworkProfileType type);
   void SetProfileTypeFromPath(Network* network);
@@ skipping 385 matching lines @@
   NetworkDeviceMap::iterator iter = device_map_.find(path);
   if (iter != device_map_.end())
     return iter->second;
   LOG(WARNING) << "Device path not found: " << path;
   return NULL;
 }
 
 const NetworkDevice* NetworkLibraryImplBase::FindCellularDevice() const {
   for (NetworkDeviceMap::const_iterator iter = device_map_.begin();
        iter != device_map_.end(); ++iter) {
-    if (iter->second->type() == TYPE_CELLULAR)
+    if (iter->second && iter->second->type() == TYPE_CELLULAR)
       return iter->second;
   }
   return NULL;
 }
 
 const NetworkDevice* NetworkLibraryImplBase::FindEthernetDevice() const {
   for (NetworkDeviceMap::const_iterator iter = device_map_.begin();
        iter != device_map_.end(); ++iter) {
     if (iter->second->type() == TYPE_ETHERNET)
       return iter->second;
@@ skipping 425 matching lines @@
     const std::string& username,
     const std::string& user_passphrase) {
   // Store the connection data to be used by the callback.
   connect_data_.service_name = service_name;
   connect_data_.psk_key = psk;
   connect_data_.server_hostname = server_hostname;
   connect_data_.psk_username = username;
   connect_data_.passphrase = user_passphrase;
   CallRequestVirtualNetworkAndConnect(
       service_name, server_hostname,
-      VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK);
+      PROVIDER_TYPE_L2TP_IPSEC_PSK);
 }
 
 // 1. Connect to a virtual network with a user cert.
 void NetworkLibraryImplBase::ConnectToVirtualNetworkCert(
     const std::string& service_name,
     const std::string& server_hostname,
     const std::string& server_ca_cert_nss_nickname,
     const std::string& client_cert_pkcs11_id,
     const std::string& username,
     const std::string& user_passphrase) {
   // Store the connection data to be used by the callback.
   connect_data_.service_name = service_name;
   connect_data_.server_hostname = server_hostname;
   connect_data_.server_ca_cert_nss_nickname = server_ca_cert_nss_nickname;
   connect_data_.client_cert_pkcs11_id = client_cert_pkcs11_id;
   connect_data_.psk_username = username;
   connect_data_.passphrase = user_passphrase;
   CallRequestVirtualNetworkAndConnect(
       service_name, server_hostname,
-      VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+      PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
 }
 
 // 2. Requests a WiFi Network by SSID and security.
 // Calls ConnectToWifiNetworkUsingConnectData if network request succeeds.
 // virtual void CallRequestWifiNetworkAndConnect(
 //     const std::string& ssid, ConnectionSecurity security) = 0;
 
 // 2. Requests a Virtual Network by service name, etc.
 // Calls ConnectToVirtualNetworkUsingConnectData if network request succeeds.
 // virtual void CallRequestVirtualNetworkAndConnect(
 //     const std::string& service_name,
 //     const std::string& server_hostname,
-//     VirtualNetwork::ProviderType provider_type) = 0;
+//     ProviderType provider_type) = 0;
 
 // 3. Sets network properties stored in ConnectData and calls
 // NetworkConnectStart.
 void NetworkLibraryImplBase::ConnectToWifiNetworkUsingConnectData(
     WifiNetwork* wifi) {
   ConnectData& data = connect_data_;
   if (wifi->name() != data.service_name) {
     LOG(WARNING) << "WiFi network name does not match ConnectData: "
                  << wifi->name() << " != " << data.service_name;
     return;
@@ skipping 209 matching lines @@
     }
   }
   DCHECK(!network->profile_path().empty())
       << "Service path not in any profile: " << network->service_path();
 }
 
 void NetworkLibraryImplBase::DeleteRememberedNetwork(
     const std::string& service_path) {
   NetworkMap::iterator found = remembered_network_map_.find(service_path);
   if (found == remembered_network_map_.end()) {
-    LOG(WARNING) << "Attempt to delete non-existant remembered network: "
+    LOG(WARNING) << "Attempt to delete non-existent remembered network: "
                  << service_path;
     return;
   }
 
   // Delete remembered network from lists.
   Network* remembered_network = found->second;
   remembered_network_map_.erase(found);
 
   if (remembered_network->type() == TYPE_WIFI) {
     WifiNetworkVector::iterator iter = std::find(
@@ skipping 33 matching lines @@
     SetProfileType(network, PROFILE_NONE);
   } else {
     // Network is not in visible list.
     VLOG(2) << "Remembered Network not visible: "
             << remembered_network->unique_id();
   }
 
   delete remembered_network;
 }
 
-Network* NetworkLibraryImplBase::CreateNewNetwork(
-    ConnectionType type, const std::string& service_path) {
-  switch (type) {
-    case TYPE_ETHERNET: {
-      EthernetNetwork* ethernet = new EthernetNetwork(service_path);
-      return ethernet;
-    }
-    case TYPE_WIFI: {
-      WifiNetwork* wifi = new WifiNetwork(service_path);
-      return wifi;
-    }
-    case TYPE_CELLULAR: {
-      CellularNetwork* cellular = new CellularNetwork(service_path);
-      return cellular;
-    }
-    case TYPE_VPN: {
-      VirtualNetwork* vpn = new VirtualNetwork(service_path);
-      return vpn;
-    }
-    default: {
-      LOG(WARNING) << "Unknown service type: " << type;
-      return new Network(service_path, type);
-    }
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////
 
 void NetworkLibraryImplBase::ClearNetworks() {
   network_map_.clear();
   network_unique_id_map_.clear();
   ethernet_ = NULL;
   active_wifi_ = NULL;
   active_cellular_ = NULL;
   active_virtual_ = NULL;
   wifi_networks_.clear();
@@ skipping 13 matching lines @@
 }
 
 void NetworkLibraryImplBase::DeleteRememberedNetworks() {
   STLDeleteValues(&remembered_network_map_);
   ClearRememberedNetworks();
 }
 
 void NetworkLibraryImplBase::DeleteDevice(const std::string& device_path) {
   NetworkDeviceMap::iterator found = device_map_.find(device_path);
   if (found == device_map_.end()) {
-    LOG(WARNING) << "Attempt to delete non-existant device: "
+    LOG(WARNING) << "Attempt to delete non-existent device: "
                  << device_path;
     return;
   }
   VLOG(2) << " Deleting device: " << device_path;
   NetworkDevice* device = found->second;
   device_map_.erase(found);
   delete device;
   DeleteDeviceFromDeviceObserversMap(device_path);
 }
 
@@ skipping 204 matching lines @@
       const std::string& device_path) OVERRIDE;
   virtual void MonitorNetworkDeviceStop(
       const std::string& device_path) OVERRIDE;
 
   virtual void CallConnectToNetwork(Network* network) OVERRIDE;
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) OVERRIDE;
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
-      VirtualNetwork::ProviderType provider_type) OVERRIDE;
+      ProviderType provider_type) OVERRIDE;
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path,
       const std::string& service_path) OVERRIDE;
 
   //////////////////////////////////////////////////////////////////////////////
   // NetworkLibrary implementation.
 
   virtual void ChangePin(const std::string& old_pin,
                          const std::string& new_pin) OVERRIDE;
   virtual void ChangeRequirePin(bool require_pin,
@@ skipping 16 matching lines @@
       const std::string& device_path,
       std::string* hardware_address,
       HardwareAddressFormat format) OVERRIDE;
   virtual void SetIPConfig(const NetworkIPConfig& ipconfig) OVERRIDE;
 
   //////////////////////////////////////////////////////////////////////////////
   // Calbacks.
   static void NetworkStatusChangedHandler(
       void* object, const char* path, const char* key, const Value* value);
   void UpdateNetworkStatus(
-      const char* path, const char* key, const Value* value);
+      const std::string& path, const std::string& key, const Value& value);
 
   static void NetworkDevicePropertyChangedHandler(
       void* object, const char* path, const char* key, const Value* value);
   void UpdateNetworkDeviceStatus(
-      const char* path, const char* key, const Value* value);
+      const std::string& path, const std::string& key, const Value& value);
 
   static void PinOperationCallback(void* object,
                                    const char* path,
                                    NetworkMethodErrorType error,
                                    const char* error_message);
 
   static void CellularRegisterCallback(void* object,
                                        const char* path,
                                        NetworkMethodErrorType error,
                                        const char* error_message);
@@ skipping 22 matching lines @@
   static void RememberedNetworkServiceUpdate(
       void* object, const char* service_path, const Value* info);
   static void ProfileUpdate(
       void* object, const char* profile_path, const Value* info);
   static void NetworkDeviceUpdate(
       void* object, const char* device_path, const Value* info);
 
  private:
   // This processes all Manager update messages.
   void NetworkManagerStatusChanged(const char* key, const Value* value);
-  void ParseNetworkManager(const DictionaryValue* dict);
+  void ParseNetworkManager(const DictionaryValue& dict);
   void UpdateTechnologies(const ListValue* technologies, int* bitfieldp);
   void UpdateAvailableTechnologies(const ListValue* technologies);
   void UpdateEnabledTechnologies(const ListValue* technologies);
   void UpdateConnectedTechnologies(const ListValue* technologies);
 
   // Update network lists.
   void UpdateNetworkServiceList(const ListValue* services);
   void UpdateWatchedNetworkServiceList(const ListValue* services);
   Network* ParseNetwork(const std::string& service_path,
-                        const DictionaryValue* info);
+                        const DictionaryValue& info);
 
   void UpdateRememberedNetworks(const ListValue* profiles);
   void RequestRememberedNetworksUpdate();
   void UpdateRememberedServiceList(const char* profile_path,
                                    const ListValue* profile_entries);
   Network* ParseRememberedNetwork(const std::string& service_path,
-                                  const DictionaryValue* info);
+                                  const DictionaryValue& info);
 
   // NetworkDevice list management functions.
   void UpdateNetworkDeviceList(const ListValue* devices);
   void ParseNetworkDevice(const std::string& device_path,
-                          const DictionaryValue* info);
+                          const DictionaryValue& info);
 
   // Empty device observer to ensure that device property updates are received.
   class NetworkLibraryDeviceObserver : public NetworkDeviceObserver {
    public:
     virtual ~NetworkLibraryDeviceObserver() {}
     virtual void OnNetworkDeviceChanged(
         NetworkLibrary* cros, const NetworkDevice* device) OVERRIDE {}
   };
 
   typedef std::map<std::string, chromeos::PropertyChangeMonitor>
@@ skipping 99 matching lines @@
     montitored_devices_.erase(iter);
   }
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkStatusChangedHandler(
     void* object, const char* path, const char* key, const Value* value) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkStatus(path, key, value);
+  if (key == NULL || value == NULL || path == NULL || object == NULL)
+    return;
+  networklib->UpdateNetworkStatus(std::string(path), std::string(key), *value);
 }
 
 void NetworkLibraryImplCros::UpdateNetworkStatus(
-    const char* path, const char* key, const Value* value) {
+    const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (key == NULL || value == NULL)
-    return;
   Network* network = FindNetworkByPath(path);
   if (network) {
     VLOG(2) << "UpdateNetworkStatus: " << network->name() << "." << key;
     bool prev_connected = network->connected();
-    // Note: ParseValue is virtual.
-    int index = property_index_parser().Get(std::string(key));
-    if (!network->ParseValue(index, value)) {
-      LOG(WARNING) << "UpdateNetworkStatus: Error parsing: "
+    if (!network->UpdateStatus(key, value, NULL)) {
+      LOG(WARNING) << "UpdateNetworkStatus: Error updating: "
                    << path << "." << key;
     }
     // If we just connected, this may have been added to remembered list.
     if (!prev_connected && network->connected())
       RequestRememberedNetworksUpdate();
     NotifyNetworkChanged(network);
     // Anything observing the manager needs to know about any service change.
     NotifyNetworkManagerChanged(false);  // Not forced.
   }
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkDevicePropertyChangedHandler(
     void* object, const char* path, const char* key, const Value* value) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkDeviceStatus(path, key, value);
+  if (key == NULL || value == NULL || path == NULL || object == NULL)
+    return;
+  networklib->UpdateNetworkDeviceStatus(std::string(path),
+                                        std::string(key),
+                                        *value);
 }
 
 void NetworkLibraryImplCros::UpdateNetworkDeviceStatus(
-    const char* path, const char* key, const Value* value) {
+    const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (key == NULL || value == NULL)
-    return;
   NetworkDevice* device = FindNetworkDeviceByPath(path);
   if (device) {
     VLOG(2) << "UpdateNetworkDeviceStatus: " << device->name() << "." << key;
-    PropertyIndex index = property_index_parser().Get(std::string(key));
-    if (!device->ParseValue(index, value)) {
-      VLOG(1) << "UpdateNetworkDeviceStatus: Failed to parse: "
+    PropertyIndex index = PROPERTY_INDEX_UNKNOWN;
+    if (device->UpdateStatus(key, value, &index)) {
+      if (index == PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING) {
+        bool settings_value =
+            UserCrosSettingsProvider::cached_data_roaming_enabled();
+        if (device->data_roaming_allowed() != settings_value) {
+          // Switch back to signed settings value.
+          SetCellularDataRoamingAllowed(settings_value);
+          return;
+        }
+      }
+    } else {
+      VLOG(1) << "UpdateNetworkDeviceStatus: Failed to update: "
               << path << "." << key;
-    } else if (index == PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING) {
-      bool settings_value =
-          UserCrosSettingsProvider::cached_data_roaming_enabled();
-      if (device->data_roaming_allowed() != settings_value) {
-        // Switch back to signed settings value.
-        SetCellularDataRoamingAllowed(settings_value);
-        return;
-      }
     }
     // Notify only observers on device property change.
     NotifyNetworkDeviceChanged(device, index);
     // If a device's power state changes, new properties may become defined.
     if (index == PROPERTY_INDEX_POWERED)
-      chromeos::RequestNetworkDeviceInfo(path, &NetworkDeviceUpdate, this);
+      chromeos::RequestNetworkDeviceInfo(path.c_str(),
+                                         &NetworkDeviceUpdate,
+                                         this);
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase connect implementation.
 
 // static callback
 void NetworkLibraryImplCros::NetworkConnectCallback(
     void* object,
     const char* service_path,
     NetworkMethodErrorType error,
     const char* error_message) {
   NetworkConnectStatus status;
   if (error == NETWORK_METHOD_ERROR_NONE) {
     status = CONNECT_SUCCESS;
   } else {
     LOG(WARNING) << "Error from ServiceConnect callback for: "
                  << service_path
                  << " Error: " << error << " Message: " << error_message;
     if (error_message &&
         strcmp(error_message, kErrorPassphraseRequiredMsg) == 0) {
       status = CONNECT_BAD_PASSPHRASE;
     } else {
       status = CONNECT_FAILED;
     }
   }
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
-  Network* network = networklib->FindNetworkByPath(service_path);
+  Network* network = networklib->FindNetworkByPath(std::string(service_path));
   if (!network) {
     LOG(ERROR) << "No network for path: " << service_path;
     return;
   }
   networklib->NetworkConnectCompleted(network, status);
 }
 
 void NetworkLibraryImplCros::CallConnectToNetwork(Network* network) {
   DCHECK(network);
   chromeos::RequestNetworkServiceConnect(network->service_path().c_str(),
                                          NetworkConnectCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::WifiServiceUpdateAndConnect(
     void* object, const char* service_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path && info) {
     DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
     const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
     Network* network =
-        networklib->ParseNetwork(std::string(service_path), dict);
+        networklib->ParseNetwork(std::string(service_path), *dict);
     DCHECK_EQ(network->type(), TYPE_WIFI);
     networklib->ConnectToWifiNetworkUsingConnectData(
         static_cast<WifiNetwork*>(network));
   }
 }
 
 void NetworkLibraryImplCros::CallRequestWifiNetworkAndConnect(
     const std::string& ssid, ConnectionSecurity security) {
   // Asynchronously request service properties and call
   // WifiServiceUpdateAndConnect.
   chromeos::RequestHiddenWifiNetwork(ssid.c_str(),
                                      SecurityToString(security),
                                      WifiServiceUpdateAndConnect,
                                      this);
 }
 
 // static callback
 void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
     void* object, const char* service_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path && info) {
     VLOG(1) << "Connecting to new VPN Service: " << service_path;
     DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
     const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
     Network* network =
-        networklib->ParseNetwork(std::string(service_path), dict);
+        networklib->ParseNetwork(std::string(service_path), *dict);
     DCHECK_EQ(network->type(), TYPE_VPN);
     networklib->ConnectToVirtualNetworkUsingConnectData(
         static_cast<VirtualNetwork*>(network));
   } else {
     LOG(WARNING) << "Unable to create VPN Service: " << service_path;
   }
 }
 
 void NetworkLibraryImplCros::CallRequestVirtualNetworkAndConnect(
     const std::string& service_name,
     const std::string& server_hostname,
-    VirtualNetwork::ProviderType provider_type) {
+    ProviderType provider_type) {
   chromeos::RequestVirtualNetwork(service_name.c_str(),
                                   server_hostname.c_str(),
                                   ProviderTypeToString(provider_type),
                                   VPNServiceUpdateAndConnect,
                                   this);
 }
 
 void NetworkLibraryImplCros::CallDeleteRememberedNetwork(
     const std::string& profile_path,
     const std::string& service_path) {
@@ skipping 335 matching lines @@
 }
 
 // This processes all Manager update messages.
 void NetworkLibraryImplCros::NetworkManagerStatusChanged(
     const char* key, const Value* value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::TimeTicks start = base::TimeTicks::Now();
   if (!key)
     return;
   VLOG(1) << "NetworkManagerStatusChanged: KEY=" << key;
-  int index = property_index_parser().Get(std::string(key));
+  int index = NativeNetworkParser::property_mapper()->Get(key);
   switch (index) {
     case PROPERTY_INDEX_STATE:
       // Currently we ignore the network manager state.
       break;
     case PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES: {
       DCHECK_EQ(value->GetType(), Value::TYPE_LIST);
       const ListValue* vlist = static_cast<const ListValue*>(value);
       UpdateAvailableTechnologies(vlist);
       break;
     }
@@ skipping 49 matching lines @@
     }
     case PROPERTY_INDEX_DEVICE:
     case PROPERTY_INDEX_DEVICES: {
       DCHECK_EQ(value->GetType(), Value::TYPE_LIST);
       const ListValue* vlist = static_cast<const ListValue*>(value);
       UpdateNetworkDeviceList(vlist);
       break;
     }
     case PROPERTY_INDEX_PORTAL_URL:
     case PROPERTY_INDEX_CHECK_PORTAL_LIST:
-      // Currently we ignore PortalURL and CheckPortalList.
+    case PROPERTY_INDEX_ARP_GATEWAY:
+      // Currently we ignore PortalURL, CheckPortalList and ArpGateway.
       break;
     default:
       LOG(WARNING) << "Manager: Unhandled key: " << key;
       break;
   }
   base::TimeDelta delta = base::TimeTicks::Now() - start;
   VLOG(2) << "NetworkManagerStatusChanged: time: "
           << delta.InMilliseconds() << " ms.";
   HISTOGRAM_TIMES("CROS_NETWORK_UPDATE", delta);
 }
 
 // static
 void NetworkLibraryImplCros::NetworkManagerUpdate(
     void* object, const char* manager_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (!info) {
     LOG(ERROR) << "Error retrieving manager properties: " << manager_path;
     return;
   }
   VLOG(1) << "Received NetworkManagerUpdate.";
   DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
   const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-  networklib->ParseNetworkManager(dict);
+  networklib->ParseNetworkManager(*dict);
 }
 
-void NetworkLibraryImplCros::ParseNetworkManager(const DictionaryValue* dict) {
-  for (DictionaryValue::key_iterator iter = dict->begin_keys();
-       iter != dict->end_keys(); ++iter) {
+void NetworkLibraryImplCros::ParseNetworkManager(const DictionaryValue& dict) {
+  for (DictionaryValue::key_iterator iter = dict.begin_keys();
+       iter != dict.end_keys(); ++iter) {
     const std::string& key = *iter;
     Value* value;
-    bool res = dict->GetWithoutPathExpansion(key, &value);
+    bool res = dict.GetWithoutPathExpansion(key, &value);
     CHECK(res);
     NetworkManagerStatusChanged(key.c_str(), value);
   }
   // If there is no Profiles entry, request remembered networks here.
-  if (!dict->HasKey(kProfilesProperty))
+  if (!dict.HasKey(kProfilesProperty))
     RequestRememberedNetworksUpdate();
 }
 
 // static
 void NetworkLibraryImplCros::DataPlanUpdateHandler(
     void* object,
     const char* modem_service_path,
     const CellularDataPlanList* dataplan) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
@@ skipping 10 matching lines @@
     const ListValue* technologies, int* bitfieldp) {
   DCHECK(bitfieldp);
   if (!technologies)
     return;
   int bitfield = 0;
   for (ListValue::const_iterator iter = technologies->begin();
        iter != technologies->end(); ++iter) {
     std::string technology;
     (*iter)->GetAsString(&technology);
     if (!technology.empty()) {
-      ConnectionType type = ParseType(technology);
+      ConnectionType type =
+          NativeNetworkParser::ParseConnectionType(technology);
       bitfield |= 1 << type;
     }
   }
   *bitfieldp = bitfield;
   NotifyNetworkManagerChanged(false);  // Not forced.
 }
 
 void NetworkLibraryImplCros::UpdateAvailableTechnologies(
     const ListValue* technologies) {
   UpdateTechnologies(technologies, &available_devices_);
@@ skipping 65 matching lines @@
        iter != old_network_map.end(); ++iter) {
     Network* network = iter->second;
     if (network->failed() && network->notify_failure()) {
       // We have not notified observers of a connection failure yet.
       AddNetwork(network);
     } else if (network->connecting()) {
       // Network was in connecting state; set state to failed.
       network->SetState(STATE_FAILURE);
       AddNetwork(network);
     } else {
-      VLOG(2) << "Deleting non-existant Network: " << network->name()
+      VLOG(2) << "Deleting non-existent Network: " << network->name()
               << " State = " << network->GetStateString();
       DeleteNetwork(network);
     }
   }
   // If the last network has disappeared, nothing else will
   // have notified observers, so do it now.
   if (services->empty())
     NotifyNetworkManagerChanged(true);  // Forced update
 }
 
@@ skipping 19 matching lines @@
 void NetworkLibraryImplCros::NetworkServiceUpdate(
     void* object, const char* service_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path) {
     if (!info)
       return;  // Network no longer in visible list, ignore.
     DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
     const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-    networklib->ParseNetwork(std::string(service_path), dict);
+    networklib->ParseNetwork(std::string(service_path), *dict);
   }
 }
 
 // Called from NetworkServiceUpdate and WifiServiceUpdateAndConnect.
 Network* NetworkLibraryImplCros::ParseNetwork(
-    const std::string& service_path, const DictionaryValue* info) {
+    const std::string& service_path, const DictionaryValue& info) {
   Network* network = FindNetworkByPath(service_path);
   if (!network) {
-    ConnectionType type = ParseTypeFromDictionary(info);
-    network = CreateNewNetwork(type, service_path);
+    NativeNetworkParser parser;
+    network = parser.CreateNetworkFromInfo(service_path, info);
     AddNetwork(network);
+  } else {
+    // Erase entry from network_unique_id_map_ in case unique id changes.
+    if (!network->unique_id().empty())
+      network_unique_id_map_.erase(network->unique_id());
+    network->network_parser()->UpdateNetworkFromInfo(info, network);
   }
 
-  // Erase entry from network_unique_id_map_ in case unique id changes.
-  if (!network->unique_id().empty())
-    network_unique_id_map_.erase(network->unique_id());
-
-  network->ParseInfo(info);  // virtual.
-
   if (!network->unique_id().empty())
     network_unique_id_map_[network->unique_id()] = network;
 
   SetProfileTypeFromPath(network);
 
   UpdateActiveNetwork(network);
 
   // Copy remembered credentials if required.
   Network* remembered = FindRememberedFromNetwork(network);
   if (remembered)
@@ skipping 138 matching lines @@
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path) {
     if (!info) {
       // Remembered network no longer exists.
       networklib->DeleteRememberedNetwork(std::string(service_path));
     } else {
       DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-      networklib->ParseRememberedNetwork(std::string(service_path), dict);
+      networklib->ParseRememberedNetwork(std::string(service_path), *dict);
     }
   }
 }
 
 // Returns NULL if |service_path| refers to a network that is not a
 // remembered type. Called from RememberedNetworkServiceUpdate.
 Network* NetworkLibraryImplCros::ParseRememberedNetwork(
-    const std::string& service_path, const DictionaryValue* info) {
+    const std::string& service_path, const DictionaryValue& info) {
   Network* remembered;
   NetworkMap::iterator found = remembered_network_map_.find(service_path);
   if (found != remembered_network_map_.end()) {
     remembered = found->second;
+    remembered->network_parser()->UpdateNetworkFromInfo(info, remembered);
   } else {
-    ConnectionType type = ParseTypeFromDictionary(info);
-    if (type == TYPE_WIFI || type == TYPE_VPN) {
-      remembered = CreateNewNetwork(type, service_path);
+    NativeNetworkParser parser;
+    remembered = parser.CreateNetworkFromInfo(service_path, info);
+    if (remembered->type() == TYPE_WIFI || remembered->type() == TYPE_VPN) {
       AddRememberedNetwork(remembered);
     } else {
-      VLOG(1) << "Ignoring remembered network: " << service_path
-              << " Type: " << ConnectionTypeToString(type);
+      LOG(WARNING) << "Ignoring remembered network: " << service_path
+                   << " Type: " << ConnectionTypeToString(remembered->type());
+      delete remembered;
       return NULL;
     }
   }
-  remembered->ParseInfo(info);  // virtual.
 
   SetProfileTypeFromPath(remembered);
 
   VLOG(1) << "ParseRememberedNetwork: " << remembered->name()
           << " path: " << remembered->service_path()
           << " profile: " << remembered->profile_path_;
   NotifyNetworkManagerChanged(false);  // Not forced.
 
   if (remembered->type() == TYPE_VPN) {
     // VPNs are only stored in profiles. If we don't have a network for it,
@@ skipping 25 matching lines @@
   device_map_.clear();
   VLOG(2) << "Updating Device List.";
   for (ListValue::const_iterator iter = devices->begin();
        iter != devices->end(); ++iter) {
     std::string device_path;
     (*iter)->GetAsString(&device_path);
     if (!device_path.empty()) {
       NetworkDeviceMap::iterator found = old_device_map.find(device_path);
       if (found != old_device_map.end()) {
         VLOG(2) << " Adding existing device: " << device_path;
+        CHECK(found->second) << "Attempted to add NULL device pointer";
         device_map_[device_path] = found->second;
         old_device_map.erase(found);
       }
       chromeos::RequestNetworkDeviceInfo(device_path.c_str(),
                                          &NetworkDeviceUpdate,
                                          this);
     }
   }
   // Delete any old devices that no longer exist.
   for (NetworkDeviceMap::iterator iter = old_device_map.begin();
@@ skipping 10 matching lines @@
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (device_path) {
     if (!info) {
       // device no longer exists.
       networklib->DeleteDevice(std::string(device_path));
     } else {
       DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-      networklib->ParseNetworkDevice(std::string(device_path), dict);
+      networklib->ParseNetworkDevice(std::string(device_path), *dict);
     }
   }
 }
 
-void NetworkLibraryImplCros::ParseNetworkDevice(
-    const std::string& device_path, const DictionaryValue* info) {
+void NetworkLibraryImplCros::ParseNetworkDevice(const std::string& device_path,
+                                                const DictionaryValue& info) {
   NetworkDeviceMap::iterator found = device_map_.find(device_path);
   NetworkDevice* device;
   if (found != device_map_.end()) {
     device = found->second;
+    device->device_parser()->UpdateDeviceFromInfo(info, device);
   } else {
-    device = new NetworkDevice(device_path);
+    NativeNetworkDeviceParser parser;
+    device = parser.CreateDeviceFromInfo(device_path, info);
     VLOG(2) << " Adding device: " << device_path;
-    device_map_[device_path] = device;
+    if (device) {
+      device_map_[device_path] = device;
+    }
+    CHECK(device) << "Attempted to add NULL device for path: " << device_path;
   }
-  device->ParseInfo(info);
   VLOG(1) << "ParseNetworkDevice:" << device->name();
   NotifyNetworkManagerChanged(false);  // Not forced.
   AddNetworkDeviceObserver(device_path, network_device_observer_.get());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 class NetworkLibraryImplStub : public NetworkLibraryImplBase {
  public:
   NetworkLibraryImplStub();
@@ skipping 10 matching lines @@
       const std::string& device_path) OVERRIDE {}
   virtual void MonitorNetworkDeviceStop(
       const std::string& device_path) OVERRIDE {}
 
   virtual void CallConnectToNetwork(Network* network) OVERRIDE;
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) OVERRIDE;
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
-      VirtualNetwork::ProviderType provider_type) OVERRIDE;
+      ProviderType provider_type) OVERRIDE;
 
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path,
       const std::string& service_path) OVERRIDE {}
 
   // NetworkLibrary implementation.
 
   virtual void ChangePin(const std::string& old_pin,
                          const std::string& new_pin) OVERRIDE;
   virtual void ChangeRequirePin(bool require_pin,
@@ skipping 52 matching lines @@
   is_locked_ = false;
 
   // Devices
   int devices =
       (1 << TYPE_ETHERNET) | (1 << TYPE_WIFI) | (1 << TYPE_CELLULAR);
   available_devices_ = devices;
   enabled_devices_ = devices;
   connected_devices_ = devices;
 
   NetworkDevice* cellular = new NetworkDevice("cellular");
-  scoped_ptr<Value> cellular_type(Value::CreateStringValue(kTypeCellular));
-  cellular->ParseValue(PROPERTY_INDEX_TYPE, cellular_type.get());
-  cellular->IMSI_ = "123456789012345";
+  cellular->type_ = TYPE_CELLULAR;
+  cellular->imsi_ = "123456789012345";
   device_map_["cellular"] = cellular;
 
   // Networks
   DeleteNetworks();
 
   ethernet_ = new EthernetNetwork("eth1");
   ethernet_->set_connected(true);
   AddNetwork(ethernet_);
 
   WifiNetwork* wifi1 = new WifiNetwork("fw1");
   wifi1->set_name("Fake WiFi Connected");
   wifi1->set_strength(90);
   wifi1->set_connected(false);
   wifi1->set_connecting(true);
-  wifi1->set_active(true);
+  wifi1->set_is_active(true);
   wifi1->set_encryption(SECURITY_NONE);
   wifi1->set_profile_type(PROFILE_SHARED);
   AddNetwork(wifi1);
 
   WifiNetwork* wifi2 = new WifiNetwork("fw2");
   wifi2->set_name("Fake WiFi");
   wifi2->set_strength(70);
   wifi2->set_connected(false);
   wifi2->set_encryption(SECURITY_NONE);
   wifi2->set_profile_type(PROFILE_SHARED);
@@ skipping 33 matching lines @@
   wifi6->set_connected(false);
   AddNetwork(wifi6);
 
   active_wifi_ = wifi1;
 
   CellularNetwork* cellular1 = new CellularNetwork("fc1");
   cellular1->set_name("Fake Cellular");
   cellular1->set_strength(70);
   cellular1->set_connected(false);
   cellular1->set_connecting(true);
-  cellular1->set_active(true);
+  cellular1->set_is_active(true);
   cellular1->set_activation_state(ACTIVATION_STATE_ACTIVATED);
   cellular1->set_payment_url(std::string("http://www.google.com"));
   cellular1->set_usage_url(std::string("http://www.google.com"));
   cellular1->set_network_technology(NETWORK_TECHNOLOGY_EVDO);
   cellular1->set_roaming_state(ROAMING_STATE_ROAMING);
 
   CellularDataPlan* base_plan = new CellularDataPlan();
   base_plan->plan_name = "Base plan";
   base_plan->plan_type = CELLULAR_DATA_PLAN_METERED_BASE;
   base_plan->plan_data_bytes = 100ll * 1024 * 1024;
@@ skipping 17 matching lines @@
   cellular2->set_strength(70);
   cellular2->set_connected(true);
   cellular2->set_activation_state(ACTIVATION_STATE_ACTIVATED);
   cellular2->set_network_technology(NETWORK_TECHNOLOGY_UMTS);
   AddNetwork(cellular2);
 
   // VPNs
   VirtualNetwork* vpn1 = new VirtualNetwork("fv1");
   vpn1->set_name("Fake VPN Provider 1");
   vpn1->set_server_hostname("vpn1server.fake.com");
-  vpn1->set_provider_type(VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK);
+  vpn1->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_PSK);
   vpn1->set_username("VPN User 1");
   vpn1->set_connected(false);
   AddNetwork(vpn1);
 
   VirtualNetwork* vpn2 = new VirtualNetwork("fv2");
   vpn2->set_name("Fake VPN Provider 2");
   vpn2->set_server_hostname("vpn2server.fake.com");
-  vpn2->set_provider_type(VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+  vpn2->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
   vpn2->set_username("VPN User 2");
   vpn2->set_connected(true);
   AddNetwork(vpn2);
 
   VirtualNetwork* vpn3 = new VirtualNetwork("fv3");
   vpn3->set_name("Fake VPN Provider 3");
   vpn3->set_server_hostname("vpn3server.fake.com");
-  vpn3->set_provider_type(VirtualNetwork::PROVIDER_TYPE_OPEN_VPN);
+  vpn3->set_provider_type(PROVIDER_TYPE_OPEN_VPN);
   vpn3->set_connected(false);
   AddNetwork(vpn3);
 
   active_virtual_ = vpn2;
 
   // Remembered Networks
   DeleteRememberedNetworks();
   NetworkProfile profile("default", PROFILE_SHARED);
   profile.services.insert("fw2");
   profile.services.insert("fv2");
   profile_list_.push_back(profile);
   WifiNetwork* remembered_wifi2 = new WifiNetwork("fw2");
   remembered_wifi2->set_name("Fake WiFi 2");
   remembered_wifi2->set_encryption(SECURITY_WEP);
   AddRememberedNetwork(remembered_wifi2);
   VirtualNetwork* remembered_vpn2 = new VirtualNetwork("fv2");
   remembered_vpn2->set_name("Fake VPN Provider 2");
   remembered_vpn2->set_server_hostname("vpn2server.fake.com");
   remembered_vpn2->set_provider_type(
-      VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+      PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
   remembered_vpn2->set_connected(true);
   AddRememberedNetwork(remembered_vpn2);
 
   wifi_scanning_ = false;
   offline_mode_ = false;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase implementation.
 
 void NetworkLibraryImplStub::CallConnectToNetwork(Network* network) {
   NetworkConnectCompleted(network, CONNECT_SUCCESS);
 }
 
 void NetworkLibraryImplStub::CallRequestWifiNetworkAndConnect(
     const std::string& ssid, ConnectionSecurity security) {
   WifiNetwork* wifi = new WifiNetwork(ssid);
   wifi->set_encryption(security);
   AddNetwork(wifi);
   ConnectToWifiNetworkUsingConnectData(wifi);
 }
 
 void NetworkLibraryImplStub::CallRequestVirtualNetworkAndConnect(
     const std::string& service_name,
     const std::string& server_hostname,
-    VirtualNetwork::ProviderType provider_type) {
+    ProviderType provider_type) {
   VirtualNetwork* vpn = new VirtualNetwork(service_name);
   vpn->set_server_hostname(server_hostname);
   vpn->set_provider_type(provider_type);
   AddNetwork(vpn);
   ConnectToVirtualNetworkUsingConnectData(vpn);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary implementation.
 
@@ skipping 75 matching lines @@
   return network_library;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);