Do not compile tests for different browsers separately

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 105 matching lines @@
       executable = executable.replaceAll('/', '\\');
     }
     var quotedArguments = [];
     quotedArguments.add(escapeCommandLineArgument(executable));
     quotedArguments.addAll(arguments.map(escapeCommandLineArgument));
     commandLine = quotedArguments.join(' ');
   }
 
   String toString() => commandLine;
 
+  Future postProcessCommand() => new Future.immediate(null);
+
   Future<bool> get outputIsUpToDate => new Future.immediate(false);
   io.Path get expectedOutputFile => null;
   bool get isPixelTest => false;
 }
 
 class CompilationCommand extends Command {
   String _outputFile;
+  String _shadowFile;
   bool _neverSkipCompilation;
   List<Uri> _bootstrapDependencies;
 
   CompilationCommand(this._outputFile,
+                     this._shadowFile,
                      this._neverSkipCompilation,
                      this._bootstrapDependencies,
                      String executable,
                      List<String> arguments)
       : super(executable, arguments);
 
   Future<bool> get outputIsUpToDate {
     if (_neverSkipCompilation) return new Future.immediate(false);
 
     Future<List<Uri>> readDepsFile(String path) {
       var file = new io.File(new io.Path(path).toNativePath());
       if (!file.existsSync()) {
         return new Future.immediate(null);
       }
       return file.readAsLines().then((List<String> lines) {
         var dependencies = new List<Uri>();
         for (var line in lines) {
           line = line.trim();
           if (line.length > 0) {
             dependencies.add(new Uri(line));
           }
         }
         return dependencies;
       });
     }
 
-    return readDepsFile("$_outputFile.deps").then((dependencies) {
+    return readDepsFile("${_shadowFile}.deps").then((dependencies) {
       if (dependencies != null) {
         dependencies.addAll(_bootstrapDependencies);
         var jsOutputLastModified = TestUtils.lastModifiedCache.getLastModified(
-            new Uri.fromComponents(scheme: 'file', path: _outputFile));
+            new Uri.fromComponents(scheme: 'file', path: _shadowFile));
         if (jsOutputLastModified != null) {
           for (var dependency in dependencies) {
             var dependencyLastModified =
                 TestUtils.lastModifiedCache.getLastModified(dependency);
             if (dependencyLastModified == null ||
                 dependencyLastModified.isAfter(jsOutputLastModified)) {
               return false;
             }
           }
+          // Shadow files are up to date, so copy them.
+          _copyFilesSync(_shadowFile, _outputFile);
           return true;
         }
       }
       return false;
     });
   }
+
+  Future postProcessCommand() {
+    // After the actual compile, we synchronously copy the compiled output files
+    // to shadow files.
+    _copyFilesSync(_outputFile, _shadowFile);
+    return new Future.immediate(null);
+  }
+
+  _copyFilesSync(String from, String to) {
+    for (var ending in ['', '.deps', '.map']) {
+      var fromFile = new io.File("${from}${ending}");
+      var toFile = new io.File("${to}${ending}");
+      toFile.writeAsBytesSync(fromFile.readAsBytesSync());

[ricow1, 2013/06/25 13:10:48]

add small comment stating why we do this sync

[kustermann, 2013/06/25 13:20:11]

Done.

+    }
+  }
 }
 
 class ContentShellCommand extends Command {
   /**
    * If [expectedOutputPath] is set, the output of content shell is compared
    * with the content of [expectedOutputPath].
    * This is used for example for pixel tests, where [expectedOutputPath] points
    * to a *png file.
    */
   io.Path expectedOutputPath;
@@ skipping 844 matching lines @@
                                                 processOptions);
         processFuture.then((io.Process process) {
           // Close stdin so that tests that try to block on input will fail.
           process.stdin.close();
           void timeoutHandler() {
             timedOut = true;
             if (process != null) {
               process.kill();
             }
           }
-          process.exitCode.then(_commandComplete);
+          process.exitCode.then((exitCode) {
+            if (exitCode == 0) {
+              command.postProcessCommand().then((_) {
+                _commandComplete(exitCode);
+              });
+            } else {
+              _commandComplete(exitCode);
+            }
+          });
           _drainStream(process.stdout, stdout);
           _drainStream(process.stderr, stderr);
           timeoutTimer = new Timer(new Duration(seconds: testCase.timeout),
                                    timeoutHandler);
         }).catchError((e) {
           // TODO(floitsch): should we try to report the stacktrace?
           print("Process error:");
           print("  Command: $command");
           print("  Error: $e");
           _commandComplete(-1);
@@ skipping 853 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
   }
 }