CrOs: Remove 29 exit time destructors and 8 static initializers.

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 122 matching lines @@
   { 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 },
 };
 
 // Serve the singleton mapper instance.
 const EnumMapper<PropertyIndex>* get_native_mapper() {
-  static const EnumMapper<PropertyIndex> mapper(property_index_table,
-                                                arraysize(property_index_table),
-                                                PROPERTY_INDEX_UNKNOWN);
+  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 },
   };
-  static EnumMapper<ConnectionType> parser(
-      table, arraysize(table), TYPE_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionType>, parser,
+      (table, arraysize(table), TYPE_UNKNOWN));
   return parser.Get(type);
 }
 
 }  // namespace
 
 // -------------------- NativeNetworkDeviceParser --------------------
 
 NativeNetworkDeviceParser::NativeNetworkDeviceParser()
     : NetworkDeviceParser(get_native_mapper()) {
 }
@@ skipping 278 matching lines @@
   return true;
 }
 
 SimLockState NativeNetworkDeviceParser::ParseSimLockState(
     const std::string& state) {
   static EnumMapper<SimLockState>::Pair table[] = {
     { "", SIM_UNLOCKED },
     { flimflam::kSIMLockPin, SIM_LOCKED_PIN },
     { flimflam::kSIMLockPuk, SIM_LOCKED_PUK },
   };
-  static EnumMapper<SimLockState> parser(
-      table, arraysize(table), SIM_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<SimLockState>, parser,
+      (table, arraysize(table), SIM_UNKNOWN));
   SimLockState parsed_state = parser.Get(state);
   DCHECK(parsed_state != SIM_UNKNOWN) << "Unknown SIMLock state encountered";
   return parsed_state;
 }
 
 bool NativeNetworkDeviceParser::ParseSimLockStateFromDictionary(
     const DictionaryValue& info,
     SimLockState* out_state,
     int* out_retries,
     bool* out_enabled) {
   std::string state_string;
   if (!info.GetString(flimflam::kSIMLockTypeProperty, &state_string) ||
       !info.GetInteger(flimflam::kSIMLockRetriesLeftProperty, out_retries) ||
       !info.GetBoolean(flimflam::kSIMLockEnabledProperty, out_enabled)) {
     LOG(ERROR) << "Error parsing SIMLock state";
     return false;
   }
   *out_state = ParseSimLockState(state_string);
   return true;
 }
 
 TechnologyFamily NativeNetworkDeviceParser::ParseTechnologyFamily(
     const std::string& technology_family) {
   static EnumMapper<TechnologyFamily>::Pair table[] = {
     { flimflam::kTechnologyFamilyCdma, TECHNOLOGY_FAMILY_CDMA },
     { flimflam::kTechnologyFamilyGsm, TECHNOLOGY_FAMILY_GSM },
   };
-  static EnumMapper<TechnologyFamily> parser(
-      table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<TechnologyFamily>, parser,
+      (table, arraysize(table), TECHNOLOGY_FAMILY_UNKNOWN));
   return parser.Get(technology_family);
 }
 
 // -------------------- NativeNetworkParser --------------------
 
 NativeNetworkParser::NativeNetworkParser()
     : NetworkParser(get_native_mapper()) {
 }
 
 NativeNetworkParser::~NativeNetworkParser() {
@@ skipping 119 matching lines @@
   std::string type_string;
   info.GetString(flimflam::kTypeProperty, &type_string);
   return ParseType(type_string);
 }
 
 ConnectionMode NativeNetworkParser::ParseMode(const std::string& mode) {
   static EnumMapper<ConnectionMode>::Pair table[] = {
     { flimflam::kModeManaged, MODE_MANAGED },
     { flimflam::kModeAdhoc, MODE_ADHOC },
   };
-  static EnumMapper<ConnectionMode> parser(
-      table, arraysize(table), MODE_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionMode>, parser,
+      (table, arraysize(table), MODE_UNKNOWN));
   return parser.Get(mode);
 }
 
 ConnectionState NativeNetworkParser::ParseState(const std::string& state) {
   static EnumMapper<ConnectionState>::Pair table[] = {
     { flimflam::kStateIdle, STATE_IDLE },
     { flimflam::kStateCarrier, STATE_CARRIER },
     { flimflam::kStateAssociation, STATE_ASSOCIATION },
     { flimflam::kStateConfiguration, STATE_CONFIGURATION },
     { flimflam::kStateReady, STATE_READY },
     { flimflam::kStateDisconnect, STATE_DISCONNECT },
     { flimflam::kStateFailure, STATE_FAILURE },
     { flimflam::kStateActivationFailure, STATE_ACTIVATION_FAILURE },
     { flimflam::kStatePortal, STATE_PORTAL },
     { flimflam::kStateOnline, STATE_ONLINE },
   };
-  static EnumMapper<ConnectionState> parser(
-      table, arraysize(table), STATE_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionState>, parser,
+      (table, arraysize(table), STATE_UNKNOWN));
   return parser.Get(state);
 }
 
 ConnectionError NativeNetworkParser::ParseError(const std::string& error) {
   static EnumMapper<ConnectionError>::Pair table[] = {
     { flimflam::kErrorOutOfRange, ERROR_OUT_OF_RANGE },
     { flimflam::kErrorPinMissing, ERROR_PIN_MISSING },
     { flimflam::kErrorDhcpFailed, ERROR_DHCP_FAILED },
     { flimflam::kErrorConnectFailed, ERROR_CONNECT_FAILED },
     { flimflam::kErrorBadPassphrase, ERROR_BAD_PASSPHRASE },
     { flimflam::kErrorBadWEPKey, ERROR_BAD_WEPKEY },
     { flimflam::kErrorActivationFailed, ERROR_ACTIVATION_FAILED },
     { flimflam::kErrorNeedEvdo, ERROR_NEED_EVDO },
     { flimflam::kErrorNeedHomeNetwork, ERROR_NEED_HOME_NETWORK },
     { flimflam::kErrorOtaspFailed, ERROR_OTASP_FAILED },
     { flimflam::kErrorAaaFailed, ERROR_AAA_FAILED },
     { flimflam::kErrorInternal, ERROR_INTERNAL },
     { flimflam::kErrorDNSLookupFailed, ERROR_DNS_LOOKUP_FAILED },
     { flimflam::kErrorHTTPGetFailed, ERROR_HTTP_GET_FAILED },
     { flimflam::kErrorIpsecPskAuthFailed, ERROR_IPSEC_PSK_AUTH_FAILED },
     { flimflam::kErrorIpsecCertAuthFailed, ERROR_IPSEC_CERT_AUTH_FAILED },
     { flimflam::kErrorPppAuthFailed, ERROR_PPP_AUTH_FAILED },
   };
-  static EnumMapper<ConnectionError> parser(
-      table, arraysize(table), ERROR_NO_ERROR);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionError>, parser,
+      (table, arraysize(table), ERROR_NO_ERROR));
   return parser.Get(error);
 }
 
 // -------------------- NativeEthernetNetworkParser --------------------
 
 NativeEthernetNetworkParser::NativeEthernetNetworkParser() {}
 NativeEthernetNetworkParser::~NativeEthernetNetworkParser() {}
 
 // -------------------- NativeWirelessNetworkParser --------------------
 
