Disallow passing a SharedArrayBuffer in the transfer list.

test/unittests/value-serializer-unittest.cc

Index: test/unittests/value-serializer-unittest.cc
diff --git a/test/unittests/value-serializer-unittest.cc b/test/unittests/value-serializer-unittest.cc
index 1dabd2a17a78f411a5af3e3dad3ce57418ddc20d..c7a58f79cd98c12a510bf4fe2151e56c84aaf2f3 100644
--- a/test/unittests/value-serializer-unittest.cc
+++ b/test/unittests/value-serializer-unittest.cc
@@ -129,15 +129,22 @@ class ValueSerializerTest : public TestWithIsolate {
     encoded_data_functor(buffer);
   }
 
-  template <typename MessageFunctor>
-  void InvalidEncodeTest(const char* source, const MessageFunctor& functor) {
+  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 = EvaluateScriptForInput(source);
+    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) {
+    InvalidEncodeTest(
+        [this, source]() { return EvaluateScriptForInput(source); }, functor);
+  }
+
   void InvalidEncodeTest(const char* source) {
     InvalidEncodeTest(source, [](Local<Message>) {});
   }
@@ -2042,7 +2049,9 @@ class ValueSerializerTestWithSharedArrayBufferTransfer
  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);
     {
@@ -2061,7 +2070,12 @@ class ValueSerializerTestWithSharedArrayBufferTransfer
   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 {
@@ -2080,6 +2094,39 @@ class ValueSerializerTestWithSharedArrayBufferTransfer
     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];
@@ -2092,6 +2139,13 @@ bool ValueSerializerTestWithSharedArrayBufferTransfer::flag_was_enabled_ =
 
 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());
@@ -2124,9 +2178,10 @@ TEST_F(ValueSerializerTestWithSharedArrayBufferTransfer,
 }
 
 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) {