Fix secure socket filter after edge-triggering.

sdk/lib/io/secure_socket.dart

 // Copyright (c) 2013, 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.
 
 part of dart.io;
 
 /**
  * A high-level class for communicating securely over a TCP socket, using
  * TLS and SSL. The [SecureSocket] exposes both a [Stream] and an
  * [IOSink] interface, making it ideal for using together with
@@ skipping 877 matching lines @@
       _filterActive = true;
       _filterPending = false;
       _pushAllFilterStages().then((status) {
         _filterStatus = status;
         _filterActive = false;
         if (_status == CLOSED) {
           _secureFilter.destroy();
           _secureFilter = null;
           return;
         }
+        _socket.readEventsEnabled = true;
         if (_filterStatus.writeEmpty && _closedWrite && !_socketClosedWrite) {
           // Checks for and handles all cases of partially closed sockets.
           shutdown(SocketDirection.SEND);
           if (_status == CLOSED) return;
         }
         if (_filterStatus.readEmpty && _socketClosedRead && !_closedRead) {
           if (_status == HANDSHAKE) {
             _secureFilter.handshake();
             if (_status == HANDSHAKE) {
               throw new HandshakeException(
@@ skipping 33 matching lines @@
     } else {
       return null;
     }
   }
 
   void _readSocket() {
     if (_status == CLOSED) return;
     var buffer = _secureFilter.buffers[READ_ENCRYPTED];
     if (buffer.writeFromSource(_readSocketOrBufferedData) > 0) {
       _filterStatus.readEmpty = false;
+    } else {
+      _socket.readEventsEnabled = false;
     }
   }
 
   void _writeSocket() {
     if (_socketClosedWrite) return;
     var buffer = _secureFilter.buffers[WRITE_ENCRYPTED];
     if (buffer.readToSocket(_socket)) {  // Returns true if blocked
       _socket.writeEventsEnabled = true;
     }
   }
@@ skipping 197 matching lines @@
       written += toWrite;
       toWrite = min(bytes - written, linearFree);
     }
     return written;
   }
 
   int writeFromSource(List<int> getData(int requested)) {
     int written = 0;
     int toWrite = linearFree;
     // Loop over zero, one, or two linear data ranges.
-    do {
+    while (toWrite > 0) {
       // Source returns at most toWrite bytes, and it returns null when empty.
       var inputData = getData(toWrite);
       if (inputData == null || inputData.length == 0) break;
       var len = inputData.length;
       data.setRange(end, end + len, inputData);
       advanceEnd(len);
       written += len;
       toWrite = linearFree;
-    } while (toWrite > 0);
+    }
     return written;
   }
 
   bool readToSocket(RawSocket socket) {
     // Loop over zero, one, or two linear data ranges.
     while (true) {
       var toWrite = linearLength;
       if (toWrite == 0) return false;
       int bytes = socket.write(data, start, toWrite);
       advanceStart(bytes);
@@ skipping 77 matching lines @@
 /**
  * An exception that happens in the handshake phase of establishing
  * a secure network connection, when looking up or verifying a
  * certificate.
  */
 class CertificateException extends TlsException {
   const CertificateException([String message = "",
                             OSError osError = null])
      : super._("CertificateException", message, osError);
 }