Make OffscreenCanvas Transferable

third_party/WebKit/Source/bindings/modules/v8/ScriptValueSerializerForModules.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/modules/v8/ScriptValueSerializerForModules.h"
 
 #include "bindings/core/v8/SerializationTag.h"
 #include "bindings/core/v8/V8Binding.h"
+#include "bindings/modules/v8/TransferablesForModules.h"
 #include "bindings/modules/v8/V8CryptoKey.h"
 #include "bindings/modules/v8/V8DOMFileSystem.h"
+#include "bindings/modules/v8/V8OffscreenCanvas.h"
 #include "modules/filesystem/DOMFileSystem.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
 
 enum CryptoKeyAlgorithmTag {
     AesCbcTag = 1,
     HmacTag = 2,
     RsaSsaPkcs1v1_5Tag = 3,
     // ID 4 was used by RsaEs, while still behind experimental flag.
@@ skipping 44 matching lines @@
     NoParamsKeyTag = 6,
     // Maximum allowed value is 255
 };
 
 enum AssymetricCryptoKeyType {
     PublicKeyType = 1,
     PrivateKeyType = 2,
     // Maximum allowed value is 2^32-1
 };
 
-
-ScriptValueSerializerForModules::ScriptValueSerializerForModules(SerializedScriptValueWriter& writer, const Transferables* transferables, WebBlobInfoArray* blobInfo, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, ScriptState* scriptState)
+ScriptValueSerializerForModules::ScriptValueSerializerForModules(SerializedScriptValueWriter& writer, Transferables* transferables, WebBlobInfoArray* blobInfo, BlobDataHandleMap& blobDataHandles, v8::TryCatch& tryCatch, ScriptState* scriptState)
     : ScriptValueSerializer(writer, transferables, blobInfo, blobDataHandles, tryCatch, scriptState)
+    , m_writer(writer)
 {
+    ASSERT(!tryCatch.HasCaught());
+    if (!transferables)
+        return;
+    auto& offscreenCanvases = static_cast<TransferablesForModules*>(transferables)->offscreenCanvases;
+    for (size_t i = 0; i < offscreenCanvases.size(); i++) {
+        v8::Local<v8::Object> v8OffscreenCanvas;
+        if (offscreenCanvases[i].get()) {
+            v8::Local<v8::Value> wrapper = toV8(offscreenCanvases[i].get(), scriptState);
+            if (!wrapper.IsEmpty()) {
+                v8OffscreenCanvas = wrapper.As<v8::Object>();
+                if (!m_transferredOffscreenCanvas.contains(v8OffscreenCanvas))
+                    m_transferredOffscreenCanvas.set(v8OffscreenCanvas, i);
+            }
+        }
+    }
 }
 
 ScriptValueSerializer::StateBase* ScriptValueSerializerForModules::writeDOMFileSystem(v8::Local<v8::Value> value, ScriptValueSerializer::StateBase* next)
 {
     DOMFileSystem* fs = V8DOMFileSystem::toImpl(value.As<v8::Object>());
     if (!fs)
         return 0;
     if (!fs->clonable())
         return handleError(DataCloneError, "A FileSystem object could not be cloned.", next);
 
@@ skipping 10 matching lines @@
 }
 
 void SerializedScriptValueWriterForModules::writeDOMFileSystem(int type, const String& name, const String& url)
 {
     append(DOMFileSystemTag);
     doWriteUint32(type);
     doWriteWebCoreString(name);
     doWriteWebCoreString(url);
 }
 
+void SerializedScriptValueWriterForModules::writeTransferredOffscreenCanvas(uint32_t index, uint32_t width, uint32_t height, uint32_t id)
+{
+    append(OffscreenCanvasTransferTag);
+    doWriteUint32(index);
+    doWriteUint32(width);
+    doWriteUint32(height);
+    doWriteUint32(id);
+}
+
 bool SerializedScriptValueWriterForModules::writeCryptoKey(const WebCryptoKey& key)
 {
     append(static_cast<uint8_t>(CryptoKeyTag));
 
     switch (key.algorithm().paramsType()) {
     case WebCryptoKeyAlgorithmParamsTypeAes:
         doWriteAesKey(key);
         break;
     case WebCryptoKeyAlgorithmParamsTypeHmac:
         doWriteHmacKey(key);
@@ skipping 180 matching lines @@
             return handleError(DataCloneError, "An object could not be cloned.", next);
         greyObject(jsObject);
 
         if (isDOMFileSystem)
             return writeDOMFileSystem(value, next);
 
         if (!writeCryptoKey(value))
             return handleError(DataCloneError, "Couldn't serialize key data", next);
         return 0;
     }
+    v8::Local<v8::Object> jsObject = value.As<v8::Object>();
+    uint32_t offscreenCanvasIndex;
+    if (V8OffscreenCanvas::hasInstance(value, isolate()) && m_transferredOffscreenCanvas.tryGet(jsObject, &offscreenCanvasIndex)) {
+        return writeTransferredOffscreenCanvas(value, offscreenCanvasIndex, next);
+    }
     return ScriptValueSerializer::doSerializeValue(value, next);
 }
 
+ScriptValueSerializer::StateBase* ScriptValueSerializerForModules::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 neutered 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;
+}
+
 bool SerializedScriptValueReaderForModules::read(v8::Local<v8::Value>* value, ScriptValueCompositeCreator& creator)
 {
     SerializationTag tag;
     if (!readTag(&tag))
         return false;
     switch (tag) {
     case DOMFileSystemTag:
         if (!readDOMFileSystem(value))
             return false;
         creator.pushObjectReference(*value);
         break;
     case CryptoKeyTag:
         if (!readCryptoKey(value))
             return false;
         creator.pushObjectReference(*value);
         break;
+    case OffscreenCanvasTransferTag:
+        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;
     default:
         return SerializedScriptValueReader::readWithTag(tag, value, creator);
     }
     return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReaderForModules::readDOMFileSystem(v8::Local<v8::Value>* value)
 {
     uint32_t type;
     String name;
@@ skipping 280 matching lines @@
     if (rawUsages & UnwrapKeyUsage)
         usages |= WebCryptoKeyUsageUnwrapKey;
     if (rawUsages & DeriveBitsUsage)
         usages |= WebCryptoKeyUsageDeriveBits;
 
     return true;
 }
 
 ScriptValueDeserializerForModules::ScriptValueDeserializerForModules(SerializedScriptValueReaderForModules& reader, MessagePortArray* messagePorts, ArrayBufferContentsArray* arrayBufferContents, ImageBitmapContentsArray* imageBitmapContents)
     : ScriptValueDeserializer(reader, messagePorts, arrayBufferContents, imageBitmapContents)
+    , m_reader(reader)
 {
 }
 
+bool ScriptValueDeserializerForModules::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 ScriptValueDeserializerForModules::read(v8::Local<v8::Value>* value)
 {
     return toSerializedScriptValueReaderForModules(reader()).read(value, *this);
 }
 
 } // namespace blink