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

net/socket/client_socket_pool_base.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_SOCKET_CLIENT_SOCKET_POOL_BASE_H_
 #define NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_
 
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_resolver.h"
+#include "net/base/load_log.h"
 #include "net/base/load_states.h"
 #include "net/socket/client_socket.h"
 #include "net/socket/client_socket_pool.h"
 
 namespace net {
 
 class ClientSocketHandle;
 class ClientSocketPoolBase;
 
 // ConnectJob provides an abstract interface for "connecting" a socket.
@@ skipping 72 matching lines @@
   // 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()
         : handle(NULL),
           callback(NULL),
           priority(0),
           resolve_info(std::string(), 0) {}
 
-    Request(ClientSocketHandle* handle,
+    Request(LoadLog* load_log,
+            ClientSocketHandle* handle,
             CompletionCallback* callback,
             int priority,
             const HostResolver::RequestInfo& resolve_info)
-        : handle(handle), callback(callback), priority(priority),
-          resolve_info(resolve_info) {
+        : load_log(load_log), handle(handle), callback(callback),
+          priority(priority), resolve_info(resolve_info) {
     }
 
+    scoped_refptr<LoadLog> load_log;
     ClientSocketHandle* handle;
     CompletionCallback* callback;
     int priority;
     HostResolver::RequestInfo resolve_info;
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const Request& request,
         ConnectJob::Delegate* delegate) const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   ClientSocketPoolBase(int max_sockets,
                        int max_sockets_per_group,
                        ConnectJobFactory* connect_job_factory);
 
   ~ClientSocketPoolBase();
 
-  int RequestSocket(const std::string& group_name,
+  int RequestSocket(LoadLog* load_log,
+                    const std::string& group_name,
                     const HostResolver::RequestInfo& resolve_info,
                     int priority,
                     ClientSocketHandle* handle,
                     CompletionCallback* callback);
 
   void CancelRequest(const std::string& group_name,
                      const ClientSocketHandle* handle);
 
   void ReleaseSocket(const std::string& group_name,
                      ClientSocket* socket);
@@ skipping 183 matching lines @@
 
   // Controls whether or not we use late binding of sockets.
   static bool g_late_binding;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_