Refactor der::Input helper methods into new constructors

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"
@@ skipping 29 matching lines @@
     return std::string();
   }
 
   return file_data;
 }
 
 // Adds the certificate |cert_der| as a trust anchor to |trust_store|.
 void AddCertificateToTrustStore(const std::string& cert_der,
                                 TrustStore* trust_store) {
   ParsedCertificate cert;
-  ASSERT_TRUE(ParseCertificate(InputFromString(&cert_der), &cert));
+  ASSERT_TRUE(ParseCertificate(der::Input(&cert_der), &cert));
 
   ParsedTbsCertificate tbs;
   ASSERT_TRUE(ParseTbsCertificate(cert.tbs_certificate_tlv, &tbs));
   TrustAnchor anchor = {tbs.spki_tlv.AsString(), tbs.subject_tlv.AsString()};
   trust_store->anchors.push_back(anchor);
 }
 
 // Reads a test case from |file_name|. Test cases are comprised of a
 // certificate chain, trust store, a timestamp to validate at, and the
 // expected result of verification.
@@ skipping 27 matching lines @@
     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) {
       AddCertificateToTrustStore(block_data, trust_store);
     } else if (block_type == kTimeHeader) {
       ASSERT_FALSE(has_time) << "Duplicate " << kTimeHeader;
       has_time = true;
-      ASSERT_TRUE(der::ParseUTCTime(InputFromString(&block_data), time));
+      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(InputFromString(&cert_str));
+    input_chain.push_back(der::Input(&cert_str));
 
   SimpleSignaturePolicy signature_policy(1024);
 
   bool result =
       VerifyCertificateChain(input_chain, trust_store, &signature_policy, time);
 
   ASSERT_EQ(expected_result, result);
 }
 
 TEST(VerifyCertificateChainTest, TargetAndIntermediary) {
@@ skipping 104 matching lines @@
 }
 
 // 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
 
 #endif