Resolve certificate references in ONC by PEM.

chromeos/network/certificate_pattern.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/certificate_pattern.h"
 
 #include "base/logging.h"
 #include "base/values.h"
+#include "chromeos/network/onc/onc_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 // Keys for converting classes below to/from dictionaries.
 const char kCommonNameKey[] = "CommonName";
 const char kLocalityKey[] = "Locality";
 const char kOrganizationKey[] = "Organization";
 const char kOrganizationalUnitKey[] = "OrganizationalUnit";
-const char kIssuerCaRefKey[] = "IssuerCARef";
 const char kIssuerKey[] = "Issuer";
 const char kSubjectKey[] = "Subject";
 const char kEnrollmentUriKey[] = "EnrollmentURI";
 
 bool GetAsListOfStrings(const base::Value& value,
                         std::vector<std::string>* result) {
   const base::ListValue* list = NULL;
   if (!value.GetAsList(&list))
     return false;
   result->clear();
@@ skipping 77 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CertificatePattern
 
 CertificatePattern::CertificatePattern() {}
 
 CertificatePattern::~CertificatePattern() {}
 
 bool CertificatePattern::Empty() const {
-  return issuer_ca_ref_list_.empty() &&
+  return issuer_ca_pems_.empty() &&
          issuer_.Empty() &&
          subject_.Empty();
 }
 
 void CertificatePattern::Clear() {
-  issuer_ca_ref_list_.clear();
+  issuer_ca_pems_.clear();
   issuer_.Clear();
   subject_.Clear();
   enrollment_uri_list_.clear();
 }
 
 base::DictionaryValue* CertificatePattern::CreateAsDictionary() const {
   base::DictionaryValue* dict = new base::DictionaryValue;
 
-  if (!issuer_ca_ref_list_.empty())
-    dict->Set(kIssuerCaRefKey, CreateListFromStrings(issuer_ca_ref_list_));
+  if (!issuer_ca_pems_.empty()) {
+    dict->Set(onc::certificate::kIssuerCAPEMs,
+              CreateListFromStrings(issuer_ca_pems_));
+  }
 
   if (!issuer_.Empty())
     dict->Set(kIssuerKey, issuer_.CreateAsDictionary());
 
   if (!subject_.Empty())
     dict->Set(kSubjectKey, subject_.CreateAsDictionary());
 
   if (!enrollment_uri_list_.empty())
     dict->Set(kEnrollmentUriKey, CreateListFromStrings(enrollment_uri_list_));
   return dict;
 }
 
 bool CertificatePattern::CopyFromDictionary(const base::DictionaryValue &dict) {
   const base::DictionaryValue* child_dict = NULL;
   const base::ListValue* child_list = NULL;
   Clear();
 
   // All of these are optional.
-  if (dict.GetList(kIssuerCaRefKey, &child_list) && child_list) {
-    if (!GetAsListOfStrings(*child_list, &issuer_ca_ref_list_))
+  if (dict.GetList(onc::certificate::kIssuerCAPEMs, &child_list) &&
+      child_list) {
+    if (!GetAsListOfStrings(*child_list, &issuer_ca_pems_))
       return false;
   }
   if (dict.GetDictionary(kIssuerKey, &child_dict) && child_dict) {
     if (!issuer_.CopyFromDictionary(*child_dict))
       return false;
   }
   child_dict = NULL;
   if (dict.GetDictionary(kSubjectKey, &child_dict) && child_dict) {
     if (!subject_.CopyFromDictionary(*child_dict))
       return false;
   }
   child_list = NULL;
   if (dict.GetList(kEnrollmentUriKey, &child_list) && child_list) {
     if (!GetAsListOfStrings(*child_list, &enrollment_uri_list_))
       return false;
   }
 
   // If we didn't copy anything from the dictionary, then it had better be
   // empty.
   DCHECK(dict.empty() == Empty());
   if (dict.empty() != Empty())
     return false;
 
   return true;
 }
 
 }  // namespace chromeos