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

third_party/WebKit/Source/bindings/modules/v8/V8BindingForModules.cpp

 /*
  * Copyright (C) 2011 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 48 matching lines @@
                                                     const IDBValue*);
 static v8::Local<v8::Value> deserializeIDBValue(
     v8::Isolate*,
     v8::Local<v8::Object> creationContext,
     const IDBValue*);
 static v8::Local<v8::Value> deserializeIDBValueArray(
     v8::Isolate*,
     v8::Local<v8::Object> creationContext,
     const Vector<RefPtr<IDBValue>>*);
 
-v8::Local<v8::Value> toV8(const IDBKeyPath& value,
+v8::Local<v8::Value> ToV8(const IDBKeyPath& value,
                           v8::Local<v8::Object> creationContext,
                           v8::Isolate* isolate) {
   switch (value.getType()) {
     case IDBKeyPath::NullType:
       return v8::Null(isolate);
     case IDBKeyPath::StringType:
       return v8String(isolate, value.string());
     case IDBKeyPath::ArrayType:
-      return toV8(value.array(), creationContext, isolate);
+      return ToV8(value.array(), creationContext, isolate);
   }
   ASSERT_NOT_REACHED();
   return v8::Undefined(isolate);
 }
 
-v8::Local<v8::Value> toV8(const IDBKey* key,
+v8::Local<v8::Value> ToV8(const IDBKey* key,
                           v8::Local<v8::Object> creationContext,
                           v8::Isolate* isolate) {
   if (!key) {
     // The IndexedDB spec requires that absent keys appear as attribute
     // values as undefined, rather than the more typical (for DOM) null.
     // This appears on the |upper| and |lower| attributes of IDBKeyRange.
     // Spec: http://www.w3.org/TR/IndexedDB/#idl-def-IDBKeyRange
     return v8Undefined();
   }
 
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   switch (key->getType()) {
     case IDBKey::InvalidType:
     case IDBKey::MinType:
       ASSERT_NOT_REACHED();
       return v8Undefined();
     case IDBKey::NumberType:
       return v8::Number::New(isolate, key->number());
     case IDBKey::StringType:
       return v8String(isolate, key->string());
     case IDBKey::BinaryType:
       // Experimental feature: binary keys
       // https://w3c.github.io/IndexedDB/#steps-to-convert-a-key-to-a-value
-      return toV8(DOMArrayBuffer::create(reinterpret_cast<const unsigned char*>(
+      return ToV8(DOMArrayBuffer::create(reinterpret_cast<const unsigned char*>(
                                              key->binary()->data()),
                                          key->binary()->size()),
                   creationContext, isolate);
     case IDBKey::DateType:
       return v8::Date::New(context, key->date()).ToLocalChecked();
     case IDBKey::ArrayType: {
       v8::Local<v8::Array> array = v8::Array::New(isolate, key->array().size());
       for (size_t i = 0; i < key->array().size(); ++i) {
         v8::Local<v8::Value> value =
-            toV8(key->array()[i].get(), creationContext, isolate);
+            ToV8(key->array()[i].get(), creationContext, isolate);
         if (value.IsEmpty())
           value = v8::Undefined(isolate);
         if (!v8CallBoolean(array->CreateDataProperty(context, i, value)))
           return v8Undefined();
       }
       return array;
     }
   }
 
   ASSERT_NOT_REACHED();
   return v8Undefined();
 }
 
 // IDBAny is a variant type used to hold the values produced by the |result|
 // attribute of IDBRequest and (as a convenience) the |source| attribute of
 // IDBRequest and IDBCursor.
 // TODO(jsbell): Replace the use of IDBAny for |source| attributes (which are
 // ScriptWrappable types) using unions per IDL.
-v8::Local<v8::Value> toV8(const IDBAny* impl,
+v8::Local<v8::Value> ToV8(const IDBAny* impl,
                           v8::Local<v8::Object> creationContext,
                           v8::Isolate* isolate) {
   if (!impl)
     return v8::Null(isolate);
 
   switch (impl->getType()) {
     case IDBAny::UndefinedType:
       return v8::Undefined(isolate);
     case IDBAny::NullType:
       return v8::Null(isolate);
     case IDBAny::DOMStringListType:
-      return toV8(impl->domStringList(), creationContext, isolate);
+      return ToV8(impl->domStringList(), creationContext, isolate);
     case IDBAny::IDBCursorType:
-      return toV8(impl->idbCursor(), creationContext, isolate);
+      return ToV8(impl->idbCursor(), creationContext, isolate);
     case IDBAny::IDBCursorWithValueType:
-      return toV8(impl->idbCursorWithValue(), creationContext, isolate);
+      return ToV8(impl->idbCursorWithValue(), creationContext, isolate);
     case IDBAny::IDBDatabaseType:
-      return toV8(impl->idbDatabase(), creationContext, isolate);
+      return ToV8(impl->idbDatabase(), creationContext, isolate);
     case IDBAny::IDBIndexType:
-      return toV8(impl->idbIndex(), creationContext, isolate);
+      return ToV8(impl->idbIndex(), creationContext, isolate);
     case IDBAny::IDBObjectStoreType:
-      return toV8(impl->idbObjectStore(), creationContext, isolate);
+      return ToV8(impl->idbObjectStore(), creationContext, isolate);
     case IDBAny::IDBValueType:
       return deserializeIDBValue(isolate, creationContext, impl->value());
     case IDBAny::IDBValueArrayType:
       return deserializeIDBValueArray(isolate, creationContext, impl->values());
     case IDBAny::IntegerType:
       return v8::Number::New(isolate, impl->integer());
     case IDBAny::KeyType:
-      return toV8(impl->key(), creationContext, isolate);
+      return ToV8(impl->key(), creationContext, isolate);
   }
 
   ASSERT_NOT_REACHED();
   return v8::Undefined(isolate);
 }
 
 static const size_t maximumDepth = 2000;
 
 static IDBKey* createIDBKeyFromValue(v8::Isolate* isolate,
                                      v8::Local<v8::Value> value,
@@ skipping 226 matching lines @@
     v8::Isolate* isolate,
     v8::Local<v8::Object> creationContext,
     const IDBValue* value) {
   ASSERT(isolate->InContext());
   if (!value || value->isNull())
     return v8::Null(isolate);
 
   v8::Local<v8::Value> v8Value = deserializeIDBValueData(isolate, value);
   if (value->primaryKey()) {
     v8::Local<v8::Value> key =
-        toV8(value->primaryKey(), creationContext, isolate);
+        ToV8(value->primaryKey(), creationContext, isolate);
     if (key.IsEmpty())
       return v8::Local<v8::Value>();
     bool injected =
         injectV8KeyIntoV8Value(isolate, key, v8Value, value->keyPath());
     DCHECK(injected);
   }
 
   return v8Value;
 }
 
@@ skipping 191 matching lines @@
   if (expectedKey && expectedKey->isEqual(value->primaryKey()))
     return;
 
   bool injected = injectV8KeyIntoV8Value(
       isolate, keyValue.v8Value(), scriptValue.v8Value(), value->keyPath());
   DCHECK(injected);
 }
 #endif
 
 }  // namespace blink