Revert "Introduce optional 'bool shared' parameter to ServerSocket.bind() ..."

dart/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,
-                                                   bool shared: false}) {
-    return _RawServerSocket.bind(address, port, backlog, v6Only, shared);
+                                                   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 431 matching lines @@
             }
           }
           connectNext();
           return completer.future;
         });
   }
 
   static Future<_NativeSocket> bind(host,
                                     int port,
                                     int backlog,
-                                    bool v6Only,
-                                    bool shared) {
+                                    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 lookup: '$host'");
                 }
                 return list[0];
               });
         })
         .then((address) {
           var socket = new _NativeSocket.listen();
           socket.address = address;
-
           var result = socket.nativeCreateBindListen(address._in_addr,
                                                      port,
                                                      backlog,
-                                                     v6Only,
-                                                     shared);
+                                                     v6Only);
           if (result is OSError) {
             throw new SocketException("Failed to create server socket",
                                       osError: result,
                                       address: address,
                                       port: port);
           }
           if (port != 0) socket.localPort = port;
           socket.connectToEventHandler();
           return socket;
         });
@@ skipping 25 matching lines @@
           if (port != 0) socket.localPort = port;
           return socket;
         });
   }
 
   _NativeSocket.datagram(this.address)
     : typeFlags = TYPE_NORMAL_SOCKET | TYPE_UDP_SOCKET;
 
   _NativeSocket.normal() : typeFlags = TYPE_NORMAL_SOCKET | TYPE_TCP_SOCKET;
 
-  _NativeSocket.listen() : typeFlags = TYPE_LISTENING_SOCKET | TYPE_TCP_SOCKET {
-    isClosedWrite = true;
-  }
+  _NativeSocket.listen() :  typeFlags = TYPE_LISTENING_SOCKET | TYPE_TCP_SOCKET;
 
   _NativeSocket.pipe() : typeFlags = TYPE_PIPE;
 
   _NativeSocket.watch(int id)
       : typeFlags = TYPE_NORMAL_SOCKET | TYPE_INTERNAL_SOCKET {
     isClosedWrite = true;
     nativeSetSocketId(id);
   }
 
   bool get isListening => (typeFlags & TYPE_LISTENING_SOCKET) != 0;
@@ skipping 569 matching lines @@
   nativeAvailable() native "Socket_Available";
   nativeRead(int len) native "Socket_Read";
   nativeRecvFrom() native "Socket_RecvFrom";
   nativeWrite(List<int> buffer, int offset, int bytes)
       native "Socket_WriteList";
   nativeSendTo(List<int> buffer, int offset, int bytes,
                List<int> address, int port)
       native "Socket_SendTo";
   nativeCreateConnect(List<int> addr,
                       int port) native "Socket_CreateConnect";
-  nativeCreateBindListen(List<int> addr, int port, int backlog, bool v6Only,
-                         bool shared)
+  nativeCreateBindListen(List<int> addr, int port, int backlog, bool v6Only)
       native "ServerSocket_CreateBindListen";
   nativeCreateBindDatagram(List<int> addr, int port, bool reuseAddress)
       native "Socket_CreateBindDatagram";
   nativeAccept(_NativeSocket socket) native "ServerSocket_Accept";
   int nativeGetPort() native "Socket_GetPort";
   List nativeGetRemotePeer() native "Socket_GetRemotePeer";
   int nativeGetSocketId() native "Socket_GetSocketId";
   OSError nativeGetError() native "Socket_GetError";
   nativeGetOption(int option, int protocol) native "Socket_GetOption";
   bool nativeSetOption(int option, int protocol, value)
       native "Socket_SetOption";
   bool nativeJoinMulticast(
       List<int> addr, List<int> interfaceAddr, int interfaceIndex)
           native "Socket_JoinMulticast";
   bool nativeLeaveMulticast(
       List<int> addr, List<int> interfaceAddr, int interfaceIndex)
       native "Socket_LeaveMulticast";
-  bool _nativeMarkSocketAsSharedHack()
-      native "Socket_MarkSocketAsSharedHack";
 }
 
 
 class _RawServerSocket extends Stream<RawSocket>
                        implements RawServerSocket {
   final _NativeSocket _socket;
   StreamController<RawSocket> _controller;
   ReceivePort _referencePort;
-  bool _v6Only;
 
   static Future<_RawServerSocket> bind(address,
                                        int port,
                                        int backlog,
-                                       bool v6Only,
-                                       bool shared) {
+                                       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, v6Only, shared)
-        .then((socket) => new _RawServerSocket(socket, v6Only));
+    return _NativeSocket.bind(address, port, backlog, v6Only)
+        .then((socket) => new _RawServerSocket(socket));
   }
 
