Change the handling of closing sockets

runtime/bin/socket_stream.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 SocketInputStream implements InputStream {
   SocketInputStream(Socket socket) {
     _socket = socket;
   }
 
   List<int> read([int len]) {
@@ skipping 18 matching lines @@
   }
 
   int readInto(List<int> buffer, int offset, int len) {
     if (offset === null) offset = 0;
     if (len === null) len = buffer.length;
     if (offset < 0) throw new StreamException("Illegal offset $offset");
     if (len < 0) throw new StreamException("Illegal length $len");
     return _socket.readList(buffer, offset, len);
   }
 
-  int available() {
-    return _socket.available();
-  }
+  int available() => _socket.available();
 
   void set dataHandler(void callback()) {
     _socket.dataHandler = callback;
   }
 
   void set closeHandler(void callback()) {
     _socket.closeHandler = callback;
   }
 
   void set errorHandler(void callback()) {
     _socket.errorHandler = callback;
   }
 
   Socket _socket;
 }
 
 
 class _BufferList2 {
   _BufferList2() {
     clear();
   }
 
   // Adds a new buffer to the list possibly with an offset of the
   // first byte of interest. The offset can only be specified if the
   // buffer list is empty.
   void add(List<int> buffer, [int offset = 0]) {
     assert(offset == 0 || _buffers.isEmpty());
     _buffers.addLast(buffer);
-    _length += buffer.length;
+    _length += buffer.length - offset;
     if (offset != 0) _index = offset;
   }
 
   List<int> get first() => _buffers.first();
   int get index() => _index;
 
   void removeBytes(int count) {
     int firstRemaining = first.length - _index;
     assert(count <= firstRemaining);
     if (count == firstRemaining) {
@@ skipping 29 matching lines @@
   }
 
   bool write(List<int> buffer) {
     return _write(buffer, 0, buffer.length, false);
   }
 
   bool writeFrom(List<int> buffer, [int offset = 0, int len]) {
     return _write(buffer, offset, (len == null) ? buffer.length : len, true);
   }
 
-  void end() {
-    if (_ending || _ended) throw new StreamException("Stream ended");
-    _ending = true;
-    if (_pendingWrites.isEmpty()) {
-      close();
+  void close() {
+    if (!_pendingWrites.isEmpty()) {
+      // Mark the socket for close when all data is written.
+      _closing = true;
+      _socket.writeHandler = _writeHandler;
+    } else {
+      // Close the socket for writing.
+      _socket._closeWrite();
+      _closed = true;
     }
   }
 
-  void close() {
+  void destroy() {
     _socket.writeHandler = null;
     _pendingWrites.clear();
     _socket.close();
-    _ended = true;
+    _closed = true;
   }
 
   void set noPendingWriteHandler(void callback()) {
     _noPendingWriteHandler = callback;
     _socket.writeHandler = _writeHandler;
   }
 
   void set closeHandler(void callback()) {
     _socket.closeHandler = callback;
   }
 
   void set errorHandler(void callback()) {
     _streamErrorHandler = callback;
   }
 
   bool _write(List<int> buffer, int offset, int len, bool copyBuffer) {
-    if (_ending || _ended) throw new StreamException("Stream ended");
+    if (_closing || _closed) throw new StreamException("Stream closed");
     if (len == null) len = buffer.length;
     int bytesWritten = 0;
     if (_pendingWrites.isEmpty()) {
       // If nothing is buffered write as much as possible and buffer
       // the rest.
       bytesWritten = _socket.writeList(buffer, offset, len);
       if (bytesWritten == len) return true;
     }
 
     // Place remaining data on the pending writes queue.
     if (copyBuffer) {
       List<int> newBuffer =
           buffer.getRange(offset + bytesWritten, buffer.length);
       _pendingWrites.add(newBuffer);
     } else {
       _pendingWrites.add(buffer, bytesWritten);
     }
   }
 
   void _writeHandler() {
-    _socket.writeHandler = _writeHandler;
     // Write as much buffered data to the socket as possible.
     while (!_pendingWrites.isEmpty()) {
       List<int> buffer = _pendingWrites.first;
       int offset = _pendingWrites.index;
       int bytesToWrite = buffer.length - offset;
       int bytesWritten = _socket.writeList(buffer, offset, bytesToWrite);
       _pendingWrites.removeBytes(bytesWritten);
-      if (bytesWritten < bytesToWrite) return;
+      if (bytesWritten < bytesToWrite) {
+        _socket.writeHandler = _writeHandler;
+        return;
+      }
     }
 
     // All buffered data was written.
-    if (_ending) {
-      _socket.close();
-      _ended = true;
+    if (_closing) {
+      _socket._closeWrite();
+      _closed = true;
     } else {
       if (_noPendingWriteHandler != null) _noPendingWriteHandler();
     }
   }
 
   void _errorHandler() {
     close();
     if (_streamErrorHandler != null) _streamErrorHandler();
   }
 
   Socket _socket;
   _BufferList2 _pendingWrites;
-  bool _ending = false;
-  bool _ended = false;
   var _noPendingWriteHandler;
   var _streamErrorHandler;
+  bool _closing = false;
+  bool _closed = false;
 }