Add support for running browser tests to the test runner.

lib/src/runner/browser/compiler_pool.dart

 // Copyright (c) 2015, 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 unittest.util.compiler_pool;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
 import 'package:pool/pool.dart';
 
 import '../../util/io.dart';
 import '../load_exception.dart';
 
 /// A pool of `dart2js` instances.
 ///
 /// This limits the number of compiler instances running concurrently. It also
 /// ensures that their output doesn't intermingle; only one instance is
 /// "visible" (that is, having its output printed) at a time, and the other
 /// instances' output is buffered until it's their turn to be visible.
 class CompilerPool {
   /// The internal pool that controls the number of process running at once.
   final Pool _pool;
 
+  /// Whether to enable colors on dart2js.
+  final bool _color;
+
   /// The currently-active compilers.
   ///
   /// The first one is the only visible the compiler; the rest will become
   /// visible in queue order. Note that some of these processes may actually
   /// have already exited; they're kept around so that their output can be
   /// emitted once they become visible.
   final _compilers = new Queue<_Compiler>();
 
   /// Creates a compiler pool that runs up to [parallel] instances of `dart2js`
   /// at once.
   ///
   /// If [parallel] isn't provided, it defaults to 4.
-  CompilerPool({int parallel})
-      : _pool = new Pool(parallel == null ? 4 : parallel);
+  ///
+  /// If [color] is true, `dart2js` will be run with colors enabled.
+  CompilerPool({int parallel, bool color: false})
+      : _pool = new Pool(parallel == null ? 4 : parallel),
+        _color = color;
 
   /// Compile the Dart code at [dartPath] to [jsPath].
   ///
   /// This wraps the Dart code in the standard browser-testing wrapper. If
   /// [packageRoot] is provided, it's used as the package root for the
   /// compilation.
   ///
   /// The returned [Future] will complete once the `dart2js` process completes
   /// *and* all its output has been printed to the command line.
   Future compile(String dartPath, String jsPath, {String packageRoot}) {
@@ skipping 12 matching lines @@
 
         var dart2jsPath = p.join(sdkDir, 'bin', 'dart2js');
         if (Platform.isWindows) dart2jsPath += '.bat';
 
         var args = ["--checked", wrapperPath, "--out=$jsPath"];
 
         if (packageRoot != null) {
           args.add("--package-root=${p.absolute(packageRoot)}");
         }
 
-        if (canUseSpecialChars) {
-          args.add("--enable-diagnostic-colors");
-        }
+        if (_color) args.add("--enable-diagnostic-colors");
 
         return Process.start(dart2jsPath, args).then((process) {
           var compiler = new _Compiler(dartPath, process);
 
           if (_compilers.isEmpty) _showProcess(compiler);
           _compilers.add(compiler);
 
           return compiler.onDone;
         });
       });
@@ skipping 39 matching lines @@
   /// The underlying process.
   final Process process;
 
   /// A future that will complete once this instance has finished running and
   /// all its output has been printed.
   Future get onDone => onDoneCompleter.future;
   final onDoneCompleter = new Completer();
 
   _Compiler(this.path, this.process);
 }