Support --batch for dart2js in testing script.

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 1937 matching lines @@
         '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;
   List<String> _arguments;
   String _runnerType;
 
   io.Process _process;
   Map _processEnvironmentOverrides;
   Completer _stdoutCompleter;
   Completer _stderrCompleter;
   StreamSubscription<String> _stdoutSubscription;
   StreamSubscription<String> _stderrSubscription;
   Function _processExitHandler;
 
   bool _currentlyRunning = false;
   OutputLog _testStdout;
   OutputLog _testStderr;
   String _status;
   DateTime _startTime;
   Timer _timer;
 
-  BatchRunnerProcess();
+  final String _executable;
+
+  BatchRunnerProcess(this._executable);
 
   Future<CommandOutput> runCommand(String runnerType, ProcessCommand command,
                                    int timeout, List<String> arguments) {
     assert(_completer == null);
     assert(!_currentlyRunning);
 
     _completer = new Completer<CommandOutput>();
     bool sameRunnerType = _runnerType == runnerType &&
         _dictEquals(_processEnvironmentOverrides, command.environmentOverrides);
     _runnerType = runnerType;
@@ skipping 92 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'];
+    var executable;
+    var arguments;
+    if (_runnerType == 'dart2js') {
+      executable = _executable;
+      arguments = ['--batch'];
+    } else {
+      executable = batchRunnerTypes[_runnerType]['run_executable'];
+      arguments = batchRunnerTypes[_runnerType]['run_arguments'];
+    }
     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 417 matching lines @@
       });
     }
     return runCommand(command.maxNumRetries);
   }
 
   Future<CommandOutput> _runCommand(Command command, int timeout) {
     var batchMode = !globalConfiguration['noBatch'];
 
     if (command is BrowserTestCommand) {
       return _startBrowserControllerTest(command, timeout);
+    } else if (command is CompilationCommand && batchMode) {
+      return _getBatchRunner(command.executable, "dart2js")
+          .runCommand("dart2js", command, timeout, command.arguments);
     } else if (command is AnalysisCommand && batchMode) {
-      return _getBatchRunner(command.flavor)
+      return _getBatchRunner(null, command.flavor)
           .runCommand(command.flavor, command, timeout, command.arguments);
     } else if (command is ScriptCommand) {
       return command.run();
     } else {
       return new RunningProcess(command, timeout).run();
     }
   }
 
-  BatchRunnerProcess _getBatchRunner(String identifier) {
+  BatchRunnerProcess _getBatchRunner(String executable, String identifier) {
     // Start batch processes if needed
     var runners = _batchProcesses[identifier];
     if (runners == null) {
       runners = new List<BatchRunnerProcess>(maxProcesses);
       for (int i = 0; i < maxProcesses; i++) {
-        runners[i] = new BatchRunnerProcess();
+        runners[i] = new BatchRunnerProcess(executable);
       }
       _batchProcesses[identifier] = runners;
     }
 
     for (var runner in runners) {
       if (!runner._currentlyRunning) return runner;
     }
     throw new Exception('Unable to find inactive batch runner.');
   }
 
@@ skipping 410 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }