Disallow passing a SharedArrayBuffer in the transfer list.

include/v8.h

 // 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.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 1692 matching lines @@
     virtual void ThrowDataCloneError(Local<String> message) = 0;
 
     /*
      * The embedder overrides this method to write some kind of host object, if
      * possible. If not, a suitable exception should be thrown and
      * Nothing<bool>() returned.
      */
     virtual Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object);
 
     /*
+     * Called when the ValueSerializer is going to serialize a
+     * SharedArrayBuffer object. The embedder must return an ID for the
+     * object, using the same ID if this SharedArrayBuffer has already been
+     * serialized in this buffer. When deserializing, this ID will be passed to
+     * ValueDeserializer::TransferSharedArrayBuffer as |transfer_id|.
+     *
+     * If the object cannot be serialized, an
+     * exception should be thrown and Nothing<uint32_t>() returned.
+     */
+    virtual Maybe<uint32_t> TransferSharedArrayBuffer(Isolate* isolate,

[jbroman, 2016/12/13 20:56:00]

Do we want to use the word "transfer" here, given we're removing it from the
transfer list? (I'm admittedly not up to date on context behind this decision.)

[binji, 2016/12/14 23:58:30]

AIUI, the thought is that transferring is defined by the original value being
detached more than whether the value is serialized or not. Makes some sense I
guess, but it unfortunately complicates the code.

So good point, though I'm not sure what else to call it. Maybe
"ShareSharedArrayBuffer"?

[binji, 2016/12/15 23:24:45]

I went with GetSharedArrayBufferId, I think that's pretty clear.

+                                                      Local<Object> object);

[jbroman, 2016/12/13 20:56:00]

I'd expect the argument to be Local<SharedArrayBuffer> here.

[binji, 2016/12/14 23:58:30]

Done.

+
+    /*
      * Allocates memory for the buffer of at least the size provided. The actual
      * size (which may be greater or equal) is written to |actual_size|. If no
      * buffer has been allocated yet, nullptr will be provided.
      */
     virtual void* ReallocateBufferMemory(void* old_buffer, size_t size,
                                          size_t* actual_size);
 
     /*
      * Frees a buffer allocated with |ReallocateBufferMemory|.
      */
@@ skipping 33 matching lines @@
    * Marks an ArrayBuffer as havings its contents transferred out of band.
    * Pass the corresponding JSArrayBuffer in the deserializing context to
    * ValueDeserializer::TransferArrayBuffer.
    */
   void TransferArrayBuffer(uint32_t transfer_id,
                            Local<ArrayBuffer> array_buffer);
 
   /*
    * Similar to TransferArrayBuffer, but for SharedArrayBuffer.
    */
-  void TransferSharedArrayBuffer(uint32_t transfer_id,
-                                 Local<SharedArrayBuffer> shared_array_buffer);
+  V8_DEPRECATE_SOON("Use Delegate::TransferSharedArrayBuffer",
+                    void TransferSharedArrayBuffer(
+                        uint32_t transfer_id,
+                        Local<SharedArrayBuffer> shared_array_buffer));
 
   /*
    * Write raw data in various common formats to the buffer.
    * Note that integer types are written in base-128 varint format, not with a
    * binary copy. For use during an override of Delegate::WriteHostObject.
    */
   void WriteUint32(uint32_t value);
   void WriteUint64(uint64_t value);
   void WriteDouble(double value);
   void WriteRawBytes(const void* source, size_t length);
@@ skipping 7923 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_