Fix SecureSocket bug where socket was not closed after all data was flushed.

sdk/lib/io/secure_socket.dart

 // Copyright (c) 2012, 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.
 
 /**
  * SecureSocket provides a secure (SSL or TLS) client connection to a server.
  * The certificate provided by the server is checked
  * using the certificate database provided in setCertificateDatabase.
  */
 abstract class SecureSocket implements Socket {
@@ skipping 200 matching lines @@
       _outputStream = new _SocketOutputStream(this);
     }
     return _outputStream;
   }
 
   int available() {
     throw new UnimplementedError("SecureSocket.available not implemented yet");
   }
 
   void close([bool halfClose = false]) {
+    if (_status == CLOSED) return;
     if (halfClose) {
       _closedWrite = true;
       _writeEncryptedData();
       if (_filterWriteEmpty) {
         _socket.close(true);
         _socketClosedWrite = true;
+        if (_closedRead) {
+          close(false);
+        }
       }
     } else {
       _closedWrite = true;
       _closedRead = true;
       _socket.close(false);
       _socketClosedWrite = true;
       _socketClosedRead = true;
       _secureFilter.destroy();
       _secureFilter = null;
       if (scheduledDataEvent != null) {
@@ skipping 84 matching lines @@
   void _secureConnectHandler() {
     _connectPending = true;
     _secureFilter.connect(_host, _port, _is_server, _certificateName);
     _status = HANDSHAKE;
     _secureHandshake();
   }
 
   void _secureWriteHandler() {
     _writeEncryptedData();
     if (_filterWriteEmpty && _closedWrite && !_socketClosedWrite) {
-      _socket.close(true);
-      _sockedClosedWrite = true;
+      close(true);
     }
     if (_status == HANDSHAKE) {
       _secureHandshake();
     } else if (_status == CONNECTED &&
                _socketWriteHandler != null &&
                _secureFilter.buffers[WRITE_PLAINTEXT].free > 0) {
       // We must be able to set onWrite from the onWrite callback.
       var handler = _socketWriteHandler;
       // Reset the one-shot handler.
       _socketWriteHandler = null;
@@ skipping 13 matching lines @@
       } catch (e) { _reportError(e, "SecureSocket error"); }
       if (!_filterReadEmpty) {
         // Call the onData event.
         if (scheduledDataEvent != null) {
           scheduledDataEvent.cancel();
           scheduledDataEvent = null;
         }
         if (_socketDataHandler != null) {
           _socketDataHandler();
         }
+      } else if (_socketClosedRead) {
+        _secureCloseHandler();
       }
     }
   }
 
   void _secureErrorHandler(e) {
     _reportError(e, 'Error on underlying Socket');
   }
 
   void _reportError(error, String message) {
     // TODO(whesse): Call _reportError from all internal functions that throw.
@@ skipping 14 matching lines @@
     if (_inputStream != null) {
       reported = reported || _inputStream._onSocketError(e);
     }
     if (_outputStream != null) {
       reported = reported || _outputStream._onSocketError(e);
     }
     if (!reported) throw e;
   }
 
   void _secureCloseHandler() {
+    if (_closedRead) return;
     _socketClosedRead = true;
     if (_filterReadEmpty) {
       _closedRead = true;
-      _fireCloseEvent();
+      if (scheduledDataEvent != null) {
+        scheduledDataEvent.cancel();
+      }
+      if (_socketCloseHandler != null) {
+        _socketCloseHandler();
+      }
       if (_socketClosedWrite) {
-        _secureFilter.destroy();
-        _secureFilter = null;
-        _status = CLOSED;
+        close(false);
       }
     }
   }
 
   void _secureHandshake() {
     _readEncryptedData();
     _secureFilter.handshake();
     _writeEncryptedData();
     if (_secureFilter.buffers[WRITE_ENCRYPTED].length > 0) {
       _socket.onWrite = _secureWriteHandler;
     }
   }
 
   void _secureHandshakeCompleteHandler() {
     _status = CONNECTED;
     if (_connectPending && _socketConnectHandler != null) {
       _connectPending = false;
       _socketConnectHandler();
     }
     if (_socketWriteHandler != null) {
       _socket.onWrite = _secureWriteHandler;
     }
   }
 
   // True if the underlying socket is closed, the filter has been emptied of
   // all data, and the close event has been fired.
-  get _closed => _socketClosed && !_fireCloseEventPending;
-
-  void _fireCloseEvent() {
-    if (scheduledDataEvent != null) {
-      scheduledDataEvent.cancel();
-    }
-    if (_socketCloseHandler != null) {
-      _socketCloseHandler();
-    }
-  }
+  get _closed => _socketClosed;
 
   void _readEncryptedData() {
     // Read from the socket, and push it through the filter as far as
     // possible.
     var encrypted = _secureFilter.buffers[READ_ENCRYPTED];
     var plaintext = _secureFilter.buffers[READ_PLAINTEXT];
     bool progress = true;
     while (progress) {
       progress = false;
       // Do not try to read plaintext from the filter while handshaking.
@@ skipping 88 matching lines @@
       // _closedRead is false, since we are in a read or readList call.
       if (!_filterReadEmpty) {
         // _filterReadEmpty may be out of date since read and readList empty
         // the plaintext buffer after calling _readEncryptedData.
         // TODO(whesse): Fix this as part of fixing read and readList.
         _readEncryptedData();
       }
       if (_filterReadEmpty) {
         // This can't be an else clause: the value of _filterReadEmpty changes.
         // This must be asynchronous, because we are in a read or readList call.
-        new Timer(0, (_) => _fireCloseEvent());
+        new Timer(0, (_) => _secureCloseHandler());
       }
     }
   }
 
   bool get _socketClosed => _closedRead;
 
   // _SecureSocket cannot extend _Socket and use _Socket's factory constructor.
   Socket _socket;
   String _host;
   int _port;
@@ skipping 51 matching lines @@
                String certificateName);
   void destroy();
   void handshake();
   void init();
   int processBuffer(int bufferIndex);
   void registerBadCertificateCallback(Function callback);
   void registerHandshakeCompleteCallback(Function handshakeCompleteHandler);
 
   List<_ExternalBuffer> get buffers;
 }