Make TCPClientSocketPool own the ConnectingSockets.

net/base/tcp_client_socket_pool.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_BASE_TCP_CLIENT_SOCKET_POOL_H_
 #define NET_BASE_TCP_CLIENT_SOCKET_POOL_H_
 
 #include <deque>
 #include <map>
 #include <string>
@@ skipping 136 matching lines @@
     int OnIOCompleteInternal(int result, bool synchronous);
 
     const std::string group_name_;
     const ClientSocketHandle* const handle_;
     ClientSocketFactory* const client_socket_factory_;
     CompletionCallbackImpl<ConnectingSocket> callback_;
     scoped_ptr<ClientSocket> socket_;
     scoped_refptr<TCPClientSocketPool> pool_;
     SingleRequestHostResolver resolver_;
     AddressList addresses_;
-    bool canceled_;
 
     // The time the Connect() method was called (if it got called).
     base::Time connect_start_time_;
 
     DISALLOW_COPY_AND_ASSIGN(ConnectingSocket);
   };
 
+  typedef std::map<const ClientSocketHandle*, ConnectingSocket*>
+      ConnectingSocketMap;
+
   virtual ~TCPClientSocketPool();
 
   static void InsertRequestIntoQueue(const Request& r,
                                      RequestQueue* pending_requests);
 
   // Closes all idle sockets if |force| is true.  Else, only closes idle
   // sockets that timed out or can't be reused.
   void CleanupIdleSockets(bool force);
 
   // Called when the number of idle sockets changes.
   void IncrementIdleCount();
   void DecrementIdleCount();
 
   // Called via PostTask by ReleaseSocket.
   void DoReleaseSocket(const std::string& group_name, ClientSocket* socket);
 
   // Called when timer_ fires.  This method scans the idle sockets removing
   // sockets that timed out or can't be reused.
   void OnCleanupTimerFired() {
     CleanupIdleSockets(false);
   }
 
+  // Removes the ConnectingSocket corresponding to |handle| from the
+  // |connecting_socket_map_|.
+  void RemoveConnectingSocket(const ClientSocketHandle* handle);
+
   ClientSocketFactory* const client_socket_factory_;
 
   GroupMap group_map_;
 
-  std::map<const ClientSocketHandle*, ConnectingSocket*> connecting_socket_map_;
+  ConnectingSocketMap connecting_socket_map_;
 
   // Timer used to periodically prune idle sockets that timed out or can't be
   // reused.
   base::RepeatingTimer<TCPClientSocketPool> timer_;
 
   // The total number of idle sockets in the system.
   int idle_socket_count_;
 
   // The maximum number of sockets kept per group.
   const int max_sockets_per_group_;
 
   // The host resolver that will be used to do DNS lookups for connecting
   // sockets.
   HostResolver* host_resolver_;
 
   DISALLOW_COPY_AND_ASSIGN(TCPClientSocketPool);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_TCP_CLIENT_SOCKET_POOL_H_