Avoid doing concurrent DNS resolves of the same hostname

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>
 
 #include "base/scoped_ptr.h"
 #include "base/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/client_socket_pool.h"
 #include "net/base/host_resolver.h"
 
 namespace net {
 
 class ClientSocketFactory;
 
 // A TCPClientSocketPool is used to restrict the number of TCP sockets open at
 // a time.  It also maintains a list of idle persistent sockets.
 //
 class TCPClientSocketPool : public ClientSocketPool {
  public:
   TCPClientSocketPool(int max_sockets_per_group,
+                      HostResolver* host_resolver,
                       ClientSocketFactory* client_socket_factory);
 
   // ClientSocketPool methods:
 
   virtual int RequestSocket(const std::string& group_name,
                             const std::string& host,
                             int port,
                             int priority,
                             ClientSocketHandle* handle,
                             CompletionCallback* callback);
 
   virtual void CancelRequest(const std::string& group_name,
                              const ClientSocketHandle* handle);
 
   virtual void ReleaseSocket(const std::string& group_name,
                              ClientSocket* socket);
 
   virtual void CloseIdleSockets();
 
+  virtual HostResolver* GetHostResolver() const {
+    return host_resolver_;
+  }
+
   virtual int idle_socket_count() const {
     return idle_socket_count_;
   }
 
   virtual int IdleSocketCountInGroup(const std::string& group_name) const;
 
   virtual LoadState GetLoadState(const std::string& group_name,
                                  const ClientSocketHandle* handle) const;
 
  private:
@@ skipping 73 matching lines @@
     // asynchronously.  OnIOCompleteInternal returns the result of the next IO
     // operation that executes, or just the value of |result|.
     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_;
-    HostResolver resolver_;
+    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);
   };
 
   virtual ~TCPClientSocketPool();
@@ skipping 27 matching lines @@
   // 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_