dart:io | Add badCertificateCallback to HttpClient.

sdk/lib/io/http_impl.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;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 1317 matching lines @@
   }
 
   void close() {
     closed = true;
     _httpClient._connectionClosed(this);
     _streamFuture
           // TODO(ajohnsen): Add timeout.
         .then((_) => _socket.destroy());
   }
 
-  Future<_HttpClientConnection> createProxyTunnel(host, port, proxy) {
+  Future<_HttpClientConnection> createProxyTunnel(host, port, proxy, callback) {
     _HttpClientRequest request =
         send(new Uri(host: host, port: port),
              port,
              "CONNECT",
              proxy);
     if (proxy.isAuthenticated) {
       // If the proxy configuration contains user information use that
       // for proxy basic authorization.
       String auth = _CryptoUtils.bytesToBase64(
           _encodeString("${proxy.username}:${proxy.password}"));
       request.headers.set(HttpHeaders.PROXY_AUTHORIZATION, "Basic $auth");
     }
     return request.close()
         .then((response) {
           if (response.statusCode != HttpStatus.OK) {
             throw "Proxy failed to establish tunnel "
                   "(${response.statusCode} ${response.reasonPhrase})";
           }
           var socket = response._httpRequest._httpClientConnection._socket;
-          return SecureSocket.secure(socket, host: host);
+          return SecureSocket.secure(
+              socket, host: host, onBadCertificate: callback);
         })
         .then((secureSocket) {
           String key = _HttpClientConnection.makeKey(true, host, port);
           return new _HttpClientConnection(
               key, secureSocket, request._httpClient, true);
         });
   }
 
   HttpConnectionInfo get connectionInfo => _HttpConnectionInfo.create(_socket);
 
@@ skipping 33 matching lines @@
   final Map<String, Set<_HttpClientConnection>> _idleConnections
       = new Map<String, Set<_HttpClientConnection>>();
   final Set<_HttpClientConnection> _activeConnections
       = new Set<_HttpClientConnection>();
   final List<_Credentials> _credentials = [];
   final List<_ProxyCredentials> _proxyCredentials = [];
   Function _authenticate;
   Function _authenticateProxy;
   Function _findProxy = HttpClient.findProxyFromEnvironment;
   Duration _idleTimeout = const Duration(seconds: 15);
+  Function _badCertificateCallback;
 
   Timer _noActiveTimer;
 
   Duration get idleTimeout => _idleTimeout;
 
   String userAgent = _getHttpVersion();
 
   void set idleTimeout(Duration timeout) {
     _idleTimeout = timeout;
     _idleConnections.values.forEach(
         (l) => l.forEach((c) {
           // Reset timer. This is fine, as it's not happening often.
           c.stopTimer();
           c.startTimer();
         }));
   }
 
+  set badCertificateCallback(bool callback(X509Certificate cert,
+                                           String host,
+                                           int port)) {
+    _badCertificateCallback = callback;
+  }
+
 
   Future<HttpClientRequest> open(String method,
                                  String host,
                                  int port,
                                  String path) {
     // TODO(sgjesse): The path set here can contain both query and
     // fragment. They should be cracked and set correctly.
     return _openUrl(method, new Uri(
         scheme: "http", host: host, port: port, path: path));
   }
@@ skipping 228 matching lines @@
         var connection = _idleConnections[key].first;
         _idleConnections[key].remove(connection);
         if (_idleConnections[key].isEmpty) {
           _idleConnections.remove(key);
         }
         connection.stopTimer();
         _activeConnections.add(connection);
         _updateTimers();
         return new Future.value(new _ConnnectionInfo(connection, proxy));
       }
+      var currentBadCertificateCallback = _badCertificateCallback;
+      bool callback(X509Certificate certificate) =>
+          currentBadCertificateCallback == null ? false :
+          currentBadCertificateCallback(certificate, uriHost, uriPort);
       return (isSecure && proxy.isDirect
                   ? SecureSocket.connect(host,
                                          port,
-                                         sendClientCertificate: true)
+                                         sendClientCertificate: true,
+                                         onBadCertificate: callback)
                   : Socket.connect(host, port))
         .then((socket) {
           socket.setOption(SocketOption.TCP_NODELAY, true);
           var connection = new _HttpClientConnection(key, socket, this);
           if (isSecure && !proxy.isDirect) {
             connection._dispose = true;
-            return connection.createProxyTunnel(uriHost, uriPort, proxy)
+            return connection.createProxyTunnel(
+                uriHost, uriPort, proxy, callback)
                 .then((tunnel) {
                   _activeConnections.add(tunnel);
                   return new _ConnnectionInfo(tunnel, proxy);
                 });
           } else {
             _activeConnections.add(connection);
             return new _ConnnectionInfo(connection, proxy);
           }
         }, onError: (error) {
           // Continue with next proxy.
@@ skipping 733 matching lines @@
   final Uri location;
 }
 
 String _getHttpVersion() {
   var version = Platform.version;
   // Only include major and minor version numbers.
   int index = version.indexOf('.', version.indexOf('.') + 1);
   version = version.substring(0, index);
   return 'Dart/$version (dart:io)';
 }