Format all files under tools and utils directory.

tools/testing/dart/android.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 android;
 
 import "dart:async";
 import "dart:convert" show LineSplitter, UTF8;
 import "dart:core";
 import "dart:collection";
 import "dart:io";
 
 import "path.dart";
 import "utils.dart";
 
 class AdbCommandResult {
   final String command;
   final String stdout;
   final String stderr;
   final int exitCode;
   final bool timedOut;
 
-  AdbCommandResult(this.command, this.stdout, this.stderr, this.exitCode,
-                   this.timedOut);
+  AdbCommandResult(
+      this.command, this.stdout, this.stderr, this.exitCode, this.timedOut);
 
   void throwIfFailed() {
     if (exitCode != 0) {
       var error = "Running: $command failed:"
-                  "stdout:\n  ${stdout.trim()}\n"
-                  "stderr:\n  ${stderr.trim()}\n"
-                  "exitCode: $exitCode\n"
-                  "timedOut: $timedOut";
+          "stdout:\n  ${stdout.trim()}\n"
+          "stderr:\n  ${stderr.trim()}\n"
+          "exitCode: $exitCode\n"
+          "timedOut: $timedOut";
       throw new Exception(error);
     }
   }
 }
 
 /**
  * [_executeCommand] will write [stdin] to the standard input of the created
  * process and will return a tuple (stdout, stderr).
  *
  * If the exit code of the process was nonzero it will complete with an error.
  * If starting the process failed, it will complete with an error as well.
  */
