Cleanup app snapshots on isolate/vm exit.

runtime/bin/gen_snapshot.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Generate a snapshot file after loading all the scripts specified on the
 // command line.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 1216 matching lines @@
 
 
 static Dart_Isolate CreateServiceIsolate(const char* script_uri,
                                          const char* main,
                                          const char* package_root,
                                          const char* package_config,
                                          Dart_IsolateFlags* flags,
                                          void* data,
                                          char** error) {
   IsolateData* isolate_data =
-      new IsolateData(script_uri, package_root, package_config);
+      new IsolateData(script_uri, package_root, package_config, NULL);
   Dart_Isolate isolate = NULL;
   isolate = Dart_CreateIsolate(script_uri, main, isolate_snapshot_data, NULL,
                                NULL, isolate_data, error);
 
   if (isolate == NULL) {
     Log::PrintErr("Error: Could not create service isolate\n");
     return NULL;
   }
 
   Dart_EnterScope();
@@ skipping 75 matching lines @@
   init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
   if (app_script_name != NULL) {
     init_params.create = CreateServiceIsolate;
   }
   init_params.file_open = DartUtils::OpenFile;
   init_params.file_read = DartUtils::ReadFile;
   init_params.file_write = DartUtils::WriteFile;
   init_params.file_close = DartUtils::CloseFile;
   init_params.entropy_source = DartUtils::EntropySource;
 
+  MappedMemory* mapped_vm_snapshot_data = NULL;
+  MappedMemory* mapped_isolate_snapshot_data = NULL;
   if (snapshot_kind == kScript) {
     File* file = File::Open(vm_snapshot_data_filename, File::kRead);
     if (file == NULL) {
       Log::PrintErr("Failed to open: %s\n", vm_snapshot_data_filename);
       return kErrorExitCode;
     }
-    void* buffer = file->Map(File::kReadOnly, 0, file->Length());
-    if (buffer == NULL) {
+    mapped_vm_snapshot_data = file->Map(File::kReadOnly, 0, file->Length());
+    if (mapped_vm_snapshot_data == NULL) {
       Log::PrintErr("Failed to read: %s\n", vm_snapshot_data_filename);
       return kErrorExitCode;
     }
     file->Close();
-    init_params.vm_snapshot_data = reinterpret_cast<const uint8_t*>(buffer);
+    init_params.vm_snapshot_data =
+        reinterpret_cast<const uint8_t*>(mapped_vm_snapshot_data->address());
 
     file = File::Open(isolate_snapshot_data_filename, File::kRead);
     if (file == NULL) {
       Log::PrintErr("Failed to open: %s\n", isolate_snapshot_data_filename);
       return kErrorExitCode;
     }
-    buffer = file->Map(File::kReadOnly, 0, file->Length());
-    if (buffer == NULL) {
+    mapped_isolate_snapshot_data =
+        file->Map(File::kReadOnly, 0, file->Length());
+    if (mapped_isolate_snapshot_data == NULL) {
       Log::PrintErr("Failed to read: %s\n", isolate_snapshot_data_filename);
       return kErrorExitCode;
     }
     file->Close();
-    isolate_snapshot_data = reinterpret_cast<const uint8_t*>(buffer);
+    isolate_snapshot_data = reinterpret_cast<const uint8_t*>(
+        mapped_isolate_snapshot_data->address());
   }
 
   char* error = Dart_Initialize(&init_params);
   if (error != NULL) {
     Log::PrintErr("VM initialization failed: %s\n", error);
     free(error);
     return kErrorExitCode;
   }
 
   IsolateData* isolate_data = new IsolateData(NULL, commandline_package_root,
-                                              commandline_packages_file);
+                                              commandline_packages_file, NULL);
   Dart_Isolate isolate = Dart_CreateIsolate(NULL, NULL, isolate_snapshot_data,
                                             NULL, NULL, isolate_data, &error);
   if (isolate == NULL) {
     Log::PrintErr("Error: %s\n", error);
     free(error);
     exit(kErrorExitCode);
   }
 
   Dart_Handle result;
   Dart_Handle library;
@@ skipping 27 matching lines @@
     result = DartUtils::SetupPackageRoot(commandline_package_root,
                                          commandline_packages_file);
     CHECK_RESULT(result);
 
     UriResolverIsolateScope::isolate = isolate;
     Dart_ExitScope();
     Dart_ExitIsolate();
 
     // Now we create an isolate into which we load all the code that needs to
     // be in the snapshot.
-    isolate_data = new IsolateData(NULL, NULL, NULL);
+    isolate_data = new IsolateData(NULL, NULL, NULL, NULL);
     const uint8_t* kernel = NULL;
     intptr_t kernel_length = 0;
     const bool is_kernel_file =
         TryReadKernel(app_script_name, &kernel, &kernel_length);
 
     void* kernel_program = NULL;
     if (is_kernel_file) {
       kernel_program = Dart_ReadKernelBinary(kernel, kernel_length);
       free(const_cast<uint8_t*>(kernel));
     }
@@ skipping 75 matching lines @@
 
     Dart_ExitScope();
     Dart_ShutdownIsolate();
   }
   error = Dart_Cleanup();
   if (error != NULL) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
     free(error);
   }
   EventHandler::Stop();
+  delete mapped_vm_snapshot_data;
+  delete mapped_isolate_snapshot_data;
   return 0;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }