Make X509Certificate creation fail if X509Certificate::Initialize fails.

net/cert/x509_util_nss.cc

 // Copyright 2015 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 <cert.h>  // Must be included before certdb.h
 #include <certdb.h>
 #include <cryptohi.h>
 #include <nss.h>
 #include <pk11pub.h>
 #include <prerror.h>
@@ skipping 71 matching lines @@
   if (rv != SECSuccess)
     return NULL;
 
   return name.release();
 }
 
 }  // namespace
 
 namespace x509_util {
 
-void ParsePrincipal(CERTName* name, CertPrincipal* principal) {
+bool ParsePrincipal(CERTName* name, CertPrincipal* principal) {
 // Starting in NSS 3.15, CERTGetNameFunc takes a const CERTName* argument.
 #if NSS_VMINOR >= 15
   typedef char* (*CERTGetNameFunc)(const CERTName* name);
 #else
   typedef char* (*CERTGetNameFunc)(CERTName * name);
 #endif
 
   // TODO(jcampan): add business_category and serial_number.
   // TODO(wtc): NSS has the CERT_GetOrgName, CERT_GetOrgUnitName, and
   // CERT_GetDomainComponentName functions, but they return only the most
@@ skipping 10 matching lines @@
 
   CERTRDN** rdns = name->rdns;
   for (size_t rdn = 0; rdns[rdn]; ++rdn) {
     CERTAVA** avas = rdns[rdn]->avas;
     for (size_t pair = 0; avas[pair] != 0; ++pair) {
       SECOidTag tag = CERT_GetAVATag(avas[pair]);
       for (size_t oid = 0; oid < arraysize(kOIDs); ++oid) {
         if (kOIDs[oid] == tag) {
           SECItem* decode_item = CERT_DecodeAVAValue(&avas[pair]->value);
           if (!decode_item)
-            break;
+            return false;
           // TODO(wtc): Pass decode_item to CERT_RFC1485_EscapeAndQuote.
           std::string value(reinterpret_cast<char*>(decode_item->data),
                             decode_item->len);
           values[oid]->push_back(value);
           SECITEM_FreeItem(decode_item, PR_TRUE);
           break;
         }
       }
     }
   }
 
   // Get CN, L, S, and C.
   CERTGetNameFunc get_name_funcs[4] = {CERT_GetCommonName, CERT_GetLocalityName,
                                        CERT_GetStateName, CERT_GetCountryName};
   std::string* single_values[4] = {
       &principal->common_name, &principal->locality_name,
       &principal->state_or_province_name, &principal->country_name};
   for (size_t i = 0; i < arraysize(get_name_funcs); ++i) {
     char* value = get_name_funcs[i](name);
     if (value) {
       single_values[i]->assign(value);
       PORT_Free(value);
     }
   }
+
+  return true;
 }
 
-void ParseDate(const SECItem* der_date, base::Time* result) {
+bool ParseDate(const SECItem* der_date, base::Time* result) {
   PRTime prtime;
   SECStatus rv = DER_DecodeTimeChoice(&prtime, der_date);
-  DCHECK_EQ(SECSuccess, rv);
+  if (rv != SECSuccess)
+    return false;
   *result = crypto::PRTimeToBaseTime(prtime);
+  return true;
 }
 
 std::string ParseSerialNumber(const CERTCertificate* certificate) {
   return std::string(reinterpret_cast<char*>(certificate->serialNumber.data),
                      certificate->serialNumber.len);
 }
 
 bool GetSubjectAltName(CERTCertificate* cert_handle,
                        std::vector<std::string>* dns_names,
                        std::vector<std::string>* ip_addrs) {
@@ skipping 252 matching lines @@
     base::SStringPrintf(&new_name, "%s #%d", nickname.c_str(), index++);
     temp_nickname = token_name + new_name;
   }
 
   return new_name;
 }
 
 }  // namespace x509_util
 
 }  // namespace net