Add new ParsedCertificate class, move TrustStore to own file.

net/cert/internal/verify_certificate_chain_unittest.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/verify_certificate_chain.h"
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "net/cert/internal/parse_certificate.h"
+#include "net/cert/internal/parsed_certificate.h"
 #include "net/cert/internal/signature_policy.h"
 #include "net/cert/internal/test_helpers.h"
+#include "net/cert/internal/trust_store.h"
 #include "net/cert/pem_tokenizer.h"
 #include "net/der/input.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 // Reads a data file from the unit-test data.
 std::string ReadTestFileToString(const std::string& file_name) {
@@ skipping 42 matching lines @@
   bool has_result = 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) {
       chain->push_back(block_data);
     } else if (block_type == kTrustedCertificateHeader) {
-      ASSERT_TRUE(trust_store->AddTrustedCertificate(block_data));
+      scoped_refptr<ParsedCertificate> cert(
+          ParsedCertificate::CreateFromCertificateCopy(block_data));
+      ASSERT_TRUE(cert);
+      trust_store->AddTrustedCertificate(std::move(cert));
     } 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) {
       ASSERT_FALSE(has_result) << "Duplicate " << kResultHeader;
       ASSERT_TRUE(block_data == "SUCCESS" || block_data == "FAIL")
           << "Unrecognized result: " << block_data;
       has_result = true;
       *verify_result = block_data == "SUCCESS";
     }
   }
 
   ASSERT_TRUE(has_time);
   ASSERT_TRUE(has_result);
 }
 
 void RunTest(const char* file_name) {
   std::vector<std::string> chain;
   TrustStore trust_store;
   der::GeneralizedTime time;
   bool expected_result;
 
   ReadTestFromFile(file_name, &chain, &trust_store, &time, &expected_result);
 
-  std::vector<der::Input> input_chain;
-  for (const auto& cert_str : chain)
-    input_chain.push_back(der::Input(&cert_str));
+  std::vector<scoped_refptr<net::ParsedCertificate>> input_chain;
+  for (const auto& cert_der : chain) {
+    ASSERT_TRUE(net::ParsedCertificate::CreateAndAddToVector(
+        reinterpret_cast<const uint8_t*>(cert_der.data()), cert_der.size(),
+        net::ParsedCertificate::DataSource::EXTERNAL_REFERENCE, &input_chain));
+  }
 
   SimpleSignaturePolicy signature_policy(1024);
 
   bool result =
       VerifyCertificateChain(input_chain, trust_store, &signature_policy, time);
 
   ASSERT_EQ(expected_result, result);
 }
 
 TEST(VerifyCertificateChainTest, TargetAndIntermediary) {
@@ skipping 101 matching lines @@
 }
 
 TEST(VerifyCertificateChainTest, NonSelfSignedRoot) {
   RunTest("non-self-signed-root.pem");
 }
 
 // Tests that verifying a chain with no certificates fails.
 TEST(VerifyCertificateChainTest, EmptyChainIsInvalid) {
   TrustStore trust_store;
   der::GeneralizedTime time;
-  std::vector<der::Input> chain;
+  std::vector<scoped_refptr<ParsedCertificate>> chain;
   SimpleSignaturePolicy signature_policy(2048);
 
   ASSERT_FALSE(
       VerifyCertificateChain(chain, trust_store, &signature_policy, time));
 }
 
 // TODO(eroman): Add test that invalidate validity dates where the day or month
 // ordinal not in range, like "March 39, 2016" are rejected.
 
 }  // namespace
 
 }  // namespace net