Convert crypto::ScopedOpenSSL to type aliases.

chrome/common/net/x509_certificate_model_openssl.cc

 // Copyright (c) 2011 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 "chrome/common/net/x509_certificate_model.h"
 
 #include <openssl/obj_mac.h>
 #include <openssl/sha.h>
 #include <openssl/stack.h>
 #include <openssl/x509.h>
@@ skipping 447 matching lines @@
   static const MaskIdPair usage_string_map[] = {
       {NS_SSL_CLIENT, IDS_CERT_USAGE_SSL_CLIENT},
       {NS_SSL_SERVER, IDS_CERT_USAGE_SSL_SERVER},
       {NS_SMIME, IDS_CERT_EXT_NS_CERT_TYPE_EMAIL},
       {NS_OBJSIGN, IDS_CERT_USAGE_OBJECT_SIGNER},
       {NS_SSL_CA, IDS_CERT_USAGE_SSL_CA},
       {NS_SMIME_CA, IDS_CERT_EXT_NS_CERT_TYPE_EMAIL_CA},
       {NS_OBJSIGN_CA, IDS_CERT_USAGE_OBJECT_SIGNER},
   };
 
-  crypto::ScopedOpenSSL<ASN1_BIT_STRING, ASN1_BIT_STRING_free>::Type value(
+  crypto::ScopedOpenSSL<ASN1_BIT_STRING, ASN1_BIT_STRING_free> value(
       reinterpret_cast<ASN1_BIT_STRING*>(X509V3_EXT_d2i(ex)));
   if (!value.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
   return ProcessBitField(value.get(),
                          usage_string_map,
                          arraysize(usage_string_map),
                          '\n');
 }
 
 std::string ProcessKeyUsageExtension(X509_EXTENSION* ex) {
   static const MaskIdPair key_usage_string_map[] = {
       {KU_DIGITAL_SIGNATURE, IDS_CERT_X509_KEY_USAGE_SIGNING},
       {KU_NON_REPUDIATION, IDS_CERT_X509_KEY_USAGE_NONREP},
       {KU_KEY_ENCIPHERMENT, IDS_CERT_X509_KEY_USAGE_ENCIPHERMENT},
       {KU_DATA_ENCIPHERMENT, IDS_CERT_X509_KEY_USAGE_DATA_ENCIPHERMENT},
       {KU_KEY_AGREEMENT, IDS_CERT_X509_KEY_USAGE_KEY_AGREEMENT},
       {KU_KEY_CERT_SIGN, IDS_CERT_X509_KEY_USAGE_CERT_SIGNER},
       {KU_CRL_SIGN, IDS_CERT_X509_KEY_USAGE_CRL_SIGNER},
       {KU_ENCIPHER_ONLY, IDS_CERT_X509_KEY_USAGE_ENCIPHER_ONLY},
       {KU_DECIPHER_ONLY, IDS_CERT_X509_KEY_USAGE_DECIPHER_ONLY},
   };
 
-  crypto::ScopedOpenSSL<ASN1_BIT_STRING, ASN1_BIT_STRING_free>::Type value(
+  crypto::ScopedOpenSSL<ASN1_BIT_STRING, ASN1_BIT_STRING_free> value(
       reinterpret_cast<ASN1_BIT_STRING*>(X509V3_EXT_d2i(ex)));
   if (!value.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
   return ProcessBitField(value.get(),
                          key_usage_string_map,
                          arraysize(key_usage_string_map),
                          '\n');
 }
 
 std::string ProcessBasicConstraints(X509_EXTENSION* ex) {
   std::string rv;
-  crypto::ScopedOpenSSL<BASIC_CONSTRAINTS, BASIC_CONSTRAINTS_free>::Type value(
+  crypto::ScopedOpenSSL<BASIC_CONSTRAINTS, BASIC_CONSTRAINTS_free> value(
       reinterpret_cast<BASIC_CONSTRAINTS*>(X509V3_EXT_d2i(ex)));
   if (!value.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
   if (value.get()->ca)
     rv = l10n_util::GetStringUTF8(IDS_CERT_X509_BASIC_CONSTRAINT_IS_CA);
   else
     rv = l10n_util::GetStringUTF8(IDS_CERT_X509_BASIC_CONSTRAINT_IS_NOT_CA);
   rv += '\n';
   if (value.get()->ca) {
     base::string16 depth;
     if (!value.get()->pathlen) {
       depth = l10n_util::GetStringUTF16(
           IDS_CERT_X509_BASIC_CONSTRAINT_PATH_LEN_UNLIMITED);
     } else {
       depth = base::FormatNumber(ASN1_INTEGER_get(value.get()->pathlen));
     }
     rv += l10n_util::GetStringFUTF8(IDS_CERT_X509_BASIC_CONSTRAINT_PATH_LEN,
                                     depth);
   }
   return rv;
 }
 
 std::string ProcessExtKeyUsage(X509_EXTENSION* ex) {
   std::string rv;
-  crypto::ScopedOpenSSL<EXTENDED_KEY_USAGE, EXTENDED_KEY_USAGE_free>::Type
-      value(reinterpret_cast<EXTENDED_KEY_USAGE*>(X509V3_EXT_d2i(ex)));
+  crypto::ScopedOpenSSL<EXTENDED_KEY_USAGE, EXTENDED_KEY_USAGE_free> value(
+      reinterpret_cast<EXTENDED_KEY_USAGE*>(X509V3_EXT_d2i(ex)));
   if (!value.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
   for (size_t i = 0; i < sk_ASN1_OBJECT_num(value.get()); i++) {
     ASN1_OBJECT* obj = sk_ASN1_OBJECT_value(value.get(), i);
     std::string oid_dump = Asn1ObjectToOIDString(obj);
     std::string oid_text = Asn1ObjectToString(obj);
 
     // If oid is one we recognize, oid_text will have a text description of the
     // OID, which we display along with the oid_dump.  If we don't recognize the
     // OID, they will be the same, so just display the OID alone.
@@ skipping 127 matching lines @@
 std::string ProcessGeneralNames(GENERAL_NAMES* names) {
   std::string rv;
   for (size_t i = 0; i < sk_GENERAL_NAME_num(names); ++i) {
     GENERAL_NAME* name = sk_GENERAL_NAME_value(names, i);
     rv += ProcessGeneralName(name);
   }
   return rv;
 }
 
 std::string ProcessAltName(X509_EXTENSION* ex) {
-  crypto::ScopedOpenSSL<GENERAL_NAMES, GENERAL_NAMES_free>::Type alt_names(
+  crypto::ScopedOpenSSL<GENERAL_NAMES, GENERAL_NAMES_free> alt_names(
       reinterpret_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(ex)));
   if (!alt_names.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   return ProcessGeneralNames(alt_names.get());
 }
 
 std::string ProcessSubjectKeyId(X509_EXTENSION* ex) {
-  crypto::ScopedOpenSSL<ASN1_OCTET_STRING, ASN1_OCTET_STRING_free>::Type value(
+  crypto::ScopedOpenSSL<ASN1_OCTET_STRING, ASN1_OCTET_STRING_free> value(
       reinterpret_cast<ASN1_OCTET_STRING*>(X509V3_EXT_d2i(ex)));
   if (!value.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   return l10n_util::GetStringFUTF8(
       IDS_CERT_KEYID_FORMAT,
       base::ASCIIToUTF16(ProcessRawAsn1String(value.get())));
 }
 
 std::string ProcessAuthKeyId(X509_EXTENSION* ex) {
   std::string rv;
-  crypto::ScopedOpenSSL<AUTHORITY_KEYID, AUTHORITY_KEYID_free>::Type value(
+  crypto::ScopedOpenSSL<AUTHORITY_KEYID, AUTHORITY_KEYID_free> value(
       reinterpret_cast<AUTHORITY_KEYID*>(X509V3_EXT_d2i(ex)));
   if (!value.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   if (value.get()->keyid && ASN1_STRING_length(value.get()->keyid) > 0) {
     rv += l10n_util::GetStringFUTF8(
         IDS_CERT_KEYID_FORMAT,
         base::ASCIIToUTF16(ProcessRawAsn1String(value.get()->keyid)));
     rv += '\n';
   }
@@ skipping 35 matching lines @@
   }
   if (notice->exptext && notice->exptext->length != 0) {
     rv += "\n    ";
     rv += Asn1StringToUTF8(notice->exptext);
   }
   return rv;
 }
 
 std::string ProcessCertificatePolicies(X509_EXTENSION* ex) {
   std::string rv;
-  crypto::ScopedOpenSSL<CERTIFICATEPOLICIES, CERTIFICATEPOLICIES_free>::Type
-      policies(reinterpret_cast<CERTIFICATEPOLICIES*>(X509V3_EXT_d2i(ex)));
+  crypto::ScopedOpenSSL<CERTIFICATEPOLICIES, CERTIFICATEPOLICIES_free> policies(
+      reinterpret_cast<CERTIFICATEPOLICIES*>(X509V3_EXT_d2i(ex)));
 
   if (!policies.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   for (size_t i = 0; i < sk_POLICYINFO_num(policies.get()); ++i) {
     POLICYINFO* info = sk_POLICYINFO_value(policies.get(), i);
     std::string key = Asn1ObjectToString(info->policyid);
     // If we have policy qualifiers, display the oid text
     // with a ':', otherwise just put the oid text and a newline.
     if (info->qualifiers && sk_POLICYQUALINFO_num(info->qualifiers)) {
@@ skipping 49 matching lines @@
       {6, IDS_CERT_REVOCATION_REASON_CERTIFICATE_HOLD},
       {7, IDS_CERT_REVOCATION_REASON_PRIVILEGE_WITHDRAWN},
       {8, IDS_CERT_REVOCATION_REASON_AA_COMPROMISE},
   };
   // OpenSSL doesn't define constants for the DIST_POINT type field. These
   // values are from reading openssl/crypto/x509v3/v3_crld.c
   const int kDistPointFullName = 0;
   const int kDistPointRelativeName = 1;
 
   std::string rv;
-  crypto::ScopedOpenSSL<CRL_DIST_POINTS, CRL_DIST_POINTS_free>::Type
-      dist_points(reinterpret_cast<CRL_DIST_POINTS*>(X509V3_EXT_d2i(ex)));
+  crypto::ScopedOpenSSL<CRL_DIST_POINTS, CRL_DIST_POINTS_free> dist_points(
+      reinterpret_cast<CRL_DIST_POINTS*>(X509V3_EXT_d2i(ex)));
 
   if (!dist_points.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   for (size_t i = 0; i < sk_DIST_POINT_num(dist_points.get()); ++i) {
     DIST_POINT* point = sk_DIST_POINT_value(dist_points.get(), i);
     if (point->distpoint) {
       switch (point->distpoint->type) {
         case kDistPointFullName:
           rv += ProcessGeneralNames(point->distpoint->name.fullname);
@@ skipping 19 matching lines @@
           IDS_CERT_ISSUER_FORMAT,
           base::UTF8ToUTF16(ProcessGeneralNames(point->CRLissuer)));
     }
   }
 
   return rv;
 }
 
 std::string ProcessAuthInfoAccess(X509_EXTENSION* ex) {
   std::string rv;
-  crypto::ScopedOpenSSL<AUTHORITY_INFO_ACCESS, AUTHORITY_INFO_ACCESS_free>::Type
-      aia(reinterpret_cast<AUTHORITY_INFO_ACCESS*>(X509V3_EXT_d2i(ex)));
+  crypto::ScopedOpenSSL<AUTHORITY_INFO_ACCESS, AUTHORITY_INFO_ACCESS_free> aia(
+      reinterpret_cast<AUTHORITY_INFO_ACCESS*>(X509V3_EXT_d2i(ex)));
 
   if (!aia.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   for (size_t i = 0; i < sk_ACCESS_DESCRIPTION_num(aia.get()); ++i) {
     ACCESS_DESCRIPTION* desc = sk_ACCESS_DESCRIPTION_value(aia.get(), i);
 
     base::string16 location_str =
         base::UTF8ToUTF16(ProcessGeneralName(desc->location));
     switch (OBJ_obj2nid(desc->method)) {
@@ skipping 11 matching lines @@
             base::UTF8ToUTF16(Asn1ObjectToString(desc->method)),
             location_str);
         break;
     }
   }
   return rv;
 }
 
 std::string ProcessIA5StringData(ASN1_OCTET_STRING* asn1_string) {
   const unsigned char* data = ASN1_STRING_data(asn1_string);
-  crypto::ScopedOpenSSL<ASN1_IA5STRING, ASN1_IA5STRING_free>::Type ia5_string(
+  crypto::ScopedOpenSSL<ASN1_IA5STRING, ASN1_IA5STRING_free> ia5_string(
       d2i_ASN1_IA5STRING(NULL, &data, ASN1_STRING_length(asn1_string)));
 
   if (!ia5_string.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   return std::string(
       reinterpret_cast<char*>(ASN1_STRING_data(ia5_string.get())),
       ASN1_STRING_length(ia5_string.get()));
 }
 
 std::string ProcessBMPStringData(ASN1_OCTET_STRING* asn1_string) {
   const unsigned char* data = ASN1_STRING_data(asn1_string);
-  crypto::ScopedOpenSSL<ASN1_BMPSTRING, ASN1_BMPSTRING_free>::Type bmp_string(
+  crypto::ScopedOpenSSL<ASN1_BMPSTRING, ASN1_BMPSTRING_free> bmp_string(
       d2i_ASN1_BMPSTRING(NULL, &data, ASN1_STRING_length(asn1_string)));
 
   if (!bmp_string.get())
     return l10n_util::GetStringUTF8(IDS_CERT_EXTENSION_DUMP_ERROR);
 
   return Asn1StringToUTF8(bmp_string.get());
 }
 
 std::string X509ExtensionValueToString(X509_EXTENSION* ex) {
   g_dynamic_oid_registerer.Get();
@@ skipping 280 matching lines @@
       return rv;
   }
 }
 
 std::string ProcessRawBitsSignatureWrap(
     net::X509Certificate::OSCertHandle cert_handle) {
   return ProcessRawAsn1String(cert_handle->signature);
 }
 
 }  // namespace x509_certificate_model