Reland of: Make OffscreenCanvas 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 "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"
 #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/V8OffscreenCanvas.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"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "public/platform/Platform.h"
@@ skipping 308 matching lines @@
     append(ArrayBufferTransferTag);
     doWriteUint32(index);
 }
 
 void SerializedScriptValueWriter::writeTransferredImageBitmap(uint32_t index)
 {
     append(ImageBitmapTransferTag);
     doWriteUint32(index);
 }
 
+void SerializedScriptValueWriter::writeTransferredOffscreenCanvas(uint32_t index, uint32_t width, uint32_t height, uint32_t id)
+{
+    append(OffscreenCanvasTransferTag);
+    doWriteUint32(index);
+    doWriteUint32(width);
+    doWriteUint32(height);
+    doWriteUint32(id);
+}
+
 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(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>();
 }
 
+static v8::Local<v8::Object> toV8Object(OffscreenCanvas* 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(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>();
 }
 
@@ skipping 43 matching lines @@
         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 = toV8Object(imageBitmaps[i].get(), creationContext, isolate());
         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 = toV8Object(offscreenCanvases[i].get(), creationContext, isolate());
+        if (!m_transferredOffscreenCanvas.contains(v8OffscreenCanvas))
+            m_transferredOffscreenCanvas.set(v8OffscreenCanvas, 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 33 matching lines @@
         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;
+        uint32_t offscreenCanvasIndex;
         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 (V8ImageBitmap::hasInstance(value, isolate()) && m_transferredImageBitmaps.tryGet(jsObject, &imageBitmapIndex)) {
             return writeTransferredImageBitmap(value, imageBitmapIndex, next);
         } else if (V8SharedArrayBuffer::hasInstance(value, isolate()) && m_transferredArrayBuffers.tryGet(jsObject, &arrayBufferIndex)) {
             return writeTransferredSharedArrayBuffer(value, arrayBufferIndex, next);
+        } else if (V8OffscreenCanvas::hasInstance(value, isolate()) && m_transferredOffscreenCanvas.tryGet(jsObject, &offscreenCanvasIndex)) {
+            return writeTransferredOffscreenCanvas(value, offscreenCanvasIndex, 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 283 matching lines @@
 {
     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::writeTransferredOffscreenCanvas(v8::Local<v8::Value> value, uint32_t index, ScriptValueSerializer::StateBase* next)
+{
+    OffscreenCanvas* offscreenCanvas = V8OffscreenCanvas::toImpl(value.As<v8::Object>());
+    if (!offscreenCanvas)
+        return nullptr;
+    if (offscreenCanvas->isNeutered())
+        return handleError(DataCloneError, "An OffscreenCanvas is detached and could not be cloned.", next);
+    if (offscreenCanvas->renderingContext())
+        return handleError(DataCloneError, "An OffscreenCanvas with a context could not be cloned.", next);
+    m_writer.writeTransferredOffscreenCanvas(index, offscreenCanvas->width(), offscreenCanvas->height(), offscreenCanvas->getAssociatedCanvasId());
+    return nullptr;
+}
+
 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 323 matching lines @@
     case ImageBitmapTransferTag: {
         if (!m_version)
             return false;
         uint32_t index;
         if (!doReadUint32(&index))
             return false;
         if (!creator.tryGetTransferredImageBitmap(index, value))
             return false;
         break;
     }
+    case OffscreenCanvasTransferTag: {
+        if (!m_version)
+            return false;
+        uint32_t index, width, height, id;
+        if (!doReadUint32(&index))
+            return false;
+        if (!doReadUint32(&width))
+            return false;
+        if (!doReadUint32(&height))
+            return false;
+        if (!doReadUint32(&id))
+            return false;
+        if (!creator.tryGetTransferredOffscreenCanvas(index, width, height, id, 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 758 matching lines @@
         v8::Local<v8::Object> creationContext = m_reader.getScriptState()->context()->Global();
         result = toV8(buffer, creationContext, isolate);
         if (result.IsEmpty())
             return false;
         m_arrayBuffers[index] = result;
     }
     *object = result;
     return true;
 }
 
+bool ScriptValueDeserializer::tryGetTransferredOffscreenCanvas(uint32_t index, uint32_t width, uint32_t height, uint32_t id, v8::Local<v8::Value>* object)
+{
+    OffscreenCanvas* offscreenCanvas = OffscreenCanvas::create(width, height);
+    offscreenCanvas->setAssociatedCanvasId(id);
+    *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;
     *object = m_objectPool[reference];
     return object;
 }
 
 uint32_t ScriptValueDeserializer::objectReferenceCount()
 {
@@ skipping 58 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