Fix most strong mode warnings.

lib/http_multi_server.dart

 // Copyright (c) 2014, 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.
 
 import 'dart:async';
 import 'dart:io';
 
+import 'package:async/async.dart';
+
 import 'src/multi_headers.dart';
 import 'src/utils.dart';
 
 /// The error code for an error caused by a port already being in use.
 final _addressInUseErrno = _computeAddressInUseErrno();
 int _computeAddressInUseErrno() {
   if (Platform.isWindows) return 10048;
   if (Platform.isMacOS) return 48;
   assert(Platform.isLinux);
   return 98;
@@ skipping 61 matching lines @@
   }
 
   /// Creates an [HttpMultiServer] wrapping [servers].
   ///
   /// All [servers] should have the same configuration and none should be
   /// listened to when this is called.
   HttpMultiServer(Iterable<HttpServer> servers)
       : _servers = servers.toSet(),
         defaultResponseHeaders = new MultiHeaders(
             servers.map((server) => server.defaultResponseHeaders)),
-        super(mergeStreams(servers));
+        super(StreamGroup.merge(servers));
 
   /// Creates an [HttpServer] listening on all available loopback addresses for
   /// this computer.
   ///
   /// See [HttpServer.bind].
   static Future<HttpServer> loopback(int port, {int backlog, bool v6Only: false,
         bool shared: false}) {
     if (backlog == null) backlog = 0;
 
     return _loopback(port, (address, port) =>
@@ skipping 14 matching lines @@
             backlog: backlog, v6Only: v6Only, shared: shared,
             requestClientCertificate: requestClientCertificate));
   }
 
   /// A helper method for initializing loopback servers.
   ///
   /// [bind] should forward to either [HttpServer.bind] or
   /// [HttpServer.bindSecure].
   static Future<HttpServer> _loopback(int port,
       Future<HttpServer> bind(InternetAddress address, int port),
-      [int remainingRetries]) {
+      [int remainingRetries]) async {
     if (remainingRetries == null) remainingRetries = 5;
 
-    return Future.wait([
-      supportsIpV6,
-      bind(InternetAddress.LOOPBACK_IP_V4, port)
-    ]).then((results) {
-      var supportsIpV6 = results[0];
-      var v4Server = results[1];
+    var v4Server = await bind(InternetAddress.LOOPBACK_IP_V4, port);
+    if (!await supportsIpV6) return v4Server;
 
-      if (!supportsIpV6) return v4Server;
-
+    try {
       // Reuse the IPv4 server's port so that if [port] is 0, both servers use
       // the same ephemeral port.
-      return bind(InternetAddress.LOOPBACK_IP_V6, v4Server.port)
-          .then((v6Server) {
-        return new HttpMultiServer([v4Server, v6Server]);
-      }).catchError((error) {
-        if (error is! SocketException) throw error;
-        if (error.osError.errorCode != _addressInUseErrno) throw error;
-        if (port != 0) throw error;
-        if (remainingRetries == 0) throw error;
+      var v6Server = await bind(InternetAddress.LOOPBACK_IP_V6, v4Server.port);
+      return new HttpMultiServer([v4Server, v6Server]);
+    } on SocketException catch (error) {
+      if (error.osError.errorCode != _addressInUseErrno) rethrow;
+      if (port != 0) rethrow;
+      if (remainingRetries == 0) rethrow;
 
-        // A port being available on IPv4 doesn't necessarily mean that the same
-        // port is available on IPv6. If it's not (which is rare in practice),
-        // we try again until we find one that's available on both.
-        v4Server.close();
-        return _loopback(port, bind, remainingRetries - 1);
-      });
-    });
+      // A port being available on IPv4 doesn't necessarily mean that the same
+      // port is available on IPv6. If it's not (which is rare in practice),
+      // we try again until we find one that's available on both.
+      v4Server.close();
+      return await _loopback(port, bind, remainingRetries - 1);
+    }
   }
 
   Future close({bool force: false}) =>
       Future.wait(_servers.map((server) => server.close(force: force)));
 
   /// Returns an HttpConnectionsInfo object summarizing the total number of
   /// current connections handled by all the servers.
   HttpConnectionsInfo connectionsInfo() {
     var info = new HttpConnectionsInfo();
     for (var server in _servers) {
       var subInfo = server.connectionsInfo();
       info.total += subInfo.total;
       info.active += subInfo.active;
       info.idle += subInfo.idle;
       info.closing += subInfo.closing;
     }
     return info;
   }
 }