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

network classes into a separate hierarchy of parsers.  This is
in preparation for creating a second parser hierarchy that can be
used to create networks from a configuration file instead of from
flimflam.

In the course of doing this, I updated much of the style
inconsistencies in this code (mainly having to do with passing
arguments).

BUG=chromium-os:15457
TEST=ran on device, connected to new network, forgot a network.

Review URL: http://codereview.chromium.org/7453051

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

10 files changed, 2959 insertions, 1592 deletions

diff --git a/chrome/browser/chromeos/cros/native_network_constants.cc b/chrome/browser/chromeos/cros/native_network_constants.cc
new file mode 100644
index 0000000..e830a2f
--- /dev/null
+++ b/chrome/browser/chromeos/cros/native_network_constants.cc
@@ -0,0 +1,321 @@
+// 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/native_network_constants.h"
+
+namespace chromeos {
+// 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";
+
+// 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";
+const char kArpGatewayProperty[] = "ArpGateway";
+
+// 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 kGuidProperty[] = "GUID";
+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 kEapPhase2AuthPeapMschap2[] = "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";
+
+////////////////////////////////////////////////////////////////////////////
+
+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;
+}
+
+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;
+}
+
+const char* ProviderTypeToString(ProviderType type) {
+  switch (type) {
+    case PROVIDER_TYPE_L2TP_IPSEC_PSK:
+    case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
+      return kProviderL2tpIpsec;
+    case PROVIDER_TYPE_OPEN_VPN:
+      return kProviderOpenVpn;
+    case PROVIDER_TYPE_MAX:
+      break;
+  }
+  LOG(ERROR) << "ProviderTypeToString called with unknown type: " << type;
+  return kUnknownString;
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/cros/native_network_constants.h b/chrome/browser/chromeos/cros/native_network_constants.h
new file mode 100644
index 0000000..990fa59
--- /dev/null
+++ b/chrome/browser/chromeos/cros/native_network_constants.h
@@ -0,0 +1,277 @@
+// 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.
+
+// Defines all the command-line switches used by Chrome.
+
+#ifndef CHROME_BROWSER_CHROMEOS_CROS_NATIVE_NETWORK_CONSTANTS_H_
+#define CHROME_BROWSER_CHROMEOS_CROS_NATIVE_NETWORK_CONSTANTS_H_
+#pragma once
+
+#include "chrome/browser/chromeos/cros/network_library.h"
+
+namespace chromeos {
+
+// Format of the Carrier ID.
+extern const char kCarrierIdFormat[];
+
+// Path of the default (shared) flimflam profile.
+extern const char kSharedProfilePath[];
+
+// D-Bus interface string constants, used in both the native parsing
+// and network library code.
+
+// Flimflam manager properties.
+extern const char kAvailableTechnologiesProperty[];
+extern const char kEnabledTechnologiesProperty[];
+extern const char kConnectedTechnologiesProperty[];
+extern const char kDefaultTechnologyProperty[];
+extern const char kOfflineModeProperty[];
+extern const char kActiveProfileProperty[];
+extern const char kProfilesProperty[];
+extern const char kServicesProperty[];
+extern const char kServiceWatchListProperty[];
+extern const char kDevicesProperty[];
+extern const char kPortalUrlProperty[];
+extern const char kCheckPortalListProperty[];
+extern const char kArpGatewayProperty[];
+
+// Flimflam service properties.
+extern const char kSecurityProperty[];
+extern const char kPassphraseProperty[];
+extern const char kIdentityProperty[];
+extern const char kPassphraseRequiredProperty[];
+extern const char kSaveCredentialsProperty[];
+extern const char kSignalStrengthProperty[];
+extern const char kNameProperty[];
+extern const char kGuidProperty[];
+extern const char kStateProperty[];
+extern const char kTypeProperty[];
+extern const char kDeviceProperty[];
+extern const char kProfileProperty[];
+extern const char kTechnologyFamilyProperty[];
+extern const char kActivationStateProperty[];
+extern const char kNetworkTechnologyProperty[];
+extern const char kRoamingStateProperty[];
+extern const char kOperatorNameProperty[];
+extern const char kOperatorCodeProperty[];
+extern const char kServingOperatorProperty[];
+extern const char kPaymentUrlProperty[];
+extern const char kUsageUrlProperty[];
+extern const char kCellularApnProperty[];
+extern const char kCellularLastGoodApnProperty[];
+extern const char kCellularApnListProperty[];
+extern const char kWifiHexSsid[];
+extern const char kWifiFrequency[];
+extern const char kWifiHiddenSsid[];
+extern const char kWifiPhyMode[];
+extern const char kWifiAuthMode[];
+extern const char kFavoriteProperty[];
+extern const char kConnectableProperty[];
+extern const char kPriorityProperty[];
+extern const char kAutoConnectProperty[];
+extern const char kIsActiveProperty[];
+extern const char kModeProperty[];
+extern const char kErrorProperty[];
+extern const char kEntriesProperty[];
+extern const char kProviderProperty[];
+extern const char kHostProperty[];
+extern const char kProxyConfigProperty[];
+
+// Flimflam property names for SIMLock status.
+extern const char kSimLockStatusProperty[];
+extern const char kSimLockTypeProperty[];
+extern const char kSimLockRetriesLeftProperty[];
+
+// Flimflam property names for Cellular.FoundNetworks.
+extern const char kLongNameProperty[];
+extern const char kStatusProperty[];
+extern const char kShortNameProperty[];
+extern const char kTechnologyProperty[];
+extern const char kNetworkIdProperty[];
+
+// Flimflam SIMLock status types.
+extern const char kSimLockPin[];
+extern const char kSimLockPuk[];
+
+// APN info property names.
+extern const char kApnProperty[];
+extern const char kApnNetworkIdProperty[];
+extern const char kApnUsernameProperty[];
+extern const char kApnPasswordProperty[];
+extern const char kApnNameProperty[];
+extern const char kApnLocalizedNameProperty[];
+extern const char kApnLanguageProperty[];
+
+// Operator info property names.
+extern const char kOperatorNameKey[];
+extern const char kOperatorCodeKey[];
+extern const char kOperatorCountryKey[];
+
+// Flimflam device info property names.
+extern const char kScanningProperty[];
+extern const char kPoweredProperty[];
+extern const char kNetworksProperty[];
+extern const char kCarrierProperty[];
+extern const char kCellularAllowRoamingProperty[];
+extern const char kHomeProviderProperty[];
+extern const char kMeidProperty[];
+extern const char kImeiProperty[];
+extern const char kImsiProperty[];
+extern const char kEsnProperty[];
+extern const char kMdnProperty[];
+extern const char kMinProperty[];
+extern const char kModelIdProperty[];
+extern const char kManufacturerProperty[];
+extern const char kFirmwareRevisionProperty[];
+extern const char kHardwareRevisionProperty[];
+extern const char kPrlVersionProperty[]; // (INT16)
+extern const char kSelectedNetworkProperty[];
+extern const char kSupportNetworkScanProperty[];
+extern const char kFoundNetworksProperty[];
+
+// Flimflam ip config property names.
+extern const char kAddressProperty[];
+extern const char kPrefixlenProperty[];
+extern const char kGatewayProperty[];
+extern const char kNameServersProperty[];
+
+// Flimflam type options.
+extern const char kTypeEthernet[];
+extern const char kTypeWifi[];
+extern const char kTypeWimax[];
+extern const char kTypeBluetooth[];
+extern const char kTypeCellular[];
+extern const char kTypeVpn[];
+
+// Flimflam mode options.
+extern const char kModeManaged[];
+extern const char kModeAdhoc[];
+
+// Flimflam security options.
+extern const char kSecurityWpa[];
+extern const char kSecurityWep[];
+extern const char kSecurityRsn[];
+extern const char kSecurity8021x[];
+extern const char kSecurityPsk[];
+extern const char kSecurityNone[];
+
+// Flimflam L2TPIPsec property names.
+extern const char kL2tpIpsecCaCertNssProperty[];
+extern const char kL2tpIpsecClientCertIdProperty[];
+extern const char kL2tpIpsecClientCertSlotProp[];
+extern const char kL2tpIpsecPinProperty[];
+extern const char kL2tpIpsecPskProperty[];
+extern const char kL2tpIpsecUserProperty[];
+extern const char kL2tpIpsecPasswordProperty[];
+
+// Flimflam EAP property names.
+// See src/third_party/flimflam/doc/service-api.txt.
+extern const char kEapIdentityProperty[];
+extern const char kEapMethodProperty[];
+extern const char kEapPhase2AuthProperty[];
+extern const char kEapAnonymousIdentityProperty[];
+extern const char kEapClientCertProperty[];  // path
+extern const char kEapCertIdProperty[];  // PKCS#11 ID
+extern const char kEapClientCertNssProperty[];  // NSS nickname
+extern const char kEapPrivateKeyProperty[];
+extern const char kEapPrivateKeyPasswordProperty[];
+extern const char kEapKeyIdProperty[];
+extern const char kEapCaCertProperty[];  // server CA cert path
+extern const char kEapCaCertIdProperty[];  // server CA PKCS#11 ID
+extern const char kEapCaCertNssProperty[];  // server CA NSS nickname
+extern const char kEapUseSystemCasProperty[];
+extern const char kEapPinProperty[];
+extern const char kEapPasswordProperty[];
+extern const char kEapKeyMgmtProperty[];
+
+// Flimflam EAP method options.
+extern const char kEapMethodPeap[];
+extern const char kEapMethodTls[];
+extern const char kEapMethodTtls[];
+extern const char kEapMethodLeap[];
+
+// Flimflam EAP phase 2 auth options.
+extern const char kEapPhase2AuthPeapMd5[];
+extern const char kEapPhase2AuthPeapMschap2[];
+extern const char kEapPhase2AuthTtlsMd5[];
+extern const char kEapPhase2AuthTtlsMschapV2[];
+extern const char kEapPhase2AuthTtlsMschap[];
+extern const char kEapPhase2AuthTtlsPap[];
+extern const char kEapPhase2AuthTtlsChap[];
+
+// Flimflam VPN provider types.
+extern const char kProviderL2tpIpsec[];
+extern const char kProviderOpenVpn[];
+
+// Flimflam state options.
+extern const char kStateIdle[];
+extern const char kStateCarrier[];
+extern const char kStateAssociation[];
+extern const char kStateConfiguration[];
+extern const char kStateReady[];
+extern const char kStatePortal[];
+extern const char kStateOnline[];
+extern const char kStateDisconnect[];
+extern const char kStateFailure[];
+extern const char kStateActivationFailure[];
+
+// Flimflam network technology options.
+extern const char kNetworkTechnology1Xrtt[];
+extern const char kNetworkTechnologyEvdo[];
+extern const char kNetworkTechnologyGprs[];
+extern const char kNetworkTechnologyEdge[];
+extern const char kNetworkTechnologyUmts[];
+extern const char kNetworkTechnologyHspa[];
+extern const char kNetworkTechnologyHspaPlus[];
+extern const char kNetworkTechnologyLte[];
+extern const char kNetworkTechnologyLteAdvanced[];
+extern const char kNetworkTechnologyGsm[];
+
+// Flimflam roaming state options
+extern const char kRoamingStateHome[];
+extern const char kRoamingStateRoaming[];
+extern const char kRoamingStateUnknown[];
+
+// Flimflam activation state options
+extern const char kActivationStateActivated[];
+extern const char kActivationStateActivating[];
+extern const char kActivationStateNotActivated[];
+extern const char kActivationStatePartiallyActivated[];
+extern const char kActivationStateUnknown[];
+
+// FlimFlam technology family options
+extern const char kTechnologyFamilyCdma[];
+extern const char kTechnologyFamilyGsm[];
+
+// Flimflam error options.
+extern const char kErrorOutOfRange[];
+extern const char kErrorPinMissing[];
+extern const char kErrorDhcpFailed[];
+extern const char kErrorConnectFailed[];
+extern const char kErrorBadPassphrase[];
+extern const char kErrorBadWepKey[];
+extern const char kErrorActivationFailed[];
+extern const char kErrorNeedEvdo[];
+extern const char kErrorNeedHomeNetwork[];
+extern const char kErrorOtaspFailed[];
+extern const char kErrorAaaFailed[];
+extern const char kErrorInternal[];
+extern const char kErrorDnsLookupFailed[];
+extern const char kErrorHttpGetFailed[];
+
+// Flimflam error messages.
+extern const char kErrorPassphraseRequiredMsg[];
+extern const char kErrorIncorrectPinMsg[];
+extern const char kErrorPinBlockedMsg[];
+extern const char kErrorPinRequiredMsg[];
+
+extern const char kUnknownString[];
+
+extern const char* ConnectionTypeToString(ConnectionType type);
+extern const char* SecurityToString(ConnectionSecurity security);
+extern const char* ProviderTypeToString(ProviderType type);
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_CROS_NATIVE_NETWORK_CONSTANTS_H_
diff --git a/chrome/browser/chromeos/cros/native_network_parser.cc b/chrome/browser/chromeos/cros/native_network_parser.cc
new file mode 100644
index 0000000..d610e27
--- /dev/null
+++ b/chrome/browser/chromeos/cros/native_network_parser.cc
@@ -0,0 +1,1158 @@
+// 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/native_network_parser.h"
+
+#include "base/stringprintf.h"
+#include "chrome/browser/chromeos/cros/native_network_constants.h"
+#include "chrome/browser/chromeos/cros/network_library.h"
+#include "chrome/browser/chromeos/login/user_manager.h"
+
+namespace chromeos {
+
+// Local constants.
+namespace {
+
+EnumMapper<PropertyIndex>::Pair property_index_table[] = {
+  { kActivationStateProperty, PROPERTY_INDEX_ACTIVATION_STATE },
+  { kActiveProfileProperty, PROPERTY_INDEX_ACTIVE_PROFILE },
+  { kArpGatewayProperty, PROPERTY_INDEX_ARP_GATEWAY },
+  { 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 },
+  { kGuidProperty, PROPERTY_INDEX_GUID },
+  { 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 },
+  { kL2tpIpsecPinProperty, PROPERTY_INDEX_L2TPIPSEC_PIN },
+  { kL2tpIpsecPskProperty, PROPERTY_INDEX_L2TPIPSEC_PSK },
+  { kL2tpIpsecPasswordProperty, PROPERTY_INDEX_L2TPIPSEC_PASSWORD },
+  { 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 },
+};
+
+// Serve the singleton mapper instance.
+const EnumMapper<PropertyIndex>* get_native_mapper() {
+  static const EnumMapper<PropertyIndex> mapper(property_index_table,
+                                                arraysize(property_index_table),
+                                                PROPERTY_INDEX_UNKNOWN);
+  return &mapper;
+}
+
+ConnectionType ParseNetworkType(const std::string& type) {
+  static EnumMapper<ConnectionType>::Pair table[] = {
+    { kTypeEthernet, TYPE_ETHERNET },
+    { kTypeWifi, TYPE_WIFI },
+    { kTypeWimax, TYPE_WIMAX },
+    { kTypeBluetooth, TYPE_BLUETOOTH },
+    { kTypeCellular, TYPE_CELLULAR },
+    { kTypeVpn, TYPE_VPN },
+  };
+  static EnumMapper<ConnectionType> parser(
+      table, arraysize(table), TYPE_UNKNOWN);
+  return parser.Get(type);
+}
+
+}  // namespace
+
+// -------------------- NativeNetworkDeviceParser --------------------
+
+NativeNetworkDeviceParser::NativeNetworkDeviceParser()
+    : NetworkDeviceParser(get_native_mapper()) {
+}
+
+NativeNetworkDeviceParser::~NativeNetworkDeviceParser() {
+}
+
+bool NativeNetworkDeviceParser::ParseValue(
+    PropertyIndex index, const Value& value, NetworkDevice* device) {
+  switch (index) {
+    case PROPERTY_INDEX_TYPE: {
+      std::string type_string;
+      if (value.GetAsString(&type_string)) {
+        device->set_type(ParseType(type_string));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_NAME: {
+      std::string name;
+      if (!value.GetAsString(&name))
+        return false;
+      device->set_name(name);
+      return true;
+    }
+    case PROPERTY_INDEX_GUID: {
+      std::string unique_id;
+      if (!value.GetAsString(&unique_id))
+        return false;
+      device->set_unique_id(unique_id);
+      return true;
+    }
+    case PROPERTY_INDEX_CARRIER: {
+      std::string carrier;
+      if (!value.GetAsString(&carrier))
+        return false;
+      device->set_carrier(carrier);
+      return true;
+    }
+    case PROPERTY_INDEX_SCANNING: {
+      bool scanning;
+      if (!value.GetAsBoolean(&scanning))
+        return false;
+      device->set_scanning(scanning);
+      return true;
+    }
+    case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING: {
+      bool data_roaming_allowed;
+      if (!value.GetAsBoolean(&data_roaming_allowed))
+        return false;
+      device->set_data_roaming_allowed(data_roaming_allowed);
+      return true;
+    }
+    case PROPERTY_INDEX_CELLULAR_APN_LIST:
+      if (value.IsType(Value::TYPE_LIST)) {
+        CellularApnList provider_apn_list;
+        if (!ParseApnList(static_cast<const ListValue&>(value),
+                          &provider_apn_list))
+          return false;
+        device->set_provider_apn_list(provider_apn_list);
+        return true;
+      }
+      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)) {
+        CellularNetworkList found_cellular_networks;
+        if (!ParseFoundNetworksFromList(
+                static_cast<const ListValue&>(value),
+                &found_cellular_networks))
+          return false;
+        device->set_found_cellular_networks(found_cellular_networks);
+        return true;
+      }
+      break;
+    case PROPERTY_INDEX_HOME_PROVIDER: {
+      if (value.IsType(Value::TYPE_DICTIONARY)) {
+        const DictionaryValue& dict =
+            static_cast<const DictionaryValue&>(value);
+        std::string home_provider_code;
+        std::string home_provider_country;
+        std::string home_provider_name;
+        dict.GetStringWithoutPathExpansion(kOperatorCodeKey,
+                                           &home_provider_code);
+        dict.GetStringWithoutPathExpansion(kOperatorCountryKey,
+                                           &home_provider_country);
+        dict.GetStringWithoutPathExpansion(kOperatorNameKey,
+                                           &home_provider_name);
+        device->set_home_provider_code(home_provider_code);
+        device->set_home_provider_country(home_provider_country);
+        device->set_home_provider_name(home_provider_name);
+        if (!device->home_provider_name().empty() &&
+            !device->home_provider_country().empty()) {
+          device->set_home_provider_id(base::StringPrintf(
+              kCarrierIdFormat,
+              device->home_provider_name().c_str(),
+              device->home_provider_country().c_str()));
+        } else {
+          device->set_home_provider_id(home_provider_code);
+          LOG(WARNING) << "Carrier ID not defined, using code instead: "
+                       << device->home_provider_id();
+        }
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_MEID:
+    case PROPERTY_INDEX_IMEI:
+    case PROPERTY_INDEX_IMSI:
+    case PROPERTY_INDEX_ESN:
+    case PROPERTY_INDEX_MDN:
+    case PROPERTY_INDEX_MIN:
+    case PROPERTY_INDEX_MODEL_ID:
+    case PROPERTY_INDEX_MANUFACTURER:
+    case PROPERTY_INDEX_FIRMWARE_REVISION:
+    case PROPERTY_INDEX_HARDWARE_REVISION:
+    case PROPERTY_INDEX_SELECTED_NETWORK: {
+      std::string item;
+      if (!value.GetAsString(&item))
+        return false;
+      switch (index) {
+        case PROPERTY_INDEX_MEID:
+          device->set_meid(item);
+          break;
+        case PROPERTY_INDEX_IMEI:
+          device->set_imei(item);
+          break;
+        case PROPERTY_INDEX_IMSI:
+          device->set_imsi(item);
+          break;
+        case PROPERTY_INDEX_ESN:
+          device->set_esn(item);
+          break;
+        case PROPERTY_INDEX_MDN:
+          device->set_mdn(item);
+          break;
+        case PROPERTY_INDEX_MIN:
+          device->set_min(item);
+          break;
+        case PROPERTY_INDEX_MODEL_ID:
+          device->set_model_id(item);
+          break;
+        case PROPERTY_INDEX_MANUFACTURER:
+          device->set_manufacturer(item);
+          break;
+        case PROPERTY_INDEX_FIRMWARE_REVISION:
+          device->set_firmware_revision(item);
+          break;
+        case PROPERTY_INDEX_HARDWARE_REVISION:
+          device->set_hardware_revision(item);
+          break;
+        case PROPERTY_INDEX_SELECTED_NETWORK:
+          device->set_selected_cellular_network(item);
+          break;
+        default:
+          break;
+      }
+      return true;
+    }
+    case PROPERTY_INDEX_SIM_LOCK:
+      if (value.IsType(Value::TYPE_DICTIONARY)) {
+        SimLockState sim_lock_state;
+        int sim_retries_left;
+        if (!ParseSimLockStateFromDictionary(
+                static_cast<const DictionaryValue&>(value),
+                &sim_lock_state,
+                &sim_retries_left))
+          return false;
+        device->set_sim_lock_state(sim_lock_state);
+        device->set_sim_retries_left(sim_retries_left);
+        // Initialize PinRequired value only once.
+        // See SimPinRequire enum comments.
+        if (device->sim_pin_required() == SIM_PIN_REQUIRE_UNKNOWN) {
+          if (device->sim_lock_state() == SIM_UNLOCKED) {
+            device->set_sim_pin_required(SIM_PIN_NOT_REQUIRED);
+          } else if (device->sim_lock_state() == SIM_LOCKED_PIN ||
+                     device->sim_lock_state() == SIM_LOCKED_PUK) {
+            device->set_sim_pin_required(SIM_PIN_REQUIRED);
+          }
+        }
+        return true;
+      }
+      break;
+    case PROPERTY_INDEX_POWERED:
+      // we don't care about the value, just the fact that it changed
+      return true;
+    case PROPERTY_INDEX_PRL_VERSION: {
+      int prl_version;
+      if (!value.GetAsInteger(&prl_version))
+        return false;
+      device->set_prl_version(prl_version);
+      return true;
+    }
+    case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN: {
+      bool support_network_scan;
+      if (!value.GetAsBoolean(&support_network_scan))
+        return false;
+      device->set_support_network_scan(support_network_scan);
+      return true;
+    }
+    case PROPERTY_INDEX_TECHNOLOGY_FAMILY: {
+      std::string technology_family_string;
+      if (value.GetAsString(&technology_family_string)) {
+        device->set_technology_family(
+            ParseTechnologyFamily(technology_family_string));
+        return true;
+      }
+      break;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+ConnectionType NativeNetworkDeviceParser::ParseType(const std::string& type) {
+  return ParseNetworkType(type);
+}
+
+bool NativeNetworkDeviceParser::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);
+      const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it);
+      dict->GetStringWithoutPathExpansion(
+          kApnProperty, &apn_list->back().apn);
+      dict->GetStringWithoutPathExpansion(
+          kApnNetworkIdProperty, &apn_list->back().network_id);
+      dict->GetStringWithoutPathExpansion(
+          kApnUsernameProperty, &apn_list->back().username);
+      dict->GetStringWithoutPathExpansion(
+          kApnPasswordProperty, &apn_list->back().password);
+      dict->GetStringWithoutPathExpansion(
+          kApnNameProperty, &apn_list->back().name);
+      dict->GetStringWithoutPathExpansion(
+          kApnLocalizedNameProperty, &apn_list->back().localized_name);
+      dict->GetStringWithoutPathExpansion(
+          kApnLanguageProperty, &apn_list->back().language);
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool NativeNetworkDeviceParser::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;
+}
+
+SimLockState NativeNetworkDeviceParser::ParseSimLockState(
+    const std::string& state) {
+  static EnumMapper<SimLockState>::Pair table[] = {
+    { "", SIM_UNLOCKED },
+    { kSimLockPin, SIM_LOCKED_PIN },
+    { kSimLockPuk, SIM_LOCKED_PUK },
+  };
+  static EnumMapper<SimLockState> parser(
+      table, arraysize(table), SIM_UNKNOWN);
+  SimLockState parsed_state = parser.Get(state);
+  DCHECK(parsed_state != SIM_UNKNOWN) << "Unknown SIMLock state encountered";
+  return parsed_state;
+}
+
+bool NativeNetworkDeviceParser::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;
+}
+
+TechnologyFamily NativeNetworkDeviceParser::ParseTechnologyFamily(
+    const std::string& technology_family) {
+  static EnumMapper<TechnologyFamily>::Pair table[] = {
+    { kTechnologyFamilyCdma, TECHNOLOGY_FAMILY_CDMA },
+    { kTechnologyFamilyGsm, TECHNOLOGY_FAMILY_GSM },
+  };
+  static EnumMapper<TechnologyFamily> parser(
+      table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN);
+  return parser.Get(technology_family);
+}
+
+// -------------------- NativeNetworkParser --------------------
+
+NativeNetworkParser::NativeNetworkParser()
+    : NetworkParser(get_native_mapper()) {
+}
+
+NativeNetworkParser::~NativeNetworkParser() {
+}
+
+// static
+const EnumMapper<PropertyIndex>* NativeNetworkParser::property_mapper() {
+  return get_native_mapper();
+
+}
+
+const ConnectionType NativeNetworkParser::ParseConnectionType(
+    const std::string& connection_type) {
+  return ParseNetworkType(connection_type);
+}
+
+bool NativeNetworkParser::ParseValue(PropertyIndex index,
+                                     const Value& value,
+                                     Network* network) {
+  switch (index) {
+    case PROPERTY_INDEX_TYPE: {
+      std::string type_string;
+      if (value.GetAsString(&type_string)) {
+        ConnectionType type = ParseType(type_string);
+        LOG_IF(ERROR, type != network->type())
+          << "Network with mismatched type: " << network->service_path()
+          << " " << type << " != " << network->type();
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_DEVICE: {
+      std::string device_path;
+      if (!value.GetAsString(&device_path))
+        return false;
+      network->set_device_path(device_path);
+      return true;
+    }
+    case PROPERTY_INDEX_NAME: {
+      std::string name;
+      if (!value.GetAsString(&name))
+        return false;
+      network->SetName(name);
+      return true;
+    }
+    case PROPERTY_INDEX_GUID: {
+      std::string unique_id;
+      if (!value.GetAsString(&unique_id))
+        return false;
+      network->set_unique_id(unique_id);
+      return true;
+    }
+    case PROPERTY_INDEX_PROFILE: {
+      // Note: currently this is only provided for non remembered networks.
+      std::string profile_path;
+      if (!value.GetAsString(&profile_path))
+        return false;
+      network->set_profile_path(profile_path);
+      return true;
+    }
+    case PROPERTY_INDEX_STATE: {
+      std::string state_string;
+      if (value.GetAsString(&state_string)) {
+        network->SetState(ParseState(state_string));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_MODE: {
+      std::string mode_string;
+      if (value.GetAsString(&mode_string)) {
+        network->set_mode(ParseMode(mode_string));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_ERROR: {
+      std::string error_string;
+      if (value.GetAsString(&error_string)) {
+        network->set_error(ParseError(error_string));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_CONNECTABLE: {
+      bool connectable;
+      if (!value.GetAsBoolean(&connectable))
+        return false;
+      network->set_connectable(connectable);
+      return true;
+    }
+    case PROPERTY_INDEX_IS_ACTIVE: {
+      bool is_active;
+      if (!value.GetAsBoolean(&is_active))
+        return false;
+      network->set_is_active(is_active);
+      return true;
+    }
+    case PROPERTY_INDEX_FAVORITE:
+      // This property is ignored.
+      return true;
+    case PROPERTY_INDEX_AUTO_CONNECT: {
+      bool auto_connect;
+      if (!value.GetAsBoolean(&auto_connect))
+        return false;
+      network->set_auto_connect(auto_connect);
+      return true;
+    }
+    case PROPERTY_INDEX_SAVE_CREDENTIALS: {
+      bool save_credentials;
+      if (!value.GetAsBoolean(&save_credentials))
+        return false;
+      network->set_save_credentials(save_credentials);
+      return true;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+ConnectionType NativeNetworkParser::ParseType(const std::string& type) {
+  return ParseNetworkType(type);
+}
+
+ConnectionType NativeNetworkParser::ParseTypeFromDictionary(
+    const DictionaryValue& info) {
+  std::string type_string;
+  info.GetString(kTypeProperty, &type_string);
+  return ParseType(type_string);
+}
+
+ConnectionMode NativeNetworkParser::ParseMode(const std::string& mode) {
+  static EnumMapper<ConnectionMode>::Pair table[] = {
+    { kModeManaged, MODE_MANAGED },
+    { kModeAdhoc, MODE_ADHOC },
+  };
+  static EnumMapper<ConnectionMode> parser(
+      table, arraysize(table), MODE_UNKNOWN);
+  return parser.Get(mode);
+}
+
+ConnectionState NativeNetworkParser::ParseState(const std::string& state) {
+  static EnumMapper<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 EnumMapper<ConnectionState> parser(
+      table, arraysize(table), STATE_UNKNOWN);
+  return parser.Get(state);
+}
+
+ConnectionError NativeNetworkParser::ParseError(const std::string& error) {
+  static EnumMapper<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 EnumMapper<ConnectionError> parser(
+      table, arraysize(table), ERROR_NO_ERROR);
+  return parser.Get(error);
+}
+
+// -------------------- NativeEthernetNetworkParser --------------------
+
+NativeEthernetNetworkParser::NativeEthernetNetworkParser() {}
+NativeEthernetNetworkParser::~NativeEthernetNetworkParser() {}
+
+// -------------------- NativeWirelessNetworkParser --------------------
+
+NativeWirelessNetworkParser::NativeWirelessNetworkParser() {}
+NativeWirelessNetworkParser::~NativeWirelessNetworkParser() {}
+
+bool NativeWirelessNetworkParser::ParseValue(PropertyIndex index,
+                                             const Value& value,
+                                             Network* network) {
+  DCHECK_NE(TYPE_ETHERNET, network->type());
+  DCHECK_NE(TYPE_VPN, network->type());
+  WirelessNetwork* wireless_network = static_cast<WirelessNetwork*>(network);
+  switch (index) {
+    case PROPERTY_INDEX_SIGNAL_STRENGTH: {
+      int strength;
+      if (!value.GetAsInteger(&strength))
+        return false;
+      wireless_network->set_strength(strength);
+      return true;
+    }
+    default:
+      return NativeNetworkParser::ParseValue(index, value, network);
+      break;
+  }
+  return false;
+}
+
+// -------------------- NativeCellularNetworkParser --------------------
+
+NativeCellularNetworkParser::NativeCellularNetworkParser() {}
+NativeCellularNetworkParser::~NativeCellularNetworkParser() {}
+
+bool NativeCellularNetworkParser::ParseValue(PropertyIndex index,
+                                             const Value& value,
+                                             Network* network) {
+  DCHECK_EQ(TYPE_CELLULAR, network->type());
+  CellularNetwork* cellular_network = static_cast<CellularNetwork*>(network);
+  switch (index) {
+    case PROPERTY_INDEX_ACTIVATION_STATE: {
+      std::string activation_state_string;
+      if (value.GetAsString(&activation_state_string)) {
+        ActivationState prev_state = cellular_network->activation_state();
+        cellular_network->set_activation_state(
+            ParseActivationState(activation_state_string));
+        if (cellular_network->activation_state() != prev_state)
+          cellular_network->RefreshDataPlansIfNeeded();
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_CELLULAR_APN: {
+      if (value.IsType(Value::TYPE_DICTIONARY)) {
+        cellular_network->set_apn(static_cast<const DictionaryValue&>(value));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: {
+      if (value.IsType(Value::TYPE_DICTIONARY)) {
+        cellular_network->set_last_good_apn(
+            static_cast<const DictionaryValue&>(value));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_NETWORK_TECHNOLOGY: {
+      std::string network_technology_string;
+      if (value.GetAsString(&network_technology_string)) {
+        cellular_network->set_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)) {
+        cellular_network->set_roaming_state(
+            ParseRoamingState(roaming_state_string));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_OPERATOR_NAME: {
+      std::string value_str;
+      if (!value.GetAsString(&value_str))
+        break;
+      cellular_network->set_operator_name(value_str);
+      return true;
+    }
+    case PROPERTY_INDEX_OPERATOR_CODE: {
+      std::string value_str;
+      if (!value.GetAsString(&value_str))
+        break;
+      cellular_network->set_operator_code(value_str);
+      return true;
+    }
+    case PROPERTY_INDEX_SERVING_OPERATOR: {
+      if (value.IsType(Value::TYPE_DICTIONARY)) {
+        const DictionaryValue& dict =
+            static_cast<const DictionaryValue&>(value);
+        std::string value_str;
+        dict.GetStringWithoutPathExpansion(kOperatorNameKey, &value_str);
+        cellular_network->set_operator_name(value_str);
+        value_str.clear();
+        dict.GetStringWithoutPathExpansion(kOperatorCodeKey, &value_str);
+        cellular_network->set_operator_code(value_str);
+        value_str.clear();
+        dict.GetStringWithoutPathExpansion(kOperatorCountryKey, &value_str);
+        cellular_network->set_operator_country(value_str);
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_PAYMENT_URL: {
+      std::string value_str;
+      if (!value.GetAsString(&value_str))
+        break;
+      cellular_network->set_payment_url(value_str);
+      return true;
+    }
+    case PROPERTY_INDEX_USAGE_URL: {
+      std::string value_str;
+      if (!value.GetAsString(&value_str))
+        break;
+      cellular_network->set_usage_url(value_str);
+      return true;
+    }
+    case PROPERTY_INDEX_STATE: {
+      // Save previous state before calling WirelessNetwork::ParseValue.
+      ConnectionState prev_state = cellular_network->state();
+      if (NativeWirelessNetworkParser::ParseValue(index, value, network)) {
+        if (cellular_network->state() != prev_state)
+          cellular_network->RefreshDataPlansIfNeeded();
+        return true;
+      }
+      break;
+    }
+    default:
+      return NativeWirelessNetworkParser::ParseValue(index, value, network);
+  }
+  return false;
+}
+
+ActivationState NativeCellularNetworkParser::ParseActivationState(
+    const std::string& state) {
+  static EnumMapper<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 EnumMapper<ActivationState> parser(
+      table, arraysize(table), ACTIVATION_STATE_UNKNOWN);
+  return parser.Get(state);
+}
+
+NetworkTechnology NativeCellularNetworkParser::ParseNetworkTechnology(
+    const std::string& technology) {
+  static EnumMapper<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 EnumMapper<NetworkTechnology> parser(
+      table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN);
+  return parser.Get(technology);
+}
+
+NetworkRoamingState NativeCellularNetworkParser::ParseRoamingState(
+    const std::string& roaming_state) {
+  static EnumMapper<NetworkRoamingState>::Pair table[] = {
+    { kRoamingStateHome, ROAMING_STATE_HOME },
+    { kRoamingStateRoaming, ROAMING_STATE_ROAMING },
+    { kRoamingStateUnknown, ROAMING_STATE_UNKNOWN },
+  };
+  static EnumMapper<NetworkRoamingState> parser(
+      table, arraysize(table), ROAMING_STATE_UNKNOWN);
+  return parser.Get(roaming_state);
+}
+
+// -------------------- NativeWifiNetworkParser --------------------
+
+NativeWifiNetworkParser::NativeWifiNetworkParser() {}
+NativeWifiNetworkParser::~NativeWifiNetworkParser() {}
+
+bool NativeWifiNetworkParser::ParseValue(PropertyIndex index,
+                                         const Value& value,
+                                         Network* network) {
+  DCHECK_EQ(TYPE_WIFI, network->type());
+  WifiNetwork* wifi_network = static_cast<WifiNetwork*>(network);
+  switch (index) {
+    case PROPERTY_INDEX_WIFI_HEX_SSID: {
+      std::string ssid_hex;
+      if (!value.GetAsString(&ssid_hex))
+        return false;
+
+      wifi_network->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 (!wifi_network->name().empty())
+        return true;
+      else
+        return NativeWirelessNetworkParser::ParseValue(index, value, network);
+    }
+    case PROPERTY_INDEX_GUID: {
+      std::string unique_id;
+      if (!value.GetAsString(&unique_id))
+        break;
+      wifi_network->set_unique_id(unique_id);
+      return true;
+    }
+    case PROPERTY_INDEX_SECURITY: {
+      std::string security_string;
+      if (!value.GetAsString(&security_string))
+        break;
+      wifi_network->set_encryption(ParseSecurity(security_string));
+      return true;
+    }
+    case PROPERTY_INDEX_PASSPHRASE: {
+      std::string passphrase;
+      if (!value.GetAsString(&passphrase))
+        break;
+      // 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())
+        wifi_network->set_passphrase(passphrase);
+      return true;
+    }
+    case PROPERTY_INDEX_PASSPHRASE_REQUIRED: {
+      bool passphrase_required;
+      value.GetAsBoolean(&passphrase_required);
+      if (!value.GetAsBoolean(&passphrase_required))
+        break;
+      wifi_network->set_passphrase_required(passphrase_required);
+      return true;
+    }
+    case PROPERTY_INDEX_IDENTITY: {
+      std::string identity;
+      if (!value.GetAsString(&identity))
+        break;
+      wifi_network->set_identity(identity);
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_IDENTITY: {
+      std::string eap_identity;
+      if (!value.GetAsString(&eap_identity))
+        break;
+      wifi_network->set_eap_identity(eap_identity);
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_METHOD: {
+      std::string eap_method;
+      if (!value.GetAsString(&eap_method))
+        break;
+      wifi_network->set_eap_method(ParseEAPMethod(eap_method));
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_PHASE_2_AUTH: {
+      std::string eap_phase_2_auth;
+      if (!value.GetAsString(&eap_phase_2_auth))
+        break;
+      wifi_network->set_eap_phase_2_auth(ParseEAPPhase2Auth(eap_phase_2_auth));
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY: {
+      std::string eap_anonymous_identity;
+      if (!value.GetAsString(&eap_anonymous_identity))
+        break;
+      wifi_network->set_eap_anonymous_identity(eap_anonymous_identity);
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_CERT_ID: {
+      std::string eap_client_cert_pkcs11_id;
+      if (!value.GetAsString(&eap_client_cert_pkcs11_id))
+        break;
+      wifi_network->set_eap_client_cert_pkcs11_id(eap_client_cert_pkcs11_id);
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_CA_CERT_NSS: {
+      std::string eap_server_ca_cert_nss_nickname;
+      if (!value.GetAsString(&eap_server_ca_cert_nss_nickname))
+        break;
+      wifi_network->set_eap_server_ca_cert_nss_nickname(
+          eap_server_ca_cert_nss_nickname);
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS: {
+      bool eap_use_system_cas;
+      if (!value.GetAsBoolean(&eap_use_system_cas))
+        break;
+      wifi_network->set_eap_use_system_cas(eap_use_system_cas);
+      return true;
+    }
+    case PROPERTY_INDEX_EAP_PASSWORD: {
+      std::string eap_passphrase;
+      if (!value.GetAsString(&eap_passphrase))
+        break;
+      wifi_network->set_eap_passphrase(eap_passphrase);
+      return true;
+    }
+    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 NativeWirelessNetworkParser::ParseValue(index, value, network);
+  }
+  return false;
+}
+
+ConnectionSecurity NativeWifiNetworkParser::ParseSecurity(
+    const std::string& security) {
+  static EnumMapper<ConnectionSecurity>::Pair table[] = {
+    { kSecurityNone, SECURITY_NONE },
+    { kSecurityWep, SECURITY_WEP },
+    { kSecurityWpa, SECURITY_WPA },
+    { kSecurityRsn, SECURITY_RSN },
+    { kSecurityPsk, SECURITY_PSK },
+    { kSecurity8021x, SECURITY_8021X },
+  };
+  static EnumMapper<ConnectionSecurity> parser(
+      table, arraysize(table), SECURITY_UNKNOWN);
+  return parser.Get(security);
+}
+
+EAPMethod NativeWifiNetworkParser::ParseEAPMethod(const std::string& method) {
+  static EnumMapper<EAPMethod>::Pair table[] = {
+    { kEapMethodPeap, EAP_METHOD_PEAP },
+    { kEapMethodTls, EAP_METHOD_TLS },
+    { kEapMethodTtls, EAP_METHOD_TTLS },
+    { kEapMethodLeap, EAP_METHOD_LEAP },
+  };
+  static EnumMapper<EAPMethod> parser(
+      table, arraysize(table), EAP_METHOD_UNKNOWN);
+  return parser.Get(method);
+}
+
+EAPPhase2Auth NativeWifiNetworkParser::ParseEAPPhase2Auth(
+    const std::string& auth) {
+  static EnumMapper<EAPPhase2Auth>::Pair table[] = {
+    { kEapPhase2AuthPeapMd5, EAP_PHASE_2_AUTH_MD5 },
+    { kEapPhase2AuthPeapMschap2, 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 EnumMapper<EAPPhase2Auth> parser(
+      table, arraysize(table), EAP_PHASE_2_AUTH_AUTO);
+  return parser.Get(auth);
+}
+
+// -------------------- NativeVirtualNetworkParser --------------------
+
+
+NativeVirtualNetworkParser::NativeVirtualNetworkParser() {}
+NativeVirtualNetworkParser::~NativeVirtualNetworkParser() {}
+
+bool NativeVirtualNetworkParser::UpdateNetworkFromInfo(
+    const DictionaryValue& info,
+    Network* network) {
+  DCHECK_EQ(TYPE_VPN, network->type());
+  VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network);
+  if (!NativeNetworkParser::UpdateNetworkFromInfo(info, network))
+    return false;
+  VLOG(1) << "Updating VPN '" << virtual_network->name()
+          << "': Server: " << virtual_network->server_hostname()
+          << " Type: "
+          << ProviderTypeToString(virtual_network->provider_type());
+  if (virtual_network->provider_type() == PROVIDER_TYPE_L2TP_IPSEC_PSK) {
+    if (!virtual_network->client_cert_id().empty())
+      virtual_network->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+  }
+  return true;
+}
+
+bool NativeVirtualNetworkParser::ParseValue(PropertyIndex index,
+                                            const Value& value,
+                                            Network* network) {
+  DCHECK_EQ(TYPE_VPN, network->type());
+  VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network);
+  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* provider_value;
+        bool res = dict.GetWithoutPathExpansion(key, &provider_value);
+        DCHECK(res);
+        if (res) {
+          PropertyIndex index = mapper().Get(key);
+          if (!ParseProviderValue(index, *provider_value, virtual_network))
+            VLOG(1) << network->name() << ": Provider unhandled key: " << key
+                    << " Type: " << provider_value->GetType();
+        }
+      }
+      return true;
+    }
+    default:
+      return NativeNetworkParser::ParseValue(index, value, network);
+      break;
+  }
+  return false;
+}
+
+bool NativeVirtualNetworkParser::ParseProviderValue(PropertyIndex index,
+                                                    const Value& value,
+                                                    VirtualNetwork* network) {
+  switch (index) {
+    case PROPERTY_INDEX_HOST: {
+      std::string server_hostname;
+      if (!value.GetAsString(&server_hostname))
+        break;
+      network->set_server_hostname(server_hostname);
+      return true;
+    }
+    case PROPERTY_INDEX_NAME: {
+      std::string name;
+      if (!value.GetAsString(&name))
+        break;
+      network->set_name(name);
+      return true;
+    }
+    case PROPERTY_INDEX_TYPE: {
+      std::string provider_type_string;
+      if (!value.GetAsString(&provider_type_string))
+        break;
+      network->set_provider_type(ParseProviderType(provider_type_string));
+      return true;
+    }
+    case PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS: {
+      std::string ca_cert_nss;
+      if (!value.GetAsString(&ca_cert_nss))
+        break;
+      network->set_ca_cert_nss(ca_cert_nss);
+      return true;
+    }
+    case PROPERTY_INDEX_L2TPIPSEC_PSK:{
+      std::string psk_passphrase;
+      if (!value.GetAsString(&psk_passphrase))
+        break;
+      network->set_psk_passphrase(psk_passphrase);
+      return true;
+    }
+    case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID:{
+      std::string client_cert_id;
+      if (!value.GetAsString(&client_cert_id))
+        break;
+      network->set_client_cert_id(client_cert_id);
+      return true;
+    }
+    case PROPERTY_INDEX_L2TPIPSEC_USER:{
+      std::string username;
+      if (!value.GetAsString(&username))
+        break;
+      network->set_username(username);
+      return true;
+    }
+    case PROPERTY_INDEX_L2TPIPSEC_PASSWORD:{
+      std::string user_passphrase;
+      if (!value.GetAsString(&user_passphrase))
+        break;
+      network->set_user_passphrase(user_passphrase);
+      return true;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+ProviderType NativeVirtualNetworkParser::ParseProviderType(
+    const std::string& type) {
+  static EnumMapper<ProviderType>::Pair table[] = {
+    { kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK },
+    { kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN },
+  };
+  static EnumMapper<ProviderType> parser(
+      table, arraysize(table), PROVIDER_TYPE_MAX);
+  return parser.Get(type);
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/cros/native_network_parser.h b/chrome/browser/chromeos/cros/native_network_parser.h
new file mode 100644
index 0000000..eee1384
--- /dev/null
+++ b/chrome/browser/chromeos/cros/native_network_parser.h
@@ -0,0 +1,141 @@
+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_CROS_NATIVE_NETWORK_PARSER_H_
+#define CHROME_BROWSER_CHROMEOS_CROS_NATIVE_NETWORK_PARSER_H_
+#pragma once
+
+#include "chrome/browser/chromeos/cros/network_parser.h"
+#include "base/compiler_specific.h"  // for OVERRIDE
+
+namespace chromeos {
+
+// This is the network device parser that parses the data from the
+// network stack on the native platform.  Currently it parses
+// FlimFlam-provided information.
+class NativeNetworkDeviceParser : public NetworkDeviceParser {
+ public:
+  NativeNetworkDeviceParser();
+  virtual ~NativeNetworkDeviceParser();
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          NetworkDevice* device) OVERRIDE;
+ protected:
+  virtual ConnectionType ParseType(const std::string& type) OVERRIDE;
+
+  // Parsing helper routines specific to native network devices.
+  virtual bool ParseApnList(const ListValue& list, CellularApnList* apn_list);
+  virtual bool ParseFoundNetworksFromList(const ListValue& list,
+                                          CellularNetworkList* found_networks);
+  virtual SimLockState ParseSimLockState(const std::string& state);
+  virtual bool ParseSimLockStateFromDictionary(const DictionaryValue& info,
+                                               SimLockState* out_state,
+                                               int* out_retries);
+  virtual TechnologyFamily ParseTechnologyFamily(
+      const std::string& technology_family);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeNetworkDeviceParser);
+};
+
+// This is the network parser that parses the data from the network
+// stack on the native platform.  Currently it parses
+// FlimFlam-provided information.
+class NativeNetworkParser : public NetworkParser {
+ public:
+  NativeNetworkParser();
+  virtual ~NativeNetworkParser();
+  static const EnumMapper<PropertyIndex>* property_mapper();
+  static const ConnectionType ParseConnectionType(const std::string& type);
+ protected:
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          Network* network) OVERRIDE;
+  virtual ConnectionType ParseType(const std::string& type) OVERRIDE;
+  virtual ConnectionType ParseTypeFromDictionary(
+      const DictionaryValue& info) OVERRIDE;
+  virtual ConnectionMode ParseMode(const std::string& mode) OVERRIDE;
+  virtual ConnectionState ParseState(const std::string& state) OVERRIDE;
+  virtual ConnectionError ParseError(const std::string& error) OVERRIDE;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeNetworkParser);
+};
+
+// Below are specific types of network parsers.
+class NativeEthernetNetworkParser : public NativeNetworkParser {
+ public:
+  NativeEthernetNetworkParser();
+  virtual ~NativeEthernetNetworkParser();
+ private:
+  // NOTE: Uses base class ParseValue, etc.
+
+  DISALLOW_COPY_AND_ASSIGN(NativeEthernetNetworkParser);
+};
+
+// Base for wireless networks.
+class NativeWirelessNetworkParser : public NativeNetworkParser {
+ public:
+  NativeWirelessNetworkParser();
+  virtual ~NativeWirelessNetworkParser();
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          Network* network) OVERRIDE;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeWirelessNetworkParser);
+};
+
+class NativeWifiNetworkParser : public NativeWirelessNetworkParser {
+ public:
+  NativeWifiNetworkParser();
+  virtual ~NativeWifiNetworkParser();
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          Network* network) OVERRIDE;
+ protected:
+  ConnectionSecurity ParseSecurity(const std::string& security);
+  EAPMethod ParseEAPMethod(const std::string& method);
+  EAPPhase2Auth ParseEAPPhase2Auth(const std::string& auth);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeWifiNetworkParser);
+};
+
+class NativeCellularNetworkParser : public NativeWirelessNetworkParser {
+ public:
+  NativeCellularNetworkParser();
+  virtual ~NativeCellularNetworkParser();
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          Network* network) OVERRIDE;
+ protected:
+  ActivationState ParseActivationState(const std::string& state);
+  NetworkTechnology ParseNetworkTechnology(
+      const std::string& technology);
+  NetworkRoamingState ParseRoamingState(
+      const std::string& roaming_state);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeCellularNetworkParser);
+};
+
+class NativeVirtualNetworkParser : public NativeNetworkParser {
+ public:
+  NativeVirtualNetworkParser();
+  virtual ~NativeVirtualNetworkParser();
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          Network* network) OVERRIDE;
+  virtual bool UpdateNetworkFromInfo(const DictionaryValue& info,
+                                     Network* network) OVERRIDE;
+ protected:
+  bool ParseProviderValue(PropertyIndex index,
+                                  const Value& value,
+                                  VirtualNetwork* network);
+  ProviderType ParseProviderType(const std::string& type);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeVirtualNetworkParser);
+};
+
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_CROS_NATIVE_NETWORK_PARSER_H_
diff --git a/chrome/browser/chromeos/cros/network_library.cc b/chrome/browser/chromeos/cros/network_library.cc
index 06f3aba..bca39b9 100644
--- a/chrome/browser/chromeos/cros/network_library.cc
+++ b/chrome/browser/chromeos/cros/network_library.cc
@@ -21,6 +21,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 +39,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 +53,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 +103,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 +163,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 +202,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 +232,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 +420,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)
+    : 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 +454,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 {
@@ -1595,47 +519,36 @@ std::string VirtualNetwork::GetProviderTypeString() const {
 }
 
 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
 
@@ -1883,7 +796,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 +807,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 +935,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 +952,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 +987,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_;
@@ -2288,16 +1027,16 @@ 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);
@@ -2314,24 +1053,24 @@ void WifiNetwork::SetEAPPhase2Auth(EAPPhase2Auth auth) {
       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;
   }
 }
@@ -2345,15 +1084,15 @@ void WifiNetwork::SetEAPServerCaCertNssNickname(
 
 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_);
 }
 
@@ -2411,11 +1150,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 +1197,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;
@@ -2759,8 +1498,6 @@ class NetworkLibraryImplBase : public NetworkLibrary  {
   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();
@@ -3166,7 +1903,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;
@@ -3612,7 +2349,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.
@@ -3632,7 +2369,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.
@@ -3645,7 +2382,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.
@@ -3875,7 +2612,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;
   }
@@ -3929,32 +2666,6 @@ void NetworkLibraryImplBase::DeleteRememberedNetwork(
   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() {
@@ -3988,7 +2699,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;
   }
@@ -4213,7 +2924,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;
@@ -4250,12 +2961,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,
@@ -4298,7 +3009,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);
@@ -4308,19 +3019,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 {
@@ -4440,22 +3151,20 @@ void NetworkLibraryImplCros::NetworkStatusChangedHandler(
   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.
@@ -4473,35 +3182,41 @@ void NetworkLibraryImplCros::NetworkDevicePropertyChangedHandler(
   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: "
-              << 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;
+    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;
     }
     // 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);
   }
 }
 
@@ -4530,7 +3245,7 @@ void NetworkLibraryImplCros::NetworkConnectCallback(
   }
   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;
@@ -4554,7 +3269,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));
@@ -4582,7 +3297,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));
@@ -4594,7 +3309,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),
@@ -4950,7 +3665,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.
@@ -5020,7 +3735,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:
+      // Currently we ignore PortalURL, CheckPortalList and ArpGateway.
       break;
     default:
       LOG(WARNING) << "Manager: Unhandled key: " << key;
@@ -5045,20 +3761,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();
 }
 
@@ -5089,7 +3805,8 @@ void NetworkLibraryImplCros::UpdateTechnologies(
     std::string technology;
     (*iter)->GetAsString(&technology);
     if (!technology.empty()) {
-      ConnectionType type = ParseType(technology);
+      ConnectionType type =
+          NativeNetworkParser::ParseConnectionType(technology);
       bitfield |= 1 << type;
     }
   }
@@ -5175,7 +3892,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);
     }
@@ -5215,26 +3932,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;
 
@@ -5393,7 +4109,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);
     }
   }
 }
@@ -5401,23 +4117,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());
+      delete remembered;
       return NULL;
     }
   }
-  remembered->ParseInfo(info);  // virtual.
 
   SetProfileTypeFromPath(remembered);
 
@@ -5463,6 +4180,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);
       }
@@ -5493,23 +4211,27 @@ 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;
+    }
+    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());
@@ -5540,7 +4262,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,
@@ -5613,9 +4335,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
@@ -5630,7 +4351,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);
@@ -5684,7 +4405,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"));
@@ -5722,7 +4443,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);
@@ -5730,7 +4451,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);
@@ -5738,7 +4459,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);
 
