Add timeouts 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 1053 matching lines @@
 }
 
 class _HttpClientConnection {
   final String key;
   final Socket _socket;
   final bool _proxyTunnel;
   final _HttpParser _httpParser;
   StreamSubscription _subscription;
   final _HttpClient _httpClient;
   bool _dispose = false;
+  Timer _idleTimer;
 
   Completer<_HttpIncoming> _nextResponseCompleter;
   Future _streamFuture;
 
   _HttpClientConnection(String this.key,
                         Socket this._socket,
                         _HttpClient this._httpClient,
                         [this._proxyTunnel = false])
       : _httpParser = new _HttpParser.responseParser() {
     _socket.pipe(_httpParser);
@@ skipping 182 matching lines @@
               key, secureSocket, request._httpClient, true);
         });
   }
 
   HttpConnectionInfo get connectionInfo => _HttpConnectionInfo.create(_socket);
 
   static makeKey(bool isSecure, String host, int port) {
     return isSecure ? "ssh:$host:$port" : "$host:$port";
   }
 
+  void stopTimer() {
+    if (_idleTimer != null) {
+      _idleTimer.cancel();
+      _idleTimer = null;
+    }
+  }
+
+  void startTimer() {
+    assert(_idleTimer == null);
+    _idleTimer = new Timer(
+        _httpClient.idleTimeout,
+        () {
+          _idleTimer = null;
+          close();
+        });
+  }
 }
 
 class _ConnnectionInfo {
   _ConnnectionInfo(_HttpClientConnection this.connection, _Proxy this.proxy);
   final _HttpClientConnection connection;
   final _Proxy proxy;
 }
 
 
 class _HttpClient implements HttpClient {
   // TODO(ajohnsen): Use eviction timeout.
-  static const int DEFAULT_EVICTION_TIMEOUT = 60000;
   bool _closing = false;
 
   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);
+
+  Timer _noActiveTimer;
+
+  Duration get idleTimeout => _idleTimeout;
+
+  void set idleTimeout(Duration timeout) {
+    _idleTimeout = timeout;
+    var idle = _idleConnections.values.forEach(
+        (l) => l.forEach((c) {
+          // Reset timer. This is fine, as it's not happening often.
+          c.stopTimer();
+          c.startTimer();
+        }));
+  }
 
   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.fromComponents(
         scheme: "http", domain: host, port: port, path: path));
   }
@@ skipping 148 matching lines @@
         });
   }
 
   // Return a live connection to the idle pool.
   void _returnConnection(_HttpClientConnection connection) {
     _activeConnections.remove(connection);
     if (_closing) {
       connection.close();
       return;
     }
-    // TODO(ajohnsen): Listen for socket close events.
     if (!_idleConnections.containsKey(connection.key)) {
       _idleConnections[connection.key] = new LinkedHashSet();
     }
     _idleConnections[connection.key].add(connection);
+    connection.startTimer();
+    _updateTimers();
   }
 
   // Remove a closed connnection from the active set.
   void _connectionClosed(_HttpClientConnection connection) {
+    connection.stopTimer();
     _activeConnections.remove(connection);
     if (_idleConnections.containsKey(connection.key)) {
       _idleConnections[connection.key].remove(connection);
       if (_idleConnections[connection.key].isEmpty) {
         _idleConnections.remove(connection.key);
       }
     }
+    _updateTimers();
+  }
+
+  void _updateTimers() {
+    if (_activeConnections.isEmpty) {
+      if (!_idleConnections.isEmpty && _noActiveTimer == null) {
+        _noActiveTimer = new Timer(const Duration(milliseconds: 100), () {
+          _noActiveTimer = null;
+          if (_activeConnections.isEmpty) {
+            close();
+            _closing = false;
+          }
+        });
+      }
+    } else if (_noActiveTimer != null) {
+      _noActiveTimer.cancel();
+      _noActiveTimer = null;
+    }
   }
 
   // Get a new _HttpClientConnection, either from the idle pool or created from
   // a new Socket.
   Future<_ConnnectionInfo> _getConnection(String uriHost,
                                           int uriPort,
                                           _ProxyConfiguration proxyConf,
                                           bool isSecure) {
     Iterator<_Proxy> proxies = proxyConf.proxies.iterator;
 
     Future<_ConnnectionInfo> connect(error) {
       if (!proxies.moveNext()) return new Future.error(error);
       _Proxy proxy = proxies.current;
       String host = proxy.isDirect ? uriHost: proxy.host;
       int port = proxy.isDirect ? uriPort: proxy.port;
       String key = _HttpClientConnection.makeKey(isSecure, host, port);
       if (_idleConnections.containsKey(key)) {
         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));
       }
       return (isSecure && proxy.isDirect
                   ? SecureSocket.connect(host,
                                          port,
                                          sendClientCertificate: true)
                   : Socket.connect(host, port))
         .then((socket) {
           socket.setOption(SocketOption.TCP_NODELAY, true);
           var connection = new _HttpClientConnection(key, socket, this);
@@ skipping 719 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }