Add Socket ref to HttpServer.

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 314 matching lines @@
   static String toJSON() {
     try {
       return generateResponse();
     } catch (e, s) {
       return '{"type":"Error","text":"$e","stacktrace":"$s"}';
     }
   }
 }
 
 
+// The NativeFieldWrapperClass1 can not be used with a mixin, due to missing
+// implicit constructor.
+class _NativeSocketNativeWrapper extends NativeFieldWrapperClass1 {}
+
+
 // The _NativeSocket class encapsulates an OS socket.
-class _NativeSocket extends NativeFieldWrapperClass1 {
+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
   // eventhandler. Additional flags are used to communicate other
   // information.
   static const int READ_EVENT = 0;
@@ skipping 39 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;
 
+  // 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();
 
   // Handlers and receive port for socket events from the event handler.
   final List eventHandlers = new List(EVENT_COUNT + 1);
   RawReceivePort eventPort;
@@ skipping 187 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;
+  _NativeSocket.listen() : super(), 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 322 matching lines @@
   void sendToEventHandler(int data) {
     assert(!isClosing);
     connectToEventHandler();
     _EventHandler._sendData(this, eventPort, data);
   }
 
   void connectToEventHandler() {
     assert(!isClosed);
     if (eventPort == null) {
       eventPort = new RawReceivePort(multiplex);
-      _SocketsObservatory.add(this);
+      _sockets[_serviceId] = this;
     }
   }
 
   void disconnectFromEventHandler() {
     assert(eventPort != null);
     eventPort.close();
     eventPort = null;
-    _SocketsObservatory.remove(this);
+    _sockets.remove(_serviceId);
   }
 
   // Check whether this is an error response from a native port call.
   static bool isErrorResponse(response) {
     return response is List && response[0] != _SUCCESS_RESPONSE;
   }
 
   // Create the appropriate error/exception from different returned
   // error objects.
   static createError(error,
@@ skipping 81 matching lines @@
   void leaveMulticast(InternetAddress addr, NetworkInterface interface) {
     var interfaceAddr = multicastAddress(addr, interface);
     var interfaceIndex = interface == null ? 0 : interface.index;
     var result = nativeLeaveMulticast(
         addr._in_addr,
         interfaceAddr == null ? null : interfaceAddr._in_addr,
         interfaceIndex);
     if (result is OSError) throw result;
   }
 
+  String get _serviceTypePath => 'io/socket';
+  String get _serviceTypeName => 'Socket';
+
+  Map _toJSON(bool ref) {
+    var r = {
+      'id': _servicePath,
+      'type': _serviceType(ref),
+      'name': '${address.host}:$port',
+      'user_name': '${address.host}:$port',
+    };
+    if (ref) {
+      return r;
+    }
+    r['port'] = port;
+    r['address'] = address.host;
+    return r;
+  }
+
   void nativeSetSocketId(int id) native "Socket_SetSocketId";
   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,
@@ skipping 112 matching lines @@
       _referencePort = new ReceivePort();
       _referencePort.listen((sendPort) {
         sendPort.send(
           [_socket.nativeGetSocketId(),
            _socket.address,
            _socket.localPort]);
       });
     }
     return new _RawServerSocketReference(_referencePort.sendPort);
   }
+
+  Map _toJSON(bool ref) => _socket._toJSON(ref);
 }
 
 
 class _RawServerSocketReference implements RawServerSocketReference {
   final SendPort _sendPort;
 
   _RawServerSocketReference(this._sendPort);
 
   Future<RawServerSocket> create() {
     var port = new ReceivePort();
@@ skipping 211 matching lines @@
 
   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);
 }
 
 
 patch class Socket {
   /* patch */ static Future<Socket> connect(host, int port) {
     return RawSocket.connect(host, port).then(
         (socket) => new _Socket(socket));
   }
 }
 
@@ skipping 430 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();