Send console messages through interaction manager.

dart/site/try/src/interaction_manager.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 trydart.interaction_manager;
 
 import 'dart:html';
 
 import 'dart:convert' show
     JSON;
@@ skipping 62 matching lines @@
 import 'shadow_root.dart' show
     getShadowRoot,
     getText,
     removeShadowRootPolyfill,
     setShadowRoot;
 
 const String TRY_DART_NEW_DEFECT =
     'https://code.google.com/p/dart/issues/entry'
     '?template=Try+Dart+Internal+Error';
 
-const Duration HEARTBEAT_INTERVAL = const Duration(milliseconds: 500);
+const Duration HEARTBEAT_INTERVAL = const Duration(milliseconds: 50);

[Johnni Winther, 2014/06/23 14:50:01]

Add comments on these constants.

[ahe, 2014/06/23 15:15:54]

Done.

 
 const Duration SAVE_INTERVAL = const Duration(seconds: 5);
 
 const Duration COMPILE_INTERVAL = const Duration(seconds: 1);
 
+const Duration SLOW_COMPILE = const Duration(seconds: 1);
+
 /**
  * UI interaction manager for the entire application.
  */
 abstract class InteractionManager {
   // Design note: All UI interactions go through one instance of this
   // class. This is by design.
   //
   // Simplicity in UI is in the eye of the beholder, not the implementor. Great
   // 'natural UI' is usually achieved with substantial implementation
   // complexity that doesn't modularize well and has nasty complicated state
@@ skipping 30 matching lines @@
   /// Called when the user selected a new project file.
   void onProjectFileSelected(String projectFile);
 
   /// Called when notified about a project file changed (on the server).
   void onProjectFileFsEvent(MessageEvent e);
 
   /// Called every 500ms.
   void onHeartbeat(Timer timer);
 
   /// Called by [:window.onMessage.listen:].
-  void onMessage(MessageEvent event);
+  void onWindowMessage(MessageEvent event);
+
+  void onCompilationFailed();
 
   void onCompilationDone();
 
   /// Called when a compilation is starting, but just before sending the
   /// initiating message to the compiler isolate.
   void compilationStarting();
+
+  // TODO(ahe): Remove this from InteractionManager, but not from InitialState.
+  void consolePrintLine(line);
+
+  void verboseCompilerMessage(String message);
 }
 
 /**
  * State machine for UI interactions.
  */
 class InteractionContext extends InteractionManager {
   InteractionState state;
 
   final Map<String, CompilationUnit> projectFiles = <String, CompilationUnit>{};
 
   final Set<CompilationUnit> modifiedUnits = new Set<CompilationUnit>();
 
   final Queue<CompilationUnit> unitsToSave = new Queue<CompilationUnit>();
 
+  /// Tracks time since last modification of a "project" file.
   final Stopwatch saveTimer = new Stopwatch();
 
+  /// Tracks time since last modification.
   final Stopwatch compileTimer = new Stopwatch();
 
+  /// Tracks elapsed time of current compilation.
+  final Stopwatch elapsedCompilationTime = new Stopwatch();
+
   CompilationUnit currentCompilationUnit =
       // TODO(ahe): Don't use a fake unit.
       new CompilationUnit('fake', '');
 
   Timer heartbeat;
 
   Completer<String> completeSaveOperation;
 
+  bool shouldClearConsole = false;
+
+  Element compilerConsole;
+
+  bool isFirstCompile = true;
+
   final Set<AnchorElement> oldDiagnostics = new Set<AnchorElement>();
 
   InteractionContext()
       : super.internal() {
     state = new InitialState(this);
     heartbeat = new Timer.periodic(HEARTBEAT_INTERVAL, onHeartbeat);
   }
 
   void onInput(Event event) => state.onInput(event);
 
@@ skipping 40 matching lines @@
   void onProjectFileSelected(String projectFile) {
     return state.onProjectFileSelected(projectFile);
   }
 
   void onProjectFileFsEvent(MessageEvent e) {
     return state.onProjectFileFsEvent(e);
   }
 
   void onHeartbeat(Timer timer) => state.onHeartbeat(timer);
 
-  void onMessage(MessageEvent event) => state.onMessage(event);
+  void onWindowMessage(MessageEvent event) => state.onWindowMessage(event);
+
+  void onCompilationFailed() => state.onCompilationFailed();
 
   void onCompilationDone() => state.onCompilationDone();
 
   void compilationStarting() => state.compilationStarting();
+
+  void consolePrintLine(line) => state.consolePrintLine(line);
+
+  void verboseCompilerMessage(String message) {
+    return state.verboseCompilerMessage(message);
+  }
 }
 
 abstract class InteractionState implements InteractionManager {
   InteractionContext get context;
 
   // TODO(ahe): Remove this.
   Set<AnchorElement> get oldDiagnostics {
     throw 'Use context.oldDiagnostics instead';
   }
 
@@ skipping 272 matching lines @@
       saveUnits();
     }
     if (!settings.compilationPaused &&
         context.compileTimer.elapsed > COMPILE_INTERVAL) {
       if (startCompilation()) {
         context.compileTimer
             ..stop()
             ..reset();
       }
     }
