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

net/base/tcp_client_socket_pool.cc

 // 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.
 
 #include "net/base/tcp_client_socket_pool.h"
 
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ skipping 40 matching lines @@
   CHECK(!ContainsKey(pool_->connecting_socket_map_, handle));
   pool_->connecting_socket_map_[handle] = this;
 }
 
 TCPClientSocketPool::ConnectingSocket::~ConnectingSocket() {
   if (!canceled_)
     pool_->connecting_socket_map_.erase(handle_);
 }
 
 int TCPClientSocketPool::ConnectingSocket::Connect(
-    const std::string& host,
-    int port) {
+    const HostResolver::RequestInfo& resolve_info) {
   CHECK(!canceled_);
-  DidStartDnsResolution(host, this);
-  int rv = resolver_.Resolve(host, port, &addresses_, &callback_);
+  int rv = resolver_.Resolve(resolve_info, &addresses_, &callback_);
   if (rv != ERR_IO_PENDING)
     rv = OnIOCompleteInternal(rv, true /* synchronous */);
   return rv;
 }
 
 void TCPClientSocketPool::ConnectingSocket::OnIOComplete(int result) {
   OnIOCompleteInternal(result, false /* asynchronous */);
 }
 
 int TCPClientSocketPool::ConnectingSocket::OnIOCompleteInternal(
@@ skipping 103 matching lines @@
 //
 // static
 void TCPClientSocketPool::InsertRequestIntoQueue(
     const Request& r, RequestQueue* pending_requests) {
   RequestQueue::iterator it = pending_requests->begin();
   while (it != pending_requests->end() && r.priority <= it->priority)
     ++it;
   pending_requests->insert(it, r);
 }
 
-int TCPClientSocketPool::RequestSocket(const std::string& group_name,
-                                       const std::string& host,
-                                       int port,
-                                       int priority,
-                                       ClientSocketHandle* handle,
-                                       CompletionCallback* callback) {
-  DCHECK(!host.empty());
+int TCPClientSocketPool::RequestSocket(
+    const std::string& group_name,
+    const HostResolver::RequestInfo& resolve_info,
+    int priority,
+    ClientSocketHandle* handle,
+    CompletionCallback* callback) {
+  DCHECK(!resolve_info.hostname().empty());
   DCHECK_GE(priority, 0);
   Group& group = group_map_[group_name];
 
   // Can we make another active socket now?
   if (group.active_socket_count == max_sockets_per_group_) {
-    Request r;
-    r.handle = handle;
     CHECK(callback);
-    r.callback = callback;
-    r.priority = priority;
-    r.host = host;
-    r.port = port;
-    r.load_state = LOAD_STATE_IDLE;
+    Request r(handle, callback, priority, resolve_info, LOAD_STATE_IDLE);
     InsertRequestIntoQueue(r, &group.pending_requests);
     return ERR_IO_PENDING;
   }
 
   // OK, we are going to activate one.
   group.active_socket_count++;
 
   while (!group.idle_sockets.empty()) {
     IdleSocket idle_socket = group.idle_sockets.back();
     group.idle_sockets.pop_back();
     DecrementIdleCount();
     if (idle_socket.socket->IsConnectedAndIdle()) {
       // We found one we can reuse!
       handle->set_socket(idle_socket.socket);
       handle->set_is_reused(true);
       return OK;
     }
     delete idle_socket.socket;
   }
 
   // We couldn't find a socket to reuse, so allocate and connect a new one.
 
   // First, we need to make sure we aren't already servicing a request for this
   // handle (which could happen if we requested, canceled, and then requested
   // with the same handle).
   if (ContainsKey(connecting_socket_map_, handle))
     connecting_socket_map_[handle]->Cancel();
 
-  Request r;
-  r.handle = handle;
   CHECK(callback);
-  r.callback = callback;
-  r.priority = priority;
-  r.host = host;
-  r.port = port;
-  r.load_state = LOAD_STATE_RESOLVING_HOST;
+  Request r(handle, callback, priority, resolve_info,
+            LOAD_STATE_RESOLVING_HOST);
   group_map_[group_name].connecting_requests[handle] = r;
 
   // connecting_socket will delete itself.
   ConnectingSocket* connecting_socket =
       new ConnectingSocket(group_name, handle, client_socket_factory_, this);
-  int rv = connecting_socket->Connect(host, port);
+  int rv = connecting_socket->Connect(resolve_info);
   return rv;
 }
 
 void TCPClientSocketPool::CancelRequest(const std::string& group_name,
                                         const ClientSocketHandle* handle) {
   CHECK(ContainsKey(group_map_, group_name));
 
   Group& group = group_map_[group_name];
 
   // Search pending_requests for matching handle.
@@ skipping 151 matching lines @@
   } else {
     delete socket;
   }
 
   // Process one pending request.
   if (!group.pending_requests.empty()) {
     Request r = group.pending_requests.front();
     group.pending_requests.pop_front();
 
     int rv = RequestSocket(
-        group_name, r.host, r.port, r.priority, r.handle, r.callback);
+        group_name, r.resolve_info, r.priority, r.handle, r.callback);
     if (rv != ERR_IO_PENDING)
       r.callback->Run(rv);
     return;
   }
 
   // Delete group if no longer needed.
   if (group.active_socket_count == 0 && group.idle_sockets.empty()) {
     CHECK(group.pending_requests.empty());
     CHECK(group.connecting_requests.empty());
     group_map_.erase(i);
   }
 }
 
 }  // namespace net