-  _RawServerSocket(this._socket, this._v6Only);
+  _RawServerSocket(this._socket);
 
   StreamSubscription<RawSocket> listen(void onData(RawSocket event),
                                        {Function onError,
                                         void onDone(),
                                         bool cancelOnError}) {
     if (_controller != null) {
       throw new StateError("Stream was already listened to");
     }
     var zone = Zone.current;
     _controller = new StreamController(sync: true,
@@ skipping 61 matching lines @@
   void _onPauseStateChange() {
     if (_controller.isPaused) {
       _pause();
     } else {
       _resume();
     }
   }
 
   RawServerSocketReference get reference {
     if (_referencePort == null) {
-      bool successfull = _socket._nativeMarkSocketAsSharedHack();
       _referencePort = new ReceivePort();
       _referencePort.listen((sendPort) {
         sendPort.send(
-          [_socket.address,
-           _socket.port,
-           _v6Only]);
+          [_socket.nativeGetSocketId(),
+           _socket.address,
+           _socket.localPort]);
       });
     }
     return new _RawServerSocketReference(_referencePort.sendPort);
   }
 
   Map _toJSON(bool ref) => _socket._toJSON(ref);
-
   void set _owner(owner) { _socket.owner = owner; }
 }
 
 
 class _RawServerSocketReference implements RawServerSocketReference {
   final SendPort _sendPort;
 
   _RawServerSocketReference(this._sendPort);
 
   Future<RawServerSocket> create() {
     var port = new ReceivePort();
     _sendPort.send(port.sendPort);
-    return port.first.then((List args) {
+    return port.first.then((args) {
       port.close();
-
-      InternetAddress address = args[0];
-      int tcpPort = args[1];
-      bool v6Only = args[2];
-      return
-          RawServerSocket.bind(address, tcpPort, v6Only: v6Only, shared: true);
+      var native = new _NativeSocket.listen();
+      native.nativeSetSocketId(args[0]);
+      native.address = args[1];
+      native.localPort = args[2];
+      return new _RawServerSocket(native);
     });
   }
 
   int get hashCode => _sendPort.hashCode;
 
   bool operator==(Object other)
-      => other is _RawServerSocketReference && _sendPort == other._sendPort;
+    => other is _RawServerSocketReference && _sendPort == other._sendPort;
 }
 
 
 class _RawSocket extends Stream<RawSocketEvent>
                  implements RawSocket {
   final _NativeSocket _socket;
   StreamController<RawSocketEvent> _controller;
   bool _readEventsEnabled = true;
   bool _writeEventsEnabled = true;
 
@@ skipping 138 matching lines @@
 
   Map _toJSON(bool ref) => _socket._toJSON(ref);
   void set _owner(owner) { _socket.owner = owner; }
 }
 
 
 patch class ServerSocket {
   /* patch */ static Future<ServerSocket> bind(address,
                                                int port,
                                                {int backlog: 0,
-                                                bool v6Only: false,
-                                                bool shared: false}) {
-    return _ServerSocket.bind(address, port, backlog, v6Only, shared);
+                                                bool v6Only: false}) {
+    return _ServerSocket.bind(address, port, backlog, v6Only);
   }
 }
 
 
 class _ServerSocketReference implements ServerSocketReference {
   final RawServerSocketReference _rawReference;
 
   _ServerSocketReference(this._rawReference);
 
   Future<ServerSocket> create() {
     return _rawReference.create().then((raw) => new _ServerSocket(raw));
   }
 }
 
 
 class _ServerSocket extends Stream<Socket>
                     implements ServerSocket {
   final _socket;
 
   static Future<_ServerSocket> bind(address,
                                     int port,
                                     int backlog,
-                                    bool v6Only,
-                                    bool shared) {
-    return _RawServerSocket.bind(address, port, backlog, v6Only, shared)
+                                    bool v6Only) {
+    return _RawServerSocket.bind(address, port, backlog, v6Only)
         .then((socket) => new _ServerSocket(socket));
   }
 
   _ServerSocket(this._socket);
 
   StreamSubscription<Socket> listen(void onData(Socket event),
                                     {Function onError,
                                      void onDone(),
                                      bool cancelOnError}) {
     return _socket.map((rawSocket) => new _Socket(rawSocket)).listen(
         onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: cancelOnError);
   }
 
   int get port => _socket.port;
 
   InternetAddress get address => _socket.address;
 
   Future close() => _socket.close().then((_) => this);
 
   ServerSocketReference get reference {
     return new _ServerSocketReference(_socket.reference);
   }
 
   Map _toJSON(bool ref) => _socket._toJSON(ref);
-
   void set _owner(owner) { _socket._owner = owner; }
 }
 
 
 patch class Socket {
   /* patch */ static Future<Socket> connect(host, int port) {
     return RawSocket.connect(host, port).then(
         (socket) => new _Socket(socket));
   }
 }
@@ skipping 435 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();