[wasm] Skeleton WasmModuleObjectBuilder for streamed compilation

test/cctest/wasm/test-run-wasm-module.cc

 // Copyright 2015 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 <stdlib.h>
 #include <string.h>
 
 #include "src/objects-inl.h"
 #include "src/snapshot/code-serializer.h"
 #include "src/version.h"
@@ skipping 419 matching lines @@
   {
     HandleScope scope(test.current_isolate());
     test.InvalidateVersion();
     test.InvalidateWireBytes();
     test.Deserialize();
   }
   Cleanup(test.current_isolate());
   Cleanup();
 }
 
+std::unique_ptr<const uint8_t[]> CreatePayload(const uint8_t* start,
+                                               size_t size) {
+  uint8_t* ret = new uint8_t[size];
+  memcpy(ret, start, size);
+  return std::unique_ptr<const uint8_t[]>(const_cast<const uint8_t*>(ret));
+}
+
+TEST(ModuleBuilder) {
+  v8::internal::AccountingAllocator allocator;
+  Zone zone(&allocator, ZONE_NAME);
+  ZoneBuffer buffer(&zone);
+  WasmSerializationTest::BuildWireBytes(&zone, &buffer);
+  CHECK_GT(buffer.size(), 0);
+  size_t third = buffer.size() / 3;
+  size_t first_mark = third - 2;
+  size_t second_mark = buffer.size() - 2 - third;
+  CHECK(0 < first_mark);
+  CHECK(first_mark < second_mark);
+  CHECK(second_mark < buffer.size());
+  Isolate* i_isolate = CcTest::InitIsolateOnce();
+  v8::WasmModuleObjectBuilder builder(CcTest::isolate());
+  std::unique_ptr<const uint8_t[]> first_part =
+      CreatePayload(buffer.begin(), first_mark);
+  std::unique_ptr<const uint8_t[]> second_part =
+      CreatePayload(buffer.begin() + first_mark, second_mark - first_mark);
+  std::unique_ptr<const uint8_t[]> third_part =
+      CreatePayload(buffer.begin() + second_mark, buffer.size() - second_mark);
+  builder.OnBytesReceived(std::move(first_part), first_mark);
+  builder.OnBytesReceived(std::move(second_part), second_mark - first_mark);
+  builder.OnBytesReceived(std::move(third_part), buffer.size() - second_mark);
+  {
+    HandleScope scope(i_isolate);
+    v8::MaybeLocal<v8::WasmCompiledModule> maybe_module = builder.Finish();
+    CHECK(!maybe_module.IsEmpty());
+  }
+}
+
+TEST(FailingModuleBuilder) {
+  v8::internal::AccountingAllocator allocator;
+  Zone zone(&allocator, ZONE_NAME);
+  ZoneBuffer buffer(&zone);
+  WasmSerializationTest::BuildWireBytes(&zone, &buffer);
+  CHECK_GT(buffer.size(), 0);
+  size_t third = buffer.size() / 3;
+  size_t first_mark = third - 2;
+  size_t second_mark = buffer.size() - 2 - third;
+  CHECK(0 < first_mark);
+  CHECK(first_mark < second_mark);
+  CHECK(second_mark < buffer.size());
+  Isolate* i_isolate = CcTest::InitIsolateOnce();
+  v8::WasmModuleObjectBuilder builder(CcTest::isolate());
+  std::unique_ptr<const uint8_t[]> first_part =
+      CreatePayload(buffer.begin(), first_mark);
+  builder.OnBytesReceived(std::move(first_part), first_mark);
+  {
+    HandleScope scope(i_isolate);
+    v8::MaybeLocal<v8::WasmCompiledModule> maybe_module = builder.Finish();
+    CHECK(maybe_module.IsEmpty());
+  }
+}
+
 bool False(v8::Local<v8::Context> context) { return false; }
 
 TEST(BlockWasmCodeGen) {
   v8::internal::AccountingAllocator allocator;
   Zone zone(&allocator, ZONE_NAME);
   ZoneBuffer buffer(&zone);
   WasmSerializationTest::BuildWireBytes(&zone, &buffer);
   Isolate* isolate = CcTest::InitIsolateOnce();
   HandleScope scope(isolate);
   testing::SetupIsolateForWasmModule(isolate);
@@ skipping 619 matching lines @@
                                               ModuleOrigin::kWasmOrigin);
     CHECK_EQ(kExpectedValue, result);
     // Free the buffer as the tracker does not know about it.
     if (!memory->has_guard_region()) {
       isolate->array_buffer_allocator()->Free(
           memory->backing_store(), NumberToSize(memory->byte_length()));
     }
   }
   Cleanup();
 }