Make ImageBitmap Transferable

third_party/WebKit/Source/bindings/core/v8/SerializedScriptValue.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 20 matching lines @@
 #include "config.h"
 #include "bindings/core/v8/SerializedScriptValue.h"
 
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValueSerializer.h"
 #include "bindings/core/v8/SerializedScriptValueFactory.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/ExceptionCode.h"
 #include "platform/SharedBuffer.h"
 #include "platform/blob/BlobData.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Assertions.h"
 #include "wtf/ByteOrder.h"
 #include "wtf/Vector.h"
 #include "wtf/text/StringBuffer.h"
@@ skipping 43 matching lines @@
             if (!wrapper.IsEmpty())
                 buffers.append(v8::Local<v8::ArrayBuffer>::Cast(wrapper));
         }
     } else {
         v8::Local<v8::Object> wrapper = DOMWrapperWorld::current(isolate).domDataStore().get(object, isolate);
         if (!wrapper.IsEmpty())
             buffers.append(v8::Local<v8::ArrayBuffer>::Cast(wrapper));
     }
 }
 
+PassOwnPtr<ImageBitmapArray> SerializedScriptValue::createImageBitmaps(v8::Isolate* isolate, ImageBitmapArray& imageBitmaps, ExceptionState& exceptionState)
+{
+    ASSERT(imageBitmaps.size());
+
+    for (size_t i = 0; i < imageBitmaps.size(); i++) {
+        if (imageBitmaps[i]->isNeutered()) {
+            exceptionState.throwDOMException(DataCloneError, "ImageBitmap at index " + String::number(i) + " is already neutered.");
+            return nullptr;
+        }
+    }
+
+    OwnPtr<ImageBitmapArray> contents = adoptPtr(new ImageBitmapArray(imageBitmaps.size()));
+    HashSet<ImageBitmap*> visited;
+    for (size_t i = 0; i < imageBitmaps.size(); i++) {
+        if (visited.contains(imageBitmaps[i].get()))
+            continue;
+        visited.add(imageBitmaps[i].get());
+        contents->at(i) = imageBitmaps[i]->transfer();
+        imageBitmaps[i]->neuter();
+    }
+
+    return contents.release();
+}
+
 PassOwnPtr<SerializedScriptValue::ArrayBufferContentsArray> SerializedScriptValue::createArrayBuffers(v8::Isolate* isolate, ArrayBufferArray& arrayBuffers, ExceptionState& exceptionState)
 {
     ASSERT(arrayBuffers.size());
 
     for (size_t i = 0; i < arrayBuffers.size(); i++) {
         if (arrayBuffers[i]->isNeutered()) {
             exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " is already neutered.");
             return nullptr;
         }
     }
@@ skipping 12 matching lines @@
                 exceptionState.throwDOMException(DataCloneError, "SharedArrayBuffer at index " + String::number(i) + " could not be transferred.");
                 return nullptr;
             }
         } else {
             Vector<v8::Local<v8::ArrayBuffer>, 4> bufferHandles;
             v8::HandleScope handleScope(isolate);
             acculumateArrayBuffersForAllWorlds(isolate, static_pointer_cast<DOMArrayBuffer>(arrayBuffers[i]).get(), bufferHandles);
             bool isNeuterable = true;
             for (size_t j = 0; j < bufferHandles.size(); j++)
                 isNeuterable &= bufferHandles[j]->IsNeuterable();
-
             RefPtr<DOMArrayBufferBase> toTransfer = arrayBuffers[i];
             if (!isNeuterable)
                 toTransfer = DOMArrayBuffer::create(arrayBuffers[i]->buffer());
             bool result = toTransfer->transfer(contents->at(i));
             if (!result) {
                 exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " could not be transferred.");
                 return nullptr;
             }
 
             if (isNeuterable)
                 for (size_t j = 0; j < bufferHandles.size(); j++)
                     bufferHandles[j]->Neuter();
         }
