Rename test.dart component to specify compiler + runtime.

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 106 matching lines @@
         Expect.stringEquals('$prefix ${c.commandLine} $suffix'.trim(),
             newCommand.commandLine);
       }
       commands = newCommands;
     }
   }
 
   int get timeout() => configuration['timeout'];
 
   String get configurationString() {
-    final component = configuration['component'];
+    final compiler = configuration['compiler'];
+    final runtime = configuration['runtime'];
     final mode = configuration['mode'];
     final arch = configuration['arch'];
-    return "$component ${mode}_$arch";
+    return "$compiler-$runtime ${mode}_$arch";
   }
 
   List<String> get batchRunnerArguments() => ['-batch'];
   List<String> get batchTestArguments() => commands.last().arguments;
 
   void completed() { completedHandler(this); }
 
-  bool get usesWebDriver() => configuration['component'] == 'webdriver';
+  bool get usesWebDriver() => (const ['chrome', 'ff', 'safari', 'ie', 'opera'])
+      .indexOf(configuration['runtime']) >= 0;
 }
 
 
 /**
  * BrowserTestCase has an extra compilation command that is run in a separate
  * process, before the regular test is run as in the base class [TestCase].
  * If the compilation command fails, then the rest of the test is not run.
  */
 class BrowserTestCase extends TestCase {
   /**
@@ skipping 73 matching lines @@
                  Duration this.time) {
     testCase.output = this;
     diagnostics = [];
   }
 
   factory TestOutputImpl.fromCase (TestCase testCase, int exitCode, bool timedOut,
                                    List<String> stdout, List<String> stderr, Duration time) {
     if (testCase is BrowserTestCase) {
       return new BrowserTestOutputImpl(testCase, exitCode, timedOut,
         stdout, stderr, time);
-    } else if (testCase.configuration['component'] == 'dartc') {
+    } else if (testCase.configuration['compiler'] == 'dartc') {
       return new AnalysisTestOutputImpl(testCase, exitCode, timedOut,
         stdout, stderr, time);
     }
     return new TestOutputImpl(testCase, exitCode, timedOut,
       stdout, stderr, time);
   }
 
   String get result() =>
       hasCrashed ? CRASH : (hasTimedOut ? TIMEOUT : (hasFailed ? FAIL : PASS));
 
@@ skipping 290 matching lines @@
     if (currentStep == totalSteps) { // done with test command
       testComplete(exitCode);
     } else if (exitCode != 0) {
       stderr.add('test.dart: Compilation failed$suffix, exit code $exitCode\n');
       testComplete(exitCode);
     } else {
       stderr.add('test.dart: Compilion finished $suffix\n');
       stdout.add('test.dart: Compilion finished $suffix\n');
       if (currentStep == totalSteps - 1 && testCase.usesWebDriver &&
           !testCase.configuration['noBatch']) {
-        // Note: processQueue will always be non-null for component == webdriver
-        // (It is only null for component == vm)
+        // Note: processQueue will always be non-null for runtime == ie, ff,
+        // safari, chrome, opera. (It is only null for runtime == vm)
         processQueue._getBatchRunner(testCase).startTest(testCase);
       } else {
         runCommand(testCase.commands[currentStep++], stepExitHandler);
       }
     }
   }
 
   Function makeReadHandler(StringInputStream source, List<String> destination) {
     return () {
       if (source.closed) return;  // TODO(whesse): Remove when bug is fixed.
@@ skipping 487 matching lines @@
   void _terminateBatchRunners() {
     for (var runners in _batchProcesses.getValues()) {
       for (var runner in runners) {
         runner.terminate();
       }
     }
   }
 
   BatchRunnerProcess _getBatchRunner(TestCase test) {
     // Start batch processes if needed
-    var component = test.configuration['component'];
-    var runners = _batchProcesses[component];
+    var compiler = test.configuration['compiler'];
+    var runners = _batchProcesses[compiler];
     if (runners == null) {
       runners = new List<BatchRunnerProcess>(_maxProcesses);
       for (int i = 0; i < _maxProcesses; i++) {
         runners[i] = new BatchRunnerProcess(test);
       }
-      _batchProcesses[component] = runners;
+      _batchProcesses[compiler] = runners;
     }
 
     for (var runner in runners) {
       if (!runner.active) return runner;
     }
     throw new Exception('Unable to find inactive batch runner.');
   }
 
   void _tryRunTest() {
     _checkDone();
@@ skipping 22 matching lines @@
       }
       _progress.start(test);
       Function oldCallback = test.completedHandler;
       Function wrapper = (TestCase test_arg) {
         _numProcesses--;
         _progress.done(test_arg);
         _tryRunTest();
         oldCallback(test_arg);
       };
       test.completedHandler = wrapper;
-      if (test.configuration['component'] == 'dartc' &&
+      if (test.configuration['compiler'] == 'dartc' &&
           test.displayName != 'dartc/junit_tests') {
         _getBatchRunner(test).startTest(test);
       } else {
         // Once we've actually failed a test, technically, we wouldn't need to
         // bother retrying any subsequent tests since the bot is already red.
         // However, we continue to retry tests until we have actually failed
         // four tests (arbitrarily chosen) for more debugable output, so that
         // the developer doesn't waste his or her time trying to fix a bunch of
         // tests that appear to be broken but were actually just flakes that
         // didn't get retried because there had already been one failure.
         bool allowRetry = _MAX_FAILED_NO_RETRY > _progress.numFailedTests;
         new RunningProcess(test, allowRetry, this).start();
       }
       _numProcesses++;
     }
   }
 }