[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 2577 matching lines @@
             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 {
+ public:
+  ValueSerializerTestWithWasm()
+      : deserialize_delegate_(&transfer_modules_),
+        serialize_delegate_(&transfer_modules_) {}
+
+  void Reset() {
+    current_serializer_delegate_ = nullptr;
+    current_deserializer_delegate_ = nullptr;
+  }
+
+  void EnableTransferSerialization() {
+    current_serializer_delegate_ = &serialize_delegate_;
+  }
+  void EnableTransferDeserialization() {
+    current_deserializer_delegate_ = &deserialize_delegate_;
+  }
+  void AllowInlineWasm(bool value) {
+    deserialize_delegate_.SetAllowInlineWasm(value);
+  }
+
  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 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->AsTransferrableModule());
+      return Just(static_cast<uint32_t>(modules_->size()) - 1);
+    }
+
+    void ThrowDataCloneError(Local<String> message) override {}
+
+   private:
+    std::vector<WasmCompiledModule::TransferrableModule>* modules_;
+  };
+
+  class DeserializeToTransfer : public ValueDeserializer::Delegate {
+   public:
+    DeserializeToTransfer(
+        std::vector<WasmCompiledModule::TransferrableModule>* modules)
+        : modules_(modules) {}
+
+    MaybeLocal<WasmCompiledModule> GetWasmModuleFromId(Isolate* isolate,
+                                                       uint32_t id) override {
+      return WasmCompiledModule::FromTransferrableModule(isolate,
+                                                         modules_->at(id));
+    }
+    bool AllowInlineWasm() const override { return allow_inline_; }
+    void SetAllowInlineWasm(bool value) { allow_inline_ = value; }
+
+   private:
+    std::vector<WasmCompiledModule::TransferrableModule>* modules_;
+    bool allow_inline_ = false;
+  };
+
+  ValueSerializer::Delegate* GetSerializerDelegate() override {
+    return current_serializer_delegate_;
+  }
+  ValueDeserializer::Delegate* GetDeserializerDelegate() override {
+    return current_deserializer_delegate_;
+  }
+
  private:
   static bool g_saved_flag;
+  std::vector<WasmCompiledModule::TransferrableModule> transfer_modules_;
+  DeserializeToTransfer deserialize_delegate_;
+  SerializeToTransfer serialize_delegate_;
+  ValueSerializer::Delegate* current_serializer_delegate_ = nullptr;
+  ValueDeserializer::Delegate* current_deserializer_delegate_ = nullptr;
 };
 
 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,
 };
 
 TEST_F(ValueSerializerTestWithWasm, RoundTripWasmModule) {
-  RoundTripTest(
-      [this]() {
-        return WasmCompiledModule::DeserializeOrCompile(
-                   isolate(), {nullptr, 0},
-                   {kIncrementerWasm, sizeof(kIncrementerWasm)})
-            .ToLocalChecked();
-      },
-      [this](Local<Value> value) {
-        ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
-        EXPECT_TRUE(EvaluateScriptForResultBool(
-            "new WebAssembly.Instance(result).exports.increment(8) === 9"));
-      });
+  auto deserialize = [this]() {
+    return WasmCompiledModule::DeserializeOrCompile(
+               isolate(), {nullptr, 0},
+               {kIncrementerWasm, sizeof(kIncrementerWasm)})
+        .ToLocalChecked();
+  };
+  auto passingTest = [this, deserialize]() {
+    RoundTripTest(deserialize, [this](Local<Value> value) {
+      ASSERT_TRUE(value->IsWebAssemblyCompiledModule());
+      EXPECT_TRUE(EvaluateScriptForResultBool(
+          "new WebAssembly.Instance(result).exports.increment(8) === 9"));
+    });
+  };
+
+  auto failingTest = [this, deserialize]() {
+    EncodeTest(deserialize, [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).
+  //
+  //
+  // Roundtripping works if serializer and
+  // deserializer both work off transferred data
+  Reset();
+  EnableTransferSerialization();
+  EnableTransferDeserialization();
+  passingTest();
+  // Alternatively, if the deserializer expects inline
+  // data, and the serializer produces that - which is default
+  Reset();
+  EnableTransferDeserialization();
+  AllowInlineWasm(true);
+  passingTest();
+  // By default, the deserializer does not work with inlined
+  // data
+  Reset();
+  failingTest();
+  // Even if the serializer tries transferring, the deserializer
+  // won't work.
+  EnableTransferSerialization();
+  failingTest();
 }
 
 // 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,
@@ skipping 96 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