Convert scoped_ptr_malloc -> scoped_ptr, part 2.

net/cert/cert_verify_proc_win.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/cert_verify_proc_win.h"
 
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 43 matching lines @@
 struct FreeCertContextFunctor {
   void operator()(PCCERT_CONTEXT context) const {
     if (context)
       CertFreeCertificateContext(context);
   }
 };
 
 typedef crypto::ScopedCAPIHandle<HCERTCHAINENGINE, FreeChainEngineFunctor>
     ScopedHCERTCHAINENGINE;
 
-typedef scoped_ptr_malloc<const CERT_CHAIN_CONTEXT,
-                          FreeCertChainContextFunctor>
+typedef scoped_ptr<const CERT_CHAIN_CONTEXT, FreeCertChainContextFunctor>
     ScopedPCCERT_CHAIN_CONTEXT;
 
-typedef scoped_ptr_malloc<const CERT_CONTEXT,
-                          FreeCertContextFunctor> ScopedPCCERT_CONTEXT;
+typedef scoped_ptr<const CERT_CONTEXT, FreeCertContextFunctor>
+    ScopedPCCERT_CONTEXT;
 
 //-----------------------------------------------------------------------------
 
 int MapSecurityError(SECURITY_STATUS err) {
   // There are numerous security error codes, but these are the ones we thus
   // far find interesting.
   switch (err) {
     case SEC_E_WRONG_PRINCIPAL:  // Schannel
     case CERT_E_CN_NO_MATCH:  // CryptoAPI
       return ERR_CERT_COMMON_NAME_INVALID;
@@ skipping 113 matching lines @@
   BOOL rv;
   rv = CryptDecodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
                            X509_NAME,
                            cert->pCertInfo->Subject.pbData,
                            cert->pCertInfo->Subject.cbData,
                            CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG,
                            &decode_para,
                            &name_info,
                            &name_info_size);
   if (rv) {
-    scoped_ptr_malloc<CERT_NAME_INFO> scoped_name_info(name_info);
+    scoped_ptr<CERT_NAME_INFO, base::FreeDeleter> scoped_name_info(name_info);
 
     // The Subject field may have multiple common names.  According to the
     // "PKI Layer Cake" paper, CryptoAPI uses every common name in the
     // Subject field, so we inspect every common name.
     //
     // From RFC 5280:
     // X520CommonName ::= CHOICE {
     //       teletexString     TeletexString   (SIZE (1..ub-common-name)),
     //       printableString   PrintableString (SIZE (1..ub-common-name)),
     //       universalString   UniversalString (SIZE (1..ub-common-name)),
@@ skipping 128 matching lines @@
     // Add the root certificate, if present, as it was not added above.
     if (has_root_ca)
       verified_chain.push_back(element[num_elements]->pCertContext);
     verify_result->verified_cert =
           X509Certificate::CreateFromHandle(verified_cert, verified_chain);
   }
 }
 
 // Decodes the cert's certificatePolicies extension into a CERT_POLICIES_INFO
 // structure and stores it in *output.
-void GetCertPoliciesInfo(PCCERT_CONTEXT cert,
-                         scoped_ptr_malloc<CERT_POLICIES_INFO>* output) {
+void GetCertPoliciesInfo(
+    PCCERT_CONTEXT cert,
+    scoped_ptr<CERT_POLICIES_INFO, base::FreeDeleter>* output) {
   PCERT_EXTENSION extension = CertFindExtension(szOID_CERT_POLICIES,
                                                 cert->pCertInfo->cExtension,
                                                 cert->pCertInfo->rgExtension);
   if (!extension)
     return;
 
   CRYPT_DECODE_PARA decode_para;
   decode_para.cbSize = sizeof(decode_para);
   decode_para.pfnAlloc = crypto::CryptAlloc;
   decode_para.pfnFree = crypto::CryptFree;
@@ skipping 199 matching lines @@
     szOID_PKIX_KP_SERVER_AUTH,
     szOID_SERVER_GATED_CRYPTO,
     szOID_SGC_NETSCAPE
   };
   chain_para.RequestedUsage.dwType = USAGE_MATCH_TYPE_OR;
   chain_para.RequestedUsage.Usage.cUsageIdentifier = arraysize(usage);
   chain_para.RequestedUsage.Usage.rgpszUsageIdentifier =
       const_cast<LPSTR*>(usage);
 
   // Get the certificatePolicies extension of the certificate.
-  scoped_ptr_malloc<CERT_POLICIES_INFO> policies_info;
+  scoped_ptr<CERT_POLICIES_INFO, base::FreeDeleter> policies_info;
   LPSTR ev_policy_oid = NULL;
   if (flags & CertVerifier::VERIFY_EV_CERT) {
     GetCertPoliciesInfo(cert_handle, &policies_info);
     if (policies_info.get()) {
       EVRootCAMetadata* metadata = EVRootCAMetadata::GetInstance();
       for (DWORD i = 0; i < policies_info->cPolicyInfo; ++i) {
         LPSTR policy_oid = policies_info->rgPolicyInfo[i].pszPolicyIdentifier;
         if (metadata->IsEVPolicyOID(policy_oid)) {
           ev_policy_oid = policy_oid;
           chain_para.RequestedIssuancePolicy.dwType = USAGE_MATCH_TYPE_AND;
@@ skipping 200 matching lines @@
     return MapCertStatusToNetError(verify_result->cert_status);
 
   if (ev_policy_oid &&
       CheckEV(chain_context, rev_checking_enabled, ev_policy_oid)) {
     verify_result->cert_status |= CERT_STATUS_IS_EV;
   }
   return OK;
 }
 
 }  // namespace net