Refactor der::Input helper methods into new constructors

net/cert/asn1_util.cc

 // Copyright (c) 2012 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/asn1_util.h"
 
 #include "net/der/input.h"
 #include "net/der/parser.h"
 
 namespace net {
@@ skipping 52 matching lines @@
     return false;
   // validity
   if (!tbs_certificate->SkipTag(der::kSequence))
     return false;
   // subject
   if (!tbs_certificate->SkipTag(der::kSequence))
     return false;
   return true;
 }
 
-der::Input InputFromStringPiece(base::StringPiece in) {
-  return der::Input(reinterpret_cast<const uint8_t*>(in.data()), in.length());
-}
-
-base::StringPiece StringPieceFromInput(der::Input in) {
-  return base::StringPiece(reinterpret_cast<const char*>(in.UnsafeData()),
-                           in.Length());
-}
-
 }  // namespace
 
 bool ExtractSPKIFromDERCert(base::StringPiece cert,
                             base::StringPiece* spki_out) {
   der::Parser parser;
-  if (!SeekToSPKI(InputFromStringPiece(cert), &parser))
+  if (!SeekToSPKI(der::Input(cert), &parser))
     return false;
   der::Input spki;
   if (!parser.ReadRawTLV(&spki))
     return false;
-  *spki_out = StringPieceFromInput(spki);
+  *spki_out = spki.AsStringPiece();
   return true;
 }
 
 bool ExtractSubjectPublicKeyFromSPKI(base::StringPiece spki,
                                      base::StringPiece* spk_out) {
   // From RFC 5280, Section 4.1
   //   SubjectPublicKeyInfo  ::=  SEQUENCE  {
   //     algorithm            AlgorithmIdentifier,
   //     subjectPublicKey     BIT STRING  }
   //
   //   AlgorithmIdentifier  ::=  SEQUENCE  {
   //     algorithm               OBJECT IDENTIFIER,
   //     parameters              ANY DEFINED BY algorithm OPTIONAL  }
 
   // Step into SubjectPublicKeyInfo sequence.
-  der::Parser parser(InputFromStringPiece(spki));
+  der::Parser parser((der::Input(spki)));
   der::Parser spki_parser;
   if (!parser.ReadSequence(&spki_parser))
     return false;
 
   // Step over algorithm field (a SEQUENCE).
   if (!spki_parser.SkipTag(der::kSequence))
     return false;
 
   // Extract the subjectPublicKey field.
   der::Input spk;
   if (!spki_parser.ReadTag(der::kBitString, &spk))
     return false;
-  *spk_out = StringPieceFromInput(spk);
+  *spk_out = spk.AsStringPiece();
   return true;
 }
 
 
 bool ExtractCRLURLsFromDERCert(base::StringPiece cert,
                                std::vector<base::StringPiece>* urls_out) {
   urls_out->clear();
   std::vector<base::StringPiece> tmp_urls_out;
 
   bool present;
   der::Parser tbs_cert_parser;
-  if (!SeekToSPKI(InputFromStringPiece(cert), &tbs_cert_parser))
+  if (!SeekToSPKI(der::Input(cert), &tbs_cert_parser))
     return false;
 
   // From RFC 5280, section 4.1
   // TBSCertificate  ::=  SEQUENCE  {
   //      ...
   //      subjectPublicKeyInfo SubjectPublicKeyInfo,
   //      issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL,
   //      subjectUniqueID [2]  IMPLICIT UniqueIdentifier OPTIONAL,
   //      extensions      [3]  EXPLICIT Extensions OPTIONAL }
 
@@ skipping 130 matching lines @@
       //   ... }
       der::Parser general_names_parser(general_names);
       while (general_names_parser.HasMore()) {
         der::Input url;
         if (!general_names_parser.ReadOptionalTag(der::kTagContextSpecific | 6,
                                                   &url, &present)) {
           return false;
         }
         if (present) {
           // This does not validate that |url| is a valid IA5String.
-          tmp_urls_out.push_back(StringPieceFromInput(url));
+          tmp_urls_out.push_back(url.AsStringPiece());
         } else {
           der::Tag unused_tag;
           der::Input unused_value;
           if (!general_names_parser.ReadTagAndValue(&unused_tag,
                                                     &unused_value)) {
             return false;
           }
         }
       }
     }
   }
 
   urls_out->swap(tmp_urls_out);
   return true;
 }
 
 } // namespace asn1
 
 } // namespace net