* Move the global "DnsResolutionObserver" code depended on by DNS prefetcher,...

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 13 matching lines @@
 //
 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,
+                            const HostResolver::RequestInfo& resolve_info,
                             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:
   // A Request is allocated per call to RequestSocket that results in
   // ERR_IO_PENDING.
   struct Request {
+    // HostResolver::RequestInfo has no default constructor, so fudge something.
+    Request() : resolve_info(std::string(), 0) {}
+
+    Request(ClientSocketHandle* handle,
+            CompletionCallback* callback,
+            int priority,
+            const HostResolver::RequestInfo& resolve_info,
+            LoadState load_state)
+        : handle(handle), callback(callback), priority(priority),
+          resolve_info(resolve_info), load_state(load_state) {
+    }
+
     ClientSocketHandle* handle;
     CompletionCallback* callback;
     int priority;
-    std::string host;
-    int port;
+    HostResolver::RequestInfo resolve_info;
     LoadState load_state;
   };
 
   // Entry for a persistent socket which became idle at time |start_time|.
   struct IdleSocket {
     ClientSocket* socket;
     base::TimeTicks start_time;
 
     // An idle socket should be removed if it can't be reused, or has been idle
     // for too long. |now| is the current time value (TimeTicks::Now()).
@@ skipping 31 matching lines @@
 
     ConnectingSocket(const std::string& group_name,
                      const ClientSocketHandle* handle,
                      ClientSocketFactory* client_socket_factory,
                      TCPClientSocketPool* pool);
     ~ConnectingSocket();
 
     // Begins the host resolution and the TCP connect.  Returns OK on success
     // and ERR_IO_PENDING if it cannot immediately service the request.
     // Otherwise, it returns a net error code.
-    int Connect(const std::string& host, int port);
+    int Connect(const HostResolver::RequestInfo& resolve_info);
 
     // Called by the TCPClientSocketPool to cancel this ConnectingSocket.  Only
     // necessary if a ClientSocketHandle is reused.
     void Cancel();
 
    private:
     // Handles asynchronous completion of IO.  |result| represents the result of
     // the IO operation.
     void OnIOComplete(int result);
 
@@ skipping 61 matching lines @@
   // 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_