+
+    if (context.elapsedCompilationTime.elapsed > SLOW_COMPILE) {
+      if (context.compilerConsole.parent == null) {
+        outputDiv.append(context.compilerConsole);
+      }
+    }
   }
 
   void saveUnits() {
     if (context.unitsToSave.isEmpty) return;
     CompilationUnit unit = context.unitsToSave.removeFirst();
     onError(ProgressEvent event) {
       HttpRequest request = event.target;
       statusDiv.text = "Couldn't save '${unit.name}': ${request.responseText}";
       context.completeSaveOperation.complete(unit.name);
     }
     new HttpRequest()
         ..open("POST", "/project/${unit.name}")
         ..onError.listen(onError)
         ..send(unit.content);
     void setupCompleter() {
       context.completeSaveOperation = new Completer<String>.sync();
       context.completeSaveOperation.future.then((String name) {
         if (name == unit.name) {
           print("Saved source of '$name'");
           saveUnits();
         } else {
           setupCompleter();
         }
       });
     }
     setupCompleter();
   }
 
-  void onMessage(MessageEvent event) {
+  void onWindowMessage(MessageEvent event) {
     if (event.source is! WindowBase || event.source == window) {
       return onBadMessage(event);
     }
     if (event.data is List) {
       List message = event.data;
       if (message.length > 0) {
         switch (message[0]) {
           case 'error':
             return onErrorMessage(message[1]['url'], message[1]['message']);
           case 'scrollHeight':
@@ skipping 26 matching lines @@
   }
 
   void onBadMessage(MessageEvent event) {
     window.console
         ..groupCollapsed('Bad message')
         ..dir(event)
         ..log(event.source.runtimeType)
         ..groupEnd();
   }
 
-  void consolePrintLine(data) {
-    outputDiv.appendText('$data\n');
+  void consolePrintLine(line) {
+    if (context.shouldClearConsole) {
+      context.shouldClearConsole = false;
+      outputDiv.nodes.clear();
+    }
+    if (window.parent != window) {
+      // Test support.
+      // TODO(ahe): Use '/' instead of '*' when Firefox is upgraded to version
+      // 30 across build bots.  Support for '/' was added in version 29, and we
+      // support the two most recent versions.
+      window.parent.postMessage('$line\n', '*');
+    }
+    outputDiv.appendText('$line\n');
+  }
+
+  void onCompilationFailed() {
   }
 
   void onCompilationDone() {
+    context.isFirstCompile = false;
+    context.elapsedCompilationTime.stop();
+    Duration compilationDuration = context.elapsedCompilationTime.elapsed;
+    context.elapsedCompilationTime.reset();
+    print('Compilation took $compilationDuration.');
+    if (context.compilerConsole.parent != null) {
+      context.compilerConsole.remove();
+    }
     for (AnchorElement diagnostic in context.oldDiagnostics) {
       if (diagnostic.parent != null) {
         // Problem fixed, remove the diagnostic.
         diagnostic.replaceWith(new Text(getText(diagnostic)));
       }
     }
     context.oldDiagnostics.clear();
     observer.takeRecords(); // Discard mutations.
   }
 
   void compilationStarting() {
+    var progress = new SpanElement()
+        ..appendHtml('<i class="icon-spinner icon-spin"></i>')
+        ..appendText(' Compiling Dart program.');
+    if (settings.verboseCompiler) {
+      progress.appendText('..');
+    }
+    context.compilerConsole = new SpanElement()
+        ..append(progress)
+        ..appendText('\n');
+    context.shouldClearConsole = true;
+    context.elapsedCompilationTime
+        ..start()
+        ..reset();
+    if (context.isFirstCompile) {
+      outputDiv.append(context.compilerConsole);
+    }
     context.oldDiagnostics
         ..clear()
         ..addAll(mainEditorPane.querySelectorAll('a.diagnostic'));
   }
+
+  void verboseCompilerMessage(String message) {
+    if (settings.verboseCompiler) {
+      context.compilerConsole.appendText('$message\n');
+    } else {
+      if (isCompilerStageMarker(message)) {
+        Element progress = context.compilerConsole.firstChild;
+        progress.appendText('.');
+      }
+    }
+  }
 }
 
 Future<String> getString(uri) {
   return new Future<String>.sync(() => HttpRequest.getString('$uri'));
 }
 
 class PendingInputState extends InitialState {
   PendingInputState(InteractionContext context)
       : super(context);
 
@@ skipping 429 matching lines @@
   return text.split(new RegExp('^', multiLine: true));
 }
 
 void removeCodeCompletion() {
   List<Node> highlighting =
       mainEditorPane.querySelectorAll('.dart-code-completion');
   for (Element element in highlighting) {
     element.remove();
   }
 }
+
+bool isCompilerStageMarker(String message) {
+  return
+      message.startsWith('Package root is ') ||
+      message.startsWith('Compiling ') ||
+      message == "Resolving..." ||
+      message.startsWith('Resolved ') ||
+      message == "Inferring types..." ||
+      message == "Compiling..." ||
+      message.startsWith('Compiled ');
+}