Fix HTTP client eviction timer bug

runtime/bin/http_impl.dart

 // Copyright (c) 2012, 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.
 
 class _HttpHeaders implements HttpHeaders {
   _HttpHeaders() : _headers = new Map<String, List<String>>();
 
   List<String> operator[](String name) {
     name = name.toLowerCase();
     return _headers[name];
@@ skipping 1942 matching lines @@
   void shutdown() {
      _openSockets.forEach((String key, Queue<_SocketConnection> connections) {
        while (!connections.isEmpty()) {
          _SocketConnection socketConn = connections.removeFirst();
          socketConn._socket.close();
        }
      });
      _activeSockets.forEach((_SocketConnection socketConn) {
        socketConn._socket.close();
      });
-     if (_evictionTimer != null) {
-       _evictionTimer.cancel();
-     }
+    if (_evictionTimer != null) _cancelEvictionTimer();
      _shutdown = true;
   }
 
+  void _cancelEvictionTimer() {
+    _evictionTimer.cancel();
+    _evictionTimer = null;
+  }
+
   String _connectionKey(String host, int port) {
     return "$host:$port";
   }
 
   HttpClientConnection _prepareHttpClientConnection(
     String host,
     int port,
     String method,
     String path,
     [_HttpClientConnection connection]) {
@@ skipping 12 matching lines @@
     }
 
     // Create a new connection if we are not re-using an existing one.
     if (connection == null) {
       connection = new _HttpClientConnection(this);
     }
     connection.onDetach = () => _activeSockets.remove(connection._socketConn);
 
     // If there are active connections for this key get the first one
     // otherwise create a new one.
-    Queue socketConnections = _openSockets[_connectionKey(host, port)];
+    String key = _connectionKey(host, port);
+    Queue socketConnections = _openSockets[key];
     if (socketConnections == null || socketConnections.isEmpty()) {
       Socket socket = new Socket(host, port);
       // Until the connection is established handle connection errors
       // here as the HttpClientConnection object is not yet associated
       // with the socket.
       socket.onError = (e) {
         // Report the error through the HttpClientConnection object to
         // the client.
         connection._onError(e);
       };
       socket.onConnect = () {
         // When the connection is established, clear the error
         // callback as it will now be handled by the
         // HttpClientConnection object which will be associated with
         // the connected socket.
         socket.onError = null;
         _SocketConnection socketConn =
             new _SocketConnection(host, port, socket);
         _activeSockets.add(socketConn);
         _connectionOpened(socketConn, connection);
       };
     } else {
       _SocketConnection socketConn = socketConnections.removeFirst();
       _activeSockets.add(socketConn);
       new Timer(0, (ignored) => _connectionOpened(socketConn, connection));
 
       // Get rid of eviction timer if there are no more active connections.
-      if (socketConnections.isEmpty()) {
-        _evictionTimer.cancel();
-        _evictionTimer = null;
-      }
+      if (socketConnections.isEmpty()) _openSockets.remove(key);
+      if (_openSockets.isEmpty()) _cancelEvictionTimer();
     }
 
     return connection;
   }
 
   void _returnSocketConnection(_SocketConnection socketConn) {
     // Mark socket as returned to unregister from the old connection.
     socketConn._markReturned();
 
     // If the HTTP client is beeing shutdown don't return the connection.
     if (_shutdown) {
       socketConn._socket.close();
       return;
     };
 
     String key = _connectionKey(socketConn._host, socketConn._port);
 
     // Get or create the connection list for this key.
     Queue sockets = _openSockets[key];
     if (sockets == null) {
       sockets = new Queue();
       _openSockets[key] = sockets;
     }
 
     // If there is currently no eviction timer start one.
     if (_evictionTimer == null) {
       void _handleEviction(Timer timer) {
         Date now = new Date.now();
+        List<String> emptyKeys = new List<String>();
         _openSockets.forEach(
             void _(String key, Queue<_SocketConnection> connections) {
               // As returned connections are added at the head of the
               // list remove from the tail.
               while (!connections.isEmpty()) {
                 _SocketConnection socketConn = connections.last();
                 if (socketConn._idleTime(now).inMilliseconds >
                     DEFAULT_EVICTION_TIMEOUT) {
                   connections.removeLast();
                   socketConn._socket.close();
+                  if (connections.isEmpty()) emptyKeys.add(key);
                 } else {
                   break;
                 }
               }
             });
+
+        // Remove the keys for which here are no more open connections.
+        emptyKeys.forEach((String key) => _openSockets.remove(key));
+
+        // If all connections where evicted cancel the eviction timer.
+        if (_openSockets.isEmpty()) _cancelEvictionTimer();
       }
       _evictionTimer = new Timer.repeating(10000, _handleEviction);
     }
 
     // Return connection.
     _activeSockets.remove(socketConn);
     sockets.addFirst(socketConn);
   }
 
   Function _onOpen;
@@ skipping 14 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;
 }