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

chrome/browser/chromeos/cros/network_library.cc

Index: chrome/browser/chromeos/cros/network_library.cc
diff --git a/chrome/browser/chromeos/cros/network_library.cc b/chrome/browser/chromeos/cros/network_library.cc
index 7f2dca60d2348e02271abd4902a4fddb113e4ecb..324a7dd08c657ab6a87e349feb085e9dea2dc557 100644
--- a/chrome/browser/chromeos/cros/network_library.cc
+++ b/chrome/browser/chromeos/cros/network_library.cc
@@ -11,6 +11,7 @@
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
+#include "base/json/json_writer.h" // for debug output only.
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
@@ -21,6 +22,8 @@
 #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"
@@ -37,10 +40,10 @@
 // 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.
@@ -51,8 +54,8 @@
 //  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.
@@ -101,813 +104,6 @@ const int kRecentPlanPaymentHours = 6;
 // 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.
 
@@ -968,158 +164,33 @@ NetworkDevice::NetworkDevice(const std::string& device_path)
       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),
@@ -1132,7 +203,8 @@ Network::Network(const std::string& service_path, ConnectionType type)
       notify_failure_(false),
       profile_type_(PROFILE_NONE),
       service_path_(service_path),
-      type_(type) {
+      type_(type),
+      network_parser_(parser) {
 }
 
 Network::~Network() {}
@@ -1161,96 +233,9 @@ void Network::SetName(const std::string& name) {
   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() {
@@ -1436,91 +421,31 @@ void Network::InitIPAddress() {
   }
 }
 
+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)

[Greg Spencer (Chromium), 2011/08/04 23:02:14]

When we want to support a new parser, we can add a second constructor here that
takes the parser as well.

+    : 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_);
@@ -1530,7 +455,7 @@ void VirtualNetwork::EraseCredentials() {
 
 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 {
@@ -1625,17 +550,6 @@ void VirtualNetwork::SetCertificateSlotAndPin(
 ////////////////////////////////////////////////////////////////////////////////
 // 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
 
@@ -1883,7 +797,8 @@ void CellularApn::Set(const DictionaryValue& dict) {
 // 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),
@@ -1893,90 +808,6 @@ CellularNetwork::CellularNetwork(const std::string& service_path)
 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;
@@ -2105,7 +936,7 @@ std::string CellularNetwork::GetRoamingStateString() const {
 // 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),
@@ -2122,7 +953,7 @@ void WifiNetwork::CalculateUniqueId() {
   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) {
@@ -2157,97 +988,6 @@ bool WifiNetwork::SetHexSsid(const std::string& ssid_hex) {
   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_;
@@ -2411,11 +1151,11 @@ std::string WifiNetwork::GetEncryptionString() const {
 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_;
 }
 
@@ -2458,7 +1198,7 @@ class NetworkLibraryImplBase : public NetworkLibrary  {
   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;
@@ -3165,7 +1905,7 @@ NetworkDevice* NetworkLibraryImplBase::FindNetworkDeviceByPath(
 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;
@@ -3611,7 +2351,7 @@ void NetworkLibraryImplBase::ConnectToVirtualNetworkPSK(
   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.
@@ -3631,7 +2371,7 @@ void NetworkLibraryImplBase::ConnectToVirtualNetworkCert(
   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.
@@ -3644,7 +2384,7 @@ void NetworkLibraryImplBase::ConnectToVirtualNetworkCert(
 // 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.
@@ -3853,7 +2593,7 @@ 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;
   }
@@ -3928,7 +2668,7 @@ Network* NetworkLibraryImplBase::CreateNewNetwork(
     }
     default: {
       LOG(WARNING) << "Unknown service type: " << type;
-      return new Network(service_path, type);
+      return new Network(service_path, type, NULL);
     }
   }
 }
@@ -3966,7 +2706,7 @@ void NetworkLibraryImplBase::DeleteRememberedNetworks() {
 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;
   }
@@ -4191,7 +2931,7 @@ class NetworkLibraryImplCros : public NetworkLibraryImplBase  {
   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;
@@ -4228,12 +2968,12 @@ class NetworkLibraryImplCros : public NetworkLibraryImplBase  {
   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,
@@ -4276,7 +3016,7 @@ class NetworkLibraryImplCros : public NetworkLibraryImplBase  {
  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);
@@ -4286,19 +3026,19 @@ class NetworkLibraryImplCros : public NetworkLibraryImplBase  {
   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 {
@@ -4418,22 +3158,20 @@ void NetworkLibraryImplCros::NetworkStatusChangedHandler(
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkStatus(path, key, value);
+  if (key == NULL || value == NULL)

[stevenjb, 2011/08/05 18:46:58]

Add a NULL check for path since string conversion would crash on NULL.

+    return;
+  networklib->UpdateNetworkStatus(path, key, *value);

[stevenjb, 2011/08/05 18:46:58]

nit: Even though we do a NULL check here, we should still avoid explicit string
conversion, so add std::string(path), etc, here and elsewhere.

[Greg Spencer (Chromium), 2011/08/11 22:19:32]

You mean implicit, right?

OK, I've added these in the callbacks where they're needed.

[stevenjb, 2011/08/12 21:32:37]

Right, yes. Cool.

 }
 
 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.
@@ -4451,20 +3189,20 @@ void NetworkLibraryImplCros::NetworkDevicePropertyChangedHandler(
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkDeviceStatus(path, key, value);
+  if (key == NULL || value == NULL)
+    return;
+  networklib->UpdateNetworkDeviceStatus(path, 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)) {

[stevenjb, 2011/08/05 18:46:58]

This logic is a little hard to follow now - index, which is set in the first if
clause, gets used in the second if clause. I would either invert the logic, or
pull the UpdateStatus call out of the if clause.

[Greg Spencer (Chromium), 2011/08/11 22:19:32]

OK, I've switched it, it should be more clear now.

+      VLOG(1) << "UpdateNetworkDeviceStatus: Failed to update: "
               << path << "." << key;
     } else if (index == PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING) {
       bool settings_value =
@@ -4479,7 +3217,9 @@ void NetworkLibraryImplCros::UpdateNetworkDeviceStatus(
     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);
   }
 }
 
@@ -4532,7 +3272,7 @@ void NetworkLibraryImplCros::WifiServiceUpdateAndConnect(
     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));
@@ -4560,7 +3300,7 @@ void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
     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));
@@ -4572,7 +3312,7 @@ void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
 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),
@@ -4928,7 +3668,7 @@ void NetworkLibraryImplCros::NetworkManagerStatusChanged(
   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.
@@ -4994,7 +3734,8 @@ void NetworkLibraryImplCros::NetworkManagerStatusChanged(
     }
     case PROPERTY_INDEX_PORTAL_URL:
     case PROPERTY_INDEX_CHECK_PORTAL_LIST:
-      // Currently we ignore PortalURL and CheckPortalList.
+    case PROPERTY_INDEX_ARP_GATEWAY:

[Greg Spencer (Chromium), 2011/08/04 23:02:14]

I added this to stop the "unhandled key" warning below, although it's still
unhandled, really, we just know about it. 

[stevenjb, 2011/08/05 18:46:58]

Thanks, that's why there is a warning here, so we know which manager properties
we are ignoring.

+      // Currently we ignore PortalURL, CheckPortalList and ArpGateway.
       break;
     default:
       LOG(WARNING) << "Manager: Unhandled key: " << key;
@@ -5019,20 +3760,20 @@ void NetworkLibraryImplCros::NetworkManagerUpdate(
   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();
 }
 
@@ -5063,7 +3804,8 @@ void NetworkLibraryImplCros::UpdateTechnologies(
     std::string technology;
     (*iter)->GetAsString(&technology);
     if (!technology.empty()) {
-      ConnectionType type = ParseType(technology);
+      ConnectionType type =
+          NativeNetworkParser::ParseConnectionType(technology);

[Greg Spencer (Chromium), 2011/08/04 23:02:14]

I think this call to the native parser is unfortunate, but necessary.  The
implementation deals directly with the native network layer, so it really should
be using it directly here, in my opinion.

[stevenjb, 2011/08/05 18:46:58]

Just a thought, but the 'Native' has been bothering me a little. I wonder if
CrosNetworkParser would be better, since really it is libcros (or, ultimately,
chromeos) specific, just as NetworkLibraryImplCros is.

Ultimately I think that CellularDataPlan should also be re-factored to also do
its parsing in Chrome instead of libcros, at which point this code would be in
the parser. For now I think this is fine.

[Greg Spencer (Chromium), 2011/08/11 22:19:32]

Well, but we're already in the chromeos/cros directory, and I wanted to avoid
"FlimFlam" because it's going to change.  I can change it if it really bothers
you though.

       bitfield |= 1 << type;
     }
   }
@@ -5149,7 +3891,7 @@ void NetworkLibraryImplCros::UpdateNetworkServiceList(
       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);
     }
@@ -5189,26 +3931,25 @@ void NetworkLibraryImplCros::NetworkServiceUpdate(
       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;
 
@@ -5367,7 +4108,7 @@ void NetworkLibraryImplCros::RememberedNetworkServiceUpdate(
     } 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);
     }
   }
 }
@@ -5375,23 +4116,24 @@ void NetworkLibraryImplCros::RememberedNetworkServiceUpdate(
 // 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());

[stevenjb, 2011/08/05 18:46:58]

nit: align <<

[Greg Spencer (Chromium), 2011/08/11 22:19:32]

Done.

+      delete remembered;
       return NULL;
     }
   }
-  remembered->ParseInfo(info);  // virtual.
 
   SetProfileTypeFromPath(remembered);
 
@@ -5437,6 +4179,7 @@ void NetworkLibraryImplCros::UpdateNetworkDeviceList(const ListValue* devices) {
       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);
       }
@@ -5467,23 +4210,31 @@ void NetworkLibraryImplCros::NetworkDeviceUpdate(
     } 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;
+    } else {
+      std::string json;
+      base::JSONWriter::Write(&info, true, &json);
+      LOG(WARNING) << " NULL Device Dictionary: " << json;

[stevenjb, 2011/08/05 18:46:58]

I think we should move the detailed output to the parser code and keep json out
of NetworkLibrary, just logging device_path here.

[Greg Spencer (Chromium), 2011/08/11 22:19:32]

Sorry, that was some debugging code I accidentally left in there.  It's gone
now.

+    }
+    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());
@@ -5514,7 +4265,7 @@ class NetworkLibraryImplStub : public NetworkLibraryImplBase {
   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,
@@ -5587,9 +4338,8 @@ void NetworkLibraryImplStub::Init() {
   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
@@ -5604,7 +4354,7 @@ void NetworkLibraryImplStub::Init() {
   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);
@@ -5658,7 +4408,7 @@ void NetworkLibraryImplStub::Init() {
   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"));
@@ -5696,7 +4446,7 @@ void NetworkLibraryImplStub::Init() {
   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);
@@ -5704,7 +4454,7 @@ void NetworkLibraryImplStub::Init() {
   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);
@@ -5712,7 +4462,7 @@ void NetworkLibraryImplStub::Init() {
   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);
 
@@ -5732,7 +4482,7 @@ void NetworkLibraryImplStub::Init() {
   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);
 
@@ -5758,7 +4508,7 @@ void NetworkLibraryImplStub::CallRequestWifiNetworkAndConnect(
 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);