@@ -5758,7 +4479,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);
 
@@ -5784,7 +4505,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);
diff --git a/chrome/browser/chromeos/cros/network_library.h b/chrome/browser/chromeos/cros/network_library.h
index 6dc7509..e82af47 100644
--- a/chrome/browser/chromeos/cros/network_library.h
+++ b/chrome/browser/chromeos/cros/network_library.h
@@ -13,6 +13,7 @@
 #include "base/memory/scoped_vector.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
+#include "base/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "third_party/cros/chromeos_network.h"
@@ -24,6 +25,120 @@ class Value;
 
 namespace chromeos {
 
+class NativeNetworkParser;
+class NativeNetworkDeviceParser;
+
+// This is the list of all implementation classes that are allowed
+// access to the internals of the network library classes.
+#define NETWORK_LIBRARY_IMPL_FRIENDS            \
+  friend class NetworkLibraryImplBase;          \
+  friend class NetworkLibraryImplCros;          \
+  friend class NetworkLibraryImplStub;
+
+// This enumerates the various property indices that can be found in a
+// dictionary being parsed.
+enum PropertyIndex {
+  PROPERTY_INDEX_ACTIVATION_STATE,
+  PROPERTY_INDEX_ACTIVE_PROFILE,
+  PROPERTY_INDEX_ARP_GATEWAY,
+  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_GUID,
+  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,
+};
+
 // Connection enums (see flimflam/include/service.h)
 enum ConnectionType {
   TYPE_UNKNOWN   = 0,
@@ -101,8 +216,17 @@ enum TechnologyFamily {
   TECHNOLOGY_FAMILY_GSM     = 2
 };
 
+// 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,
+};
+
 // SIMLock states (see gobi-cromo-plugin/gobi_gsm_modem.cc)
-enum SIMLockState {
+enum SimLockState {
   SIM_UNKNOWN    = 0,
   SIM_UNLOCKED   = 1,
   SIM_LOCKED_PIN = 2,
@@ -110,15 +234,15 @@ enum SIMLockState {
 };
 
 // SIM PinRequire states. Since PinRequire current state is not exposed as a
-// cellular property, we initialize it's value based on the SIMLockState
+// cellular property, we initialize it's value based on the SimLockState
 // initial value.
-// SIM_PIN_REQUIRE_UNKNOWN - SIM card is absent or SIMLockState initial value
+// SIM_PIN_REQUIRE_UNKNOWN - SIM card is absent or SimLockState initial value
 //                           hasn't been received yet.
 // SIM_PIN_REQUIRED - SIM card is locked when booted/wake from sleep and
 //                    requires user to enter PIN.
 // SIM_PIN_NOT_REQUIRED - SIM card is unlocked all the time and requires PIN
 // only on certain operations, such as ChangeRequirePin, ChangePin, EnterPin.
-enum SIMPinRequire {
+enum SimPinRequire {
   SIM_PIN_REQUIRE_UNKNOWN = 0,
   SIM_PIN_NOT_REQUIRED    = 1,
   SIM_PIN_REQUIRED        = 2,
@@ -177,6 +301,15 @@ enum NetworkProfileType {
   PROFILE_USER     // In the user provile, not visible to other users.
 };
 
+// Virtual Network provider type.
+enum ProviderType {
+  PROVIDER_TYPE_L2TP_IPSEC_PSK,
+  PROVIDER_TYPE_L2TP_IPSEC_USER_CERT,
+  PROVIDER_TYPE_OPEN_VPN,
+  // Add new provider types before PROVIDER_TYPE_MAX.
+  PROVIDER_TYPE_MAX,
+};
+
 // Simple wrapper for property Cellular.FoundNetworks.
 struct FoundCellularNetwork {
   FoundCellularNetwork();
@@ -235,26 +368,27 @@ class NetworkDevice {
   // Device info.
   const std::string& device_path() const { return device_path_; }
   const std::string& name() const { return name_; }
+  const std::string& unique_id() const { return unique_id_; }
   ConnectionType type() const { return type_; }
   bool scanning() const { return scanning_; }
-  const std::string& meid() const { return MEID_; }
-  const std::string& imei() const { return IMEI_; }
-  const std::string& imsi() const { return IMSI_; }
-  const std::string& esn() const { return ESN_; }
-  const std::string& mdn() const { return MDN_; }
-  const std::string& min() const { return MIN_; }
+  const std::string& meid() const { return meid_; }
+  const std::string& imei() const { return imei_; }
+  const std::string& imsi() const { return imsi_; }
+  const std::string& esn() const { return esn_; }
+  const std::string& mdn() const { return mdn_; }
+  const std::string& min() const { return min_; }
   const std::string& model_id() const { return model_id_; }
   const std::string& manufacturer() const { return manufacturer_; }
-  SIMLockState sim_lock_state() const { return sim_lock_state_; }
+  SimLockState sim_lock_state() const { return sim_lock_state_; }
   bool is_sim_locked() const {
     return sim_lock_state_ == SIM_LOCKED_PIN ||
         sim_lock_state_ == SIM_LOCKED_PUK;
   }
   const int sim_retries_left() const { return sim_retries_left_; }
-  SIMPinRequire sim_pin_required() const { return sim_pin_required_; }
+  SimPinRequire sim_pin_required() const { return sim_pin_required_; }
   const std::string& firmware_revision() const { return firmware_revision_; }
   const std::string& hardware_revision() const { return hardware_revision_; }
-  const unsigned int prl_version() const { return PRL_version_; }
+  const unsigned int prl_version() const { return prl_version_; }
   const std::string& home_provider() const { return home_provider_; }
   const std::string& home_provider_code() const { return home_provider_code_; }
   const std::string& home_provider_country() const {
@@ -275,13 +409,110 @@ class NetworkDevice {
     return provider_apn_list_;
   }
 
+  // Updates the property specified by |key| with the contents of
+  // |value|.  Returns false on failure.  Upon success, returns the
+  // PropertyIndex that was updated in |index|.  |index| may be NULL
+  // if not needed.
+  virtual bool UpdateStatus(const std::string& key,
+                            const Value& value,
+                            PropertyIndex *index);
+
+  NativeNetworkDeviceParser* device_parser() { return device_parser_.get(); }
+
+ protected:
+  void set_unique_id(const std::string& unique_id) { unique_id_ = unique_id; }
+
  private:
-  bool ParseValue(int index, const base::Value* value);
-  void ParseInfo(const base::DictionaryValue* info);
+  // This allows NetworkDeviceParser and its subclasses access to
+  // device privates so that they can be reconstituted during parsing.
+  // The parsers only access things through the private set_ functions
+  // so that this class can evolve without having to change all the
+  // parsers.
+  friend class NativeNetworkDeviceParser;
+
+  // This allows the implementation classes access to privates.
+  NETWORK_LIBRARY_IMPL_FRIENDS;
+
+  // Use these functions at your peril.  They are used by the various
+  // parsers to set state, and really shouldn't be used by anyone
+  // else.
+  void set_device_path(const std::string& device_path) {
+    device_path_ = device_path;
+  }
+  void set_name(const std::string& name) { name_ = name; }
+  void set_type(ConnectionType type) { type_ = type; }
+  void set_scanning(bool scanning) { scanning_ = scanning; }
+  void set_meid(const std::string& meid) { meid_ = meid; }
+  void set_imei(const std::string& imei) { imei_ = imei; }
+  void set_imsi(const std::string& imsi) { imsi_ = imsi; }
+  void set_esn(const std::string& esn) { esn_ = esn; }
+  void set_mdn(const std::string& mdn) { mdn_ = mdn; }
+  void set_min(const std::string& min) { min_ = min; }
+  void set_technology_family(TechnologyFamily technology_family) {
+    technology_family_ = technology_family;
+  }
+  void set_carrier(const std::string& carrier) { carrier_ = carrier; }
+  void set_home_provider(const std::string& home_provider) {
+    home_provider_ = home_provider;
+  }
+  void set_home_provider_code(const std::string& home_provider_code) {
+    home_provider_code_ = home_provider_code;
+  }
+  void set_home_provider_country(const std::string& home_provider_country) {
+    home_provider_country_ = home_provider_country;
+  }
+  void set_home_provider_id(const std::string& home_provider_id) {
+    home_provider_id_ = home_provider_id;
+  }
+  void set_home_provider_name(const std::string& home_provider_name) {
+    home_provider_name_ = home_provider_name;
+  }
+  void set_model_id(const std::string& model_id) { model_id_ = model_id; }
+  void set_manufacturer(const std::string& manufacturer) {
+    manufacturer_ = manufacturer;
+  }
+  void set_prl_version(int prl_version) {
+    prl_version_ = prl_version;
+  }
+  void set_sim_lock_state(SimLockState sim_lock_state) {
+    sim_lock_state_ = sim_lock_state;
+  }
+  void set_sim_retries_left(int sim_retries_left) {
+    sim_retries_left_ = sim_retries_left;
+  }
+  void set_sim_pin_required(SimPinRequire sim_pin_required) {
+    sim_pin_required_ = sim_pin_required;
+  }
+  void set_firmware_revision(const std::string& firmware_revision) {
+    firmware_revision_ = firmware_revision;
+  }
+  void set_hardware_revision(const std::string& hardware_revision) {
+    hardware_revision_ = hardware_revision;
+  }
+  void set_selected_cellular_network(
+      const std::string& selected_cellular_network) {
+    selected_cellular_network_ = selected_cellular_network;
+  }
+  void set_found_cellular_networks(
+      const CellularNetworkList& found_cellular_networks) {
+    found_cellular_networks_ = found_cellular_networks;
+  }
+  void set_data_roaming_allowed(bool data_roaming_allowed) {
+    data_roaming_allowed_ = data_roaming_allowed;
+  }
+  void set_support_network_scan(bool support_network_scan) {
+    support_network_scan_ = support_network_scan;
+  }
+  void set_provider_apn_list(const CellularApnList& provider_apn_list) {
+    provider_apn_list_ = provider_apn_list;
+  }
+
+  void ParseInfo(const base::DictionaryValue& info);
 
   // General device info.
   std::string device_path_;
   std::string name_;
+  std::string unique_id_;
   ConnectionType type_;
   bool scanning_;
   // Cellular specific device info.
@@ -292,29 +523,30 @@ class NetworkDevice {
   std::string home_provider_country_;
   std::string home_provider_id_;
   std::string home_provider_name_;
-  std::string MEID_;
-  std::string IMEI_;
-  std::string IMSI_;
-  std::string ESN_;
-  std::string MDN_;
-  std::string MIN_;
+  std::string meid_;
+  std::string imei_;
+  std::string imsi_;
+  std::string esn_;
+  std::string mdn_;
+  std::string min_;
   std::string model_id_;
   std::string manufacturer_;
-  SIMLockState sim_lock_state_;
+  SimLockState sim_lock_state_;
   int sim_retries_left_;
-  SIMPinRequire sim_pin_required_;
+  SimPinRequire sim_pin_required_;
   std::string firmware_revision_;
   std::string hardware_revision_;
-  int PRL_version_;
+  int prl_version_;
   std::string selected_cellular_network_;
   CellularNetworkList found_cellular_networks_;
   bool data_roaming_allowed_;
   bool support_network_scan_;
   CellularApnList provider_apn_list_;
 
-  friend class NetworkLibraryImplBase;
-  friend class NetworkLibraryImplCros;
-  friend class NetworkLibraryImplStub;
+  // This is the parser we use to parse messages from the native
+  // network layer.
+  scoped_ptr<NativeNetworkDeviceParser> device_parser_;
+
   DISALLOW_COPY_AND_ASSIGN(NetworkDevice);
 };
 
@@ -404,12 +636,20 @@ class Network {
             state == STATE_ACTIVATION_FAILURE);
   }
 
+  virtual bool UpdateStatus(const std::string& key,
+                            const Value& value,
+                            PropertyIndex* index);
+
  protected:
-  Network(const std::string& service_path, ConnectionType type);
+  Network(const std::string& service_path,
+          ConnectionType type,
+          NativeNetworkParser* parser);
+
+  // Set the state and update flags if necessary.
+  void SetState(ConnectionState state);
 
   // Parse name/value pairs from libcros.
-  virtual bool ParseValue(int index, const base::Value* value);
-  virtual void ParseInfo(const base::DictionaryValue* info);
+  virtual void ParseInfo(const base::DictionaryValue& info);
 
   // Erase cached credentials, used when "Save password" is unchecked.
   virtual void EraseCredentials();
@@ -430,24 +670,32 @@ class Network {
                                         const std::string& str,
                                         std::string* dest);
 
-  std::string device_path_;
-  std::string name_;
-  std::string ip_address_;
-  ConnectionMode mode_;
-  ConnectionState state_;
-  ConnectionError error_;
-  bool connectable_;
-  bool is_active_;
-  int priority_;  // determines order in network list.
-  bool auto_connect_;
-  bool save_credentials_;  // save passphrase and EAP credentials to disk.
-  std::string proxy_config_;
+  NativeNetworkParser* network_parser() { return network_parser_.get(); }
 
-  // Unique identifier, set the first time the network is parsed.
-  std::string unique_id_;
+  void set_unique_id(const std::string& unique_id) { unique_id_ = unique_id; }
 
  private:
+  // This allows NetworkParser and its subclasses access to device
+  // privates so that they can be reconstituted during parsing.  The
+  // parsers only access things through the private set_ functions so
+  // that this class can evolve without having to change all the
+  // parsers.
+  friend class NetworkParser;
+  friend class NativeNetworkParser;
+  friend class NativeVirtualNetworkParser;
+
+  // This allows the implementation classes access to privates.
+  NETWORK_LIBRARY_IMPL_FRIENDS;
+
+  // Use these functions at your peril.  They are used by the various
+  // parsers to set state, and really shouldn't be used by anything else
+  // because they don't do the error checking and sending to the
+  // network layer that the other setters do.
+  void set_device_path(const std::string& device_path) {
+    device_path_ = device_path;
+  }
   void set_name(const std::string& name) { name_ = name; }
+  void set_mode(ConnectionMode mode) { mode_ = mode; }
   void set_connecting(bool connecting) {
     state_ = (connecting ? STATE_ASSOCIATION : STATE_IDLE);
   }
@@ -455,14 +703,31 @@ class Network {
     state_ = (connected ? STATE_ONLINE : STATE_IDLE);
   }
   void set_connectable(bool connectable) { connectable_ = connectable; }
-  void set_active(bool is_active) { is_active_ = is_active; }
+  void set_is_active(bool is_active) { is_active_ = is_active; }
   void set_error(ConnectionError error) { error_ = error; }
   void set_added(bool added) { added_ = added; }
+  void set_auto_connect(bool auto_connect) { auto_connect_ = auto_connect; }
+  void set_save_credentials(bool save_credentials) {
+    save_credentials_ = save_credentials;
+  }
   void set_profile_path(const std::string& path) { profile_path_ = path; }
   void set_profile_type(NetworkProfileType type) { profile_type_ = type; }
 
-  // Set the state and update flags if necessary.
-  void SetState(ConnectionState state);
+  std::string device_path_;
+  std::string name_;
+  std::string ip_address_;
+  ConnectionMode mode_;
+  ConnectionState state_;
+  ConnectionError error_;
+  bool connectable_;
+  bool is_active_;
+  int priority_;  // determines order in network list.
+  bool auto_connect_;
+  bool save_credentials_;  // save passphrase and EAP credentials to disk.
+  std::string proxy_config_;
+
+  // Unique identifier, set the first time the network is parsed.
+  std::string unique_id_;
 
   // Set the profile path and update the flimfalm property.
   void SetProfilePath(const std::string& profile_path);
@@ -490,36 +755,27 @@ class Network {
   std::string service_path_;
   ConnectionType type_;
 
-  friend class NetworkLibraryImplBase;
-  friend class NetworkLibraryImplCros;
-  friend class NetworkLibraryImplStub;
+  // This is the parser we use to parse messages from the native
+  // network layer.
+  scoped_ptr<NativeNetworkParser> network_parser_;
+
   DISALLOW_COPY_AND_ASSIGN(Network);
 };
 
 // Class for networks of TYPE_ETHERNET.
 class EthernetNetwork : public Network {
  public:
-  explicit EthernetNetwork(const std::string& service_path) :
-      Network(service_path, TYPE_ETHERNET) {
-  }
+  explicit EthernetNetwork(const std::string& service_path);
  private:
-  friend class NetworkLibraryImplBase;
-  friend class NetworkLibraryImplCros;
-  friend class NetworkLibraryImplStub;
+  // This allows the implementation classes access to privates.
+  NETWORK_LIBRARY_IMPL_FRIENDS;
+
   DISALLOW_COPY_AND_ASSIGN(EthernetNetwork);
 };
 
 // Class for networks of TYPE_VPN.
 class VirtualNetwork : public Network {
  public:
-  enum ProviderType {
-    PROVIDER_TYPE_L2TP_IPSEC_PSK,
-    PROVIDER_TYPE_L2TP_IPSEC_USER_CERT,
-    PROVIDER_TYPE_OPEN_VPN,
-    // Add new provider types before PROVIDER_TYPE_MAX.
-    PROVIDER_TYPE_MAX,
-  };
-
   explicit VirtualNetwork(const std::string& service_path);
   virtual ~VirtualNetwork();
 
@@ -551,15 +807,21 @@ class VirtualNetwork : public Network {
   void SetUserPassphrase(const std::string& user_passphrase);
 
  private:
-  // Network overrides.
-  virtual bool ParseValue(int index, const base::Value* value);
-  virtual void ParseInfo(const base::DictionaryValue* info);
-  virtual void EraseCredentials();
-  virtual void CalculateUniqueId();
-
-  // VirtualNetwork private methods.
-  bool ParseProviderValue(int index, const base::Value* value);
-
+  // This allows NativeNetworkParser and its subclasses access to
+  // device privates so that they can be reconstituted during parsing.
+  // The parsers only access things through the private set_ functions
+  // so that this class can evolve without having to change all the
+  // parsers.
+  friend class NativeNetworkParser;
+  friend class NativeVirtualNetworkParser;
+
+  // This allows the implementation classes access to privates.
+  NETWORK_LIBRARY_IMPL_FRIENDS;
+
+  // Use these functions at your peril.  They are used by the various
+  // parsers to set state, and really shouldn't be used by anything else
+  // because they don't do the error checking and sending to the
+  // network layer that the other setters do.
   void set_server_hostname(const std::string& server_hostname) {
     server_hostname_ = server_hostname;
   }
@@ -575,13 +837,18 @@ class VirtualNetwork : public Network {
   void set_client_cert_id(const std::string& client_cert_id) {
     client_cert_id_ = client_cert_id;
   }
-  void set_username(const std::string& username) {
-    username_ = username;
-  }
+  void set_username(const std::string& username) { username_ = username; }
   void set_user_passphrase(const std::string& user_passphrase) {
     user_passphrase_ = user_passphrase;
   }
 
+  // Network overrides.
+  virtual void EraseCredentials() OVERRIDE;
+  virtual void CalculateUniqueId() OVERRIDE;
+
+  // VirtualNetwork private methods.
+  bool ParseProviderValue(int index, const base::Value* value);
+
   std::string server_hostname_;
   ProviderType provider_type_;
   // NSS nickname for server CA certificate.
@@ -591,10 +858,6 @@ class VirtualNetwork : public Network {
   std::string client_cert_id_;
   std::string username_;
   std::string user_passphrase_;
-
-  friend class NetworkLibraryImplBase;
-  friend class NetworkLibraryImplCros;
-  friend class NetworkLibraryImplStub;
   DISALLOW_COPY_AND_ASSIGN(VirtualNetwork);
 };
 typedef std::vector<VirtualNetwork*> VirtualNetworkVector;
@@ -605,20 +868,25 @@ class WirelessNetwork : public Network {
   int strength() const { return strength_; }
 
  protected:
-  WirelessNetwork(const std::string& service_path, ConnectionType type)
-      : Network(service_path, type),
-        strength_(0) {}
-  int strength_;  // 0-100
+  WirelessNetwork(const std::string& service_path,
+                  ConnectionType type,
+                  NativeNetworkParser* parser)
+      : Network(service_path, type, parser), strength_(0) {}
+ private:
+  // This allows NativeWirelessNetworkParser access to device privates
+  // so that they can be reconstituted during parsing.  The parsers
+  // only access things through the private set_ functions so that
+  // this class can evolve without having to change all the parsers.
+  friend class NativeWirelessNetworkParser;
 
-  // Network overrides.
-  virtual bool ParseValue(int index, const base::Value* value);
+  // This allows the implementation classes access to privates.
+  NETWORK_LIBRARY_IMPL_FRIENDS;
 
- private:
+  // The friend parsers use this.
   void set_strength(int strength) { strength_ = strength; }
 
-  friend class NetworkLibraryImplBase;
-  friend class NetworkLibraryImplCros;
-  friend class NetworkLibraryImplStub;
+  int strength_;  // 0-100
+
   DISALLOW_COPY_AND_ASSIGN(WirelessNetwork);
 };
 
@@ -666,6 +934,7 @@ class CellularNetwork : public WirelessNetwork {
   DataLeft data_left() const { return data_left_; }
   const CellularApn& apn() const { return apn_; }
   const CellularApn& last_good_apn() const { return last_good_apn_; }
+
   // Sets the APN to use in establishing data connections. Only
   // the fields of the APN that are needed for making connections
   // are passed to flimflam. The name, localized_name, and language
@@ -689,9 +958,47 @@ class CellularNetwork : public WirelessNetwork {
   // Return a string representation of |activation_state|.
   static std::string ActivationStateToString(ActivationState activation_state);
 
- protected:
-  // WirelessNetwork overrides.
-  virtual bool ParseValue(int index, const base::Value* value);
+ private:
+  // This allows NativeCellularNetworkParser access to device privates
+  // so that they can be reconstituted during parsing.  The parsers
+  // only access things through the private set_ functions so that
+  // this class can evolve without having to change all the parsers.
+  friend class NativeCellularNetworkParser;
+
+  // This allows the implementation classes access to privates.
+  NETWORK_LIBRARY_IMPL_FRIENDS;
+
+  // Use these functions at your peril.  They are used by the various
+  // parsers to set state, and really shouldn't be used by anything else
+  // because they don't do the error checking and sending to the
+  // network layer that the other setters do.
+  void set_activation_state(ActivationState activation_state) {
+    activation_state_ = activation_state;
+  }
+  void set_network_technology(NetworkTechnology network_technology) {
+    network_technology_ = network_technology;
+  }
+  void set_roaming_state(NetworkRoamingState roaming_state) {
+    roaming_state_ = roaming_state;
+  }
+  void set_operator_name(const std::string& operator_name) {
+    operator_name_ = operator_name;
+  }
+  void set_operator_code(const std::string& operator_code) {
+    operator_code_ = operator_code;
+  }
+  void set_operator_country(const std::string& operator_country) {
+    operator_country_ = operator_country;
+  }
+  void set_payment_url(const std::string& payment_url) {
+    payment_url_ = payment_url;
+  }
+  void set_usage_url(const std::string& usage_url) { usage_url_ = usage_url; }
+  void set_data_left(DataLeft data_left) { data_left_ = data_left; }
+  void set_apn(const DictionaryValue& apn) { apn_.Set(apn); }
+  void set_last_good_apn(const DictionaryValue& last_good_apn) {
+    last_good_apn_.Set(last_good_apn);
+  }
 
   ActivationState activation_state_;
   NetworkTechnology network_technology_;
@@ -707,23 +1014,6 @@ class CellularNetwork : public WirelessNetwork {
   CellularApn apn_;
   CellularApn last_good_apn_;
 
- private:
-  void set_activation_state(ActivationState state) {
-    activation_state_ = state;
-  }
-  void set_payment_url(const std::string& url) { payment_url_ = url; }
-  void set_usage_url(const std::string& url) { usage_url_ = url; }
-  void set_network_technology(NetworkTechnology technology) {
-    network_technology_ = technology;
-  }
-  void set_roaming_state(NetworkRoamingState state) { roaming_state_ = state; }
-  void set_data_left(DataLeft data_left) { data_left_ = data_left; }
-  void set_apn(const CellularApn& apn) { apn_ = apn; }
-  void set_last_good_apn(const CellularApn& apn) { last_good_apn_ = apn; }
-
-  friend class NetworkLibraryImplBase;
-  friend class NetworkLibraryImplCros;
-  friend class NetworkLibraryImplStub;
   DISALLOW_COPY_AND_ASSIGN(CellularNetwork);
 };
 typedef std::vector<CellularNetwork*> CellularNetworkVector;
@@ -783,18 +1073,25 @@ class WifiNetwork : public WirelessNetwork {
   bool IsPassphraseRequired() const;
 
  private:
-  // Network overrides.
-  virtual void EraseCredentials();
-  virtual void CalculateUniqueId();
-
-  // WirelessNetwork overrides.
-  virtual bool ParseValue(int index, const base::Value* value);
-
+  // This allows NativeWifiNetworkParser access to device privates so
+  // that they can be reconstituted during parsing.  The parsers only
+  // access things through the private set_ functions so that this
+  // class can evolve without having to change all the parsers.
+  friend class NativeWifiNetworkParser;
+
+  // This allows the implementation classes access to privates.
+  NETWORK_LIBRARY_IMPL_FRIENDS;
+
+  // Use these functions at your peril.  They are used by the various
+  // parsers to set state, and really shouldn't be used by anything else
+  // because they don't do the error checking and sending to the
+  // network layer that the other setters do.
   void set_encryption(ConnectionSecurity encryption) {
     encryption_ = encryption;
   }
   void set_passphrase(const std::string& passphrase) {
     passphrase_ = passphrase;
+    user_passphrase_ = passphrase;
   }
   void set_passphrase_required(bool passphrase_required) {
     passphrase_required_ = passphrase_required;
@@ -802,6 +1099,35 @@ class WifiNetwork : public WirelessNetwork {
   void set_identity(const std::string& identity) {
     identity_ = identity;
   }
+  void set_eap_method(EAPMethod eap_method) { eap_method_ = eap_method; }
+  void set_eap_phase_2_auth(EAPPhase2Auth eap_phase_2_auth) {
+    eap_phase_2_auth_ = eap_phase_2_auth;
+  }
+  void set_eap_server_ca_cert_nss_nickname(
+      const std::string& eap_server_ca_cert_nss_nickname) {
+    eap_server_ca_cert_nss_nickname_ = eap_server_ca_cert_nss_nickname;
+  }
+  void set_eap_client_cert_pkcs11_id(
+      const std::string& eap_client_cert_pkcs11_id) {
+    eap_client_cert_pkcs11_id_ = eap_client_cert_pkcs11_id;
+  }
+  void set_eap_use_system_cas(bool eap_use_system_cas) {
+    eap_use_system_cas_ = eap_use_system_cas;
+  }
+  void set_eap_identity(const std::string& eap_identity) {
+    eap_identity_ = eap_identity;
+  }
+  void set_eap_anonymous_identity(const std::string& eap_anonymous_identity) {
+    eap_anonymous_identity_ = eap_anonymous_identity;
+  }
+  void set_eap_passphrase(const std::string& eap_passphrase) {
+    eap_passphrase_ = eap_passphrase;
+  }
+
+  // Network overrides.
+  virtual void EraseCredentials() OVERRIDE;
+  virtual void CalculateUniqueId() OVERRIDE;
+
   ConnectionSecurity encryption_;
   std::string passphrase_;
   bool passphrase_required_;
@@ -820,9 +1146,6 @@ class WifiNetwork : public WirelessNetwork {
   // Passphrase set by user (stored for UI).
   std::string user_passphrase_;
 
-  friend class NetworkLibraryImplBase;
-  friend class NetworkLibraryImplCros;
-  friend class NetworkLibraryImplStub;
   DISALLOW_COPY_AND_ASSIGN(WifiNetwork);
 };
 typedef std::vector<WifiNetwork*> WifiNetworkVector;
diff --git a/chrome/browser/chromeos/cros/network_parser.cc b/chrome/browser/chromeos/cros/network_parser.cc
new file mode 100644
index 0000000..7657655
--- /dev/null
+++ b/chrome/browser/chromeos/cros/network_parser.cc
@@ -0,0 +1,272 @@
+// 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_parser.h"
+
+#include "base/json/json_writer.h" // for debug output only.
+#include "base/stringprintf.h"
+// Needed only for debug output (ConnectionTypeToString).
+#include "chrome/browser/chromeos/cros/native_network_constants.h"
+
+namespace chromeos {
+
+namespace {
+Network* 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: {
+      // If we try and create a service for which we have an unknown
+      // type, then that's a bug, and we will crash.
+      LOG(FATAL) << "Unknown service type: " << type;
+      return NULL;
+    }
+  }
+}
+}  // namespace
+
+NetworkDeviceParser::NetworkDeviceParser(
+    const EnumMapper<PropertyIndex>* mapper) : mapper_(mapper) {
+  CHECK(mapper);
+}
+
+NetworkDeviceParser::~NetworkDeviceParser() {
+}
+
+NetworkDevice* NetworkDeviceParser::CreateDeviceFromInfo(
+    const std::string& device_path,
+    const DictionaryValue& info) {
+  scoped_ptr<NetworkDevice> device(new NetworkDevice(device_path));
+  if (!UpdateDeviceFromInfo(info, device.get())) {
+    NOTREACHED() << "Unable to create new device";
+    return NULL;
+  }
+  VLOG(2) << "Created device for path " << device_path;
+  return device.release();
+}
+
+bool NetworkDeviceParser::UpdateDeviceFromInfo(const DictionaryValue& info,
+                                               NetworkDevice* device) {
+  for (DictionaryValue::key_iterator iter = info.begin_keys();
+       iter != info.end_keys(); ++iter) {
+    const std::string& key = *iter;
+    Value* value;
+    bool result = info.GetWithoutPathExpansion(key, &value);
+    DCHECK(result);
+    if (result)
+      UpdateStatus(key, *value, device, NULL);
+  }
+  if (VLOG_IS_ON(2)) {
+    std::string json;
+    base::JSONWriter::Write(&info, true, &json);
+    VLOG(2) << "Updated device for path "
+            << device->device_path() << ": " << json;
+  }
+  return true;
+}
+
+bool NetworkDeviceParser::UpdateStatus(const std::string& key,
+                                       const Value& value,
+                                       NetworkDevice* device,
+                                       PropertyIndex* index) {
+  PropertyIndex found_index = mapper().Get(key);
+  if (index)
+    *index = found_index;
+  if (!ParseValue(found_index, value, device)) {
+    VLOG(1) << "NetworkDeviceParser: Unhandled key: " << key;
+    return false;
+  }
+  if (VLOG_IS_ON(2)) {
+    std::string value_json;
+    base::JSONWriter::Write(&value, true, &value_json);
+    VLOG(2) << "Updated value on device: "
+            << device->device_path() << "[" << key << "] = " << value_json;
+  }
+  return true;
+}
+
+//----------- Network Parser -----------------
+
+NetworkParser::NetworkParser(const EnumMapper<PropertyIndex>* mapper)
+    : mapper_(mapper) {
+  CHECK(mapper);
+}
+
+NetworkParser::~NetworkParser() {
+}
+
+Network* NetworkParser::CreateNetworkFromInfo(
+    const std::string& service_path,
+    const DictionaryValue& info) {
+  ConnectionType type = ParseTypeFromDictionary(info);
+  scoped_ptr<Network> network(CreateNewNetwork(type, service_path));
+  if (network.get())
+    UpdateNetworkFromInfo(info, network.get());
+  VLOG(2) << "Created Network '" << network->name()
+          << "' from info. Path:" << service_path
+          << " Type:" << ConnectionTypeToString(type);
+  return network.release();
+}
+
+bool NetworkParser::UpdateNetworkFromInfo(const DictionaryValue& info,
+                                          Network* network) {
+  network->set_unique_id("");
+  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)
+      UpdateStatus(key, *value, network, NULL);
+  }
+  if (network->unique_id().empty())
+    network->CalculateUniqueId();
+  VLOG(2) << "Updated network '" << network->name()
+          << "' Path:" << network->service_path() << " Type:"
+          << ConnectionTypeToString(network->type());
+  return true;
+}
+
+bool NetworkParser::UpdateStatus(const std::string& key,
+                                 const Value& value,
+                                 Network* network,
+                                 PropertyIndex* index) {
+  PropertyIndex found_index = mapper().Get(key);
+  if (index)
+    *index = found_index;
+  if (!ParseValue(found_index, value, network)) {
+    VLOG(1) << "Unhandled key '" << key << "' in Network: " << network->name()
+            << " ID: " << network->unique_id()
+            << " Type: " << ConnectionTypeToString(network->type());
+    return false;
+  }
+  if (VLOG_IS_ON(2)) {
+    std::string value_json;
+    base::JSONWriter::Write(&value, true, &value_json);
+    VLOG(2) << "Updated value on network: "
+            << network->unique_id() << "[" << key << "] = " << value_json;
+  }
+  return true;
+}
+
+bool NetworkParser::ParseValue(PropertyIndex index,
+                               const Value& value,
+                               Network* network) {
+  switch (index) {
+    case PROPERTY_INDEX_TYPE: {
+      std::string type_string;
+      if (value.GetAsString(&type_string)) {
+        ConnectionType type = ParseType(type_string);
+        LOG_IF(ERROR, type != network->type())
+            << "Network with mismatched type: " << network->service_path()
+            << " " << type << " != " << network->type();
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_DEVICE: {
+      std::string device_path;
+      if (!value.GetAsString(&device_path))
+        break;
+      network->set_device_path(device_path);
+      return true;
+    }
+    case PROPERTY_INDEX_NAME: {
+      std::string name;
+      if (value.GetAsString(&name)) {
+        network->SetName(name);
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_GUID: {
+      std::string unique_id;
+      if (!value.GetAsString(&unique_id))
+        break;
+      network->set_unique_id(unique_id);
+      return true;
+    }
+    case PROPERTY_INDEX_PROFILE: {
+      // Note: currently this is only provided for non remembered networks.
+      std::string profile_path;
+      if (!value.GetAsString(&profile_path))
+        break;
+      network->set_profile_path(profile_path);
+      return true;
+    }
+    case PROPERTY_INDEX_STATE: {
+      std::string state_string;
+      if (value.GetAsString(&state_string)) {
+        network->SetState(ParseState(state_string));
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_MODE: {
+      std::string mode_string;
+      if (value.GetAsString(&mode_string)) {
+        network->mode_ = ParseMode(mode_string);
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_ERROR: {
+      std::string error_string;
+      if (value.GetAsString(&error_string)) {
+        network->error_ = ParseError(error_string);
+        return true;
+      }
+      break;
+    }
+    case PROPERTY_INDEX_CONNECTABLE: {
+      bool connectable;
+      if (!value.GetAsBoolean(&connectable))
+        break;
+      network->set_connectable(connectable);
+      return true;
+    }
+    case PROPERTY_INDEX_IS_ACTIVE: {
+      bool is_active;
+      if (!value.GetAsBoolean(&is_active))
+        break;
+      network->set_is_active(is_active);
+      return true;
+    }
+    case PROPERTY_INDEX_AUTO_CONNECT: {
+      bool auto_connect;
+      if (!value.GetAsBoolean(&auto_connect))
+        break;
+      network->set_auto_connect(auto_connect);
+      return true;
+    }
+    case PROPERTY_INDEX_SAVE_CREDENTIALS: {
+      bool save_credentials;
+      if (!value.GetAsBoolean(&save_credentials))
+        break;
+      network->set_save_credentials(save_credentials);
+      return true;
+    }
+    default:
+      break;
+  }
+  return false;
+}
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/cros/network_parser.h b/chrome/browser/chromeos/cros/network_parser.h
new file mode 100644
index 0000000..922238e
--- /dev/null
+++ b/chrome/browser/chromeos/cros/network_parser.h
@@ -0,0 +1,154 @@
+// 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_PARSER_H_
+#define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_PARSER_H_
+#pragma once
+
+#include <string>
+#include <map>
+
+#include "base/scoped_ptr.h"
+#include "chrome/browser/chromeos/cros/network_library.h"
+
+class Value;
+
+namespace chromeos {
+
+class NetworkDevice;
+
+// This turns an array of string-to-enum-value mappings into a class
+// that can cache the mapping and do quick lookups using an actual map
+// class.  Usage is something like:
+//
+// const char kKey1[] = "key1";
+// const char kKey2[] = "key2";
+//
+// enum EnumFoo {
+//   UNKNOWN = 0,
+//   FOO = 1,
+//   BAR = 2,
+// };
+//
+// const EnumMapper<EnumFoo>::Pair index_table[] = {
+//   { kKey1, FOO },
+//   { kKey2, BAR },
+// };
+//
+// EnumMapper<EnumFoo> mapper(index_table, arraysize(index_table), UNKNOWN);
+// EnumFoo value = mapper.Get(kKey1);  // Returns FOO.
+// EnumFoo value = mapper.Get('boo');  // Returns UNKNOWN.
+template <typename EnumType>
+class EnumMapper {
+ public:
+  struct Pair {
+    const char* key;
+    const EnumType value;
+  };
+
+  EnumMapper(const Pair* list, size_t num_entries, EnumType unknown)
+      : unknown_value_(unknown) {
+    for (size_t i = 0; i < num_entries; ++i, ++list)
+      enum_map_[list->key] = list->value;
+  }
+
+  EnumType 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, EnumType> EnumMap;
+  typedef typename EnumMap::const_iterator EnumMapConstIter;
+  EnumMap enum_map_;
+  EnumType unknown_value_;
+  DISALLOW_COPY_AND_ASSIGN(EnumMapper);
+};
+
+// This takes a Value of a particular form, and maps the keys in the
+// dictionary to a NetworkDevice object to initialize it properly.
+// Subclasses of this can then customize its methods to parse either
+// libcros (flimflam) data or network setup information obtained from
+// policy or setup file import depending on the EnumMapper supplied.
+class NetworkDeviceParser {
+ public:
+  virtual NetworkDevice* CreateDeviceFromInfo(const std::string& device_path,
+                                              const DictionaryValue& info);
+  virtual bool UpdateDeviceFromInfo(const DictionaryValue& info,
+                                    NetworkDevice* device);
+  virtual bool UpdateStatus(const std::string& key,
+                            const Value& value,
+                            NetworkDevice* device,
+                            PropertyIndex* index);
+ protected:
+  // The NetworkDeviceParser does not take ownership of the |mapper|.
+  explicit NetworkDeviceParser(const EnumMapper<PropertyIndex>* mapper);
+  virtual ~NetworkDeviceParser();
+
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          NetworkDevice* device) = 0;
+  virtual ConnectionType ParseType(const std::string& type) = 0;
+
+  const EnumMapper<PropertyIndex>& mapper() const {
+    return *mapper_;
+  }
+
+ private:
+  const EnumMapper<PropertyIndex>* mapper_;
+  DISALLOW_COPY_AND_ASSIGN(NetworkDeviceParser);
+};
+
+// This takes a Value of a particular form, and uses the keys in the
+// dictionary to create Network (WiFiNetwork, EthernetNetwork, etc.)
+// objects and initialize them properly.  Subclasses of this can then
+// customize its methods to parse other forms of input dictionaries.
+class NetworkParser {
+ public:
+  // Called when a new network is encountered.  Returns NULL upon failure.
+  virtual Network* CreateNetworkFromInfo(const std::string& service_path,
+                                         const DictionaryValue& info);
+
+  // Called when an existing network is has new information that needs
+  // to be updated.  Returns false upon failure.
+  virtual bool UpdateNetworkFromInfo(const DictionaryValue& info,
+                                     Network* network);
+
+  // Called when an individual attribute of an existing network has
+  // changed.  |index| is a return value that supplies the appropriate
+  // property index for the given key.  |index| is filled in even if
+  // the update fails.  Returns false upon failure.
+  virtual bool UpdateStatus(const std::string& key,
+                            const Value& value,
+                            Network* network,
+                            PropertyIndex* index);
+ protected:
+  // The NetworkParser does not take ownership of the |mapper|.
+  explicit NetworkParser(const EnumMapper<PropertyIndex>* mapper);
+  virtual ~NetworkParser();
+
+  virtual bool ParseValue(PropertyIndex index,
+                          const Value& value,
+                          Network* network) = 0;
+  virtual ConnectionType ParseType(const std::string& type) = 0;
+  virtual ConnectionType ParseTypeFromDictionary(
+      const DictionaryValue& info) = 0;
+  virtual ConnectionMode ParseMode(const std::string& mode) = 0;
+  virtual ConnectionState ParseState(const std::string& state) = 0;
+  virtual ConnectionError ParseError(const std::string& error) = 0;
+
+  const EnumMapper<PropertyIndex>& mapper() const {
+    return *mapper_;
+  }
+
+ private:
+  const EnumMapper<PropertyIndex>* mapper_;
+  DISALLOW_COPY_AND_ASSIGN(NetworkParser);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_PARSER_H_
diff --git a/chrome/browser/chromeos/options/vpn_config_view.cc b/chrome/browser/chromeos/options/vpn_config_view.cc
index 19f49c9..1ab3b65 100644
--- a/chrome/browser/chromeos/options/vpn_config_view.cc
+++ b/chrome/browser/chromeos/options/vpn_config_view.cc
@@ -28,18 +28,18 @@ namespace {
 // Root CA certificates that are built into Chrome use this token name.
 const char* const kRootCertificateTokenName = "Builtin Object Token";
 
-string16 ProviderTypeToString(chromeos::VirtualNetwork::ProviderType type) {
+string16 ProviderTypeToString(chromeos::ProviderType type) {
   switch (type) {
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_PSK);
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
+    case chromeos::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_L2TP_IPSEC_USER_CERT);
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
+    case chromeos::PROVIDER_TYPE_OPEN_VPN:
       return l10n_util::GetStringUTF16(
           IDS_OPTIONS_SETTINGS_INTERNET_OPTIONS_OPEN_VPN);
-    case chromeos::VirtualNetwork::PROVIDER_TYPE_MAX:
+    case chromeos::PROVIDER_TYPE_MAX:
       break;
   }
   NOTREACHED();
@@ -56,12 +56,11 @@ class ProviderTypeComboboxModel : public ui::ComboboxModel {
   virtual ~ProviderTypeComboboxModel() {}
   virtual int GetItemCount() {
     // TODO(stevenjb): Include OpenVPN option once enabled.
-    return VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT + 1;
+    return PROVIDER_TYPE_L2TP_IPSEC_USER_CERT + 1;
     // return VirtualNetwork::PROVIDER_TYPE_MAX;
   }
   virtual string16 GetItemAt(int index) {
-    VirtualNetwork::ProviderType type =
-        static_cast<VirtualNetwork::ProviderType>(index);
+    ProviderType type = static_cast<ProviderType>(index);
     return ProviderTypeToString(type);
   }
  private:
@@ -199,10 +198,11 @@ void VPNConfigView::ItemChanged(views::Combobox* combo_box,
   if (prev_index == new_index)
     return;
   if (combo_box == provider_type_combobox_) {
-    provider_type_ = static_cast<VirtualNetwork::ProviderType>(new_index);
+    provider_type_ = static_cast<ProviderType>(new_index);
     UpdateControls();
-  } else if (combo_box == user_cert_combobox_) {
-  } else if (combo_box == server_ca_cert_combobox_) {
+  } else if (combo_box == user_cert_combobox_ ||
+             combo_box == server_ca_cert_combobox_) {
+    // Do nothing.
   } else {
     NOTREACHED();
   }
@@ -218,14 +218,14 @@ bool VPNConfigView::Login() {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   if (service_path_.empty()) {
     switch (provider_type_) {
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+      case PROVIDER_TYPE_L2TP_IPSEC_PSK:
         cros->ConnectToVirtualNetworkPSK(GetService(),
                                          GetServer(),
                                          GetPSKPassphrase(),
                                          GetUsername(),
                                          GetUserPassphrase());
         break;
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
+      case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
         cros->ConnectToVirtualNetworkCert(GetService(),
                                           GetServer(),
                                           GetServerCACertNssNickname(),
@@ -234,11 +234,11 @@ bool VPNConfigView::Login() {
                                           GetUserPassphrase());
         break;
       }
-      case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
+      case PROVIDER_TYPE_OPEN_VPN:
         // TODO(stevenjb): Add support for OpenVPN.
         LOG(WARNING) << "Unsupported provider type: " << provider_type_;
         break;
-      case VirtualNetwork::PROVIDER_TYPE_MAX:
+      case PROVIDER_TYPE_MAX:
         break;
     }
   } else {
@@ -249,18 +249,18 @@ bool VPNConfigView::Login() {
       return true;  // Close dialog.
     }
     switch (provider_type_) {
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+      case PROVIDER_TYPE_L2TP_IPSEC_PSK:
         vpn->SetPSKPassphrase(GetPSKPassphrase());
         break;
-      case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
+      case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT: {
         vpn->SetClientCertID(GetUserCertID());
         break;
       }
-      case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN: {
+      case PROVIDER_TYPE_OPEN_VPN: {
         LOG(WARNING) << "OpenVPN not yet supported.";
         break;
       }
-      case VirtualNetwork::PROVIDER_TYPE_MAX:
+      case PROVIDER_TYPE_MAX:
         break;
     }
     vpn->SetUsername(GetUsername());
@@ -371,7 +371,7 @@ void VPNConfigView::Init(VirtualNetwork* vpn) {
   service_text_modified_ = false;
   provider_type_ = vpn ?
       vpn->provider_type() :
-      chromeos::VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK;
+      chromeos::PROVIDER_TYPE_L2TP_IPSEC_PSK;
 
   // Server label and input.
   layout->StartRow(0, column_view_set_id);
@@ -542,7 +542,7 @@ void VPNConfigView::Refresh() {
 void VPNConfigView::UpdateControls() {
   // Enable controls.
   switch (provider_type_) {
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
+    case PROVIDER_TYPE_L2TP_IPSEC_PSK:
       psk_passphrase_label_->SetEnabled(true);
       psk_passphrase_textfield_->SetEnabled(true);
       server_ca_cert_label_->SetEnabled(false);
@@ -550,7 +550,7 @@ void VPNConfigView::UpdateControls() {
       user_cert_label_->SetEnabled(false);
       user_cert_combobox_->SetEnabled(false);
       break;
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
+    case PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
       psk_passphrase_label_->SetEnabled(false);
       psk_passphrase_textfield_->SetEnabled(false);
       server_ca_cert_label_->SetEnabled(true);
@@ -559,7 +559,7 @@ void VPNConfigView::UpdateControls() {
       // Only enable the combobox if the user actually has a cert to select.
       user_cert_combobox_->SetEnabled(HaveUserCerts());
       break;
-    case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
+    case PROVIDER_TYPE_OPEN_VPN:
       psk_passphrase_label_->SetEnabled(false);
       psk_passphrase_textfield_->SetEnabled(false);
       server_ca_cert_label_->SetEnabled(false);
@@ -613,8 +613,8 @@ void VPNConfigView::UpdateCanLogin() {
 }
 
 bool VPNConfigView::UserCertRequired() const {
-  return provider_type_ == VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT
-      || provider_type_ == VirtualNetwork::PROVIDER_TYPE_OPEN_VPN;
+  return provider_type_ == PROVIDER_TYPE_L2TP_IPSEC_USER_CERT
+      || provider_type_ == PROVIDER_TYPE_OPEN_VPN;
 }
 
 bool VPNConfigView::HaveUserCerts() const {
diff --git a/chrome/browser/chromeos/options/vpn_config_view.h b/chrome/browser/chromeos/options/vpn_config_view.h
index 2fea727..401e176 100644
--- a/chrome/browser/chromeos/options/vpn_config_view.h
+++ b/chrome/browser/chromeos/options/vpn_config_view.h
@@ -99,7 +99,7 @@ class VPNConfigView : public ChildNetworkConfigView,
   std::string server_hostname_;
   string16 service_name_from_server_;
   bool service_text_modified_;
-  VirtualNetwork::ProviderType provider_type_;
+  ProviderType provider_type_;
 
   views::Label* server_text_;
   views::Textfield* server_textfield_;