Resubmit CL. See 8429004.

chrome/browser/chromeos/cros/native_network_parser.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/native_network_parser.h"
 
 #include <string>
 
 #include "base/stringprintf.h"
 #include "base/string_util.h"
@@ skipping 94 matching lines @@
   { flimflam::kPassphraseRequiredProperty, PROPERTY_INDEX_PASSPHRASE_REQUIRED },
   { flimflam::kPortalURLProperty, PROPERTY_INDEX_PORTAL_URL },
   { flimflam::kPoweredProperty, PROPERTY_INDEX_POWERED },
   { flimflam::kPriorityProperty, PROPERTY_INDEX_PRIORITY },
   { flimflam::kProfileProperty, PROPERTY_INDEX_PROFILE },
   { flimflam::kProfilesProperty, PROPERTY_INDEX_PROFILES },
   { flimflam::kProviderProperty, PROPERTY_INDEX_PROVIDER },
   { flimflam::kProxyConfigProperty, PROPERTY_INDEX_PROXY_CONFIG },
   { flimflam::kRoamingStateProperty, PROPERTY_INDEX_ROAMING_STATE },
   { flimflam::kSIMLockStatusProperty, PROPERTY_INDEX_SIM_LOCK },
+  { flimflam::kSSIDProperty, PROPERTY_INDEX_SSID },
   { flimflam::kSaveCredentialsProperty, PROPERTY_INDEX_SAVE_CREDENTIALS },
   { flimflam::kScanningProperty, PROPERTY_INDEX_SCANNING },
   { flimflam::kSecurityProperty, PROPERTY_INDEX_SECURITY },
   { flimflam::kSelectedNetworkProperty, PROPERTY_INDEX_SELECTED_NETWORK },
   { flimflam::kServiceWatchListProperty, PROPERTY_INDEX_SERVICE_WATCH_LIST },
   { flimflam::kServicesProperty, PROPERTY_INDEX_SERVICES },
   { flimflam::kServingOperatorProperty, PROPERTY_INDEX_SERVING_OPERATOR },
   { flimflam::kSignalStrengthProperty, PROPERTY_INDEX_SIGNAL_STRENGTH },
   { flimflam::kStateProperty, PROPERTY_INDEX_STATE },
   { flimflam::kSupportNetworkScanProperty,
     PROPERTY_INDEX_SUPPORT_NETWORK_SCAN },
   { flimflam::kTechnologyFamilyProperty, PROPERTY_INDEX_TECHNOLOGY_FAMILY },
   { flimflam::kTypeProperty, PROPERTY_INDEX_TYPE },
   { flimflam::kUIDataProperty, PROPERTY_INDEX_UI_DATA },
   { flimflam::kUsageURLProperty, PROPERTY_INDEX_USAGE_URL },
   { flimflam::kOpenVPNUserProperty, PROPERTY_INDEX_OPEN_VPN_USER },
   { flimflam::kOpenVPNPasswordProperty, PROPERTY_INDEX_OPEN_VPN_PASSWORD },
   { flimflam::kOpenVPNClientCertIdProperty,
     PROPERTY_INDEX_OPEN_VPN_CLIENT_CERT_ID },
   { flimflam::kPaymentPortalProperty, PROPERTY_INDEX_OLP },
   { flimflam::kWifiAuthMode, PROPERTY_INDEX_WIFI_AUTH_MODE },
   { flimflam::kWifiFrequency, PROPERTY_INDEX_WIFI_FREQUENCY },
   { flimflam::kWifiHexSsid, PROPERTY_INDEX_WIFI_HEX_SSID },
   { flimflam::kWifiHiddenSsid, PROPERTY_INDEX_WIFI_HIDDEN_SSID },
   { flimflam::kWifiPhyMode, PROPERTY_INDEX_WIFI_PHY_MODE },
 };
 
