Terminate event handler thread on isolate shutdown.

runtime/bin/main.cc

 // Copyright (c) 2012, 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.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/dbg_connection.h"
 #include "bin/directory.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
+#include "bin/isolate_data.h"
 #include "bin/platform.h"
 #include "bin/process.h"
 #include "platform/globals.h"
 
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
 extern const uint8_t* snapshot_buffer;
 
 
 // Global state that stores the original working directory..
@@ skipping 576 matching lines @@
   return true;
 }
 
 
 static bool CreateIsolateAndSetup(const char* script_uri,
                                   const char* main,
                                   void* data, char** error) {
   return CreateIsolateAndSetupHelper(script_uri,
                                      main,
                                      false,  // script_uri already canonical.
-                                     data,
+                                     new IsolateData(),
                                      error);
 }
 
 
 static void PrintUsage() {
   fprintf(stderr,
           "dart [<vm-flags>] <dart-script-file> [<dart-options>]\n");
 }
 
 
@@ skipping 59 matching lines @@
   va_end(arguments);
 
   Dart_ExitScope();
   Dart_ShutdownIsolate();
   free(const_cast<char*>(original_working_directory));
 
   return kErrorExitCode;
 }
 
 
+static void ShutdownIsolate(void* callback_data) {
+  IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
+  EventHandler* handler = isolate_data->event_handler;
+  if (handler != NULL) handler->Shutdown();
+  delete isolate_data;
+}
+
+
 int main(int argc, char** argv) {
   char* executable_name;
   char* script_name;
   CommandLineOptions vm_options(argc);
   CommandLineOptions dart_options(argc);
   CommandLineOptions import_map(argc);
   import_map_options = &import_map;
   bool print_flags_seen = false;
 
   // Perform platform specific initialization.
@@ skipping 16 matching lines @@
       return 0;
     } else {
       PrintUsage();
       return kErrorExitCode;
     }
   }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Initialize the Dart VM.
-  Dart_Initialize(CreateIsolateAndSetup, NULL, NULL);
+  Dart_Initialize(CreateIsolateAndSetup,
+                  NULL,
+                  ShutdownIsolate);
 
   original_working_directory = Directory::Current();
 
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   char* isolate_name = BuildIsolateName(script_name, "main");
   if (!CreateIsolateAndSetupHelper(script_name,
                                    "main",
                                    true,  // Canonicalize the script name.
-                                   NULL,
+                                   new IsolateData(),
                                    &error)) {
     fprintf(stderr, "%s\n", error);
     free(const_cast<char*>(original_working_directory));
     free(error);
     delete [] isolate_name;
     return kErrorExitCode;  // Indicates we encountered an error.
   }
   delete [] isolate_name;
 
   Dart_Isolate isolate = Dart_CurrentIsolate();
@@ skipping 53 matching lines @@
   DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   free(const_cast<char*>(original_working_directory));
 
   return 0;
 }