Provide stdout and stderr output in the Observatory debugger.

runtime/observatory/lib/src/elements/debugger.dart

 // Copyright (c) 2014, 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 debugger_page_element;
 
 import 'dart:async';
 import 'dart:html';
 import 'observatory_element.dart';
 import 'package:observatory/cli.dart';
@@ skipping 836 matching lines @@
   }
 
   String helpShort = 'Refresh debugging information of various sorts';
 
   String helpLong =
       'Refresh debugging information of various sorts.\n'
       '\n'
       'Syntax: refresh <subcommand>\n';
 }
 
+class _VMStreamPrinter {
+  ObservatoryDebugger _debugger;
+
+  _VMStreamPrinter(this._debugger);
+
+  String _savedStream;
+  String _savedIsolate;
+  String _savedLine;
+  List<String> _buffer = [];
+
+  void onEvent(String streamName, ServiceEvent event) {
+    String isolateName = event.isolate.name;
+    // If we get a line from a different isolate/stream, flush
+    // any pending output, even if it is not newline-terminated.
+    if ((_savedIsolate != null && isolateName != _savedIsolate) ||
+        (_savedStream != null && streamName != _savedStream)) {
+       flush();
+    }
+    String data = event.bytesAsString;
+    bool hasNewline = data.endsWith('\n');
+    if (_savedLine != null) {
+       data = _savedLine + data;
+      _savedIsolate = null;
+      _savedStream = null;
+      _savedLine = null;
+    }
+    var lines = data.split('\n').where((line) => line != '').toList();
+    if (lines.isEmpty) {
+      return;
+    }
+    int limit = (hasNewline ? lines.length : lines.length - 1);
+    for (int i = 0; i < limit; i++) {
+      _buffer.add(_format(isolateName, streamName, lines[i]));
+    }
+    // If there is no newline, we save the last line of output for next time.
+    if (!hasNewline) {
+      _savedIsolate = isolateName;
+      _savedStream = streamName;
+      _savedLine = lines[lines.length - 1];
+    }
+  }
+
+  void flush() {
+    // If there is any saved output, flush it now.
+    if (_savedLine != null) {
+      _buffer.add(_format(_savedIsolate, _savedStream, _savedLine));
+      _savedIsolate = null;
+      _savedStream = null;
+      _savedLine = null;
+    }
+    if (_buffer.isNotEmpty) {
+      _debugger.console.printStdio(_buffer);
+      _buffer.clear();
+    }
+  }
+
+  String _format(String isolateName, String streamName, String line) {
+    return '${isolateName}:${streamName}> ${line}';
+  }
+}
+
 // Tracks the state for an isolate debugging session.
 class ObservatoryDebugger extends Debugger {
   RootCommand cmd;
   DebuggerPageElement page;
   DebuggerConsoleElement console;
   DebuggerInputElement input;
   DebuggerStackElement stackElement;
   ServiceMap stack;
   String exceptions = "none";  // Last known setting.
 
@@ skipping 24 matching lines @@
         new StepCommand(this),
         new FinishCommand(this),
         new BreakCommand(this),
         new SetCommand(this),
         new ClearCommand(this),
         new DeleteCommand(this),
         new InfoCommand(this),
         new IsolateCommand(this),
         new RefreshCommand(this),
     ]);
+    _stdioPrinter = new _VMStreamPrinter(this);
   }
 
   VM get vm => page.app.vm;
 
   void updateIsolate(Isolate iso) {
     _isolate = iso;
     if (_isolate != null) {
       if (exceptions != iso.exceptionsPauseInfo) {
         exceptions = iso.exceptionsPauseInfo;
         console.print("Now pausing for $exceptions exceptions");
@@ skipping 79 matching lines @@
       if (stack['frames'].length > 0) {
         currentFrame = 0;
       } else {
         currentFrame = null;
       }
       input.focus();
     });
   }
 
   void reportStatus() {
+    flushStdio();
     if (_isolate == null) {
       console.print('No current isolate');
     } else if (_isolate.idle) {
       console.print('Isolate is idle');
     } else if (_isolate.running) {
       console.print("Isolate is running (type 'pause' to interrupt)");
     } else if (_isolate.pauseEvent != null) {
       _reportPause(_isolate.pauseEvent);
     } else {
       console.print('Isolate is in unknown state');
@@ skipping 99 matching lines @@
         console.print("Isolate ${iso.number} renamed to '${iso.name}'");
         break;
 
       case ServiceEvent.kPauseStart:
       case ServiceEvent.kPauseExit:
       case ServiceEvent.kPauseBreakpoint:
       case ServiceEvent.kPauseInterrupted:
       case ServiceEvent.kPauseException:
         if (event.owner == isolate) {
           _refreshStack(event).then((_) {
+            flushStdio();
             _reportPause(event);
           });
         }
         break;
 
       case ServiceEvent.kResume:
         if (event.owner == isolate) {
+          flushStdio();
           console.print('Continuing...');
         }
         break;
 
       case ServiceEvent.kBreakpointAdded:
       case ServiceEvent.kBreakpointResolved:
       case ServiceEvent.kBreakpointRemoved:
         if (event.owner == isolate) {
           _reportBreakpointEvent(event);
         }
         break;
 
       case ServiceEvent.kIsolateStart:
       case ServiceEvent.kGraph:
       case ServiceEvent.kGC:
       case ServiceEvent.kInspect:
         break;
 
       default:
         console.print('Unrecognized event: $event');
         break;
     }
   }
 
