Make ImageBitmap Transferable

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 "config.h"
 #include "bindings/core/v8/ScriptValueSerializer.h"
 
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ArrayBufferView.h"
 #include "bindings/core/v8/V8Blob.h"
 #include "bindings/core/v8/V8CompositorProxy.h"
 #include "bindings/core/v8/V8File.h"
 #include "bindings/core/v8/V8FileList.h"
+#include "bindings/core/v8/V8ImageBitmap.h"
 #include "bindings/core/v8/V8ImageData.h"
 #include "bindings/core/v8/V8MessagePort.h"
 #include "bindings/core/v8/V8SharedArrayBuffer.h"
 #include "core/dom/CompositorProxy.h"
 #include "core/dom/DOMDataView.h"
 #include "core/dom/DOMSharedArrayBuffer.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/fileapi/Blob.h"
 #include "core/fileapi/File.h"
 #include "core/fileapi/FileList.h"
@@ skipping 292 matching lines @@
     append(MessagePortTag);
     doWriteUint32(index);
 }
 
 void SerializedScriptValueWriter::writeTransferredArrayBuffer(uint32_t index)
 {
     append(ArrayBufferTransferTag);
     doWriteUint32(index);
 }
 
+void SerializedScriptValueWriter::writeTransferredImageBitmap(uint32_t index)
+{
+    append(ImageBitmapTransferTag);
+    doWriteUint32(index);
+}
+
 void SerializedScriptValueWriter::writeTransferredSharedArrayBuffer(uint32_t index)
 {
     ASSERT(RuntimeEnabledFeatures::sharedArrayBufferEnabled());
     append(SharedArrayBufferTransferTag);
     doWriteUint32(index);
 }
 
 void SerializedScriptValueWriter::writeObjectReference(uint32_t reference)
 {
     append(ObjectReferenceTag);
@@ skipping 303 matching lines @@
 static v8::Local<v8::Object> toV8Object(DOMArrayBufferBase* impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     if (!impl)
         return v8::Local<v8::Object>();
     v8::Local<v8::Value> wrapper = toV8(impl, creationContext, isolate);
     if (wrapper.IsEmpty())
         return v8::Local<v8::Object>();
     return wrapper.As<v8::Object>();
 }
 
+static v8::Local<v8::Object> toV8Object(ImageBitmap* impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
+{
+    if (!impl)
+        return v8::Local<v8::Object>();
+    v8::Local<v8::Value> wrapper = toV8(impl, creationContext, isolate);
+    if (wrapper.IsEmpty())
+        return v8::Local<v8::Object>();
+    return wrapper.As<v8::Object>();
+}
+
 // Returns true if the provided object is to be considered a 'host object', as used in the
 // HTML5 structured clone algorithm.
 static bool isHostObject(v8::Local<v8::Object> object)
 {
     // If the object has any internal fields, then we won't be able to serialize or deserialize
     // them; conveniently, this is also a quick way to detect DOM wrapper objects, because
     // the mechanism for these relies on data stored in these fields. We should
     // catch external array data as a special case.
     return object->InternalFieldCount();
 }
 
-ScriptValueSerializer::ScriptValueSerializer(SerializedScriptValueWriter& writer, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, WebBlobInfoArray* blobInfo, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, ScriptState* scriptState)
+ScriptValueSerializer::ScriptValueSerializer(SerializedScriptValueWriter& writer, MessagePortArray* messagePorts, ArrayBufferArray* arrayBuffers, ImageBitmapArray* imageBitmaps, WebBlobInfoArray* blobInfo, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, ScriptState* scriptState)
     : m_scriptState(scriptState)
     , m_writer(writer)
     , m_tryCatch(tryCatch)
     , m_depth(0)
     , m_status(Success)
     , m_nextObjectReference(0)
     , m_blobInfo(blobInfo)
     , m_blobDataHandles(blobDataHandles)
 {
     ASSERT(!tryCatch.HasCaught());
     v8::Local<v8::Object> creationContext = m_scriptState->context()->Global();
     if (messagePorts) {
         for (size_t i = 0; i < messagePorts->size(); i++)
             m_transferredMessagePorts.set(toV8Object(messagePorts->at(i).get(), creationContext, isolate()), i);
     }
     if (arrayBuffers) {
         for (size_t i = 0; i < arrayBuffers->size(); i++)  {
             v8::Local<v8::Object> v8ArrayBuffer = toV8Object(arrayBuffers->at(i).get(), creationContext, isolate());
             // Coalesce multiple occurences of the same buffer to the first index.
             if (!m_transferredArrayBuffers.contains(v8ArrayBuffer))
                 m_transferredArrayBuffers.set(v8ArrayBuffer, i);
         }
     }
+    if (imageBitmaps) {
+        for (size_t i = 0; i < imageBitmaps->size(); i++) {
+            v8::Local<v8::Object> v8ImageBitmap = toV8Object(imageBitmaps->at(i).get(), creationContext, isolate());
+            if (!m_transferredImageBitmaps.contains(v8ImageBitmap))
+                m_transferredImageBitmaps.set(v8ImageBitmap, i);
+        }
+    }
 }
 
 ScriptValueSerializer::Status ScriptValueSerializer::serialize(v8::Local<v8::Value> value)
 {
     v8::HandleScope scope(isolate());
     m_writer.writeVersion();
     StateBase* state = doSerialize(value, 0);
     while (state)
         state = state->advance(*this);
     return m_status;
@@ skipping 32 matching lines @@
     } else if (value->IsUint32()) {
         m_writer.writeUint32(value.As<v8::Uint32>()->Value());
     } else if (value->IsNumber()) {
         m_writer.writeNumber(value.As<v8::Number>()->Value());
     } else if (value->IsString()) {
         writeString(value);
     } else if (value->IsObject()) {
         v8::Local<v8::Object> jsObject = value.As<v8::Object>();
 
         uint32_t arrayBufferIndex;
+        uint32_t imageBitmapIndex;
         if (V8ArrayBufferView::hasInstance(value, isolate())) {
             return writeAndGreyArrayBufferView(jsObject, next);
         } else if (V8MessagePort::hasInstance(value, isolate())) {
             uint32_t messagePortIndex;
             if (!m_transferredMessagePorts.tryGet(jsObject, &messagePortIndex))
                 return handleError(DataCloneError, "A MessagePort could not be cloned.", next);
             m_writer.writeTransferredMessagePort(messagePortIndex);
             return nullptr;
         } else if (V8ArrayBuffer::hasInstance(value, isolate()) && m_transferredArrayBuffers.tryGet(jsObject, &arrayBufferIndex)) {
             return writeTransferredArrayBuffer(value, arrayBufferIndex, next);
         } else if (V8SharedArrayBuffer::hasInstance(value, isolate()) && m_transferredArrayBuffers.tryGet(jsObject, &arrayBufferIndex)) {
             return writeTransferredSharedArrayBuffer(value, arrayBufferIndex, next);
+        } else if (V8ImageBitmap::hasInstance(value, isolate()) && m_transferredImageBitmaps.tryGet(jsObject, &imageBitmapIndex)) {
+            return writeTransferredImageBitmap(value, imageBitmapIndex, next);
         }
 
         greyObject(jsObject);
         if (value->IsDate()) {
             m_writer.writeDate(value.As<v8::Date>()->ValueOf());
         } else if (value->IsStringObject()) {
             writeStringObject(value);
         } else if (value->IsNumberObject()) {
             writeNumberObject(value);
         } else if (value->IsBooleanObject()) {
@@ skipping 258 matching lines @@
 {
     DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(value.As<v8::Object>());
     if (!arrayBuffer)
         return 0;
     if (arrayBuffer->isNeutered())
         return handleError(DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
     m_writer.writeTransferredArrayBuffer(index);
     return 0;
 }
 
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeTransferredImageBitmap(v8::Local<v8::Value> value, uint32_t index, ScriptValueSerializer::StateBase* next)
+{
+    ImageBitmap* imageBitmap = V8ImageBitmap::toImpl(value.As<v8::Object>());
+    if (!imageBitmap)
+        return 0;
+    if (imageBitmap->isNeutered())
+        return handleError(DataCloneError, "An ImageBitmap is neutered and could not be cloned.", next);
+    m_writer.writeTransferredImageBitmap(index);
+    return 0;
+}
+
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeTransferredSharedArrayBuffer(v8::Local<v8::Value> value, uint32_t index, ScriptValueSerializer::StateBase* next)
 {
     ASSERT(RuntimeEnabledFeatures::sharedArrayBufferEnabled());
     DOMSharedArrayBuffer* sharedArrayBuffer = V8SharedArrayBuffer::toImpl(value.As<v8::Object>());
     if (!sharedArrayBuffer)
         return 0;
     m_writer.writeTransferredSharedArrayBuffer(index);
     return 0;
 }
 
@@ skipping 308 matching lines @@
     case ArrayBufferTransferTag: {
         if (!m_version)
             return false;
         uint32_t index;
         if (!doReadUint32(&index))
             return false;
         if (!creator.tryGetTransferredArrayBuffer(index, value))
             return false;
         break;
     }
+    case ImageBitmapTransferTag: {
+        if (!m_version)
+            return false;
+        uint32_t index;
+        if (!doReadUint32(&index))
+            return false;
+        if (!creator.tryGetTransferredImageBitmap(index, value))
+            return false;
+        break;
+    }
     case SharedArrayBufferTransferTag: {
         if (!m_version)
             return false;
         uint32_t index;
         if (!doReadUint32(&index))
             return false;
         if (!creator.tryGetTransferredSharedArrayBuffer(index, value))
             return false;
         break;
     }
@@ skipping 694 matching lines @@
         v8::Local<v8::Object> creationContext = m_reader.scriptState()->context()->Global();
         result = toV8(buffer.get(), 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_imageBitmaps)
+        return false;
+    if (index >= m_imageBitmaps->size())
+        return false;
+    v8::Local<v8::Object> creationContext = m_reader.scriptState()->context()->Global();
+    *object = toV8(m_imageBitmaps->at(index).get(), creationContext, m_reader.scriptState()->isolate());
+    return !object->IsEmpty();
+}
+
 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()) {
         RefPtr<DOMSharedArrayBuffer> buffer = DOMSharedArrayBuffer::create(m_arrayBufferContents->at(index));
@@ skipping 79 matching lines @@
         return false;
     uint32_t objectReference = 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