Rename toV8(...) function in Blink to ToV8(...).

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 161 matching lines @@
       Platform::current()->createRTCCertificateGenerator());
   std::unique_ptr<WebRTCCertificate> webCertificate =
       certificateGenerator->fromPEM(
           WebString::fromUTF8(kEcdsaPrivateKey, sizeof(kEcdsaPrivateKey)),
           WebString::fromUTF8(kEcdsaCertificate, sizeof(kEcdsaCertificate)));
   ASSERT_TRUE(webCertificate);
   RTCCertificate* certificate = new RTCCertificate(std::move(webCertificate));
 
   // Round trip test.
   v8::Local<v8::Value> wrapper =
-      toV8(certificate, scope.context()->Global(), scope.isolate());
+      ToV8(certificate, scope.context()->Global(), scope.isolate());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_TRUE(V8RTCCertificate::hasInstance(result, scope.isolate()));
   RTCCertificate* newCertificate =
       V8RTCCertificate::toImpl(result.As<v8::Object>());
   WebRTCCertificatePEM pem = newCertificate->certificate().toPEM();
   EXPECT_EQ(kEcdsaPrivateKey, pem.privateKey());
   EXPECT_EQ(kEcdsaCertificate, pem.certificate());
 }
 
 TEST(V8ScriptValueSerializerForModulesTest, DecodeRTCCertificate) {
@@ skipping 211 matching lines @@
 
   // Generate a 128-bit AES key.
   std::unique_ptr<WebCryptoAlgorithmParams> params(
       new WebCryptoAesKeyGenParams(128));
   WebCryptoAlgorithm algorithm(WebCryptoAlgorithmIdAesCbc, std::move(params));
   CryptoKey* key =
       syncGenerateKey(scriptState, algorithm, true,
                       WebCryptoKeyUsageEncrypt | WebCryptoKeyUsageDecrypt);
 
   // Round trip it and check the visible attributes.
-  v8::Local<v8::Value> wrapper = toV8(key, scope.getScriptState());
+  v8::Local<v8::Value> wrapper = ToV8(key, scope.getScriptState());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_TRUE(V8CryptoKey::hasInstance(result, scope.isolate()));
   CryptoKey* newKey = V8CryptoKey::toImpl(result.As<v8::Object>());
   EXPECT_EQ("secret", newKey->type());
   EXPECT_TRUE(newKey->extractable());
   EXPECT_THAT(newKey->usages(), UnorderedElementsAre("encrypt", "decrypt"));
 
   // Check that the keys have the same raw representation.
   WebVector<uint8_t> keyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatRaw, key->key());
@@ skipping 52 matching lines @@
   WebCryptoAlgorithm hash(WebCryptoAlgorithmIdSha256, nullptr);
   std::unique_ptr<WebCryptoAlgorithmParams> generateKeyParams(
       new WebCryptoHmacKeyGenParams(hash, false, 0));
   WebCryptoAlgorithm generateKeyAlgorithm(WebCryptoAlgorithmIdHmac,
                                           std::move(generateKeyParams));
   CryptoKey* key =
       syncGenerateKey(scriptState, generateKeyAlgorithm, true,
                       WebCryptoKeyUsageSign | WebCryptoKeyUsageVerify);
 
   // Round trip it and check the visible attributes.
-  v8::Local<v8::Value> wrapper = toV8(key, scope.getScriptState());
+  v8::Local<v8::Value> wrapper = ToV8(key, scope.getScriptState());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_TRUE(V8CryptoKey::hasInstance(result, scope.isolate()));
   CryptoKey* newKey = V8CryptoKey::toImpl(result.As<v8::Object>());
   EXPECT_EQ("secret", newKey->type());
   EXPECT_TRUE(newKey->extractable());
   EXPECT_THAT(newKey->usages(), UnorderedElementsAre("sign", "verify"));
 
   // Check that the keys have the same raw representation.
   WebVector<uint8_t> keyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatRaw, key->key());
@@ skipping 55 matching lines @@
       new WebCryptoRsaHashedKeyGenParams(hash, 1024, Vector<uint8_t>{1, 0, 1}));
   WebCryptoAlgorithm generateKeyAlgorithm(WebCryptoAlgorithmIdRsaPss,
                                           std::move(generateKeyParams));
   CryptoKey* publicKey;
   CryptoKey* privateKey;
   std::tie(publicKey, privateKey) =
       syncGenerateKeyPair(scriptState, generateKeyAlgorithm, true,
                           WebCryptoKeyUsageSign | WebCryptoKeyUsageVerify);
 
   // Round trip the private key and check the visible attributes.
-  v8::Local<v8::Value> wrapper = toV8(privateKey, scope.getScriptState());
+  v8::Local<v8::Value> wrapper = ToV8(privateKey, scope.getScriptState());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_TRUE(V8CryptoKey::hasInstance(result, scope.isolate()));
   CryptoKey* newPrivateKey = V8CryptoKey::toImpl(result.As<v8::Object>());
   EXPECT_EQ("private", newPrivateKey->type());
   EXPECT_TRUE(newPrivateKey->extractable());
   EXPECT_THAT(newPrivateKey->usages(), UnorderedElementsAre("sign"));
 
   // Check that the keys have the same PKCS8 representation.
   WebVector<uint8_t> keyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatPkcs8, privateKey->key());
