[wasm] Module Builder v8 API: bytes passed in are owned by caller.

src/api.cc

 // Copyright 2012 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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 7572 matching lines @@
                                                            size_t length) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::wasm::ErrorThrower thrower(i_isolate, "WasmCompiledModule::Deserialize()");
   i::MaybeHandle<i::JSObject> maybe_compiled = i::wasm::SyncCompile(
       i_isolate, &thrower, i::wasm::ModuleWireBytes(start, start + length));
   if (maybe_compiled.is_null()) return MaybeLocal<WasmCompiledModule>();
   return Local<WasmCompiledModule>::Cast(
       Utils::ToLocal(maybe_compiled.ToHandleChecked()));
 }
 
-void WasmModuleObjectBuilder::OnBytesReceived(
-    std::unique_ptr<const uint8_t[]>&& bytes, size_t size) {
-  received_buffers_.push_back(Buffer(std::move(bytes), size));
+void WasmModuleObjectBuilder::OnBytesReceived(const uint8_t* bytes,
+                                              size_t size) {
+  std::unique_ptr<uint8_t[]> cloned_bytes(new uint8_t[size]);
+  memcpy(cloned_bytes.get(), bytes, size);
+  received_buffers_.push_back(
+      Buffer(std::unique_ptr<const uint8_t[]>(
+                 const_cast<const uint8_t*>(cloned_bytes.release())),
+             size));
   total_size_ += size;
 }
 
 MaybeLocal<WasmCompiledModule> WasmModuleObjectBuilder::Finish() {
   std::unique_ptr<uint8_t[]> wire_bytes(new uint8_t[total_size_]);
   uint8_t* insert_at = wire_bytes.get();
 
   for (size_t i = 0; i < received_buffers_.size(); ++i) {
     const Buffer& buff = received_buffers_[i];
     memcpy(insert_at, buff.first.get(), buff.second);
@@ skipping 2718 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8