Re-write many calls to WrapUnique() with MakeUnique()

components/cast_certificate/cast_crl.cc

 // Copyright 2016 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 "components/cast_certificate/cast_crl.h"
 
 #include <unordered_map>
 #include <unordered_set>
 
 #include "base/base64.h"
@@ skipping 74 matching lines @@
       base::Time::UnixEpoch() +
       base::TimeDelta::FromSeconds(base::saturated_cast<int64_t>(seconds));
   return net::der::EncodeTimeAsGeneralizedTime(unix_timestamp,
                                                generalized_time);
 }
 
 // Specifies the signature verification policy.
 // The required algorithms are:
 // RSASSA PKCS#1 v1.5 with SHA-256, using RSA keys 2048-bits or longer.
 std::unique_ptr<net::SignaturePolicy> CreateCastSignaturePolicy() {
-  return base::WrapUnique(new net::SimpleSignaturePolicy(2048));
+  return base::MakeUnique<net::SimpleSignaturePolicy>(2048);
 }
 
 // Verifies the CRL is signed by a trusted CRL authority at the time the CRL
 // was issued. Verifies the signature of |tbs_crl| is valid based on the
 // certificate and signature in |crl|. The validity of |tbs_crl| is verified
 // at |time|. The validity period of the CRL is adjusted to be the earliest
 // of the issuer certificate chain's expiration and the CRL's expiration and
 // the result is stored in |overall_not_after|.
 bool VerifyCRL(const Crl& crl,
                const TbsCrl& tbs_crl,
@@ skipping 225 matching lines @@
       continue;
     }
     if (tbs_crl.version() != CRL_VERSION_0) {
       continue;
     }
     net::der::GeneralizedTime overall_not_after;
     if (!VerifyCRL(crl, tbs_crl, time, trust_store, &overall_not_after)) {
       LOG(ERROR) << "CRL - Verification failed.";
       return nullptr;
     }
-    return base::WrapUnique(new CastCRLImpl(tbs_crl, overall_not_after));
+    return base::MakeUnique<CastCRLImpl>(tbs_crl, overall_not_after);
   }
   LOG(ERROR) << "No supported version of revocation data.";
   return nullptr;
 }
 
 }  // namespace
 
 std::unique_ptr<CastCRL> ParseAndVerifyCRL(const std::string& crl_proto,
                                            const base::Time& time) {
   return ParseAndVerifyCRL(crl_proto, time, &CastCRLTrustStore::Get());
 }
 
 std::unique_ptr<CastCRL> ParseAndVerifyCRLForTest(
     const std::string& crl_proto,
     const base::Time& time,
     net::TrustStore* trust_store) {
   return ParseAndVerifyCRL(crl_proto, time, trust_store);
 }
 
 }  // namespace cast_certificate