-Future<AdbCommandResult> _executeCommand(
-    String executable, List<String> args,
+Future<AdbCommandResult> _executeCommand(String executable, List<String> args,
     {String stdin, Duration timeout}) {
   Future<String> getOutput(Stream<List<int>> stream) {
     return stream
         .transform(UTF8.decoder)
         .toList()
         .then((data) => data.join(""));
   }
 
   return Process.start(executable, args).then((Process process) async {
     if (stdin != null && stdin != '') {
       process.stdin.write(stdin);
       await process.stdin.flush();
     }
     process.stdin.close();
 
     Timer timer;
     bool timedOut = false;
     if (timeout != null) {
       timer = new Timer(timeout, () {
         timedOut = true;
         process.kill(ProcessSignal.SIGTERM);
         timer = null;
       });
     }
 
     var results = await Future.wait([
-        getOutput(process.stdout),
-        getOutput(process.stderr),
-        process.exitCode
+      getOutput(process.stdout),
+      getOutput(process.stderr),
+      process.exitCode
     ]);
     if (timer != null) timer.cancel();
 
     String command = "$executable ${args.join(' ')}";
     return new AdbCommandResult(
         command, results[0], results[1], results[2], timedOut);
   });
 }
 
 /**
@@ skipping 123 matching lines @@
   /**
    * Polls the 'sys.boot_completed' property. Returns as soon as the property is
    * 1.
    */
   Future waitForBootCompleted() async {
     while (true) {
       try {
         AdbCommandResult result =
             await _adbCommand(['shell', 'getprop', 'sys.boot_completed']);
         if (result.stdout.trim() == '1') return;
-      } catch (_) { }
+      } catch (_) {}
       await new Future.delayed(const Duration(seconds: 2));
     }
   }
 
   /**
    * Put adb in root mode.
    */
   Future adbRoot() {
     var adbRootCompleter = new Completer();
     _adbCommand(['root']).then((_) {
@@ skipping 17 matching lines @@
   Future pushData(Path local, Path remote) {
     return _adbCommand(['push', '$local', '$remote']);
   }
 
   /**
    * Upload data to the device, unless [local] is the same as the most recently
    * used source for [remote].
    */
   Future pushCachedData(String local, String remote) {
     if (_cachedData[remote] == local) {
-      return new Future.value(new AdbCommandResult(
-          "Skipped cached push", "", "", 0, false));
+      return new Future.value(
+          new AdbCommandResult("Skipped cached push", "", "", 0, false));
     }
     _cachedData[remote] = local;
     return _adbCommand(['push', local, remote]);
   }
 
   /**
    * Change permission of directory recursively.
    */
   Future chmod(String mode, Path directory) {
     var arguments = ['shell', 'chmod', '-R', mode, '$directory'];
@@ skipping 45 matching lines @@
 
   /**
    * Kill all background processes.
    */
   Future killAll() {
     var arguments = ['shell', 'am', 'kill-all'];
     return _adbCommand(arguments);
   }
 
   Future<AdbCommandResult> runAdbCommand(List<String> adbArgs,
-                                         {Duration timeout}) {
-    return _executeCommand(
-        "adb", _deviceSpecificArgs(adbArgs), timeout: timeout);
+      {Duration timeout}) {
+    return _executeCommand("adb", _deviceSpecificArgs(adbArgs),
+        timeout: timeout);
   }
 
   Future<AdbCommandResult> runAdbShellCommand(List<String> shellArgs,
-                                              {Duration timeout}) async {
+      {Duration timeout}) async {
     const MARKER = 'AdbShellExitCode: ';
 
     // The exitcode of 'adb shell ...' can be 0 even though the command failed
     // with a non-zero exit code. We therefore explicitly print it to stdout and
     // search for it.
 
-    var args = ['shell',
-                "${shellArgs.join(' ')} ; echo $MARKER \$?"];
+    var args = ['shell', "${shellArgs.join(' ')} ; echo $MARKER \$?"];
     AdbCommandResult result = await _executeCommand(
-        "adb", _deviceSpecificArgs(args), timeout: timeout);
+        "adb", _deviceSpecificArgs(args),
+        timeout: timeout);
     int exitCode = result.exitCode;
-    var lines = result
-        .stdout.split('\n')
+    var lines = result.stdout
+        .split('\n')
         .where((line) => line.trim().length > 0)
         .toList();
     if (lines.length > 0) {
       int index = lines.last.indexOf(MARKER);
       if (index >= 0) {
-        exitCode = int.parse(
-            lines.last.substring(index + MARKER.length).trim());
+        exitCode =
+            int.parse(lines.last.substring(index + MARKER.length).trim());
         if (exitCode > 128 && exitCode <= 128 + 31) {
           // Return negative exit codes for signals 1..31 (128+N for signal N)
           exitCode = 128 - exitCode;
         }
       } else {
         // In case of timeouts, for example, we won't get the exitcode marker.
         assert(result.exitCode != 0);
       }
     }
-    return new AdbCommandResult(
-        result.command, result.stdout, result.stderr, exitCode,
-        result.timedOut);
+    return new AdbCommandResult(result.command, result.stdout, result.stderr,
+        exitCode, result.timedOut);
   }
 
   Future<AdbCommandResult> _adbCommand(List<String> adbArgs) async {
     var result = await _executeCommand("adb", _deviceSpecificArgs(adbArgs));
     result.throwIfFailed();
     return result;
   }
 
   List<String> _deviceSpecificArgs(List<String> adbArgs) {
     if (_deviceId != null) {
@@ skipping 46 matching lines @@
   final Queue<Completer> _waiter = new Queue<Completer>();
 
   AdbDevicePool(List<AdbDevice> idleDevices) {
     _idleDevices.addAll(idleDevices);
   }
 
   static Future<AdbDevicePool> create() async {
     var names = await AdbHelper.listDevices();
     var devices = names.map((id) => new AdbDevice(id)).toList();
     if (devices.length == 0) {
-      throw new Exception(
-          'No android devices found. '
+      throw new Exception('No android devices found. '
           'Please make sure "adb devices" shows your device!');
     }
     print("Found ${devices.length} Android devices.");
     return new AdbDevicePool(devices);
   }
 
   Future<AdbDevice> acquireDevice() async {
     if (_idleDevices.length > 0) {
       return _idleDevices.removeFirst();
     } else {
       var completer = new Completer();
       _waiter.add(completer);
       return completer.future;
     }
   }
 
   void releaseDevice(AdbDevice device) {
     if (_waiter.length > 0) {
       Completer completer = _waiter.removeFirst();
       completer.complete(device);
     } else {
       _idleDevices.add(device);
     }
   }
 }