Revert 24086 Update checked in binary to version 0.5.19.0

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.
  */
 library test_runner;
 
 import "dart:async";
 import "dart:collection" show Queue;
 // We need to use the 'io' prefix here, otherwise io.exitCode will shadow
 // CommandOutput.exitCode in subclasses of CommandOutput.
 import "dart:io" as io;
 import "dart:isolate";
+import "dart:uri";
 import "browser_controller.dart";
 import "http_server.dart" as http_server;
 import "status_file_parser.dart";
 import "test_progress.dart";
 import "test_suite.dart";
 import "utils.dart";
 import 'record_and_replay.dart';
 
 const int NO_TIMEOUT = 0;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
@@ skipping 84 matching lines @@
       // TODO(efortuna): Remove this when fixed (Issue 1306).
       executable = executable.replaceAll('/', '\\');
     }
     var quotedArguments = [];
     arguments.forEach((argument) => quotedArguments.add('"$argument"'));
     commandLine = "\"$executable\" ${quotedArguments.join(' ')}";
   }
 
   String toString() => commandLine;
 
-  Future<bool> get outputIsUpToDate => new Future.value(false);
+  Future<bool> get outputIsUpToDate => new Future.immediate(false);
   io.Path get expectedOutputFile => null;
   bool get isPixelTest => false;
 }
 
 class CompilationCommand extends Command {
   String _outputFile;
   bool _neverSkipCompilation;
   List<Uri> _bootstrapDependencies;
 
   CompilationCommand(this._outputFile,
                      this._neverSkipCompilation,
                      this._bootstrapDependencies,
                      String executable,
                      List<String> arguments)
       : super(executable, arguments);
 
   Future<bool> get outputIsUpToDate {
-    if (_neverSkipCompilation) return new Future.value(false);
+    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.value(null);
+        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(Uri.parse(line));
+            dependencies.add(new Uri(line));
           }
         }
         return dependencies;
       });
     }
 
     return readDepsFile("$_outputFile.deps").then((dependencies) {
       if (dependencies != null) {
         dependencies.addAll(_bootstrapDependencies);
         var jsOutputLastModified = TestUtils.lastModifiedCache.getLastModified(
-            new Uri(scheme: 'file', path: _outputFile));
+            new Uri.fromComponents(scheme: 'file', path: _outputFile));
         if (jsOutputLastModified != null) {
           for (var dependency in dependencies) {
             var dependencyLastModified =
                 TestUtils.lastModifiedCache.getLastModified(dependency);
             if (dependencyLastModified == null ||
                 dependencyLastModified.isAfter(jsOutputLastModified)) {
               return false;
             }
           }
           return true;
@@ skipping 844 matching lines @@
     _runCommand();
     return completer.future;
   }
 
   void _runCommand() {
     command.outputIsUpToDate.then((bool isUpToDate) {
       if (isUpToDate) {
         compilationSkipped = true;
         _commandComplete(0);
       } else {
-        var processEnvironment = _createProcessEnvironment();
+        var processOptions = _createProcessOptions();
         var commandArguments = _modifySeleniumTimeout(command.arguments,
                                                       testCase.timeout);
-        Future processFuture =
-            io.Process.start(command.executable,
-                             commandArguments,
-                             environment: processEnvironment);
+        Future processFuture = io.Process.start(command.executable,
+                                                commandArguments,
+                                                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);
@@ skipping 33 matching lines @@
         stderr,
         new DateTime.now().difference(startTime),
         compilationSkipped);
     return commandOutput;
   }
 
   void _drainStream(Stream<List<int>> source, List<int> destination) {
     source.listen(destination.addAll);
   }
 
-  Map<String, String> _createProcessEnvironment() {
+  io.ProcessOptions _createProcessOptions() {
     var baseEnvironment = command.environment != null ?
         command.environment : io.Platform.environment;
-    var environment = new Map<String, String>.from(baseEnvironment);
-    environment['DART_CONFIGURATION'] =
+    io.ProcessOptions options = new io.ProcessOptions();
+    options.environment = new Map<String, String>.from(baseEnvironment);
+    options.environment['DART_CONFIGURATION'] =
         TestUtils.configurationDir(testCase.configuration);
 
     for (var excludedEnvironmentVariable in EXCLUDED_ENVIRONMENT_VARIABLES) {
-      environment.remove(excludedEnvironmentVariable);
+      options.environment.remove(excludedEnvironmentVariable);
     }
 
-    return environment;
+    return options;
   }
 }
 
 class BatchRunnerProcess {
   Command _command;
   String _executable;
   List<String> _batchArguments;
 
   io.Process _process;
   Completer _stdoutCompleter;
@@ skipping 39 matching lines @@
           doStartTest(testCase);
         });
       };
       _process.kill();
     } else {
       doStartTest(testCase);
     }
   }
 
   Future terminate() {
-    if (_process == null) return new Future.value(true);
+    if (_process == null) return new Future.immediate(true);
     Completer completer = new Completer();
     Timer killTimer;
     _processExitHandler = (_) {
       if (killTimer != null) killTimer.cancel();
       completer.complete(true);
     };
     if (_isWebDriver) {
       // Use a graceful shutdown so our Selenium script can close
       // the open browser processes. On Windows, signals do not exist
       // and a kill is a hard kill.
@@ skipping 483 matching lines @@
       testRunner.logger = DebugLogger.info;
       _browserTestRunners[runtime] = testRunner;
       return testRunner.start().then((started) {
         if (started) {
           return testRunner;
         }
         print("Issue starting browser test runner");
         io.exit(1);
       });
     }
-    return new Future.value(_browserTestRunners[runtime]);
+    return new Future.immediate(_browserTestRunners[runtime]);
   }
 
   void _startBrowserControllerTest(var test) {
     var callback = (var output, var duration) {
       var nextCommandIndex = test.commandOutputs.keys.length;
       new CommandOutput.fromCase(test,
                                  test.commands[nextCommandIndex],
                                  0,
                                  false,
                                  output == "TIMEOUT",
@@ skipping 233 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
   }
 }