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

third_party/WebKit/Source/bindings/modules/v8/serialization/V8ScriptValueSerializerForModulesTest.cpp

 // 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 "bindings/modules/v8/serialization/V8ScriptValueSerializerForModules.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "bindings/core/v8/ToV8.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
@@ skipping 410 matching lines @@
 
   // Check that the keys have the same raw representation.
   WebVector<uint8_t> keyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatRaw, key->key());
   WebVector<uint8_t> newKeyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatRaw, newKey->key());
   EXPECT_THAT(newKeyRaw, ElementsAreArray(keyRaw));
 
   // Check that one can decrypt data encrypted with the other.
   Vector<unsigned char> iv(16, 0);
-  WebCryptoAlgorithm encryptAlgorithm(WebCryptoAlgorithmIdAesCbc,
-                                      makeUnique<WebCryptoAesCbcParams>(iv));
+  WebCryptoAlgorithm encryptAlgorithm(
+      WebCryptoAlgorithmIdAesCbc, WTF::makeUnique<WebCryptoAesCbcParams>(iv));
   Vector<unsigned char> plaintext{1, 2, 3};
   WebVector<uint8_t> ciphertext =
       syncEncrypt(scriptState, encryptAlgorithm, key->key(), plaintext);
   WebVector<uint8_t> newPlaintext =
       syncDecrypt(scriptState, encryptAlgorithm, newKey->key(), ciphertext);
   EXPECT_THAT(newPlaintext, ElementsAre(1, 2, 3));
 }
 
 TEST(V8ScriptValueSerializerForModulesTest, DecodeCryptoKeyAES) {
   ScopedEnableV8BasedStructuredClone enable;
@@ skipping 10 matching lines @@
   ASSERT_TRUE(V8CryptoKey::hasInstance(result, scope.isolate()));
   CryptoKey* newKey = V8CryptoKey::toImpl(result.As<v8::Object>());
   EXPECT_EQ("secret", newKey->type());
   EXPECT_FALSE(newKey->extractable());
   EXPECT_THAT(newKey->usages(), UnorderedElementsAre("decrypt"));
 
   // Check that it can successfully decrypt data.
   Vector<uint8_t> iv(16, 0);
   Vector<uint8_t> ciphertext{0x33, 0x26, 0xe7, 0x64, 0x11, 0x5e, 0xf4, 0x60,
                              0x96, 0x08, 0x11, 0xaf, 0x65, 0x8b, 0x87, 0x04};
-  WebCryptoAlgorithm encryptAlgorithm(WebCryptoAlgorithmIdAesCbc,
-                                      makeUnique<WebCryptoAesCbcParams>(iv));
+  WebCryptoAlgorithm encryptAlgorithm(
+      WebCryptoAlgorithmIdAesCbc, WTF::makeUnique<WebCryptoAesCbcParams>(iv));
   WebVector<uint8_t> plaintext =
       syncDecrypt(scriptState, encryptAlgorithm, newKey->key(), ciphertext);
   EXPECT_THAT(plaintext, ElementsAre(1, 2, 3));
 }
 
 // HMAC-SHA256 uses HMAC key params.
 TEST(V8ScriptValueSerializerForModulesTest, RoundTripCryptoKeyHMAC) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
@@ skipping 96 matching lines @@
   // Check that the keys have the same PKCS8 representation.
   WebVector<uint8_t> keyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatPkcs8, privateKey->key());
   WebVector<uint8_t> newKeyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatPkcs8, newPrivateKey->key());
   EXPECT_THAT(newKeyRaw, ElementsAreArray(keyRaw));
 
   // Check that one can verify a message signed by the other.
   Vector<uint8_t> message{1, 2, 3};
   WebCryptoAlgorithm algorithm(WebCryptoAlgorithmIdRsaPss,
-                               makeUnique<WebCryptoRsaPssParams>(16));
+                               WTF::makeUnique<WebCryptoRsaPssParams>(16));
   WebVector<uint8_t> signature =
       syncSign(scriptState, algorithm, newPrivateKey->key(), message);
   EXPECT_TRUE(syncVerifySignature(scriptState, algorithm, publicKey->key(),
                                   signature, message));
 }
 
 TEST(V8ScriptValueSerializerForModulesTest, DecodeCryptoKeyRSAHashed) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
