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

third_party/WebKit/Source/bindings/core/v8/ToV8Test.cpp

 // Copyright 2014 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/core/v8/ToV8.h"
 
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/testing/GarbageCollectedScriptWrappable.h"
 #include "platform/heap/Heap.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Vector.h"
 #include <limits>
 
 #define TEST_TOV8(expected, value) \
   testToV8(&scope, expected, value, __FILE__, __LINE__)
 
 namespace blink {
 
 namespace {
 
 template <typename T>
 void testToV8(V8TestingScope* scope,
               const char* expected,
               T value,
               const char* path,
               int lineNumber) {
   v8::Local<v8::Value> actual =
-      toV8(value, scope->context()->Global(), scope->isolate());
+      ToV8(value, scope->context()->Global(), scope->isolate());
   if (actual.IsEmpty()) {
     ADD_FAILURE_AT(path, lineNumber) << "toV8 returns an empty value.";
     return;
   }
   String actualString =
       toCoreString(actual->ToString(scope->context()).ToLocalChecked());
   if (String(expected) != actualString) {
     ADD_FAILURE_AT(path, lineNumber)
         << "toV8 returns an incorrect value.\n  Actual: "
         << actualString.utf8().data() << "\nExpected: " << expected;
@@ skipping 165 matching lines @@
 }
 
 TEST(ToV8Test, dictionaryVector) {
   V8TestingScope scope;
   Vector<std::pair<String, int>> dictionary;
   dictionary.push_back(std::make_pair("one", 1));
   dictionary.push_back(std::make_pair("two", 2));
   TEST_TOV8("[object Object]", dictionary);
   v8::Local<v8::Context> context = scope.getScriptState()->context();
   v8::Local<v8::Object> result =
-      toV8(dictionary, context->Global(), scope.isolate())
+      ToV8(dictionary, context->Global(), scope.isolate())
           ->ToObject(context)
           .ToLocalChecked();
   v8::Local<v8::Value> one =
       result->Get(context, v8String(scope.isolate(), "one")).ToLocalChecked();
   EXPECT_EQ(1, one->NumberValue(context).FromJust());
   v8::Local<v8::Value> two =
       result->Get(context, v8String(scope.isolate(), "two")).ToLocalChecked();
   EXPECT_EQ(2, two->NumberValue(context).FromJust());
 }
 
 TEST(ToV8Test, heapVector) {
   V8TestingScope scope;
   HeapVector<Member<GarbageCollectedScriptWrappable>> v;
   v.push_back(new GarbageCollectedScriptWrappable("hoge"));
   v.push_back(new GarbageCollectedScriptWrappable("fuga"));
   v.push_back(nullptr);
 
   TEST_TOV8("hoge,fuga,", v);
 }
 
 TEST(ToV8Test, withScriptState) {
   V8TestingScope scope;
   ScriptValue value(scope.getScriptState(),
                     v8::Number::New(scope.isolate(), 1234.0));
 
-  v8::Local<v8::Value> actual = toV8(value, scope.getScriptState());
+  v8::Local<v8::Value> actual = ToV8(value, scope.getScriptState());
   EXPECT_FALSE(actual.IsEmpty());
 
   double actualAsNumber = actual.As<v8::Number>()->Value();
   EXPECT_EQ(1234.0, actualAsNumber);
 }
 
 }  // namespace
 
 }  // namespace blink