+  _VMStreamPrinter _stdioPrinter;
+
+  void flushStdio() {
+    _stdioPrinter.flush();
+  }
+
+  void onStdout(ServiceEvent event) {
+    _stdioPrinter.onEvent('stdout', event);
+  }
+
+  void onStderr(ServiceEvent event) {
+    _stdioPrinter.onEvent('stderr', event);
+  }
+
   static String _commonPrefix(String a, String b) {
     int pos = 0;
     while (pos < a.length && pos < b.length) {
       if (a.codeUnitAt(pos) != b.codeUnitAt(pos)) {
         break;
       }
       pos++;
     }
     return a.substring(0, pos);
   }
@@ skipping 69 matching lines @@
     }
   }
   ObservatoryDebugger debugger = new ObservatoryDebugger();
 
   DebuggerPageElement.created() : super.created() {
     debugger.page = this;
   }
 
   Future<StreamSubscription> _isolateSubscriptionFuture;
   Future<StreamSubscription> _debugSubscriptionFuture;
+  Future<StreamSubscription> _stdoutSubscriptionFuture;
+  Future<StreamSubscription> _stderrSubscriptionFuture;
 
   @override
   void attached() {
     super.attached();
 
     var navbarDiv = $['navbarDiv'];
     var stackDiv = $['stackDiv'];
     var splitterDiv = $['splitterDiv'];
     var cmdDiv = $['commandDiv'];
 
@@ skipping 13 matching lines @@
     stackElement.debugger = debugger;
     debugger.console = $['console'];
     debugger.input = $['commandline'];
     debugger.input.debugger = debugger;
     debugger.init();
 
     _isolateSubscriptionFuture =
         app.vm.listenEventStream(VM.kIsolateStream, debugger.onEvent);
     _debugSubscriptionFuture =
         app.vm.listenEventStream(VM.kDebugStream, debugger.onEvent);
+    _stdoutSubscriptionFuture =
+        app.vm.listenEventStream(VM.kStdoutStream, debugger.onStdout);
+    _stderrSubscriptionFuture =
+        app.vm.listenEventStream(VM.kStderrStream, debugger.onStderr);
+
+    // Turn on the periodic poll timer for this page.
+    pollPeriod = const Duration(milliseconds:100);
 
     onClick.listen((event) {
       // Random clicks should focus on the text box.  If the user selects
       // a range, don't interfere.
       var selection = window.getSelection();
       if (selection == null || selection.type == 'Caret') {
         debugger.input.focus();
       }
     });
   }
 
+  void onPoll() {
+    debugger.flushStdio();
+  }
+
   @override
   void detached() {
     cancelFutureSubscription(_isolateSubscriptionFuture);
     _isolateSubscriptionFuture = null;
     cancelFutureSubscription(_debugSubscriptionFuture);
     _debugSubscriptionFuture = null;
+    cancelFutureSubscription(_stdoutSubscriptionFuture);
+    _stdoutSubscriptionFuture = null;
+    cancelFutureSubscription(_stderrSubscriptionFuture);
+    _stderrSubscriptionFuture = null;
     super.detached();
   }
 }
 
 @CustomTag('debugger-stack')
 class DebuggerStackElement extends ObservatoryElement {
   @published Isolate isolate;
   @observable bool hasStack = false;
   @observable bool hasMessages = false;
   @observable bool isSampled = false;
@@ skipping 359 matching lines @@
     var span = new SpanElement();
     span.classes.add('red');
     span.appendText(line);
     if (newline) {
       span.appendText('\n');
     }
     $['consoleText'].children.add(span);
     span.scrollIntoView();
   }
 
+  void printStdio(List<String> lines) {
+    var lastSpan;
+    for (var line in lines) {
+      var span = new SpanElement();
+      span.classes.add('green');
+      span.appendText(line);
+      span.appendText('\n');
+      $['consoleText'].children.add(span);
+      lastSpan = span;
+    }
+    if (lastSpan != null) {
+      lastSpan.scrollIntoView();
+    }
+  }
+
   void printRef(Instance ref, { bool newline:true }) {
     var refElement = new Element.tag('instance-ref');
     refElement.ref = ref;
     $['consoleText'].children.add(refElement);
     if (newline) {
       this.newline();
     }
     refElement.scrollIntoView();
   }
 
@@ skipping 62 matching lines @@
       });
   }
 
   void focus() {
     $['textBox'].focus();
   }
 
   DebuggerInputElement.created() : super.created();
 }