Replace the configuration map with a typed object.

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 'dart:async';
+import 'dart:convert';
+import 'dart:core';
+import 'dart:io';
+import 'dart:math';
 
 import 'android.dart';
-import 'http_server.dart';
+import 'configuration.dart';
 import 'path.dart';
+import 'reset_safari.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();
 }
 
@@ skipping 37 matching lines @@
 
   /** Print everything (stdout, stderr, usageLog) whenever we add to it */
   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,
+  factory Browser.byRuntime(Runtime runtime, String executablePath,
       [bool checkedMode = false]) {
     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();
-    } else if (name.startsWith('ie')) {
-      browser = new IE();
-    } else {
-      throw "Non supported browser";
+    switch (runtime) {
+      case Runtime.firefox:
+        browser = new Firefox();
+        break;
+      case Runtime.chrome:
+        browser = new Chrome();
+        break;
+      case Runtime.dartium:
+        browser = new Dartium(checkedMode);
+        break;
+      case Runtime.safari:
+        browser = new Safari();
+        break;
+      case Runtime.safariMobileSim:
+        browser = new SafariMobileSimulator();
+        break;
+      case Runtime.ie9:
+      case Runtime.ie10:
+      case Runtime.ie11:
+        browser = new IE();
+        break;
+      default:
+        throw "unreachable";
     }
+
     browser._binary = executablePath;
     return browser;
   }
 
   static const List<String> SUPPORTED_BROWSERS = const [
     'safari',
     'ff',
     'firefox',
     'chrome',
     'ie9',
     'ie10',
     'ie11',
     'dartium'
   ];
 
