Use native wrapper fields to store socket ids.

runtime/bin/socket_impl.dart

 // Copyright (c) 2012, 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.
 
 
-class _SocketBase {
+class _SocketBase extends NativeFieldWrapperClass1 {
   // 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 _IN_EVENT = 0;
@@ skipping 13 matching lines @@
   static const int _FIRST_EVENT = _IN_EVENT;
   static const int _LAST_EVENT = _CLOSE_EVENT;
 
   static const int _FIRST_COMMAND = _CLOSE_COMMAND;
   static const int _LAST_COMMAND = _SHUTDOWN_WRITE_COMMAND;
 
   _SocketBase () {
     _handlerMap = new List(_LAST_EVENT + 1);
     _handlerMask = 0;
     _canActivateHandlers = true;
-    _id = -1;
+    _closed = true;

[Søren Gjesse, 2012/09/21 06:47:06]

We could consider making this a state with 3 values INIT, OPEN, CLOSED, instead
of having a socket starting out "closed".

[Mads Ager (google), 2012/09/21 08:18:25]

Yes, we could do that to give better error messages. I'd like to postpone that
until we are done moving these to use native fields.

     _EventHandler._start();
     _hashCode = _nextHashCode;
     _nextHashCode = (_nextHashCode + 1) & 0xFFFFFFF;
   }
 
   // Multiplexes socket events to the socket handlers.
   void _multiplex(int event_mask) {
     _canActivateHandlers = false;
     for (int i = _FIRST_EVENT; i <= _LAST_EVENT; i++) {
       if (((event_mask & (1 << i)) != 0)) {
-        if ((i == _CLOSE_EVENT) && this is _Socket && _id >= 0) {
+        if ((i == _CLOSE_EVENT) && this is _Socket && !_closed) {
           _closedRead = true;
           if (_closedWrite) _close();
         }
 
         var eventHandler = _handlerMap[i];
         if (eventHandler != null || i == _ERROR_EVENT) {
           // Unregister the out handler before executing it.
           if (i == _OUT_EVENT) _setHandler(i, null);
 
           // Don't call the in handler if there is no data available
@@ skipping 35 matching lines @@
   }
 
   OSError _getError() native "Socket_GetError";
   int _getPort() native "Socket_GetPort";
 
   void set onError(void callback(e)) {
     _setHandler(_ERROR_EVENT, callback);
   }
 
   void _activateHandlers() {
-    if (_canActivateHandlers && (_id >= 0)) {
+    if (_canActivateHandlers && !_closed) {
       if (_handlerMask == 0) {
         if (_handler != null) {
           _handler.close();
           _handler = null;
         }
         return;
       }
       int data = _handlerMask;
       if (_isListenSocket()) {
         data |= (1 << _LISTENING_SOCKET);
       } else {
         if (_closedRead) { data &= ~(1 << _IN_EVENT); }
         if (_closedWrite) { data &= ~(1 << _OUT_EVENT); }
         if (_isPipe()) data |= (1 << _PIPE);
       }
       _sendToEventHandler(data);
     }
   }
 
   int get port {
     if (_port === null) {
       _port = _getPort();
     }
     return _port;
   }
 
   void close([bool halfClose = false]) {
-    if (_id >= 0) {
+    if (!_closed) {
       if (halfClose) {
         _closeWrite();
       } else {
         _close();
       }
     } else if (_handler != null) {
       // This is to support closing sockets created but never assigned
       // any actual socket.
       _handler.close();
       _handler = null;
     }
   }
 
   void _closeWrite() {
-    if (_id >= 0) {
+    if (!_closed) {
       if (_closedRead) {
         _close();
       } else {
         _sendToEventHandler(1 << _SHUTDOWN_WRITE_COMMAND);
       }
       _closedWrite = true;
     }
   }
 
   void _closeRead() {
-    if (_id >= 0) {
+    if (!_closed) {
       if (_closedWrite) {
         _close();
       } else {
         _sendToEventHandler(1 << _SHUTDOWN_READ_COMMAND);
       }
       _closedRead = true;
     }
   }
 
   void _close() {
-    if (_id >= 0) {
+    if (!_closed) {
       _sendToEventHandler(1 << _CLOSE_COMMAND);
       _handler.close();
       _handler = null;
-      _id = -1;
+      _closed = true;
     }
   }
 
   void _sendToEventHandler(int data) {
     if (_handler === null) {
       _handler = new ReceivePort();
       _handler.receive((var message, ignored) { _multiplex(message); });
     }
-    assert(_id >= 0);
-    _EventHandler._sendData(_id, _handler, data);
+    assert(!_closed);
+    _EventHandler._sendData(this, _handler, data);
   }
 
   bool _reportError(error, String message) {
     void doReportError(Exception e) {
       // Invoke the socket error callback if any.
       bool reported = false;
       if (_handlerMap[_ERROR_EVENT] != null) {
         _handlerMap[_ERROR_EVENT](e);
         reported = true;
       }
@@ skipping 26 matching lines @@
     }
   }
 
   int hashCode() => _hashCode;
 
   bool _propagateError(Exception e) => false;
 
   abstract bool _isListenSocket();
   abstract bool _isPipe();
 
-  // Socket id is set from native. -1 indicates that the socket was closed.
-  int _id;
+  // Is this socket closed.
+  bool _closed;
 
   // Dedicated ReceivePort for socket events.
   ReceivePort _handler;
 
   // Poll event to handler map.
   List _handlerMap;
 
   // Indicates for which poll events the socket registered handlers.
   int _handlerMask;
 
@@ skipping 17 matching lines @@
   // is called which creates a file descriptor and binds the given address
   // and port to the socket. Null is returned if file descriptor creation or
   // bind failed.
   factory _ServerSocket(String bindAddress, int port, int backlog) {
     _ServerSocket socket = new _ServerSocket._internal();
     var result = socket._createBindListen(bindAddress, port, backlog);
     if (result is OSError) {
       socket.close();
       throw new SocketIOException("Failed to create server socket", result);
     }
+    socket._closed = false;
     assert(result);
     if (port != 0) {
       socket._port = port;
     }
     return socket;
   }
 
   _ServerSocket._internal();
 
   _accept(Socket socket) native "ServerSocket_Accept";
 
   _createBindListen(String bindAddress, int port, int backlog)
       native "ServerSocket_CreateBindListen";
 
   void set onConnection(void callback(Socket connection)) {
     _clientConnectionHandler = callback;
     _setHandler(_SocketBase._IN_EVENT,
                 _clientConnectionHandler != null ? _connectionHandler : null);
   }
 
   void _connectionHandler() {
-    if (_id >= 0) {
+    if (!_closed) {
       _Socket socket = new _Socket._internal();
       var result = _accept(socket);
       if (result is OSError) {
         _reportError(result, "Accept failed");
       } else if (result) {
+        socket._closed = false;
         _clientConnectionHandler(socket);
       } else {
         // Temporary failure accepting the connection. Ignoring
         // temporary failures lets us retry when we wake up with data
         // on the listening socket again.
       }
     }
   }
 
   bool _isListenSocket() => true;
@@ skipping 17 matching lines @@
     request[1] = host;
     _socketService.call(request).then((response) {
       if (socket._isErrorResponse(response)) {
         socket._reportError(response, "Failed host name lookup");
       } else{
         var result = socket._createConnect(response, port);
         if (result is OSError) {
           socket.close();
           socket._reportError(result, "Connection failed");
         } else {
+          socket._closed = false;
           socket._activateHandlers();
         }
       }
     });
     return socket;
   }
 
   _Socket._internal();
   _Socket._internalReadOnly() : _pipe = true { super._closedWrite = true; }
   _Socket._internalWriteOnly() : _pipe = true { super._closedRead = true; }
 
   int available() {
-    if (_id >= 0) {
+    if (!_closed) {
       var result = _available();
       if (result is OSError) {
         _reportError(result, "Available failed");
         return 0;
       } else {
         return result;
       }
     }
     throw new
         SocketIOException("Error: available failed - invalid socket handle");
   }
 
   _available() native "Socket_Available";
 
   int readList(List<int> buffer, int offset, int bytes) {
-    if (_id >= 0) {
+    if (!_closed) {
       if (bytes == 0) {
         return 0;
       }
       if (offset < 0) {
         throw new IndexOutOfRangeException(offset);
       }
       if (bytes < 0) {
         throw new IndexOutOfRangeException(bytes);
       }
       if ((offset + bytes) > buffer.length) {
         throw new IndexOutOfRangeException(offset + bytes);
       }
       var result = _readList(buffer, offset, bytes);
       if (result is OSError) {
         _reportError(result, "Read failed");
         return -1;
       }
       return result;
     }
     throw new
         SocketIOException("Error: readList failed - invalid socket handle");
   }
 
-  _readList(List<int> buffer, int offset, int bytes)
-      native "Socket_ReadList";
+  _readList(List<int> buffer, int offset, int bytes) native "Socket_ReadList";
 
   int writeList(List<int> buffer, int offset, int bytes) {
-    if (_id >= 0) {
+    if (!_closed) {
       if (bytes == 0) {
         return 0;
       }
       if (offset < 0) {
         throw new IndexOutOfRangeException(offset);
       }
       if (bytes < 0) {
         throw new IndexOutOfRangeException(bytes);
       }
       if ((offset + bytes) > buffer.length) {
@@ skipping 182 matching lines @@
   bool _seenFirstOutEvent = false;
   bool _pipe = false;
   Function _clientConnectHandler;
   Function _clientWriteHandler;
   SocketInputStream _inputStream;
   SocketOutputStream _outputStream;
   String _remoteHost;
   int _remotePort;
   static SendPort _socketService;
 }