Revert of 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) {
+  template <typename MessageFunctor>
+  void InvalidEncodeTest(const char* source, const MessageFunctor& functor) {
     Context::Scope scope(serialization_context());
     TryCatch try_catch(isolate());
-    Local<Value> input_value = input_functor();
+    Local<Value> input_value = EvaluateScriptForInput(source);
     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>) {});
   }
 
   template <typename OutputFunctor>
   void DecodeTest(const std::vector<uint8_t>& data,
                   const OutputFunctor& output_functor) {
     Local<Context> context = deserialization_context();
     Context::Scope scope(context);
     TryCatch try_catch(isolate());
@@ skipping 1884 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()
-      : serializer_delegate_(this) {
+  ValueSerializerTestWithSharedArrayBufferTransfer() {
     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_);
+  }
+
   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(GetSharedArrayBufferId,
-                 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_;
-
  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) {
-  EXPECT_CALL(serializer_delegate_,
-              GetSharedArrayBufferId(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