Replace wrapUnique(new T(args)) by makeUnique<T>(args) in Blink

third_party/WebKit/Source/modules/crypto/NormalizeAlgorithm.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 513 matching lines @@
 //      [EnforceRange] required unsigned short length;
 //    };
 bool parseAesKeyGenParams(const Dictionary& raw,
                           std::unique_ptr<WebCryptoAlgorithmParams>& params,
                           const ErrorContext& context,
                           AlgorithmError* error) {
   uint16_t length;
   if (!getUint16(raw, "length", length, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoAesKeyGenParams(length));
+  params = makeUnique<WebCryptoAesKeyGenParams>(length);
   return true;
 }
 
 bool parseAlgorithmIdentifier(const AlgorithmIdentifier&,
                               WebCryptoOperation,
                               WebCryptoAlgorithm&,
                               ErrorContext,
                               AlgorithmError*);
 
 bool parseHash(const Dictionary& raw,
@@ skipping 21 matching lines @@
                            AlgorithmError* error) {
   WebCryptoAlgorithm hash;
   if (!parseHash(raw, hash, context, error))
     return false;
 
   bool hasLength;
   uint32_t length = 0;
   if (!getOptionalUint32(raw, "length", hasLength, length, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoHmacImportParams(hash, hasLength, length));
+  params = makeUnique<WebCryptoHmacImportParams>(hash, hasLength, length);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary HmacKeyGenParams : Algorithm {
 //      required HashAlgorithmIdentifier hash;
 //      [EnforceRange] unsigned long length;
 //    };
 bool parseHmacKeyGenParams(const Dictionary& raw,
                            std::unique_ptr<WebCryptoAlgorithmParams>& params,
                            const ErrorContext& context,
                            AlgorithmError* error) {
   WebCryptoAlgorithm hash;
   if (!parseHash(raw, hash, context, error))
     return false;
 
   bool hasLength;
   uint32_t length = 0;
   if (!getOptionalUint32(raw, "length", hasLength, length, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoHmacKeyGenParams(hash, hasLength, length));
+  params = makeUnique<WebCryptoHmacKeyGenParams>(hash, hasLength, length);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary RsaHashedImportParams : Algorithm {
 //      required HashAlgorithmIdentifier hash;
 //    };
 bool parseRsaHashedImportParams(
     const Dictionary& raw,
     std::unique_ptr<WebCryptoAlgorithmParams>& params,
     const ErrorContext& context,
     AlgorithmError* error) {
   WebCryptoAlgorithm hash;
   if (!parseHash(raw, hash, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoRsaHashedImportParams(hash));
+  params = makeUnique<WebCryptoRsaHashedImportParams>(hash);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary RsaKeyGenParams : Algorithm {
 //      [EnforceRange] required unsigned long modulusLength;
 //      required BigInteger publicExponent;
 //    };
 //
@@ skipping 101 matching lines @@
 //       [EnforceRange] required unsigned long saltLength;
 //     };
 bool parseRsaPssParams(const Dictionary& raw,
                        std::unique_ptr<WebCryptoAlgorithmParams>& params,
                        const ErrorContext& context,
                        AlgorithmError* error) {
   uint32_t saltLengthBytes;
   if (!getUint32(raw, "saltLength", saltLengthBytes, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoRsaPssParams(saltLengthBytes));
+  params = makeUnique<WebCryptoRsaPssParams>(saltLengthBytes);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary EcdsaParams : Algorithm {
 //       required HashAlgorithmIdentifier hash;
 //     };
 bool parseEcdsaParams(const Dictionary& raw,
                       std::unique_ptr<WebCryptoAlgorithmParams>& params,
                       const ErrorContext& context,
                       AlgorithmError* error) {
   WebCryptoAlgorithm hash;
   if (!parseHash(raw, hash, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoEcdsaParams(hash));
+  params = makeUnique<WebCryptoEcdsaParams>(hash);
   return true;
 }
 
 struct CurveNameMapping {
   const char* const name;
   WebCryptoNamedCurve value;
 };
 
 const CurveNameMapping curveNameMappings[] = {
     {"P-256", WebCryptoNamedCurveP256},
@@ skipping 33 matching lines @@
 //       required NamedCurve namedCurve;
 //     };
 bool parseEcKeyGenParams(const Dictionary& raw,
                          std::unique_ptr<WebCryptoAlgorithmParams>& params,
                          const ErrorContext& context,
                          AlgorithmError* error) {
   WebCryptoNamedCurve namedCurve;
   if (!parseNamedCurve(raw, namedCurve, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoEcKeyGenParams(namedCurve));
+  params = makeUnique<WebCryptoEcKeyGenParams>(namedCurve);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary EcKeyImportParams : Algorithm {
 //       required NamedCurve namedCurve;
 //     };
 bool parseEcKeyImportParams(const Dictionary& raw,
                             std::unique_ptr<WebCryptoAlgorithmParams>& params,
                             const ErrorContext& context,
                             AlgorithmError* error) {
   WebCryptoNamedCurve namedCurve;
   if (!parseNamedCurve(raw, namedCurve, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoEcKeyImportParams(namedCurve));
+  params = makeUnique<WebCryptoEcKeyImportParams>(namedCurve);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary EcdhKeyDeriveParams : Algorithm {
 //       required CryptoKey public;
 //     };
 bool parseEcdhKeyDeriveParams(const Dictionary& raw,
                               std::unique_ptr<WebCryptoAlgorithmParams>& params,
@@ skipping 50 matching lines @@
 //      [EnforceRange] required unsigned short length;
 //    };
 bool parseAesDerivedKeyParams(const Dictionary& raw,
                               std::unique_ptr<WebCryptoAlgorithmParams>& params,
                               const ErrorContext& context,
                               AlgorithmError* error) {
   uint16_t length;
   if (!getUint16(raw, "length", length, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoAesDerivedKeyParams(length));
+  params = makeUnique<WebCryptoAesDerivedKeyParams>(length);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary HkdfParams : Algorithm {
 //      required HashAlgorithmIdentifier hash;
 //      required BufferSource salt;
 //      required BufferSource info;
 //    };
@@ skipping 182 matching lines @@
 }  // namespace
 
 bool normalizeAlgorithm(const AlgorithmIdentifier& raw,
                         WebCryptoOperation op,
                         WebCryptoAlgorithm& algorithm,
                         AlgorithmError* error) {
   return parseAlgorithmIdentifier(raw, op, algorithm, ErrorContext(), error);
 }
 
 }  // namespace blink