Autoformat tools/testing/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 LineSplitter, UTF8, JSON;
 import "dart:core";
 import "dart:io";
 import "dart:math" show max, min;
@@ skipping 49 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,
-                         [bool checkedMode = false]) {
+  factory Browser.byName(String name, String executablePath,
+      [bool checkedMode = false]) {
     var 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";
     }
     browser._binary = executablePath;
     return browser;
   }
 
-  static const List<String> SUPPORTED_BROWSERS =
-    const ['safari', 'ff', 'firefox', 'chrome', 'ie9', 'ie10',
-           'ie11', 'dartium'];
+  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'];
+  static const List<String> BROWSERS_WITH_WINDOW_SUPPORT = const [
+    'ie11',
+    'ie10'
+  ];
 
   // TODO(kustermann): add standard support for chrome on android
   static bool supportedBrowser(String name) {
     return SUPPORTED_BROWSERS.contains(name);
   }
 
   void _logEvent(String event) {
     String toLog = "$this ($id) - $event \n";
     if (debugPrint) print("usageLog: $toLog");
     if (logger != null) logger(toLog);
@@ skipping 28 matching lines @@
     } else {
       _logEvent("The process is already dead.");
       return new Future.value(true);
     }
   }
 
   /**
    * Start the browser using the supplied argument.
    * This sets up the error handling and usage logging.
    */
