[wasm] Fix memory leak in wasm-module-runner.cc

test/common/wasm/wasm-module-runner.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 "test/common/wasm/wasm-module-runner.h"
 
 #include "src/handles.h"
 #include "src/isolate.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
@@ skipping 63 matching lines @@
   Handle<JSObject> instance;
   if (!maybe_instance.ToHandle(&instance)) {
     return Handle<JSObject>::null();
   }
   return instance;
 }
 
 const Handle<JSObject> CompileInstantiateWasmModuleForTesting(
     Isolate* isolate, ErrorThrower* thrower, const byte* module_start,
     const byte* module_end, ModuleOrigin origin) {
-  const WasmModule* module = DecodeWasmModuleForTesting(
-      isolate, thrower, module_start, module_end, origin);
+  std::unique_ptr<const WasmModule> module(DecodeWasmModuleForTesting(

[titzer, 2016/10/24 13:34:40]

This isn't quite right.

This C++ object should be cleaned up by the garbage collector, since the
instance now holds a special Managed<WasmModule> reference to it. Adding this
unique pointer reclaims the C++ object after reaching the end of the method, but
the instance still holds a pointer to it.

If this is not getting cleaned up because the GC is not running finalizers, then
we should find a way to clean it up by explicitly, perhaps by manually deleting
the Managed<WasmModule> in InstantiateModuleForTesting.

[ahaas, 2016/10/24 14:04:29]

This is not the WasmModule that is given to the instance in
InstantiateModuleForTesting, so the garbage collector does not deallocate this
WasmModule. I added a TODO in InstantiateModuleForTesting that this module
should be given to the instance instead of decoding the module bytes again to
make a new WasmModule.

+      isolate, thrower, module_start, module_end, origin));
 
   if (module == nullptr) {
     thrower->CompileError("Wasm module decoding failed");
     return Handle<JSObject>::null();
   }
-  return InstantiateModuleForTesting(isolate, thrower, module);
+  return InstantiateModuleForTesting(isolate, thrower, module.get());
 }
 
 int32_t RunWasmModuleForTesting(Isolate* isolate, Handle<JSObject> instance,
                                 int argc, Handle<Object> argv[],
                                 ModuleOrigin origin) {
   ErrorThrower thrower(isolate, "RunWasmModule");
   const char* f_name = origin == ModuleOrigin::kAsmJsOrigin ? "caller" : "main";
   return CallWasmFunctionForTesting(isolate, instance, &thrower, f_name, argc,
                                     argv, origin);
 }
@@ skipping 120 matching lines @@
 
 void SetupIsolateForWasmModule(Isolate* isolate) {
   WasmJs::InstallWasmMapsIfNeeded(isolate, isolate->native_context());
   WasmJs::InstallWasmModuleSymbolIfNeeded(isolate, isolate->global_object(),
                                           isolate->native_context());
 }
 }  // namespace testing
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8