-
     }
 
     return contents.release();
 }
 
 SerializedScriptValue::SerializedScriptValue(const String& wireData)
     : m_externallyAllocatedMemory(0)
 {
     m_data = wireData.isolatedCopy();
 }
 
 v8::Local<v8::Value> SerializedScriptValue::deserialize(MessagePortArray* messagePorts)
 {
     return deserialize(v8::Isolate::GetCurrent(), messagePorts, 0);
 }
 
 v8::Local<v8::Value> SerializedScriptValue::deserialize(v8::Isolate* isolate, MessagePortArray* messagePorts, const WebBlobInfoArray* blobInfo)
 {
     return SerializedScriptValueFactory::instance().deserialize(this, isolate, messagePorts, blobInfo);
 }
 
-bool SerializedScriptValue::extractTransferables(v8::Isolate* isolate, v8::Local<v8::Value> value, int argumentIndex, MessagePortArray& ports, ArrayBufferArray& arrayBuffers, ExceptionState& exceptionState)
+bool SerializedScriptValue::extractTransferables(v8::Isolate* isolate, v8::Local<v8::Value> value, int argumentIndex, MessagePortArray& ports, ArrayBufferArray& arrayBuffers, ImageBitmapArray& imageBitmaps, ExceptionState& exceptionState)
 {
     if (isUndefinedOrNull(value)) {
         ports.resize(0);
         arrayBuffers.resize(0);
+        imageBitmaps.resize(0);
         return true;
     }
 
     uint32_t length = 0;
     if (value->IsArray()) {
         v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(value);
         length = array->Length();
     } else if (!toV8Sequence(value, length, isolate, exceptionState)) {
         if (!exceptionState.hadException())
             exceptionState.throwTypeError(ExceptionMessages::notAnArrayTypeArgumentOrValue(argumentIndex + 1));
@@ skipping 28 matching lines @@
                 return false;
             }
             arrayBuffers.append(arrayBuffer.release());
         } else if (V8SharedArrayBuffer::hasInstance(transferrable, isolate)) {
             RefPtr<DOMSharedArrayBuffer> sharedArrayBuffer = V8SharedArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(transferrable));
             if (arrayBuffers.contains(sharedArrayBuffer)) {
                 exceptionState.throwDOMException(DataCloneError, "SharedArrayBuffer at index " + String::number(i) + " is a duplicate of an earlier SharedArrayBuffer.");
                 return false;
             }
             arrayBuffers.append(sharedArrayBuffer.release());
+        } else if (V8ImageBitmap::hasInstance(transferrable, isolate)) {
+            RefPtr<ImageBitmap> imageBitmap = V8ImageBitmap::toImpl(v8::Local<v8::Object>::Cast(transferrable));
+            if (imageBitmaps.contains(imageBitmap)) {
+                exceptionState.throwDOMException(DataCloneError, "ImageBitmap at index " + String::number(i) + " is a duplicate of an earlier ImageBitmap.");
+                return false;
+            }
+            imageBitmaps.append(imageBitmap.release());
         } else {
             exceptionState.throwTypeError("Value at index " + String::number(i) + " does not have a transferable type.");
             return false;
         }
     }
     return true;
 }
 
 void SerializedScriptValue::registerMemoryAllocatedWithCurrentScriptContext()
 {
@@ skipping 17 matching lines @@
         ASSERT(v8::Isolate::GetCurrent());
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 void SerializedScriptValue::transferArrayBuffers(v8::Isolate* isolate, ArrayBufferArray& arrayBuffers, ExceptionState& exceptionState)
 {
     m_arrayBufferContentsArray = createArrayBuffers(isolate, arrayBuffers, exceptionState);
 }
 
+void SerializedScriptValue::transferImageBitmaps(v8::Isolate* isolate, ImageBitmapArray& imageBitmaps, ExceptionState& exceptionState)
+{
+    m_imageBitmapsArray = createImageBitmaps(isolate, imageBitmaps, exceptionState);
+}
+
 } // namespace blink