@@ skipping 72 matching lines @@
       new WebCryptoEcKeyGenParams(WebCryptoNamedCurveP256));
   WebCryptoAlgorithm generateKeyAlgorithm(WebCryptoAlgorithmIdEcdsa,
                                           std::move(generateKeyParams));
   CryptoKey* publicKey;
   CryptoKey* privateKey;
   std::tie(publicKey, privateKey) =
       syncGenerateKeyPair(scriptState, generateKeyAlgorithm, true,
                           WebCryptoKeyUsageSign | WebCryptoKeyUsageVerify);
 
   // Round trip the private key and check the visible attributes.
-  v8::Local<v8::Value> wrapper = toV8(privateKey, scope.getScriptState());
+  v8::Local<v8::Value> wrapper = ToV8(privateKey, scope.getScriptState());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_TRUE(V8CryptoKey::hasInstance(result, scope.isolate()));
   CryptoKey* newPrivateKey = V8CryptoKey::toImpl(result.As<v8::Object>());
   EXPECT_EQ("private", newPrivateKey->type());
   EXPECT_TRUE(newPrivateKey->extractable());
   EXPECT_THAT(newPrivateKey->usages(), UnorderedElementsAre("sign"));
 
   // Check that the keys have the same PKCS8 representation.
   WebVector<uint8_t> keyRaw =
       syncExportKey(scriptState, WebCryptoKeyFormatPkcs8, privateKey->key());
@@ skipping 57 matching lines @@
   V8TestingScope scope;
   ScriptState* scriptState = scope.getScriptState();
 
   // Import some data into a PBKDF2 state.
   WebCryptoAlgorithm importKeyAlgorithm(WebCryptoAlgorithmIdPbkdf2, nullptr);
   CryptoKey* key = syncImportKey(scriptState, WebCryptoKeyFormatRaw,
                                  Vector<uint8_t>{1, 2, 3}, importKeyAlgorithm,
                                  false, WebCryptoKeyUsageDeriveBits);
 
   // Round trip the key and check the visible attributes.
-  v8::Local<v8::Value> wrapper = toV8(key, scope.getScriptState());
+  v8::Local<v8::Value> wrapper = ToV8(key, scope.getScriptState());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   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("deriveBits"));
 
   // Check that the keys derive the same bits.
   WebCryptoAlgorithm hash(WebCryptoAlgorithmIdSha256, nullptr);
   WebVector<uint8_t> salt(static_cast<size_t>(16));
@@ skipping 144 matching lines @@
 TEST(V8ScriptValueSerializerForModulesTest, RoundTripDOMFileSystem) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
 
   DOMFileSystem* fs = DOMFileSystem::create(
       scope.getExecutionContext(), "http_example.com_0:Persistent",
       FileSystemTypePersistent,
       KURL(ParsedURLString, "filesystem:http://example.com/persistent/"));
   // At time of writing, this can only happen for filesystems from PPAPI.
   fs->makeClonable();
-  v8::Local<v8::Value> wrapper = toV8(fs, scope.getScriptState());
+  v8::Local<v8::Value> wrapper = ToV8(fs, scope.getScriptState());
   v8::Local<v8::Value> result = roundTrip(wrapper, scope);
   ASSERT_FALSE(result.IsEmpty());
   ASSERT_TRUE(V8DOMFileSystem::hasInstance(result, scope.isolate()));
   DOMFileSystem* newFS = V8DOMFileSystem::toImpl(result.As<v8::Object>());
   EXPECT_EQ("http_example.com_0:Persistent", newFS->name());
   EXPECT_EQ(FileSystemTypePersistent, newFS->type());
   EXPECT_EQ("filesystem:http://example.com/persistent/",
             newFS->rootURL().getString());
 }
 
 TEST(V8ScriptValueSerializerForModulesTest, RoundTripDOMFileSystemNotClonable) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
   ExceptionState exceptionState(scope.isolate(),
                                 ExceptionState::ExecutionContext, "Window",
                                 "postMessage");
 
   DOMFileSystem* fs = DOMFileSystem::create(
       scope.getExecutionContext(), "http_example.com_0:Persistent",
       FileSystemTypePersistent,
       KURL(ParsedURLString, "filesystem:http://example.com/persistent/0/"));
   ASSERT_FALSE(fs->clonable());
-  v8::Local<v8::Value> wrapper = toV8(fs, scope.getScriptState());
+  v8::Local<v8::Value> wrapper = ToV8(fs, scope.getScriptState());
   EXPECT_FALSE(V8ScriptValueSerializer(scope.getScriptState())
                    .serialize(wrapper, nullptr, exceptionState));
   EXPECT_TRUE(hadDOMException("DataCloneError", scope.getScriptState(),
                               exceptionState));
 }
 
 TEST(V8ScriptValueSerializerForModulesTest, DecodeDOMFileSystem) {
   ScopedEnableV8BasedStructuredClone enable;
   V8TestingScope scope;
 
@@ skipping 38 matching lines @@
                            0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x72, 0x73, 0x69,
                            0x73, 0x74, 0x65, 0x6e, 0x74, 0x2f
 
           }))
           .deserialize()
           ->IsNull());
 }
 
 }  // namespace
 }  // namespace blink