Add reusePort argument to ServerSocket.

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);
+                                                   bool v6Only: false,
+                                                   bool reusePort: false}) {
+    return _RawServerSocket.bind(address, port, backlog, v6Only, reusePort);
   }
 }
 
 
 patch class RawSocket {
   /* patch */ static Future<RawSocket> connect(host, int port) {
     return _RawSocket.connect(host, port);
   }
 }
 
@@ skipping 291 matching lines @@
             );
             socket.setListening(read: false, write: true);
             return completer.future;
           }
         });
   }
 
   static Future<_NativeSocket> bind(host,
                                     int port,
                                     int backlog,
-                                    bool v6Only) {
+                                    bool v6Only,
+                                    bool reusePort) {
     return new Future.value(host)
         .then((host) {
           if (host is _InternetAddress) return host;
           return lookup(host)
               .then((list) {
                 if (list.length == 0) {
                   throw createError(response, "Failed host lookup: '$host'");
                 }
                 return list[0];
               });
         })
         .then((address) {
           var socket = new _NativeSocket.listen();
           socket.address = address;
           var result = socket.nativeCreateBindListen(address._sockaddr_storage,
                                                      port,
                                                      backlog,
-                                                     v6Only);
+                                                     v6Only,
+                                                     reusePort);
           if (result is OSError) {
             throw new SocketException("Failed to create server socket",
                                       osError: result,
                                       address: address,
                                       port: port);
           }
           if (port != 0) socket.localPort = port;
           return socket;
         });
   }
@@ skipping 297 matching lines @@
     return nativeSetOption(option._value, enabled);
   }
 
   void nativeSetSocketId(int id) native "Socket_SetSocketId";
   nativeAvailable() native "Socket_Available";
   nativeRead(int len) native "Socket_Read";
   nativeWrite(List<int> buffer, int offset, int bytes)
       native "Socket_WriteList";
   nativeCreateConnect(List<int> addr,
                       int port) native "Socket_CreateConnect";
-  nativeCreateBindListen(List<int> addr, int port, int backlog, bool v6Only)
+  nativeCreateBindListen(
+      List<int> addr, int port, int backlog, bool v6Only, bool reusePort)
       native "ServerSocket_CreateBindListen";
   nativeAccept(_NativeSocket socket) native "ServerSocket_Accept";
   int nativeGetPort() native "Socket_GetPort";
   List nativeGetRemotePeer() native "Socket_GetRemotePeer";
   OSError nativeGetError() native "Socket_GetError";
   bool nativeSetOption(int option, bool enabled) native "Socket_SetOption";
 }
 
 
 class _RawServerSocket extends Stream<RawSocket>
                        implements RawServerSocket {
   final _NativeSocket _socket;
   StreamController<RawSocket> _controller;
 
   static Future<_RawServerSocket> bind(address,
                                        int port,
                                        int backlog,
-                                       bool v6Only) {
+                                       bool v6Only,
+                                       bool reusePort) {
     if (port < 0 || port > 0xFFFF)
       throw new ArgumentError("Invalid port $port");
     if (backlog < 0) throw new ArgumentError("Invalid backlog $backlog");
-    return _NativeSocket.bind(address, port, backlog, v6Only)
+    return _NativeSocket.bind(address, port, backlog, v6Only, reusePort)
         .then((socket) => new _RawServerSocket(socket));
   }
 
   _RawServerSocket(this._socket) {
     _controller = new StreamController(sync: true,
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
     _socket.closeFuture.then((_) => _controller.close());
@@ skipping 195 matching lines @@
       close();
     }
   }
 }
 
 
 patch class ServerSocket {
   /* patch */ static Future<ServerSocket> bind(address,
                                                int port,
                                                {int backlog: 0,
-                                                bool v6Only: false}) {
-    return _ServerSocket.bind(address, port, backlog, v6Only);
+                                                bool v6Only: false,
+                                                bool reusePort: false}) {
+    return _ServerSocket.bind(address, port, backlog, v6Only, reusePort);
   }
 }
 
 class _ServerSocket extends Stream<Socket>
                     implements ServerSocket {
   final _socket;
 
   static Future<_ServerSocket> bind(address,
                                     int port,
                                     int backlog,
-                                    bool v6Only) {
-    return _RawServerSocket.bind(address, port, backlog, v6Only)
+                                    bool v6Only,
+                                    bool reusePort) {
+    return _RawServerSocket.bind(address, port, backlog, v6Only, reusePort)
         .then((socket) => new _ServerSocket(socket));
   }
 
   _ServerSocket(this._socket);
 
   StreamSubscription<Socket> listen(void onData(Socket event),
                                     {void onError(error),
                                      void onDone(),
                                      bool cancelOnError}) {
     return _socket.map((rawSocket) => new _Socket(rawSocket)).listen(
@@ skipping 295 matching lines @@
     if (_detachReady != null) {
       _detachReady.complete(null);
     } else {
       if (_raw != null) {
         _raw.shutdown(SocketDirection.SEND);
         _disableWriteEvent();
       }
     }
   }
 }