In Socket:connect, start connecting to next address, after 250 (25 for loopback).

runtime/bin/socket_patch.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.
 
 patch class RawServerSocket {
   /* patch */ static Future<RawServerSocket> bind(address,
                                                   int port,
                                                   {int backlog: 0,
                                                    bool v6Only: false}) {
     return _RawServerSocket.bind(address, port, backlog, v6Only);
@@ skipping 193 matching lines @@
   String toString() {
     return "NetworkInterface('$name', $addresses)";
   }
 }
 
 
 // The NativeFieldWrapperClass1 can not be used with a mixin, due to missing
 // implicit constructor.
 class _NativeSocketNativeWrapper extends NativeFieldWrapperClass1 {}
 
+class _ConnectingSocket {
+  final _NativeSocket socket;
+  final Timer timer;
+
+  _ConnectingSocket(this.socket, this.timer);
+
+  void abort() {
+    timer.cancel();
+    socket.close();
+    socket.setHandlers();
+    socket.setListening(read: false, write: false);
+  }
+}
+
 
 // The _NativeSocket class encapsulates an OS socket.
 class _NativeSocket extends _NativeSocketNativeWrapper with _ServiceObject {
   // Bit flags used when communicating between the eventhandler and
   // dart code. The EVENT flags are used to indicate events of
   // interest when sending a message from dart code to the
   // eventhandler. When receiving a message from the eventhandler the
   // EVENT flags indicate the events that actually happened. The
   // COMMAND flags are used to send commands from dart to the
   // eventhandler. COMMAND flags are never received from the
@@ skipping 42 matching lines @@
   static const LIST_INTERFACES = 1;
   static const REVERSE_LOOKUP = 2;
 
   // Protocol flags.
   static const int PROTOCOL_IPV4 = 1 << 0;
   static const int PROTOCOL_IPV6 = 1 << 1;
 
   static const int NORMAL_TOKEN_BATCH_SIZE = 8;
   static const int LISTENING_TOKEN_BATCH_SIZE = 2;
 
+  static const Duration _RETRY_DURATION = const Duration(milliseconds: 250);
+  static const Duration _RETRY_DURATION_LOOPBACK =
+      const Duration(milliseconds: 25);
+
   // Use default Map so we keep order.
   static Map<int, _NativeSocket> _sockets = new Map<int, _NativeSocket>();
 
   // Socket close state
   bool isClosed = false;
   bool isClosing = false;
   bool isClosedRead = false;
   bool isClosedWrite = false;
   Completer closeCompleter = new Completer.sync();
 
@@ skipping 89 matching lines @@
           }
         });
   }
 
   static Future<_NativeSocket> connect(host, int port) {
     return new Future.value(host)
         .then((host) {
           if (host is _InternetAddress) return [host];
           return lookup(host)
               .then((list) {
                 if (list.length == 0) {

[Bill Hesse, 2014/07/29 10:57:06]

Maybe list should be "addresses" here.  Use isNotEmpty?

[Anders Johnsen, 2014/07/29 11:23:27]

Done.

                   throw createError(response, "Failed host lookup: '$host'");
                 }
                 return list;
               });
         })
         .then((addresses) {
           assert(addresses is List);
+          assert(addresses.isNotEmpty);

[Bill Hesse, 2014/07/29 10:57:06]

This assert is covered by the check in the above function.

[Anders Johnsen, 2014/07/29 11:23:27]

Done.

           var completer = new Completer();
           var it = addresses.iterator;
-          void run(error) {
+          var error = null;
+          var connecting = new HashSet();
+          void connectNext() {
             if (!it.moveNext()) {
-              assert(error != null);
-              completer.completeError(error);
+              if (connecting.isEmpty) {
+                assert(error != null);
+                completer.completeError(error);
+              }
               return;
             }
             var address = it.current;
             var socket = new _NativeSocket.normal();
             socket.address = address;
             var result = socket.nativeCreateConnect(address._in_addr, port);
             if (result is OSError) {
               // Keep first error, if present.
-              run(error != null ? error :
-                  createError(result, "Connection failed", address, port));
+              if (error == null) {
+                error = createError(result, "Connection failed", address, port);
+              }
+              connectNext();
             } else {
               socket.port;  // Query the local port, for error messages.
+              // Set up timer for when we should retry the next address (if any).
+              var duration = address.isLoopback ?
+                  _RETRY_DURATION_LOOPBACK :
+                  _RETRY_DURATION;
+              var timer = new Timer(duration, connectNext);
+              var connectingSocket = new _ConnectingSocket(socket, timer);
+              connecting.add(connectingSocket);

[Bill Hesse, 2014/07/29 10:57:06]

If you used a Map, rather than a Set, then this would just be connecting[socket]
= timer, and the connectingSocket class would disappear.  I don't think the
other code would get more complicated - abort could still be encapsulated as a
closure, binding connecting.

But you can keep it a set.

[Anders Johnsen, 2014/07/29 11:23:27]

Acknowledged.

               // Setup handlers for receiving the first write event which
               // indicate that the socket is fully connected.
               socket.setHandlers(
                   write: () {
+                    timer.cancel();
                     socket.setListening(read: false, write: false);
                     completer.complete(socket);
+                    connecting.remove(connectingSocket);
+                    for (var s in connecting) {
+                      s.abort();
+                    }
                   },
                   error: (e) {
-                    socket.close();
+                    connectingSocket.abort();
                     // Keep first error, if present.
-                    run(error != null ? error : e);
-                  }
-              );
+                    if (error == null) error = e;
+                    connecting.remove(connectingSocket);
+                    if (connecting.isEmpty) connectNext();
+                  });
               socket.setListening(read: false, write: true);
             }
           }
-          run(null);
+          connectNext();
           return completer.future;
         });
   }
 
   static Future<_NativeSocket> bind(host,
                                     int port,
                                     int backlog,
                                     bool v6Only) {
     return new Future.value(host)
         .then((host) {
@@ skipping 1464 matching lines @@
                        String address,
                        List<int> in_addr,
                        int port) {
   return new Datagram(
       data,
       new _InternetAddress(address, null, in_addr),
       port);
 }
 
 String _socketsStats() => _SocketsObservatory.toJSON();