+EnumMapper<ConnectionType>::Pair network_type_table[] = {
+  { flimflam::kTypeEthernet, TYPE_ETHERNET },
+  { flimflam::kTypeWifi, TYPE_WIFI },
+  { flimflam::kTypeWimax, TYPE_WIMAX },
+  { flimflam::kTypeBluetooth, TYPE_BLUETOOTH },
+  { flimflam::kTypeCellular, TYPE_CELLULAR },
+  { flimflam::kTypeVPN, TYPE_VPN },
+};
+
+EnumMapper<ConnectionSecurity>::Pair network_security_table[] = {
+  { flimflam::kSecurityNone, SECURITY_NONE },
+  { flimflam::kSecurityWep, SECURITY_WEP },
+  { flimflam::kSecurityWpa, SECURITY_WPA },
+  { flimflam::kSecurityRsn, SECURITY_RSN },
+  { flimflam::kSecurityPsk, SECURITY_PSK },
+  { flimflam::kSecurity8021x, SECURITY_8021X },
+};
+
+EnumMapper<EAPMethod>::Pair network_eap_method_table[] = {
+  { flimflam::kEapMethodPEAP, EAP_METHOD_PEAP },
+  { flimflam::kEapMethodTLS, EAP_METHOD_TLS },
+  { flimflam::kEapMethodTTLS, EAP_METHOD_TTLS },
+  { flimflam::kEapMethodLEAP, EAP_METHOD_LEAP },
+};
+
+EnumMapper<EAPPhase2Auth>::Pair network_eap_auth_table[] = {
+  { flimflam::kEapPhase2AuthPEAPMD5, EAP_PHASE_2_AUTH_MD5 },
+  { flimflam::kEapPhase2AuthPEAPMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
+  { flimflam::kEapPhase2AuthTTLSMD5, EAP_PHASE_2_AUTH_MD5 },
+  { flimflam::kEapPhase2AuthTTLSMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
+  { flimflam::kEapPhase2AuthTTLSMSCHAP, EAP_PHASE_2_AUTH_MSCHAP },
+  { flimflam::kEapPhase2AuthTTLSPAP, EAP_PHASE_2_AUTH_PAP },
+  { flimflam::kEapPhase2AuthTTLSCHAP, EAP_PHASE_2_AUTH_CHAP },
+};
+
 // Serve the singleton mapper instance.
 const EnumMapper<PropertyIndex>* get_native_mapper() {
   CR_DEFINE_STATIC_LOCAL(EnumMapper<PropertyIndex>, mapper,
       (property_index_table,
        arraysize(property_index_table),
        PROPERTY_INDEX_UNKNOWN));
   return &mapper;
 }
 
-ConnectionType ParseNetworkType(const std::string& type) {
-  static EnumMapper<ConnectionType>::Pair table[] = {
-    { flimflam::kTypeEthernet, TYPE_ETHERNET },
-    { flimflam::kTypeWifi, TYPE_WIFI },
-    { flimflam::kTypeWimax, TYPE_WIMAX },
-    { flimflam::kTypeBluetooth, TYPE_BLUETOOTH },
-    { flimflam::kTypeCellular, TYPE_CELLULAR },
-    { flimflam::kTypeVPN, TYPE_VPN },
-  };
-  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionType>, parser,
-      (table, arraysize(table), TYPE_UNKNOWN));
-  return parser.Get(type);
-}
-
 }  // namespace
 
 // -------------------- NativeNetworkDeviceParser --------------------
 
 NativeNetworkDeviceParser::NativeNetworkDeviceParser()
     : NetworkDeviceParser(get_native_mapper()) {
 }
 
 NativeNetworkDeviceParser::~NativeNetworkDeviceParser() {
 }
