[wasm] Support recompilation if deserialization fails.

src/api.cc

Index: src/api.cc
diff --git a/src/api.cc b/src/api.cc
index 44933b965becb813a6f0dba8e2b8785ce844bc64..eaa12318f75c488f01aa5e4297a2db78304e9ebe 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -7184,22 +7184,49 @@ MaybeLocal<Proxy> Proxy::New(Local<Context> context, Local<Object> local_target,
   RETURN_ESCAPED(result);
 }
 
+Local<String> WasmCompiledModule::GetUncompiledBytes() {
+  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)));
+  return Local<String>::Cast(Utils::ToLocal(compiled_part->module_bytes()));
+}
+
 WasmCompiledModule::SerializedModule WasmCompiledModule::Serialize() {
+  class WasmCompiledModuleRawBytesManager {
+   public:
+    WasmCompiledModuleRawBytesManager(
+        i::Handle<i::wasm::WasmCompiledModule> wasm_module)
+        : module_(wasm_module), bytes_(wasm_module->module_bytes()) {
+      module_->reset_module_bytes();
+    }
+
+    ~WasmCompiledModuleRawBytesManager() { module_->set_module_bytes(bytes_); }
+
+   private:
+    i::Handle<i::wasm::WasmCompiledModule> module_;
+    i::Handle<i::String> bytes_;
+  };
+
   i::Handle<i::JSObject> obj =
       i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
-  i::Handle<i::FixedArray> compiled_part =
-      i::handle(i::FixedArray::cast(obj->GetInternalField(0)));
+  i::Handle<i::wasm::WasmCompiledModule> compiled_part =
+      i::handle(i::wasm::WasmCompiledModule::cast(obj->GetInternalField(0)));
+
+  WasmCompiledModuleRawBytesManager ensure_clean_serialization(compiled_part);

[Yang, 2016/10/06 07:35:34]

what's the advantage of this over of simply take compiled_part->module_bytes()
here and store it back at the end?

Also, do we expect compiled_part->module_bytes() to changed in
SerializeWasmModule?

[vogelheim, 2016/10/06 10:00:50]

Agree w/ Yang.

Also, in case we do want to keep this: Elsewhere in V8 we've called similar
helper objects SomethingSomethingScope, which makes it clearer to people
familiar w/ V8 code what this does. Maybe something like: SaveModuleBytesScope?
Or SaveModuleBytesScope?

[Mircea Trofin, 2016/10/06 16:17:47]

Initially I thought there may be error cases to deal with, coming out of the
serializer, but now I realize that's not
the case, and that in itself wouldn't change the control flow in a way that'd
make the simpler code unfeasible. 
So canning the over-complication. 
Absolutely not. We take it out, however, because:
- we want the bytes to be separately handled by the caller. The scenario is:
serialize to IndexedDB today; Chrome+v8 updates; deserialize. We want the
uncompiled bytes to be serialized separately as raw bytes, and not depend  on
v8's serializer. 
- we don't want to pay for the bytes twice. Wasm payloads are large. Uncompiled
bytes are megs or tens of megs. Especially on mobile, it'd be sloppy to save
them both.
I like the name suggestions, but I think for now I'm taking the simpler code
suggestion.

   std::unique_ptr<i::ScriptData> script_data =
       i::WasmCompiledModuleSerializer::SerializeWasmModule(obj->GetIsolate(),
                                                            compiled_part);
   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(
+MaybeLocal<WasmCompiledModule> WasmCompiledModule::DeserializeOrCompile(
     Isolate* isolate,
-    const WasmCompiledModule::SerializedModule& serialized_data) {
+    const WasmCompiledModule::SerializedModule& serialized_data,
+    Local<String> uncompiled_bytes) {
   int size = static_cast<int>(serialized_data.second);
   i::ScriptData sc(serialized_data.first.get(), size);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
@@ -7207,11 +7234,31 @@ MaybeLocal<WasmCompiledModule> WasmCompiledModule::Deserialize(
       i::WasmCompiledModuleSerializer::DeserializeWasmModule(i_isolate, &sc);
   i::Handle<i::FixedArray> compiled_part;
   if (!maybe_compiled_part.ToHandle(&compiled_part)) {
-    return MaybeLocal<WasmCompiledModule>();
+    return Compile(isolate, uncompiled_bytes);
   }
+  i::Handle<i::wasm::WasmCompiledModule> compiled_module =
+      handle(i::wasm::WasmCompiledModule::cast(*compiled_part));
+  i::Handle<i::String> module_bytes = Utils::OpenHandle(*uncompiled_bytes);
+  compiled_module->set_module_bytes(module_bytes);
   return Local<WasmCompiledModule>::Cast(
       Utils::ToLocal(i::wasm::CreateCompiledModuleObject(
-          i_isolate, compiled_part, i::wasm::ModuleOrigin::kWasmOrigin)));
+          i_isolate, compiled_module, i::wasm::ModuleOrigin::kWasmOrigin)));
+}
+
+MaybeLocal<WasmCompiledModule> WasmCompiledModule::Compile(
+    Isolate* isolate, Local<String> bytes) {
+  i::Handle<i::String> module_bytes = Utils::OpenHandle(*bytes);
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  // if we cannot deserialize, we recompile

[vogelheim, 2016/10/06 10:00:50]

Doesn't that comment belongs into DeserializeOrCompile? (Once we're here, we
have already made the decision to recompile, right?)

[Mircea Trofin, 2016/10/06 16:17:47]

yes.

+  i::wasm::ErrorThrower thrower(i_isolate, "WasmCompiledModule::Deserialize()");
+  i::SeqOneByteString* data = i::SeqOneByteString::cast(*module_bytes);
+  i::MaybeHandle<i::JSObject> maybe_compiled =
+      i::wasm::CreateModuleObjectFromBytes(
+          i_isolate, data->GetChars(), data->GetChars() + data->length(),
+          &thrower, i::wasm::ModuleOrigin::kWasmOrigin);
+  if (maybe_compiled.is_null()) return MaybeLocal<WasmCompiledModule>();
+  return Local<WasmCompiledModule>::Cast(
+      Utils::ToLocal(maybe_compiled.ToHandleChecked()));
 }
 
 // static