@@ skipping 31 matching lines @@
       0x98, 0x1f, 0xf3, 0x9d, 0x32, 0x87, 0xdc, 0xbb, 0xb6, 0x3a, 0xa4, 0x6d,
       0xd4, 0xb5, 0x52, 0x83, 0x24, 0x02, 0xc7, 0x62, 0x1f, 0xb7, 0x27, 0x2b,
       0x5a, 0x54, 0x59, 0x17, 0x81, 0x8a, 0xf5, 0x0c, 0x17, 0x01, 0x45, 0x3f,
       0x14, 0xf2, 0x3c, 0x27, 0x4d, 0xfa, 0xc0, 0x0a, 0x82, 0x4b, 0xb2, 0xf4,
       0x7b, 0x14, 0x1b, 0xd8, 0xbc, 0xe9, 0x2e, 0xd4, 0x55, 0x27, 0x62, 0x83,
       0x11, 0xed, 0xc2, 0x81, 0x7d, 0xa9, 0x4f, 0xe0, 0xef, 0x0e, 0xa5, 0xa5,
       0xc6, 0x40, 0x46, 0xbf, 0x90, 0x19, 0xfc, 0xc8, 0x51, 0x0e, 0x0f, 0x62,
       0xeb, 0x17, 0x68, 0x1f, 0xbd, 0xfa, 0xf7, 0xd6, 0x1f, 0xa4, 0x7c, 0x9e,
       0x9e, 0xb1, 0x96, 0x8f, 0xe6, 0x5e, 0x89, 0x99};
   WebCryptoAlgorithm algorithm(WebCryptoAlgorithmIdRsaPss,
-                               makeUnique<WebCryptoRsaPssParams>(16));
+                               WTF::makeUnique<WebCryptoRsaPssParams>(16));
   EXPECT_TRUE(syncVerifySignature(scriptState, algorithm, newPublicKey->key(),
                                   signature, message));
 }
 
 // ECDSA uses EC key params.
 TEST(V8ScriptValueSerializerForModulesTest, RoundTripCryptoKeyEC) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
 
@@ skipping 21 matching lines @@
   WebVector<uint8_t> keyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatPkcs8, privateKey->key());
   WebVector<uint8_t> newKeyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatPkcs8, newPrivateKey->key());
   EXPECT_THAT(newKeyRaw, ElementsAreArray(keyRaw));
 
   // Check that one can verify a message signed by the other.
   WebCryptoAlgorithm hash(WebCryptoAlgorithmIdSha256, nullptr);
   Vector<uint8_t> message{1, 2, 3};
   WebCryptoAlgorithm algorithm(WebCryptoAlgorithmIdEcdsa,
-                               makeUnique<WebCryptoEcdsaParams>(hash));
+                               WTF::makeUnique<WebCryptoEcdsaParams>(hash));
   WebVector<uint8_t> signature =
       syncSign(scriptState, algorithm, newPrivateKey->key(), message);
   EXPECT_TRUE(syncVerifySignature(scriptState, algorithm, publicKey->key(),
                                   signature, message));
 }
 
 TEST(V8ScriptValueSerializerForModulesTest, DecodeCryptoKeyEC) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
@@ skipping 21 matching lines @@
   Vector<uint8_t> message{1, 2, 3};
   Vector<uint8_t> signature{
       0xee, 0x63, 0xa2, 0xa3, 0x87, 0x6c, 0x9f, 0xc5, 0x64, 0x12, 0x87,
       0x0d, 0xc7, 0xff, 0x3c, 0xd2, 0x6c, 0x2b, 0x2c, 0x0b, 0x2b, 0x8d,
       0x3c, 0xe0, 0x3f, 0xd3, 0xfc, 0x28, 0xf0, 0xa1, 0x22, 0x69, 0x0a,
       0x33, 0x4d, 0x48, 0x97, 0xad, 0x67, 0xa9, 0x6e, 0x24, 0xe7, 0x31,
       0x09, 0xdb, 0xa8, 0x92, 0x48, 0x70, 0xa6, 0x6c, 0x46, 0x4d, 0x0b,
       0x83, 0x27, 0x37, 0x69, 0x4d, 0x32, 0x63, 0x1e, 0x82};
   WebCryptoAlgorithm hash(WebCryptoAlgorithmIdSha256, nullptr);
   WebCryptoAlgorithm algorithm(WebCryptoAlgorithmIdEcdsa,
-                               makeUnique<WebCryptoEcdsaParams>(hash));
+                               WTF::makeUnique<WebCryptoEcdsaParams>(hash));
   EXPECT_TRUE(syncVerifySignature(scriptState, algorithm, newPublicKey->key(),
                                   signature, message));
 }
 
 TEST(V8ScriptValueSerializerForModulesTest, RoundTripCryptoKeyNoParams) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
 
   // Import some data into a PBKDF2 state.
@@ skipping 243 matching lines @@
                            0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x72, 0x73, 0x69,
                            0x73, 0x74, 0x65, 0x6e, 0x74, 0x2f
 
           }))
           .deserialize()
           ->IsNull());
 }
 
 }  // namespace
 }  // namespace blink