@@ skipping 209 matching lines @@
       }
       break;
     }
     default:
       break;
   }
   return false;
 }
 
 ConnectionType NativeNetworkDeviceParser::ParseType(const std::string& type) {
-  return ParseNetworkType(type);
+  return NativeNetworkParser::network_type_mapper()->Get(type);
 }
 
 bool NativeNetworkDeviceParser::ParseApnList(const ListValue& list,
                                              CellularApnList* apn_list) {
   apn_list->clear();
   apn_list->reserve(list.GetSize());
   for (ListValue::const_iterator it = list.begin(); it != list.end(); ++it) {
     if ((*it)->IsType(base::Value::TYPE_DICTIONARY)) {
       apn_list->resize(apn_list->size() + 1);
       const DictionaryValue* dict = static_cast<const DictionaryValue*>(*it);
@@ skipping 93 matching lines @@
 }
 
 NativeNetworkParser::~NativeNetworkParser() {
 }
 
 // static
 const EnumMapper<PropertyIndex>* NativeNetworkParser::property_mapper() {
   return get_native_mapper();
 }
 
+// static
+const EnumMapper<ConnectionType>* NativeNetworkParser::network_type_mapper() {
+  CR_DEFINE_STATIC_LOCAL(
+      EnumMapper<ConnectionType>,
+      network_type_mapper,
+      (network_type_table, arraysize(network_type_table), TYPE_UNKNOWN));
+  return &network_type_mapper;
+}
+
+// static
+const EnumMapper<ConnectionSecurity>*
+    NativeNetworkParser::network_security_mapper() {
+  CR_DEFINE_STATIC_LOCAL(
+      EnumMapper<ConnectionSecurity>,
+      network_security_mapper,
+      (network_security_table, arraysize(network_security_table),
+          SECURITY_UNKNOWN));
+  return &network_security_mapper;
+}
+
+// static
+const EnumMapper<EAPMethod>* NativeNetworkParser::network_eap_method_mapper() {
+  CR_DEFINE_STATIC_LOCAL(
+      EnumMapper<EAPMethod>,
+      network_eap_method_mapper,
+      (network_eap_method_table, arraysize(network_eap_method_table),
+          EAP_METHOD_UNKNOWN));
+  return &network_eap_method_mapper;
+}
+
+// static
+const EnumMapper<EAPPhase2Auth>*
+    NativeNetworkParser::network_eap_auth_mapper() {
+  CR_DEFINE_STATIC_LOCAL(
+      EnumMapper<EAPPhase2Auth>,
+      network_eap_auth_mapper,
+      (network_eap_auth_table, arraysize(network_eap_auth_table),
+          EAP_PHASE_2_AUTH_AUTO));
+  return &network_eap_auth_mapper;
+}
+
 const ConnectionType NativeNetworkParser::ParseConnectionType(
     const std::string& connection_type) {
-  return ParseNetworkType(connection_type);
+  return network_type_mapper()->Get(connection_type);
 }
 
 Network* NativeNetworkParser::CreateNewNetwork(
     ConnectionType type, const std::string& service_path) {
   Network* network = NetworkParser::CreateNewNetwork(type, service_path);
   if (network) {
     if (type == TYPE_ETHERNET)
       network->SetNetworkParser(new NativeEthernetNetworkParser());
     else if (type == TYPE_WIFI)
       network->SetNetworkParser(new NativeWifiNetworkParser());
@@ skipping 84 matching lines @@
       return true;
     }
     default:
       return NetworkParser::ParseValue(index, value, network);
       break;
   }
   return false;
 }
 
 ConnectionType NativeNetworkParser::ParseType(const std::string& type) {
-  return ParseNetworkType(type);
+  return network_type_mapper()->Get(type);
 }
 
 ConnectionType NativeNetworkParser::ParseTypeFromDictionary(
     const DictionaryValue& info) {
   std::string type_string;
   info.GetString(flimflam::kTypeProperty, &type_string);
   return ParseType(type_string);
 }
 
 ConnectionMode NativeNetworkParser::ParseMode(const std::string& mode) {
@@ skipping 401 matching lines @@
       // These properties are currently not used in the UI.
       return true;
     default:
       return NativeWirelessNetworkParser::ParseValue(index, value, network);
   }
   return false;
 }
 
 ConnectionSecurity NativeWifiNetworkParser::ParseSecurity(
     const std::string& security) {
-  static EnumMapper<ConnectionSecurity>::Pair table[] = {
-    { flimflam::kSecurityNone, SECURITY_NONE },
-    { flimflam::kSecurityWep, SECURITY_WEP },
-    { flimflam::kSecurityWpa, SECURITY_WPA },
-    { flimflam::kSecurityRsn, SECURITY_RSN },
-    { flimflam::kSecurityPsk, SECURITY_PSK },
-    { flimflam::kSecurity8021x, SECURITY_8021X },
-  };
-  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionSecurity>, parser,
-      (table, arraysize(table), SECURITY_UNKNOWN));
-  return parser.Get(security);
+  return network_security_mapper()->Get(security);
 }
 
 EAPMethod NativeWifiNetworkParser::ParseEAPMethod(const std::string& method) {
-  static EnumMapper<EAPMethod>::Pair table[] = {
-    { flimflam::kEapMethodPEAP, EAP_METHOD_PEAP },
-    { flimflam::kEapMethodTLS, EAP_METHOD_TLS },
-    { flimflam::kEapMethodTTLS, EAP_METHOD_TTLS },
-    { flimflam::kEapMethodLEAP, EAP_METHOD_LEAP },
-  };
-  CR_DEFINE_STATIC_LOCAL(EnumMapper<EAPMethod>, parser,
-      (table, arraysize(table), EAP_METHOD_UNKNOWN));
-  return parser.Get(method);
+  return network_eap_method_mapper()->Get(method);
 }
 
 EAPPhase2Auth NativeWifiNetworkParser::ParseEAPPhase2Auth(
     const std::string& auth) {
-  static EnumMapper<EAPPhase2Auth>::Pair table[] = {
-    { flimflam::kEapPhase2AuthPEAPMD5, EAP_PHASE_2_AUTH_MD5 },
-    { flimflam::kEapPhase2AuthPEAPMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
-    { flimflam::kEapPhase2AuthTTLSMD5, EAP_PHASE_2_AUTH_MD5 },
-    { flimflam::kEapPhase2AuthTTLSMSCHAPV2, EAP_PHASE_2_AUTH_MSCHAPV2 },
-    { flimflam::kEapPhase2AuthTTLSMSCHAP, EAP_PHASE_2_AUTH_MSCHAP },
-    { flimflam::kEapPhase2AuthTTLSPAP, EAP_PHASE_2_AUTH_PAP },
-    { flimflam::kEapPhase2AuthTTLSCHAP, EAP_PHASE_2_AUTH_CHAP },
-  };
-  CR_DEFINE_STATIC_LOCAL(EnumMapper<EAPPhase2Auth>, parser,
-      (table, arraysize(table), EAP_PHASE_2_AUTH_AUTO));
-  return parser.Get(auth);
+  return network_eap_auth_mapper()->Get(auth);
 }
 
 // -------------------- NativeVirtualNetworkParser --------------------
 
 
 NativeVirtualNetworkParser::NativeVirtualNetworkParser() {}
 NativeVirtualNetworkParser::~NativeVirtualNetworkParser() {}
 
 bool NativeVirtualNetworkParser::UpdateNetworkFromInfo(
     const DictionaryValue& info,
@@ skipping 125 matching lines @@
   static EnumMapper<ProviderType>::Pair table[] = {
     { flimflam::kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK },
     { flimflam::kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN },
   };
   CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser,
       (table, arraysize(table), PROVIDER_TYPE_MAX));
   return parser.Get(type);
 }
 
 }  // namespace chromeos