Migrate DBus service constants from flimflam namespace to shill namespace.

chromeos/network/client_cert_util.cc

 // Copyright (c) 2012 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 "chromeos/network/client_cert_util.h"
 
 #include <cert.h>
 #include <pk11pub.h>
 
 #include <list>
@@ skipping 190 matching lines @@
                         const std::string& tpm_slot,
                         const std::string& tpm_pin,
                         const std::string* pkcs11_id,
                         base::DictionaryValue* properties) {
   const char* tpm_pin_property = NULL;
   switch (cert_config_type) {
     case CONFIG_TYPE_NONE: {
       return;
     }
     case CONFIG_TYPE_OPENVPN: {
-      tpm_pin_property = flimflam::kOpenVPNPinProperty;
+      tpm_pin_property = shill::kOpenVPNPinProperty;
       if (pkcs11_id) {
         properties->SetStringWithoutPathExpansion(
-            flimflam::kOpenVPNClientCertIdProperty, *pkcs11_id);
+            shill::kOpenVPNClientCertIdProperty, *pkcs11_id);
       }
       break;
     }
     case CONFIG_TYPE_IPSEC: {
-      tpm_pin_property = flimflam::kL2tpIpsecPinProperty;
+      tpm_pin_property = shill::kL2tpIpsecPinProperty;
       if (!tpm_slot.empty()) {
         properties->SetStringWithoutPathExpansion(
-            flimflam::kL2tpIpsecClientCertSlotProperty, tpm_slot);
+            shill::kL2tpIpsecClientCertSlotProperty, tpm_slot);
       }
       if (pkcs11_id) {
         properties->SetStringWithoutPathExpansion(
-            flimflam::kL2tpIpsecClientCertIdProperty, *pkcs11_id);
+            shill::kL2tpIpsecClientCertIdProperty, *pkcs11_id);
       }
       break;
     }
     case CONFIG_TYPE_EAP: {
-      tpm_pin_property = flimflam::kEapPinProperty;
+      tpm_pin_property = shill::kEapPinProperty;
       if (pkcs11_id) {
         // Shill requires both CertID and KeyID for TLS connections, despite the
         // fact that by convention they are the same ID.
-        properties->SetStringWithoutPathExpansion(flimflam::kEapCertIdProperty,
+        properties->SetStringWithoutPathExpansion(shill::kEapCertIdProperty,
                                                   *pkcs11_id);
-        properties->SetStringWithoutPathExpansion(flimflam::kEapKeyIdProperty,
+        properties->SetStringWithoutPathExpansion(shill::kEapKeyIdProperty,
                                                   *pkcs11_id);
       }
       break;
     }
   }
   DCHECK(tpm_pin_property);
   if (!tpm_pin.empty())
     properties->SetStringWithoutPathExpansion(tpm_pin_property, tpm_pin);
 }
 
 bool IsCertificateConfigured(const client_cert::ConfigType cert_config_type,
                              const base::DictionaryValue& service_properties) {
   // VPN certificate properties are read from the Provider dictionary.
   const base::DictionaryValue* provider_properties = NULL;
   service_properties.GetDictionaryWithoutPathExpansion(
-      flimflam::kProviderProperty, &provider_properties);
+      shill::kProviderProperty, &provider_properties);
   switch (cert_config_type) {
     case CONFIG_TYPE_NONE:
       return true;
     case CONFIG_TYPE_OPENVPN:
       // OpenVPN generally requires a passphrase and we don't know whether or
       // not one is required, so always return false here.
       return false;
     case CONFIG_TYPE_IPSEC:
       // IPSec may require a passphrase, so return false here also.
       return false;
     case CONFIG_TYPE_EAP: {
       std::string cert_id = GetStringFromDictionary(
-          service_properties, flimflam::kEapCertIdProperty);
+          service_properties, shill::kEapCertIdProperty);
       std::string key_id = GetStringFromDictionary(
-          service_properties, flimflam::kEapKeyIdProperty);
+          service_properties, shill::kEapKeyIdProperty);
       std::string identity = GetStringFromDictionary(
-          service_properties, flimflam::kEapIdentityProperty);
+          service_properties, shill::kEapIdentityProperty);
       return !cert_id.empty() && !key_id.empty() && !identity.empty();
     }
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace client_cert
 
 }  // namespace chromeos