[wasm] Use a Managed<WasmModule> to hold metadata about modules.

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 7173 matching lines @@
   i::Handle<i::String> wire_bytes = compiled_part->module_bytes();
   return Local<String>::Cast(Utils::ToLocal(wire_bytes));
 }
 
 WasmCompiledModule::SerializedModule WasmCompiledModule::Serialize() {
   i::Handle<i::JSObject> obj =
       i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
   i::Handle<i::wasm::WasmCompiledModule> compiled_part =
       i::handle(i::wasm::WasmCompiledModule::cast(obj->GetInternalField(0)));
 
-  i::Handle<i::SeqOneByteString> wire_bytes = compiled_part->module_bytes();
-  compiled_part->reset_module_bytes();

[Mircea Trofin, 2016/10/15 17:38:39]

Consider the scenario when we try to deserialize from an older version stored in
indexedDB, and need to recompile. To recompile, we need the wasm wire bytes.
Since deserialization won't even get past the serialized header, our only way to
get back to the wire bytes is to explicitly serialize them (as discussed, long
term, we envision they are stored separately as Blobs). 

This means the serialized payload is wire_bytes + serialized_module.

If we leave the wire bytes hanging off the serialized module, the serialized
payload is 2*wire_bytes + serialized_module.

Typically, the serialized module is about 4-5x larger than the wire bytes. So
this means the duplicate wire_bytes constitute a 16-20% increase in serialized
data.

To achieve the goal of this CL, we only need the header bytes. Is the plan to
follow-up with another CL, where that happens? If so, I think we should do that
before we ship, so we should add an issue#; also, are we OK with taking a hit in
user-observable properties in the meantime? (I realize the whole wasm feature is
under a flag, so I don't think this is much of an issue myself, just calling it
out to make sure we understand the trade-offs and are all OK with them).

   std::unique_ptr<i::ScriptData> script_data =
       i::WasmCompiledModuleSerializer::SerializeWasmModule(obj->GetIsolate(),
                                                            compiled_part);
-  compiled_part->set_module_bytes(wire_bytes);
   script_data->ReleaseDataOwnership();
 
   size_t size = static_cast<size_t>(script_data->length());
   return {std::unique_ptr<const uint8_t[]>(script_data->data()), size};
 }
 
 MaybeLocal<WasmCompiledModule> WasmCompiledModule::Deserialize(
     Isolate* isolate,
     const WasmCompiledModule::SerializedModule& serialized_module) {
   return Deserialize(isolate,
                      {serialized_module.first.get(), serialized_module.second});
 }
 
 MaybeLocal<WasmCompiledModule> WasmCompiledModule::Deserialize(
     Isolate* isolate,
     const WasmCompiledModule::CallerOwnedBuffer& serialized_module) {
   int size = static_cast<int>(serialized_module.second);
   i::ScriptData sc(serialized_module.first, size);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   i::MaybeHandle<i::FixedArray> maybe_compiled_part =
       i::WasmCompiledModuleSerializer::DeserializeWasmModule(i_isolate, &sc);
   i::Handle<i::FixedArray> compiled_part;
   if (!maybe_compiled_part.ToHandle(&compiled_part)) {
     return MaybeLocal<WasmCompiledModule>();
   }
   i::Handle<i::wasm::WasmCompiledModule> compiled_module =
       handle(i::wasm::WasmCompiledModule::cast(*compiled_part));
   return Local<WasmCompiledModule>::Cast(
-      Utils::ToLocal(i::wasm::CreateCompiledModuleObject(
+      Utils::ToLocal(i::wasm::CreateWasmModuleObject(
           i_isolate, compiled_module, i::wasm::ModuleOrigin::kWasmOrigin)));
 }
 
 MaybeLocal<WasmCompiledModule> WasmCompiledModule::DeserializeOrCompile(
     Isolate* isolate,
     const WasmCompiledModule::CallerOwnedBuffer& serialized_module,
     const WasmCompiledModule::CallerOwnedBuffer& wire_bytes) {
   MaybeLocal<WasmCompiledModule> ret = Deserialize(isolate, serialized_module);
   if (!ret.IsEmpty()) return ret;
   return Compile(isolate, wire_bytes.first, wire_bytes.second);
@@ skipping 2176 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