Add CertErrors* parameter to the main Certificate parsing functions.

net/cert/internal/test_helpers.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 "net/cert/internal/test_helpers.h"
 
 #include "base/base64.h"
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
+#include "net/cert/internal/cert_errors.h"
 #include "net/cert/pem_tokenizer.h"
 #include "net/der/parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace der {
 
 void PrintTo(const Input& data, ::std::ostream* os) {
   std::string b64;
@@ skipping 113 matching lines @@
   bool has_time = false;
   bool has_result = false;
   bool has_errors = false;
 
   PEMTokenizer pem_tokenizer(file_data, pem_headers);
   while (pem_tokenizer.GetNext()) {
     const std::string& block_type = pem_tokenizer.block_type();
     const std::string& block_data = pem_tokenizer.data();
 
     if (block_type == kCertificateHeader) {
-      ASSERT_TRUE(net::ParsedCertificate::CreateAndAddToVector(
-          reinterpret_cast<const uint8_t*>(block_data.data()),
-          block_data.size(), net::ParsedCertificate::DataSource::INTERNAL_COPY,
-          {}, chain));
+      CertErrors errors;
+      ASSERT_TRUE(net::ParsedCertificate::CreateAndAddToVector(block_data, {},
+                                                               chain, &errors))
+          << errors.ToDebugString();
     } else if (block_type == kTrustAnchorUnconstrained ||
                block_type == kTrustAnchorConstrained) {
       ASSERT_FALSE(*trust_anchor) << "Duplicate trust anchor";
+      CertErrors errors;
       scoped_refptr<ParsedCertificate> root =
-          net::ParsedCertificate::CreateFromCertificateData(
-              reinterpret_cast<const uint8_t*>(block_data.data()),
-              block_data.size(),
-              net::ParsedCertificate::DataSource::INTERNAL_COPY, {});
-      ASSERT_TRUE(root);
+          net::ParsedCertificate::Create(block_data, {}, &errors);
+      ASSERT_TRUE(root) << errors.ToDebugString();
       *trust_anchor =
           block_type == kTrustAnchorUnconstrained
               ? TrustAnchor::CreateFromCertificateNoConstraints(std::move(root))
               : TrustAnchor::CreateFromCertificateWithConstraints(
                     std::move(root));
     } else if (block_type == kTimeHeader) {
       ASSERT_FALSE(has_time) << "Duplicate " << kTimeHeader;
       has_time = true;
       ASSERT_TRUE(der::ParseUTCTime(der::Input(&block_data), time));
     } else if (block_type == kResultHeader) {
@@ skipping 24 matching lines @@
   std::string file_data;
   if (!base::ReadFileToString(filepath, &file_data)) {
     ADD_FAILURE() << "Couldn't read file: " << filepath.value();
     return std::string();
   }
 
   return file_data;
 }
 
 }  // namespace net