Merge IO v2 branch to bleeding edge

tests/standalone/debugger/debug_lib.dart

 // 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.
 
 // Library used by debugger wire protocol tests (standalone VM debugging).
 
 library DartDebugger;
 
 import "dart:io";
 import "dart:utf";
@@ skipping 292 matching lines @@
     currentIndex++;
   }
 }
 
 
 class Debugger {
   // Debug target process properties.
   Process targetProcess;
   int portNumber;
   Socket socket;
-  OutputStream to;
-  StringInputStream from;
   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();
 
   // Data collected from debug target.
   Map currentMessage = null;  // Currently handled message sent by target.
   String scriptUrl = null;
   bool shutdownEventSeen = false;
   int isolateId = 0;
-  
+
+  // stdin subscription to allow terminating the test via command-line.
+  var stdinSubscription;
+
   Debugger(this.targetProcess, this.portNumber) {
-    var targetStdout = new StringInputStream(targetProcess.stdout);
-    targetStdout.onLine = () {
-      var s = targetStdout.readLine();
+    stdinSubscription =
+        stdin.listen((d) {},
+                     onError: (error) => close(killDebugee: true),
+                     onDone: () => close(killDebugee: true));
+
+    var stdoutStringStream = targetProcess.stdout
+        .transform(new StringDecoder())
+        .transform(new LineTransformer());
+    stdoutStringStream.listen((line) {
       if (showDebuggeeOutput) {
-        print("TARG: $s");
+        print("TARG: $line");
       }
-    };
-    var targetStderr = new StringInputStream(targetProcess.stderr);
-    targetStderr.onLine = () {
-      var s = targetStderr.readLine();
+    });
+
+    var stderrStringStream = targetProcess.stderr
+        .transform(new StringDecoder())
+        .transform(new LineTransformer());
+    stderrStringStream.listen((line) {
       if (showDebuggeeOutput) {
-        print("TARG: $s");
+        print("TARG: $line");
       }
-    };
+    });
   }
 
   // Handle debugger events for which there is no explicit
   // entry in the debug script, for example isolate create and
   // shutdown events, breakpoint resolution events, etc.
   bool handleImplicitEvents(Map<String,dynamic> msg) {
     if (msg["event"] == "isolate") {
       if (msg["params"]["reason"] == "created") {
         isolateId = msg["params"]["id"];
         assert(isolateId != null);
@@ skipping 91 matching lines @@
 
   runScript(List entries) {
     script = new DebugScript(entries);
     openConnection();
   }
 
   // Send a debugger command to the target VM.
   void sendMessage(Map<String,dynamic> msg) {
     String jsonMsg = JSON.stringify(msg);
     if (verboseWire) print("SEND: $jsonMsg");
-    to.writeString(jsonMsg, Encoding.UTF_8);
+    socket.addString(jsonMsg);
   }
 
   bool get errorsDetected => errors.length > 0;
 
   // Record error message.
   void error(String s) {
     errors.add(s);
   }
 
   void openConnection() {
-    socket = new Socket("127.0.0.1", portNumber);
-    to = socket.outputStream;
-    from = new StringInputStream(socket.inputStream, Encoding.UTF_8);
-    from.onData = () {
-      try {
-        responses.append(from.read());
-        handleMessages();
-      } catch(e, trace) {
-        print("Unexpected exception:\n$e\n$trace");
-        close(killDebugee: true);
-      }
-    };
-    from.onClosed = () {
-      print("Connection closed by debug target");
-      close(killDebugee: true);
-    };
-    from.onError = (e) {
-      print("Error '$e' detected in input stream from debug target");
-      close(killDebugee: true);
-    };
+    Socket.connect("127.0.0.1", portNumber).then((s) {
+      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);
+            }
+          },
+          onDone: () {
+            print("Connection closed by debug target");
+            close(killDebugee: true);
+          },
+          onError: (e) {
+            print("Error '$e' detected in input stream from debug target");
+            close(killDebugee: true);
+          });
+      });
   }
 
   void close({killDebugee: false}) {
     if (errorsDetected) {
       for (int i = 0; i < errors.length; i++) print(errors[i]);
     }
-    to.close();
     socket.close();
+    stdinSubscription.cancel();
     if (killDebugee) {
       targetProcess.kill();
       print("Target process killed");
     }
     Expect.isTrue(!errorsDetected);
     stdin.close();
     stdout.close();
     stderr.close();
   }
 }
 
 
 bool RunScript(List script) {
   var options = new Options();
   if (options.arguments.contains("--debuggee")) {
     return false;
   }
   showDebuggeeOutput = options.arguments.contains("--verbose");
   verboseWire = options.arguments.contains("--wire");
 
   var targetOpts = [ "--debug:$debugPort" ];
   if (showDebuggeeOutput) targetOpts.add("--verbose_debug");
   targetOpts.add(options.script);
   targetOpts.add("--debuggee");
 
   Process.start(options.executable, targetOpts).then((Process process) {
     print("Debug target process started");
     process.stdin.close();
-    process.stdout.onData = process.stdout.read;
-    process.stderr.onData = process.stderr.read;
-    process.onExit = (int exitCode) {
+    process.exitCode.then((int exitCode) {
+      Expect.equals(0, exitCode);
       Expect.equals(0, exitCode);
       print("Debug target process exited with exit code $exitCode");
-    };
+    });
     var debugger = new Debugger(process, debugPort);
-    stdin.onClosed = () => debugger.close(killDebugee: true);
-    stdin.onError = (error) => debugger.close(killDebugee: true);
     debugger.runScript(script);
   });
   return true;
 }