ONC: Cleanup client certificate related fields.

chromeos/network/onc/onc_normalizer.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/onc/onc_normalizer.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/values.h"
@@ skipping 86 matching lines @@
 
   std::string auth;
   ethernet->GetStringWithoutPathExpansion(kAuthentication, &auth);
   RemoveEntryUnless(ethernet, kEAP, auth == k8021X);
 }
 
 void Normalizer::NormalizeEAP(base::DictionaryValue* eap) {
   using namespace ::onc::eap;
 
   std::string clientcert_type;
-  eap->GetStringWithoutPathExpansion(kClientCertType, &clientcert_type);
-  RemoveEntryUnless(
-      eap, kClientCertPattern, clientcert_type == ::onc::certificate::kPattern);
-  RemoveEntryUnless(
-      eap, kClientCertRef, clientcert_type == ::onc::certificate::kRef);
+  eap->GetStringWithoutPathExpansion(::onc::client_cert::kClientCertType,
+                                     &clientcert_type);
+  RemoveEntryUnless(eap,
+                    ::onc::client_cert::kClientCertPattern,
+                    clientcert_type == ::onc::client_cert::kPattern);
+  RemoveEntryUnless(eap,
+                    ::onc::client_cert::kClientCertRef,
+                    clientcert_type == ::onc::client_cert::kRef);
 
   std::string outer;
   eap->GetStringWithoutPathExpansion(kOuter, &outer);
   RemoveEntryUnless(eap, kAnonymousIdentity,
                     outer == kPEAP || outer == kEAP_TTLS);
   RemoveEntryUnless(eap, kInner,
                     outer == kPEAP || outer == kEAP_TTLS || outer == kEAP_FAST);
 }
 
 void Normalizer::NormalizeIPsec(base::DictionaryValue* ipsec) {
   using namespace ::onc::ipsec;
 
   std::string auth_type;
   ipsec->GetStringWithoutPathExpansion(kAuthenticationType, &auth_type);
-  RemoveEntryUnless(ipsec, ::onc::vpn::kClientCertType, auth_type == kCert);
+  RemoveEntryUnless(
+      ipsec, ::onc::client_cert::kClientCertType, auth_type == kCert);
   RemoveEntryUnless(ipsec, kServerCARef, auth_type == kCert);
   RemoveEntryUnless(ipsec, kPSK, auth_type == kPSK);
   RemoveEntryUnless(ipsec, ::onc::vpn::kSaveCredentials, auth_type == kPSK);
 
   std::string clientcert_type;
-  ipsec->GetStringWithoutPathExpansion(::onc::vpn::kClientCertType,
+  ipsec->GetStringWithoutPathExpansion(::onc::client_cert::kClientCertType,
                                        &clientcert_type);
   RemoveEntryUnless(ipsec,
-                    ::onc::vpn::kClientCertPattern,
-                    clientcert_type == ::onc::certificate::kPattern);
+                    ::onc::client_cert::kClientCertPattern,
+                    clientcert_type == ::onc::client_cert::kPattern);
   RemoveEntryUnless(ipsec,
-                    ::onc::vpn::kClientCertRef,
-                    clientcert_type == ::onc::certificate::kRef);
+                    ::onc::client_cert::kClientCertRef,
+                    clientcert_type == ::onc::client_cert::kRef);
 
   int ike_version = -1;
   ipsec->GetIntegerWithoutPathExpansion(kIKEVersion, &ike_version);
   RemoveEntryUnless(ipsec, kEAP, ike_version == 2);
   RemoveEntryUnless(ipsec, kGroup, ike_version == 1);
   RemoveEntryUnless(ipsec, kXAUTH, ike_version == 1);
 }
 
 void Normalizer::NormalizeNetworkConfiguration(base::DictionaryValue* network) {
   bool remove = false;
@@ skipping 21 matching lines @@
       network, ::onc::network_config::kVPN, type == ::onc::network_type::kVPN);
   RemoveEntryUnless(network,
                     ::onc::network_config::kWiFi,
                     type == ::onc::network_type::kWiFi);
 }
 
 void Normalizer::NormalizeOpenVPN(base::DictionaryValue* openvpn) {
   using namespace ::onc::vpn;
 
   std::string clientcert_type;
-  openvpn->GetStringWithoutPathExpansion(kClientCertType, &clientcert_type);
+  openvpn->GetStringWithoutPathExpansion(::onc::client_cert::kClientCertType,
+                                         &clientcert_type);
   RemoveEntryUnless(openvpn,
-                    kClientCertPattern,
-                    clientcert_type == ::onc::certificate::kPattern);
-  RemoveEntryUnless(
-      openvpn, kClientCertRef, clientcert_type == ::onc::certificate::kRef);
+                    ::onc::client_cert::kClientCertPattern,
+                    clientcert_type == ::onc::client_cert::kPattern);
+  RemoveEntryUnless(openvpn,
+                    ::onc::client_cert::kClientCertRef,
+                    clientcert_type == ::onc::client_cert::kRef);
 }
 
 void Normalizer::NormalizeProxySettings(base::DictionaryValue* proxy) {
   using namespace ::onc::proxy;
 
   std::string type;
   proxy->GetStringWithoutPathExpansion(::onc::proxy::kType, &type);
   RemoveEntryUnless(proxy, kManual, type == kManual);
   RemoveEntryUnless(proxy, kExcludeDomains, type == kManual);
   RemoveEntryUnless(proxy, kPAC, type == kPAC);
@@ skipping 14 matching lines @@
 
   std::string security;
   wifi->GetStringWithoutPathExpansion(::onc::wifi::kSecurity, &security);
   RemoveEntryUnless(wifi, kEAP, security == kWEP_8021X || security == kWPA_EAP);
   RemoveEntryUnless(wifi, kPassphrase,
                     security == kWEP_PSK || security == kWPA_PSK);
 }
 
 }  // namespace onc
 }  // namespace chromeos