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 121 matching lines @@
   { 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 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 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 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 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::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::type_mapper() {
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionType>, type_mapper,
+      (type_table, arraysize(type_table), TYPE_UNKNOWN));
+  return &type_mapper;

[stevenjb, 2011/11/30 17:36:20]

nit: "type_mapper" and "type_table" sound like generic functions, we should
probably name these "network_type_mapper", etc.

[Charlie Lee, 2011/11/30 18:01:21]

Done.

+}
+
+// static
+const EnumMapper<ConnectionSecurity>* NativeNetworkParser::security_mapper() {
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionSecurity>, security_mapper,
+      (security_table, arraysize(security_table), SECURITY_UNKNOWN));
+  return &security_mapper;
+}
+
+// static
+const EnumMapper<EAPMethod>* NativeNetworkParser::eap_method_mapper() {
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<EAPMethod>, eap_method_mapper,
+      (eap_method_table, arraysize(eap_method_table), EAP_METHOD_UNKNOWN));
+  return &eap_method_mapper;
+}
+
+// static
+const EnumMapper<EAPPhase2Auth>* NativeNetworkParser::eap_auth_mapper() {
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<EAPPhase2Auth>, eap_auth_mapper,
+      (eap_auth_table, arraysize(eap_auth_table), EAP_PHASE_2_AUTH_AUTO));
+  return &eap_auth_mapper;
+}
+
 const ConnectionType NativeNetworkParser::ParseConnectionType(
     const std::string& connection_type) {
-  return ParseNetworkType(connection_type);
+  return 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 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 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 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 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