Add v6Only named argument to ServerSocket and etc.

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}) {
-    return _RawServerSocket.bind(address, port, backlog);
+                                                  {int backlog: 0,
+                                                   bool v6Only: false}) {
+    return _RawServerSocket.bind(address, port, backlog, v6Only);
   }
 }
 
 
 patch class RawSocket {
   /* patch */ static Future<RawSocket> connect(host, int port) {
     return _RawSocket.connect(host, port);
   }
 }
 
@@ skipping 188 matching lines @@
                 }
             );
             socket.setListening(read: false, write: true);
             return completer.future;
           }
         });
   }
 
   static Future<_NativeSocket> bind(host,
                                     int port,
-                                    int backlog) {
+                                    int backlog,
+                                    bool v6Only) {
     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 name lookup");
                 }
                 return list[0];
               });
         })
         .then((address) {
           var socket = new _NativeSocket.listen();
           socket.address = address;
           var result = socket.nativeCreateBindListen(address._sockaddr_storage,
                                                      port,
-                                                     backlog);
+                                                     backlog,
+                                                     v6Only);
           if (result is OSError) {
             throw new SocketIOException(
                 "Failed to create server socket", result);
           }
           if (port != 0) socket.localPort = port;
           return socket;
         });
   }
 
   _NativeSocket.normal() : typeFlags = TYPE_NORMAL_SOCKET {
@@ skipping 273 matching lines @@
     if (enabled is! bool) throw new ArgumentError(enabled);
     return nativeSetOption(option._value, enabled);
   }
 
   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)
+  nativeCreateBindListen(List<int> addr, int port, int backlog, bool v6Only)
       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";
 
   static SendPort newServicePort() native "Socket_NewServicePort";
 }
 
 
 class _RawServerSocket extends Stream<RawSocket>
                        implements RawServerSocket {
   final _NativeSocket _socket;
   StreamController<RawSocket> _controller;
 
   static Future<_RawServerSocket> bind(address,
                                        int port,
-                                       int backlog) {
+                                       int backlog,
+                                       bool v6Only) {
     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)
+    return _NativeSocket.bind(address, port, backlog, v6Only)
         .then((socket) => new _RawServerSocket(socket));
   }
 
   _RawServerSocket(this._socket) {
     _controller = new StreamController(
         onListen: _onSubscriptionStateChange,
         onCancel: _onSubscriptionStateChange,
         onPause: _onPauseStateChange,
         onResume: _onPauseStateChange);
     _socket.closeFuture.then((_) => _controller.close());
@@ skipping 32 matching lines @@
     _socket.setListening(read: true, write: false);
   }
 
   void _onSubscriptionStateChange() {
     if (_controller.hasListener) {
       _resume();
     } else {
       close();
     }
   }
+
   void _onPauseStateChange() {
     if (_controller.isPaused) {
       _pause();
     } else {
       _resume();
     }
   }
 }
 
 
@@ skipping 117 matching lines @@
     } else {
       close();
     }
   }
 }
 
 
 patch class ServerSocket {
   /* patch */ static Future<ServerSocket> bind(address,
                                                int port,
-                                               {int backlog: 0}) {
-    return _ServerSocket.bind(address, port, backlog);
+                                               {int backlog: 0,
+                                                bool v6Only: false}) {
+    return _ServerSocket.bind(address, port, backlog, v6Only);
   }
 }
 
 class _ServerSocket extends Stream<Socket>
                     implements ServerSocket {
   final _socket;
 
   static Future<_ServerSocket> bind(address,
                                     int port,
-                                    int backlog) {
-    return _RawServerSocket.bind(address, port, backlog)
+                                    int backlog,
+                                    bool v6Only) {
+    return _RawServerSocket.bind(address, port, backlog, v6Only)
         .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 323 matching lines @@
     _raw.onBadCertificate = callback;
   }
 
   X509Certificate get peerCertificate {
     if (_raw == null) {
      throw new StateError("peerCertificate called on destroyed SecureSocket");
     }
     return _raw.peerCertificate;
   }
 }