Support wedging isolates before startup or before exit.

runtime/vm/service.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.
 
 #include "vm/service.h"
 
 #include "include/dart_api.h"
 
 #include "vm/compiler.h"
 #include "vm/coverage.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
 #include "vm/message.h"
+#include "vm/message_handler.h"
 #include "vm/native_entry.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/profiler.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ skipping 229 matching lines @@
   if (create_callback == NULL) {
     return NULL;
   }
   Isolate::SetCurrent(NULL);
   char* error = NULL;
   Isolate* isolate = reinterpret_cast<Isolate*>(
       create_callback(callback_data, &error));
   if (isolate == NULL) {
     return NULL;
   }
+  // We don't want to pause the service isolate.
+  isolate->message_handler()->set_pause_on_start(false);
+  isolate->message_handler()->set_pause_on_exit(false);
   Isolate::SetCurrent(isolate);
   {
     // Install the dart:vmservice library.
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
     Library& library =
         Library::Handle(isolate, isolate->object_store()->root_library());
     // Isolate is empty.
     ASSERT(library.IsNull());
     // Grab embedder tag handler.
@@ skipping 83 matching lines @@
   ASSERT(!name.IsNull());
   const Array& list = Array::Handle(
       MakeServiceControlMessage(Dart_GetMainPortId(),
                                 VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID,
                                 name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
+  if (FLAG_trace_service) {
+    OS::Print("Isolate %s %" Pd64 " registered with service \n",
+              name.ToCString(),
+              Dart_GetMainPortId());
+  }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 bool Service::SendIsolateShutdownMessage() {
   if (!IsRunning()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   HANDLESCOPE(isolate);
+  const String& name = String::Handle(String::New(isolate->name()));
+  ASSERT(!name.IsNull());
   const Array& list = Array::Handle(
       MakeServiceControlMessage(Dart_GetMainPortId(),
                                 VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID,
-                                String::Handle(String::null())));
+                                name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
+  if (FLAG_trace_service) {
+    OS::Print("Isolate %s %" Pd64 " deregistered with service \n",
+              name.ToCString(),
+              Dart_GetMainPortId());
+  }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 
 bool Service::IsRunning() {
   return port_ != ILLEGAL_PORT;
 }
 
 
@@ skipping 1007 matching lines @@
   }
   if (js->num_arguments() != 1) {
     PrintError(js, "Command too long");
     return true;
   }
   isolate->class_table()->AllocationProfilePrintToJSONStream(js);
   return true;
 }
 
 
-static bool HandleUnpin(Isolate* isolate, JSONStream* js) {
+static bool HandleResume(Isolate* isolate, JSONStream* js) {
   // TODO(johnmccutchan): What do I respond with??
-  isolate->ClosePinPort();
+  if (isolate->message_handler()->pause_on_start()) {
+    isolate->message_handler()->set_pause_on_start(false);
+    return true;
+  }
+  if (isolate->message_handler()->pause_on_exit()) {
+    isolate->message_handler()->set_pause_on_exit(false);
+    return true;
+  }
   return true;
 }
 
 
 static bool HandleHeapMap(Isolate* isolate, JSONStream* js) {
   isolate->heap()->PrintHeapMapToJSONStream(js);
   return true;
 }
 
 
 static IsolateMessageHandlerEntry isolate_handlers[] = {
   { "_echo", HandleIsolateEcho },
   { "", HandleIsolate },
   { "allocationprofile", HandleAllocationProfile },
   { "classes", HandleClasses },
   { "code", HandleCode },
   { "coverage", HandleCoverage },
   { "cpu", HandleCpu },
   { "debug", HandleDebug },
   { "heapmap", HandleHeapMap },
   { "libraries", HandleLibraries },
   { "objects", HandleObjects },
   { "profile", HandleProfile },
-  { "unpin", HandleUnpin },
+  { "resume", HandleResume },
   { "scripts", HandleScripts },
   { "stacktrace", HandleStackTrace },
 };
 
 
 static IsolateMessageHandler FindIsolateMessageHandler(const char* command) {
   intptr_t num_message_handlers = sizeof(isolate_handlers) /
                                   sizeof(isolate_handlers[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const IsolateMessageHandlerEntry& entry = isolate_handlers[i];
@@ skipping 201 matching lines @@
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
 }
 
 }  // namespace dart