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

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/cros/network_library.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 
 #include "base/i18n/icu_encoding_detection.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
+#include "base/json/json_writer.h" // for debug output only.
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/utf_string_conversion_utils.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/native_network_constants.h"
+#include "chrome/browser/chromeos/cros/native_network_parser.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/network_login_observer.h"
 #include "chrome/browser/chromeos/user_cros_settings_provider.h"
 #include "chrome/common/time_format.h"
 #include "content/browser/browser_thread.h"
 #include "crypto/nss_util.h"  // crypto::GetTPMTokenInfo() for 802.1X and VPN.
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/bytes_formatting.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementation notes.
 // NetworkLibraryImpl manages a series of classes that describe network devices
 // and services:
 //
 // NetworkDevice: e.g. ethernet, wifi modem, cellular modem
-//  device_map_: canonical map<path,NetworkDevice*> for devices
+//  device_map_: canonical map<path, NetworkDevice*> for devices
 //
 // Network: a network service ("network").
-//  network_map_: canonical map<path,Network*> for all visible networks.
+//  network_map_: canonical map<path, Network*> for all visible networks.
 //  EthernetNetwork
 //   ethernet_: EthernetNetwork* to the active ethernet network in network_map_.
 //  WirelessNetwork: a WiFi or Cellular Network.
 //  WifiNetwork
 //   active_wifi_: WifiNetwork* to the active wifi network in network_map_.
 //   wifi_networks_: ordered vector of WifiNetwork* entries in network_map_,
 //       in descending order of importance.
 //  CellularNetwork
 //   active_cellular_: Cellular version of wifi_.
 //   cellular_networks_: Cellular version of wifi_.
-// network_unique_id_map_: map<unique_id,Network*> for visible networks.
-// remembered_network_map_: a canonical map<path,Network*> for all networks
+// network_unique_id_map_: map<unique_id, Network*> for visible networks.
+// remembered_network_map_: a canonical map<path, Network*> for all networks
 //     remembered in the active Profile ("favorites").
 // remembered_wifi_networks_: ordered vector of WifiNetwork* entries in
 //     remembered_network_map_, in descending order of preference.
 // remembered_virtual_networks_: ordered vector of VirtualNetwork* entries in
 //     remembered_network_map_, in descending order of preference.
 //
 // network_manager_monitor_: a handle to the libcros network Manager handler.
 // NetworkManagerStatusChanged: This handles all messages from the Manager.
 //   Messages are parsed here and the appropriate updates are then requested.
 //
@@ skipping 28 matching lines @@
 const int kNetworkNotifyDelayMs = 50;
 
 // How long we should remember that cellular plan payment was received.
 const int kRecentPlanPaymentHours = 6;
 
 // Default value of the SIM unlock retries count. It is updated to the real
 // retries count once cellular device with SIM card is initialized.
 // If cellular device doesn't have SIM card, then retries are never used.
 const int kDefaultSimUnlockRetriesCount = 999;
 
-// Format of the Carrier ID: <carrier name> (<carrier country>).
-const char kCarrierIdFormat[] = "%s (%s)";
-
-// Path of the default (shared) flimflam profile.
-const char kSharedProfilePath[] = "/profile/default";
-
-// Type of a pending SIM operation.
-enum SimOperationType {
-  SIM_OPERATION_NONE               = 0,
-  SIM_OPERATION_CHANGE_PIN         = 1,
-  SIM_OPERATION_CHANGE_REQUIRE_PIN = 2,
-  SIM_OPERATION_ENTER_PIN          = 3,
-  SIM_OPERATION_UNBLOCK_PIN        = 4,
-};
-
-// D-Bus interface string constants.
-
-// Flimflam manager properties.
-const char kAvailableTechnologiesProperty[] = "AvailableTechnologies";
-const char kEnabledTechnologiesProperty[] = "EnabledTechnologies";
-const char kConnectedTechnologiesProperty[] = "ConnectedTechnologies";
-const char kDefaultTechnologyProperty[] = "DefaultTechnology";
-const char kOfflineModeProperty[] = "OfflineMode";
-const char kActiveProfileProperty[] = "ActiveProfile";
-const char kProfilesProperty[] = "Profiles";
-const char kServicesProperty[] = "Services";
-const char kServiceWatchListProperty[] = "ServiceWatchList";
-const char kDevicesProperty[] = "Devices";
-const char kPortalURLProperty[] = "PortalURL";
-const char kCheckPortalListProperty[] = "CheckPortalList";
-
-// Flimflam service properties.
-const char kSecurityProperty[] = "Security";
-const char kPassphraseProperty[] = "Passphrase";
-const char kIdentityProperty[] = "Identity";
-const char kPassphraseRequiredProperty[] = "PassphraseRequired";
-const char kSaveCredentialsProperty[] = "SaveCredentials";
-const char kSignalStrengthProperty[] = "Strength";
-const char kNameProperty[] = "Name";
-const char kStateProperty[] = "State";
-const char kTypeProperty[] = "Type";
-const char kDeviceProperty[] = "Device";
-const char kProfileProperty[] = "Profile";
-const char kTechnologyFamilyProperty[] = "Cellular.Family";
-const char kActivationStateProperty[] = "Cellular.ActivationState";
-const char kNetworkTechnologyProperty[] = "Cellular.NetworkTechnology";
-const char kRoamingStateProperty[] = "Cellular.RoamingState";
-const char kOperatorNameProperty[] = "Cellular.OperatorName";
-const char kOperatorCodeProperty[] = "Cellular.OperatorCode";
-const char kServingOperatorProperty[] = "Cellular.ServingOperator";
-const char kPaymentURLProperty[] = "Cellular.OlpUrl";
-const char kUsageURLProperty[] = "Cellular.UsageUrl";
-const char kCellularApnProperty[] = "Cellular.APN";
-const char kCellularLastGoodApnProperty[] = "Cellular.LastGoodAPN";
-const char kCellularApnListProperty[] = "Cellular.APNList";
-const char kWifiHexSsid[] = "WiFi.HexSSID";
-const char kWifiFrequency[] = "WiFi.Frequency";
-const char kWifiHiddenSsid[] = "WiFi.HiddenSSID";
-const char kWifiPhyMode[] = "WiFi.PhyMode";
-const char kWifiAuthMode[] = "WiFi.AuthMode";
-const char kFavoriteProperty[] = "Favorite";
-const char kConnectableProperty[] = "Connectable";
-const char kPriorityProperty[] = "Priority";
-const char kAutoConnectProperty[] = "AutoConnect";
-const char kIsActiveProperty[] = "IsActive";
-const char kModeProperty[] = "Mode";
-const char kErrorProperty[] = "Error";
-const char kEntriesProperty[] = "Entries";
-const char kProviderProperty[] = "Provider";
-const char kHostProperty[] = "Host";
-const char kProxyConfigProperty[] = "ProxyConfig";
-
-// Flimflam property names for SIMLock status.
-const char kSIMLockStatusProperty[] = "Cellular.SIMLockStatus";
-const char kSIMLockTypeProperty[] = "LockType";
-const char kSIMLockRetriesLeftProperty[] = "RetriesLeft";
-
-// Flimflam property names for Cellular.FoundNetworks.
-const char kLongNameProperty[] = "long_name";
-const char kStatusProperty[] = "status";
-const char kShortNameProperty[] = "short_name";
-const char kTechnologyProperty[] = "technology";
-const char kNetworkIdProperty[] = "network_id";
-
-// Flimflam SIMLock status types.
-const char kSIMLockPin[] = "sim-pin";
-const char kSIMLockPuk[] = "sim-puk";
-
-// APN info property names.
-const char kApnProperty[] = "apn";
-const char kApnNetworkIdProperty[] = "network_id";
-const char kApnUsernameProperty[] = "username";
-const char kApnPasswordProperty[] = "password";
-const char kApnNameProperty[] = "name";
-const char kApnLocalizedNameProperty[] = "localized_name";
-const char kApnLanguageProperty[] = "language";
-
-// Operator info property names.
-const char kOperatorNameKey[] = "name";
-const char kOperatorCodeKey[] = "code";
-const char kOperatorCountryKey[] = "country";
-
-// Flimflam device info property names.
-const char kScanningProperty[] = "Scanning";
-const char kPoweredProperty[] = "Powered";
-const char kNetworksProperty[] = "Networks";
-const char kCarrierProperty[] = "Cellular.Carrier";
-const char kCellularAllowRoamingProperty[] = "Cellular.AllowRoaming";
-const char kHomeProviderProperty[] = "Cellular.HomeProvider";
-const char kMeidProperty[] = "Cellular.MEID";
-const char kImeiProperty[] = "Cellular.IMEI";
-const char kImsiProperty[] = "Cellular.IMSI";
-const char kEsnProperty[] = "Cellular.ESN";
-const char kMdnProperty[] = "Cellular.MDN";
-const char kMinProperty[] = "Cellular.MIN";
-const char kModelIDProperty[] = "Cellular.ModelID";
-const char kManufacturerProperty[] = "Cellular.Manufacturer";
-const char kFirmwareRevisionProperty[] = "Cellular.FirmwareRevision";
-const char kHardwareRevisionProperty[] = "Cellular.HardwareRevision";
-const char kPRLVersionProperty[] = "Cellular.PRLVersion"; // (INT16)
-const char kSelectedNetworkProperty[] = "Cellular.SelectedNetwork";
-const char kSupportNetworkScanProperty[] = "Cellular.SupportNetworkScan";
-const char kFoundNetworksProperty[] = "Cellular.FoundNetworks";
-
-// Flimflam ip config property names.
-const char kAddressProperty[] = "Address";
-const char kPrefixlenProperty[] = "Prefixlen";
-const char kGatewayProperty[] = "Gateway";
-const char kNameServersProperty[] = "NameServers";
-
-// Flimflam type options.
-const char kTypeEthernet[] = "ethernet";
-const char kTypeWifi[] = "wifi";
-const char kTypeWimax[] = "wimax";
-const char kTypeBluetooth[] = "bluetooth";
-const char kTypeCellular[] = "cellular";
-const char kTypeVPN[] = "vpn";
-
-// Flimflam mode options.
-const char kModeManaged[] = "managed";
-const char kModeAdhoc[] = "adhoc";
-
-// Flimflam security options.
-const char kSecurityWpa[] = "wpa";
-const char kSecurityWep[] = "wep";
-const char kSecurityRsn[] = "rsn";
-const char kSecurity8021x[] = "802_1x";
-const char kSecurityPsk[] = "psk";
-const char kSecurityNone[] = "none";
-
-// Flimflam L2TPIPsec property names.
-const char kL2TPIPSecCACertNSSProperty[] = "L2TPIPsec.CACertNSS";
-const char kL2TPIPSecClientCertIDProperty[] = "L2TPIPsec.ClientCertID";
-const char kL2TPIPSecClientCertSlotProp[] = "L2TPIPsec.ClientCertSlot";
-const char kL2TPIPSecPINProperty[] = "L2TPIPsec.PIN";
-const char kL2TPIPSecPSKProperty[] = "L2TPIPsec.PSK";
-const char kL2TPIPSecUserProperty[] = "L2TPIPsec.User";
-const char kL2TPIPSecPasswordProperty[] = "L2TPIPsec.Password";
-
-// Flimflam EAP property names.
-// See src/third_party/flimflam/doc/service-api.txt.
-const char kEapIdentityProperty[] = "EAP.Identity";
-const char kEapMethodProperty[] = "EAP.EAP";
-const char kEapPhase2AuthProperty[] = "EAP.InnerEAP";
-const char kEapAnonymousIdentityProperty[] = "EAP.AnonymousIdentity";
-const char kEapClientCertProperty[] = "EAP.ClientCert";  // path
-const char kEapCertIDProperty[] = "EAP.CertID";  // PKCS#11 ID
-const char kEapClientCertNssProperty[] = "EAP.ClientCertNSS";  // NSS nickname
-const char kEapPrivateKeyProperty[] = "EAP.PrivateKey";
-const char kEapPrivateKeyPasswordProperty[] = "EAP.PrivateKeyPassword";
-const char kEapKeyIDProperty[] = "EAP.KeyID";
-const char kEapCaCertProperty[] = "EAP.CACert";  // server CA cert path
-const char kEapCaCertIDProperty[] = "EAP.CACertID";  // server CA PKCS#11 ID
-const char kEapCaCertNssProperty[] = "EAP.CACertNSS";  // server CA NSS nickname
-const char kEapUseSystemCAsProperty[] = "EAP.UseSystemCAs";
-const char kEapPinProperty[] = "EAP.PIN";
-const char kEapPasswordProperty[] = "EAP.Password";
-const char kEapKeyMgmtProperty[] = "EAP.KeyMgmt";
-
-// Flimflam EAP method options.
-const char kEapMethodPEAP[] = "PEAP";
-const char kEapMethodTLS[] = "TLS";
-const char kEapMethodTTLS[] = "TTLS";
-const char kEapMethodLEAP[] = "LEAP";
-
-// Flimflam EAP phase 2 auth options.
-const char kEapPhase2AuthPEAPMD5[] = "auth=MD5";
-const char kEapPhase2AuthPEAPMSCHAPV2[] = "auth=MSCHAPV2";
-const char kEapPhase2AuthTTLSMD5[] = "autheap=MD5";
-const char kEapPhase2AuthTTLSMSCHAPV2[] = "autheap=MSCHAPV2";
-const char kEapPhase2AuthTTLSMSCHAP[] = "autheap=MSCHAP";
-const char kEapPhase2AuthTTLSPAP[] = "autheap=PAP";
-const char kEapPhase2AuthTTLSCHAP[] = "autheap=CHAP";
-
-// Flimflam VPN provider types.
-const char kProviderL2tpIpsec[] = "l2tpipsec";
-const char kProviderOpenVpn[] = "openvpn";
-
-
-// Flimflam state options.
-const char kStateIdle[] = "idle";
-const char kStateCarrier[] = "carrier";
-const char kStateAssociation[] = "association";
-const char kStateConfiguration[] = "configuration";
-const char kStateReady[] = "ready";
-const char kStatePortal[] = "portal";
-const char kStateOnline[] = "online";
-const char kStateDisconnect[] = "disconnect";
-const char kStateFailure[] = "failure";
-const char kStateActivationFailure[] = "activation-failure";
-
-// Flimflam network technology options.
-const char kNetworkTechnology1Xrtt[] = "1xRTT";
-const char kNetworkTechnologyEvdo[] = "EVDO";
-const char kNetworkTechnologyGprs[] = "GPRS";
-const char kNetworkTechnologyEdge[] = "EDGE";
-const char kNetworkTechnologyUmts[] = "UMTS";
-const char kNetworkTechnologyHspa[] = "HSPA";
-const char kNetworkTechnologyHspaPlus[] = "HSPA+";
-const char kNetworkTechnologyLte[] = "LTE";
-const char kNetworkTechnologyLteAdvanced[] = "LTE Advanced";
-const char kNetworkTechnologyGsm[] = "GSM";
-
-// Flimflam roaming state options
-const char kRoamingStateHome[] = "home";
-const char kRoamingStateRoaming[] = "roaming";
-const char kRoamingStateUnknown[] = "unknown";
-
-// Flimflam activation state options
-const char kActivationStateActivated[] = "activated";
-const char kActivationStateActivating[] = "activating";
-const char kActivationStateNotActivated[] = "not-activated";
-const char kActivationStatePartiallyActivated[] = "partially-activated";
-const char kActivationStateUnknown[] = "unknown";
-
-// FlimFlam technology family options
-const char kTechnologyFamilyCdma[] = "CDMA";
-const char kTechnologyFamilyGsm[] = "GSM";
-
-// Flimflam error options.
-const char kErrorOutOfRange[] = "out-of-range";
-const char kErrorPinMissing[] = "pin-missing";
-const char kErrorDhcpFailed[] = "dhcp-failed";
-const char kErrorConnectFailed[] = "connect-failed";
-const char kErrorBadPassphrase[] = "bad-passphrase";
-const char kErrorBadWEPKey[] = "bad-wepkey";
-const char kErrorActivationFailed[] = "activation-failed";
-const char kErrorNeedEvdo[] = "need-evdo";
-const char kErrorNeedHomeNetwork[] = "need-home-network";
-const char kErrorOtaspFailed[] = "otasp-failed";
-const char kErrorAaaFailed[] = "aaa-failed";
-const char kErrorInternal[] = "internal-error";
-const char kErrorDNSLookupFailed[] = "dns-lookup-failed";
-const char kErrorHTTPGetFailed[] = "http-get-failed";
-
-// Flimflam error messages.
-const char kErrorPassphraseRequiredMsg[] = "Passphrase required";
-const char kErrorIncorrectPinMsg[] = "org.chromium.flimflam.Error.IncorrectPin";
-const char kErrorPinBlockedMsg[] = "org.chromium.flimflam.Error.PinBlocked";
-const char kErrorPinRequiredMsg[] = "org.chromium.flimflam.Error.PinRequired";
-
-const char kUnknownString[] = "UNKNOWN";
-
-////////////////////////////////////////////////////////////////////////////
-
-static const char* ConnectionTypeToString(ConnectionType type) {
-  switch (type) {
-    case TYPE_UNKNOWN:
-      break;
-    case TYPE_ETHERNET:
-      return kTypeEthernet;
-    case TYPE_WIFI:
-      return kTypeWifi;
-    case TYPE_WIMAX:
-      return kTypeWimax;
-    case TYPE_BLUETOOTH:
-      return kTypeBluetooth;
-    case TYPE_CELLULAR:
-      return kTypeCellular;
-    case TYPE_VPN:
-      return kTypeVPN;
-  }
-  LOG(ERROR) << "ConnectionTypeToString called with unknown type: " << type;
-  return kUnknownString;
-}
-
-static const char* SecurityToString(ConnectionSecurity security) {
-  switch (security) {
-    case SECURITY_NONE:
-      return kSecurityNone;
-    case SECURITY_WEP:
-      return kSecurityWep;
-    case SECURITY_WPA:
-      return kSecurityWpa;
-    case SECURITY_RSN:
-      return kSecurityRsn;
-    case SECURITY_8021X:
-      return kSecurity8021x;
-    case SECURITY_PSK:
-      return kSecurityPsk;
-    case SECURITY_UNKNOWN:
-      break;
-  }
-  LOG(ERROR) << "SecurityToString called with unknown type: " << security;
-  return kUnknownString;
-}
-
-static const char* ProviderTypeToString(VirtualNetwork::ProviderType type) {
-  switch (type) {
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK:
-    case VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT:
-      return kProviderL2tpIpsec;
-    case VirtualNetwork::PROVIDER_TYPE_OPEN_VPN:
-      return kProviderOpenVpn;
-    case VirtualNetwork::PROVIDER_TYPE_MAX:
-      break;
-  }
-  LOG(ERROR) << "ProviderTypeToString called with unknown type: " << type;
-  return kUnknownString;
-}
-
-////////////////////////////////////////////////////////////////////////////
-
-// Helper class to cache maps of strings to enums.
-template <typename Type>
-class StringToEnum {
- public:
-  struct Pair {
-    const char* key;
-    const Type value;
-  };
-
-  StringToEnum(const Pair* list, size_t num_entries, Type unknown)
-      : unknown_value_(unknown) {
-    for (size_t i = 0; i < num_entries; ++i, ++list)
-      enum_map_[list->key] = list->value;
-  }
-
-  Type Get(const std::string& type) const {
-    EnumMapConstIter iter = enum_map_.find(type);
-    if (iter != enum_map_.end())
-      return iter->second;
-    return unknown_value_;
-  }
-
- private:
-  typedef typename std::map<std::string, Type> EnumMap;
-  typedef typename std::map<std::string, Type>::const_iterator EnumMapConstIter;
-  EnumMap enum_map_;
-  Type unknown_value_;
-  DISALLOW_COPY_AND_ASSIGN(StringToEnum);
-};
-
-////////////////////////////////////////////////////////////////////////////
-
-enum PropertyIndex {
-  PROPERTY_INDEX_ACTIVATION_STATE,
-  PROPERTY_INDEX_ACTIVE_PROFILE,
-  PROPERTY_INDEX_AUTO_CONNECT,
-  PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES,
-  PROPERTY_INDEX_CARRIER,
-  PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING,
-  PROPERTY_INDEX_CELLULAR_APN,
-  PROPERTY_INDEX_CELLULAR_APN_LIST,
-  PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN,
-  PROPERTY_INDEX_CHECK_PORTAL_LIST,
-  PROPERTY_INDEX_CONNECTABLE,
-  PROPERTY_INDEX_CONNECTED_TECHNOLOGIES,
-  PROPERTY_INDEX_CONNECTIVITY_STATE,
-  PROPERTY_INDEX_DEFAULT_TECHNOLOGY,
-  PROPERTY_INDEX_DEVICE,
-  PROPERTY_INDEX_DEVICES,
-  PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY,
-  PROPERTY_INDEX_EAP_CA_CERT,
-  PROPERTY_INDEX_EAP_CA_CERT_ID,
-  PROPERTY_INDEX_EAP_CA_CERT_NSS,
-  PROPERTY_INDEX_EAP_CERT_ID,
-  PROPERTY_INDEX_EAP_CLIENT_CERT,
-  PROPERTY_INDEX_EAP_CLIENT_CERT_NSS,
-  PROPERTY_INDEX_EAP_IDENTITY,
-  PROPERTY_INDEX_EAP_KEY_ID,
-  PROPERTY_INDEX_EAP_KEY_MGMT,
-  PROPERTY_INDEX_EAP_METHOD,
-  PROPERTY_INDEX_EAP_PASSWORD,
-  PROPERTY_INDEX_EAP_PHASE_2_AUTH,
-  PROPERTY_INDEX_EAP_PIN,
-  PROPERTY_INDEX_EAP_PRIVATE_KEY,
-  PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD,
-  PROPERTY_INDEX_EAP_USE_SYSTEM_CAS,
-  PROPERTY_INDEX_ENABLED_TECHNOLOGIES,
-  PROPERTY_INDEX_ERROR,
-  PROPERTY_INDEX_ESN,
-  PROPERTY_INDEX_FAVORITE,
-  PROPERTY_INDEX_FIRMWARE_REVISION,
-  PROPERTY_INDEX_FOUND_NETWORKS,
-  PROPERTY_INDEX_HARDWARE_REVISION,
-  PROPERTY_INDEX_HOME_PROVIDER,
-  PROPERTY_INDEX_HOST,
-  PROPERTY_INDEX_IDENTITY,
-  PROPERTY_INDEX_IMEI,
-  PROPERTY_INDEX_IMSI,
-  PROPERTY_INDEX_IS_ACTIVE,
-  PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS,
-  PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID,
-  PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT,
-  PROPERTY_INDEX_L2TPIPSEC_PASSWORD,
-  PROPERTY_INDEX_L2TPIPSEC_PIN,
-  PROPERTY_INDEX_L2TPIPSEC_PSK,
-  PROPERTY_INDEX_L2TPIPSEC_USER,
-  PROPERTY_INDEX_MANUFACTURER,
-  PROPERTY_INDEX_MDN,
-  PROPERTY_INDEX_MEID,
-  PROPERTY_INDEX_MIN,
-  PROPERTY_INDEX_MODE,
-  PROPERTY_INDEX_MODEL_ID,
-  PROPERTY_INDEX_NAME,
-  PROPERTY_INDEX_NETWORKS,
-  PROPERTY_INDEX_NETWORK_TECHNOLOGY,
-  PROPERTY_INDEX_OFFLINE_MODE,
-  PROPERTY_INDEX_OPERATOR_CODE,
-  PROPERTY_INDEX_OPERATOR_NAME,
-  PROPERTY_INDEX_PASSPHRASE,
-  PROPERTY_INDEX_PASSPHRASE_REQUIRED,
-  PROPERTY_INDEX_PAYMENT_URL,
-  PROPERTY_INDEX_PORTAL_URL,
-  PROPERTY_INDEX_POWERED,
-  PROPERTY_INDEX_PRIORITY,
-  PROPERTY_INDEX_PRL_VERSION,
-  PROPERTY_INDEX_PROFILE,
-  PROPERTY_INDEX_PROFILES,
-  PROPERTY_INDEX_PROVIDER,
-  PROPERTY_INDEX_PROXY_CONFIG,
-  PROPERTY_INDEX_ROAMING_STATE,
-  PROPERTY_INDEX_SAVE_CREDENTIALS,
-  PROPERTY_INDEX_SCANNING,
-  PROPERTY_INDEX_SECURITY,
-  PROPERTY_INDEX_SELECTED_NETWORK,
-  PROPERTY_INDEX_SERVICES,
-  PROPERTY_INDEX_SERVICE_WATCH_LIST,
-  PROPERTY_INDEX_SERVING_OPERATOR,
-  PROPERTY_INDEX_SIGNAL_STRENGTH,
-  PROPERTY_INDEX_SIM_LOCK,
-  PROPERTY_INDEX_STATE,
-  PROPERTY_INDEX_SUPPORT_NETWORK_SCAN,
-  PROPERTY_INDEX_TECHNOLOGY_FAMILY,
-  PROPERTY_INDEX_TYPE,
-  PROPERTY_INDEX_UNKNOWN,
-  PROPERTY_INDEX_USAGE_URL,
-  PROPERTY_INDEX_WIFI_AUTH_MODE,
-  PROPERTY_INDEX_WIFI_FREQUENCY,
-  PROPERTY_INDEX_WIFI_HEX_SSID,
-  PROPERTY_INDEX_WIFI_HIDDEN_SSID,
-  PROPERTY_INDEX_WIFI_PHY_MODE,
-};
-
-StringToEnum<PropertyIndex>::Pair property_index_table[] =  {
-  { kActivationStateProperty, PROPERTY_INDEX_ACTIVATION_STATE },
-  { kActiveProfileProperty, PROPERTY_INDEX_ACTIVE_PROFILE },
-  { kAutoConnectProperty, PROPERTY_INDEX_AUTO_CONNECT },
-  { kAvailableTechnologiesProperty, PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES },
-  { kCarrierProperty, PROPERTY_INDEX_CARRIER },
-  { kCellularAllowRoamingProperty, PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING },
-  { kCellularApnListProperty, PROPERTY_INDEX_CELLULAR_APN_LIST },
-  { kCellularApnProperty, PROPERTY_INDEX_CELLULAR_APN },
-  { kCellularLastGoodApnProperty, PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN },
-  { kCheckPortalListProperty, PROPERTY_INDEX_CHECK_PORTAL_LIST },
-  { kConnectableProperty, PROPERTY_INDEX_CONNECTABLE },
-  { kConnectedTechnologiesProperty, PROPERTY_INDEX_CONNECTED_TECHNOLOGIES },
-  { kDefaultTechnologyProperty, PROPERTY_INDEX_DEFAULT_TECHNOLOGY },
-  { kDeviceProperty, PROPERTY_INDEX_DEVICE },
-  { kDevicesProperty, PROPERTY_INDEX_DEVICES },
-  { kEapAnonymousIdentityProperty, PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY },
-  { kEapCaCertIDProperty, PROPERTY_INDEX_EAP_CA_CERT_ID },
-  { kEapCaCertNssProperty, PROPERTY_INDEX_EAP_CA_CERT_NSS },
-  { kEapCaCertProperty, PROPERTY_INDEX_EAP_CA_CERT },
-  { kEapCertIDProperty, PROPERTY_INDEX_EAP_CERT_ID },
-  { kEapClientCertNssProperty, PROPERTY_INDEX_EAP_CLIENT_CERT_NSS },
-  { kEapClientCertProperty, PROPERTY_INDEX_EAP_CLIENT_CERT },
-  { kEapIdentityProperty, PROPERTY_INDEX_EAP_IDENTITY },
-  { kEapKeyIDProperty, PROPERTY_INDEX_EAP_KEY_ID },
-  { kEapKeyMgmtProperty, PROPERTY_INDEX_EAP_KEY_MGMT },
-  { kEapMethodProperty, PROPERTY_INDEX_EAP_METHOD },
-  { kEapPasswordProperty, PROPERTY_INDEX_EAP_PASSWORD },
-  { kEapPhase2AuthProperty, PROPERTY_INDEX_EAP_PHASE_2_AUTH },
-  { kEapPinProperty, PROPERTY_INDEX_EAP_PIN },
-  { kEapPrivateKeyPasswordProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD },
-  { kEapPrivateKeyProperty, PROPERTY_INDEX_EAP_PRIVATE_KEY },
-  { kEapUseSystemCAsProperty, PROPERTY_INDEX_EAP_USE_SYSTEM_CAS },
-  { kEnabledTechnologiesProperty, PROPERTY_INDEX_ENABLED_TECHNOLOGIES },
-  { kErrorProperty, PROPERTY_INDEX_ERROR },
-  { kEsnProperty, PROPERTY_INDEX_ESN },
-  { kFavoriteProperty, PROPERTY_INDEX_FAVORITE },
-  { kFirmwareRevisionProperty, PROPERTY_INDEX_FIRMWARE_REVISION },
-  { kFoundNetworksProperty, PROPERTY_INDEX_FOUND_NETWORKS },
-  { kHardwareRevisionProperty, PROPERTY_INDEX_HARDWARE_REVISION },
-  { kHomeProviderProperty, PROPERTY_INDEX_HOME_PROVIDER },
-  { kHostProperty, PROPERTY_INDEX_HOST },
-  { kIdentityProperty, PROPERTY_INDEX_IDENTITY },
-  { kImeiProperty, PROPERTY_INDEX_IMEI },
-  { kImsiProperty, PROPERTY_INDEX_IMSI },
-  { kIsActiveProperty, PROPERTY_INDEX_IS_ACTIVE },
-  { kL2TPIPSecCACertNSSProperty, PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS },
-  { kL2TPIPSecClientCertIDProperty, PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID },
-  { kL2TPIPSecClientCertSlotProp, PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT },
-  { kL2TPIPSecPasswordProperty, PROPERTY_INDEX_L2TPIPSEC_PASSWORD },
-  { kL2TPIPSecPINProperty, PROPERTY_INDEX_L2TPIPSEC_PIN },
-  { kL2TPIPSecPSKProperty, PROPERTY_INDEX_L2TPIPSEC_PSK },
-  { kL2TPIPSecUserProperty, PROPERTY_INDEX_L2TPIPSEC_USER },
-  { kManufacturerProperty, PROPERTY_INDEX_MANUFACTURER },
-  { kMdnProperty, PROPERTY_INDEX_MDN },
-  { kMeidProperty, PROPERTY_INDEX_MEID },
-  { kMinProperty, PROPERTY_INDEX_MIN },
-  { kModeProperty, PROPERTY_INDEX_MODE },
-  { kModelIDProperty, PROPERTY_INDEX_MODEL_ID },
-  { kNameProperty, PROPERTY_INDEX_NAME },
-  { kNetworkTechnologyProperty, PROPERTY_INDEX_NETWORK_TECHNOLOGY },
-  { kNetworksProperty, PROPERTY_INDEX_NETWORKS },
-  { kOfflineModeProperty, PROPERTY_INDEX_OFFLINE_MODE },
-  { kOperatorCodeProperty, PROPERTY_INDEX_OPERATOR_CODE },
-  { kOperatorNameProperty, PROPERTY_INDEX_OPERATOR_NAME },
-  { kPRLVersionProperty, PROPERTY_INDEX_PRL_VERSION },
-  { kPassphraseProperty, PROPERTY_INDEX_PASSPHRASE },
-  { kPassphraseRequiredProperty, PROPERTY_INDEX_PASSPHRASE_REQUIRED },
-  { kPaymentURLProperty, PROPERTY_INDEX_PAYMENT_URL },
-  { kPortalURLProperty, PROPERTY_INDEX_PORTAL_URL },
-  { kPoweredProperty, PROPERTY_INDEX_POWERED },
-  { kPriorityProperty, PROPERTY_INDEX_PRIORITY },
-  { kProfileProperty, PROPERTY_INDEX_PROFILE },
-  { kProfilesProperty, PROPERTY_INDEX_PROFILES },
-  { kProviderProperty, PROPERTY_INDEX_PROVIDER },
-  { kProxyConfigProperty, PROPERTY_INDEX_PROXY_CONFIG },
-  { kRoamingStateProperty, PROPERTY_INDEX_ROAMING_STATE },
-  { kSIMLockStatusProperty, PROPERTY_INDEX_SIM_LOCK },
-  { kSaveCredentialsProperty, PROPERTY_INDEX_SAVE_CREDENTIALS },
-  { kScanningProperty, PROPERTY_INDEX_SCANNING },
-  { kSecurityProperty, PROPERTY_INDEX_SECURITY },
-  { kSelectedNetworkProperty, PROPERTY_INDEX_SELECTED_NETWORK },
-  { kServiceWatchListProperty, PROPERTY_INDEX_SERVICE_WATCH_LIST },
-  { kServicesProperty, PROPERTY_INDEX_SERVICES },
-  { kServingOperatorProperty, PROPERTY_INDEX_SERVING_OPERATOR },
-  { kSignalStrengthProperty, PROPERTY_INDEX_SIGNAL_STRENGTH },
-  { kStateProperty, PROPERTY_INDEX_STATE },
-  { kSupportNetworkScanProperty, PROPERTY_INDEX_SUPPORT_NETWORK_SCAN },
-  { kTechnologyFamilyProperty, PROPERTY_INDEX_TECHNOLOGY_FAMILY },
-  { kTypeProperty, PROPERTY_INDEX_TYPE },
-  { kUsageURLProperty, PROPERTY_INDEX_USAGE_URL },
-  { kWifiAuthMode, PROPERTY_INDEX_WIFI_AUTH_MODE },
-  { kWifiFrequency, PROPERTY_INDEX_WIFI_FREQUENCY },
-  { kWifiHexSsid, PROPERTY_INDEX_WIFI_HEX_SSID },
-  { kWifiHiddenSsid, PROPERTY_INDEX_WIFI_HIDDEN_SSID },
-  { kWifiPhyMode, PROPERTY_INDEX_WIFI_PHY_MODE },
-};
-
-StringToEnum<PropertyIndex>& property_index_parser() {
-  static StringToEnum<PropertyIndex> parser(property_index_table,
-                                            arraysize(property_index_table),
-                                            PROPERTY_INDEX_UNKNOWN);
-  return parser;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// Parse strings from libcros.
-
-// Network.
-static ConnectionType ParseType(const std::string& type) {
-  static StringToEnum<ConnectionType>::Pair table[] = {
-    { kTypeEthernet, TYPE_ETHERNET },
-    { kTypeWifi, TYPE_WIFI },
-    { kTypeWimax, TYPE_WIMAX },
-    { kTypeBluetooth, TYPE_BLUETOOTH },
-    { kTypeCellular, TYPE_CELLULAR },
-    { kTypeVPN, TYPE_VPN },
-  };
-  static StringToEnum<ConnectionType> parser(
-      table, arraysize(table), TYPE_UNKNOWN);
-  return parser.Get(type);
-}
-
-ConnectionType ParseTypeFromDictionary(const DictionaryValue* info) {
-  std::string type_string;
-  info->GetString(kTypeProperty, &type_string);
-  return ParseType(type_string);
-}
-
-static ConnectionMode ParseMode(const std::string& mode) {
-  static StringToEnum<ConnectionMode>::Pair table[] = {
-    { kModeManaged, MODE_MANAGED },
-    { kModeAdhoc, MODE_ADHOC },
-  };
-  static StringToEnum<ConnectionMode> parser(
-      table, arraysize(table), MODE_UNKNOWN);
-  return parser.Get(mode);
-}
-
-static ConnectionState ParseState(const std::string& state) {
-  static StringToEnum<ConnectionState>::Pair table[] = {
-    { kStateIdle, STATE_IDLE },
-    { kStateCarrier, STATE_CARRIER },
-    { kStateAssociation, STATE_ASSOCIATION },
-    { kStateConfiguration, STATE_CONFIGURATION },
-    { kStateReady, STATE_READY },
-    { kStateDisconnect, STATE_DISCONNECT },
-    { kStateFailure, STATE_FAILURE },
-    { kStateActivationFailure, STATE_ACTIVATION_FAILURE },
-    { kStatePortal, STATE_PORTAL },
-    { kStateOnline, STATE_ONLINE },
-  };
-  static StringToEnum<ConnectionState> parser(
-      table, arraysize(table), STATE_UNKNOWN);
-  return parser.Get(state);
-}
-
-static ConnectionError ParseError(const std::string& error) {
-  static StringToEnum<ConnectionError>::Pair table[] = {
-    { kErrorOutOfRange, ERROR_OUT_OF_RANGE },
-    { kErrorPinMissing, ERROR_PIN_MISSING },
-    { kErrorDhcpFailed, ERROR_DHCP_FAILED },
-    { kErrorConnectFailed, ERROR_CONNECT_FAILED },
-    { kErrorBadPassphrase, ERROR_BAD_PASSPHRASE },
-    { kErrorBadWEPKey, ERROR_BAD_WEPKEY },
-    { kErrorActivationFailed, ERROR_ACTIVATION_FAILED },
-    { kErrorNeedEvdo, ERROR_NEED_EVDO },
-    { kErrorNeedHomeNetwork, ERROR_NEED_HOME_NETWORK },
-    { kErrorOtaspFailed, ERROR_OTASP_FAILED },
-    { kErrorAaaFailed, ERROR_AAA_FAILED },
-    { kErrorInternal, ERROR_INTERNAL },
-    { kErrorDNSLookupFailed, ERROR_DNS_LOOKUP_FAILED },
-    { kErrorHTTPGetFailed, ERROR_HTTP_GET_FAILED },
-  };
-  static StringToEnum<ConnectionError> parser(
-      table, arraysize(table), ERROR_NO_ERROR);
-  return parser.Get(error);
-}
-
-// VirtualNetwork
-static VirtualNetwork::ProviderType ParseProviderType(const std::string& mode) {
-  static StringToEnum<VirtualNetwork::ProviderType>::Pair table[] = {
-    { kProviderL2tpIpsec, VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK },
-    { kProviderOpenVpn, VirtualNetwork::PROVIDER_TYPE_OPEN_VPN },
-  };
-  static StringToEnum<VirtualNetwork::ProviderType> parser(
-      table, arraysize(table), VirtualNetwork::PROVIDER_TYPE_MAX);
-  return parser.Get(mode);
-}
-
-// CellularNetwork.
-static ActivationState ParseActivationState(const std::string& state) {
-  static StringToEnum<ActivationState>::Pair table[] = {
-    { kActivationStateActivated, ACTIVATION_STATE_ACTIVATED },
-    { kActivationStateActivating, ACTIVATION_STATE_ACTIVATING },
-    { kActivationStateNotActivated, ACTIVATION_STATE_NOT_ACTIVATED },
-    { kActivationStatePartiallyActivated, ACTIVATION_STATE_PARTIALLY_ACTIVATED},
-    { kActivationStateUnknown, ACTIVATION_STATE_UNKNOWN},
-  };
-  static StringToEnum<ActivationState> parser(
-      table, arraysize(table), ACTIVATION_STATE_UNKNOWN);
-  return parser.Get(state);
-}
-
-static NetworkTechnology ParseNetworkTechnology(const std::string& technology) {
-  static StringToEnum<NetworkTechnology>::Pair table[] = {
-    { kNetworkTechnology1Xrtt, NETWORK_TECHNOLOGY_1XRTT },
-    { kNetworkTechnologyEvdo, NETWORK_TECHNOLOGY_EVDO },
-    { kNetworkTechnologyGprs, NETWORK_TECHNOLOGY_GPRS },
-    { kNetworkTechnologyEdge, NETWORK_TECHNOLOGY_EDGE },
-    { kNetworkTechnologyUmts, NETWORK_TECHNOLOGY_UMTS },
-    { kNetworkTechnologyHspa, NETWORK_TECHNOLOGY_HSPA },
-    { kNetworkTechnologyHspaPlus, NETWORK_TECHNOLOGY_HSPA_PLUS },
-    { kNetworkTechnologyLte, NETWORK_TECHNOLOGY_LTE },
-    { kNetworkTechnologyLteAdvanced, NETWORK_TECHNOLOGY_LTE_ADVANCED },
-    { kNetworkTechnologyGsm, NETWORK_TECHNOLOGY_GSM },
-  };
-  static StringToEnum<NetworkTechnology> parser(
-      table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN);
-  return parser.Get(technology);
-}
-
-static SIMLockState ParseSimLockState(const std::string& state) {
-  static StringToEnum<SIMLockState>::Pair table[] = {
-    { "", SIM_UNLOCKED },
-    { kSIMLockPin, SIM_LOCKED_PIN },
-    { kSIMLockPuk, SIM_LOCKED_PUK },
-  };
-  static StringToEnum<SIMLockState> parser(
-      table, arraysize(table), SIM_UNKNOWN);
-  SIMLockState parsed_state = parser.Get(state);
-  DCHECK_NE(parsed_state, SIM_UNKNOWN) << "Unknown SIMLock state encountered";
-  return parsed_state;
-}
-
-static bool ParseSimLockStateFromDictionary(const DictionaryValue* info,
-                                            SIMLockState* out_state,
-                                            int* out_retries) {
-  std::string state_string;
-  if (!info->GetString(kSIMLockTypeProperty, &state_string) ||
-      !info->GetInteger(kSIMLockRetriesLeftProperty, out_retries)) {
-    LOG(ERROR) << "Error parsing SIMLock state";
-    return false;
-  }
-  *out_state = ParseSimLockState(state_string);
-  return true;
-}
-
-static bool ParseFoundNetworksFromList(const ListValue* list,
-                                       CellularNetworkList* found_networks_) {
-  found_networks_->clear();
-  found_networks_->reserve(list->GetSize());
-  for (ListValue::const_iterator it = list->begin(); it != list->end(); ++it) {
-    if ((*it)->IsType(Value::TYPE_DICTIONARY)) {
-      found_networks_->resize(found_networks_->size() + 1);
-      const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it);
-      dict->GetStringWithoutPathExpansion(
-          kStatusProperty, &found_networks_->back().status);
-      dict->GetStringWithoutPathExpansion(
-          kNetworkIdProperty, &found_networks_->back().network_id);
-      dict->GetStringWithoutPathExpansion(
-          kShortNameProperty, &found_networks_->back().short_name);
-      dict->GetStringWithoutPathExpansion(
-          kLongNameProperty, &found_networks_->back().long_name);
-      dict->GetStringWithoutPathExpansion(
-          kTechnologyProperty, &found_networks_->back().technology);
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-static bool ParseApnList(const ListValue* list,
-                         CellularApnList* apn_list) {
-  apn_list->clear();
-  apn_list->reserve(list->GetSize());
-  for (ListValue::const_iterator it = list->begin(); it != list->end(); ++it) {
-    if ((*it)->IsType(Value::TYPE_DICTIONARY)) {
-      apn_list->resize(apn_list->size() + 1);
-      apn_list->back().Set(*static_cast<const DictionaryValue*>(*it));
-    } else {
-      return false;
-    }
-  }
-  return true;
-}
-
-static NetworkRoamingState ParseRoamingState(const std::string& roaming_state) {
-  static StringToEnum<NetworkRoamingState>::Pair table[] = {
-    { kRoamingStateHome, ROAMING_STATE_HOME },
-    { kRoamingStateRoaming, ROAMING_STATE_ROAMING },
-    { kRoamingStateUnknown, ROAMING_STATE_UNKNOWN },
-  };
-  static StringToEnum<NetworkRoamingState> parser(
-      table, arraysize(table), ROAMING_STATE_UNKNOWN);
-  return parser.Get(roaming_state);
-}
-
-// WifiNetwork
-static ConnectionSecurity ParseSecurity(const std::string& security) {
-  static StringToEnum<ConnectionSecurity>::Pair table[] = {
-    { kSecurityNone, SECURITY_NONE },
-    { kSecurityWep, SECURITY_WEP },
-    { kSecurityWpa, SECURITY_WPA },
-    { kSecurityRsn, SECURITY_RSN },
-    { kSecurityPsk, SECURITY_PSK },
-    { kSecurity8021x, SECURITY_8021X },
-  };
-  static StringToEnum<ConnectionSecurity> parser(
-      table, arraysize(table), SECURITY_UNKNOWN);
-  return parser.Get(security);
-}
-
-static EAPMethod ParseEAPMethod(const std::string& method) {
-  static StringToEnum<EAPMethod>::Pair table[] = {
-    { kEapMethodPEAP, EAP_METHOD_PEAP },
-    { kEapMethodTLS, EAP_METHOD_TLS },
-    { kEapMethodTTLS, EAP_METHOD_TTLS },
-    { kEapMethodLEAP, EAP_METHOD_LEAP },
-  };
-  static StringToEnum<EAPMethod> parser(
-      table, arraysize(table), EAP_METHOD_UNKNOWN);
-  return parser.Get(method);
-}
-
-static EAPPhase2Auth ParseEAPPhase2Auth(const std::string& auth) {
-  static StringToEnum<EAPPhase2Auth>::Pair table[] = {
-    { kEapPhase2AuthPEAPMD5, EAP_PHASE_2_AUTH_MD5 },
-    { kEapPhase2AuthPEAPMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
-    { kEapPhase2AuthTTLSMD5, EAP_PHASE_2_AUTH_MD5 },
-    { kEapPhase2AuthTTLSMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
-    { kEapPhase2AuthTTLSMSCHAP, EAP_PHASE_2_AUTH_MSCHAP },
-    { kEapPhase2AuthTTLSPAP, EAP_PHASE_2_AUTH_PAP },
-    { kEapPhase2AuthTTLSCHAP, EAP_PHASE_2_AUTH_CHAP },
-  };
-  static StringToEnum<EAPPhase2Auth> parser(
-      table, arraysize(table), EAP_PHASE_2_AUTH_AUTO);
-  return parser.Get(auth);
-}
-
-// NetworkDevice
-static TechnologyFamily ParseTechnologyFamily(const std::string& family) {
-  static StringToEnum<TechnologyFamily>::Pair table[] = {
-    { kTechnologyFamilyCdma, TECHNOLOGY_FAMILY_CDMA },
-    { kTechnologyFamilyGsm, TECHNOLOGY_FAMILY_GSM },
-  };
-  static StringToEnum<TechnologyFamily> parser(
-      table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN);
-  return parser.Get(family);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // Misc.
 
 // Safe string constructor since we can't rely on non NULL pointers
 // for string values from libcros.
 static std::string SafeString(const char* s) {
   return s ? std::string(s) : std::string();
 }
 
 // Erase the memory used by a string, then clear it.
@@ skipping 40 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkDevice
 
 NetworkDevice::NetworkDevice(const std::string& device_path)
     : device_path_(device_path),
       type_(TYPE_UNKNOWN),
       scanning_(false),
       sim_lock_state_(SIM_UNKNOWN),
       sim_retries_left_(kDefaultSimUnlockRetriesCount),
       sim_pin_required_(SIM_PIN_REQUIRE_UNKNOWN),
-      PRL_version_(0),
+      prl_version_(0),
       data_roaming_allowed_(false),
-      support_network_scan_(false) {
+      support_network_scan_(false),
+      device_parser_(new NativeNetworkDeviceParser) {
 }
 
 NetworkDevice::~NetworkDevice() {}
 
-bool NetworkDevice::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_TYPE: {
-      std::string type_string;
-      if (value->GetAsString(&type_string)) {
-        type_ = ParseType(type_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_NAME:
-      return value->GetAsString(&name_);
-    case PROPERTY_INDEX_CARRIER:
-      return value->GetAsString(&carrier_);
-    case PROPERTY_INDEX_SCANNING:
-      return value->GetAsBoolean(&scanning_);
-    case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING:
-      return value->GetAsBoolean(&data_roaming_allowed_);
-    case PROPERTY_INDEX_CELLULAR_APN_LIST:
-      if (value->IsType(Value::TYPE_LIST)) {
-        return ParseApnList(static_cast<const ListValue*>(value),
-                            &provider_apn_list_);
-      }
-      break;
-    case PROPERTY_INDEX_NETWORKS:
-      if (value->IsType(Value::TYPE_LIST)) {
-        // Ignored.
-        return true;
-      }
-      break;
-    case PROPERTY_INDEX_FOUND_NETWORKS:
-      if (value->IsType(Value::TYPE_LIST)) {
-        return ParseFoundNetworksFromList(
-            static_cast<const ListValue*>(value),
-            &found_cellular_networks_);
-      }
-      break;
-    case PROPERTY_INDEX_HOME_PROVIDER: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        const DictionaryValue* dict =
-            static_cast<const DictionaryValue*>(value);
-        home_provider_code_.clear();
-        home_provider_country_.clear();
-        home_provider_name_.clear();
-        dict->GetStringWithoutPathExpansion(kOperatorCodeKey,
-                                            &home_provider_code_);
-        dict->GetStringWithoutPathExpansion(kOperatorCountryKey,
-                                            &home_provider_country_);
-        dict->GetStringWithoutPathExpansion(kOperatorNameKey,
-                                            &home_provider_name_);
-        if (!home_provider_name_.empty() && !home_provider_country_.empty()) {
-          home_provider_id_ = base::StringPrintf(
-              kCarrierIdFormat,
-              home_provider_name_.c_str(),
-              home_provider_country_.c_str());
-        } else {
-          home_provider_id_ = home_provider_code_;
-          LOG(WARNING) << "Carrier ID not defined, using code instead: "
-                       << home_provider_id_;
-        }
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_MEID:
-      return value->GetAsString(&MEID_);
-    case PROPERTY_INDEX_IMEI:
-      return value->GetAsString(&IMEI_);
-    case PROPERTY_INDEX_IMSI:
-      return value->GetAsString(&IMSI_);
-    case PROPERTY_INDEX_ESN:
-      return value->GetAsString(&ESN_);
-    case PROPERTY_INDEX_MDN:
-      return value->GetAsString(&MDN_);
-    case PROPERTY_INDEX_MIN:
-      return value->GetAsString(&MIN_);
-    case PROPERTY_INDEX_MODEL_ID:
-      return value->GetAsString(&model_id_);
-    case PROPERTY_INDEX_MANUFACTURER:
-      return value->GetAsString(&manufacturer_);
-    case PROPERTY_INDEX_SIM_LOCK:
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        bool result = ParseSimLockStateFromDictionary(
-            static_cast<const DictionaryValue*>(value),
-            &sim_lock_state_,
-            &sim_retries_left_);
-        // Initialize PinRequired value only once.
-        // See SIMPinRequire enum comments.
-        if (sim_pin_required_ == SIM_PIN_REQUIRE_UNKNOWN) {
-          if (sim_lock_state_ == SIM_UNLOCKED) {
-            sim_pin_required_ = SIM_PIN_NOT_REQUIRED;
-          } else if (sim_lock_state_ == SIM_LOCKED_PIN ||
-                     sim_lock_state_ == SIM_LOCKED_PUK) {
-            sim_pin_required_ = SIM_PIN_REQUIRED;
-          }
-        }
-        return result;
-      }
-      break;
-    case PROPERTY_INDEX_FIRMWARE_REVISION:
-      return value->GetAsString(&firmware_revision_);
-    case PROPERTY_INDEX_HARDWARE_REVISION:
-      return value->GetAsString(&hardware_revision_);
-    case PROPERTY_INDEX_POWERED:
-      // we don't care about the value, just the fact that it changed
-      return true;
-    case PROPERTY_INDEX_PRL_VERSION:
-      return value->GetAsInteger(&PRL_version_);
-    case PROPERTY_INDEX_SELECTED_NETWORK:
-      return value->GetAsString(&selected_cellular_network_);
-    case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN:
-      return value->GetAsBoolean(&support_network_scan_);
-    case PROPERTY_INDEX_TECHNOLOGY_FAMILY: {
-      std::string technology_family_string;
-      if (value->GetAsString(&technology_family_string)) {
-        technology_family_ = ParseTechnologyFamily(technology_family_string);
-        return true;
-      }
-      break;
-    }
-    default:
-      break;
-  }
-  return false;
+void NetworkDevice::ParseInfo(const DictionaryValue& info) {
+  if (device_parser_.get())
+    device_parser_->UpdateDeviceFromInfo(info, this);
 }
 
-void NetworkDevice::ParseInfo(const DictionaryValue* info) {
-  for (DictionaryValue::key_iterator iter = info->begin_keys();
-       iter != info->end_keys(); ++iter) {
-    const std::string& key = *iter;
-    Value* value;
-    bool res = info->GetWithoutPathExpansion(key, &value);
-    DCHECK(res);
-    if (res) {
-      int index = property_index_parser().Get(key);
-      if (!ParseValue(index, value))
-        VLOG(1) << "NetworkDevice: Unhandled key: " << key;
-    }
-  }
+bool NetworkDevice::UpdateStatus(const std::string& key,
+                                 const Value& value,
+                                 PropertyIndex* index) {
+  if (device_parser_.get())
+    return device_parser_->UpdateStatus(key, value, this, index);
+  return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Network
 
-Network::Network(const std::string& service_path, ConnectionType type)
+Network::Network(const std::string& service_path,
+                 ConnectionType type,
+                 NativeNetworkParser* parser)
     : state_(STATE_UNKNOWN),
       error_(ERROR_NO_ERROR),
       connectable_(true),
       is_active_(false),
       priority_(kPriorityNotSet),
       auto_connect_(false),
       save_credentials_(false),
       priority_order_(0),
       added_(false),
       notify_failure_(false),
       profile_type_(PROFILE_NONE),
       service_path_(service_path),
-      type_(type) {
+      type_(type),
+      network_parser_(parser) {
 }
 
 Network::~Network() {}
 
 void Network::SetState(ConnectionState new_state) {
   if (new_state == state_)
     return;
   ConnectionState old_state = state_;
   state_ = new_state;
   if (new_state == STATE_FAILURE) {
     if (old_state != STATE_UNKNOWN) {
       // New failure, the user needs to be notified.
       notify_failure_ = true;
     }
   } else {
     // State changed, so refresh IP address.
     // Note: blocking DBus call. TODO(stevenjb): refactor this.
     InitIPAddress();
   }
   VLOG(1) << name() << ".State = " << GetStateString();
 }
 
 void Network::SetName(const std::string& name) {
   std::string name_utf8;
   ValidateUTF8(name, &name_utf8);
   set_name(name_utf8);
 }
 
-bool Network::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_TYPE: {
-      std::string type_string;
-      if (value->GetAsString(&type_string)) {
-        ConnectionType type = ParseType(type_string);
-        LOG_IF(ERROR, type != type_)
-            << "Network with mismatched type: " << service_path_
-            << " " << type << " != " << type_;
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_DEVICE:
-      return value->GetAsString(&device_path_);
-    case PROPERTY_INDEX_NAME: {
-      std::string name;
-      if (value->GetAsString(&name)) {
-        SetName(name);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PROFILE:
-      // Note: currently this is only provided for non remembered networks.
-      return value->GetAsString(&profile_path_);
-    case PROPERTY_INDEX_STATE: {
-      std::string state_string;
-      if (value->GetAsString(&state_string)) {
-        SetState(ParseState(state_string));
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_MODE: {
-      std::string mode_string;
-      if (value->GetAsString(&mode_string)) {
-        mode_ = ParseMode(mode_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_ERROR: {
-      std::string error_string;
-      if (value->GetAsString(&error_string)) {
-        error_ = ParseError(error_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_CONNECTABLE:
-      return value->GetAsBoolean(&connectable_);
-    case PROPERTY_INDEX_IS_ACTIVE:
-      return value->GetAsBoolean(&is_active_);
-    case PROPERTY_INDEX_FAVORITE:
-      // Not used currently.
-      return true;
-    case PROPERTY_INDEX_PRIORITY:
-      return value->GetAsInteger(&priority_);
-    case PROPERTY_INDEX_AUTO_CONNECT:
-      return value->GetAsBoolean(&auto_connect_);
-    case PROPERTY_INDEX_SAVE_CREDENTIALS:
-      return value->GetAsBoolean(&save_credentials_);
-    case PROPERTY_INDEX_PROXY_CONFIG:
-      return value->GetAsString(&proxy_config_);
-    default:
-      break;
-  }
-  return false;
-}
-
-void Network::ParseInfo(const DictionaryValue* info) {
-  // Set default values for properties that may not exist in the dictionary.
-  priority_ = kPriorityNotSet;
-
-  for (DictionaryValue::key_iterator iter = info->begin_keys();
-       iter != info->end_keys(); ++iter) {
-    const std::string& key = *iter;
-    Value* value;
-    bool res = info->GetWithoutPathExpansion(key, &value);
-    DCHECK(res);
-    if (res) {
-      int index = property_index_parser().Get(key);
-      if (!ParseValue(index, value))  // virtual.
-        VLOG(1) << "Network: " << name()
-                << " Type: " << ConnectionTypeToString(type())
-                << " Unhandled key: " << key;
-    }
-  }
-  CalculateUniqueId();
+void Network::ParseInfo(const DictionaryValue& info) {
+  if (network_parser_.get())
+    network_parser_->UpdateNetworkFromInfo(info, this);
 }
 
 void Network::EraseCredentials() {
 }
 
 void Network::CalculateUniqueId() {
   unique_id_ = name_;
 }
 
 bool Network::RequiresUserProfile() const {
@@ skipping 165 matching lines @@
         if (strlen(ipconfig.address) > 0) {
           ip_address_ = ipconfig.address;
           break;
         }
       }
       chromeos::FreeIPConfigStatus(ipconfig_status);
     }
   }
 }
 
+bool Network::UpdateStatus(const std::string& key,
+                           const Value& value,
+                           PropertyIndex* index) {
+  if (network_parser_.get())
+    return network_parser_->UpdateStatus(key, value, this, index);
+  return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// EthernetNetwork
+
+EthernetNetwork::EthernetNetwork(const std::string& service_path)

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

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

+    : Network(service_path, TYPE_ETHERNET, new NativeEthernetNetworkParser) {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // VirtualNetwork
 
 VirtualNetwork::VirtualNetwork(const std::string& service_path)
-    : Network(service_path, TYPE_VPN),
+    : Network(service_path, TYPE_VPN, new NativeVirtualNetworkParser),
       provider_type_(PROVIDER_TYPE_L2TP_IPSEC_PSK) {
 }
 
 VirtualNetwork::~VirtualNetwork() {}
 
-bool VirtualNetwork::ParseProviderValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_HOST:
-      return value->GetAsString(&server_hostname_);
-    case PROPERTY_INDEX_NAME:
-      // Note: shadows Network::name_ property.
-      return value->GetAsString(&name_);
-    case PROPERTY_INDEX_TYPE: {
-      std::string provider_type_string;
-      if (value->GetAsString(&provider_type_string)) {
-        provider_type_ = ParseProviderType(provider_type_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_L2TPIPSEC_CA_CERT_NSS:
-      return value->GetAsString(&ca_cert_nss_);
-    case PROPERTY_INDEX_L2TPIPSEC_PIN:
-      // Ignore PIN property.
-      return true;
-    case PROPERTY_INDEX_L2TPIPSEC_PSK:
-      return value->GetAsString(&psk_passphrase_);
-    case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_ID:
-      return value->GetAsString(&client_cert_id_);
-    case PROPERTY_INDEX_L2TPIPSEC_CLIENT_CERT_SLOT:
-      // Ignore ClientCertSlot property.
-      return true;
-    case PROPERTY_INDEX_L2TPIPSEC_USER:
-      return value->GetAsString(&username_);
-    case PROPERTY_INDEX_L2TPIPSEC_PASSWORD:
-      return value->GetAsString(&user_passphrase_);
-    default:
-      break;
-  }
-  return false;
-}
-
-bool VirtualNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_PROVIDER: {
-      DCHECK_EQ(value->GetType(), Value::TYPE_DICTIONARY);
-      const DictionaryValue* dict = static_cast<const DictionaryValue*>(value);
-      for (DictionaryValue::key_iterator iter = dict->begin_keys();
-           iter != dict->end_keys(); ++iter) {
-        const std::string& key = *iter;
-        Value* v;
-        bool res = dict->GetWithoutPathExpansion(key, &v);
-        DCHECK(res);
-        if (res) {
-          int index = property_index_parser().Get(key);
-          if (!ParseProviderValue(index, v))
-            VLOG(1) << name() << ": Provider unhandled key: " << key
-                    << " Type: " << v->GetType();
-        }
-      }
-      return true;
-    }
-    default:
-      return Network::ParseValue(index, value);
-      break;
-  }
-  return false;
-}
-
-void VirtualNetwork::ParseInfo(const DictionaryValue* info) {
-  Network::ParseInfo(info);
-  VLOG(1) << "VPN: " << name()
-          << " Server: " << server_hostname()
-          << " Type: " << ProviderTypeToString(provider_type());
-  if (provider_type_ == PROVIDER_TYPE_L2TP_IPSEC_PSK) {
-    if (!client_cert_id_.empty())
-      provider_type_ = PROVIDER_TYPE_L2TP_IPSEC_USER_CERT;
-  }
-}
-
 void VirtualNetwork::EraseCredentials() {
   WipeString(&ca_cert_nss_);
   WipeString(&psk_passphrase_);
   WipeString(&client_cert_id_);
   WipeString(&user_passphrase_);
 }
 
 void VirtualNetwork::CalculateUniqueId() {
   std::string provider_type(ProviderTypeToString(provider_type_));
-  unique_id_ = provider_type + "|" + server_hostname_;
+  set_unique_id(provider_type + "|" + server_hostname_);
 }
 
 bool VirtualNetwork::RequiresUserProfile() const {
   return true;
 }
 
 void VirtualNetwork::CopyCredentialsFromRemembered(Network* remembered) {
   DCHECK_EQ(remembered->type(), TYPE_VPN);
   VirtualNetwork* remembered_vpn = static_cast<VirtualNetwork*>(remembered);
   VLOG(1) << "Copy VPN credentials: " << name()
@@ skipping 74 matching lines @@
 
 void VirtualNetwork::SetCertificateSlotAndPin(
     const std::string& slot, const std::string& pin) {
   SetOrClearStringProperty(kL2TPIPSecClientCertSlotProp, slot, NULL);
   SetOrClearStringProperty(kL2TPIPSecPINProperty, pin, NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WirelessNetwork
 
-bool WirelessNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_SIGNAL_STRENGTH:
-      return value->GetAsInteger(&strength_);
-    default:
-      return Network::ParseValue(index, value);
-      break;
-  }
-  return false;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // CellularDataPlan
 
 CellularDataPlan::CellularDataPlan()
     : plan_name("Unknown"),
       plan_type(CELLULAR_DATA_PLAN_UNLIMITED),
       plan_data_bytes(0),
       data_bytes_used(0) {
 }
 
@@ skipping 227 matching lines @@
                                           &localized_name))
     localized_name.clear();
   if (!dict.GetStringWithoutPathExpansion(kApnLanguageProperty, &language))
     language.clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CellularNetwork
 
 CellularNetwork::CellularNetwork(const std::string& service_path)
-    : WirelessNetwork(service_path, TYPE_CELLULAR),
+    : WirelessNetwork(service_path, TYPE_CELLULAR,
+                      new NativeCellularNetworkParser),
       activation_state_(ACTIVATION_STATE_UNKNOWN),
       network_technology_(NETWORK_TECHNOLOGY_UNKNOWN),
       roaming_state_(ROAMING_STATE_UNKNOWN),
       data_left_(DATA_UNKNOWN) {
 }
 
 CellularNetwork::~CellularNetwork() {
 }
 
-bool CellularNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_ACTIVATION_STATE: {
-      std::string activation_state_string;
-      if (value->GetAsString(&activation_state_string)) {
-        ActivationState prev_state = activation_state_;
-        activation_state_ = ParseActivationState(activation_state_string);
-        if (activation_state_ != prev_state)
-          RefreshDataPlansIfNeeded();
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_CELLULAR_APN: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        apn_.Set(*static_cast<const DictionaryValue*>(value));
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        last_good_apn_.Set(*static_cast<const DictionaryValue*>(value));
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_NETWORK_TECHNOLOGY: {
-      std::string network_technology_string;
-      if (value->GetAsString(&network_technology_string)) {
-        network_technology_ = ParseNetworkTechnology(network_technology_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_ROAMING_STATE: {
-      std::string roaming_state_string;
-      if (value->GetAsString(&roaming_state_string)) {
-        roaming_state_ = ParseRoamingState(roaming_state_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_OPERATOR_NAME:
-      return value->GetAsString(&operator_name_);
-    case PROPERTY_INDEX_OPERATOR_CODE:
-      return value->GetAsString(&operator_code_);
-    case PROPERTY_INDEX_SERVING_OPERATOR: {
-      if (value->IsType(Value::TYPE_DICTIONARY)) {
-        const DictionaryValue* dict =
-            static_cast<const DictionaryValue*>(value);
-        operator_code_.clear();
-        operator_country_.clear();
-        operator_name_.clear();
-        dict->GetStringWithoutPathExpansion(kOperatorNameKey,
-                                            &operator_name_);
-        dict->GetStringWithoutPathExpansion(kOperatorCodeKey,
-                                            &operator_code_);
-        dict->GetStringWithoutPathExpansion(kOperatorCountryKey,
-                                            &operator_country_);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PAYMENT_URL:
-      return value->GetAsString(&payment_url_);
-    case PROPERTY_INDEX_USAGE_URL:
-      return value->GetAsString(&usage_url_);
-    case PROPERTY_INDEX_STATE: {
-      // Save previous state before calling WirelessNetwork::ParseValue.
-      ConnectionState prev_state = state_;
-      if (WirelessNetwork::ParseValue(index, value)) {
-        if (state_ != prev_state)
-          RefreshDataPlansIfNeeded();
-        return true;
-      }
-      break;
-    }
-    default:
-      return WirelessNetwork::ParseValue(index, value);
-  }
-  return false;
-}
-
 bool CellularNetwork::StartActivation() const {
   if (!EnsureCrosLoaded())
     return false;
   return chromeos::ActivateCellularModem(service_path().c_str(), NULL);
 }
 
 void CellularNetwork::RefreshDataPlansIfNeeded() const {
   if (!EnsureCrosLoaded())
     return;
   if (connected() && activated())
@@ skipping 108 matching lines @@
       return l10n_util::GetStringUTF8(
           IDS_CHROMEOS_NETWORK_ROAMING_STATE_UNKNOWN);
       break;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // WifiNetwork
 
 WifiNetwork::WifiNetwork(const std::string& service_path)
-    : WirelessNetwork(service_path, TYPE_WIFI),
+    : WirelessNetwork(service_path, TYPE_WIFI, new NativeWifiNetworkParser),
       encryption_(SECURITY_NONE),
       passphrase_required_(false),
       eap_method_(EAP_METHOD_UNKNOWN),
       eap_phase_2_auth_(EAP_PHASE_2_AUTH_AUTO),
       eap_use_system_cas_(true) {
 }
 
 WifiNetwork::~WifiNetwork() {}
 
 void WifiNetwork::CalculateUniqueId() {
   ConnectionSecurity encryption = encryption_;
   // Flimflam treats wpa and rsn as psk internally, so convert those types
   // to psk for unique naming.
   if (encryption == SECURITY_WPA || encryption == SECURITY_RSN)
     encryption = SECURITY_PSK;
   std::string security = std::string(SecurityToString(encryption));
-  unique_id_ = security + "|" + name_;
+  set_unique_id(security + "|" + name());
 }
 
 bool WifiNetwork::SetSsid(const std::string& ssid) {
   // Detects encoding and convert to UTF-8.
   std::string ssid_utf8;
   if (!IsStringUTF8(ssid)) {
     std::string encoding;
     if (base::DetectEncoding(ssid, &encoding)) {
       if (!base::ConvertToUtf8AndNormalize(ssid, encoding, &ssid_utf8)) {
         ssid_utf8.clear();
@@ skipping 14 matching lines @@
   std::vector<uint8> ssid_raw;
   if (!base::HexStringToBytes(ssid_hex, &ssid_raw)) {
     LOG(ERROR) << "Illegal hex char is found in WiFi.HexSSID.";
     ssid_raw.clear();
     return false;
   }
 
   return SetSsid(std::string(ssid_raw.begin(), ssid_raw.end()));
 }
 
-bool WifiNetwork::ParseValue(int index, const Value* value) {
-  switch (index) {
-    case PROPERTY_INDEX_WIFI_HEX_SSID: {
-      std::string ssid_hex;
-      if (!value->GetAsString(&ssid_hex))
-        return false;
-
-      SetHexSsid(ssid_hex);
-      return true;
-    }
-    case PROPERTY_INDEX_WIFI_AUTH_MODE:
-    case PROPERTY_INDEX_WIFI_PHY_MODE:
-    case PROPERTY_INDEX_WIFI_HIDDEN_SSID:
-    case PROPERTY_INDEX_WIFI_FREQUENCY:
-      // These properties are currently not used in the UI.
-      return true;
-    case PROPERTY_INDEX_NAME: {
-      // Does not change network name when it was already set by WiFi.HexSSID.
-      if (!name().empty())
-        return true;
-      else
-        return WirelessNetwork::ParseValue(index, value);
-    }
-    case PROPERTY_INDEX_SECURITY: {
-      std::string security_string;
-      if (value->GetAsString(&security_string)) {
-        encryption_ = ParseSecurity(security_string);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PASSPHRASE: {
-      std::string passphrase;
-      if (value->GetAsString(&passphrase)) {
-        // Only store the passphrase if we are the owner.
-        // TODO(stevenjb): Remove this when chromium-os:12948 is resolved.
-        if (chromeos::UserManager::Get()->current_user_is_owner())
-          passphrase_ = passphrase;
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_PASSPHRASE_REQUIRED:
-      return value->GetAsBoolean(&passphrase_required_);
-    case PROPERTY_INDEX_IDENTITY:
-      return value->GetAsString(&identity_);
-    case PROPERTY_INDEX_EAP_IDENTITY:
-      return value->GetAsString(&eap_identity_);
-    case PROPERTY_INDEX_EAP_METHOD: {
-      std::string method;
-      if (value->GetAsString(&method)) {
-        eap_method_ = ParseEAPMethod(method);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_EAP_PHASE_2_AUTH: {
-      std::string auth;
-      if (value->GetAsString(&auth)) {
-        eap_phase_2_auth_ = ParseEAPPhase2Auth(auth);
-        return true;
-      }
-      break;
-    }
-    case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY:
-      return value->GetAsString(&eap_anonymous_identity_);
-    case PROPERTY_INDEX_EAP_CERT_ID:
-      return value->GetAsString(&eap_client_cert_pkcs11_id_);
-    case PROPERTY_INDEX_EAP_CA_CERT_NSS:
-      return value->GetAsString(&eap_server_ca_cert_nss_nickname_);
-    case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS:
-      return value->GetAsBoolean(&eap_use_system_cas_);
-    case PROPERTY_INDEX_EAP_PASSWORD:
-      return value->GetAsString(&eap_passphrase_);
-    case PROPERTY_INDEX_EAP_CLIENT_CERT:
-    case PROPERTY_INDEX_EAP_CLIENT_CERT_NSS:
-    case PROPERTY_INDEX_EAP_PRIVATE_KEY:
-    case PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD:
-    case PROPERTY_INDEX_EAP_KEY_ID:
-    case PROPERTY_INDEX_EAP_CA_CERT:
-    case PROPERTY_INDEX_EAP_CA_CERT_ID:
-    case PROPERTY_INDEX_EAP_PIN:
-    case PROPERTY_INDEX_EAP_KEY_MGMT:
-      // These properties are currently not used in the UI.
-      return true;
-    default:
-      return WirelessNetwork::ParseValue(index, value);
-  }
-  return false;
-}
-
 const std::string& WifiNetwork::GetPassphrase() const {
   if (!user_passphrase_.empty())
     return user_passphrase_;
   return passphrase_;
 }
 
 void WifiNetwork::SetPassphrase(const std::string& passphrase) {
   // Set the user_passphrase_ only; passphrase_ stores the flimflam value.
   // If the user sets an empty passphrase, restore it to the passphrase
   // remembered by flimflam.
@@ skipping 143 matching lines @@
     }
     case SECURITY_PSK:
       return "PSK";
   }
   return "Unknown";
 }
 
 bool WifiNetwork::IsPassphraseRequired() const {
   // TODO(stevenjb): Remove error_ tests when fixed in flimflam
   // (http://crosbug.com/10135).
-  if (error_ == ERROR_BAD_PASSPHRASE || error_ == ERROR_BAD_WEPKEY)
+  if (error() == ERROR_BAD_PASSPHRASE || error() == ERROR_BAD_WEPKEY)
     return true;
   // For 802.1x networks, configuration is required if connectable is false.
   if (encryption_ == SECURITY_8021X)
-    return !connectable_;
+    return !connectable();
   return passphrase_required_;
 }
 
 bool WifiNetwork::RequiresUserProfile() const {
   // 8021X requires certificates which are only stored for individual users.
   if (encryption_ == SECURITY_8021X &&
       (eap_method_ == EAP_METHOD_TLS ||
        !eap_client_cert_pkcs11_id().empty()))
     return true;
   return false;
@@ skipping 22 matching lines @@
 
   // Called from ConnectToWifiNetwork.
   // Calls ConnectToWifiNetworkUsingConnectData if network request succeeds.
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) = 0;
   // Called from ConnectToVirtualNetwork*.
   // Calls ConnectToVirtualNetworkUsingConnectData if network request succeeds.
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
-      VirtualNetwork::ProviderType provider_type) = 0;
+      ProviderType provider_type) = 0;
   // Called from NetworkConnectStart.
   // Calls NetworkConnectCompleted when the connection attept completes.
   virtual void CallConnectToNetwork(Network* network) = 0;
   // Called from DeleteRememberedNetwork.
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path, const std::string& service_path) = 0;
 
   // Called from Enable*NetworkDevice.
   // Asynchronously enables or disables the specified device type.
   virtual void CallEnableNetworkDeviceType(
@@ skipping 686 matching lines @@
   NetworkDeviceMap::iterator iter = device_map_.find(path);
   if (iter != device_map_.end())
     return iter->second;
   LOG(WARNING) << "Device path not found: " << path;
   return NULL;
 }
 
 const NetworkDevice* NetworkLibraryImplBase::FindCellularDevice() const {
   for (NetworkDeviceMap::const_iterator iter = device_map_.begin();
        iter != device_map_.end(); ++iter) {
-    if (iter->second->type() == TYPE_CELLULAR)
+    if (iter->second && iter->second->type() == TYPE_CELLULAR)
       return iter->second;
   }
   return NULL;
 }
 
 const NetworkDevice* NetworkLibraryImplBase::FindEthernetDevice() const {
   for (NetworkDeviceMap::const_iterator iter = device_map_.begin();
        iter != device_map_.end(); ++iter) {
     if (iter->second->type() == TYPE_ETHERNET)
       return iter->second;
@@ skipping 425 matching lines @@
     const std::string& username,
     const std::string& user_passphrase) {
   // Store the connection data to be used by the callback.
   connect_data_.service_name = service_name;
   connect_data_.psk_key = psk;
   connect_data_.server_hostname = server_hostname;
   connect_data_.psk_username = username;
   connect_data_.passphrase = user_passphrase;
   CallRequestVirtualNetworkAndConnect(
       service_name, server_hostname,
-      VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK);
+      PROVIDER_TYPE_L2TP_IPSEC_PSK);
 }
 
 // 1. Connect to a virtual network with a user cert.
 void NetworkLibraryImplBase::ConnectToVirtualNetworkCert(
     const std::string& service_name,
     const std::string& server_hostname,
     const std::string& server_ca_cert_nss_nickname,
     const std::string& client_cert_pkcs11_id,
     const std::string& username,
     const std::string& user_passphrase) {
   // Store the connection data to be used by the callback.
   connect_data_.service_name = service_name;
   connect_data_.server_hostname = server_hostname;
   connect_data_.server_ca_cert_nss_nickname = server_ca_cert_nss_nickname;
   connect_data_.client_cert_pkcs11_id = client_cert_pkcs11_id;
   connect_data_.psk_username = username;
   connect_data_.passphrase = user_passphrase;
   CallRequestVirtualNetworkAndConnect(
       service_name, server_hostname,
-      VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+      PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
 }
 
 // 2. Requests a WiFi Network by SSID and security.
 // Calls ConnectToWifiNetworkUsingConnectData if network request succeeds.
 // virtual void CallRequestWifiNetworkAndConnect(
 //     const std::string& ssid, ConnectionSecurity security) = 0;
 
 // 2. Requests a Virtual Network by service name, etc.
 // Calls ConnectToVirtualNetworkUsingConnectData if network request succeeds.
 // virtual void CallRequestVirtualNetworkAndConnect(
 //     const std::string& service_name,
 //     const std::string& server_hostname,
-//     VirtualNetwork::ProviderType provider_type) = 0;
+//     ProviderType provider_type) = 0;
 
 // 3. Sets network properties stored in ConnectData and calls
 // NetworkConnectStart.
 void NetworkLibraryImplBase::ConnectToWifiNetworkUsingConnectData(
     WifiNetwork* wifi) {
   ConnectData& data = connect_data_;
   if (wifi->name() != data.service_name) {
     LOG(WARNING) << "WiFi network name does not match ConnectData: "
                  << wifi->name() << " != " << data.service_name;
     return;
@@ skipping 188 matching lines @@
     }
   }
   DCHECK(!network->profile_path().empty())
       << "Service path not in any profile: " << network->service_path();
 }
 
 void NetworkLibraryImplBase::DeleteRememberedNetwork(
     const std::string& service_path) {
   NetworkMap::iterator found = remembered_network_map_.find(service_path);
   if (found == remembered_network_map_.end()) {
-    LOG(WARNING) << "Attempt to delete non-existant remembered network: "
+    LOG(WARNING) << "Attempt to delete non-existent remembered network: "
                  << service_path;
     return;
   }
 
   // Delete remembered network from lists.
   Network* remembered_network = found->second;
   remembered_network_map_.erase(found);
 
   if (remembered_network->type() == TYPE_WIFI) {
     WifiNetworkVector::iterator iter = std::find(
@@ skipping 54 matching lines @@
     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);
+      return new Network(service_path, type, NULL);
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 void NetworkLibraryImplBase::ClearNetworks() {
   network_map_.clear();
   network_unique_id_map_.clear();
   ethernet_ = NULL;
@@ skipping 17 matching lines @@
 }
 
 void NetworkLibraryImplBase::DeleteRememberedNetworks() {
   STLDeleteValues(&remembered_network_map_);
   ClearRememberedNetworks();
 }
 
 void NetworkLibraryImplBase::DeleteDevice(const std::string& device_path) {
   NetworkDeviceMap::iterator found = device_map_.find(device_path);
   if (found == device_map_.end()) {
-    LOG(WARNING) << "Attempt to delete non-existant device: "
+    LOG(WARNING) << "Attempt to delete non-existent device: "
                  << device_path;
     return;
   }
   VLOG(2) << " Deleting device: " << device_path;
   NetworkDevice* device = found->second;
   device_map_.erase(found);
   delete device;
   DeleteDeviceFromDeviceObserversMap(device_path);
 }
 
@@ skipping 204 matching lines @@
       const std::string& device_path) OVERRIDE;
   virtual void MonitorNetworkDeviceStop(
       const std::string& device_path) OVERRIDE;
 
   virtual void CallConnectToNetwork(Network* network) OVERRIDE;
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) OVERRIDE;
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
-      VirtualNetwork::ProviderType provider_type) OVERRIDE;
+      ProviderType provider_type) OVERRIDE;
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path,
       const std::string& service_path) OVERRIDE;
 
   //////////////////////////////////////////////////////////////////////////////
   // NetworkLibrary implementation.
 
   virtual void ChangePin(const std::string& old_pin,
                          const std::string& new_pin) OVERRIDE;
   virtual void ChangeRequirePin(bool require_pin,
@@ skipping 16 matching lines @@
       const std::string& device_path,
       std::string* hardware_address,
       HardwareAddressFormat format) OVERRIDE;
   virtual void SetIPConfig(const NetworkIPConfig& ipconfig) OVERRIDE;
 
   //////////////////////////////////////////////////////////////////////////////
   // Calbacks.
   static void NetworkStatusChangedHandler(
       void* object, const char* path, const char* key, const Value* value);
   void UpdateNetworkStatus(
-      const char* path, const char* key, const Value* value);
+      const std::string& path, const std::string& key, const Value& value);
 
   static void NetworkDevicePropertyChangedHandler(
       void* object, const char* path, const char* key, const Value* value);
   void UpdateNetworkDeviceStatus(
-      const char* path, const char* key, const Value* value);
+      const std::string& path, const std::string& key, const Value& value);
 
   static void PinOperationCallback(void* object,
                                    const char* path,
                                    NetworkMethodErrorType error,
                                    const char* error_message);
 
   static void CellularRegisterCallback(void* object,
                                        const char* path,
                                        NetworkMethodErrorType error,
                                        const char* error_message);
@@ skipping 22 matching lines @@
   static void RememberedNetworkServiceUpdate(
       void* object, const char* service_path, const Value* info);
   static void ProfileUpdate(
       void* object, const char* profile_path, const Value* info);
   static void NetworkDeviceUpdate(
       void* object, const char* device_path, const Value* info);
 
  private:
   // This processes all Manager update messages.
   void NetworkManagerStatusChanged(const char* key, const Value* value);
-  void ParseNetworkManager(const DictionaryValue* dict);
+  void ParseNetworkManager(const DictionaryValue& dict);
   void UpdateTechnologies(const ListValue* technologies, int* bitfieldp);
   void UpdateAvailableTechnologies(const ListValue* technologies);
   void UpdateEnabledTechnologies(const ListValue* technologies);
   void UpdateConnectedTechnologies(const ListValue* technologies);
 
   // Update network lists.
   void UpdateNetworkServiceList(const ListValue* services);
   void UpdateWatchedNetworkServiceList(const ListValue* services);
   Network* ParseNetwork(const std::string& service_path,
-                        const DictionaryValue* info);
+                        const DictionaryValue& info);
 
   void UpdateRememberedNetworks(const ListValue* profiles);
   void RequestRememberedNetworksUpdate();
   void UpdateRememberedServiceList(const char* profile_path,
                                    const ListValue* profile_entries);
   Network* ParseRememberedNetwork(const std::string& service_path,
-                                  const DictionaryValue* info);
+                                  const DictionaryValue& info);
 
   // NetworkDevice list management functions.
   void UpdateNetworkDeviceList(const ListValue* devices);
   void ParseNetworkDevice(const std::string& device_path,
-                          const DictionaryValue* info);
+                          const DictionaryValue& info);
 
   // Empty device observer to ensure that device property updates are received.
   class NetworkLibraryDeviceObserver : public NetworkDeviceObserver {
    public:
     virtual ~NetworkLibraryDeviceObserver() {}
     virtual void OnNetworkDeviceChanged(
         NetworkLibrary* cros, const NetworkDevice* device) OVERRIDE {}
   };
 
   typedef std::map<std::string, chromeos::PropertyChangeMonitor>
@@ skipping 99 matching lines @@
     montitored_devices_.erase(iter);
   }
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkStatusChangedHandler(
     void* object, const char* path, const char* key, const Value* value) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkStatus(path, key, value);
+  if (key == NULL || value == NULL)

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

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

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

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

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

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

You mean implicit, right?

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

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

Right, yes. Cool.

 }
 
 void NetworkLibraryImplCros::UpdateNetworkStatus(
-    const char* path, const char* key, const Value* value) {
+    const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (key == NULL || value == NULL)
-    return;
   Network* network = FindNetworkByPath(path);
   if (network) {
     VLOG(2) << "UpdateNetworkStatus: " << network->name() << "." << key;
     bool prev_connected = network->connected();
-    // Note: ParseValue is virtual.
-    int index = property_index_parser().Get(std::string(key));
-    if (!network->ParseValue(index, value)) {
-      LOG(WARNING) << "UpdateNetworkStatus: Error parsing: "
+    if (!network->UpdateStatus(key, value, NULL)) {
+      LOG(WARNING) << "UpdateNetworkStatus: Error updating: "
                    << path << "." << key;
     }
     // If we just connected, this may have been added to remembered list.
     if (!prev_connected && network->connected())
       RequestRememberedNetworksUpdate();
     NotifyNetworkChanged(network);
     // Anything observing the manager needs to know about any service change.
     NotifyNetworkManagerChanged(false);  // Not forced.
   }
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkDevicePropertyChangedHandler(
     void* object, const char* path, const char* key, const Value* value) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkDeviceStatus(path, key, value);
+  if (key == NULL || value == NULL)
+    return;
+  networklib->UpdateNetworkDeviceStatus(path, key, *value);
 }
 
 void NetworkLibraryImplCros::UpdateNetworkDeviceStatus(
-    const char* path, const char* key, const Value* value) {
+    const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (key == NULL || value == NULL)
-    return;
   NetworkDevice* device = FindNetworkDeviceByPath(path);
   if (device) {
     VLOG(2) << "UpdateNetworkDeviceStatus: " << device->name() << "." << key;
-    PropertyIndex index = property_index_parser().Get(std::string(key));
-    if (!device->ParseValue(index, value)) {
-      VLOG(1) << "UpdateNetworkDeviceStatus: Failed to parse: "
+    PropertyIndex index = PROPERTY_INDEX_UNKNOWN;
+    if (!device->UpdateStatus(key, value, &index)) {

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

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

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

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

+      VLOG(1) << "UpdateNetworkDeviceStatus: Failed to update: "
               << path << "." << key;
     } else if (index == PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING) {
       bool settings_value =
           UserCrosSettingsProvider::cached_data_roaming_enabled();
       if (device->data_roaming_allowed() != settings_value) {
         // Switch back to signed settings value.
         SetCellularDataRoamingAllowed(settings_value);
         return;
       }
     }
     // Notify only observers on device property change.
     NotifyNetworkDeviceChanged(device, index);
     // If a device's power state changes, new properties may become defined.
     if (index == PROPERTY_INDEX_POWERED)
-      chromeos::RequestNetworkDeviceInfo(path, &NetworkDeviceUpdate, this);
+      chromeos::RequestNetworkDeviceInfo(path.c_str(),
+                                         &NetworkDeviceUpdate,
+                                         this);
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase connect implementation.
 
 // static callback
 void NetworkLibraryImplCros::NetworkConnectCallback(
     void* object,
     const char* service_path,
@@ skipping 32 matching lines @@
 // static callback
 void NetworkLibraryImplCros::WifiServiceUpdateAndConnect(
     void* object, const char* service_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path && info) {
     DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
     const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
     Network* network =
-        networklib->ParseNetwork(std::string(service_path), dict);
+        networklib->ParseNetwork(std::string(service_path), *dict);
     DCHECK_EQ(network->type(), TYPE_WIFI);
     networklib->ConnectToWifiNetworkUsingConnectData(
         static_cast<WifiNetwork*>(network));
   }
 }
 
 void NetworkLibraryImplCros::CallRequestWifiNetworkAndConnect(
     const std::string& ssid, ConnectionSecurity security) {
   // Asynchronously request service properties and call
   // WifiServiceUpdateAndConnect.
   chromeos::RequestHiddenWifiNetwork(ssid.c_str(),
                                      SecurityToString(security),
                                      WifiServiceUpdateAndConnect,
                                      this);
 }
 
 // static callback
 void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
     void* object, const char* service_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path && info) {
     VLOG(1) << "Connecting to new VPN Service: " << service_path;
     DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
     const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
     Network* network =
-        networklib->ParseNetwork(std::string(service_path), dict);
+        networklib->ParseNetwork(std::string(service_path), *dict);
     DCHECK_EQ(network->type(), TYPE_VPN);
     networklib->ConnectToVirtualNetworkUsingConnectData(
         static_cast<VirtualNetwork*>(network));
   } else {
     LOG(WARNING) << "Unable to create VPN Service: " << service_path;
   }
 }
 
 void NetworkLibraryImplCros::CallRequestVirtualNetworkAndConnect(
     const std::string& service_name,
     const std::string& server_hostname,
-    VirtualNetwork::ProviderType provider_type) {
+    ProviderType provider_type) {
   chromeos::RequestVirtualNetwork(service_name.c_str(),
                                   server_hostname.c_str(),
                                   ProviderTypeToString(provider_type),
                                   VPNServiceUpdateAndConnect,
                                   this);
 }
 
 void NetworkLibraryImplCros::CallDeleteRememberedNetwork(
     const std::string& profile_path,
     const std::string& service_path) {
@@ skipping 335 matching lines @@
 }
 
 // This processes all Manager update messages.
 void NetworkLibraryImplCros::NetworkManagerStatusChanged(
     const char* key, const Value* value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::TimeTicks start = base::TimeTicks::Now();
   if (!key)
     return;
   VLOG(1) << "NetworkManagerStatusChanged: KEY=" << key;
-  int index = property_index_parser().Get(std::string(key));
+  int index = NativeNetworkParser::property_mapper()->Get(key);
   switch (index) {
     case PROPERTY_INDEX_STATE:
       // Currently we ignore the network manager state.
       break;
     case PROPERTY_INDEX_AVAILABLE_TECHNOLOGIES: {
       DCHECK_EQ(value->GetType(), Value::TYPE_LIST);
       const ListValue* vlist = static_cast<const ListValue*>(value);
       UpdateAvailableTechnologies(vlist);
       break;
     }
@@ skipping 45 matching lines @@
     }
     case PROPERTY_INDEX_DEVICE:
     case PROPERTY_INDEX_DEVICES: {
       DCHECK_EQ(value->GetType(), Value::TYPE_LIST);
       const ListValue* vlist = static_cast<const ListValue*>(value);
       UpdateNetworkDeviceList(vlist);
       break;
     }
     case PROPERTY_INDEX_PORTAL_URL:
     case PROPERTY_INDEX_CHECK_PORTAL_LIST:
-      // Currently we ignore PortalURL and CheckPortalList.
+    case PROPERTY_INDEX_ARP_GATEWAY:

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

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

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

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

+      // Currently we ignore PortalURL, CheckPortalList and ArpGateway.
       break;
     default:
       LOG(WARNING) << "Manager: Unhandled key: " << key;
       break;
   }
   base::TimeDelta delta = base::TimeTicks::Now() - start;
   VLOG(2) << "NetworkManagerStatusChanged: time: "
           << delta.InMilliseconds() << " ms.";
   HISTOGRAM_TIMES("CROS_NETWORK_UPDATE", delta);
 }
 
 // static
 void NetworkLibraryImplCros::NetworkManagerUpdate(
     void* object, const char* manager_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (!info) {
     LOG(ERROR) << "Error retrieving manager properties: " << manager_path;
     return;
   }
   VLOG(1) << "Received NetworkManagerUpdate.";
   DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
   const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-  networklib->ParseNetworkManager(dict);
+  networklib->ParseNetworkManager(*dict);
 }
 
-void NetworkLibraryImplCros::ParseNetworkManager(const DictionaryValue* dict) {
-  for (DictionaryValue::key_iterator iter = dict->begin_keys();
-       iter != dict->end_keys(); ++iter) {
+void NetworkLibraryImplCros::ParseNetworkManager(const DictionaryValue& dict) {
+  for (DictionaryValue::key_iterator iter = dict.begin_keys();
+       iter != dict.end_keys(); ++iter) {
     const std::string& key = *iter;
     Value* value;
-    bool res = dict->GetWithoutPathExpansion(key, &value);
+    bool res = dict.GetWithoutPathExpansion(key, &value);
     CHECK(res);
     NetworkManagerStatusChanged(key.c_str(), value);
   }
   // If there is no Profiles entry, request remembered networks here.
-  if (!dict->HasKey(kProfilesProperty))
+  if (!dict.HasKey(kProfilesProperty))
     RequestRememberedNetworksUpdate();
 }
 
 // static
 void NetworkLibraryImplCros::DataPlanUpdateHandler(
     void* object,
     const char* modem_service_path,
     const CellularDataPlanList* dataplan) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
@@ skipping 10 matching lines @@
     const ListValue* technologies, int* bitfieldp) {
   DCHECK(bitfieldp);
   if (!technologies)
     return;
   int bitfield = 0;
   for (ListValue::const_iterator iter = technologies->begin();
        iter != technologies->end(); ++iter) {
     std::string technology;
     (*iter)->GetAsString(&technology);
     if (!technology.empty()) {
-      ConnectionType type = ParseType(technology);
+      ConnectionType type =
+          NativeNetworkParser::ParseConnectionType(technology);

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

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

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

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

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

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

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

       bitfield |= 1 << type;
     }
   }
   *bitfieldp = bitfield;
   NotifyNetworkManagerChanged(false);  // Not forced.
 }
 
 void NetworkLibraryImplCros::UpdateAvailableTechnologies(
     const ListValue* technologies) {
   UpdateTechnologies(technologies, &available_devices_);
@@ skipping 65 matching lines @@
        iter != old_network_map.end(); ++iter) {
     Network* network = iter->second;
     if (network->failed() && network->notify_failure()) {
       // We have not notified observers of a connection failure yet.
       AddNetwork(network);
     } else if (network->connecting()) {
       // Network was in connecting state; set state to failed.
       network->SetState(STATE_FAILURE);
       AddNetwork(network);
     } else {
-      VLOG(2) << "Deleting non-existant Network: " << network->name()
+      VLOG(2) << "Deleting non-existent Network: " << network->name()
               << " State = " << network->GetStateString();
       DeleteNetwork(network);
     }
   }
   // If the last network has disappeared, nothing else will
   // have notified observers, so do it now.
   if (services->empty())
     NotifyNetworkManagerChanged(true);  // Forced update
 }
 
@@ skipping 19 matching lines @@
 void NetworkLibraryImplCros::NetworkServiceUpdate(
     void* object, const char* service_path, const Value* info) {
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path) {
     if (!info)
       return;  // Network no longer in visible list, ignore.
     DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
     const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-    networklib->ParseNetwork(std::string(service_path), dict);
+    networklib->ParseNetwork(std::string(service_path), *dict);
   }
 }
 
 // Called from NetworkServiceUpdate and WifiServiceUpdateAndConnect.
 Network* NetworkLibraryImplCros::ParseNetwork(
-    const std::string& service_path, const DictionaryValue* info) {
+    const std::string& service_path, const DictionaryValue& info) {
   Network* network = FindNetworkByPath(service_path);
   if (!network) {
-    ConnectionType type = ParseTypeFromDictionary(info);
-    network = CreateNewNetwork(type, service_path);
+    NativeNetworkParser parser;
+    network = parser.CreateNetworkFromInfo(service_path, info);
     AddNetwork(network);
+  } else {
+    // Erase entry from network_unique_id_map_ in case unique id changes.
+    if (!network->unique_id().empty())
+      network_unique_id_map_.erase(network->unique_id());
+    network->network_parser()->UpdateNetworkFromInfo(info, network);
   }
 
-  // Erase entry from network_unique_id_map_ in case unique id changes.
-  if (!network->unique_id().empty())
-    network_unique_id_map_.erase(network->unique_id());
-
-  network->ParseInfo(info);  // virtual.
-
   if (!network->unique_id().empty())
     network_unique_id_map_[network->unique_id()] = network;
 
   SetProfileTypeFromPath(network);
 
   UpdateActiveNetwork(network);
 
   // Copy remembered credentials if required.
   Network* remembered = FindRememberedFromNetwork(network);
   if (remembered)
@@ skipping 138 matching lines @@
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path) {
     if (!info) {
       // Remembered network no longer exists.
       networklib->DeleteRememberedNetwork(std::string(service_path));
     } else {
       DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-      networklib->ParseRememberedNetwork(std::string(service_path), dict);
+      networklib->ParseRememberedNetwork(std::string(service_path), *dict);
     }
   }
 }
 
 // Returns NULL if |service_path| refers to a network that is not a
 // remembered type. Called from RememberedNetworkServiceUpdate.
 Network* NetworkLibraryImplCros::ParseRememberedNetwork(
-    const std::string& service_path, const DictionaryValue* info) {
+    const std::string& service_path, const DictionaryValue& info) {
   Network* remembered;
   NetworkMap::iterator found = remembered_network_map_.find(service_path);
   if (found != remembered_network_map_.end()) {
     remembered = found->second;
+    remembered->network_parser()->UpdateNetworkFromInfo(info, remembered);
   } else {
-    ConnectionType type = ParseTypeFromDictionary(info);
-    if (type == TYPE_WIFI || type == TYPE_VPN) {
-      remembered = CreateNewNetwork(type, service_path);
+    NativeNetworkParser parser;
+    remembered = parser.CreateNetworkFromInfo(service_path, info);
+    if (remembered->type() == TYPE_WIFI || remembered->type() == TYPE_VPN) {
       AddRememberedNetwork(remembered);
     } else {
-      VLOG(1) << "Ignoring remembered network: " << service_path
-              << " Type: " << ConnectionTypeToString(type);
+      LOG(WARNING) << "Ignoring remembered network: " << service_path
+              << " Type: " << ConnectionTypeToString(remembered->type());

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

nit: align <<

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

Done.

+      delete remembered;
       return NULL;
     }
   }
-  remembered->ParseInfo(info);  // virtual.
 
   SetProfileTypeFromPath(remembered);
 
   VLOG(1) << "ParseRememberedNetwork: " << remembered->name()
           << " path: " << remembered->service_path()
           << " profile: " << remembered->profile_path_;
   NotifyNetworkManagerChanged(false);  // Not forced.
 
   if (remembered->type() == TYPE_VPN) {
     // VPNs are only stored in profiles. If we don't have a network for it,
@@ skipping 25 matching lines @@
   device_map_.clear();
   VLOG(2) << "Updating Device List.";
   for (ListValue::const_iterator iter = devices->begin();
        iter != devices->end(); ++iter) {
     std::string device_path;
     (*iter)->GetAsString(&device_path);
     if (!device_path.empty()) {
       NetworkDeviceMap::iterator found = old_device_map.find(device_path);
       if (found != old_device_map.end()) {
         VLOG(2) << " Adding existing device: " << device_path;
+        CHECK(found->second) << "Attempted to add NULL device pointer";
         device_map_[device_path] = found->second;
         old_device_map.erase(found);
       }
       chromeos::RequestNetworkDeviceInfo(device_path.c_str(),
                                          &NetworkDeviceUpdate,
                                          this);
     }
   }
   // Delete any old devices that no longer exist.
   for (NetworkDeviceMap::iterator iter = old_device_map.begin();
@@ skipping 10 matching lines @@
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (device_path) {
     if (!info) {
       // device no longer exists.
       networklib->DeleteDevice(std::string(device_path));
     } else {
       DCHECK_EQ(info->GetType(), Value::TYPE_DICTIONARY);
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(info);
-      networklib->ParseNetworkDevice(std::string(device_path), dict);
+      networklib->ParseNetworkDevice(std::string(device_path), *dict);
     }
   }
 }
 
-void NetworkLibraryImplCros::ParseNetworkDevice(
-    const std::string& device_path, const DictionaryValue* info) {
+void NetworkLibraryImplCros::ParseNetworkDevice(const std::string& device_path,
+                                                const DictionaryValue& info) {
   NetworkDeviceMap::iterator found = device_map_.find(device_path);
   NetworkDevice* device;
   if (found != device_map_.end()) {
     device = found->second;
+    device->device_parser()->UpdateDeviceFromInfo(info, device);
   } else {
-    device = new NetworkDevice(device_path);
+    NativeNetworkDeviceParser parser;
+    device = parser.CreateDeviceFromInfo(device_path, info);
     VLOG(2) << " Adding device: " << device_path;
-    device_map_[device_path] = device;
+    if (device) {
+      device_map_[device_path] = device;
+    } else {
+      std::string json;
+      base::JSONWriter::Write(&info, true, &json);
+      LOG(WARNING) << " NULL Device Dictionary: " << json;

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

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

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

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

+    }
+    CHECK(device) << "Attempted to add NULL device for path: " << device_path;
   }
-  device->ParseInfo(info);
   VLOG(1) << "ParseNetworkDevice:" << device->name();
   NotifyNetworkManagerChanged(false);  // Not forced.
   AddNetworkDeviceObserver(device_path, network_device_observer_.get());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 class NetworkLibraryImplStub : public NetworkLibraryImplBase {
  public:
   NetworkLibraryImplStub();
@@ skipping 10 matching lines @@
       const std::string& device_path) OVERRIDE {}
   virtual void MonitorNetworkDeviceStop(
       const std::string& device_path) OVERRIDE {}
 
   virtual void CallConnectToNetwork(Network* network) OVERRIDE;
   virtual void CallRequestWifiNetworkAndConnect(
       const std::string& ssid, ConnectionSecurity security) OVERRIDE;
   virtual void CallRequestVirtualNetworkAndConnect(
       const std::string& service_name,
       const std::string& server_hostname,
-      VirtualNetwork::ProviderType provider_type) OVERRIDE;
+      ProviderType provider_type) OVERRIDE;
 
   virtual void CallDeleteRememberedNetwork(
       const std::string& profile_path,
       const std::string& service_path) OVERRIDE {}
 
   // NetworkLibrary implementation.
 
   virtual void ChangePin(const std::string& old_pin,
                          const std::string& new_pin) OVERRIDE;
   virtual void ChangeRequirePin(bool require_pin,
@@ skipping 52 matching lines @@
   is_locked_ = false;
 
   // Devices
   int devices =
       (1 << TYPE_ETHERNET) | (1 << TYPE_WIFI) | (1 << TYPE_CELLULAR);
   available_devices_ = devices;
   enabled_devices_ = devices;
   connected_devices_ = devices;
 
   NetworkDevice* cellular = new NetworkDevice("cellular");
-  scoped_ptr<Value> cellular_type(Value::CreateStringValue(kTypeCellular));
-  cellular->ParseValue(PROPERTY_INDEX_TYPE, cellular_type.get());
-  cellular->IMSI_ = "123456789012345";
+  cellular->type_ = TYPE_CELLULAR;
+  cellular->imsi_ = "123456789012345";
   device_map_["cellular"] = cellular;
 
   // Networks
   DeleteNetworks();
 
   ethernet_ = new EthernetNetwork("eth1");
   ethernet_->set_connected(true);
   AddNetwork(ethernet_);
 
   WifiNetwork* wifi1 = new WifiNetwork("fw1");
   wifi1->set_name("Fake WiFi Connected");
   wifi1->set_strength(90);
   wifi1->set_connected(false);
   wifi1->set_connecting(true);
-  wifi1->set_active(true);
+  wifi1->set_is_active(true);
   wifi1->set_encryption(SECURITY_NONE);
   wifi1->set_profile_type(PROFILE_SHARED);
   AddNetwork(wifi1);
 
   WifiNetwork* wifi2 = new WifiNetwork("fw2");
   wifi2->set_name("Fake WiFi");
   wifi2->set_strength(70);
   wifi2->set_connected(false);
   wifi2->set_encryption(SECURITY_NONE);
   wifi2->set_profile_type(PROFILE_SHARED);
@@ skipping 33 matching lines @@
   wifi6->set_connected(false);
   AddNetwork(wifi6);
 
   active_wifi_ = wifi1;
 
   CellularNetwork* cellular1 = new CellularNetwork("fc1");
   cellular1->set_name("Fake Cellular");
   cellular1->set_strength(70);
   cellular1->set_connected(false);
   cellular1->set_connecting(true);
-  cellular1->set_active(true);
+  cellular1->set_is_active(true);
   cellular1->set_activation_state(ACTIVATION_STATE_ACTIVATED);
   cellular1->set_payment_url(std::string("http://www.google.com"));
   cellular1->set_usage_url(std::string("http://www.google.com"));
   cellular1->set_network_technology(NETWORK_TECHNOLOGY_EVDO);
   cellular1->set_roaming_state(ROAMING_STATE_ROAMING);
 
   CellularDataPlan* base_plan = new CellularDataPlan();
   base_plan->plan_name = "Base plan";
   base_plan->plan_type = CELLULAR_DATA_PLAN_METERED_BASE;
   base_plan->plan_data_bytes = 100ll * 1024 * 1024;
@@ skipping 17 matching lines @@
   cellular2->set_strength(70);
   cellular2->set_connected(true);
   cellular2->set_activation_state(ACTIVATION_STATE_ACTIVATED);
   cellular2->set_network_technology(NETWORK_TECHNOLOGY_UMTS);
   AddNetwork(cellular2);
 
   // VPNs
   VirtualNetwork* vpn1 = new VirtualNetwork("fv1");
   vpn1->set_name("Fake VPN Provider 1");
   vpn1->set_server_hostname("vpn1server.fake.com");
-  vpn1->set_provider_type(VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_PSK);
+  vpn1->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_PSK);
   vpn1->set_username("VPN User 1");
   vpn1->set_connected(false);
   AddNetwork(vpn1);
 
   VirtualNetwork* vpn2 = new VirtualNetwork("fv2");
   vpn2->set_name("Fake VPN Provider 2");
   vpn2->set_server_hostname("vpn2server.fake.com");
-  vpn2->set_provider_type(VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+  vpn2->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
   vpn2->set_username("VPN User 2");
   vpn2->set_connected(true);
   AddNetwork(vpn2);
 
   VirtualNetwork* vpn3 = new VirtualNetwork("fv3");
   vpn3->set_name("Fake VPN Provider 3");
   vpn3->set_server_hostname("vpn3server.fake.com");
-  vpn3->set_provider_type(VirtualNetwork::PROVIDER_TYPE_OPEN_VPN);
+  vpn3->set_provider_type(PROVIDER_TYPE_OPEN_VPN);
   vpn3->set_connected(false);
   AddNetwork(vpn3);
 
   active_virtual_ = vpn2;
 
   // Remembered Networks
   DeleteRememberedNetworks();
   NetworkProfile profile("default", PROFILE_SHARED);
   profile.services.insert("fw2");
   profile.services.insert("fv2");
   profile_list_.push_back(profile);
   WifiNetwork* remembered_wifi2 = new WifiNetwork("fw2");
   remembered_wifi2->set_name("Fake WiFi 2");
   remembered_wifi2->set_encryption(SECURITY_WEP);
   AddRememberedNetwork(remembered_wifi2);
   VirtualNetwork* remembered_vpn2 = new VirtualNetwork("fv2");
   remembered_vpn2->set_name("Fake VPN Provider 2");
   remembered_vpn2->set_server_hostname("vpn2server.fake.com");
   remembered_vpn2->set_provider_type(
-      VirtualNetwork::PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
+      PROVIDER_TYPE_L2TP_IPSEC_USER_CERT);
   remembered_vpn2->set_connected(true);
   AddRememberedNetwork(remembered_vpn2);
 
   wifi_scanning_ = false;
   offline_mode_ = false;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase implementation.
 
 void NetworkLibraryImplStub::CallConnectToNetwork(Network* network) {
   NetworkConnectCompleted(network, CONNECT_SUCCESS);
 }
 
 void NetworkLibraryImplStub::CallRequestWifiNetworkAndConnect(
     const std::string& ssid, ConnectionSecurity security) {
   WifiNetwork* wifi = new WifiNetwork(ssid);
   wifi->set_encryption(security);
   AddNetwork(wifi);
   ConnectToWifiNetworkUsingConnectData(wifi);
 }
 
 void NetworkLibraryImplStub::CallRequestVirtualNetworkAndConnect(
     const std::string& service_name,
     const std::string& server_hostname,
-    VirtualNetwork::ProviderType provider_type) {
+    ProviderType provider_type) {
   VirtualNetwork* vpn = new VirtualNetwork(service_name);
   vpn->set_server_hostname(server_hostname);
   vpn->set_provider_type(provider_type);
   AddNetwork(vpn);
   ConnectToVirtualNetworkUsingConnectData(vpn);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary implementation.
 
@@ skipping 75 matching lines @@
   return network_library;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);