Make OffscreenCanvas Transferable

third_party/WebKit/Source/bindings/core/v8/SerializedScriptValueFactory.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/SerializedScriptValueFactory.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptValueSerializer.h"
 #include "bindings/core/v8/Transferables.h"
+#include "bindings/core/v8/V8ArrayBuffer.h"
+#include "bindings/core/v8/V8ImageBitmap.h"
+#include "bindings/core/v8/V8MessagePort.h"
+#include "bindings/core/v8/V8SharedArrayBuffer.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/MessagePort.h"
 #include "core/frame/ImageBitmap.h"
 #include "wtf/ByteOrder.h"
 #include "wtf/text/StringBuffer.h"
 
 namespace blink {
 
 SerializedScriptValueFactory* SerializedScriptValueFactory::m_instance = 0;
 
@@ skipping 11 matching lines @@
             exceptionState.rethrowV8Exception(tryCatch.Exception());
             return serializedValue.release();
         }
     }
     switch (status) {
     case ScriptValueSerializer::InputError:
     case ScriptValueSerializer::DataCloneError:
         exceptionState.throwDOMException(ScriptValueSerializer::DataCloneError, errorMessage);
         return serializedValue.release();
     case ScriptValueSerializer::Success:
-        transferData(serializedValue.get(), writer, transferables, exceptionState, isolate);
+        transferData(isolate, transferables, exceptionState, serializedValue.get(), writer);
         return serializedValue.release();
     case ScriptValueSerializer::JSException:
         ASSERT_NOT_REACHED();
         break;
     }
     ASSERT_NOT_REACHED();
     return serializedValue.release();
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValueFactory::create(v8::Isolate* isolate, v8::Local<v8::Value> value, Transferables* transferables, ExceptionState& exceptionState)
@@ skipping 44 matching lines @@
     writer.writeWebCoreString(data);
     String wireData = writer.takeWireString();
     return createFromWire(wireData);
 }
 
 PassRefPtr<SerializedScriptValue> SerializedScriptValueFactory::create()
 {
     return adoptRef(new SerializedScriptValue());
 }
 
-void SerializedScriptValueFactory::transferData(SerializedScriptValue* serializedValue, SerializedScriptValueWriter& writer, Transferables* transferables, ExceptionState& exceptionState, v8::Isolate* isolate)
+void SerializedScriptValueFactory::transferData(v8::Isolate* isolate, Transferables* transferables, ExceptionState& exceptionState, SerializedScriptValue* serializedValue, SerializedScriptValueWriter& writer)
 {
     serializedValue->setData(writer.takeWireString());
     ASSERT(serializedValue->data().impl()->hasOneRef());
     if (!transferables)
         return;
 
     serializedValue->transferImageBitmaps(isolate, transferables->imageBitmaps, exceptionState);
     if (exceptionState.hadException())
         return;
     serializedValue->transferArrayBuffers(isolate, transferables->arrayBuffers, exceptionState);
@@ skipping 31 matching lines @@
     // information stored in m_data isn't even encoded in UTF-16. Instead,
     // unicode characters are encoded as UTF-8 with two code units per UChar.
     SerializedScriptValueReader reader(reinterpret_cast<const uint8_t*>(data.impl()->characters16()), 2 * data.length(), blobInfo, blobDataHandles, ScriptState::current(isolate));
     ScriptValueDeserializer deserializer(reader, messagePorts, arrayBufferContentsArray, imageBitmapContentsArray);
 
     // deserialize() can run arbitrary script (e.g., setters), which could result in |this| being destroyed.
     // Holding a RefPtr ensures we are alive (along with our internal data) throughout the operation.
     return deserializer.deserialize();
 }
 
+bool SerializedScriptValueFactory::extractTransferables(v8::Isolate* isolate, Transferables& transferables, ExceptionState& exceptionState, v8::Local<v8::Value>& transferableObject, unsigned index)
+{
+    // Validation of Objects implementing an interface, per WebIDL spec 4.1.15.
+    if (V8MessagePort::hasInstance(transferableObject, isolate)) {
+        MessagePort* port = V8MessagePort::toImpl(v8::Local<v8::Object>::Cast(transferableObject));
+        // Check for duplicate MessagePorts.
+        if (transferables.messagePorts.contains(port)) {
+            exceptionState.throwDOMException(DataCloneError, "Message port at index " + String::number(index) + " is a duplicate of an earlier port.");
+            return false;
+        }
+        transferables.messagePorts.append(port);
+        return true;
+    }
+    if (V8ArrayBuffer::hasInstance(transferableObject, isolate)) {
+        DOMArrayBuffer* arrayBuffer = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(transferableObject));
+        if (transferables.arrayBuffers.contains(arrayBuffer)) {
+            exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(index) + " is a duplicate of an earlier ArrayBuffer.");
+            return false;
+        }
+        transferables.arrayBuffers.append(arrayBuffer);
+        return true;
+    }
+    if (V8SharedArrayBuffer::hasInstance(transferableObject, isolate)) {
+        DOMSharedArrayBuffer* sharedArrayBuffer = V8SharedArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(transferableObject));
+        if (transferables.arrayBuffers.contains(sharedArrayBuffer)) {
+            exceptionState.throwDOMException(DataCloneError, "SharedArrayBuffer at index " + String::number(index) + " is a duplicate of an earlier SharedArrayBuffer.");
+            return false;
+        }
+        transferables.arrayBuffers.append(sharedArrayBuffer);
+        return true;
+    }
+    if (V8ImageBitmap::hasInstance(transferableObject, isolate)) {
+        ImageBitmap* imageBitmap = V8ImageBitmap::toImpl(v8::Local<v8::Object>::Cast(transferableObject));
+        if (transferables.imageBitmaps.contains(imageBitmap)) {
+            exceptionState.throwDOMException(DataCloneError, "ImageBitmap at index " + String::number(index) + " is a duplicate of an earlier ImageBitmap.");
+            return false;
+        }
+        transferables.imageBitmaps.append(imageBitmap);
+        return true;
+    }
+    return false;
+}
 
 } // namespace blink