-  Future<bool> startBrowserProcess(String command,
-                            List<String> arguments,
-                            {Map<String,String> environment}) {
-    return Process.start(command, arguments, environment: environment)
+  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();
       done = doneCompleter.future;
 
       Completer stdoutDone = new Completer();
       Completer stderrDone = new Completer();
 
       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;
 
-      void closeStdout([_]){
+      void closeStdout([_]) {
         if (!stdoutIsDone) {
           stdoutDone.complete();
           stdoutIsDone = true;
 
           if (stderrIsDone && watchdogTimer != null) {
             watchdogTimer.cancel();
           }
         }
       }
 
       void closeStderr([_]) {
         if (!stderrIsDone) {
           stderrDone.complete();
           stderrIsDone = true;
 
           if (stdoutIsDone && watchdogTimer != null) {
             watchdogTimer.cancel();
           }
         }
       }
 
       stdoutSubscription =
-        process.stdout.transform(UTF8.decoder).listen((data) {
+          process.stdout.transform(UTF8.decoder).listen((data) {
         _addStdout(data);
       }, onError: (error) {
         // This should _never_ happen, but we really want this in the log
         // if it actually does due to dart:io or vm bug.
         _logEvent("An error occured in the process stdout handling: $error");
       }, onDone: closeStdout);
 
       stderrSubscription =
-        process.stderr.transform(UTF8.decoder).listen((data) {
+          process.stderr.transform(UTF8.decoder).listen((data) {
         _addStderr(data);
       }, onError: (error) {
         // This should _never_ happen, but we really want this in the log
         // if it actually does due to dart:io or vm bug.
         _logEvent("An error occured in the process stderr handling: $error");
-      },  onDone: closeStderr);
+      }, onDone: closeStderr);
 
       process.exitCode.then((exitCode) {
         _logEvent("Browser closed with exitcode $exitCode");
 
         if (!stdoutIsDone || !stderrIsDone) {
           watchdogTimer = new Timer(MAX_STDIO_DELAY, () {
-            DebugLogger.warning(
-                "$MAX_STDIO_DELAY_PASSED_MESSAGE (browser: $this)");
+            DebugLogger
+                .warning("$MAX_STDIO_DELAY_PASSED_MESSAGE (browser: $this)");
             watchdogTimer = null;
             stdoutSubscription.cancel();
             stderrSubscription.cancel();
             closeStdout();
             closeStderr();
           });
         }
 
         Future.wait([stdoutDone.future, stderrDone.future]).then((_) {
           process = null;
@@ skipping 19 matching lines @@
 
   void resetTestBrowserOutput() {
     _testBrowserOutput = new BrowserOutput();
   }
 
   /**
    * Add useful info about the browser to the _testBrowserOutput.stdout,
    * where it will be reported for failing tests.  Used to report which
    * android device a failing test is running on.
    */
-  void logBrowserInfoToTestBrowserOutput() { }
+  void logBrowserInfoToTestBrowserOutput() {}
 
   String toString();
 
   /** Starts the browser loading the given url */
   Future<bool> start(String url);
 }
 
 class Safari extends Browser {
   /**
    * We get the safari version by parsing a version file
    */
   static const String versionFile =
       "/Applications/Safari.app/Contents/version.plist";
 
   /**
    * Directories where safari stores state. We delete these if the deleteCache
    * is set
    */
-  static const List<String> CACHE_DIRECTORIES =
-      const ["Library/Caches/com.apple.Safari",
-             "Library/Safari",
-             "Library/Saved Application State/com.apple.Safari.savedState",
-             "Library/Caches/Metadata/Safari"];
-
+  static const List<String> CACHE_DIRECTORIES = const [
+    "Library/Caches/com.apple.Safari",
+    "Library/Safari",
+    "Library/Saved Application State/com.apple.Safari.savedState",
+    "Library/Caches/Metadata/Safari"
+  ];
 
   Future<bool> allowPopUps() {
     var command = "defaults";
-    var args = ["write", "com.apple.safari",
-                "com.apple.Safari.ContentPageGroupIdentifier."
-                "WebKit2JavaScriptCanOpenWindowsAutomatically",
-                "1"];
+    var args = [
+      "write",
+      "com.apple.safari",
+      "com.apple.Safari.ContentPageGroupIdentifier."
+          "WebKit2JavaScriptCanOpenWindowsAutomatically",
+      "1"
+    ];
     return Process.run(command, args).then((result) {
       if (result.exitCode != 0) {
         _logEvent("Could not disable pop-up blocking for safari");
         return false;
       }
       return true;
     });
   }
 
   Future<bool> deleteIfExists(Iterator<String> paths) {
     if (!paths.moveNext()) return new Future.value(true);
     Directory directory = new Directory(paths.current);
     return directory.exists().then((exists) {
       if (exists) {
         _logEvent("Deleting ${paths.current}");
-        return directory.delete(recursive: true)
-            .then((_) => deleteIfExists(paths))
-            .catchError((error) {
-              _logEvent("Failure trying to delete ${paths.current}: $error");
-              return false;
-            });
+        return directory
+            .delete(recursive: true)
+            .then((_) => deleteIfExists(paths))
+            .catchError((error) {
+          _logEvent("Failure trying to delete ${paths.current}: $error");
+          return false;
+        });
       } else {
         _logEvent("${paths.current} is not present");
         return deleteIfExists(paths);
       }
     });
   }
 
   // Clears the cache if the static deleteCache flag is set.
   // Returns false if the command to actually clear the cache did not complete.
   Future<bool> clearCache() {
@@ skipping 52 matching lines @@
       }
       return clearCache().then((cleared) {
         if (!cleared) {
           _logEvent("Could not clear cache");
           return false;
         }
         // Get the version and log that.
         return getVersion().then((version) {
           _logEvent("Got version: $version");
           return Directory.systemTemp.createTemp().then((userDir) {
-            _cleanup = () { userDir.deleteSync(recursive: true); };
+            _cleanup = () {
+              userDir.deleteSync(recursive: true);
+            };
             _createLaunchHTML(userDir.path, url);
             var args = ["${userDir.path}/launch.html"];
             return startBrowserProcess(_binary, args);
           });
         }).catchError((error) {
           _logEvent("Running $_binary --version failed with $error");
           return false;
         });
       });
     });
   }
 
   String toString() => "Safari";
 }
 
-
 class Chrome extends Browser {
   String _version = "Version not found yet";
 
   Map<String, String> _getEnvironment() => null;
 
   Future<bool> _getVersion() {
     if (Platform.isWindows) {
       // The version flag does not work on windows.
       // See issue:
       // https://code.google.com/p/chromium/issues/detail?id=158372
@@ skipping 13 matching lines @@
       if (versionResult.exitCode != 0) {
         _logEvent("Failed to chrome get version");
         _logEvent("Make sure $_binary is a valid program for running chrome");
         return false;
       }
       _version = versionResult.stdout;
       return true;
     });
   }
 
-
   Future<bool> start(String url) {
     _logEvent("Starting chrome browser on: $url");
     // Get the version and log that.
     return _getVersion().then((success) {
       if (!success) return false;
       _logEvent("Got version: $_version");
 
       return Directory.systemTemp.createTemp().then((userDir) {
-        _cleanup = () { userDir.deleteSync(recursive: true); };
-        var args = ["--user-data-dir=${userDir.path}", url,
-                    "--disable-extensions", "--disable-popup-blocking",
-                    "--bwsi", "--no-first-run"];
-        return startBrowserProcess(_binary, args, environment: _getEnvironment());
+        _cleanup = () {
+          userDir.deleteSync(recursive: true);
+        };
+        var args = [
+          "--user-data-dir=${userDir.path}",
+          url,
+          "--disable-extensions",
+          "--disable-popup-blocking",
+          "--bwsi",
+          "--no-first-run"
+        ];
+        return startBrowserProcess(_binary, args,
+            environment: _getEnvironment());
       });
     }).catchError((e) {
       _logEvent("Running $_binary --version failed with $e");
       return false;
     });
   }
 
   String toString() => "Chrome";
 }
 
-
 class SafariMobileSimulator extends Safari {
   /**
    * Directories where safari simulator stores state. We delete these if the
    * deleteCache is set
    */
-  static const List<String> CACHE_DIRECTORIES =
-      const ["Library/Application Support/iPhone Simulator/7.1/Applications"];
+  static const List<String> CACHE_DIRECTORIES = const [
+    "Library/Application Support/iPhone Simulator/7.1/Applications"
+  ];
 
   // Clears the cache if the static deleteCache flag is set.
   // Returns false if the command to actually clear the cache did not complete.
   Future<bool> clearCache() {
     if (!Browser.deleteCache) return new Future.value(true);
     var home = Platform.environment['HOME'];
     Iterator iterator = CACHE_DIRECTORIES.map((s) => "$home/$s").iterator;
     return deleteIfExists(iterator);
   }
 
   Future<bool> start(String url) {
     _logEvent("Starting safari mobile simulator browser on: $url");
     return clearCache().then((success) {
       if (!success) {
         _logEvent("Could not clear cache, exiting");
-        return false;
+        return false;
       }
-      var args = ["-SimulateApplication",
-                  "/Applications/Xcode.app/Contents/Developer/Platforms/"
-                  "iPhoneSimulator.platform/Developer/SDKs/"
-                  "iPhoneSimulator7.1.sdk/Applications/MobileSafari.app/"
-                  "MobileSafari",
-                  "-u", url];
-      return startBrowserProcess(_binary, args)
-        .catchError((e) {
-          _logEvent("Running $_binary --version failed with $e");
-          return false;
-        });
+      var args = [
+        "-SimulateApplication",
+        "/Applications/Xcode.app/Contents/Developer/Platforms/"
+            "iPhoneSimulator.platform/Developer/SDKs/"
+            "iPhoneSimulator7.1.sdk/Applications/MobileSafari.app/"
+            "MobileSafari",
+        "-u",
+        url
+      ];
+      return startBrowserProcess(_binary, args).catchError((e) {
+        _logEvent("Running $_binary --version failed with $e");
+        return false;
+      });
     });
   }
 
   String toString() => "SafariMobileSimulator";
 }
 
-
 class Dartium extends Chrome {
   final bool checkedMode;
 
   Dartium(this.checkedMode);
 
   Map<String, String> _getEnvironment() {
-    var environment = new Map<String,String>.from(Platform.environment);
+    var environment = new Map<String, String>.from(Platform.environment);
     // By setting this environment variable, dartium will forward "print()"
     // calls in dart to the top-level javascript function "dartPrint()" if
     // available.
     environment['DART_FORWARDING_PRINT'] = '1';
     if (checkedMode) {
       environment['DART_FLAGS'] = '--checked';
     }
     return environment;
   }
 
   String toString() => "Dartium";
 }
 
 class IE extends Browser {
   Future<String> getVersion() {
-    var args = ["query",
-                "HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Internet Explorer",
-                "/v",
-                "svcVersion"];
+    var args = [
+      "query",
+      "HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Internet Explorer",
+      "/v",
+      "svcVersion"
+    ];
     return Process.run("reg", args).then((result) {
       if (result.exitCode == 0) {
         // The string we get back looks like this:
         // HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Explorer
         //    version    REG_SZ    9.0.8112.16421
         var findString = "REG_SZ";
         var index = result.stdout.indexOf(findString);
         if (index > 0) {
           return result.stdout.substring(index + findString.length).trim();
         }
       }
       return "Could not get the version of internet explorer";
     });
   }
 
   // Clears the recovery cache if the static deleteCache flag is set.
   Future<bool> clearCache() {
     if (!Browser.deleteCache) return new Future.value(true);
     var localAppData = Platform.environment['LOCALAPPDATA'];
 
     Directory dir = new Directory("$localAppData\\Microsoft\\"
-                                  "Internet Explorer\\Recovery");
-    return dir.delete(recursive: true)
-      .then((_) { return true; })
-      .catchError((error) {
-        _logEvent("Deleting recovery dir failed with $error");
-        return false;
-      });
+        "Internet Explorer\\Recovery");
+    return dir.delete(recursive: true).then((_) {
+      return true;
+    }).catchError((error) {
+      _logEvent("Deleting recovery dir failed with $error");
+      return false;
+    });
   }
 
   Future<bool> start(String url) {
     _logEvent("Starting ie browser on: $url");
     return clearCache().then((_) => getVersion()).then((version) {
       _logEvent("Got version: $version");
       return startBrowserProcess(_binary, [url]);
     });
   }
+
   String toString() => "IE";
-
 }
 
-
 class AndroidBrowserConfig {
   final String name;
   final String package;
   final String activity;
   final String action;
   AndroidBrowserConfig(this.name, this.package, this.activity, this.action);
 }
 
-
 final contentShellOnAndroidConfig = new AndroidBrowserConfig(
     'ContentShellOnAndroid',
     'org.chromium.content_shell_apk',
     '.ContentShellActivity',
     'android.intent.action.VIEW');
 
-
-final dartiumOnAndroidConfig = new AndroidBrowserConfig(
-    'DartiumOnAndroid',
-    'com.google.android.apps.chrome',
-    '.Main',
-    '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) {
     _binary = apkPath;
   }
 
   Future<bool> start(String url) {
-    var intent = new Intent(
-        _config.action, _config.package, _config.activity, 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();
     }).then((_) {
       return _adbDevice.adbRoot();
     }).then((_) {
       return _adbDevice.setProp("DART_FORWARDING_PRINT", "1");
     }).then((_) {
       if (checkedMode) {
@@ skipping 11 matching lines @@
   Future<bool> close() {
     if (_adbDevice != null) {
       return _adbDevice.forceStop(_config.package).then((_) {
         return _adbDevice.killAll().then((_) => true);
       });
     }
     return new Future.value(true);
   }
 
   void logBrowserInfoToTestBrowserOutput() {
-    _testBrowserOutput.stdout.write(
-        'Android device id: ${_adbDevice.deviceId}\n');
+    _testBrowserOutput.stdout
+        .write('Android device id: ${_adbDevice.deviceId}\n');
   }
 
   String toString() => _config.name;
 }
 
-
 class AndroidChrome extends Browser {
   static const String viewAction = 'android.intent.action.VIEW';
   static const String mainAction = 'android.intent.action.MAIN';
   static const String chromePackage = 'com.android.chrome';
   static const String browserPackage = 'com.android.browser';
   static const String firefoxPackage = 'org.mozilla.firefox';
   static const String turnScreenOnPackage = 'com.google.dart.turnscreenon';
 
   AdbDevice _adbDevice;
 
   AndroidChrome(this._adbDevice);
 
   Future<bool> start(String url) {
-    var browserIntent = new Intent(
-        viewAction, browserPackage, '.BrowserActivity', url);
+    var browserIntent =
+        new Intent(viewAction, browserPackage, '.BrowserActivity', url);
     var chromeIntent = new Intent(viewAction, chromePackage, '.Main', url);
     var firefoxIntent = new Intent(viewAction, firefoxPackage, '.App', url);
     var turnScreenOnIntent =
         new Intent(mainAction, turnScreenOnPackage, '.Main');
 
     var testing_resources_dir =
         new Path('third_party/android_testing_resources');
     if (!new Directory(testing_resources_dir.toNativePath()).existsSync()) {
       DebugLogger.error("$testing_resources_dir doesn't exist. Exiting now.");
       exit(1);
@@ skipping 28 matching lines @@
   Future<bool> close() {
     if (_adbDevice != null) {
       return _adbDevice.forceStop(chromePackage).then((_) {
         return _adbDevice.killAll().then((_) => true);
       });
     }
     return new Future.value(true);
   }
 
   void logBrowserInfoToTestBrowserOutput() {
-    _testBrowserOutput.stdout.write(
-        'Android device id: ${_adbDevice.deviceId}\n');
+    _testBrowserOutput.stdout
+        .write('Android device id: ${_adbDevice.deviceId}\n');
   }
 
   String toString() => "chromeOnAndroid";
 }
 
-
 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");
@@ skipping 11 matching lines @@
       if (versionResult.exitCode != 0) {
         _logEvent("Failed to firefox get version");
         _logEvent("Make sure $_binary is a valid program for running firefox");
         return new Future.value(false);
       }
       version = versionResult.stdout;
       _logEvent("Got version: $version");
 
       return Directory.systemTemp.createTemp().then((userDir) {
         _createPreferenceFile(userDir.path);
-        _cleanup = () { userDir.deleteSync(recursive: true); };
-        var args = ["-profile", "${userDir.path}",
-                    "-no-remote", "-new-instance", url];
-        var environment = new Map<String,String>.from(Platform.environment);
+        _cleanup = () {
+          userDir.deleteSync(recursive: true);
+        };
+        var args = [
+          "-profile",
+          "${userDir.path}",
+          "-no-remote",
+          "-new-instance",
+          url
+        ];
+        var environment = new Map<String, String>.from(Platform.environment);
         environment["MOZ_CRASHREPORTER_DISABLE"] = "1";
         return startBrowserProcess(_binary, args, environment: environment);
-
       });
     }).catchError((e) {
       _logEvent("Running $_binary --version failed with $e");
       return false;
     });
   }
 
   String toString() => "Firefox";
 }
 
-
 /**
  * Describes the current state of a browser used for testing.
  */
 class BrowserStatus {
   Browser browser;
   BrowserTest currentTest;
 
   // This is currently not used for anything except for error reporting.
   // Given the usefulness of this in debugging issues this should not be
   // removed even when we have a really stable system.
   BrowserTest lastTest;
   bool timeout = false;
   Timer nextTestTimeout;
   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;
   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)
   Timer timeoutTimer;
 
   // Used for debugging, this is simply a unique identifier assigned to each
   // test.
   int id;
   static int _idCounter = 0;
 
   BrowserTest(this.url, this.doneCallback, this.timeout) {
     id = _idCounter++;
   }
 
-  String toJSON() => JSON.encode({'url': url,
-                                  'id': id,
-                                  'isHtmlTest': false});
+  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)
-      : super(url, doneCallback, timeout) { }
+      : super(url, doneCallback, timeout) {}
 
-  String toJSON() => JSON.encode({'url': url,
-                                  'id': id,
-                                  'isHtmlTest': true,
-                                  'expectedMessages': expectedMessages});
+  String toJSON() => JSON.encode({
+        'url': url,
+        'id': id,
+        'isHtmlTest': true,
+        'expectedMessages': expectedMessages
+      });
 }
 
