Reland of: Make OffscreenCanvas 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 22 matching lines @@
 #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/Transferables.h"
 #include "bindings/core/v8/V8ArrayBuffer.h"
 #include "bindings/core/v8/V8ImageBitmap.h"
 #include "bindings/core/v8/V8MessagePort.h"
+#include "bindings/core/v8/V8OffscreenCanvas.h"
 #include "bindings/core/v8/V8SharedArrayBuffer.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMSharedArrayBuffer.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/MessagePort.h"
 #include "core/frame/ImageBitmap.h"
 #include "platform/SharedBuffer.h"
 #include "platform/blob/BlobData.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Assertions.h"
@@ skipping 80 matching lines @@
     HeapHashSet<Member<ImageBitmap>> visited;
     for (size_t i = 0; i < imageBitmaps.size(); ++i) {
         if (visited.contains(imageBitmaps[i]))
             continue;
         visited.add(imageBitmaps[i]);
         contents->append(imageBitmaps[i]->transfer());
     }
     m_imageBitmapContentsArray = contents.release();
 }
 
+void SerializedScriptValue::transferOffscreenCanvas(v8::Isolate* isolate, const OffscreenCanvasArray& offscreenCanvases, ExceptionState& exceptionState)
+{
+    if (!offscreenCanvases.size())
+        return;
+
+    HeapHashSet<Member<OffscreenCanvas>> visited;
+    for (size_t i = 0; i < offscreenCanvases.size(); i++) {
+        if (offscreenCanvases[i]->isNeutered()) {
+            exceptionState.throwDOMException(DataCloneError, "OffscreenCanvas at index " + String::number(i) + " is already neutered.");
+            return;
+        }
+        if (offscreenCanvases[i]->renderingContext()) {
+            exceptionState.throwDOMException(DataCloneError, "OffscreenCanvas at index " + String::number(i) + " has an associated context.");
+            return;
+        }
+        if (visited.contains(offscreenCanvases[i].get()))

[sof, 2016/04/26 19:37:15]

If it really is legal/expected to have duplicates here, should this check be at
the top/first? 

[xidachen, 2016/04/26 20:40:59]

Done.

+            continue;
+        visited.add(offscreenCanvases[i].get());
+        offscreenCanvases[i].get()->setNeutered();
+    }
+}
 
 void SerializedScriptValue::transferArrayBuffers(v8::Isolate* isolate, const ArrayBufferArray& arrayBuffers, ExceptionState& exceptionState)
 {
     if (!arrayBuffers.size())
         return;
 
     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;
@@ skipping 106 matching lines @@
                 return false;
             }
             transferables.arrayBuffers.append(sharedArrayBuffer);
         } else 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(i) + " is a duplicate of an earlier ImageBitmap.");
                 return false;
             }
             transferables.imageBitmaps.append(imageBitmap);
+        } else if (V8OffscreenCanvas::hasInstance(transferableObject, isolate)) {
+            OffscreenCanvas* offscreenCanvas = V8OffscreenCanvas::toImpl(v8::Local<v8::Object>::Cast(transferableObject));
+            if (transferables.offscreenCanvases.contains(offscreenCanvas)) {
+                exceptionState.throwDOMException(DataCloneError, "OffscreenCanvas at index " + String::number(i) + " is a duplicate of an earlier OffscreenCanvas.");
+                return false;
+            }
+            transferables.offscreenCanvases.append(offscreenCanvas);
         } else {
             exceptionState.throwTypeError("Value at index " + String::number(i) + " does not have a transferable type.");
             return false;
         }
     }
     return true;
 }
 
 void SerializedScriptValue::registerMemoryAllocatedWithCurrentScriptContext()
 {
     if (m_externallyAllocatedMemory)
         return;
     m_externallyAllocatedMemory = static_cast<intptr_t>(m_data.length());
     v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(m_externallyAllocatedMemory);
 }
 
 bool SerializedScriptValue::containsTransferableArrayBuffer() const
 {
     return m_arrayBufferContentsArray && !m_arrayBufferContentsArray->isEmpty();
 }
 
 } // namespace blink