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

net/socket/client_socket_pool_base.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/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
@@ skipping 85 matching lines @@
 // static
 void ClientSocketPoolBase::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 ClientSocketPoolBase::RequestSocket(
+    LoadLog* load_log,
     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);
   DCHECK(callback);
   Group& group = group_map_[group_name];
 
   // Can we make another active socket now?
   if (ReachedMaxSocketsLimit() ||
       !group.HasAvailableSocketSlot(max_sockets_per_group_)) {
     if (ReachedMaxSocketsLimit()) {
       // We could check if we really have a stalled group here, but it requires
       // a scan of all groups, so just flip a flag here, and do the check later.
       may_have_stalled_group_ = true;
     }
     CHECK(callback);
-    Request r(handle, callback, priority, resolve_info);
+    Request r(load_log, handle, callback, priority, resolve_info);
     InsertRequestIntoQueue(r, &group.pending_requests);
     return ERR_IO_PENDING;
   }
 
   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!
       HandOutSocket(idle_socket.socket, idle_socket.used, handle, &group);
       return OK;
     }
     delete idle_socket.socket;
   }
 
   // We couldn't find a socket to reuse, so allocate and connect a new one.
 
   CHECK(callback);
-  Request r(handle, callback, priority, resolve_info);
+  Request r(load_log, handle, callback, priority, resolve_info);
   scoped_ptr<ConnectJob> connect_job(
       connect_job_factory_->NewConnectJob(group_name, r, this));
 
   int rv = connect_job->Connect();
   if (rv == OK) {
     HandOutSocket(connect_job->ReleaseSocket(), false /* not reused */,
                   handle, &group);
   } else if (rv == ERR_IO_PENDING) {
     connecting_socket_count_++;
 
@@ skipping 335 matching lines @@
     group_map_.erase(group_name);
   }
 }
 
 void ClientSocketPoolBase::ProcessPendingRequest(const std::string& group_name,
                                                  Group* group) {
   Request r = group->pending_requests.front();
   group->pending_requests.pop_front();
 
   int rv = RequestSocket(
-      group_name, r.resolve_info, r.priority, r.handle, r.callback);
+      r.load_log, group_name, r.resolve_info, r.priority, r.handle, r.callback);
 
   if (rv != ERR_IO_PENDING) {
     r.callback->Run(rv);
     if (rv != OK) {
       // |group| may be invalid after the callback, we need to search
       // |group_map_| again.
       MaybeOnAvailableSocketSlot(group_name);
     }
   }
 }
@@ skipping 38 matching lines @@
 }
 
 bool ClientSocketPoolBase::ReachedMaxSocketsLimit() const {
   // Each connecting socket will eventually connect and be handed out.
   int total = handed_out_socket_count_ + connecting_socket_count_;
   DCHECK_LE(total, max_sockets_);
   return total == max_sockets_;
 }
 
 }  // namespace net