Always send kill signal to debug target

tests/standalone/debugger/debug_lib.dart

 // 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.
 
 // Library used by debugger wire protocol tests (standalone VM debugging).
 
 library DartDebugger;
 
 import "dart:async";
 import "dart:io";
@@ skipping 161 matching lines @@
 
   void send(Debugger debugger) {
     debugger.sendMessage(template);
   }
 
   void matchResponse(Debugger debugger) {
     Map response = debugger.currentMessage;
     var id = template["id"];
     assert(id != null && id >= 0);
     if (response["id"] != id) {
-      debugger.error("Expected messaged id $id but got ${response["id"]}.");
+      debugger.error("Error: expected messaged id $id but got ${response["id"]}.");
     }
   }
 }
 
 
 class FrameMatcher extends Command {
   int frameIndex;
   List<String> functionNames;
 
   FrameMatcher(this.frameIndex, this.functionNames) {
     template = {"id": 0, "command": "getStackTrace", "params": {"isolateId": 0}};
   }
 
   void matchResponse(Debugger debugger) {
     super.matchResponse(debugger);
     var msg = debugger.currentMessage;
     List frames = getJsonValue(msg, "result:callFrames");
     assert(frames != null);
     if (debugger.scriptUrl == null) {
       var name = frames[0]["functionName"];
       if (name == "main") {
         // Extract script url of debugged script.
         debugger.scriptUrl = frames[0]["location"]["url"];
         assert(debugger.scriptUrl != null);
       }
     }
     if (frames.length < functionNames.length) {
-      debugger.error("stack trace not long enough "
+      debugger.error("Error: stack trace not long enough "
                      "to match ${functionNames.length} frames");
       return;
     }
     for (int i = 0; i < functionNames.length; i++) {
       var idx = i + frameIndex;
       var name = frames[idx]["functionName"];
       assert(name != null);
       if (name != functionNames[i]) {
-        debugger.error("call frame $idx: "
+        debugger.error("Error: call frame $idx: "
           "expected function name '${functionNames[i]}' but found '$name'");
         return;
       }
     }
   }
 }
 
 
 MatchFrame(int frameIndex, String functionName) {
   return new FrameMatcher(frameIndex, [ functionName ]);
@@ skipping 68 matching lines @@
   // Debug target process properties.
   Process targetProcess;
   int portNumber;
   Socket socket;
   JsonBuffer responses = new JsonBuffer();
 
   DebugScript script;
   int seqNr = 0;  // Sequence number of next debugger command message.
   Command lastCommand = null;  // Most recent command sent to target.
   List<String> errors = new List();
+  bool cleanupDone = false;
 
   // Data collected from debug target.
   Map currentMessage = null;  // Currently handled message sent by target.
   String scriptUrl = null;
   bool shutdownEventSeen = false;
   int isolateId = 0;
   bool isPaused = false;
 
   Debugger(this.targetProcess, this.portNumber, this.script) {
     stdin.listen((_) {});
@@ skipping 19 matching lines @@
   void handleEvent(Map<String,dynamic> msg) {
     if (msg["event"] == "isolate") {
       if (msg["params"]["reason"] == "created") {
         isolateId = msg["params"]["id"];
         assert(isolateId != null);
         print("Debuggee isolate id $isolateId created.");
       } else if (msg["params"]["reason"] == "shutdown") {
         print("Debuggee isolate id ${msg["params"]["id"]} shut down.");
         shutdownEventSeen = true;
         if (!script.isEmpty) {
-          error("Premature isolate shutdown event seen.");
+          error("Error: premature isolate shutdown event seen.");
         }
       }
     } else if (msg["event"] == "breakpointResolved") {
       var bpId = msg["params"]["breakpointId"];
       assert(bpId != null);
       var isolateId = msg["params"]["isolateId"];
       assert(isolateId != null);
       var location = msg["params"]["location"];
       assert(location != null);
       print("Isolate $isolateId: breakpoint $bpId resolved"
             " at location $location");
       // We may want to maintain a table of breakpoints in the future.
     } else if (msg["event"] == "paused") {
       isPaused = true;
     } else {
-      error("unknown debugger event received");
+      error("Error: unknown debugger event received");
     }
   }
 
   // Handle one JSON message object and match it to the
   // expected events and responses in the debugging script.
   void handleMessage(Map<String,dynamic> receivedMsg) {
     currentMessage = receivedMsg;
     if (receivedMsg["event"] != null) {
       handleEvent(receivedMsg);
       if (errorsDetected) {
@@ skipping 28 matching lines @@
   // Handle data received over the wire from the debug target
   // process. Split input from JSON wire format into individual
   // message objects (maps).
   void handleMessages() {
     var msg = responses.getNextMessage();
     while (msg != null) {
       if (verboseWire) print("RECV: $msg");
       if (responses.haveGarbage()) {
         error("Error: leftover text after message: '${responses.buffer}'");
         error("Previous message may be malformed, was: '$msg'");
-        close(killDebugee: true);
+        cleanup();
         return;
       }
       var msgObj = JSON.parse(msg);
       handleMessage(msgObj);
       if (errorsDetected) {
         error("Error while handling script entry");
         error("Message received from debug target: $msg");
-        close(killDebugee: true);
+        cleanup();
         return;
       }
       if (shutdownEventSeen) {
-        close();
+        cleanup();
         return;
       }
       if (isPaused) sendNextCommand();
       msg = responses.getNextMessage();
     }
   }
 
   runScript(List entries) {
     script = new DebugScript(entries);
     openConnection();
@@ skipping 22 matching lines @@
   void openConnection() {
     Socket.connect("127.0.0.1", portNumber).then((s) {
         this.socket = s;
         var stringStream = socket.transform(new StringDecoder());
         stringStream.listen((str) {
             try {
               responses.append(str);
               handleMessages();
             } catch(e, trace) {
               print("Unexpected exception:\n$e\n$trace");
-              close(killDebugee: true);
+              cleanup();
             }
           },
           onDone: () {
             print("Connection closed by debug target");
-            close(killDebugee: true);
+            cleanup();
           },
           onError: (e) {
             print("Error '$e' detected in input stream from debug target");
             var trace = getAttachedStackTrace(e);
             if (trace != null) print("StackTrace: $trace");
-            close(killDebugee: true);
+            cleanup();
           });
       },
       onError: (e) {
         String msg = "Error while connecting to debugee: $e";
         var trace = getAttachedStackTrace(e);
         if (trace != null) msg += "\nStackTrace: $trace";
         error(msg);
-        close(killDebugee: true);
+        cleanup();
       });
   }
 
-  void close({killDebugee: false}) {
-    void printErrorsAndExit() {
-      if (errorsDetected) throw "Errors detected";
-      exit(errors.length);
-    }
-    if (errorsDetected) {
-      for (int i = 0; i < errors.length; i++) print(errors[i]);
-    }
+  void cleanup() {
+    if (cleanupDone) return;
     if (socket != null) {
       socket.close().catchError((error) {
-        print("Error occured while closing socket: $error");
+        // Print this directly in addition to adding it to the
+        // error message queue, in case the error message queue
+        // gets printed before this error handler is called.
+        print("Error occurred while closing socket: $error");
+        error("Error while closing socket: $error");
       });
     }
-    if (killDebugee) {
-      if (!targetProcess.kill()) {
-        print("Could not send kill signal to target process.");
-      } else {
-        print("Successfully sent kill signal to target process.");
+    targetProcess.kill();
+    // If the process was already dead exitCode is already
+    // available and we call exit() in the next event loop cycle.
+    // Otherwise this will wait for the process to exit.
+    targetProcess.exitCode.then((exitCode) {
+      if (errorsDetected) {
+        print("\n===== Errors detected: =====");
+        for (int i = 0; i < errors.length; i++) print(errors[i]);
+        print("============================\n");
       }
-      // If the process was already dead exitCode is already
-      // available and we call exit() in the next event loop cycle.
-      // Otherwise this will wait for the process to exit.
-      targetProcess.exitCode.then((exitCode) {
-        printErrorsAndExit();
-      });
-    } else {
-      printErrorsAndExit();
-    }
+      exit(errors.length);
+    });
+    cleanupDone = true;
   }
 }
 
 
 bool RunScript(List script) {
   var options = new Options();
   if (options.arguments.contains("--debuggee")) {
     return false;
   }
   verboseWire = options.arguments.contains("--wire");
@@ skipping 30 matching lines @@
         var trace = getAttachedStackTrace(e);
         if (trace != null) print("StackTrace: $trace");
         return -1;
       } else {
         // Retry with another random port.
         RunScript(script);
       }
     });
   return true;
 }