Fix bug when transferring SharedArrayBuffer to multiple Workers. (try 2)

src/d8.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 // Defined when linking against shared lib on Windows.
 #if defined(USING_V8_SHARED) && !defined(V8_SHARED)
 #define V8_SHARED
 #endif
 
@@ skipping 1519 matching lines @@
   if (thread_ == NULL) return;
   if (Shell::options.last_run) {
     thread_->Join();
   } else {
     done_semaphore_.Wait();
   }
 }
 
 
 SerializationData::~SerializationData() {
-  // Any ArrayBuffer::Contents are owned by this SerializationData object.
-  // SharedArrayBuffer::Contents may be used by other threads, so must be
+  // Any ArrayBuffer::Contents are owned by this SerializationData object if
+  // ownership hasn't been transferred out via ReadArrayBufferContents.
+  // SharedArrayBuffer::Contents may be used by multiple threads, so must be
   // cleaned up by the main thread in Shell::CleanupWorkers().
-  for (int i = 0; i < array_buffer_contents.length(); ++i) {
-    ArrayBuffer::Contents& contents = array_buffer_contents[i];
-    Shell::array_buffer_allocator->Free(contents.Data(), contents.ByteLength());
+  for (int i = 0; i < array_buffer_contents_.length(); ++i) {
+    ArrayBuffer::Contents& contents = array_buffer_contents_[i];
+    if (contents.Data()) {
+      Shell::array_buffer_allocator->Free(contents.Data(),
+                                          contents.ByteLength());
+    }
   }
 }
 
 
-void SerializationData::WriteTag(SerializationTag tag) { data.Add(tag); }
+void SerializationData::WriteTag(SerializationTag tag) { data_.Add(tag); }
 
 
 void SerializationData::WriteMemory(const void* p, int length) {
   if (length > 0) {
-    i::Vector<uint8_t> block = data.AddBlock(0, length);
+    i::Vector<uint8_t> block = data_.AddBlock(0, length);
     memcpy(&block[0], p, length);
   }
 }
 
 
 void SerializationData::WriteArrayBufferContents(
     const ArrayBuffer::Contents& contents) {
-  array_buffer_contents.Add(contents);
+  array_buffer_contents_.Add(contents);
   WriteTag(kSerializationTagTransferredArrayBuffer);
-  int index = array_buffer_contents.length() - 1;
+  int index = array_buffer_contents_.length() - 1;
   Write(index);
 }
 
 
 void SerializationData::WriteSharedArrayBufferContents(
     const SharedArrayBuffer::Contents& contents) {
-  shared_array_buffer_contents.Add(contents);
+  shared_array_buffer_contents_.Add(contents);
   WriteTag(kSerializationTagTransferredSharedArrayBuffer);
-  int index = shared_array_buffer_contents.length() - 1;
+  int index = shared_array_buffer_contents_.length() - 1;
   Write(index);
 }
 
 
 SerializationTag SerializationData::ReadTag(int* offset) const {
   return static_cast<SerializationTag>(Read<uint8_t>(offset));
 }
 
 
 void SerializationData::ReadMemory(void* p, int length, int* offset) const {
   if (length > 0) {
-    memcpy(p, &data[*offset], length);
+    memcpy(p, &data_[*offset], length);
     (*offset) += length;
   }
 }
 
 
 void SerializationData::ReadArrayBufferContents(ArrayBuffer::Contents* contents,
                                                 int* offset) const {
   int index = Read<int>(offset);
-  DCHECK(index < array_buffer_contents.length());
-  *contents = array_buffer_contents[index];
+  DCHECK(index < array_buffer_contents_.length());
+  *contents = array_buffer_contents_[index];
+  // Ownership of this ArrayBuffer::Contents is passed to the caller. Neuter
+  // our copy so it won't be double-free'd when this SerializationData is
+  // destroyed.
+  array_buffer_contents_[index] = ArrayBuffer::Contents();
 }
 
 
 void SerializationData::ReadSharedArrayBufferContents(
     SharedArrayBuffer::Contents* contents, int* offset) const {
   int index = Read<int>(offset);
-  DCHECK(index < shared_array_buffer_contents.length());
-  *contents = shared_array_buffer_contents[index];
+  DCHECK(index < shared_array_buffer_contents_.length());
+  *contents = shared_array_buffer_contents_[index];
 }
 
 
 void SerializationDataQueue::Enqueue(SerializationData* data) {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   data_.Add(data);
 }
 
 
 bool SerializationDataQueue::Dequeue(SerializationData** data) {
@@ skipping 22 matching lines @@
 
 Worker::Worker()
     : in_semaphore_(0),
       out_semaphore_(0),
       thread_(NULL),
       script_(NULL),
       state_(IDLE),
       join_called_(false) {}
 
 
-Worker::~Worker() { Cleanup(); }
+Worker::~Worker() {
+  delete thread_;
+  thread_ = NULL;
+  delete[] script_;
+  script_ = NULL;
+  in_queue_.Clear();
+  out_queue_.Clear();
+}
 
 
 void Worker::StartExecuteInThread(Isolate* isolate, const char* script) {
   if (base::NoBarrier_CompareAndSwap(&state_, IDLE, RUNNING) == IDLE) {
     script_ = i::StrDup(script);
     thread_ = new WorkerThread(this);
     thread_->Start();
   } else {
     // Somehow the Worker was started twice.
     UNREACHABLE();
   }
 }
 
 
 void Worker::PostMessage(SerializationData* data) {
   in_queue_.Enqueue(data);
   in_semaphore_.Signal();
 }
 
 
 SerializationData* Worker::GetMessage() {
   SerializationData* data = NULL;
   while (!out_queue_.Dequeue(&data)) {
     // If the worker is no longer running, and there are no messages in the
     // queue, don't expect any more messages from it.
     if (base::NoBarrier_Load(&state_) != RUNNING) break;
     out_semaphore_.Wait();
   }
-
   return data;
 }
 
 
 void Worker::Terminate() {
   if (base::NoBarrier_CompareAndSwap(&state_, RUNNING, TERMINATED) == RUNNING) {
     // Post NULL to wake the Worker thread message loop, and tell it to stop
     // running.
     PostMessage(NULL);
   }
@@ skipping 71 matching lines @@
     Shell::CollectGarbage(isolate);
   }
   isolate->Dispose();
 
   // Post NULL to wake the thread waiting on GetMessage() if there is one.
   out_queue_.Enqueue(NULL);
   out_semaphore_.Signal();
 }
 
 
-void Worker::Cleanup() {
-  delete thread_;
-  thread_ = NULL;
-  delete[] script_;
-  script_ = NULL;
-  in_queue_.Clear();
-  out_queue_.Clear();
-}
-
-
 void Worker::PostMessageOut(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   HandleScope handle_scope(isolate);
 
   if (args.Length() < 1) {
     Throw(isolate, "Invalid argument");
     return;
   }
 
   Handle<Value> message = args[0];
@@ skipping 264 matching lines @@
       return false;
     }
     seen_objects->Add(array_buffer);
     if (FindInObjectList(array_buffer, to_transfer)) {
       // Transfer ArrayBuffer
       if (!array_buffer->IsNeuterable()) {
         Throw(isolate, "Attempting to transfer an un-neuterable ArrayBuffer");
         return false;
       }
 
-      ArrayBuffer::Contents contents = array_buffer->Externalize();
+      ArrayBuffer::Contents contents = array_buffer->IsExternal()
+                                           ? array_buffer->GetContents()
+                                           : array_buffer->Externalize();
       array_buffer->Neuter();
       out_data->WriteArrayBufferContents(contents);
     } else {
       ArrayBuffer::Contents contents = array_buffer->GetContents();
       // Clone ArrayBuffer
       if (contents.ByteLength() > i::kMaxUInt32) {
         Throw(isolate, "ArrayBuffer is too big to clone");
         return false;
       }
 
       int byte_length = static_cast<int>(contents.ByteLength());
       out_data->WriteTag(kSerializationTagArrayBuffer);
       out_data->Write(byte_length);
       out_data->WriteMemory(contents.Data(),
                             static_cast<int>(contents.ByteLength()));
     }
   } else if (value->IsSharedArrayBuffer()) {
     Handle<SharedArrayBuffer> sab = Handle<SharedArrayBuffer>::Cast(value);
     if (FindInObjectList(sab, *seen_objects)) {
       Throw(isolate, "Duplicated shared array buffers not supported");
       return false;
     }
     seen_objects->Add(sab);
     if (!FindInObjectList(sab, to_transfer)) {
       Throw(isolate, "SharedArrayBuffer must be transferred");
       return false;
     }
 
-    SharedArrayBuffer::Contents contents = sab->Externalize();
+    SharedArrayBuffer::Contents contents;
+    if (sab->IsExternal()) {
+      contents = sab->GetContents();
+    } else {
+      contents = sab->Externalize();
+      externalized_shared_contents_.Add(contents);
+    }
     out_data->WriteSharedArrayBufferContents(contents);
-    externalized_shared_contents_.Add(contents);
   } else if (value->IsObject()) {
     Handle<Object> object = Handle<Object>::Cast(value);
     if (FindInObjectList(object, *seen_objects)) {
       Throw(isolate, "Duplicated objects not supported");
       return false;
     }
     seen_objects->Add(object);
     Local<Array> property_names;
     if (!object->GetOwnPropertyNames(context).ToLocal(&property_names)) {
       Throw(isolate, "Unable to get property names");
@@ skipping 92 matching lines @@
       Handle<ArrayBuffer> array_buffer = ArrayBuffer::New(isolate, byte_length);
       ArrayBuffer::Contents contents = array_buffer->GetContents();
       DCHECK(static_cast<size_t>(byte_length) == contents.ByteLength());
       data.ReadMemory(contents.Data(), byte_length, offset);
       result = array_buffer;
       break;
     }
     case kSerializationTagTransferredArrayBuffer: {
       ArrayBuffer::Contents contents;
       data.ReadArrayBufferContents(&contents, offset);
-      result =
-          ArrayBuffer::New(isolate, contents.Data(), contents.ByteLength());
+      result = ArrayBuffer::New(isolate, contents.Data(), contents.ByteLength(),
+                                ArrayBufferCreationMode::kInternalized);
       break;
     }
     case kSerializationTagTransferredSharedArrayBuffer: {
       SharedArrayBuffer::Contents contents;
       data.ReadSharedArrayBufferContents(&contents, offset);
       result = SharedArrayBuffer::New(isolate, contents.Data(),
                                       contents.ByteLength());
       break;
     }
     default:
@@ skipping 228 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif