Refactor der::Input helper methods into new constructors

net/cert/internal/verify_certificate_chain.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/logging.h"
 #include "net/cert/internal/parse_certificate.h"
 #include "net/cert/internal/signature_algorithm.h"
 #include "net/cert/internal/signature_policy.h"
 #include "net/cert/internal/verify_name_match.h"
 #include "net/cert/internal/verify_signed_data.h"
 #include "net/der/input.h"
 #include "net/der/parser.h"
 
 namespace net {
 
 namespace {
 
-// TODO(eroman): Move into net/der (duplicated from test_helpers.cc).
-static der::Input InputFromString(const std::string* s) {
-  return der::Input(reinterpret_cast<const uint8_t*>(s->data()), s->size());
-}
-
 // Map from OID to ParsedExtension.
 using ExtensionsMap = std::map<der::Input, ParsedExtension>;
 
 // Describes all parsed properties of a certificate that are relevant for
 // certificate verification.
 struct FullyParsedCert {
   ParsedCertificate cert;
   ParsedTbsCertificate tbs;
 
   scoped_ptr<SignatureAlgorithm> signature_algorithm;
@@ skipping 135 matching lines @@
 //
 // TODO(eroman): This implementation is linear in the size of the trust store,
 // and also presumes that all names are unique. In practice it is possible to
 // have multiple SPKIs with the same name. Also this mechanism of
 // searching is fairly primitive, and does not take advantage of other
 // properties like the authority key id.
 WARN_UNUSED_RESULT const TrustAnchor* FindTrustAnchorByName(
     const TrustStore& trust_store,
     const der::Input& name) {
   for (const auto& anchor : trust_store.anchors) {
-    if (NameMatches(name, InputFromString(&anchor.name)))
+    if (NameMatches(name, der::Input(&anchor.name)))
       return &anchor;
   }
   return nullptr;
 }
 
 // Returns true if |cert| is valid at time |time|.
 //
 // The certificate's validity requirements are described by RFC 5280 section
 // 4.1.2.5:
 //
@@ skipping 321 matching lines @@
 
     // When processing the first certificate, initialize |working_spki|
     // and |working_issuer_name| to the trust anchor per RFC 5280 section 6.1.2.
     // This is done inside the loop in order to have access to the parsed
     // certificate.
     if (i == 0) {
       const TrustAnchor* trust_anchor =
           FindTrustAnchorByName(trust_store, cert.tbs.issuer_tlv);
       if (!trust_anchor)
         return false;
-      working_spki = InputFromString(&trust_anchor->spki);
-      working_issuer_name = InputFromString(&trust_anchor->name);
+      working_spki = der::Input(&trust_anchor->spki);
+      working_issuer_name = der::Input(&trust_anchor->name);
     }
 
     // Per RFC 5280 section 6.1:
     //  * Do basic processing for each certificate
     //  * If it is the last certificate in the path (target certificate)
     //     - Then run "Wrap up"
     //     - Otherwise run "Prepare for Next cert"
     if (!BasicCertificateProcessing(cert, signature_policy, time, working_spki,
                                     working_issuer_name)) {
       return false;
@@ skipping 11 matching lines @@
 
   // TODO(eroman): RFC 5280 forbids duplicate certificates per section 6.1:
   //
   //    A certificate MUST NOT appear more than once in a prospective
   //    certification path.
 
   return true;
 }
 
 }  // namespace net