Add support for cloning server-sockets.

runtime/bin/socket_patch.dart

Index: runtime/bin/socket_patch.dart
diff --git a/runtime/bin/socket_patch.dart b/runtime/bin/socket_patch.dart
index 030a9058cc9409517c0b116b94c071a970be7813..eaba3c3c53e38fb255b2023511f3b823a2ed7353 100644
--- a/runtime/bin/socket_patch.dart
+++ b/runtime/bin/socket_patch.dart
@@ -390,6 +390,9 @@ class _NativeSocket extends NativeFieldWrapperClass1 {
   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;
+
   // Socket close state
   bool isClosed = false;
   bool isClosing = false;
@@ -712,7 +715,7 @@ class _NativeSocket extends NativeFieldWrapperClass1 {
     assert(available > 0);
     available--;
     tokens++;
-    returnTokens();
+    returnTokens(LISTENING_TOKEN_BATCH_SIZE);
     var socket = new _NativeSocket.normal();
     if (nativeAccept(socket) != true) return null;
     socket.localPort = localPort;
@@ -845,14 +848,14 @@ class _NativeSocket extends NativeFieldWrapperClass1 {
     }
     if (!isListening) {
       tokens++;
-      returnTokens();
+      returnTokens(NORMAL_TOKEN_BATCH_SIZE);
     }
   }
 
-  void returnTokens() {
+  void returnTokens(int tokenBatchSize) {
     if (eventPort != null && !isClosing && !isClosed) {
-      if (tokens == 8) {
-        // Return in batches of 8.
+      // Return in batches.
+      if (tokens == tokenBatchSize) {
         assert(tokens < (1 << FIRST_COMMAND));
         sendToEventHandler((1 << RETURN_TOKEN_COMMAND) | tokens);
         tokens = 0;
@@ -1066,6 +1069,7 @@ class _NativeSocket extends NativeFieldWrapperClass1 {
   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)
@@ -1083,6 +1087,7 @@ class _RawServerSocket extends Stream<RawSocket>
                        implements RawServerSocket {
   final _NativeSocket _socket;
   StreamController<RawSocket> _controller;
+  ReceivePort _port;

[Søren Gjesse, 2014/05/06 08:47:39]

Call this variable something less generic, e.g. _referencePort.

[Anders Johnsen, 2014/05/06 12:34:32]

Done.

 
   static Future<_RawServerSocket> bind(address,
                                        int port,
@@ -1123,7 +1128,12 @@ class _RawServerSocket extends Stream<RawSocket>
         _controller.addError(e);
         _controller.close();
       }),
-      destroyed: _controller.close);
+      destroyed: () {
+        _controller.close();
+        if (_port != null) {
+          _port.close();
+        }
+      });
     return _controller.stream.listen(
         onData,
         onError: onError,
@@ -1160,6 +1170,39 @@ class _RawServerSocket extends Stream<RawSocket>
       _resume();
     }
   }
+
+  RawServerSocketReference get reference {
+    if (_port == null) {
+      _port = new ReceivePort();
+      _port.listen((sendPort) {
+        sendPort.send(
+          [_socket.nativeGetSocketId(),
+           _socket.address,
+           _socket.localPort]);
+      });
+    }
+    return new _RawServerSocketReference(_port.sendPort);
+  }
+}
+
+
+class _RawServerSocketReference implements RawServerSocketReference {
+  final SendPort _sendPort;
+
+  _RawServerSocketReference(this._sendPort);
+
+  Future<RawServerSocket> create() {

[Lasse Reichstein Nielsen, 2014/05/06 09:04:20]

I would still prefer to just return a RawServerSocket.

[Anders Johnsen, 2014/05/06 12:34:32]

The problem is that it may return an invalid object. Let's iterate this one some
more.

+    var port = new ReceivePort();

[Lasse Reichstein Nielsen, 2014/05/06 09:04:20]

Consider using a RawReceivePort. It requires you to do more low-level stuff, but
it probably has lower overhead.
On the other hand, this function isn't likely to be performance critical.

[Anders Johnsen, 2014/05/06 12:34:32]

Done.

+    _sendPort.send(port.sendPort);
+    return port.first.then((args) {
+      port.close();
+      var native = new _NativeSocket.listen();
+      native.nativeSetSocketId(args[0]);
+      native.address = args[1];
+      native.localPort = args[2];
+      return new _RawServerSocket(native);
+    });
+  }

[Lasse Reichstein Nielsen, 2014/05/06 09:04:20]

Consider adding:

  int get hashCode => _sendPort.hashCode;
  bool operator==(Object other) 
      => other is _RawServerSocketReference && 
         sendPort == other._sendPort;

[Anders Johnsen, 2014/05/06 12:34:32]

Done.

 }
 
 
@@ -1320,6 +1363,18 @@ patch class ServerSocket {
   }
 }
 
+
+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;
@@ -1350,6 +1405,10 @@ class _ServerSocket extends Stream<Socket>
   InternetAddress get address => _socket.address;
 
   Future close() => _socket.close().then((_) => this);
+
+  ServerSocketReference get reference {
+    return new _ServerSocketReference(_socket.reference);
+  }
 }