-  static const List<String> BROWSERS_WITH_WINDOW_SUPPORT = const [
-    'ie11',
-    'ie10'
-  ];
-
-  /// If [browserName] doesn't support Window.open, we use iframes instead.
-  static bool requiresIframe(String browserName) {
-    return !BROWSERS_WITH_WINDOW_SUPPORT.contains(browserName);
-  }
-
   static bool requiresFocus(String browserName) {
     return browserName == "safari";
   }
 
   // TODO(kustermann): add standard support for chrome on android
   static bool supportedBrowser(String name) {
     return SUPPORTED_BROWSERS.contains(name);
   }
 
   void _logEvent(String event) {
@@ skipping 809 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<String, dynamic> configuration;
+  final Configuration 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;
 
   int browserIdCounter = 1;
 
   bool testingServerStarted = false;
   bool underTermination = false;
   int numBrowserGetTestTimeouts = 0;
   DateTime lastEmptyTestQueueTime = new DateTime.now();
   String _currentStartingBrowserId;
-  List<BrowserTest> testQueue = new List<BrowserTest>();
-  Map<String, BrowserStatus> browserStatus = new Map<String, BrowserStatus>();
+  List<BrowserTest> testQueue = [];
+  Map<String, BrowserStatus> browserStatus = {};
 
-  var adbDeviceMapping = new Map<String, AdbDevice>();
+  Map<String, AdbDevice> adbDeviceMapping = {};
   List<AdbDevice> idleAdbDevices;
 
   // This cache is used to guarantee that we never see double reporting.
   // If we do we need to provide developers with this information.
   // We don't add urls to the cache until we have run it.
-  Map<int, String> testCache = new Map<int, String>();
+  Map<int, String> testCache = {};
 
-  Map<int, String> doubleReportingOutputs = new Map<int, String>();
+  Map<int, String> doubleReportingOutputs = {};
   List<String> timedOut = [];
 
   // We will start a new browser when the test queue hasn't been empty
   // recently, we have fewer than maxNumBrowsers browsers, and there is
   // no other browser instance currently starting up.
   bool get queueWasEmptyRecently {
     return testQueue.isEmpty ||
         new DateTime.now().difference(lastEmptyTestQueueTime) <
             MIN_NONEMPTY_QUEUE_TIME;
   }
 
   // While a browser is starting, but has not requested its first test, its
   // browserId is stored in _currentStartingBrowserId.
   // When no browser is currently starting, _currentStartingBrowserId is null.
   bool get aBrowserIsCurrentlyStarting => _currentStartingBrowserId != null;
   void markCurrentlyStarting(String id) {
     _currentStartingBrowserId = id;
   }
 
   void markNotCurrentlyStarting(String id) {
     if (_currentStartingBrowserId == id) _currentStartingBrowserId = null;
   }
 
-  BrowserTestRunner(Map<String, dynamic> configuration, String localIp,
-      String browserName, this.maxNumBrowsers)
+  BrowserTestRunner(
+      Configuration configuration, String localIp, this.maxNumBrowsers)
       : configuration = configuration,
         localIp = localIp,
-        browserName = (browserName == 'ff') ? 'firefox' : browserName,
-        checkedMode = configuration['checked'] as bool,
-        testingServer = new BrowserTestingServer(
-            configuration,
-            localIp,
-            Browser.requiresIframe(browserName),
-            Browser.requiresFocus(browserName)) {
+        testingServer = new BrowserTestingServer(configuration, localIp,
+            Browser.requiresFocus(configuration.runtime.name)) {
     testingServer.testRunner = this;
   }
 
   Future start() async {
     await testingServer.start();
     testingServer
       ..testDoneCallBack = handleResults
       ..testStatusUpdateCallBack = handleStatusUpdate
       ..testStartedCallBack = handleStarted
       ..nextTestCallBack = getNextTest;
-    if (browserName == 'chromeOnAndroid') {
+    if (configuration.runtime == Runtime.chromeOnAndroid) {
       var idbNames = await AdbHelper.listDevices();
       idleAdbDevices = new List.from(idbNames.map((id) => new AdbDevice(id)));
       maxNumBrowsers = min(maxNumBrowsers, idleAdbDevices.length);
     }
     testingServerStarted = true;
     requestBrowser();
   }
 
   /// requestBrowser() is called whenever we might want to start an additional
   /// browser instance.
   /// It is called when starting the BrowserTestRunner, and whenever a browser
   /// is killed, whenever a new test is enqueued, or whenever a browser
   /// finishes a test.
   /// So we are guaranteed that this will always eventually be called, as long
   /// as the test queue isn't empty.
   void requestBrowser() {
     if (!testingServerStarted) return;
     if (underTermination) return;
     if (numBrowsers == maxNumBrowsers) return;
     if (aBrowserIsCurrentlyStarting) return;
     if (numBrowsers > 0 && queueWasEmptyRecently) return;
     createBrowser();
   }
 
   String getNextBrowserId() => "BROWSER${browserIdCounter++}";
 
   void createBrowser() {
-    final String id = getNextBrowserId();
-    final String url = testingServer.getDriverUrl(id);
+    var id = getNextBrowserId();
+    var url = testingServer.getDriverUrl(id);
+
     Browser browser;
-    if (browserName == 'chromeOnAndroid') {
+    if (configuration.runtime == Runtime.chromeOnAndroid) {
       AdbDevice device = idleAdbDevices.removeLast();
       adbDeviceMapping[id] = device;
       browser = new AndroidChrome(device);
     } else {
-      String path = Locations.getBrowserLocation(browserName, configuration);
-      browser = new Browser.byName(browserName, path, checkedMode);
+      var path = configuration.browserLocation;
+      browser = new Browser.byRuntime(
+          configuration.runtime, path, configuration.isChecked);
       browser.logger = logger;
     }
+
     browser.id = id;
     markCurrentlyStarting(id);
-    final status = new BrowserStatus(browser);
+    var status = new BrowserStatus(browser);
     browserStatus[id] = status;
     numBrowsers++;
     status.nextTestTimeout = createNextTestTimer(status);
     browser.start(url);
   }
 
   void handleResults(String browserId, String output, int testId) {
     var status = browserStatus[browserId];
     if (testCache.containsKey(testId)) {
       doubleReportingOutputs[testId] = output;
@@ skipping 106 matching lines @@
 
     // We don't want to start a new browser if we are terminating.
     if (underTermination) return;
     removeBrowser(id);
     requestBrowser();
   }
 
   /// Remove a browser that has closed from our data structures that track
   /// open browsers. Check if we want to replace it with a new browser.
   void removeBrowser(String id) {
-    if (browserName == 'chromeOnAndroid') {
+    if (configuration.runtime == Runtime.chromeOnAndroid) {
       idleAdbDevices.add(adbDeviceMapping.remove(id));
     }
     markNotCurrentlyStarting(id);
     browserStatus.remove(id);
     --numBrowsers;
   }
 
   BrowserTest getNextTest(String browserId) {
     markNotCurrentlyStarting(browserId);
     var status = browserStatus[browserId];
     if (status == null) return null;
     if (status.nextTestTimeout != null) {
       status.nextTestTimeout.cancel();
       status.nextTestTimeout = null;
     }
     if (testQueue.isEmpty) return null;
 
     // We are currently terminating this browser, don't start a new test.
     if (status.timeout) return null;
 
     // Restart Internet Explorer if it has been
     // running for longer than RESTART_BROWSER_INTERVAL. The tests have
     // had flaky timeouts, and this may help.
-    if ((browserName == 'ie10' || browserName == 'ie11') &&
+    if ((configuration.runtime == Runtime.ie10 ||
+            configuration.runtime == Runtime.ie11) &&
         status.timeSinceRestart.elapsed > RESTART_BROWSER_INTERVAL) {
       var id = status.browser.id;
       // Reset stopwatch so we don't trigger again before restarting.
       status.timeout = true;
       status.browser.close().then((_) {
         // We don't want to start a new browser if we are terminating.
         if (underTermination) return;
         removeBrowser(id);
         requestBrowser();
       });
@@ skipping 109 matching lines @@
     for (var browser in browsers) {
       await browser.close();
     }
 
     testingServer.errorReportingServer.close();
     printDoubleReportingTests();
   }
 }
 
 class BrowserTestingServer {
-  final Map configuration;
+  final Configuration configuration;
 
   /// Interface of the testing server:
   ///
   /// GET /driver/BROWSER_ID -- This will get the driver page to fetch
   ///                           and run tests ...
   /// GET /next_test/BROWSER_ID -- returns "WAIT" "TERMINATE" or "url#id"
   /// where url is the test to run, and id is the id of the test.
   /// If there are currently no available tests the waitSignal is send
   /// back. If we are in the process of terminating the terminateSignal
   /// is send back and the browser will stop requesting new tasks.
   /// POST /report/BROWSER_ID?id=NUM -- sends back the dom of the executed
   ///                                   test
 
   final String localIp;
-  final bool useIframe;
   final bool requiresFocus;
   BrowserTestRunner testRunner;
 
   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;
   HttpServer errorReportingServer;
   bool underTermination = false;
 
   TestChangedCallback testDoneCallBack;
   TestChangedCallback testStatusUpdateCallBack;
   TestChangedCallback testStartedCallBack;
   NextTestCallback nextTestCallBack;
 
-  BrowserTestingServer(
-      this.configuration, this.localIp, this.useIframe, this.requiresFocus);
+  BrowserTestingServer(this.configuration, this.localIp, this.requiresFocus);
 
   Future start() {
-    var testDriverErrorPort = configuration['test_driver_error_port'] as int;
     return HttpServer
-        .bind(localIp, testDriverErrorPort)
+        .bind(localIp, configuration.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 13 matching lines @@
     }
 
     void errorHandler(e) {
       if (!underTermination) print("Error occured in httpserver: $e");
     }
 
     errorReportingServer.listen(errorReportingHandler, onError: errorHandler);
   }
 
   void setupDispatchingServer(_) {
-    var server = (configuration['_servers_'] as TestingServers).server;
+    var server = configuration.servers.server;
     void noCache(HttpRequest request) {
       request.response.headers
           .set("Cache-Control", "no-cache, no-store, must-revalidate");
     }
 
     int testId(HttpRequest request) =>
         int.parse(request.uri.queryParameters["id"]);
     String browserId(HttpRequest request, String prefix) =>
         request.uri.path.substring(prefix.length + 1);
 
@@ skipping 95 matching lines @@
     return nextTest == null ? waitSignal : nextTest.toJSON();
   }
 
   String getDriverUrl(String browserId) {
     if (errorReportingServer == null) {
       print("Bad browser testing server, you are not started yet. Can't "
           "produce driver url");
       exit(1);
       // This should never happen - exit immediately;
     }
-    var port = (configuration['_servers_'] as TestingServers).port;
-    return "http://$localIp:$port/driver/$browserId";
+
+    return "http://$localIp:${configuration.servers.port}/driver/$browserId";
   }
 
   Future<String> getDriverPage(String browserId) async {
     await testRunner.browserStatus[browserId].browser.onDriverPageRequested();
     var errorReportingUrl =
         "http://$localIp:${errorReportingServer.port}/$browserId";
     String driverContent = """
 <!DOCTYPE html><html>
 <head>
   <title>Driving page</title>
@@ skipping 29 matching lines @@
       var test_completed = true;
       // Has the test in the current iframe reported that it is started?
       var test_started = false;
       var testing_window;
 
       var embedded_iframe_div = document.getElementById('embedded_iframe_div');
       var embedded_iframe = document.getElementById('embedded_iframe');
       var number_div = document.getElementById('number');
       var executing_div = document.getElementById('currently_executing');
       var error_div = document.getElementById('unhandled_error');
-      var use_iframe = ${useIframe};
+      var use_iframe = ${configuration.runtime.requiresIFrame};
       var start = new Date();
 
       // Object that holds the state of an HTML test
       var html_test;
 
       function newTaskHandler() {
         if (this.readyState == this.DONE) {
           if (this.status == 200) {
             if (this.responseText == '$waitSignal') {
               setTimeout(getNextTask, 500);
@@ skipping 349 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('--------------------------------------------------------------------');
 }