-
 /* Describes the output of running the test in a browser */
 class BrowserTestOutput {
   final Duration delayUntilTestStarted;
   final Duration duration;
 
   final String lastKnownMessage;
 
   final BrowserOutput browserOutput;
   final bool didTimeout;
 
-  BrowserTestOutput(
-      this.delayUntilTestStarted, this.duration, this.lastKnownMessage,
-      this.browserOutput, {this.didTimeout: false});
+  BrowserTestOutput(this.delayUntilTestStarted, this.duration,
+      this.lastKnownMessage, this.browserOutput,
+      {this.didTimeout: false});
 }
 
-
 /// Encapsulates all the functionality for running tests in browsers.
 /// Tests are added to the queue and the supplied callbacks are called
 /// when a test completes.
 /// BrowserTestRunner starts up to maxNumBrowser instances of the browser,
 /// to run the tests, starting them sequentially, as needed, so only
 /// one is starting up at a time.
 /// BrowserTestRunner starts a BrowserTestingServer, which serves a
 /// driver page to the browsers, serves tests, and receives results and
 /// requests back from the browsers.
 class BrowserTestRunner {
@@ skipping 16 matching lines @@
   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>();
+  Map<String, BrowserStatus> browserStatus = new Map<String, BrowserStatus>();
 
   var adbDeviceMapping = new Map<String, AdbDevice>();
   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> doubleReportingOutputs = new Map<int, String>();
   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;
+    _currentStartingBrowserId = id;
   }
