Add dart2js batch mode support

tools/testing/dart/test_runner.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.
 
 /**
  * Classes and methods for executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
@@ skipping 1923 matching lines @@
     }
     for (var excludedEnvironmentVariable in EXCLUDED_ENVIRONMENT_VARIABLES) {
       environment.remove(excludedEnvironmentVariable);
     }
 
     return environment;
   }
 }
 
 class BatchRunnerProcess {
-  static bool isWindows = io.Platform.operatingSystem == 'windows';
-
-  final batchRunnerTypes = {
-      'dartanalyzer' : {
-        'run_executable' :
-           isWindows ?
-             'sdk\\bin\\dartanalyzer_developer.bat'
-              : 'sdk/bin/dartanalyzer_developer',
-        'run_arguments' : ['--batch'],
-      },
-      'dart2analyzer' : {
-        // This is a unix shell script, no windows equivalent available
-        'run_executable' : 'editor/tools/analyzer',
-        'run_arguments' : ['--batch'],
-    },
-  };
-
   Completer<CommandOutput> _completer;
-  Command _command;
+  ProcessCommand _command;
   List<String> _arguments;
   String _runnerType;
 
   io.Process _process;
   Map _processEnvironmentOverrides;
   Completer _stdoutCompleter;
   Completer _stderrCompleter;
   StreamSubscription<String> _stdoutSubscription;
   StreamSubscription<String> _stderrSubscription;
   Function _processExitHandler;
@@ skipping 12 matching lines @@
     assert(_completer == null);
     assert(!_currentlyRunning);
 
     _completer = new Completer<CommandOutput>();
     bool sameRunnerType = _runnerType == runnerType &&
         _dictEquals(_processEnvironmentOverrides, command.environmentOverrides);
     _runnerType = runnerType;
     _currentlyRunning = true;
     _command = command;
     _arguments = arguments;
-
     _processEnvironmentOverrides = command.environmentOverrides;
 
     if (_process == null) {
       // Start process if not yet started.
       _startProcess(() {
         doStartTest(command, timeout);
       });
     } else if (!sameRunnerType) {
       // Restart this runner with the right executable for this test if needed.
       _processExitHandler = (_) {
@@ skipping 78 matching lines @@
     }
     return handler;
   }
 
   void _timeoutHandler() {
     _processExitHandler = makeExitHandler(">>> TEST TIMEOUT");
     _process.kill();
   }
 
   _startProcess(callback) {
-    var executable = batchRunnerTypes[_runnerType]['run_executable'];
-    var arguments = batchRunnerTypes[_runnerType]['run_arguments'];
+    assert(_command is ProcessCommand);
+    var executable = _command.executable;
+    var arguments = ['--batch'];
     var environment = new Map.from(io.Platform.environment);
     if (_processEnvironmentOverrides != null) {
       for (var key in _processEnvironmentOverrides.keys) {
         environment[key] = _processEnvironmentOverrides[key];
       }
     }
     Future processFuture = io.Process.start(executable,
                                             arguments,
                                             environment: environment);
     processFuture.then((io.Process p) {
@@ skipping 414 matching lines @@
         } else {
           return new Future.value(output);
         }
       });
     }
     return runCommand(command.maxNumRetries);
   }
 
   Future<CommandOutput> _runCommand(Command command, int timeout) {
     var batchMode = !globalConfiguration['noBatch'];
+    var dart2jsBatchMode = globalConfiguration['dart2js_batch'];
 
     if (command is BrowserTestCommand) {
       return _startBrowserControllerTest(command, timeout);
+    } else if (command is CompilationCommand && dart2jsBatchMode) {
+      return _getBatchRunner("dart2js")
+          .runCommand("dart2js", command, timeout, command.arguments);
     } else if (command is AnalysisCommand && batchMode) {
       return _getBatchRunner(command.flavor)
           .runCommand(command.flavor, command, timeout, command.arguments);
     } else if (command is ScriptCommand) {
       return command.run();
     } else {
       return new RunningProcess(command, timeout).run();
     }
   }
 
@@ skipping 427 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }