Remove DCHECK that transferred array buffers are neutered or shared.

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 46 matching lines @@
   const Local<Context>& serialization_context() {
     return serialization_context_;
   }
   const Local<Context>& deserialization_context() {
     return deserialization_context_;
   }
 
   // Overridden in more specific fixtures.
   virtual ValueSerializer::Delegate* GetSerializerDelegate() { return nullptr; }
   virtual void BeforeEncode(ValueSerializer*) {}
+  virtual void AfterEncode() {}
   virtual ValueDeserializer::Delegate* GetDeserializerDelegate() {
     return nullptr;
   }
   virtual void BeforeDecode(ValueDeserializer*) {}
 
   template <typename InputFunctor, typename OutputFunctor>
   void RoundTripTest(const InputFunctor& input_functor,
                      const OutputFunctor& output_functor) {
     EncodeTest(input_functor,
                [this, &output_functor](const std::vector<uint8_t>& data) {
@@ skipping 25 matching lines @@
   }
 
   Maybe<std::vector<uint8_t>> DoEncode(Local<Value> value) {
     Local<Context> context = serialization_context();
     ValueSerializer serializer(isolate(), GetSerializerDelegate());
     BeforeEncode(&serializer);
     serializer.WriteHeader();
     if (!serializer.WriteValue(context, value).FromMaybe(false)) {
       return Nothing<std::vector<uint8_t>>();
     }
+    AfterEncode();
     return Just(serializer.ReleaseBuffer());
   }
 
   template <typename InputFunctor, typename EncodedDataFunctor>
   void EncodeTest(const InputFunctor& input_functor,
                   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;
@@ skipping 1611 matching lines @@
 // Includes an ArrayBuffer wrapper marked for transfer from the serialization
 // context to the deserialization context.
 class ValueSerializerTestWithArrayBufferTransfer : public ValueSerializerTest {
  protected:
   static const size_t kTestByteLength = 4;
 
   ValueSerializerTestWithArrayBufferTransfer() {
     {
       Context::Scope scope(serialization_context());
       input_buffer_ = ArrayBuffer::New(isolate(), nullptr, 0);
-      input_buffer_->Neuter();
     }
     {
       Context::Scope scope(deserialization_context());
       output_buffer_ = ArrayBuffer::New(isolate(), kTestByteLength);
       const uint8_t data[kTestByteLength] = {0x00, 0x01, 0x80, 0xff};
       memcpy(output_buffer_->GetContents().Data(), data, kTestByteLength);
     }
   }
 
   const Local<ArrayBuffer>& input_buffer() { return input_buffer_; }
   const Local<ArrayBuffer>& output_buffer() { return output_buffer_; }
 
   void BeforeEncode(ValueSerializer* serializer) override {
     serializer->TransferArrayBuffer(0, input_buffer_);
   }
 
+  void AfterEncode() override { input_buffer_->Neuter(); }
+
   void BeforeDecode(ValueDeserializer* deserializer) override {
     deserializer->TransferArrayBuffer(0, output_buffer_);
   }
 
  private:
   Local<ArrayBuffer> input_buffer_;
   Local<ArrayBuffer> output_buffer_;
 };
 
 TEST_F(ValueSerializerTestWithArrayBufferTransfer,
@@ skipping 594 matching lines @@
       "({ a: new ExampleHostObject(), get b() { return this.a; }})",
       [this](Local<Value> value) {
         EXPECT_TRUE(EvaluateScriptForResultBool(
             "result.a instanceof ExampleHostObject"));
         EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
       });
 }
 
 }  // namespace
 }  // namespace v8