Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

extensions/common/cast/cast_cert_validator.cc

 // Copyright 2014 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 "extensions/common/cast/cast_cert_validator.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <algorithm>
+#include <memory>
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "net/cert/internal/certificate_policies.h"
 #include "net/cert/internal/extended_key_usage.h"
 #include "net/cert/internal/parse_certificate.h"
 #include "net/cert/internal/parse_name.h"
 #include "net/cert/internal/signature_algorithm.h"
 #include "net/cert/internal/signature_policy.h"
 #include "net/cert/internal/verify_certificate_chain.h"
 #include "net/cert/internal/verify_signed_data.h"
 #include "net/der/input.h"
@@ skipping 68 matching lines @@
 // The following signature policy specifies which signature algorithms (and key
 // sizes) are acceptable. It is used when verifying a chain of certificates, as
 // well as when verifying digital signature using the target certificate's
 // SPKI.
 //
 // This particular policy allows for:
 //   * ECDSA, RSA-SSA, and RSA-PSS
 //   * Supported EC curves: P-256, P-384, P-521.
 //   * Hashes: All SHA hashes including SHA-1 (despite being known weak).
 //   * RSA keys must have a modulus at least 2048-bits long.
-scoped_ptr<net::SignaturePolicy> CreateCastSignaturePolicy() {
-  return make_scoped_ptr(new net::SimpleSignaturePolicy(2048));
+std::unique_ptr<net::SignaturePolicy> CreateCastSignaturePolicy() {
+  return base::WrapUnique(new net::SimpleSignaturePolicy(2048));
 }
 
 class CertVerificationContextImpl : public CertVerificationContext {
  public:
   // Save a copy of the passed in public key (DER) and common name (text).
   CertVerificationContextImpl(const net::der::Input& spki,
                               const base::StringPiece& common_name)
       : spki_(spki.AsString()), common_name_(common_name.as_string()) {}
 
   bool VerifySignatureOverData(const base::StringPiece& signature,
@@ skipping 52 matching lines @@
 }
 
 // Checks properties on the target certificate.
 //
 //   * The Key Usage must include Digital Signature
 //   * THe Extended Key Usage must includ TLS Client Auth
 //   * May have the policy 1.3.6.1.4.1.11129.2.5.2 to indicate it
 //     is an audio-only device.
 WARN_UNUSED_RESULT bool CheckTargetCertificate(
     const net::der::Input& cert_der,
-    scoped_ptr<CertVerificationContext>* context,
+    std::unique_ptr<CertVerificationContext>* context,
     CastDeviceCertPolicy* policy) {
   // TODO(eroman): Simplify this. The certificate chain verification
   // function already parses this stuff, awkward to re-do it here.
 
   net::ParsedCertificate cert;
   if (!net::ParseCertificate(cert_der, &cert))
     return false;
 
   net::ParsedTbsCertificate tbs;
   if (!net::ParseTbsCertificate(cert.tbs_certificate_tlv, &tbs))
@@ skipping 65 matching lines @@
   result.hours = exploded.hour;
   result.minutes = exploded.minute;
   result.seconds = exploded.second;
   return result;
 }
 
 }  // namespace
 
 bool VerifyDeviceCert(const std::vector<std::string>& certs,
                       const base::Time::Exploded& time,
-                      scoped_ptr<CertVerificationContext>* context,
+                      std::unique_ptr<CertVerificationContext>* context,
                       CastDeviceCertPolicy* policy) {
   // The underlying verification function expects a sequence of
   // der::Input, so wrap the data in it (cheap).
   std::vector<net::der::Input> input_chain;
   for (const auto& cert : certs)
     input_chain.push_back(net::der::Input(&cert));
 
   // Use a signature policy compatible with Cast's PKI.
   auto signature_policy = CreateCastSignaturePolicy();
 
   // Do RFC 5280 compatible certificate verification using the two Cast
   // trust anchors and Cast signature policy.
   if (!net::VerifyCertificateChain(input_chain, CastTrustStore::Get(),
                                    signature_policy.get(),
                                    ConvertExplodedTime(time))) {
     return false;
   }
 
   // Check properties of the leaf certificate (key usage, policy), and construct
   // a CertVerificationContext that uses its public key.
   return CheckTargetCertificate(input_chain[0], context, policy);
 }
 
-scoped_ptr<CertVerificationContext> CertVerificationContextImplForTest(
+std::unique_ptr<CertVerificationContext> CertVerificationContextImplForTest(
     const base::StringPiece& spki) {
   // Use a bogus CommonName, since this is just exposed for testing signature
   // verification by unittests.
-  return make_scoped_ptr(
+  return base::WrapUnique(
       new CertVerificationContextImpl(net::der::Input(spki), "CommonName"));
 }
 
 }  // namespace cast_crypto
 }  // namespace api
 }  // namespace extensions