+
   void markNotCurrentlyStarting(String id) {
     if (_currentStartingBrowserId == id) _currentStartingBrowserId = null;
   }
 
   // If [browserName] doesn't support opening new windows, we use new iframes
   // instead.
   bool get useIframe =>
-     !Browser.BROWSERS_WITH_WINDOW_SUPPORT.contains(browserName);
+      !Browser.BROWSERS_WITH_WINDOW_SUPPORT.contains(browserName);
 
   /// The optional testingServer parameter allows callers to pass in
   /// a testing server with different behavior than the  default
   /// BrowserTestServer. The url handlers of the testingServer are
   /// overwritten, so an existing handler can't be shared between instances.
-  BrowserTestRunner(this.configuration,
-                    this.localIp,
-                    this.browserName,
-                    this.maxNumBrowsers,
-                    {BrowserTestingServer this.testingServer}) {
+  BrowserTestRunner(
+      this.configuration, this.localIp, this.browserName, this.maxNumBrowsers,
+      {BrowserTestingServer this.testingServer}) {
     checkedMode = configuration['checked'];
     if (browserName == 'ff') browserName = 'firefox';
   }
 
   Future start() async {
     if (testingServer == null) {
-      testingServer = new BrowserTestingServer(
-          configuration, localIp, useIframe);
+      testingServer =
+          new BrowserTestingServer(configuration, localIp, useIframe);
     }
     await testingServer.start();
     testingServer
-        ..testDoneCallBack = handleResults
-        ..testStatusUpdateCallBack = handleStatusUpdate
-        ..testStartedCallBack = handleStarted
-        ..nextTestCallBack = getNextTest;
+      ..testDoneCallBack = handleResults
+      ..testStatusUpdateCallBack = handleStatusUpdate
+      ..testStartedCallBack = handleStarted
+      ..nextTestCallBack = getNextTest;
     if (browserName == '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
@@ skipping 12 matching lines @@
     createBrowser();
   }
 
   String getNextBrowserId() => "BROWSER${browserIdCounter++}";
 
   void createBrowser() {
     final String id = getNextBrowserId();
     final String url = testingServer.getDriverUrl(id);
     Browser browser;
     if (browserName == 'chromeOnAndroid') {
-      AdbDevice device = idleAdbDevices.removeLast(); 
+      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);
       browser.logger = logger;
     }
     browser.id = id;
     markCurrentlyStarting(id);
     final status = new BrowserStatus(browser);
@@ skipping 13 matching lines @@
     if (status == null || status.timeout) {
       // We don't do anything, this browser is currently being killed and
       // replaced. The browser here can be null if we decided to kill the
       // browser.
     } else if (status.currentTest != null) {
       status.currentTest.timeoutTimer.cancel();
       status.currentTest.stopwatch.stop();
 
       if (status.currentTest.id != testId) {
         print("Expected test id ${status.currentTest.id} for"
-              "${status.currentTest.url}");
+            "${status.currentTest.url}");
         print("Got test id ${testId}");
         print("Last test id was ${status.lastTest.id} for "
-              "${status.currentTest.url}");
-        throw("This should never happen, wrong test id");
+            "${status.currentTest.url}");
+        throw ("This should never happen, wrong test id");
       }
       testCache[testId] = status.currentTest.url;
 
       // Report that the test is finished now
       var browserTestOutput = new BrowserTestOutput(
           status.currentTest.delayUntilTestStarted,
           status.currentTest.stopwatch.elapsed,
           output,
           status.browser.testBrowserOutput);
       status.currentTest.doneCallback(browserTestOutput);
@@ skipping 32 matching lines @@
           createTimeoutTimer(status.currentTest, status);
       status.currentTest.delayUntilTestStarted =
           status.currentTest.stopwatch.elapsed;
     }
   }
 
   void handleTimeout(BrowserStatus status) {
     // We simply kill the browser and starts up a new one!
     // We could be smarter here, but it does not seems like it is worth it.
     if (status.timeout) {
-      DebugLogger.error(
-          "Got test timeout for an already restarting browser");
+      DebugLogger.error("Got test timeout for an already restarting browser");
       return;
     }
     status.timeout = true;
     timedOut.add(status.currentTest.url);
     var id = status.browser.id;
 
     status.currentTest.stopwatch.stop();
     status.browser.close().then((_) {
       var lastKnownMessage =
           'Dom could not be fetched, since the test timed out.';
@@ skipping 40 matching lines @@
       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 ((browserName == 'ie10' || browserName == '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 29 matching lines @@
 
     // Reset the test specific output information (stdout, stderr) on the
     // browser, since a new test is being started.
     status.browser.resetTestBrowserOutput();
     status.browser.logBrowserInfoToTestBrowserOutput();
     return test;
   }
 
   /// Creates a timer that is active while a test is running on a browser.
   Timer createTimeoutTimer(BrowserTest test, BrowserStatus status) {
-    return new Timer(new Duration(seconds: test.timeout),
-                     () { handleTimeout(status); });
+    return new Timer(new Duration(seconds: test.timeout), () {
+      handleTimeout(status);
+    });
   }
 
   /// 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); });
+    return new Timer(BrowserTestRunner.NEXT_TEST_TIMEOUT, () {
+      handleNextTestTimeout(status);
+    });
   }
 
   void handleNextTestTimeout(status) {
-    DebugLogger.warning(
-        "Browser timed out before getting next test. Restarting");
+    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;
       status.browser.close().then((_) {
         removeBrowser(status.browser.id);
@@ skipping 43 matching lines @@
     for (Browser b in browsers) {
       await b.close();
     }
     testingServer.errorReportingServer.close();
     printDoubleReportingTests();
   }
 }
 
 class BrowserTestingServer {
   final Map 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
@@ skipping 16 matching lines @@
 
   Function testDoneCallBack;
   Function testStatusUpdateCallBack;
   Function testStartedCallBack;
   Function nextTestCallBack;
 
   BrowserTestingServer(this.configuration, this.localIp, this.useIframe);
 
   Future start() {
     var test_driver_error_port = configuration['test_driver_error_port'];
-    return HttpServer.bind(localIp, test_driver_error_port)
-      .then(setupErrorServer)
-      .then(setupDispatchingServer);
+    return HttpServer
+        .bind(localIp, test_driver_error_port)
+        .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);
-        }, onDone: () {
-          String back = buffer.toString();
-          request.response.headers.set("Access-Control-Allow-Origin", "*");
-          request.response.done.catchError((error) {
-              DebugLogger.error("Error getting error from browser"
-                                "on uri ${request.uri.path}: $error");
-            });
-          request.response.close();
-          DebugLogger.error("Error from browser on : "
-                            "${request.uri.path}, data:  $back");
-        }, onError: (error) { print(error); });
+        buffer.write(data);
+      }, onDone: () {
+        String back = buffer.toString();
+        request.response.headers.set("Access-Control-Allow-Origin", "*");
+        request.response.done.catchError((error) {
+          DebugLogger.error("Error getting error from browser"
+              "on uri ${request.uri.path}: $error");
+        });
+        request.response.close();
+        DebugLogger.error("Error from browser on : "
+            "${request.uri.path}, data:  $back");
+      }, onError: (error) {
+        print(error);
+      });
     }
     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) {
-        request.response.headers.set("Cache-Control",
-                                     "no-cache, no-store, must-revalidate");
+      request.response.headers
+          .set("Cache-Control", "no-cache, no-store, must-revalidate");
     }
