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"
 #include "src/api.h"
 #include "src/base/build_config.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace v8 {
 namespace {
 
 using ::testing::_;
 using ::testing::Invoke;
+using ::testing::Return;
 
 class ValueSerializerTest : public TestWithIsolate {
  protected:
   ValueSerializerTest()
       : serialization_context_(Context::New(isolate())),
         deserialization_context_(Context::New(isolate())) {
     // Create a host object type that can be tested through
     // serialization/deserialization delegates below.
     Local<FunctionTemplate> function_template = v8::FunctionTemplate::New(
         isolate(), [](const FunctionCallbackInfo<Value>& args) {
@@ skipping 90 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<SharedArrayBuffer> shared_array_buffer));
+    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_;

[jbroman, 2016/12/15 16:15:33]

This seems to only ever be set to false. Should it be set to true somewhere, or
is the code guarded by this dead?

[binji, 2016/12/15 19:31:20]

Done, forgot to remove after removing the test that used it!

+
  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(), input_buffer()))
+      .WillRepeatedly(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 11 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)");
-}
-
 TEST_F(ValueSerializerTest, UnsupportedHostObject) {
   InvalidEncodeTest("new ExampleHostObject()");
   InvalidEncodeTest("({ a: new ExampleHostObject() })");
 }
 
 class ValueSerializerTestWithHostObject : public ValueSerializerTest {
  protected:
   ValueSerializerTestWithHostObject() : serializer_delegate_(this) {}
 
   static const uint8_t kExampleHostObjectTag;
@@ skipping 385 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