dart:io | Fix handling of exceptions from onBadCertificate callback.

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 498 matching lines @@
         onResume: _onPauseStateChange,
         onCancel: _onSubscriptionStateChange);
     _stream = _controller.stream;
     // Throw an ArgumentError if any field is invalid.  After this, all
     // errors will be reported through the future or the stream.
     _secureFilter.init();
     _filterPointer = _secureFilter._pointer();
     _secureFilter.registerHandshakeCompleteCallback(
         _secureHandshakeCompleteHandler);
     if (onBadCertificate != null) {
-      _secureFilter.registerBadCertificateCallback(onBadCertificate);
+      _secureFilter.registerBadCertificateCallback(_onBadCertificateWrapper);
     }
     var futureSocket;
     if (socket == null) {
       futureSocket = RawSocket.connect(address, requestedPort);
     } else {
       futureSocket = new Future.value(socket);
     }
     futureSocket.then((rawSocket) {
       _connectPending = true;
       _socket = rawSocket;
@@ skipping 183 matching lines @@
         _secureFilter.buffers[WRITE_PLAINTEXT].write(data, offset, bytes);
     if (written > 0) {
       _filterStatus.writeEmpty = false;
     }
     _scheduleFilter();
     return written;
   }
 
   X509Certificate get peerCertificate => _secureFilter.peerCertificate;
 
+  bool _onBadCertificateWrapper(X509Certificate certificate) {
+    if (onBadCertificate == null) return false;
+    var result = onBadCertificate(certificate);
+    if (result is bool) return result;
+    throw new ArgumentError(
+        "onBadCertificate callback returned non-boolean $result");
+  }
+
   bool setOption(SocketOption option, bool enabled) {
     if (_socket == null) return false;
     return _socket.setOption(option, enabled);
   }
 
   void _eventDispatcher(RawSocketEvent event) {
     try {
       if (event == RawSocketEvent.READ) {
         _readHandler();
       } else if (event == RawSocketEvent.WRITE) {
@@ skipping 21 matching lines @@
       _close();
     }
   }
 
   void _reportError(e) {
     if (_status == CLOSED) {
       return;
     } else if (_connectPending) {
       // _connectPending is true after the underlying connection has been
       // made, but before the handshake has completed.
-      if (e is! TlsException) {
-        e = new HandshakeException("$e", null);
-      }
       _handshakeComplete.completeError(e);
     } else {
       _controller.addError(e);
     }
     _close();
   }
 
   void _closeHandler() {
     if  (_status == CONNECTED) {
       if (_closedRead) return;
@@ skipping 478 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);
 }