Tighten up a bunch of types in test.dart.

tools/testing/dart/browser_controller.dart

 // Copyright (c) 2013, 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.
 library browser;
 
 import "dart:async";
 import "dart:convert" show UTF8, JSON;
 import "dart:core";
 import "dart:io";
 import "dart:math" show min;
 
 import 'android.dart';
 import 'http_server.dart';
 import 'path.dart';
 import 'utils.dart';
 
 import 'reset_safari.dart' show killAndResetSafari;
 
+typedef void BrowserDoneCallback(BrowserTestOutput output);
+typedef void TestChangedCallback(String browserId, String output, int testId);
+typedef BrowserTest NextTestCallback(String browserId);
+
 class BrowserOutput {
   final StringBuffer stdout = new StringBuffer();
   final StringBuffer stderr = new StringBuffer();
   final StringBuffer eventLog = new StringBuffer();
 }
 
 /** Class describing the interface for communicating with browsers. */
 abstract class Browser {
   BrowserOutput _allBrowserOutput = new BrowserOutput();
   BrowserOutput _testBrowserOutput = new BrowserOutput();
@@ skipping 35 matching lines @@
   bool debugPrint = false;
 
   // This future returns when the process exits. It is also the return value
   // of close()
   Future done;
 
   Browser();
 
   factory Browser.byName(String name, String executablePath,
       [bool checkedMode = false]) {
-    var browser;
+    Browser browser;
     if (name == 'firefox') {
       browser = new Firefox();
     } else if (name == 'chrome') {
       browser = new Chrome();
     } else if (name == 'dartium') {
       browser = new Dartium(checkedMode);
     } else if (name == 'safari') {
       browser = new Safari();
     } else if (name == 'safarimobilesim') {
       browser = new SafariMobileSimulator();
@@ skipping 80 matching lines @@
    */
   Future<bool> startBrowserProcess(String command, List<String> arguments,
       {Map<String, String> environment}) {
     return Process
         .start(command, arguments, environment: environment)
         .then((startedProcess) {
       _logEvent("Started browser using $command ${arguments.join(' ')}");
       process = startedProcess;
       // Used to notify when exiting, and as a return value on calls to
       // close().
-      var doneCompleter = new Completer();
+      var doneCompleter = new Completer<bool>();
       done = doneCompleter.future;
 
-      Completer stdoutDone = new Completer();
-      Completer stderrDone = new Completer();
+      Completer stdoutDone = new Completer<Null>();
+      Completer stderrDone = new Completer<Null>();
 
       bool stdoutIsDone = false;
       bool stderrIsDone = false;
       StreamSubscription stdoutSubscription;
       StreamSubscription stderrSubscription;
 
       // This timer is used to close stdio to the subprocess once we got
       // the exitCode. Sometimes descendants of the subprocess keep stdio
       // handles alive even though the direct subprocess is dead.
       Timer watchdogTimer;
@@ skipping 106 matching lines @@
   static const String versionFile =
       "/Applications/Safari.app/Contents/version.plist";
 
   static const String safariBundleLocation = "/Applications/Safari.app/";
 
   // Clears the cache if the static resetBrowserConfiguration flag is set.
   // Returns false if the command to actually clear the cache did not complete.
   Future<bool> resetConfiguration() async {
     if (!Browser.resetBrowserConfiguration) return true;
 
-    Completer completer = new Completer();
+    var completer = new Completer<Null>();
     handleUncaughtError(error, StackTrace stackTrace) {
       if (!completer.isCompleted) {
         completer.completeError(error, stackTrace);
       } else {
         throw new AsyncError(error, stackTrace);
       }
     }
 
     Zone parent = Zone.current;
     ZoneSpecification specification = new ZoneSpecification(
@@ skipping 49 matching lines @@
       for (var line in content) {
         if (versionOnNextLine) return line;
         if (line.contains("CFBundleShortVersionString")) {
           versionOnNextLine = true;
         }
       }
       return null;
     });
   }
 
-  Future<Null> _createLaunchHTML(var path, var url) async {
-    var file = new File("${path}/launch.html");
+  Future<Null> _createLaunchHTML(String path, String url) async {
+    var file = new File("$path/launch.html");
     var randomFile = await file.open(mode: FileMode.WRITE);
     var content = '<script language="JavaScript">location = "$url"</script>';
     await randomFile.writeString(content);
     await randomFile.close();
   }
 
   Future<bool> start(String url) async {
     _logEvent("Starting Safari browser on: $url");
     if (!await resetConfiguration()) {
       _logEvent("Could not clear cache");
@@ skipping 274 matching lines @@
     'android.intent.action.VIEW');
 
 final dartiumOnAndroidConfig = new AndroidBrowserConfig('DartiumOnAndroid',
     'com.google.android.apps.chrome', '.Main', 'android.intent.action.VIEW');
 
 class AndroidBrowser extends Browser {
   final bool checkedMode;
   AdbDevice _adbDevice;
   AndroidBrowserConfig _config;
 
-  AndroidBrowser(this._adbDevice, this._config, this.checkedMode, apkPath) {
+  AndroidBrowser(
+      this._adbDevice, this._config, this.checkedMode, String apkPath) {
     _binary = apkPath;
   }
 
   Future<bool> start(String url) {
     var intent =
         new Intent(_config.action, _config.package, _config.activity, url);
     return _adbDevice.waitForBootCompleted().then((_) {
       return _adbDevice.forceStop(_config.package);
     }).then((_) {
       return _adbDevice.killAll();
@@ skipping 104 matching lines @@
 }
 
 class Firefox extends Browser {
   static const String enablePopUp =
       'user_pref("dom.disable_open_during_load", false);';
   static const String disableDefaultCheck =
       'user_pref("browser.shell.checkDefaultBrowser", false);';
   static const String disableScriptTimeLimit =
       'user_pref("dom.max_script_run_time", 0);';
 
-  void _createPreferenceFile(var path) {
-    var file = new File("${path.toString()}/user.js");
+  void _createPreferenceFile(String path) {
+    var file = new File("$path/user.js");
     var randomFile = file.openSync(mode: FileMode.WRITE);
     randomFile.writeStringSync(enablePopUp);
     randomFile.writeStringSync(disableDefaultCheck);
     randomFile.writeStringSync(disableScriptTimeLimit);
     randomFile.close();
   }
 
   Future<bool> start(String url) {
     _logEvent("Starting firefox browser on: $url");
     // Get the version and log that.
@@ skipping 47 matching lines @@
   Stopwatch timeSinceRestart = new Stopwatch()..start();
 
   BrowserStatus(Browser this.browser);
 }
 
 /**
  * Describes a single test to be run in the browser.
  */
 class BrowserTest {
   // TODO(ricow): Add timeout callback instead of the string passing hack.
-  Function doneCallback;
+  BrowserDoneCallback doneCallback;
   String url;
   int timeout;
   String lastKnownMessage = '';
   Stopwatch stopwatch;
 
   // This might be null
   Duration delayUntilTestStarted;
 
   // We store this here for easy access when tests time out (instead of
   // capturing this in a closure)
@@ skipping 10 matching lines @@
 
   String toJSON() => JSON.encode({'url': url, 'id': id, 'isHtmlTest': false});
 }
 
 /**
  * Describes a test with a custom HTML page to be run in the browser.
  */
 class HtmlTest extends BrowserTest {
   List<String> expectedMessages;
 
-  HtmlTest(url, doneCallback, timeout, this.expectedMessages)
+  HtmlTest(String url, BrowserDoneCallback doneCallback, int timeout,
+      this.expectedMessages)
       : super(url, doneCallback, timeout) {}
 
   String toJSON() => JSON.encode({
         'url': url,
         'id': id,
         'isHtmlTest': true,
         'expectedMessages': expectedMessages
       });
 }
 
@@ skipping 22 matching lines @@
 /// driver page to the browsers, serves tests, and receives results and
 /// requests back from the browsers.
 class BrowserTestRunner {
   static const int MAX_NEXT_TEST_TIMEOUTS = 10;
   static const Duration NEXT_TEST_TIMEOUT = const Duration(seconds: 120);
   static const Duration RESTART_BROWSER_INTERVAL = const Duration(seconds: 60);
 
   /// If the queue was recently empty, don't start another browser.
   static const Duration MIN_NONEMPTY_QUEUE_TIME = const Duration(seconds: 1);
 
-  final Map configuration;
+  final Map<String, String> configuration;
   final BrowserTestingServer testingServer;
 
   final String localIp;
   final String browserName;
   int maxNumBrowsers;
   final bool checkedMode;
   int numBrowsers = 0;
   // Used to send back logs from the browser (start, stop etc)
   Function logger;
 
@@ skipping 309 matching lines @@
   }
 
   /// Creates a timer that is active while no test is running on the
   /// browser. It has finished one test, and it has not requested a new test.
   Timer createNextTestTimer(BrowserStatus status) {
     return new Timer(BrowserTestRunner.NEXT_TEST_TIMEOUT, () {
       handleNextTestTimeout(status);
     });
   }
 
-  void handleNextTestTimeout(status) {
+  void handleNextTestTimeout(BrowserStatus status) {
     DebugLogger
         .warning("Browser timed out before getting next test. Restarting");
     if (status.timeout) return;
     numBrowserGetTestTimeouts++;
     if (numBrowserGetTestTimeouts >= MAX_NEXT_TEST_TIMEOUTS) {
       DebugLogger.error(
           "Too many browser timeouts before getting next test. Terminating");
       terminate().then((_) => exit(1));
     } else {
       status.timeout = true;
@@ skipping 25 matching lines @@
       DebugLogger.warning("${testCache[id]}, output: ");
       DebugLogger.warning("${doubleReportingOutputs[id]}");
       DebugLogger.warning("");
       DebugLogger.warning("");
     }
   }
 
   // TODO(26191): Call a unified fatalError(), that shuts down all subprocesses.
   // This just kills the browsers in this BrowserTestRunner instance.
   Future terminate() async {
-    var browsers = [];
+    var browsers = <Browser>[];
     underTermination = true;
     testingServer.underTermination = true;
     for (BrowserStatus status in browserStatus.values) {
       browsers.add(status.browser);
       if (status.nextTestTimeout != null) {
         status.nextTestTimeout.cancel();
         status.nextTestTimeout = null;
       }
     }
-    for (Browser b in browsers) {
-      await b.close();
+
+    for (var browser in browsers) {
+      await browser.close();
     }
+
     testingServer.errorReportingServer.close();
     printDoubleReportingTests();
   }
 }
 
 class BrowserTestingServer {
   final Map configuration;
 
   /// Interface of the testing server:
   ///
@@ skipping 14 matching lines @@
 
   static const String driverPath = "/driver";
   static const String nextTestPath = "/next_test";
   static const String reportPath = "/report";
   static const String statusUpdatePath = "/status_update";
   static const String startedPath = "/started";
   static const String waitSignal = "WAIT";
   static const String terminateSignal = "TERMINATE";
 
   var testCount = 0;
-  var errorReportingServer;
+  HttpServer errorReportingServer;
   bool underTermination = false;
 
-  Function testDoneCallBack;
-  Function testStatusUpdateCallBack;
-  Function testStartedCallBack;
-  Function nextTestCallBack;
+  TestChangedCallback testDoneCallBack;
+  TestChangedCallback testStatusUpdateCallBack;
+  TestChangedCallback testStartedCallBack;
+  NextTestCallback nextTestCallBack;
 
   BrowserTestingServer(
       this.configuration, this.localIp, this.useIframe, this.requiresFocus);
 
   Future start() {
-    var test_driver_error_port = configuration['test_driver_error_port'];
+    var testDriverErrorPort = configuration['test_driver_error_port'];
     return HttpServer
-        .bind(localIp, test_driver_error_port)
+        .bind(localIp, testDriverErrorPort)
         .then(setupErrorServer)
         .then(setupDispatchingServer);
   }
 
   void setupErrorServer(HttpServer server) {
     errorReportingServer = server;
     void errorReportingHandler(HttpRequest request) {
       StringBuffer buffer = new StringBuffer();
       request.transform(UTF8.decoder).listen((data) {
         buffer.write(data);
@@ skipping 14 matching lines @@
 
     void errorHandler(e) {
       if (!underTermination) print("Error occured in httpserver: $e");
     }
 
     errorReportingServer.listen(errorReportingHandler, onError: errorHandler);
   }
 
   void setupDispatchingServer(_) {
     DispatchingServer server = configuration['_servers_'].server;
-    void noCache(request) {
+    void noCache(HttpRequest request) {
       request.response.headers
           .set("Cache-Control", "no-cache, no-store, must-revalidate");
     }
 
-    int testId(request) => int.parse(request.uri.queryParameters["id"]);
-    String browserId(request, prefix) =>
+    int testId(HttpRequest request) =>
+        int.parse(request.uri.queryParameters["id"]);
+    String browserId(HttpRequest request, String prefix) =>
         request.uri.path.substring(prefix.length + 1);
 
     server.addHandler(reportPath, (HttpRequest request) {
       noCache(request);
       handleReport(request, browserId(request, reportPath), testId(request),
           isStatusUpdate: false);
     });
     server.addHandler(statusUpdatePath, (HttpRequest request) {
       noCache(request);
       handleReport(
@@ skipping 35 matching lines @@
         // Ignoring the returned closure as it returns the 'done' future
         // which already has catchError installed above.
         request.response.close();
       });
     }
 
     server.addHandler(driverPath, sendPageHandler);
     server.addHandler(nextTestPath, sendPageHandler);
   }
 
-  void handleReport(HttpRequest request, String browserId, var testId,
+  void handleReport(HttpRequest request, String browserId, int testId,
       {bool isStatusUpdate}) {
     StringBuffer buffer = new StringBuffer();
     request.transform(UTF8.decoder).listen((data) {
       buffer.write(data);
     }, onDone: () {
       String back = buffer.toString();
       request.response.close();
       if (isStatusUpdate) {
         testStatusUpdateCallBack(browserId, back, testId);
       } else {
         testDoneCallBack(browserId, back, testId);
       }
       // TODO(ricow): We should do something smart if we get an error here.
     }, onError: (error) {
       DebugLogger.error("$error");
     });
   }
 
-  void handleStarted(HttpRequest request, String browserId, var testId) {
+  void handleStarted(HttpRequest request, String browserId, int testId) {
     StringBuffer buffer = new StringBuffer();
     // If an error occurs while receiving the data from the request stream,
     // we don't handle it specially. We can safely ignore it, since the started
     // events are not crucial.
     request.transform(UTF8.decoder).listen((data) {
       buffer.write(data);
     }, onDone: () {
       String back = buffer.toString();
       request.response.close();
       testStartedCallBack(browserId, back, testId);
@@ skipping 433 matching lines @@
           'exit code: ${result.exitCode}\n'
           'stdout: ${result.stdout}\n'
           'stderr: ${result.stderr}');
     } else {
       print('[$message] Successfully uploaded screenshot to $storageUrl');
     }
     new File(screenshotFile).deleteSync();
   }
   print('--------------------------------------------------------------------');
 }