Add a "LoadLog*" parameter to transactions, hostresolver, clientsocketpool.

net/socket/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/socket/tcp_client_socket_pool.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
@@ skipping 71 matching lines @@
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != kStateNone);
 
   return rv;
 }
 
 int TCPConnectJob::DoResolveHost() {
   set_load_state(LOAD_STATE_RESOLVING_HOST);
   next_state_ = kStateResolveHostComplete;
-  return resolver_.Resolve(resolve_info_, &addresses_, &callback_);
+  return resolver_.Resolve(NULL, resolve_info_, &addresses_, &callback_);
 }
 
 int TCPConnectJob::DoResolveHostComplete(int result) {
   DCHECK_EQ(LOAD_STATE_RESOLVING_HOST, load_state());
   if (result == OK)
     next_state_ = kStateTCPConnect;
   return result;
 }
 
 int TCPConnectJob::DoTCPConnect() {
@@ skipping 39 matching lines @@
     int max_sockets_per_group,
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory)
     : base_(new ClientSocketPoolBase(
         max_sockets, max_sockets_per_group,
         new TCPConnectJobFactory(client_socket_factory, host_resolver))) {}
 
 TCPClientSocketPool::~TCPClientSocketPool() {}
 
 int TCPClientSocketPool::RequestSocket(
+    LoadLog* load_log,
     const std::string& group_name,
     const HostResolver::RequestInfo& resolve_info,
     int priority,
     ClientSocketHandle* handle,
     CompletionCallback* callback) {
   return base_->RequestSocket(
-      group_name, resolve_info, priority, handle, callback);
+      load_log, group_name, resolve_info, priority, handle, callback);
 }
 
 void TCPClientSocketPool::CancelRequest(
     const std::string& group_name,
     const ClientSocketHandle* handle) {
   base_->CancelRequest(group_name, handle);
 }
 
 void TCPClientSocketPool::ReleaseSocket(
     const std::string& group_name,
     ClientSocket* socket) {
   base_->ReleaseSocket(group_name, socket);
 }
 
 void TCPClientSocketPool::CloseIdleSockets() {
   base_->CloseIdleSockets();
 }
 
 int TCPClientSocketPool::IdleSocketCountInGroup(
     const std::string& group_name) const {
   return base_->IdleSocketCountInGroup(group_name);
 }
 
 LoadState TCPClientSocketPool::GetLoadState(
     const std::string& group_name, const ClientSocketHandle* handle) const {
   return base_->GetLoadState(group_name, handle);
 }
 
 }  // namespace net