Adapt streams for additional stackTrace argument.

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 536 matching lines @@
                             requestClientCertificate ||
                                 requireClientCertificate,
                             requireClientCertificate,
                             sendClientCertificate);
       _secureHandshake();
     })
     .catchError(_reportError);
   }
 
   StreamSubscription listen(void onData(RawSocketEvent data),
-                            {void onError(error),
+                            {Function onError,
                              void onDone(),
                              bool cancelOnError}) {
     _sendWriteEvent();
     return _stream.listen(onData,
                           onError: onError,
                           onDone: onDone,
                           cancelOnError: cancelOnError);
   }
 
   static void _verifyFields(host,
@@ skipping 173 matching lines @@
 
   void _eventDispatcher(RawSocketEvent event) {
     try {
       if (event == RawSocketEvent.READ) {
         _readHandler();
       } else if (event == RawSocketEvent.WRITE) {
         _writeHandler();
       } else if (event == RawSocketEvent.READ_CLOSED) {
         _closeHandler();
       }
-    } catch (e) {
-      _reportError(e);
+    } catch (e, stackTrace) {
+      _reportError(e, stackTrace);
     }
   }
 
   void _readHandler() {
     _readSocket();
     _scheduleFilter();
   }
 
   void _writeHandler() {
     _writeSocket();
     _scheduleFilter();
   }
 
   void _doneHandler() {
     if (_filterStatus.readEmpty) {
       _close();
     }
   }
 
-  void _reportError(e) {
+  void _reportError(e, [StackTrace stackTrace]) {
     if (_status == CLOSED) {
       return;
     } else if (_connectPending) {
       // _connectPending is true until the handshake has completed, and the
       // _handshakeComplete future returned from SecureSocket.connect has
       // completed.  Before this point, we must complete it with an error.
-      _handshakeComplete.completeError(e);
+      _handshakeComplete.completeError(e, stackTrace);
     } else {
-      _controller.addError(e);
+      _controller.addError(e, stackTrace);
     }
     _close();
   }
 
   void _closeHandler() {
     if  (_status == CONNECTED) {
       if (_closedRead) return;
       _socketClosedRead = true;
       if (_filterStatus.readEmpty) {
         _closedRead = true;
         _controller.add(RawSocketEvent.READ_CLOSED);
         if (_socketClosedWrite) {
           _close();
         }
       } else {
         _scheduleFilter();
       }
     } else if (_status == HANDSHAKE) {
       _socketClosedRead = true;
       if (_filterStatus.readEmpty) {
       _reportError(
-          new HandshakeException('Connection terminated during handshake'));
+          new HandshakeException('Connection terminated during handshake'),
+          null);
       } else {
         _secureHandshake();
       }
     }
   }
 
   void _secureHandshake() {
     try {
       _secureFilter.handshake();
       _filterStatus.writeEmpty = false;
       _readSocket();
       _writeSocket();
       _scheduleFilter();
-    } catch (e) {
-      _reportError(e);
+    } catch (e, stackTrace) {
+      _reportError(e, stackTrace);
     }
   }
 
   void renegotiate({bool useSessionCache: true,
                     bool requestClientCertificate: false,
                     bool requireClientCertificate: false}) {
     if (_status != CONNECTED) {
       throw new HandshakeException(
           "Called renegotiate on a non-connected socket");
     }
@@ skipping 163 matching lines @@
     args[0] = _filterPointer;
     args[1] = wasInHandshake;
     var bufs = _secureFilter.buffers;
     for (var i = 0; i < NUM_BUFFERS; ++i) {
       args[2 * i + 2] = bufs[i].start;
       args[2 * i + 3] = bufs[i].end;
     }
 
     return _IOService.dispatch(_SSL_PROCESS_FILTER, args).then((response) {
       if (response.length == 2) {
-        _reportError(new TlsException('${response[1]} error ${response[0]}'));
+        _reportError(new TlsException('${response[1]} error ${response[0]}'),
+                     null);
       }
       int start(int index) => response[2 * index];
       int end(int index) => response[2 * index + 1];
 
       _FilterStatus status = new _FilterStatus();
       // Compute writeEmpty as "write plaintext buffer and write encrypted
       // buffer were empty when we started and are empty now".
       status.writeEmpty = bufs[WRITE_PLAINTEXT].isEmpty &&
           start(WRITE_ENCRYPTED) == end(WRITE_ENCRYPTED);
       // If we were in handshake when this started, _writeEmpty may be false
@@ skipping 251 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);
 }