@@ skipping 158 matching lines @@
 ActivationState NativeCellularNetworkParser::ParseActivationState(
     const std::string& state) {
   static EnumMapper<ActivationState>::Pair table[] = {
     { flimflam::kActivationStateActivated, ACTIVATION_STATE_ACTIVATED },
     { flimflam::kActivationStateActivating, ACTIVATION_STATE_ACTIVATING },
     { flimflam::kActivationStateNotActivated, ACTIVATION_STATE_NOT_ACTIVATED },
     { flimflam::kActivationStatePartiallyActivated,
       ACTIVATION_STATE_PARTIALLY_ACTIVATED},
     { flimflam::kActivationStateUnknown, ACTIVATION_STATE_UNKNOWN},
   };
-  static EnumMapper<ActivationState> parser(
-      table, arraysize(table), ACTIVATION_STATE_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ActivationState>, parser,
+      (table, arraysize(table), ACTIVATION_STATE_UNKNOWN));
   return parser.Get(state);
 }
 
 NetworkTechnology NativeCellularNetworkParser::ParseNetworkTechnology(
     const std::string& technology) {
   static EnumMapper<NetworkTechnology>::Pair table[] = {
     { flimflam::kNetworkTechnology1Xrtt, NETWORK_TECHNOLOGY_1XRTT },
     { flimflam::kNetworkTechnologyEvdo, NETWORK_TECHNOLOGY_EVDO },
     { flimflam::kNetworkTechnologyGprs, NETWORK_TECHNOLOGY_GPRS },
     { flimflam::kNetworkTechnologyEdge, NETWORK_TECHNOLOGY_EDGE },
     { flimflam::kNetworkTechnologyUmts, NETWORK_TECHNOLOGY_UMTS },
     { flimflam::kNetworkTechnologyHspa, NETWORK_TECHNOLOGY_HSPA },
     { flimflam::kNetworkTechnologyHspaPlus, NETWORK_TECHNOLOGY_HSPA_PLUS },
     { flimflam::kNetworkTechnologyLte, NETWORK_TECHNOLOGY_LTE },
     { flimflam::kNetworkTechnologyLteAdvanced,
       NETWORK_TECHNOLOGY_LTE_ADVANCED },
     { flimflam::kNetworkTechnologyGsm, NETWORK_TECHNOLOGY_GSM },
   };
-  static EnumMapper<NetworkTechnology> parser(
-      table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<NetworkTechnology>, parser,
+      (table, arraysize(table), NETWORK_TECHNOLOGY_UNKNOWN));
   return parser.Get(technology);
 }
 
 NetworkRoamingState NativeCellularNetworkParser::ParseRoamingState(
     const std::string& roaming_state) {
   static EnumMapper<NetworkRoamingState>::Pair table[] = {
     { flimflam::kRoamingStateHome, ROAMING_STATE_HOME },
     { flimflam::kRoamingStateRoaming, ROAMING_STATE_ROAMING },
     { flimflam::kRoamingStateUnknown, ROAMING_STATE_UNKNOWN },
   };
-  static EnumMapper<NetworkRoamingState> parser(
-      table, arraysize(table), ROAMING_STATE_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<NetworkRoamingState>, parser,
+      (table, arraysize(table), ROAMING_STATE_UNKNOWN));
   return parser.Get(roaming_state);
 }
 
 // -------------------- NativeWifiNetworkParser --------------------
 
 NativeWifiNetworkParser::NativeWifiNetworkParser() {}
 NativeWifiNetworkParser::~NativeWifiNetworkParser() {}
 
 bool NativeWifiNetworkParser::ParseValue(PropertyIndex index,
                                          const base::Value& value,
@@ skipping 138 matching lines @@
 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 },
   };
