Revert of [wasm] Transferrable modules

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 56 matching lines @@
     }
   }
 
   const Local<Context>& serialization_context() {
     return serialization_context_;
   }
   const Local<Context>& deserialization_context() {
     return deserialization_context_;
   }
 
-  bool ExpectInlineWasm() const { return expect_inline_wasm_; }
-  void SetExpectInlineWasm(bool value) { expect_inline_wasm_ = value; }
-
   // 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>
@@ skipping 78 matching lines @@
   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());
     ValueDeserializer deserializer(isolate(), &data[0],
                                    static_cast<int>(data.size()),
                                    GetDeserializerDelegate());
     deserializer.SetSupportsLegacyWireFormat(true);
-    deserializer.SetExpectInlineWasm(ExpectInlineWasm());
     BeforeDecode(&deserializer);
     ASSERT_TRUE(deserializer.ReadHeader(context).FromMaybe(false));
     Local<Value> result;
     ASSERT_TRUE(deserializer.ReadValue(context).ToLocal(&result));
     ASSERT_FALSE(result.IsEmpty());
     ASSERT_FALSE(try_catch.HasCaught());
     ASSERT_TRUE(
         context->Global()
             ->CreateDataProperty(context, StringFromUtf8("result"), result)
             .FromMaybe(false));
     output_functor(result);
     ASSERT_FALSE(try_catch.HasCaught());
   }
 
   template <typename OutputFunctor>
   void DecodeTestForVersion0(const std::vector<uint8_t>& data,
                              const OutputFunctor& output_functor) {
     Local<Context> context = deserialization_context();
     Context::Scope scope(context);
     TryCatch try_catch(isolate());
     ValueDeserializer deserializer(isolate(), &data[0],
                                    static_cast<int>(data.size()),
                                    GetDeserializerDelegate());
     deserializer.SetSupportsLegacyWireFormat(true);
-    deserializer.SetExpectInlineWasm(ExpectInlineWasm());
     BeforeDecode(&deserializer);
     ASSERT_TRUE(deserializer.ReadHeader(context).FromMaybe(false));
     ASSERT_EQ(0u, deserializer.GetWireFormatVersion());
     Local<Value> result;
     ASSERT_TRUE(deserializer.ReadValue(context).ToLocal(&result));
     ASSERT_FALSE(result.IsEmpty());
     ASSERT_FALSE(try_catch.HasCaught());
     ASSERT_TRUE(
         context->Global()
             ->CreateDataProperty(context, StringFromUtf8("result"), result)
             .FromMaybe(false));
     output_functor(result);
     ASSERT_FALSE(try_catch.HasCaught());
   }
 
   void InvalidDecodeTest(const std::vector<uint8_t>& data) {
     Local<Context> context = deserialization_context();
     Context::Scope scope(context);
     TryCatch try_catch(isolate());
     ValueDeserializer deserializer(isolate(), &data[0],
                                    static_cast<int>(data.size()),
                                    GetDeserializerDelegate());
     deserializer.SetSupportsLegacyWireFormat(true);
-    deserializer.SetExpectInlineWasm(ExpectInlineWasm());
     BeforeDecode(&deserializer);
     Maybe<bool> header_result = deserializer.ReadHeader(context);
     if (header_result.IsNothing()) {
       EXPECT_TRUE(try_catch.HasCaught());
       return;
     }
     ASSERT_TRUE(header_result.ToChecked());
     ASSERT_TRUE(deserializer.ReadValue(context).IsEmpty());
     EXPECT_TRUE(try_catch.HasCaught());
   }
@@ skipping 36 matching lines @@
     Local<ArrayBuffer> ab =
         ArrayBuffer::New(isolate(), static_cast<void*>(data), sizeof(data));
     return Uint8Array::New(ab, 0, sizeof(data));
   }
 
  private:
   Local<Context> serialization_context_;
   Local<Context> deserialization_context_;
   Local<FunctionTemplate> host_object_constructor_template_;
   i::Isolate* isolate_;
-  bool expect_inline_wasm_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(ValueSerializerTest);
 };
 
 TEST_F(ValueSerializerTest, DecodeInvalid) {
   // Version tag but no content.
   InvalidDecodeTest({0xff});
   // Version too large.
   InvalidDecodeTest({0xff, 0x7f, 0x5f});
   // Nonsense tag.
@@ skipping 2299 matching lines @@
         EXPECT_TRUE(
             EvaluateScriptForResultBool("result.a.toString() === '4,5,6'"));
         EXPECT_TRUE(EvaluateScriptForResultBool("result.a === result.b"));
       });
 }
 
 // It's expected that WebAssembly has more exhaustive tests elsewhere; this
 // mostly checks that the logic to embed it in structured clone serialization
 // works correctly.
 
+class ValueSerializerTestWithWasm : public ValueSerializerTest {
+ protected:
+  static void SetUpTestCase() {
+    g_saved_flag = i::FLAG_expose_wasm;
+    i::FLAG_expose_wasm = true;
+    ValueSerializerTest::SetUpTestCase();
+  }
+
+  static void TearDownTestCase() {
+    ValueSerializerTest::TearDownTestCase();
+    i::FLAG_expose_wasm = g_saved_flag;
+    g_saved_flag = false;
+  }
+
+ private:
+  static bool g_saved_flag;
+};
+
+bool ValueSerializerTestWithWasm::g_saved_flag = false;
+
 // A simple module which exports an "increment" function.
 // Copied from test/mjsunit/wasm/incrementer.wasm.
 const unsigned char kIncrementerWasm[] = {
     0,   97, 115, 109, 1, 0,  0, 0, 1,   6,   1,  96,  1,   127, 1,   127,
     3,   2,  1,   0,   7, 13, 1, 9, 105, 110, 99, 114, 101, 109, 101, 110,
     116, 0,  0,   10,  9, 1,  7, 0, 32,  0,   65, 1,   106, 11,
 };
 
-class ValueSerializerTestWithWasm : public ValueSerializerTest {
- public:
-  static const char* kUnsupportedSerialization;
-
-  ValueSerializerTestWithWasm()
-      : serialize_delegate_(&transfer_modules_),
-        deserialize_delegate_(&transfer_modules_) {}
-
-  void Reset() {
-    current_serializer_delegate_ = nullptr;
-    transfer_modules_.clear();
-    SetExpectInlineWasm(false);
-  }
-
-  void EnableTransferSerialization() {
-    current_serializer_delegate_ = &serialize_delegate_;
-  }
-
-  void EnableTransferDeserialization() {
-    current_deserializer_delegate_ = &deserialize_delegate_;
-  }
-
-  void EnableThrowingSerializer() {
-    current_serializer_delegate_ = &throwing_serializer_;
-  }
-
-  void EnableDefaultDeserializer() {
-    current_deserializer_delegate_ = &default_deserializer_;
-  }
-
- protected:
-  static void SetUpTestCase() {
-    g_saved_flag = i::FLAG_expose_wasm;
-    i::FLAG_expose_wasm = true;
-    ValueSerializerTest::SetUpTestCase();
-  }
-
-  static void TearDownTestCase() {
-    ValueSerializerTest::TearDownTestCase();
-    i::FLAG_expose_wasm = g_saved_flag;
-    g_saved_flag = false;
-  }
-
-  class ThrowingSerializer : public ValueSerializer::Delegate {
-   public:
-    Maybe<uint32_t> GetWasmModuleTransferId(
-        Isolate* isolate, Local<WasmCompiledModule> module) override {
-      isolate->ThrowException(Exception::Error(
-          String::NewFromOneByte(
-              isolate,
-              reinterpret_cast<const uint8_t*>(kUnsupportedSerialization),
-              NewStringType::kNormal)
-              .ToLocalChecked()));
-      return Nothing<uint32_t>();
-    }
-
-    void ThrowDataCloneError(Local<String> message) override { UNREACHABLE(); }
-  };
-
-  class SerializeToTransfer : public ValueSerializer::Delegate {
-   public:
-    SerializeToTransfer(
-        std::vector<WasmCompiledModule::TransferrableModule>* modules)
-        : modules_(modules) {}
-    Maybe<uint32_t> GetWasmModuleTransferId(
-        Isolate* isolate, Local<WasmCompiledModule> module) override {
-      modules_->push_back(module->GetTransferrableModule());
-      return Just(static_cast<uint32_t>(modules_->size()) - 1);
-    }
-
-    void ThrowDataCloneError(Local<String> message) override { UNREACHABLE(); }
-
-   private:
-    std::vector<WasmCompiledModule::TransferrableModule>* modules_;
-  };
-
-  class DeserializeFromTransfer : public ValueDeserializer::Delegate {
-   public:
-    DeserializeFromTransfer(
-        std::vector<WasmCompiledModule::TransferrableModule>* modules)
-        : modules_(modules) {}
-
-    MaybeLocal<WasmCompiledModule> GetWasmModuleFromId(Isolate* isolate,
-                                                       uint32_t id) override {
-      return WasmCompiledModule::FromTransferrableModule(isolate,
-                                                         modules_->at(id));
-    }
-
-   private:
-    std::vector<WasmCompiledModule::TransferrableModule>* modules_;
-  };
-
-  ValueSerializer::Delegate* GetSerializerDelegate() override {
-    return current_serializer_delegate_;
-  }
-
-  ValueDeserializer::Delegate* GetDeserializerDelegate() override {
-    return current_deserializer_delegate_;
-  }
-
-  Local<WasmCompiledModule> MakeWasm() {
-    return WasmCompiledModule::DeserializeOrCompile(
-               isolate(), {nullptr, 0},
-               {kIncrementerWasm, sizeof(kIncrementerWasm)})
-        .ToLocalChecked();
-  }
-
-  void ExpectPass() {
-    RoundTripTest(
-        [this]() { return MakeWasm(); },
-        [this](Local<Value> value) {
-          ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
-          EXPECT_TRUE(EvaluateScriptForResultBool(
-              "new WebAssembly.Instance(result).exports.increment(8) === 9"));
-        });
-  }
-
-  void ExpectFail() {
-    EncodeTest(
-        [this]() { return MakeWasm(); },
-        [this](const std::vector<uint8_t>& data) { InvalidDecodeTest(data); });
-  }
-
-  Local<Value> GetComplexObjectWithDuplicate() {
-    Local<Value> wasm_module = MakeWasm();
-    serialization_context()
-        ->Global()
-        ->CreateDataProperty(serialization_context(),
-                             StringFromUtf8("wasm_module"), wasm_module)
-        .FromMaybe(false);
-    Local<Script> script =
-        Script::Compile(
-            serialization_context(),
-            StringFromUtf8("({mod1: wasm_module, num: 2, mod2: wasm_module})"))
+TEST_F(ValueSerializerTestWithWasm, RoundTripWasmModule) {
+  RoundTripTest(
+      [this]() {
+        return WasmCompiledModule::DeserializeOrCompile(
+                   isolate(), {nullptr, 0},
+                   {kIncrementerWasm, sizeof(kIncrementerWasm)})
             .ToLocalChecked();
-    return script->Run(serialization_context()).ToLocalChecked();
-  }
-
-  void VerifyComplexObject(Local<Value> value) {
-    ASSERT_TRUE(value->IsObject());
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "result.mod1 instanceof WebAssembly.Module"));
-    EXPECT_TRUE(EvaluateScriptForResultBool(
-        "result.mod2 instanceof WebAssembly.Module"));
-    EXPECT_TRUE(EvaluateScriptForResultBool("result.num === 2"));
-  }
-
-  Local<Value> GetComplexObjectWithMany() {
-    Local<Value> wasm_module1 = MakeWasm();
-    Local<Value> wasm_module2 = MakeWasm();
-    serialization_context()
-        ->Global()
-        ->CreateDataProperty(serialization_context(),
-                             StringFromUtf8("wasm_module1"), wasm_module1)
-        .FromMaybe(false);
-    serialization_context()
-        ->Global()
-        ->CreateDataProperty(serialization_context(),
-                             StringFromUtf8("wasm_module2"), wasm_module2)
-        .FromMaybe(false);
-    Local<Script> script =
-        Script::Compile(
-            serialization_context(),
-            StringFromUtf8(
-                "({mod1: wasm_module1, num: 2, mod2: wasm_module2})"))
-            .ToLocalChecked();
-    return script->Run(serialization_context()).ToLocalChecked();
-  }
-
- private:
-  static bool g_saved_flag;
-  std::vector<WasmCompiledModule::TransferrableModule> transfer_modules_;
-  SerializeToTransfer serialize_delegate_;
-  DeserializeFromTransfer deserialize_delegate_;
-  ValueSerializer::Delegate* current_serializer_delegate_ = nullptr;
-  ValueDeserializer::Delegate* current_deserializer_delegate_ = nullptr;
-  ThrowingSerializer throwing_serializer_;
-  ValueDeserializer::Delegate default_deserializer_;
-};
-
-bool ValueSerializerTestWithWasm::g_saved_flag = false;
-const char* ValueSerializerTestWithWasm::kUnsupportedSerialization =
-    "Wasm Serialization Not Supported";
-
-// The default implementation of the serialization
-// delegate throws when trying to serialize wasm. The
-// embedder must decide serialization policy.
-TEST_F(ValueSerializerTestWithWasm, DefaultSerializationDelegate) {
-  EnableThrowingSerializer();
-  InvalidEncodeTest(
-      [this]() { return MakeWasm(); },
-      [](Local<Message> message) {
-        size_t msg_len = static_cast<size_t>(message->Get()->Length());
-        std::unique_ptr<char[]> buff(new char[msg_len + 1]);
-        message->Get()->WriteOneByte(reinterpret_cast<uint8_t*>(buff.get()));
-        // the message ends with the custom error string
-        size_t custom_msg_len = strlen(kUnsupportedSerialization);
-        ASSERT_GE(msg_len, custom_msg_len);
-        size_t start_pos = msg_len - custom_msg_len;
-        ASSERT_EQ(strcmp(&buff.get()[start_pos], kUnsupportedSerialization), 0);
+      },
+      [this](Local<Value> value) {
+        ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
+        EXPECT_TRUE(EvaluateScriptForResultBool(
+            "new WebAssembly.Instance(result).exports.increment(8) === 9"));
       });
 }
 
-// The default deserializer throws if wasm transfer is attempted
-TEST_F(ValueSerializerTestWithWasm, DefaultDeserializationDelegate) {
-  EnableTransferSerialization();
-  EnableDefaultDeserializer();
-  EncodeTest(
-      [this]() { return MakeWasm(); },
-      [this](const std::vector<uint8_t>& data) { InvalidDecodeTest(data); });
-}
-
-// We only want to allow deserialization through
-// transferred modules - which requres both serializer
-// and deserializer to understand that - or through
-// explicitly allowing inlined data, which requires
-// deserializer opt-in (we default the serializer to
-// inlined data because we don't trust that data on the
-// receiving end anyway).
-
-TEST_F(ValueSerializerTestWithWasm, RoundtripWasmTransfer) {
-  EnableTransferSerialization();
-  EnableTransferDeserialization();
-  ExpectPass();
-}
-
-TEST_F(ValueSerializerTestWithWasm, RountripWasmInline) {
-  SetExpectInlineWasm(true);
-  ExpectPass();
-}
-
-TEST_F(ValueSerializerTestWithWasm, CannotDeserializeWasmInlineData) {
-  ExpectFail();
-}
-
-TEST_F(ValueSerializerTestWithWasm, CannotTransferWasmWhenExpectingInline) {
-  EnableTransferSerialization();
-  SetExpectInlineWasm(true);
-  ExpectFail();
-}
-
-TEST_F(ValueSerializerTestWithWasm, ComplexObjectDuplicateTransfer) {
-  EnableTransferSerialization();
-  EnableTransferDeserialization();
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithDuplicate(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 === result.mod2"));
-      });
-}
-
-TEST_F(ValueSerializerTestWithWasm, ComplexObjectDuplicateInline) {
-  SetExpectInlineWasm(true);
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithDuplicate(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 === result.mod2"));
-      });
-}
-
-TEST_F(ValueSerializerTestWithWasm, ComplexObjectWithManyTransfer) {
-  EnableTransferSerialization();
-  EnableTransferDeserialization();
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithMany(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 != result.mod2"));
-      });
-}
-
-TEST_F(ValueSerializerTestWithWasm, ComplexObjectWithManyInline) {
-  SetExpectInlineWasm(true);
-  RoundTripTest(
-      [this]() { return GetComplexObjectWithMany(); },
-      [this](Local<Value> value) {
-        VerifyComplexObject(value);
-        EXPECT_TRUE(EvaluateScriptForResultBool("result.mod1 != result.mod2"));
-      });
-}
-
 // As produced around Chrome 56.
 const unsigned char kSerializedIncrementerWasm[] = {
     0xff, 0x09, 0x3f, 0x00, 0x57, 0x79, 0x2d, 0x00, 0x61, 0x73, 0x6d, 0x0d,
     0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60, 0x01, 0x7f, 0x01, 0x7f, 0x03,
     0x02, 0x01, 0x00, 0x07, 0x0d, 0x01, 0x09, 0x69, 0x6e, 0x63, 0x72, 0x65,
     0x6d, 0x65, 0x6e, 0x74, 0x00, 0x00, 0x0a, 0x08, 0x01, 0x06, 0x00, 0x20,
     0x00, 0x41, 0x01, 0x6a, 0xf8, 0x04, 0xa1, 0x06, 0xde, 0xc0, 0xc6, 0x44,
     0x3c, 0x29, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x02, 0x00, 0x00, 0x81, 0x4e,
     0xce, 0x7c, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x30, 0x02,
     0x00, 0x00, 0xb0, 0x25, 0x30, 0xe3, 0xf2, 0xdb, 0x2e, 0x48, 0x00, 0x00,
@@ skipping 94 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