Fix idle connection pool issue in dart:io's HttpClient

dart/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;
 
 const int _OUTGOING_BUFFER_SIZE = 8 * 1024;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
@@ skipping 1567 matching lines @@
       c.close();
     }
     if (force) {
       for (var c in _active.toList()) {
         c.destroy();
       }
     }
   }
 
   Future<_ConnectionInfo> connect(String uriHost,
-                                   int uriPort,
-                                   _Proxy proxy,
-                                   _HttpClient client) {
+                                  int uriPort,
+                                  _Proxy proxy,
+                                  _HttpClient client) {
     if (hasIdle) {
       var connection = takeIdle();
-      client._updateTimers();
+      client._connectionsChanged();
       return new Future.value(new _ConnectionInfo(connection, proxy));
     }
     if (client.maxConnectionsPerHost != null &&
         _active.length + _connecting >= client.maxConnectionsPerHost) {
       var completer = new Completer();
       _pending.add(() {
         connect(uriHost, uriPort, proxy, client)
             .then(completer.complete, onError: completer.completeError);
       });
       return completer.future;
@@ skipping 29 matching lines @@
         _connecting--;
         _checkPending();
         throw error;
       });
   }
 }
 
 
 class _HttpClient implements HttpClient {
   bool _closing = false;
+  bool _closingForcefully = false;
   final Map<String, _ConnectionTarget> _connectionTargets
       = new HashMap<String, _ConnectionTarget>();
   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;
 
   int maxConnectionsPerHost;
 
   bool autoUncompress = true;
 
   String userAgent = _getHttpVersion();
 
   void set idleTimeout(Duration timeout) {
     _idleTimeout = timeout;
     for (var c in _connectionTargets.values) {
-      for (var idle in c.idle) {
+      for (var idle in c._idle) {
         // Reset timer. This is fine, as it's not happening often.
         idle.stopTimer();
         idle.startTimer();
       }
     }
   }
 
   set badCertificateCallback(bool callback(X509Certificate cert,
                                            String host,
                                            int port)) {
@@ skipping 40 matching lines @@
 
   Future<HttpClientRequest> headUrl(Uri url) => _openUrl("head", url);
 
   Future<HttpClientRequest> patch(String host, int port, String path)
       => open("patch", host, port, path);
 
   Future<HttpClientRequest> patchUrl(Uri url) => _openUrl("patch", url);
 
   void close({bool force: false}) {
     _closing = true;
-    _connectionTargets.values.toList().forEach((c) => c.close(force));
+    _closingForcefully = force;
+    _closeConnections(_closingForcefully);
     assert(!_connectionTargets.values.any((s) => s.hasIdle));
     assert(!force ||
         !_connectionTargets.values.any((s) => s._active.isNotEmpty));
   }
 
   set authenticate(Future<bool> f(Uri url, String scheme, String realm)) {
     _authenticate = f;
   }
 
   void addCredentials(Uri url, String realm, HttpClientCredentials cr) =>
@@ skipping 82 matching lines @@
           }
           return request
               ..headers.chunkedTransferEncoding = false
               ..contentLength = 0;
         });
   }
 
   // Return a live connection to the idle pool.
   void _returnConnection(_HttpClientConnection connection) {
     _connectionTargets[connection.key].returnConnection(connection);
-    _updateTimers();
+    _connectionsChanged();
   }
 
   // Remove a closed connnection from the active set.
   void _connectionClosed(_HttpClientConnection connection) {
     connection.stopTimer();
     var connectionTarget = _connectionTargets[connection.key];
     if (connectionTarget != null) {
       connectionTarget.connectionClosed(connection);
       if (connectionTarget.isEmpty) {
         _connectionTargets.remove(connection.key);
       }
-      _updateTimers();
+      _connectionsChanged();
     }
   }
 
-  void _updateTimers() {
-    bool hasActive = _connectionTargets.values.any((t) => t.hasActive);
-    if (!hasActive) {
-      bool hasIdle = _connectionTargets.values.any((t) => t.hasIdle);
-      if (hasIdle && _noActiveTimer == null) {
-        _noActiveTimer = new Timer(const Duration(milliseconds: 100), () {
-          _noActiveTimer = null;
-          bool hasActive =
-              _connectionTargets.values.any((t) => t.hasActive);
-          if (!hasActive) {
-            close();
-            _closing = false;
-          }
-        });
-      }
-    } else if (_noActiveTimer != null) {
-      _noActiveTimer.cancel();
-      _noActiveTimer = null;
+  void _connectionsChanged() {
+    if (_closing) {
+      _closeConnections(_closingForcefully);
     }
   }
 
+  void _closeConnections(bool force) {
+    for (var connectionTarget in _connectionTargets.values.toList()) {
+      connectionTarget.close(force);
+    }
+  }
+
   _ConnectionTarget _getConnectionTarget(String host, int port, bool isSecure) {
     String key = _HttpClientConnection.makeKey(isSecure, host, port);
     return _connectionTargets.putIfAbsent(
         key, () => new _ConnectionTarget(key, host, port, isSecure));
   }
 
   // Get a new _HttpClientConnection, from the matching _ConnectionTarget.
   Future<_ConnectionInfo> _getConnection(String uriHost,
                                           int uriPort,
                                           _ProxyConfiguration proxyConf,
@@ skipping 132 matching lines @@
 
   // Use HashMap, as we don't need to keep order.
   static Map<int, _HttpConnection> _connections =
       new HashMap<int, _HttpConnection>();
 
   final _socket;
   final _HttpServer _httpServer;
   final _HttpParser _httpParser;
   int _state = _IDLE;
   StreamSubscription _subscription;
-  Timer _idleTimer;
   bool _idleMark = false;
   Future _streamFuture;
 
   _HttpConnection(this._socket, this._httpServer)
       : _httpParser = new _HttpParser.requestParser() {
     try { _socket._owner = this; } catch (_) { print(_); }
     _connections[_serviceId] = this;
     _httpParser.listenToStream(_socket);
     _subscription = _httpParser.listen(
         (incoming) {
@@ skipping 787 matching lines @@
   const _RedirectInfo(this.statusCode, this.method, this.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)';
 }