Add 'owner' field to sockets, that point to a potential IO resource using that Socket.

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 418 matching lines @@
   bool readEventIssued = false;
 
   bool sendWriteEvents = false;
   bool writeEventIssued = false;
   bool writeAvailable = false;
 
   // Statistics.
   int totalRead = 0;
   int totalWritten = 0;
 
+  // The owner object is the object that the Socket is being used by, e.g.
+  // a HttpServer, a WebSocket connection, a process pipe, etc.
+  Object owner;
+
   static Future<List<InternetAddress>> lookup(
       String host, {InternetAddressType type: InternetAddressType.ANY}) {
     return _IOService.dispatch(_SOCKET_LOOKUP, [host, type._value])
         .then((response) {
           if (isErrorResponse(response)) {
             throw createError(response, "Failed host lookup: '$host'");
           } else {
             return response.skip(1).map((result) {
               var type = new InternetAddressType._from(result[0]);
               return new _InternetAddress(result[1], host, result[2]);
@@ skipping 504 matching lines @@
       eventPort = new RawReceivePort(multiplex);
       _sockets[_serviceId] = this;
     }
   }
 
   void disconnectFromEventHandler() {
     assert(eventPort != null);
     eventPort.close();
     eventPort = null;
     _sockets.remove(_serviceId);
+    // Now that we don't track this Socket anymore, we can clear the owner
+    // field.
+    owner = null;
   }
 
   // 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 99 matching lines @@
       'type': _serviceType(ref),
       'name': name,
       'user_name': name,
     };
     if (ref) {
       return r;
     }
     r['port'] = port;
     r['address'] = address.host;
     r['fd'] = nativeGetSocketId();
+    if (owner != null) {
+      r['owner'] = owner._toJSON(true);
+    }
     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,
@@ skipping 117 matching lines @@
         sendPort.send(
           [_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();
@@ skipping 155 matching lines @@
 
   void _onSubscriptionStateChange() {
     if (_controller.hasListener) {
       _resume();
     } else {
       _socket.close();
     }
   }
 
   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}) {
     return _ServerSocket.bind(address, port, backlog, v6Only);
   }
@@ skipping 40 matching lines @@
 
   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 278 matching lines @@
       _detachReady.complete(null);
     } else {
       if (_raw != null) {
         _raw.shutdown(SocketDirection.SEND);
         _disableWriteEvent();
       }
     }
   }
 
   Map _toJSON(bool ref) => _raw._toJSON(ref);
+  void set _owner(owner) { _raw._owner = owner; }
 }
 
 
 patch class RawDatagramSocket {
   /* patch */ static Future<RawDatagramSocket> bind(
       host, int port, {bool reuseAddress: true}) {
     return _RawDatagramSocket.bind(host, port, reuseAddress);
   }
 }
 
@@ skipping 135 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();