Add close to input stream and cleanup socket and streams

runtime/bin/socket_impl.dart

Index: runtime/bin/socket_impl.dart
diff --git a/runtime/bin/socket_impl.dart b/runtime/bin/socket_impl.dart
index c269a88f8f7415af18c4126c45a93fe79c97e46d..8d1ddce3cc6e81ab3bbf0b4c0ebabaedc350f545 100644
--- a/runtime/bin/socket_impl.dart
+++ b/runtime/bin/socket_impl.dart
@@ -352,28 +352,39 @@ class _Socket extends _SocketBase implements Socket {
   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;
@@ -381,14 +392,55 @@ class _Socket extends _SocketBase implements Socket {
 
   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;
 }