-    int testId(request) =>
-        int.parse(request.uri.queryParameters["id"]);
+    int testId(request) => int.parse(request.uri.queryParameters["id"]);
     String browserId(request, prefix) =>
         request.uri.path.substring(prefix.length + 1);
 
-
     server.addHandler(reportPath, (HttpRequest request) {
       noCache(request);
-      handleReport(request, browserId(request, reportPath),
-                   testId(request), isStatusUpdate: false);
+      handleReport(request, browserId(request, reportPath), testId(request),
+          isStatusUpdate: false);
     });
     server.addHandler(statusUpdatePath, (HttpRequest request) {
       noCache(request);
-      handleReport(request, browserId(request, statusUpdatePath),
-                   testId(request), isStatusUpdate: true);
+      handleReport(
+          request, browserId(request, statusUpdatePath), testId(request),
+          isStatusUpdate: true);
     });
     server.addHandler(startedPath, (HttpRequest request) {
       noCache(request);
-      handleStarted(request, browserId(request, startedPath),
-                   testId(request));
+      handleStarted(request, browserId(request, startedPath), testId(request));
     });
 
     makeSendPageHandler(String prefix) => (HttpRequest request) {
-      noCache(request);
-      var textResponse = "";
-      if (prefix == driverPath) {
-        textResponse = getDriverPage(browserId(request, prefix));
-        request.response.headers.set('Content-Type', 'text/html');
-      }
-      if (prefix == nextTestPath) {
-        textResponse = getNextTest(browserId(request, prefix));
-        request.response.headers.set('Content-Type', 'text/plain');
-      }
-      request.response.write(textResponse);
-      request.listen((_) {}, onDone: request.response.close);
-      request.response.done.catchError((error) {
-        if (!underTermination) {
-          print("URI ${request.uri}");
-          print("Textresponse $textResponse");
-          throw "Error returning content to browser: $error";
-        }
-      });
-    };
+          noCache(request);
+          var textResponse = "";
+          if (prefix == driverPath) {
+            textResponse = getDriverPage(browserId(request, prefix));
+            request.response.headers.set('Content-Type', 'text/html');
+          }
+          if (prefix == nextTestPath) {
+            textResponse = getNextTest(browserId(request, prefix));
+            request.response.headers.set('Content-Type', 'text/plain');
+          }
+          request.response.write(textResponse);
+          request.listen((_) {}, onDone: request.response.close);
+          request.response.done.catchError((error) {
+            if (!underTermination) {
+              print("URI ${request.uri}");
+              print("Textresponse $textResponse");
+              throw "Error returning content to browser: $error";
+            }
+          });
+        };
     server.addHandler(driverPath, makeSendPageHandler(driverPath));
     server.addHandler(nextTestPath, makeSendPageHandler(nextTestPath));
   }
 
   void handleReport(HttpRequest request, String browserId, var testId,
-                    {bool isStatusUpdate}) {
+      {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"); });
+    }, onError: (error) {
+      DebugLogger.error("$error");
+    });
   }
 
   void handleStarted(HttpRequest request, String browserId, var 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);
-    }, onError: (error) { DebugLogger.error("$error"); });
+    }, onError: (error) {
+      DebugLogger.error("$error");
+    });
   }
 
   String getNextTest(String browserId) {
     var nextTest = nextTestCallBack(browserId);
     if (underTermination) {
       // Browsers will be killed shortly, send them a terminate signal so
       // that they stop pulling.
       return terminateSignal;
     }
     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");
+          "produce driver url");
       exit(1);
       // This should never happen - exit immediately;
     }
     var port = configuration['_servers_'].port;
     return "http://$localIp:$port/driver/$browserId";
   }
 
-
   String getDriverPage(String browserId) {
     var errorReportingUrl =
         "http://$localIp:${errorReportingServer.port}/$browserId";
     String driverContent = """
 <!DOCTYPE html><html>
 <head>
   <style>
     body {
       margin: 0;
     }
@@ skipping 322 matching lines @@
     </div>
     <div id="embedded_iframe_div" class="test box">
       <iframe style="width:100%;height:100%;" id="embedded_iframe"></iframe>
     </div>
   </body>
 </html>
 """;
     return driverContent;
   }
 }