Disallow passing a SharedArrayBuffer in the transfer list.

test/unittests/value-serializer-unittest.cc

 // Copyright 2016 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.
 
 #include "src/value-serializer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "include/v8.h"
@@ skipping 111 matching lines @@
                   const EncodedDataFunctor& encoded_data_functor) {
     Context::Scope scope(serialization_context());
     TryCatch try_catch(isolate());
     Local<Value> input_value = input_functor();
     std::vector<uint8_t> buffer;
     ASSERT_TRUE(DoEncode(input_value).To(&buffer));
     ASSERT_FALSE(try_catch.HasCaught());
     encoded_data_functor(buffer);
   }
 
+  template <typename InputFunctor, typename MessageFunctor>
+  void InvalidEncodeTest(const InputFunctor& input_functor,
+                         const MessageFunctor& functor) {
+    Context::Scope scope(serialization_context());
+    TryCatch try_catch(isolate());
+    Local<Value> input_value = input_functor();
+    ASSERT_TRUE(DoEncode(input_value).IsNothing());
+    functor(try_catch.Message());
+  }
+
   template <typename MessageFunctor>
   void InvalidEncodeTest(const char* source, const MessageFunctor& functor) {
-    Context::Scope scope(serialization_context());
-    TryCatch try_catch(isolate());
-    Local<Value> input_value = EvaluateScriptForInput(source);
-    ASSERT_TRUE(DoEncode(input_value).IsNothing());
-    functor(try_catch.Message());
+    InvalidEncodeTest(
+        [this, source]() { return EvaluateScriptForInput(source); }, functor);
   }
 
   void InvalidEncodeTest(const char* source) {
     InvalidEncodeTest(source, [](Local<Message>) {});
   }
 
   template <typename OutputFunctor>
   void DecodeTest(const std::vector<uint8_t>& data,
                   const OutputFunctor& output_functor) {
     Local<Context> context = deserialization_context();
@@ skipping 1886 matching lines @@
   // Byte offset in range, offset + length out of range.
   InvalidDecodeTest(
       {0xff, 0x09, 0x42, 0x02, 0x00, 0x00, 0x56, 0x3f, 0x01, 0x03});
 }
 
 class ValueSerializerTestWithSharedArrayBufferTransfer
     : public ValueSerializerTest {
  protected:
   static const size_t kTestByteLength = 4;
 
-  ValueSerializerTestWithSharedArrayBufferTransfer() {
+  ValueSerializerTestWithSharedArrayBufferTransfer()
+      : serializer_delegate_(this),
+        should_transfer_shared_array_buffer_(false) {
     const uint8_t data[kTestByteLength] = {0x00, 0x01, 0x80, 0xff};
     memcpy(data_, data, kTestByteLength);
     {
       Context::Scope scope(serialization_context());
       input_buffer_ =
           SharedArrayBuffer::New(isolate(), &data_, kTestByteLength);
     }
     {
       Context::Scope scope(deserialization_context());
       output_buffer_ =
           SharedArrayBuffer::New(isolate(), &data_, kTestByteLength);
     }
   }
 
   const Local<SharedArrayBuffer>& input_buffer() { return input_buffer_; }
   const Local<SharedArrayBuffer>& output_buffer() { return output_buffer_; }
 
   void BeforeEncode(ValueSerializer* serializer) override {
-    serializer->TransferSharedArrayBuffer(0, input_buffer_);
+    if (should_transfer_shared_array_buffer_) {
+      // TODO(binji): In general, this should not be called, because
+      // SharedArrayBuffers are not allowed in the transfer list. We allow it
+      // for testing for now, but this function will be removed soon.
+      serializer->TransferSharedArrayBuffer(0, input_buffer_);
+    }
   }
 
   void BeforeDecode(ValueDeserializer* deserializer) override {
     deserializer->TransferSharedArrayBuffer(0, output_buffer_);
   }
 
   static void SetUpTestCase() {
     flag_was_enabled_ = i::FLAG_harmony_sharedarraybuffer;
     i::FLAG_harmony_sharedarraybuffer = true;
     ValueSerializerTest::SetUpTestCase();
   }
 
   static void TearDownTestCase() {
     ValueSerializerTest::TearDownTestCase();
     i::FLAG_harmony_sharedarraybuffer = flag_was_enabled_;
     flag_was_enabled_ = false;
   }
 
+ protected:
+// GMock doesn't use the "override" keyword.
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winconsistent-missing-override"
+#endif
+
+  class SerializerDelegate : public ValueSerializer::Delegate {
+   public:
+    explicit SerializerDelegate(
+        ValueSerializerTestWithSharedArrayBufferTransfer* test)
+        : test_(test) {}
+    MOCK_METHOD2(TransferSharedArrayBuffer,
+                 Maybe<uint32_t>(Isolate* isolate, Local<Object> object));
+    void ThrowDataCloneError(Local<String> message) override {
+      test_->isolate()->ThrowException(Exception::Error(message));
+    }
+
+   private:
+    ValueSerializerTestWithSharedArrayBufferTransfer* test_;
+  };
+
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+
+  ValueSerializer::Delegate* GetSerializerDelegate() override {
+    return &serializer_delegate_;
+  }
+
+  SerializerDelegate serializer_delegate_;
+  bool should_transfer_shared_array_buffer_;
+
  private:
   static bool flag_was_enabled_;
   uint8_t data_[kTestByteLength];
   Local<SharedArrayBuffer> input_buffer_;
   Local<SharedArrayBuffer> output_buffer_;
 };
 
 bool ValueSerializerTestWithSharedArrayBufferTransfer::flag_was_enabled_ =
     false;
 
 TEST_F(ValueSerializerTestWithSharedArrayBufferTransfer,
        RoundTripSharedArrayBufferTransfer) {
+  should_transfer_shared_array_buffer_ = false;
+  EXPECT_CALL(serializer_delegate_, TransferSharedArrayBuffer(isolate(), _))
+      .WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {

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

nit: Since this just validates an argument and returns a constant, you might not
need to use testing::Invoke. Does this work?

EXPECT_CALL(serializer_delegate_, TransferSharedArrayBuffer(isolate(),
input_buffer()))
    .WillOnce(Return(Just(0U)));

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

Done.

+        EXPECT_EQ(input_buffer(), object);
+        return Just(0U);
+      }));
+
   RoundTripTest([this]() { return input_buffer(); },
                 [this](Local<Value> value) {
                   ASSERT_TRUE(value->IsSharedArrayBuffer());
                   EXPECT_EQ(output_buffer(), value);
                   EXPECT_TRUE(EvaluateScriptForResultBool(
                       "new Uint8Array(result).toString() === '0,1,128,255'"));
                 });
   RoundTripTest(
       [this]() {
         Local<Object> object = Object::New(isolate());
@@ skipping 12 matching lines @@
       [this](Local<Value> value) {
         EXPECT_TRUE(EvaluateScriptForResultBool(
             "result.a instanceof SharedArrayBuffer"));
         EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
         EXPECT_TRUE(EvaluateScriptForResultBool(
             "new Uint8Array(result.a).toString() === '0,1,128,255'"));
       });
 }
 
 TEST_F(ValueSerializerTestWithSharedArrayBufferTransfer,
-       SharedArrayBufferMustBeTransferred) {
-  // A SharedArrayBuffer which was not marked for transfer should fail encoding.
-  InvalidEncodeTest("new SharedArrayBuffer(32)");
+       SharedArrayBufferMustNotBeTransferred) {
+  // A SharedArrayBuffer which was marked for transfer should fail encoding.
+  should_transfer_shared_array_buffer_ = true;
+  InvalidEncodeTest([this]() { return input_buffer(); }, [](Local<Message>) {});
 }
 
 TEST_F(ValueSerializerTest, UnsupportedHostObject) {
   InvalidEncodeTest("new ExampleHostObject()");
   InvalidEncodeTest("({ a: new ExampleHostObject() })");
 }
 
 class ValueSerializerTestWithHostObject : public ValueSerializerTest {
  protected:
   ValueSerializerTestWithHostObject() : serializer_delegate_(this) {}
@@ skipping 387 matching lines @@
   InvalidDecodeTest(raw);
 }
 
 TEST_F(ValueSerializerTestWithWasm, DecodeWasmModuleWithInvalidDataLength) {
   InvalidDecodeTest({0xff, 0x09, 0x3f, 0x00, 0x57, 0x79, 0x7f, 0x00});
   InvalidDecodeTest({0xff, 0x09, 0x3f, 0x00, 0x57, 0x79, 0x00, 0x7f});
 }
 
 }  // namespace
 }  // namespace v8