Add CertErrors* parameter to the main Certificate parsing functions.

net/cert/internal/path_builder_unittest.cc

 // Copyright 2016 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/path_builder.h"
 
 #include "base/base_paths.h"
 #include "base/cancelable_callback.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ skipping 103 matching lines @@
 }
 
 ::testing::AssertionResult ReadTestCert(
     const std::string& file_name,
     scoped_refptr<ParsedCertificate>* result) {
   std::string der;
   ::testing::AssertionResult r = ReadTestPem(
       "net/data/ssl/certificates/" + file_name, "CERTIFICATE", &der);
   if (!r)
     return r;
-  *result = ParsedCertificate::CreateFromCertificateCopy(der, {});
-  if (!*result)
-    return ::testing::AssertionFailure() << "CreateFromCertificateCopy failed";
+  CertErrors errors;
+  *result = ParsedCertificate::Create(der, {}, &errors);
+  if (!*result) {
+    return ::testing::AssertionFailure()
+           << "ParseCertificate::Create() failed:\n"
+           << errors.ToDebugString();
+  }
   return ::testing::AssertionSuccess();
 }
 
 // Run the path builder, and wait for async completion if necessary. The return
 // value signifies whether the path builder completed synchronously or
 // asynchronously, not that RunPathBuilder itself is asynchronous.
 CompletionStatus RunPathBuilder(CertPathBuilder* path_builder) {
   TestClosure callback;
   CompletionStatus rv = path_builder->Run(callback.closure());
 
@@ skipping 797 matching lines @@
   ASSERT_EQ(1U, best_result->path.certs.size());
   EXPECT_EQ(newroot_, best_result->path.certs[0]);
   EXPECT_EQ(newrootrollover_, best_result->path.trust_anchor->cert());
 }
 
 // Test that PathBuilder will not try the same path twice if multiple
 // CertIssuerSources provide the same certificate.
 TEST_F(PathBuilderKeyRolloverTest, TestDuplicateIntermediates) {
   // Create a separate copy of oldintermediate.
   scoped_refptr<ParsedCertificate> oldintermediate_dupe(
-      ParsedCertificate::CreateFromCertificateCopy(
-          oldintermediate_->der_cert().AsStringPiece(), {}));
+      ParsedCertificate::Create(oldintermediate_->der_cert().AsStringPiece(),
+                                {}, nullptr));
 
   // Only newroot is a trusted root.
   TrustStoreInMemory trust_store;
   AddTrustedCertificate(newroot_, &trust_store);
 
   // The oldintermediate is supplied synchronously by |sync_certs1| and
   // another copy of oldintermediate is supplied synchronously by |sync_certs2|.
   // The path target <- oldintermediate <- newroot  should be built first,
   // though it won't verify. It should not be attempted again even though
   // oldintermediate was supplied twice.
@@ skipping 39 matching lines @@
   ASSERT_EQ(2U, path1.certs.size());
   EXPECT_EQ(target_, path1.certs[0]);
   EXPECT_EQ(newintermediate_, path1.certs[1]);
   EXPECT_EQ(newroot_, path1.trust_anchor->cert());
 }
 
 // Test when PathBuilder is given a cert CertIssuerSources that has the same
 // SPKI as a TrustAnchor.
 TEST_F(PathBuilderKeyRolloverTest, TestDuplicateIntermediateAndRoot) {
   // Create a separate copy of newroot.
-  scoped_refptr<ParsedCertificate> newroot_dupe(
-      ParsedCertificate::CreateFromCertificateCopy(
-          newroot_->der_cert().AsStringPiece(), {}));
+  scoped_refptr<ParsedCertificate> newroot_dupe(ParsedCertificate::Create(
+      newroot_->der_cert().AsStringPiece(), {}, nullptr));
 
   // Only newroot is a trusted root.
   TrustStoreInMemory trust_store;
   AddTrustedCertificate(newroot_, &trust_store);
 
   // The oldintermediate and newroot are supplied synchronously by |sync_certs|.
   CertIssuerSourceStatic sync_certs;
   sync_certs.AddCert(oldintermediate_);
   sync_certs.AddCert(newroot_dupe);
 
@@ skipping 208 matching lines @@
                 SyncGetIssuersOf(oldintermediate_.get(), _));
     EXPECT_CALL(cert_issuer_source,
                 AsyncGetIssuersOf(oldintermediate_.get(), _, _));
   }
   target_issuers_callback.Run(target_issuers_req);
   ::testing::Mock::VerifyAndClearExpectations(target_issuers_req);
   ::testing::Mock::VerifyAndClearExpectations(&cert_issuer_source);
 
   // Second async batch: return a different copy of oldintermediate_ again.
   scoped_refptr<ParsedCertificate> oldintermediate_dupe(
-      ParsedCertificate::CreateFromCertificateCopy(
-          oldintermediate_->der_cert().AsStringPiece(), {}));
+      ParsedCertificate::Create(oldintermediate_->der_cert().AsStringPiece(),
+                                {}, nullptr));
   EXPECT_CALL(*target_issuers_req, GetNext(_))
       .WillOnce(DoAll(SetArgPointee<0>(oldintermediate_dupe),
                       Return(CompletionStatus::SYNC)))
       .WillOnce(
           DoAll(SetArgPointee<0>(nullptr), Return(CompletionStatus::ASYNC)));
   target_issuers_callback.Run(target_issuers_req);
   // oldintermediate was already processed above, it should not generate any
   // more requests.
   ::testing::Mock::VerifyAndClearExpectations(target_issuers_req);
   ::testing::Mock::VerifyAndClearExpectations(&cert_issuer_source);
@@ skipping 36 matching lines @@
   const auto& path1 = result.paths[1]->path;
   ASSERT_EQ(2U, path1.certs.size());
   EXPECT_EQ(target_, path1.certs[0]);
   EXPECT_EQ(newintermediate_, path1.certs[1]);
   EXPECT_EQ(newroot_, path1.trust_anchor->cert());
 }
 
 }  // namespace
 
 }  // namespace net