Revert "Use native async/await support in pub."

sdk/lib/_internal/pub_generated/test/serve/utils.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS d.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 pub_tests;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
@@ skipping 131 matching lines @@
 }
 """;
 }
 
 /// Schedules starting the `pub serve` process.
 ///
 /// Unlike [pubServe], this doesn't determine the port number of the server, and
 /// so may be used to test for errors in the initialization process.
 ///
 /// Returns the `pub serve` process.
-ScheduledProcess startPubServe({Iterable<String> args,
-    bool createWebDir: true}) {
-  var pubArgs = [
-    "serve",
-    "--port=0", // Use port 0 to get an ephemeral port.
-    "--force-poll",
-    "--log-admin-url"
-  ];
+ScheduledProcess startPubServe({Iterable<String> args, bool createWebDir: true})
+    {
+  var pubArgs = ["serve", "--port=0", // Use port 0 to get an ephemeral port.
+    "--force-poll", "--log-admin-url"];
 
   if (args != null) pubArgs.addAll(args);
 
   // Dart2js can take a long time to compile dart code, so we increase the
   // timeout to cope with that.
   currentSchedule.timeout *= 1.5;
 
   if (createWebDir) d.dir(appPath, [d.dir("web")]).create();
   return startPub(args: pubArgs);
 }
@@ skipping 17 matching lines @@
     _ports.clear();
 
     if (_webSocket != null) {
       _webSocket.close();
       _webSocket = null;
       _webSocketBroadcastStream = null;
     }
   });
 
   if (shouldGetFirst) {
-    _pubServer.stdout.expect(consumeThrough(anyOf([
-      "Got dependencies!",
-      matches(new RegExp(r"^Changed \d+ dependenc"))
-    ])));
+    _pubServer.stdout.expect(
+        consumeThrough(
+            anyOf(["Got dependencies!", matches(new RegExp(r"^Changed \d+ dependenc"))])));
   }
 
   _pubServer.stdout.expect(startsWith("Loading source assets..."));
   _pubServer.stdout.expect(consumeWhile(matches("Loading .* transformers...")));
 
   _pubServer.stdout.expect(predicate(_parseAdminPort));
 
   // The server should emit one or more ports.
   _pubServer.stdout.expect(
       consumeWhile(predicate(_parsePort, 'emits server url')));
@@ skipping 66 matching lines @@
 }
 
 /// Schedules an HTTP request to the running pub server with [urlPath] and
 /// verifies that it responds with a redirect to the given [redirectTarget].
 ///
 /// [redirectTarget] may be either a [Matcher] or a string to match an exact
 /// URL. [root] indicates which server should be accessed, and defaults to
 /// "web".
 void requestShouldRedirect(String urlPath, redirectTarget, {String root}) {
   schedule(() {
-    var request = new http.Request("GET",
-        Uri.parse(_getServerUrlSync(root, urlPath)));
+    var request =
+        new http.Request("GET", Uri.parse(_getServerUrlSync(root, urlPath)));
     request.followRedirects = false;
     return request.send().then((response) {
       expect(response.statusCode ~/ 100, equals(3));
       expect(response.headers, containsPair('location', redirectTarget));
     });
   }, "request $urlPath");
 }
 
 /// Schedules an HTTP POST to the running pub server with [urlPath] and verifies
 /// that it responds with a 405.
 ///
 /// [root] indicates which server should be accessed, and defaults to "web".
 void postShould405(String urlPath, {String root}) {
   schedule(() {
     return http.post(_getServerUrlSync(root, urlPath)).then((response) {
       expect(response.statusCode, equals(405));
     });
   }, "request $urlPath");
 }
 
 /// Schedules an HTTP request to the (theoretically) running pub server with
 /// [urlPath] and verifies that it cannot be connected to.
 ///
 /// [root] indicates which server should be accessed, and defaults to "web".
 void requestShouldNotConnect(String urlPath, {String root}) {
   schedule(() {
-    return expect(http.get(_getServerUrlSync(root, urlPath)),
+    return expect(
+        http.get(_getServerUrlSync(root, urlPath)),
         throwsA(new isInstanceOf<SocketException>()));
   }, "request $urlPath");
 }
 
 /// Reads lines from pub serve's stdout until it prints the build success
 /// message.
 ///
 /// The schedule will not proceed until the output is found. If not found, it
 /// will eventually time out.
 void waitForBuildSuccess() =>
-  _pubServer.stdout.expect(consumeThrough(contains("successfully")));
+    _pubServer.stdout.expect(consumeThrough(contains("successfully")));
 
 /// Schedules opening a web socket connection to the currently running pub
 /// serve.
 Future _ensureWebSocket() {
   // Use the existing one if already connected.
   if (_webSocket != null) return new Future.value();
 
   // Server should already be running.
   expect(_pubServer, isNotNull);
   expect(_adminPort, isNotNull);
 
   return WebSocket.connect("ws://localhost:$_adminPort").then((socket) {
     _webSocket = socket;
     // TODO(rnystrom): Works around #13913.
     _webSocketBroadcastStream = _webSocket.map(JSON.decode).asBroadcastStream();
   });
 }
 
 /// Schedules closing the web socket connection to the currently-running pub
 /// serve.
 void closeWebSocket() {
   schedule(() {
-    return _ensureWebSocket().then((_) => _webSocket.close())
-        .then((_) => _webSocket = null);
+    return _ensureWebSocket().then((_) => _webSocket.close()).then((_) => _webSocket =
+        null);
   }, "closing web socket");
 }
 
 /// Sends a JSON RPC 2.0 request to the running pub serve's web socket
 /// connection.
 ///
 /// This calls a method named [method] with the given [params] (or no
 /// parameters, if it's not passed). [params] may contain Futures, in which case
 /// this will wait until they've completed before sending the request.
 ///
 /// This schedules the request, but doesn't block the schedule on the response.
 /// It returns the response as a [Future].
 Future<Map> webSocketRequest(String method, [Map params]) {
   var completer = new Completer();
   schedule(() {
-    return Future.wait([
-      _ensureWebSocket(),
-      awaitObject(params),
-    ]).then((results) {
+    return Future.wait(
+        [_ensureWebSocket(), awaitObject(params),]).then((results) {
       var resolvedParams = results[1];
       chainToCompleter(
           currentSchedule.wrapFuture(_jsonRpcRequest(method, resolvedParams)),
           completer);
     });
   }, "send $method with $params to web socket");
   return completer.future;
 }
 
 /// Sends a JSON RPC 2.0 request to the running pub serve's web socket
 /// connection, waits for a reply, then verifies the result.
 ///
 /// This calls a method named [method] with the given [params]. [params] may
 /// contain Futures, in which case this will wait until they've completed before
 /// sending the request.
 ///
 /// The result is validated using [result], which may be a [Matcher] or a [Map]
 /// containing [Matcher]s and [Future]s. This will wait until any futures are
 /// completed before sending the request.
 ///
 /// Returns a [Future] that completes to the call's result.
 Future<Map> expectWebSocketResult(String method, Map params, result) {
   return schedule(() {
-    return Future.wait([
-      webSocketRequest(method, params),
-      awaitObject(result)
-    ]).then((results) {
+    return Future.wait(
+        [webSocketRequest(method, params), awaitObject(result)]).then((results) {
       var response = results[0];
       var resolvedResult = results[1];
       expect(response["result"], resolvedResult);
       return response["result"];
     });
   }, "send $method with $params to web socket and expect $result");
 }
 
 /// Sends a JSON RPC 2.0 request to the running pub serve's web socket
 /// connection, waits for a reply, then verifies the error response.
 ///
 /// This calls a method named [method] with the given [params]. [params] may
 /// contain Futures, in which case this will wait until they've completed before
 /// sending the request.
 ///
 /// The error response is validated using [errorCode] and [errorMessage]. Both
 /// of these must be provided. The error code is checked against [errorCode] and
 /// the error message is checked against [errorMessage]. Either of these may be
 /// matchers.
 ///
 /// If [data] is provided, it is a JSON value or matcher used to validate the
 /// "data" value of the error response.
 ///
 /// Returns a [Future] that completes to the error's [data] field.
-Future expectWebSocketError(String method, Map params, errorCode,
-    errorMessage, {data}) {
+Future expectWebSocketError(String method, Map params, errorCode, errorMessage,
+    {data}) {
   return schedule(() {
     return webSocketRequest(method, params).then((response) {
       expect(response["error"]["code"], errorCode);
       expect(response["error"]["message"], errorMessage);
 
       if (data != null) {
         expect(response["error"]["data"], data);
       }
 
       return response["error"]["data"];
@@ skipping 17 matching lines @@
 Future<Map> _jsonRpcRequest(String method, [Map params]) {
   var id = _rpcId++;
   var message = {
     "jsonrpc": "2.0",
     "method": method,
     "id": id
   };
   if (params != null) message["params"] = params;
   _webSocket.add(JSON.encode(message));
 
-  return _webSocketBroadcastStream
-      .firstWhere((response) => response["id"] == id).then((value) {
+  return _webSocketBroadcastStream.firstWhere(
+      (response) => response["id"] == id).then((value) {
     currentSchedule.addDebugInfo(
-        "Web Socket request $method with params $params\n"
-        "Result: $value");
+        "Web Socket request $method with params $params\n" "Result: $value");
 
     expect(value["id"], equals(id));
     return value;
   });
 }
 
 /// Returns a [Future] that completes to a URL string for the server serving
 /// [path] from [root].
 ///
 /// If [root] is omitted, defaults to "web". If [path] is omitted, no path is
@@ skipping 16 matching lines @@
 /// included. Unlike [getServerUrl], this should only be called after the ports
 /// are known.
 String _getServerUrlSync([String root, String path]) {
   if (root == null) root = 'web';
   expect(_ports, contains(root));
   var url = "http://localhost:${_ports[root]}";
   if (path != null) url = "$url/$path";
   return url;
 }