s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

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 496 matching lines @@
 //      required BufferSource iv;
 //    };
 bool parseAesCbcParams(const Dictionary& raw,
                        std::unique_ptr<WebCryptoAlgorithmParams>& params,
                        const ErrorContext& context,
                        AlgorithmError* error) {
   WebVector<uint8_t> iv;
   if (!getBufferSource(raw, "iv", iv, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoAesCbcParams(std::move(iv)));
+  params = WTF::wrapUnique(new WebCryptoAesCbcParams(std::move(iv)));
   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) {
   uint16_t length;
   if (!getUint16(raw, "length", length, context, error))
     return false;
 
-  params = makeUnique<WebCryptoAesKeyGenParams>(length);
+  params = WTF::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 = makeUnique<WebCryptoHmacImportParams>(hash, hasLength, length);
+  params = WTF::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 = makeUnique<WebCryptoHmacKeyGenParams>(hash, hasLength, length);
+  params = WTF::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 = makeUnique<WebCryptoRsaHashedImportParams>(hash);
+  params = WTF::makeUnique<WebCryptoRsaHashedImportParams>(hash);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    dictionary RsaKeyGenParams : Algorithm {
 //      [EnforceRange] required unsigned long modulusLength;
 //      required BigInteger publicExponent;
 //    };
 //
@@ skipping 10 matching lines @@
     return false;
 
   WebVector<uint8_t> publicExponent;
   if (!getBigInteger(raw, "publicExponent", publicExponent, context, error))
     return false;
 
   WebCryptoAlgorithm hash;
   if (!parseHash(raw, hash, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoRsaHashedKeyGenParams(
+  params = WTF::wrapUnique(new WebCryptoRsaHashedKeyGenParams(
       hash, modulusLength, std::move(publicExponent)));
   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) {
   WebVector<uint8_t> counter;
   if (!getBufferSource(raw, "counter", counter, context, error))
     return false;
 
   uint8_t length;
   if (!getUint8(raw, "length", length, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoAesCtrParams(length, std::move(counter)));
+  params =
+      WTF::wrapUnique(new WebCryptoAesCtrParams(length, std::move(counter)));
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //     dictionary AesGcmParams : Algorithm {
 //       required BufferSource iv;
 //       BufferSource additionalData;
 //       [EnforceRange] octet tagLength;
 //     }
@@ skipping 10 matching lines @@
   if (!getOptionalBufferSource(raw, "additionalData", hasAdditionalData,
                                additionalData, context, error))
     return false;
 
   uint8_t tagLength = 0;
   bool hasTagLength;
   if (!getOptionalUint8(raw, "tagLength", hasTagLength, tagLength, context,
                         error))
     return false;
 
-  params = wrapUnique(new WebCryptoAesGcmParams(
+  params = WTF::wrapUnique(new WebCryptoAesGcmParams(
       std::move(iv), hasAdditionalData, std::move(additionalData), 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 hasLabel;
   WebVector<uint8_t> label;
   if (!getOptionalBufferSource(raw, "label", hasLabel, label, context, error))
     return false;
 
-  params = wrapUnique(new WebCryptoRsaOaepParams(hasLabel, std::move(label)));
+  params =
+      WTF::wrapUnique(new WebCryptoRsaOaepParams(hasLabel, std::move(label)));
   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) {
   uint32_t saltLengthBytes;
   if (!getUint32(raw, "saltLength", saltLengthBytes, context, error))
     return false;
 
-  params = makeUnique<WebCryptoRsaPssParams>(saltLengthBytes);
+  params = WTF::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 = makeUnique<WebCryptoEcdsaParams>(hash);
+  params = WTF::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 = makeUnique<WebCryptoEcKeyGenParams>(namedCurve);
+  params = WTF::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 = makeUnique<WebCryptoEcKeyImportParams>(namedCurve);
+  params = WTF::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,
                               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 = WTF::wrapUnique(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) {
   WebVector<uint8_t> salt;
   if (!getBufferSource(raw, "salt", salt, context, error))
     return false;
 
   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, std::move(salt), iterations));
+  params = WTF::wrapUnique(
+      new WebCryptoPbkdf2Params(hash, std::move(salt), 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) {
   uint16_t length;
   if (!getUint16(raw, "length", length, context, error))
     return false;
 
-  params = makeUnique<WebCryptoAesDerivedKeyParams>(length);
+  params = WTF::makeUnique<WebCryptoAesDerivedKeyParams>(length);
   return true;
 }
 
 // Defined by the WebCrypto spec as:
 //
 //    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) {
   WebCryptoAlgorithm hash;
   if (!parseHash(raw, hash, context, error))
     return false;
   WebVector<uint8_t> salt;
   if (!getBufferSource(raw, "salt", salt, context, error))
     return false;
   WebVector<uint8_t> info;
   if (!getBufferSource(raw, "info", info, context, error))
     return false;
 
-  params = wrapUnique(
+  params = WTF::wrapUnique(
       new WebCryptoHkdfParams(hash, std::move(salt), std::move(info)));
   return true;
 }
 
 bool parseAlgorithmParams(const Dictionary& raw,
                           WebCryptoAlgorithmParamsType type,
                           std::unique_ptr<WebCryptoAlgorithmParams>& params,
                           ErrorContext& context,
                           AlgorithmError* error) {
   switch (type) {
@@ skipping 157 matching lines @@
 }  // namespace
 
 bool normalizeAlgorithm(const AlgorithmIdentifier& raw,
                         WebCryptoOperation op,
                         WebCryptoAlgorithm& algorithm,
                         AlgorithmError* error) {
   return parseAlgorithmIdentifier(raw, op, algorithm, ErrorContext(), error);
 }
 
 }  // namespace blink