-  static EnumMapper<ConnectionSecurity> parser(
-      table, arraysize(table), SECURITY_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ConnectionSecurity>, parser,
+      (table, arraysize(table), SECURITY_UNKNOWN));
   return parser.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 },
   };
-  static EnumMapper<EAPMethod> parser(
-      table, arraysize(table), EAP_METHOD_UNKNOWN);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<EAPMethod>, parser,
+      (table, arraysize(table), EAP_METHOD_UNKNOWN));
   return parser.Get(method);
 }
 
 EAPPhase2Auth NativeWifiNetworkParser::ParseEAPPhase2Auth(
     const std::string& auth) {
   static EnumMapper<EAPPhase2Auth>::Pair table[] = {
     { 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 },
   };
-  static EnumMapper<EAPPhase2Auth> parser(
-      table, arraysize(table), EAP_PHASE_2_AUTH_AUTO);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<EAPPhase2Auth>, parser,
+      (table, arraysize(table), EAP_PHASE_2_AUTH_AUTO));
   return parser.Get(auth);
 }
 
 // -------------------- NativeVirtualNetworkParser --------------------
 
 
 NativeVirtualNetworkParser::NativeVirtualNetworkParser() {}
 NativeVirtualNetworkParser::~NativeVirtualNetworkParser() {}
 
 bool NativeVirtualNetworkParser::UpdateNetworkFromInfo(
@@ skipping 120 matching lines @@
   }
   return false;
 }
 
 ProviderType NativeVirtualNetworkParser::ParseProviderType(
     const std::string& type) {
   static EnumMapper<ProviderType>::Pair table[] = {
     { flimflam::kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK },
     { flimflam::kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN },
   };
-  static EnumMapper<ProviderType> parser(
-      table, arraysize(table), PROVIDER_TYPE_MAX);
+  CR_DEFINE_STATIC_LOCAL(EnumMapper<ProviderType>, parser,
+      (table, arraysize(table), PROVIDER_TYPE_MAX));
   return parser.Get(type);
 }
 
 }  // namespace chromeos