WebMessaging: Send transferable ArrayBuffers by copy-and-neuter semantics

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 131 matching lines @@
     const LChar* src = m_data.characters8();
     for (size_t i = 0; i < length; i++)
       dst[i] = htons(static_cast<UChar>(src[i]));
   } else {
     const UChar* src = m_data.characters16();
     for (size_t i = 0; i < length; i++)
       dst[i] = htons(src[i]);
   }
 }
 
-static void acculumateArrayBuffersForAllWorlds(
+static void accumulateArrayBuffersForAllWorlds(
     v8::Isolate* isolate,
     DOMArrayBuffer* object,
     Vector<v8::Local<v8::ArrayBuffer>, 4>& buffers) {
   if (isMainThread()) {
     Vector<RefPtr<DOMWrapperWorld>> worlds;
     DOMWrapperWorld::allWorldsInMainThread(worlds);
     for (size_t i = 0; i < worlds.size(); i++) {
       v8::Local<v8::Object> wrapper =
           worlds[i]->domDataStore().get(object, isolate);
       if (!wrapper.IsEmpty())
@@ skipping 60 matching lines @@
     }
     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;
-    }
-  }
-
-  std::unique_ptr<ArrayBufferContentsArray> contents =
-      wrapUnique(new ArrayBufferContentsArray(arrayBuffers.size()));
-
-  HeapHashSet<Member<DOMArrayBufferBase>> visited;
-  for (size_t i = 0; i < arrayBuffers.size(); ++i) {
-    if (visited.contains(arrayBuffers[i]))
-      continue;
-    visited.add(arrayBuffers[i]);
-
-    if (arrayBuffers[i]->isShared()) {
-      bool result = arrayBuffers[i]->shareContentsWith(contents->at(i));
-      if (!result) {
-        exceptionState.throwDOMException(
-            DataCloneError, "SharedArrayBuffer at index " + String::number(i) +
-                                " could not be transferred.");
-        return;
-      }
-    } else {
-      Vector<v8::Local<v8::ArrayBuffer>, 4> bufferHandles;
-      v8::HandleScope handleScope(isolate);
-      acculumateArrayBuffersForAllWorlds(
-          isolate, static_cast<DOMArrayBuffer*>(arrayBuffers[i].get()),
-          bufferHandles);
-      bool isNeuterable = true;
-      for (size_t j = 0; j < bufferHandles.size(); ++j)
-        isNeuterable &= bufferHandles[j]->IsNeuterable();
-
-      DOMArrayBufferBase* toTransfer = arrayBuffers[i];
-      if (!isNeuterable)
-        toTransfer =
-            DOMArrayBuffer::create(arrayBuffers[i]->buffer()->data(),
-                                   arrayBuffers[i]->buffer()->byteLength());
-      bool result = toTransfer->transfer(contents->at(i));
-      if (!result) {
-        exceptionState.throwDOMException(
-            DataCloneError, "ArrayBuffer at index " + String::number(i) +
-                                " could not be transferred.");
-        return;
-      }
-
-      if (isNeuterable)
-        for (size_t j = 0; j < bufferHandles.size(); ++j)
-          bufferHandles[j]->Neuter();
-    }
-  }
-  m_arrayBufferContentsArray = std::move(contents);
+  m_arrayBufferContentsArray =
+      transferArrayBufferContents(isolate, arrayBuffers, exceptionState);
 }
 
 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,
@@ skipping 94 matching lines @@
       transferables.offscreenCanvases.append(offscreenCanvas);
     } else {
       exceptionState.throwTypeError("Value at index " + String::number(i) +
                                     " does not have a transferable type.");
       return false;
     }
   }
   return true;
 }
 
+std::unique_ptr<ArrayBufferContentsArray>
+SerializedScriptValue::transferArrayBufferContents(
+    v8::Isolate* isolate,
+    const ArrayBufferArray& arrayBuffers,
+    ExceptionState& exceptionState) {
+  if (!arrayBuffers.size())
+    return nullptr;
+
+  for (auto it = arrayBuffers.begin(); it != arrayBuffers.end(); ++it) {
+    DOMArrayBufferBase* arrayBuffer = *it;
+    if (arrayBuffer->isNeutered()) {
+      size_t index = std::distance(arrayBuffers.begin(), it);
+      exceptionState.throwDOMException(
+          DataCloneError, "ArrayBuffer at index " + String::number(index) +
+                              " is already neutered.");
+      return nullptr;
+    }
+  }
+
+  std::unique_ptr<ArrayBufferContentsArray> contents =
+      wrapUnique(new ArrayBufferContentsArray(arrayBuffers.size()));
+
+  HeapHashSet<Member<DOMArrayBufferBase>> visited;
+  for (auto it = arrayBuffers.begin(); it != arrayBuffers.end(); ++it) {
+    DOMArrayBufferBase* arrayBuffer = *it;
+    if (visited.contains(arrayBuffer))
+      continue;
+    visited.add(arrayBuffer);
+
+    size_t index = std::distance(arrayBuffers.begin(), it);
+    if (arrayBuffer->isShared()) {
+      if (!arrayBuffer->shareContentsWith(contents->at(index))) {
+        exceptionState.throwDOMException(DataCloneError,
+                                         "SharedArrayBuffer at index " +
+                                             String::number(index) +
+                                             " could not be transferred.");
+        return nullptr;
+      }
+    } else {
+      Vector<v8::Local<v8::ArrayBuffer>, 4> bufferHandles;
+      v8::HandleScope handleScope(isolate);
+      accumulateArrayBuffersForAllWorlds(
+          isolate, static_cast<DOMArrayBuffer*>(it->get()), bufferHandles);
+      bool isNeuterable = true;
+      for (const auto& bufferHandle : bufferHandles)
+        isNeuterable &= bufferHandle->IsNeuterable();
+
+      DOMArrayBufferBase* toTransfer = arrayBuffer;
+      if (!isNeuterable) {
+        toTransfer = DOMArrayBuffer::create(
+            arrayBuffer->buffer()->data(), arrayBuffer->buffer()->byteLength());
+      }
+      if (!toTransfer->transfer(contents->at(index))) {
+        exceptionState.throwDOMException(
+            DataCloneError, "ArrayBuffer at index " + String::number(index) +
+                                " could not be transferred.");
+        return nullptr;
+      }
+
+      if (isNeuterable) {
+        for (const auto& bufferHandle : bufferHandles)
+          bufferHandle->Neuter();
+      }
+    }
+  }
+  return contents;
+}
+
 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