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

third_party/WebKit/Source/bindings/core/v8/ScriptValueSerializer.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/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/Transferables.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
@@ skipping 691 matching lines @@
 void ScriptValueSerializer::copyTransferables(
     const Transferables& transferables) {
   v8::Local<v8::Object> creationContext = m_scriptState->context()->Global();
 
   // Also kept in separate ObjectPools, iterate and copy the contents
   // of each kind of transferable vector.
 
   const auto& messagePorts = transferables.messagePorts;
   for (size_t i = 0; i < messagePorts.size(); ++i) {
     v8::Local<v8::Object> v8MessagePort =
-        toV8(messagePorts[i].get(), creationContext, isolate())
+        ToV8(messagePorts[i].get(), creationContext, isolate())
             .As<v8::Object>();
     m_transferredMessagePorts.set(v8MessagePort, i);
   }
 
   const auto& arrayBuffers = transferables.arrayBuffers;
   for (size_t i = 0; i < arrayBuffers.size(); ++i) {
     v8::Local<v8::Object> v8ArrayBuffer =
-        toV8(arrayBuffers[i].get(), creationContext, isolate())
+        ToV8(arrayBuffers[i].get(), creationContext, isolate())
             .As<v8::Object>();
     // Coalesce multiple occurences of the same buffer to the first index.
     if (!m_transferredArrayBuffers.contains(v8ArrayBuffer))
       m_transferredArrayBuffers.set(v8ArrayBuffer, i);
   }
 
   const auto& imageBitmaps = transferables.imageBitmaps;
   for (size_t i = 0; i < imageBitmaps.size(); ++i) {
     v8::Local<v8::Object> v8ImageBitmap =
-        toV8(imageBitmaps[i].get(), creationContext, isolate())
+        ToV8(imageBitmaps[i].get(), creationContext, isolate())
             .As<v8::Object>();
     if (!m_transferredImageBitmaps.contains(v8ImageBitmap))
       m_transferredImageBitmaps.set(v8ImageBitmap, i);
   }
 
   const auto& offscreenCanvases = transferables.offscreenCanvases;
   for (size_t i = 0; i < offscreenCanvases.size(); ++i) {
     v8::Local<v8::Object> v8OffscreenCanvas =
-        toV8(offscreenCanvases[i].get(), creationContext, isolate())
+        ToV8(offscreenCanvases[i].get(), creationContext, isolate())
             .As<v8::Object>();
     if (!m_transferredOffscreenCanvas.contains(v8OffscreenCanvas))
       m_transferredOffscreenCanvas.set(v8OffscreenCanvas, i);
   }
 }
 
 PassRefPtr<SerializedScriptValue> ScriptValueSerializer::serialize(
     v8::Local<v8::Value> value,
     Transferables* transferables,
     ExceptionState& exceptionState) {
@@ skipping 450 matching lines @@
 ScriptValueSerializer::writeAndGreyArrayBufferView(v8::Local<v8::Object> object,
                                                    StateBase* next) {
   ASSERT(!object.IsEmpty());
   DOMArrayBufferView* arrayBufferView = V8ArrayBufferView::toImpl(object);
   if (!arrayBufferView)
     return nullptr;
   if (!arrayBufferView->bufferBase())
     return handleError(Status::DataCloneError,
                        "An ArrayBuffer could not be cloned.", next);
   v8::Local<v8::Value> underlyingBuffer =
-      toV8(arrayBufferView->bufferBase(), m_scriptState->context()->Global(),
+      ToV8(arrayBufferView->bufferBase(), m_scriptState->context()->Global(),
            isolate());
   if (underlyingBuffer.IsEmpty())
     return handleError(Status::DataCloneError,
                        "An ArrayBuffer could not be cloned.", next);
   StateBase* stateOut = doSerializeArrayBuffer(underlyingBuffer, next);
   if (stateOut)
     return stateOut;
   m_writer.writeArrayBufferView(*arrayBufferView);
   // This should be safe: we serialize something that we know to be a wrapper
   // (see the toV8 call above), so the call to doSerializeArrayBuffer should
@@ skipping 657 matching lines @@
   if (!doReadImageDataProperties(&width, &height, &pixelDataLength))
     return false;
   ImageData* imageData = ImageData::create(IntSize(width, height));
   DOMUint8ClampedArray* pixelArray = imageData->data();
   ASSERT(pixelArray);
   ASSERT(pixelArray->length() >= pixelDataLength);
   memcpy(pixelArray->data(), m_buffer + m_position, pixelDataLength);
   m_position += pixelDataLength;
   if (!imageData)
     return false;
-  *value = toV8(imageData, m_scriptState->context()->Global(), isolate());
+  *value = ToV8(imageData, m_scriptState->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReader::readImageBitmap(v8::Local<v8::Value>* value) {
   uint32_t isOriginClean;
   if (!doReadUint32(&isOriginClean))
     return false;
   uint32_t isPremultiplied;
   if (!doReadUint32(&isPremultiplied))
     return false;
   uint32_t width;
   uint32_t height;
   uint32_t pixelDataLength;
   if (!doReadImageDataProperties(&width, &height, &pixelDataLength))
     return false;
   const void* pixelData = m_buffer + m_position;
   m_position += pixelDataLength;
   ImageBitmap* imageBitmap = ImageBitmap::create(
       pixelData, width, height, isPremultiplied, isOriginClean);
   if (!imageBitmap)
     return false;
-  *value = toV8(imageBitmap, m_scriptState->context()->Global(), isolate());
+  *value = ToV8(imageBitmap, m_scriptState->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReader::readCompositorProxy(
     v8::Local<v8::Value>* value) {
   uint32_t attributes;
   uint64_t element;
   if (!doReadUint64(&element))
     return false;
   if (!doReadUint32(&attributes))
     return false;
 
   CompositorProxy* compositorProxy = CompositorProxy::create(
       m_scriptState->getExecutionContext(), element, attributes);
-  *value = toV8(compositorProxy, m_scriptState->context()->Global(), isolate());
+  *value = ToV8(compositorProxy, m_scriptState->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 DOMArrayBuffer* SerializedScriptValueReader::doReadArrayBuffer() {
   uint32_t byteLength;
   if (!doReadUint32(&byteLength))
     return nullptr;
   if (m_position + byteLength > m_length)
     return nullptr;
   const void* bufferStart = m_buffer + m_position;
@@ skipping 38 matching lines @@
       v8::WasmCompiledModule::DeserializeOrCompile(isolate(), compiledBytes,
                                                    wireBytes);
 
   return retval.ToLocal(value);
 }
 
 bool SerializedScriptValueReader::readArrayBuffer(v8::Local<v8::Value>* value) {
   DOMArrayBuffer* arrayBuffer = doReadArrayBuffer();
   if (!arrayBuffer)
     return false;
-  *value = toV8(arrayBuffer, m_scriptState->context()->Global(), isolate());
+  *value = ToV8(arrayBuffer, m_scriptState->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReader::readArrayBufferView(
     v8::Local<v8::Value>* value,
     ScriptValueDeserializer& deserializer) {
   ArrayBufferViewSubTag subTag;
   uint32_t byteOffset;
   uint32_t byteLength;
   DOMArrayBufferBase* arrayBuffer = nullptr;
@@ skipping 60 matching lines @@
   const unsigned numElements = byteLength / elementByteSize;
   const unsigned remainingElements =
       (arrayBuffer->byteLength() - byteOffset) / elementByteSize;
   if (byteOffset % elementByteSize || byteOffset > arrayBuffer->byteLength() ||
       numElements > remainingElements)
     return false;
 
   v8::Local<v8::Object> creationContext = m_scriptState->context()->Global();
   switch (subTag) {
     case ByteArrayTag:
-      *value = toV8(DOMInt8Array::create(arrayBuffer, byteOffset, numElements),
+      *value = ToV8(DOMInt8Array::create(arrayBuffer, byteOffset, numElements),
                     creationContext, isolate());
       break;
     case UnsignedByteArrayTag:
-      *value = toV8(DOMUint8Array::create(arrayBuffer, byteOffset, numElements),
+      *value = ToV8(DOMUint8Array::create(arrayBuffer, byteOffset, numElements),
                     creationContext, isolate());
       break;
     case UnsignedByteClampedArrayTag:
-      *value = toV8(
+      *value = ToV8(
           DOMUint8ClampedArray::create(arrayBuffer, byteOffset, numElements),
           creationContext, isolate());
       break;
     case ShortArrayTag:
-      *value = toV8(DOMInt16Array::create(arrayBuffer, byteOffset, numElements),
+      *value = ToV8(DOMInt16Array::create(arrayBuffer, byteOffset, numElements),
                     creationContext, isolate());
       break;
     case UnsignedShortArrayTag:
       *value =
-          toV8(DOMUint16Array::create(arrayBuffer, byteOffset, numElements),
+          ToV8(DOMUint16Array::create(arrayBuffer, byteOffset, numElements),
                creationContext, isolate());
       break;
     case IntArrayTag:
-      *value = toV8(DOMInt32Array::create(arrayBuffer, byteOffset, numElements),
+      *value = ToV8(DOMInt32Array::create(arrayBuffer, byteOffset, numElements),
                     creationContext, isolate());
       break;
     case UnsignedIntArrayTag:
       *value =
-          toV8(DOMUint32Array::create(arrayBuffer, byteOffset, numElements),
+          ToV8(DOMUint32Array::create(arrayBuffer, byteOffset, numElements),
                creationContext, isolate());
       break;
     case FloatArrayTag:
       *value =
-          toV8(DOMFloat32Array::create(arrayBuffer, byteOffset, numElements),
+          ToV8(DOMFloat32Array::create(arrayBuffer, byteOffset, numElements),
                creationContext, isolate());
       break;
     case DoubleArrayTag:
       *value =
-          toV8(DOMFloat64Array::create(arrayBuffer, byteOffset, numElements),
+          ToV8(DOMFloat64Array::create(arrayBuffer, byteOffset, numElements),
                creationContext, isolate());
       break;
     case DataViewTag:
-      *value = toV8(DOMDataView::create(arrayBuffer, byteOffset, byteLength),
+      *value = ToV8(DOMDataView::create(arrayBuffer, byteOffset, byteLength),
                     creationContext, isolate());
       break;
   }
   return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReader::readRegExp(v8::Local<v8::Value>* value) {
   v8::Local<v8::Value> pattern;
   if (!readString(&pattern))
     return false;
@@ skipping 29 matching lines @@
     uint64_t size;
     ASSERT(!m_blobInfo);
     if (!readWebCoreString(&uuid))
       return false;
     if (!readWebCoreString(&type))
       return false;
     if (!doReadUint64(&size))
       return false;
     blob = Blob::create(getOrCreateBlobDataHandle(uuid, type, size));
   }
-  *value = toV8(blob, m_scriptState->context()->Global(), isolate());
+  *value = ToV8(blob, m_scriptState->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReader::readFile(v8::Local<v8::Value>* value,
                                            bool isIndexed) {
   File* file = nullptr;
   if (isIndexed) {
     if (m_version < 6)
       return false;
     file = readFileIndexHelper();
   } else {
     file = readFileHelper();
   }
   if (!file)
     return false;
-  *value = toV8(file, m_scriptState->context()->Global(), isolate());
+  *value = ToV8(file, m_scriptState->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReader::readFileList(v8::Local<v8::Value>* value,
                                                bool isIndexed) {
   if (m_version < 3)
     return false;
   uint32_t length;
   if (!doReadUint32(&length))
     return false;
   FileList* fileList = FileList::create();
   for (unsigned i = 0; i < length; ++i) {
     File* file = nullptr;
     if (isIndexed) {
       if (m_version < 6)
         return false;
       file = readFileIndexHelper();
     } else {
       file = readFileHelper();
     }
     if (!file)
       return false;
     fileList->append(file);
   }
-  *value = toV8(fileList, m_scriptState->context()->Global(), isolate());
+  *value = ToV8(fileList, m_scriptState->context()->Global(), isolate());
   return !value->IsEmpty();
 }
 
 File* SerializedScriptValueReader::readFileHelper() {
   if (m_version < 3)
     return nullptr;
   ASSERT(!m_blobInfo);
   String path;
   String name;
   String relativePath;
@@ skipping 259 matching lines @@
 
 bool ScriptValueDeserializer::tryGetTransferredMessagePort(
     uint32_t index,
     v8::Local<v8::Value>* object) {
   if (!m_transferredMessagePorts)
     return false;
   if (index >= m_transferredMessagePorts->size())
     return false;
   v8::Local<v8::Object> creationContext =
       m_reader.getScriptState()->context()->Global();
-  *object = toV8(m_transferredMessagePorts->at(index).get(), creationContext,
+  *object = ToV8(m_transferredMessagePorts->at(index).get(), creationContext,
                  m_reader.getScriptState()->isolate());
   return !object->IsEmpty();
 }
 
 bool ScriptValueDeserializer::tryGetTransferredArrayBuffer(
     uint32_t index,
     v8::Local<v8::Value>* object) {
   if (!m_arrayBufferContents)
     return false;
   if (index >= m_arrayBuffers.size())
     return false;
   v8::Local<v8::Value> result = m_arrayBuffers.at(index);
   if (result.IsEmpty()) {
     DOMArrayBuffer* buffer =
         DOMArrayBuffer::create(m_arrayBufferContents->at(index));
     v8::Isolate* isolate = m_reader.getScriptState()->isolate();
     v8::Local<v8::Object> creationContext =
         m_reader.getScriptState()->context()->Global();
-    result = toV8(buffer, creationContext, isolate);
+    result = ToV8(buffer, creationContext, isolate);
     if (result.IsEmpty())
       return false;
     m_arrayBuffers[index] = result;
   }
   *object = result;
   return true;
 }
 
 bool ScriptValueDeserializer::tryGetTransferredImageBitmap(
     uint32_t index,
     v8::Local<v8::Value>* object) {
   if (!m_imageBitmapContents)
     return false;
   if (index >= m_imageBitmaps.size())
     return false;
   v8::Local<v8::Value> result = m_imageBitmaps.at(index);
   if (result.IsEmpty()) {
     ImageBitmap* bitmap = ImageBitmap::create(m_imageBitmapContents->at(index));
     v8::Isolate* isolate = m_reader.getScriptState()->isolate();
     v8::Local<v8::Object> creationContext =
         m_reader.getScriptState()->context()->Global();
-    result = toV8(bitmap, creationContext, isolate);
+    result = ToV8(bitmap, creationContext, isolate);
     if (result.IsEmpty())
       return false;
     m_imageBitmaps[index] = result;
   }
   *object = result;
   return true;
 }
 
 bool ScriptValueDeserializer::tryGetTransferredSharedArrayBuffer(
     uint32_t index,
     v8::Local<v8::Value>* object) {
   ASSERT(RuntimeEnabledFeatures::sharedArrayBufferEnabled());
   if (!m_arrayBufferContents)
     return false;
   if (index >= m_arrayBuffers.size())
     return false;
   v8::Local<v8::Value> result = m_arrayBuffers.at(index);
   if (result.IsEmpty()) {
     DOMSharedArrayBuffer* buffer =
         DOMSharedArrayBuffer::create(m_arrayBufferContents->at(index));
     v8::Isolate* isolate = m_reader.getScriptState()->isolate();
     v8::Local<v8::Object> creationContext =
         m_reader.getScriptState()->context()->Global();
-    result = toV8(buffer, creationContext, isolate);
+    result = ToV8(buffer, creationContext, isolate);
     if (result.IsEmpty())
       return false;
     m_arrayBuffers[index] = result;
   }
   *object = result;
   return true;
 }
 
 bool ScriptValueDeserializer::tryGetTransferredOffscreenCanvas(
     uint32_t width,
     uint32_t height,
     uint32_t canvasId,
     uint32_t clientId,
     uint32_t sinkId,
     v8::Local<v8::Value>* object) {
   OffscreenCanvas* offscreenCanvas = OffscreenCanvas::create(width, height);
   offscreenCanvas->setPlaceholderCanvasId(canvasId);
   offscreenCanvas->setFrameSinkId(clientId, sinkId);
-  *object = toV8(offscreenCanvas, m_reader.getScriptState());
+  *object = ToV8(offscreenCanvas, m_reader.getScriptState());
   if ((*object).IsEmpty())
     return false;
   return true;
 }
 
 bool ScriptValueDeserializer::tryGetObjectFromObjectReference(
     uint32_t reference,
     v8::Local<v8::Value>* object) {
   if (reference >= m_objectPool.size())
     return false;
@@ skipping 64 matching lines @@
       m_openCompositeReferenceStack[m_openCompositeReferenceStack.size() - 1];
   m_openCompositeReferenceStack.shrink(m_openCompositeReferenceStack.size() -
                                        1);
   if (objectReference >= m_objectPool.size())
     return false;
   *object = m_objectPool[objectReference];
   return true;
 }
 
 }  // namespace blink