Explicitly handle listen sockets and connection sockets differently in Linux and Mac OS eventhandler

runtime/bin/socket_impl.dart

 // Copyright (c) 2011, 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 {
-
-  /*
-   * Keep these constants in sync with the native poll event identifiers.
-   */
+  // 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 final int _IN_EVENT = 0;
   static final int _OUT_EVENT = 1;
   static final int _ERROR_EVENT = 2;
   static final int _CLOSE_EVENT = 3;
+
+  static final int _CLOSE_COMMAND = 8;
+
+  // Flag send to the eventhandler saying that the file descriptor in
+  // question represents a listening socket.
+  static final int _LISTENING_SOCKET = 16;
+
   static final int _FIRST_EVENT = _IN_EVENT;
   static final int _LAST_EVENT = _CLOSE_EVENT;
 
-  static final int _CLOSE_COMMAND = 4;
-
   _SocketBase () {
     _handler = new ReceivePort();
     _handlerMap = new List(_CLOSE_EVENT + 1);
     _handlerMask = 0;
     _canActivateHandlers = true;
     _id = -1;
     _handler.receive((var message, ignored) {
       _multiplex(message);
     });
     EventHandler._start();
@@ skipping 35 matching lines @@
   }
 
   void _getPort() native "Socket_GetPort";
 
   void setErrorHandler(void callback()) {
     _setHandler(_ERROR_EVENT, callback);
   }
 
   void _doActivateHandlers() {
     if (_canActivateHandlers && (_id >= 0)) {
-      EventHandler._sendData(_id, _handler, _handlerMask);
+      int data = _handlerMask;
+      if (_isListenSocket()) data |= (1 << _LISTENING_SOCKET);
+      EventHandler._sendData(_id, _handler, data);
     }
   }
 
   void _scheduleEvent(int event) {
     _handler.toSendPort().send([1 << event], null);
   }
 
   int get port() {
     if (_port === null) {
       _port = _getPort();
@@ skipping 13 matching lines @@
       if (_handler === null) {
         throw new
             SocketIOException("Error: close failed - invalid socket handle");
       } else {
         _handler.close();
         _handler = null;
       }
     }
   }
 
+  abstract bool _isListenSocket();
 
   /*
    * Socket id is set from native. -1 indicates that the socket was closed.
    */
   int _id;
 
   /*
    * Dedicated ReceivePort for socket events.
    */
   ReceivePort _handler;
@@ skipping 54 matching lines @@
   }
 
   bool _accept(Socket socket) native "ServerSocket_Accept";
 
   bool _createBindListen(String bindAddress, int port, int backlog)
       native "ServerSocket_CreateBindListen";
 
   void setConnectionHandler(void callback()) {
     _setHandler(_IN_EVENT, callback);
   }
+
+  bool _isListenSocket() => true;
 }
 
 
 class _Socket extends _SocketBase implements Socket {
   /*
    * Constructor for socket. First a socket object is allocated
    * in which the native socket is stored. After that _createConnect is
    * called which creates a file discriptor and connects to the given
    * host on the given port. Null is returned if file descriptor creation
    * or connect failsed
@@ skipping 75 matching lines @@
   }
 
   void setDataHandler(void callback()) {
     _setHandler(_IN_EVENT, callback);
   }
 
   void setCloseHandler(void callback()) {
     _setHandler(_CLOSE_EVENT, callback);
   }
 
+  bool _isListenSocket() => false;
+
   InputStream get inputStream() {
     if (_inputStream === null) {
       _inputStream = new SocketInputStream(this);
     }
     return _inputStream;
   }
 
   OutputStream get outputStream() {
     if (_outputStream === null) {
       _outputStream = new SocketOutputStream(this);
     }
     return _outputStream;
   }
 
   SocketInputStream _inputStream;
   SocketOutputStream _outputStream;
 }