Revert "Remove OwnPtr from 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 22 matching lines @@
 #include "bindings/core/v8/ArrayBufferOrArrayBufferView.h"
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/modules/v8/V8CryptoKey.h"
 #include "core/dom/DOMArrayPiece.h"
 #include "core/dom/DOMTypedArray.h"
 #include "public/platform/WebCryptoAlgorithmParams.h"
 #include "public/platform/WebString.h"
 #include "wtf/MathExtras.h"
-#include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringBuilder.h"
 #include <algorithm>
-#include <memory>
 
 namespace blink {
 
 namespace {
 
 typedef ArrayBufferOrArrayBufferView BufferSource;
 
 struct AlgorithmNameMapping {
     // Must be an upper case ASCII string.
     const char* const algorithmName;
@@ skipping 384 matching lines @@
 
     value.setString(algorithmName);
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesCbcParams : Algorithm {
 //      required BufferSource iv;
 //    };
-bool parseAesCbcParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseAesCbcParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     BufferSource ivBufferSource;
     if (!getBufferSource(raw, "iv", ivBufferSource, context, error))
         return false;
 
     DOMArrayPiece iv(ivBufferSource);
 
-    params = wrapUnique(new WebCryptoAesCbcParams(iv.bytes(), iv.byteLength()));
+    params = adoptPtr(new WebCryptoAesCbcParams(iv.bytes(), iv.byteLength()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesKeyGenParams : Algorithm {
 //      [EnforceRange] required unsigned short length;
 //    };
-bool parseAesKeyGenParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseAesKeyGenParams(const Dictionary& raw, OwnPtr<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 = adoptPtr(new WebCryptoAesKeyGenParams(length));
     return true;
 }
 
 bool parseAlgorithmIdentifier(const AlgorithmIdentifier&, WebCryptoOperation, WebCryptoAlgorithm&, ErrorContext, AlgorithmError*);
 
 bool parseHash(const Dictionary& raw, WebCryptoAlgorithm& hash, ErrorContext context, AlgorithmError* error)
 {
     AlgorithmIdentifier rawHash;
     if (!getAlgorithmIdentifier(raw, "hash", rawHash, context, error))
         return false;
 
     context.add("hash");
     return parseAlgorithmIdentifier(rawHash, WebCryptoOperationDigest, hash, context, error);
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary HmacImportParams : Algorithm {
 //      HashAlgorithmIdentifier hash;
 //      [EnforceRange] unsigned long length;
 //    };
 //
 // FIXME: http://crbug.com/438475: The current implementation differs from the
 // spec in that the "hash" parameter is required. This seems more sensible, and
 // is being proposed as a change to the spec. (https://www.w3.org/Bugs/Public/show_bug.cgi?id=27448).
-bool parseHmacImportParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseHmacImportParams(const Dictionary& raw, OwnPtr<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 WebCryptoHmacImportParams(hash, hasLength, length));
+    params = adoptPtr(new 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)
+bool parseHmacKeyGenParams(const Dictionary& raw, OwnPtr<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 = adoptPtr(new 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)
+bool parseRsaHashedImportParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoRsaHashedImportParams(hash));
+    params = adoptPtr(new WebCryptoRsaHashedImportParams(hash));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary RsaKeyGenParams : Algorithm {
 //      [EnforceRange] required unsigned long modulusLength;
 //      required BigInteger publicExponent;
 //    };
 //
 //    dictionary RsaHashedKeyGenParams : RsaKeyGenParams {
 //      required HashAlgorithmIdentifier hash;
 //    };
-bool parseRsaHashedKeyGenParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseRsaHashedKeyGenParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     uint32_t modulusLength;
     if (!getUint32(raw, "modulusLength", modulusLength, context, error))
         return false;
 
     DOMUint8Array* publicExponent = nullptr;
     if (!getBigInteger(raw, "publicExponent", publicExponent, context, error))
         return false;
 
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoRsaHashedKeyGenParams(hash, modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
+    params = adoptPtr(new WebCryptoRsaHashedKeyGenParams(hash, modulusLength, static_cast<const unsigned char*>(publicExponent->baseAddress()), publicExponent->byteLength()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesCtrParams : Algorithm {
 //      required BufferSource counter;
 //      [EnforceRange] required octet length;
 //    };
-bool parseAesCtrParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseAesCtrParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     BufferSource counterBufferSource;
     if (!getBufferSource(raw, "counter", counterBufferSource, context, error))
         return false;
 
     DOMArrayPiece counter(counterBufferSource);
     uint8_t length;
     if (!getUint8(raw, "length", length, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoAesCtrParams(length, counter.bytes(), counter.byteLength()));
+    params = adoptPtr(new WebCryptoAesCtrParams(length, counter.bytes(), counter.byteLength()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary AesGcmParams : Algorithm {
 //       required BufferSource iv;
 //       BufferSource additionalData;
 //       [EnforceRange] octet tagLength;
 //     }
-bool parseAesGcmParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseAesGcmParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     BufferSource ivBufferSource;
     if (!getBufferSource(raw, "iv", ivBufferSource, context, error))
         return false;
 
     bool hasAdditionalData;
     BufferSource additionalDataBufferSource;
     if (!getOptionalBufferSource(raw, "additionalData", hasAdditionalData, additionalDataBufferSource, context, error))
         return false;
 
     uint8_t tagLength = 0;
     bool hasTagLength;
     if (!getOptionalUint8(raw, "tagLength", hasTagLength, tagLength, context, error))
         return false;
 
     DOMArrayPiece iv(ivBufferSource);
     DOMArrayPiece additionalData(additionalDataBufferSource, DOMArrayPiece::AllowNullPointToNullWithZeroSize);
 
-    params = wrapUnique(new WebCryptoAesGcmParams(iv.bytes(), iv.byteLength(), hasAdditionalData, additionalData.bytes(), additionalData.byteLength(), hasTagLength, tagLength));
+    params = adoptPtr(new WebCryptoAesGcmParams(iv.bytes(), iv.byteLength(), hasAdditionalData, additionalData.bytes(), additionalData.byteLength(), hasTagLength, tagLength));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary RsaOaepParams : Algorithm {
 //       BufferSource label;
 //     };
-bool parseRsaOaepParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseRsaOaepParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     bool hasLabel;
     BufferSource labelBufferSource;
     if (!getOptionalBufferSource(raw, "label", hasLabel, labelBufferSource, context, error))
         return false;
 
     DOMArrayPiece label(labelBufferSource, DOMArrayPiece::AllowNullPointToNullWithZeroSize);
-    params = wrapUnique(new WebCryptoRsaOaepParams(hasLabel, label.bytes(), label.byteLength()));
+    params = adoptPtr(new WebCryptoRsaOaepParams(hasLabel, label.bytes(), label.byteLength()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary RsaPssParams : Algorithm {
 //       [EnforceRange] required unsigned long saltLength;
 //     };
-bool parseRsaPssParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseRsaPssParams(const Dictionary& raw, OwnPtr<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 = adoptPtr(new 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)
+bool parseEcdsaParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoEcdsaParams(hash));
+    params = adoptPtr(new WebCryptoEcdsaParams(hash));
     return true;
 }
 
 struct CurveNameMapping {
     const char* const name;
     WebCryptoNamedCurve value;
 };
 
 const CurveNameMapping curveNameMappings[] = {
     { "P-256", WebCryptoNamedCurveP256 },
@@ skipping 21 matching lines @@
 
     setNotSupportedError(context.toString("Unrecognized namedCurve"), error);
     return false;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary EcKeyGenParams : Algorithm {
 //       required NamedCurve namedCurve;
 //     };
-bool parseEcKeyGenParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseEcKeyGenParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     WebCryptoNamedCurve namedCurve;
     if (!parseNamedCurve(raw, namedCurve, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoEcKeyGenParams(namedCurve));
+    params = adoptPtr(new 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)
+bool parseEcKeyImportParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     WebCryptoNamedCurve namedCurve;
     if (!parseNamedCurve(raw, namedCurve, context, error))
         return false;
 
-    params = wrapUnique(new WebCryptoEcKeyImportParams(namedCurve));
+    params = adoptPtr(new 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, const ErrorContext& context, AlgorithmError* error)
+bool parseEcdhKeyDeriveParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     v8::Local<v8::Value> v8Value;
     if (!raw.get("public", v8Value)) {
         setTypeError(context.toString("public", "Missing required property"), error);
         return false;
     }
 
     CryptoKey* cryptoKey = V8CryptoKey::toImplWithTypeCheck(raw.isolate(), v8Value);
     if (!cryptoKey) {
         setTypeError(context.toString("public", "Must be a CryptoKey"), error);
         return false;
     }
 
-    params = wrapUnique(new WebCryptoEcdhKeyDeriveParams(cryptoKey->key()));
+    params = adoptPtr(new WebCryptoEcdhKeyDeriveParams(cryptoKey->key()));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary Pbkdf2Params : Algorithm {
 //       required BufferSource salt;
 //       [EnforceRange] required unsigned long iterations;
 //       required HashAlgorithmIdentifier hash;
 //     };
-bool parsePbkdf2Params(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parsePbkdf2Params(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     BufferSource saltBufferSource;
     if (!getBufferSource(raw, "salt", saltBufferSource, context, error))
         return false;
 
     DOMArrayPiece salt(saltBufferSource);
 
     uint32_t iterations;
     if (!getUint32(raw, "iterations", iterations, context, error))
         return false;
 
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
-    params = wrapUnique(new WebCryptoPbkdf2Params(hash, salt.bytes(), salt.byteLength(), iterations));
+    params = adoptPtr(new WebCryptoPbkdf2Params(hash, salt.bytes(), salt.byteLength(), iterations));
     return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary AesDerivedKeyParams : Algorithm {
 //      [EnforceRange] required unsigned short length;
 //    };
-bool parseAesDerivedKeyParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseAesDerivedKeyParams(const Dictionary& raw, OwnPtr<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 = adoptPtr(new WebCryptoAesDerivedKeyParams(length));
     return true;
 }
 
 // FIXME: once the spec has been updated, check that the implementation is
 // still correct and update this comment. http://crbug.com/399095
 //
 // The WebCrypto spec hasn't been updated yet to define HKDF
 // (https://www.w3.org/Bugs/Public/show_bug.cgi?id=27425). The assumed
 // parameters are:
 //
 //    dictionary HkdfParams : Algorithm {
 //      required HashAlgorithmIdentifier hash;
 //      required BufferSource salt;
 //      required BufferSource info;
 //    };
-bool parseHkdfParams(const Dictionary& raw, std::unique_ptr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
+bool parseHkdfParams(const Dictionary& raw, OwnPtr<WebCryptoAlgorithmParams>& params, const ErrorContext& context, AlgorithmError* error)
 {
     WebCryptoAlgorithm hash;
     if (!parseHash(raw, hash, context, error))
         return false;
     BufferSource saltBufferSource;
     if (!getBufferSource(raw, "salt", saltBufferSource, context, error))
         return false;
     BufferSource infoBufferSource;
     if (!getBufferSource(raw, "info", infoBufferSource, context, error))
         return false;
 
     DOMArrayPiece salt(saltBufferSource);
     DOMArrayPiece info(infoBufferSource);
 
-    params = wrapUnique(new WebCryptoHkdfParams(hash, salt.bytes(), salt.byteLength(), info.bytes(), info.byteLength()));
+    params = adoptPtr(new WebCryptoHkdfParams(hash, salt.bytes(), salt.byteLength(), info.bytes(), info.byteLength()));
     return true;
 }
 
-bool parseAlgorithmParams(const Dictionary& raw, WebCryptoAlgorithmParamsType type, std::unique_ptr<WebCryptoAlgorithmParams>& params, ErrorContext& context, AlgorithmError* error)
+bool parseAlgorithmParams(const Dictionary& raw, WebCryptoAlgorithmParamsType type, OwnPtr<WebCryptoAlgorithmParams>& params, ErrorContext& context, AlgorithmError* error)
 {
     switch (type) {
     case WebCryptoAlgorithmParamsTypeNone:
         return true;
     case WebCryptoAlgorithmParamsTypeAesCbcParams:
         context.add("AesCbcParams");
         return parseAesCbcParams(raw, params, context, error);
     case WebCryptoAlgorithmParamsTypeAesKeyGenParams:
         context.add("AesKeyGenParams");
         return parseAesKeyGenParams(raw, params, context, error);
@@ skipping 90 matching lines @@
     const WebCryptoAlgorithmInfo* algorithmInfo = WebCryptoAlgorithm::lookupAlgorithmInfo(algorithmId);
 
     if (algorithmInfo->operationToParamsType[op] == WebCryptoAlgorithmInfo::Undefined) {
         context.add(algorithmInfo->name);
         setNotSupportedError(context.toString("Unsupported operation", operationToString(op)), error);
         return false;
     }
 
     WebCryptoAlgorithmParamsType paramsType = static_cast<WebCryptoAlgorithmParamsType>(algorithmInfo->operationToParamsType[op]);
 
-    std::unique_ptr<WebCryptoAlgorithmParams> params;
+    OwnPtr<WebCryptoAlgorithmParams> params;
     if (!parseAlgorithmParams(raw, paramsType, params, context, error))
         return false;
 
     algorithm = WebCryptoAlgorithm(algorithmId, std::move(params));
     return true;
 }
 
 bool parseAlgorithmIdentifier(const AlgorithmIdentifier& raw, WebCryptoOperation op, WebCryptoAlgorithm& algorithm, ErrorContext context, AlgorithmError* error)
 {
     context.add("Algorithm");
@@ skipping 21 matching lines @@
 }
 
 } // namespace
 
 bool normalizeAlgorithm(const AlgorithmIdentifier& raw, WebCryptoOperation op, WebCryptoAlgorithm& algorithm, AlgorithmError* error)
 {
     return parseAlgorithmIdentifier(raw, op, algorithm, ErrorContext(), error);
 }
 
 } // namespace blink