Add close to input stream and cleanup socket and streams

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 {
   // 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
@@ skipping 334 matching lines @@
     var errorHandler = _handlerMap[_ERROR_EVENT];
     if (errorHandler != null) {
       errorHandler();
       _setHandler(_ERROR_EVENT, null);
     }
   }
 
   bool _createConnect(String host, int port) native "Socket_CreateConnect";
 
   void set writeHandler(void callback()) {
-    _setHandler(_OUT_EVENT, callback);
+    if (_outputStream != null) throw new StreamException("Illegal state");

[Mads Ager (google), 2011/12/23 08:35:40]

An error message that gave the programmer more help figuring out what is wrong
would be nice for all of these 'illegal state' exceptions.

[Søren Gjesse, 2012/01/02 11:51:17]

Done.

+    _clientWriteHandler = callback;
+    _updateOutHandler();
   }
 
   void set connectHandler(void callback()) {
-    // TODO(ager): Make sure that write handler and connect handler do
-    // not compete for the out events.
-    _setHandler(_OUT_EVENT, callback);
+    if (_seenFirstOutEvent || _outputStream != null) {
+      throw new StreamException("Illegal state");
+    }
+    _clientConnectHandler = callback;
+    _updateOutHandler();
   }
 
   void set dataHandler(void callback()) {
-    _setHandler(_IN_EVENT, callback);
+    if (_inputStream != null) throw new StreamException("Illegal state");
+    _dataHandler = callback;
   }
 
   void set closeHandler(void callback()) {
-    _setHandler(_CLOSE_EVENT, callback);
+    if (_inputStream != null) throw new StreamException("Illegal state");
+    _closeHandler = callback;
   }
 
   bool _isListenSocket() => false;
+
   bool _isPipe() => _pipe;
 
   InputStream get inputStream() {
     if (_inputStream === null) {
+      if (_handlerMap[_IN_EVENT] !== null ||
+          _handlerMap[_CLOSE_EVENT]) {
+        throw new StreamException("Illegal state");
+      }
       _inputStream = new SocketInputStream(this);
     }
     return _inputStream;
   }
 
   OutputStream get outputStream() {
     if (_outputStream === null) {
+      if (_handlerMap[_OUT_EVENT] !== null) {
+        throw new StreamException("Illegal state");
+      }
       _outputStream = new SocketOutputStream(this);
     }
     return _outputStream;
   }
 
+  void set _writeHandler(void callback()) {
+    _setHandler(_OUT_EVENT, callback);
+  }
+
+  void set _dataHandler(void callback()) {
+    _setHandler(_IN_EVENT, callback);
+  }
+
+  void set _closeHandler(void callback()) {
+    _setHandler(_CLOSE_EVENT, callback);
+  }
+
+  void _updateOutHandler() {
+    void writeHandler() {
+      if (!_seenFirstOutEvent) {
+        // First out event is socket connected event.
+        _seenFirstOutEvent = true;
+        var connectHandler = _clientConnectHandler;
+        _clientConnectHandler = null;
+        if (_clientWriteHandler === null) _writeHandler = null;

[Mads Ager (google), 2011/12/23 08:35:40]

Can't we just unconditionally do '_writeHandler = _clientWriteHandler' here? No
reason the keep checking for the first out event when we have just received it?

Maybe we should even move that to the first line of writeHandler before the
check on first out event. Once writeHandler has been called once there is no
need to check for first out event again?

[Søren Gjesse, 2012/01/02 11:51:17]

Good point. Refactored to only use this write handler for the first out event.
After that the write handler is always set to the _clientWriteHandler.

+        if (connectHandler !== null) connectHandler();
+      }
+
+      // Always (even for the first out event) call the write handler.
+      if (_clientWriteHandler !== null) _clientWriteHandler();
+    }
+
+    if (_clientConnectHandler === null && _clientWriteHandler === null) {
+      _writeHandler = null;
+    } else {
+      _writeHandler = writeHandler;
+    }
+  }
+
+
+  bool _seenFirstOutEvent = false;
   bool _closedRead = false;
   bool _closedWrite = false;
   bool _pipe = false;
+  Function _clientConnectHandler;
+  Function _clientWriteHandler;
   SocketInputStream _inputStream;
   SocketOutputStream _outputStream;
 }