dart:io | Fix issue 8795, (Raw)SecureSocket loses data when close() is called.

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 265 matching lines @@
                             certificateName,
                             requestClientCertificate ||
                                 requireClientCertificate,
                             requireClientCertificate,
                             sendClientCertificate);
       _status = HANDSHAKE;
       _secureHandshake();
     })
     .catchError((error) {
       _handshakeComplete.completeError(error);
-      close();
+      _close();
     });
   }
 
   StreamSubscription listen(void onData(RawSocketEvent data),
                             {void onError(AsyncError error),
                              void onDone(),
                              bool unsubscribeOnError}) {
     if (_writeEventsEnabled) {
       _writeEventsEnabled = false;
       _controller.add(RawSocketEvent.WRITE);
@@ skipping 37 matching lines @@
 
   int get remotePort => _socket.remotePort;
 
   int available() {
     if (_status != CONNECTED) return 0;
     _readEncryptedData();
     return _secureFilter.buffers[READ_PLAINTEXT].length;
   }
 
   void close() {
+    shutdown(SocketDirection.BOTH);
+  }
+
+  void _close() {
     _closedWrite = true;
     _closedRead = true;
     if (_socket != null) {
       _socket.close();
     }
     _socketClosedWrite = true;
     _socketClosedRead = true;
     if (_secureFilter != null) {
       _secureFilter.destroy();
       _secureFilter = null;
     }
     if (_socketSubscription != null) {
       _socketSubscription.cancel();
     }
     _controller.close();
     _status = CLOSED;
   }
 
   void shutdown(SocketDirection direction) {
-    if (direction == SocketDirection.BOTH) {
-      close();
-    } else if (direction == SocketDirection.SEND) {
+    if (direction == SocketDirection.SEND ||
+        direction == SocketDirection.BOTH) {
       _closedWrite = true;
       _writeEncryptedData();
       if (_filterWriteEmpty) {
         _socket.shutdown(SocketDirection.SEND);
         _socketClosedWrite = true;
         if (_closedRead) {
-          close();
+          _close();
         }
       }
-    } else if (direction == SocketDirection.RECEIVE) {
+    }
+    if (direction == SocketDirection.RECEIVE ||
+        direction == SocketDirection.BOTH) {
       _closedRead = true;
       _socketClosedRead = true;
       _socket.shutdown(SocketDirection.RECEIVE);
       if (_socketClosedWrite) {
-        close();
+        _close();
       }
     }
   }
 
   bool get writeEventsEnabled => _writeEventsEnabled;
 
   void set writeEventsEnabled(bool value) {
     if (value &&
         _controller.hasSubscribers &&
         _secureFilter != null &&
@@ skipping 145 matching lines @@
           }
         }
       } else if (_socketClosedRead) {
         _closeHandler();
       }
     }
   }
 
   void _doneHandler() {
     if (_filterReadEmpty) {
-      close();
+      _close();
     }
   }
 
   void _errorHandler(e) {
     _reportError(e, 'Error on underlying RawSocket');
   }
 
   void _reportError(error, String message) {
     // TODO(whesse): Call _reportError from all internal functions that throw.
     var e;
     if (error is AsyncError) {
       e = error;
     } else if (error is SocketIOException) {
       e = new SocketIOException('$message (${error.message})', error.osError);
     } else if (error is OSError) {
       e = new SocketIOException(message, error);
     } else {
       e = new SocketIOException('$message (${error.toString()})', null);
     }
     if (_connectPending) {
       _handshakeComplete.completeError(e);
     } else {
       _controller.signalError(e);
     }
-    close();
+    _close();
   }
 
   void _closeHandler() {
     if  (_status == CONNECTED) {
       if (_closedRead) return;
       _socketClosedRead = true;
       if (_filterReadEmpty) {
         _closedRead = true;
         _controller.add(RawSocketEvent.READ_CLOSED);
         if (_socketClosedWrite) {
-          close();
+          _close();
         }
       }
     } else if (_status == HANDSHAKE) {
       _reportError(
           new SocketIOException('Connection terminated during handshake'),
           'handshake error');
     }
   }
 
   void _secureHandshake() {
@@ skipping 149 matching lines @@
   void destroy();
   void handshake();
   void init();
   X509Certificate get peerCertificate;
   int processBuffer(int bufferIndex);
   void registerBadCertificateCallback(Function callback);
   void registerHandshakeCompleteCallback(Function handshakeCompleteHandler);
 
   List<_ExternalBuffer> get buffers;
 }