[wasm] Support wasm module structured cloning.

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 873 matching lines @@
         return writeAndGreyArrayBuffer(object, next);
     }
     if (object->IsSharedArrayBuffer()) {
         uint32_t index;
         if (!m_transferredArrayBuffers.tryGet(object, &index)) {
             return handleError(Status::DataCloneError, "A SharedArrayBuffer could not be cloned.", next);
         }
         return writeTransferredSharedArrayBuffer(object, index, next);
     }
 
+    if (object->IsWebAssemblyCompiledModule())
+        return writeWasmCompiledModule(object, next);
+
     // Transferable only objects
     if (V8MessagePort::hasInstance(object, isolate())) {
         uint32_t index;
         if (!m_transferredMessagePorts.tryGet(object, &index)) {
             return handleError(Status::DataCloneError, "A MessagePort could not be cloned.", next);
         }
         m_writer.writeTransferredMessagePort(index);
         return nullptr;
     }
     if (V8OffscreenCanvas::hasInstance(object, isolate())) {
@@ skipping 287 matching lines @@
     //
     // We do need to grey the underlying buffer before we grey its view, however;
     // ArrayBuffers may be shared, so they need to be given reference IDs, and an
     // ArrayBufferView cannot be constructed without a corresponding ArrayBuffer
     // (or without an additional tag that would allow us to do two-stage construction
     // like we do for Objects and Arrays).
     greyObject(object);
     return nullptr;
 }
 
+ScriptValueSerializer::StateBase* ScriptValueSerializer::writeWasmCompiledModule(v8::Local<v8::Object> object, StateBase* next)
+{
+    CHECK(RuntimeEnabledFeatures::webAssemblySerializationEnabled());
+    // TODO (mtrofin): explore mechanism avoiding data copying / buffer resizing.
+    v8::Local<v8::WasmCompiledModule> wasmModule = object.As<v8::WasmCompiledModule>();
+    v8::WasmCompiledModule::SerializedModule data = wasmModule->Serialize();
+    m_writer.append(WasmModuleTag);
+    m_writer.doWriteUint32(static_cast<uint32_t>(data.second));
+    m_writer.append(data.first.get(), static_cast<int>(data.second));
+    return nullptr;
+}
+
 ScriptValueSerializer::StateBase* ScriptValueSerializer::writeAndGreyArrayBuffer(v8::Local<v8::Object> object, StateBase* next)
 {
     DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(object);
     if (!arrayBuffer)
         return nullptr;
     if (arrayBuffer->isNeutered())
         return handleError(Status::DataCloneError, "An ArrayBuffer is neutered and could not be cloned.", next);
 
     uint32_t index;
     if (m_transferredArrayBuffers.tryGet(object, &index)) {
@@ skipping 280 matching lines @@
         break;
     }
     case ArrayBufferViewTag: {
         if (!m_version)
             return false;
         if (!readArrayBufferView(value, deserializer))
             return false;
         deserializer.pushObjectReference(*value);
         break;
     }
+    case WasmModuleTag: {
+        if (!readWasmCompiledModule(value))
+            return false;
+        deserializer.pushObjectReference(*value);
+        break;
+    }
     case ArrayBufferTag: {
         if (!m_version)
             return false;
         if (!readArrayBuffer(value))
             return false;
         deserializer.pushObjectReference(*value);
         break;
     }
     case GenerateFreshObjectTag: {
         if (!m_version)
@@ skipping 332 matching lines @@
     uint32_t byteLength;
     if (!doReadUint32(&byteLength))
         return nullptr;
     if (m_position + byteLength > m_length)
         return nullptr;
     const void* bufferStart = m_buffer + m_position;
     m_position += byteLength;
     return DOMArrayBuffer::create(bufferStart, byteLength);
 }
 
+bool SerializedScriptValueReader::readWasmCompiledModule(v8::Local<v8::Value>* value)
+{
+    CHECK(RuntimeEnabledFeatures::webAssemblySerializationEnabled());
+    uint32_t size = 0;
+    if (!doReadUint32(&size))
+        return false;
+    if (m_position + size > m_length)
+        return false;
+    const uint8_t* buf = m_buffer + m_position;
+    // TODO(mtrofin): simplify deserializer API. const uint8_t* + size_t should
+    // be sufficient.
+    v8::WasmCompiledModule::SerializedModule data = {
+        std::unique_ptr<const uint8_t[]>(buf),
+        static_cast<size_t>(size)
+    };
+    v8::MaybeLocal<v8::WasmCompiledModule> retval = v8::WasmCompiledModule::Deserialize(isolate(), data);
+    data.first.release();
+    m_position += size;
+
+    // TODO(mtrofin): right now, we'll return undefined if the deserialization
+    // fails, which is what may happen when v8's version changes. Update when
+    // spec settles. crbug.com/639090
+    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());
     return !value->IsEmpty();
 }
 
 bool SerializedScriptValueReader::readArrayBufferView(v8::Local<v8::Value>* value, ScriptValueDeserializer& deserializer)
@@ skipping 624 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