Sharing of SharedArrayBuffer via PostMessage transfer

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 21 matching lines @@
 #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/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"
 #include "wtf/text/StringHash.h"
 
@@ skipping 54 matching lines @@
 
     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;
         }
     }
 
     OwnPtr<ArrayBufferContentsArray> contents = adoptPtr(new ArrayBufferContentsArray(arrayBuffers.size()));
 
-    HashSet<DOMArrayBuffer*> visited;
+    HashSet<DOMArrayBufferBase*> visited;
     for (size_t i = 0; i < arrayBuffers.size(); i++) {
         if (visited.contains(arrayBuffers[i].get()))
             continue;
         visited.add(arrayBuffers[i].get());
 
-        Vector<v8::Local<v8::ArrayBuffer>, 4> bufferHandles;
-        v8::HandleScope handleScope(isolate);
-        acculumateArrayBuffersForAllWorlds(isolate, arrayBuffers[i].get(), bufferHandles);
-        bool isNeuterable = true;
-        for (size_t j = 0; j < bufferHandles.size(); j++)
-            isNeuterable &= bufferHandles[j]->IsNeuterable();
+        if (!arrayBuffers[i]->isShared()) {

[haraken, 2015/06/11 05:59:28]

Avoid if(!f()) {} else {}. Instead you can use if(f()) {} 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<DOMArrayBuffer> 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;
+            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();
+        } else {
+            bool result = arrayBuffers[i]->transfer(contents->at(i));
+            if (!result) {
+                exceptionState.throwDOMException(DataCloneError, "SharedArrayBuffer 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)
@@ skipping 45 matching lines @@
                 return false;
             }
             ports.append(port.release());
         } else if (V8ArrayBuffer::hasInstance(transferrable, isolate)) {
             RefPtr<DOMArrayBuffer> arrayBuffer = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(transferrable));
             if (arrayBuffers.contains(arrayBuffer)) {
                 exceptionState.throwDOMException(DataCloneError, "ArrayBuffer at index " + String::number(i) + " is a duplicate of an earlier ArrayBuffer.");
                 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 {
             exceptionState.throwTypeError("Value at index " + String::number(i) + " does not have a transferable type.");
             return false;
         }
     }
     return true;
 }
 
 void SerializedScriptValue::registerMemoryAllocatedWithCurrentScriptContext()
 {
@@ skipping 13 matching lines @@
         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-m_externallyAllocatedMemory);
     }
 }
 
 void SerializedScriptValue::transferArrayBuffers(v8::Isolate* isolate, ArrayBufferArray& arrayBuffers, ExceptionState& exceptionState)
 {
     m_arrayBufferContentsArray = createArrayBuffers(isolate, arrayBuffers, exceptionState);
 }
 
 } // namespace blink