LoadLog is used as an output parameter, reorder it to the last parameter.

Review URL: http://codereview.chromium.org/164531

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@23419 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 120 insertions, 123 deletions

diff --git a/net/socket/client_socket_handle.cc b/net/socket/client_socket_handle.cc
index 6c12f70..7c3b182 100644
--- a/net/socket/client_socket_handle.cc
+++ b/net/socket/client_socket_handle.cc
@@ -23,16 +23,16 @@ ClientSocketHandle::~ClientSocketHandle() {
   Reset();
 }
 
-int ClientSocketHandle::Init(LoadLog* load_log,
-                             const std::string& group_name,
+int ClientSocketHandle::Init(const std::string& group_name,
                              const HostResolver::RequestInfo& resolve_info,
                              int priority,
-                             CompletionCallback* callback) {
+                             CompletionCallback* callback,
+                             LoadLog* load_log) {
   CHECK(!group_name.empty());
   ResetInternal(true);
   group_name_ = group_name;
   int rv = pool_->RequestSocket(
-      load_log, group_name, resolve_info, priority, this, &callback_);
+      group_name, resolve_info, priority, this, &callback_, load_log);
   if (rv == ERR_IO_PENDING) {
     user_callback_ = callback;
   } else {
diff --git a/net/socket/client_socket_handle.h b/net/socket/client_socket_handle.h
index f1d85899..0dbb1bc 100644
--- a/net/socket/client_socket_handle.h
+++ b/net/socket/client_socket_handle.h
@@ -47,11 +47,11 @@ class ClientSocketHandle {
   // Init may be called multiple times.
   //
   // Profiling information for the request is saved to |load_log| if non-NULL.
-  int Init(LoadLog* load_log,
-           const std::string& group_name,
+  int Init(const std::string& group_name,
            const HostResolver::RequestInfo& resolve_info,
            int priority,
-           CompletionCallback* callback);
+           CompletionCallback* callback,
+           LoadLog* load_log);
 
   // An initialized handle can be reset, which causes it to return to the
   // un-initialized state.  This releases the underlying socket, which in the
diff --git a/net/socket/client_socket_pool.h b/net/socket/client_socket_pool.h
index b6a740d..ae0f48a 100644
--- a/net/socket/client_socket_pool.h
+++ b/net/socket/client_socket_pool.h
@@ -47,12 +47,12 @@ class ClientSocketPool : public base::RefCounted<ClientSocketPool> {
   // client of completion.
   //
   // Profiling information for the request is saved to |load_log| if non-NULL.
-  virtual int RequestSocket(LoadLog* load_log,
-                            const std::string& group_name,
+  virtual int RequestSocket(const std::string& group_name,
                             const HostResolver::RequestInfo& resolve_info,
                             int priority,
                             ClientSocketHandle* handle,
-                            CompletionCallback* callback) = 0;
+                            CompletionCallback* callback,
+                            LoadLog* load_log) = 0;
 
   // Called to cancel a RequestSocket call that returned ERR_IO_PENDING.  The
   // same handle parameter must be passed to this method as was passed to the
diff --git a/net/socket/client_socket_pool_base.cc b/net/socket/client_socket_pool_base.cc
index 4261c55..a45d74a 100644
--- a/net/socket/client_socket_pool_base.cc
+++ b/net/socket/client_socket_pool_base.cc
@@ -103,12 +103,12 @@ void ClientSocketPoolBase::InsertRequestIntoQueue(
 }
 
 int ClientSocketPoolBase::RequestSocket(
-    LoadLog* load_log,
     const std::string& group_name,
     const HostResolver::RequestInfo& resolve_info,
     int priority,
     ClientSocketHandle* handle,
-    CompletionCallback* callback) {
+    CompletionCallback* callback,
+    LoadLog* load_log) {
   DCHECK(!resolve_info.hostname().empty());
   DCHECK_GE(priority, 0);
   DCHECK(callback);
@@ -123,7 +123,7 @@ int ClientSocketPoolBase::RequestSocket(
       may_have_stalled_group_ = true;
     }
     CHECK(callback);
-    Request r(load_log, handle, callback, priority, resolve_info);
+    Request r(handle, callback, priority, resolve_info, load_log);
     InsertRequestIntoQueue(r, &group.pending_requests);
     return ERR_IO_PENDING;
   }
@@ -143,7 +143,7 @@ int ClientSocketPoolBase::RequestSocket(
   // We couldn't find a socket to reuse, so allocate and connect a new one.
 
   CHECK(callback);
-  Request r(load_log, handle, callback, priority, resolve_info);
+  Request r(handle, callback, priority, resolve_info, load_log);
   scoped_ptr<ConnectJob> connect_job(
       connect_job_factory_->NewConnectJob(group_name, r, this));
 
@@ -499,7 +499,7 @@ void ClientSocketPoolBase::ProcessPendingRequest(const std::string& group_name,
   group->pending_requests.pop_front();
 
   int rv = RequestSocket(
-      r.load_log, group_name, r.resolve_info, r.priority, r.handle, r.callback);
+      group_name, r.resolve_info, r.priority, r.handle, r.callback, r.load_log);
 
   if (rv != ERR_IO_PENDING) {
     r.callback->Run(rv);
diff --git a/net/socket/client_socket_pool_base.h b/net/socket/client_socket_pool_base.h
index 762c0ed..4ae96f8 100644
--- a/net/socket/client_socket_pool_base.h
+++ b/net/socket/client_socket_pool_base.h
@@ -110,11 +110,11 @@ class ClientSocketPoolBase
           priority(0),
           resolve_info(std::string(), 0) {}
 
-    Request(LoadLog* load_log,
-            ClientSocketHandle* handle,
+    Request(ClientSocketHandle* handle,
             CompletionCallback* callback,
             int priority,
-            const HostResolver::RequestInfo& resolve_info)
+            const HostResolver::RequestInfo& resolve_info,
+            LoadLog* load_log)
         : load_log(load_log), handle(handle), callback(callback),
           priority(priority), resolve_info(resolve_info) {
     }
@@ -146,12 +146,12 @@ class ClientSocketPoolBase
 
   ~ClientSocketPoolBase();
 
-  int RequestSocket(LoadLog* load_log,
-                    const std::string& group_name,
+  int RequestSocket(const std::string& group_name,
                     const HostResolver::RequestInfo& resolve_info,
                     int priority,
                     ClientSocketHandle* handle,
-                    CompletionCallback* callback);
+                    CompletionCallback* callback,
+                    LoadLog* load_log);
 
   void CancelRequest(const std::string& group_name,
                      const ClientSocketHandle* handle);
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index 3139b27..963d017 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -248,14 +248,14 @@ class TestClientSocketPool : public ClientSocketPool {
           max_sockets, max_sockets_per_group, connect_job_factory)) {}
 
   virtual int RequestSocket(
-      LoadLog* load_log,
       const std::string& group_name,
       const HostResolver::RequestInfo& resolve_info,
       int priority,
       ClientSocketHandle* handle,
-      CompletionCallback* callback) {
+      CompletionCallback* callback,
+      LoadLog* load_log) {
     return base_->RequestSocket(
-        NULL, group_name, resolve_info, priority, handle, callback);
+        group_name, resolve_info, priority, handle, callback, load_log);
   }
 
   virtual void CancelRequest(
@@ -416,8 +416,8 @@ TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
 
   TestCompletionCallback callback;
   ClientSocketHandle handle(pool_.get());
-  EXPECT_EQ(OK, handle.Init(NULL, "a", ignored_request_info_,
-                            kDefaultPriority, &callback));
+  EXPECT_EQ(OK, handle.Init("a", ignored_request_info_,
+                            kDefaultPriority, &callback, NULL));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   handle.Reset();
@@ -428,7 +428,7 @@ TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
-  int rv = req.handle()->Init(NULL, "a", ignored_request_info_, 0, &req);
+  int rv = req.handle()->Init("a", ignored_request_info_, 0, &req, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(OK, req.WaitForResult());
@@ -443,8 +443,8 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, InitConnectionAsynchronousFailure) {
@@ -453,8 +453,8 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionAsynchronousFailure) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
 }
@@ -745,8 +745,8 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
   req.handle()->Reset();
 }
 
@@ -758,11 +758,11 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
   TestSocketRequest req2(pool_.get(), &request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
   EXPECT_EQ(ERR_IO_PENDING,
-            req2.handle()->Init(NULL, "a", ignored_request_info_,
-                                kDefaultPriority, &req2));
+            req2.handle()->Init("a", ignored_request_info_,
+                                kDefaultPriority, &req2, NULL));
 
   req.handle()->Reset();
 
@@ -779,15 +779,15 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init(NULL, "a", ignored_request_info_,
-                        kDefaultPriority, &callback));
+            handle.Init("a", ignored_request_info_,
+                        kDefaultPriority, &callback, NULL));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init(NULL, "a", ignored_request_info_,
-                        kDefaultPriority, &callback2));
+            handle.Init("a", ignored_request_info_,
+                        kDefaultPriority, &callback2, NULL));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
@@ -849,8 +849,8 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
       handle_->Reset();
       within_callback_ = true;
       int rv = handle_->Init(
-          NULL, "a", HostResolver::RequestInfo("www.google.com", 80),
-          kDefaultPriority, this);
+          "a", HostResolver::RequestInfo("www.google.com", 80),
+          kDefaultPriority, this, NULL);
       switch (next_job_type_) {
         case TestConnectJob::kMockJob:
           EXPECT_EQ(OK, rv);
@@ -885,7 +885,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
   RequestSocketCallback callback(
       &handle, connect_job_factory_, TestConnectJob::kMockPendingJob);
   int rv = handle.Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &callback);
+      "a", ignored_request_info_, kDefaultPriority, &callback, NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -900,7 +900,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
   RequestSocketCallback callback(
       &handle, connect_job_factory_, TestConnectJob::kMockJob);
   int rv = handle.Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &callback);
+      "a", ignored_request_info_, kDefaultPriority, &callback, NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -963,14 +963,14 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
 
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   int rv = req.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req);
+      "a", ignored_request_info_, kDefaultPriority, &req, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   req.handle()->Reset();
 
   rv = req.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req);
+      "a", ignored_request_info_, kDefaultPriority, &req, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req.WaitForResult());
 
@@ -990,14 +990,14 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
 
   // Start job 1 (async error).
   TestSocketRequest req1(pool_.get(), &request_order_, &completion_count_);
-  int rv = req1.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req1);
+  int rv = req1.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Start job 2 (async error).
   TestSocketRequest req2(pool_.get(), &request_order_, &completion_count_);
   rv = req2.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req2);
+      "a", ignored_request_info_, kDefaultPriority, &req2, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
@@ -1006,7 +1006,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
   // Request 3 does not have a ConnectJob yet.  It's just pending.
   TestSocketRequest req3(pool_.get(), &request_order_, &completion_count_);
   rv = req3.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req3);
+      "a", ignored_request_info_, kDefaultPriority, &req3, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
@@ -1033,8 +1033,8 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req1(pool_.get(), &request_order_, &completion_count_);
-  int rv = req1.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req1);
+  int rv = req1.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
@@ -1043,7 +1043,7 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
 
   TestSocketRequest req2(pool_.get(), &request_order_, &completion_count_);
   rv = req2.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req2);
+      "a", ignored_request_info_, kDefaultPriority, &req2, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   req1.handle()->Reset();
   MessageLoop::current()->RunAllPending();  // Run the DoReleaseSocket()
@@ -1053,7 +1053,7 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
 
   TestSocketRequest req3(pool_.get(), &request_order_, &completion_count_);
   rv = req3.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req3);
+      "a", ignored_request_info_, kDefaultPriority, &req3, NULL);
   EXPECT_EQ(OK, rv);
 
   EXPECT_FALSE(req2.handle()->socket());
@@ -1150,8 +1150,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, BasicSynchronous) {
 
   TestCompletionCallback callback;
   ClientSocketHandle handle(pool_.get());
-  EXPECT_EQ(OK, handle.Init(NULL, "a", ignored_request_info_, kDefaultPriority,
-                            &callback));
+  EXPECT_EQ(OK, handle.Init("a", ignored_request_info_, kDefaultPriority,
+                            &callback, NULL));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   handle.Reset();
@@ -1162,7 +1162,7 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, BasicAsynchronous) {
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
-  int rv = req.handle()->Init(NULL, "a", ignored_request_info_, 0, &req);
+  int rv = req.handle()->Init("a", ignored_request_info_, 0, &req, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(OK, req.WaitForResult());
@@ -1177,8 +1177,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, InitConnectionFailure) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
 }
 
 TEST_F(ClientSocketPoolBaseTest_LateBinding,
@@ -1188,8 +1188,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding,
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
 }
@@ -1253,8 +1253,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, CancelRequestClearGroup) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
   req.handle()->Reset();
 }
 
@@ -1266,11 +1266,11 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, TwoRequestsCancelOne) {
   TestSocketRequest req2(pool_.get(), &request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req));
+            req.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req, NULL));
   EXPECT_EQ(ERR_IO_PENDING,
-            req2.handle()->Init(NULL, "a", ignored_request_info_,
-                                kDefaultPriority, &req2));
+            req2.handle()->Init("a", ignored_request_info_,
+                                kDefaultPriority, &req2, NULL));
 
   req.handle()->Reset();
 
@@ -1287,15 +1287,15 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, ConnectCancelConnect) {
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init(NULL, "a", ignored_request_info_,
-                        kDefaultPriority, &callback));
+            handle.Init("a", ignored_request_info_,
+                        kDefaultPriority, &callback, NULL));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init(NULL, "a", ignored_request_info_,
-                        kDefaultPriority, &callback2));
+            handle.Init("a", ignored_request_info_,
+                        kDefaultPriority, &callback2, NULL));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
@@ -1368,7 +1368,7 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, RequestPendingJobTwice) {
   RequestSocketCallback callback(
       &handle, connect_job_factory_, TestConnectJob::kMockPendingJob);
   int rv = handle.Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &callback);
+      "a", ignored_request_info_, kDefaultPriority, &callback, NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -1383,7 +1383,7 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, RequestPendingJobThenSynchronous) {
   RequestSocketCallback callback(
       &handle, connect_job_factory_, TestConnectJob::kMockJob);
   int rv = handle.Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &callback);
+      "a", ignored_request_info_, kDefaultPriority, &callback, NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -1449,14 +1449,14 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding,
 
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   int rv = req.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req);
+      "a", ignored_request_info_, kDefaultPriority, &req, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   req.handle()->Reset();
 
   rv = req.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req);
+      "a", ignored_request_info_, kDefaultPriority, &req, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req.WaitForResult());
 
@@ -1474,8 +1474,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, ReleaseSockets) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req1(pool_.get(), &request_order_, &completion_count_);
-  int rv = req1.handle()->Init(NULL, "a", ignored_request_info_,
-                               kDefaultPriority, &req1);
+  int rv = req1.handle()->Init("a", ignored_request_info_,
+                               kDefaultPriority, &req1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
@@ -1485,11 +1485,11 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, ReleaseSockets) {
 
   TestSocketRequest req2(pool_.get(), &request_order_, &completion_count_);
   rv = req2.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req2);
+      "a", ignored_request_info_, kDefaultPriority, &req2, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   TestSocketRequest req3(pool_.get(), &request_order_, &completion_count_);
   rv = req3.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req3);
+      "a", ignored_request_info_, kDefaultPriority, &req3, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Both Requests 2 and 3 are pending.  We release socket 1 which should
@@ -1521,12 +1521,12 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, PendingJobCompletionOrder) {
 
   TestSocketRequest req1(pool_.get(), &request_order_, &completion_count_);
   int rv = req1.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req1);
+      "a", ignored_request_info_, kDefaultPriority, &req1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req2(pool_.get(), &request_order_, &completion_count_);
   rv = req2.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req2);
+      "a", ignored_request_info_, kDefaultPriority, &req2, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
@@ -1534,7 +1534,7 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, PendingJobCompletionOrder) {
 
   TestSocketRequest req3(pool_.get(), &request_order_, &completion_count_);
   rv = req3.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req3);
+      "a", ignored_request_info_, kDefaultPriority, &req3, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
@@ -1554,7 +1554,7 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, DISABLED_LoadState) {
 
   TestSocketRequest req1(pool_.get(), &request_order_, &completion_count_);
   int rv = req1.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req1);
+      "a", ignored_request_info_, kDefaultPriority, &req1, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_IDLE, req1.handle()->GetLoadState());
 
@@ -1562,7 +1562,7 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, DISABLED_LoadState) {
 
   TestSocketRequest req2(pool_.get(), &request_order_, &completion_count_);
   rv = req2.handle()->Init(
-      NULL, "a", ignored_request_info_, kDefaultPriority, &req2);
+      "a", ignored_request_info_, kDefaultPriority, &req2, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, req1.handle()->GetLoadState());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, req2.handle()->GetLoadState());
diff --git a/net/socket/socket_test_util.cc b/net/socket/socket_test_util.cc
index 0f61714..30927ad 100644
--- a/net/socket/socket_test_util.cc
+++ b/net/socket/socket_test_util.cc
@@ -337,8 +337,8 @@ int ClientSocketPoolTest::StartRequestUsingPool(ClientSocketPool* socket_pool,
                                                      &request_order_,
                                                      &completion_count_);
   requests_.push_back(request);
-  int rv = request->handle()->Init(NULL, group_name, ignored_request_info_,
-                                   priority, request);
+  int rv = request->handle()->Init(group_name, ignored_request_info_,
+                                   priority, request, NULL);
   if (rv != ERR_IO_PENDING)
     request_order_.push_back(request);
   return rv;
diff --git a/net/socket/socks5_client_socket.cc b/net/socket/socks5_client_socket.cc
index bb058cb..a4fca1a 100644
--- a/net/socket/socks5_client_socket.cc
+++ b/net/socket/socks5_client_socket.cc
@@ -177,7 +177,7 @@ int SOCKS5ClientSocket::DoResolveHost() {
 
   next_state_ = STATE_RESOLVE_HOST_COMPLETE;
   return host_resolver_.Resolve(
-      NULL, host_request_info_, &addresses_, &io_callback_);
+      host_request_info_, &addresses_, &io_callback_, NULL);
 }
 
 int SOCKS5ClientSocket::DoResolveHostComplete(int result) {
@@ -428,4 +428,3 @@ int SOCKS5ClientSocket::GetPeerName(struct sockaddr* name,
 #endif
 
 }  // namespace net
-
diff --git a/net/socket/socks5_client_socket_unittest.cc b/net/socket/socks5_client_socket_unittest.cc
index 3ad5bab..9dedc39 100644
--- a/net/socket/socks5_client_socket_unittest.cc
+++ b/net/socket/socks5_client_socket_unittest.cc
@@ -59,7 +59,7 @@ void SOCKS5ClientSocketTest::SetUp() {
 
   // Resolve the "localhost" AddressList used by the TCP connection to connect.
   HostResolver::RequestInfo info("www.socks-proxy.com", 1080);
-  int rv = host_resolver_->Resolve(NULL, info, &address_list_, NULL, NULL);
+  int rv = host_resolver_->Resolve(info, &address_list_, NULL, NULL, NULL);
   ASSERT_EQ(OK, rv);
 }
 
@@ -285,4 +285,3 @@ TEST_F(SOCKS5ClientSocketTest, PartialReadWrites) {
 }
 
 }  // namespace net
-
diff --git a/net/socket/socks_client_socket.cc b/net/socket/socks_client_socket.cc
index 8b08dc1..31f362e 100644
--- a/net/socket/socks_client_socket.cc
+++ b/net/socket/socks_client_socket.cc
@@ -197,7 +197,7 @@ int SOCKSClientSocket::DoResolveHost() {
 
   next_state_ = STATE_RESOLVE_HOST_COMPLETE;
   return host_resolver_.Resolve(
-      NULL, host_request_info_, &addresses_, &io_callback_);
+      host_request_info_, &addresses_, &io_callback_, NULL);
 }
 
 int SOCKSClientSocket::DoResolveHostComplete(int result) {
@@ -383,4 +383,3 @@ int SOCKSClientSocket::GetPeerName(struct sockaddr* name,
 #endif
 
 }  // namespace net
-
diff --git a/net/socket/ssl_client_socket_unittest.cc b/net/socket/ssl_client_socket_unittest.cc
index cb8efe1..d565ab6 100644
--- a/net/socket/ssl_client_socket_unittest.cc
+++ b/net/socket/ssl_client_socket_unittest.cc
@@ -91,7 +91,7 @@ TEST_F(SSLClientSocketTest, MAYBE_Connect) {
   TestCompletionCallback callback;
 
   net::HostResolver::RequestInfo info(server_.kHostName, server_.kOKHTTPSPort);
-  int rv = resolver_->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver_->Resolve(info, &addr, NULL, NULL, NULL);
   EXPECT_EQ(net::OK, rv);
 
   net::ClientSocket *transport = new net::TCPClientSocket(addr);
@@ -128,7 +128,7 @@ TEST_F(SSLClientSocketTest, MAYBE_ConnectExpired) {
   TestCompletionCallback callback;
 
   net::HostResolver::RequestInfo info(server_.kHostName, server_.kBadHTTPSPort);
-  int rv = resolver_->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver_->Resolve(info, &addr, NULL, NULL, NULL);
   EXPECT_EQ(net::OK, rv);
 
   net::ClientSocket *transport = new net::TCPClientSocket(addr);
@@ -165,7 +165,7 @@ TEST_F(SSLClientSocketTest, MAYBE_ConnectMismatched) {
 
   net::HostResolver::RequestInfo info(server_.kMismatchedHostName,
                                       server_.kOKHTTPSPort);
-  int rv = resolver_->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver_->Resolve(info, &addr, NULL, NULL, NULL);
   EXPECT_EQ(net::OK, rv);
 
   net::ClientSocket *transport = new net::TCPClientSocket(addr);
@@ -206,7 +206,7 @@ TEST_F(SSLClientSocketTest, MAYBE_Read) {
   TestCompletionCallback callback;
 
   net::HostResolver::RequestInfo info(server_.kHostName, server_.kOKHTTPSPort);
-  int rv = resolver_->Resolve(NULL, info, &addr, &callback, NULL);
+  int rv = resolver_->Resolve(info, &addr, &callback, NULL, NULL);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
@@ -266,7 +266,7 @@ TEST_F(SSLClientSocketTest, MAYBE_Read_SmallChunks) {
   TestCompletionCallback callback;
 
   net::HostResolver::RequestInfo info(server_.kHostName, server_.kOKHTTPSPort);
-  int rv = resolver_->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver_->Resolve(info, &addr, NULL, NULL, NULL);
   EXPECT_EQ(net::OK, rv);
 
   net::ClientSocket *transport = new net::TCPClientSocket(addr);
@@ -321,7 +321,7 @@ TEST_F(SSLClientSocketTest, MAYBE_Read_Interrupted) {
   TestCompletionCallback callback;
 
   net::HostResolver::RequestInfo info(server_.kHostName, server_.kOKHTTPSPort);
-  int rv = resolver_->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver_->Resolve(info, &addr, NULL, NULL, NULL);
   EXPECT_EQ(net::OK, rv);
 
   net::ClientSocket *transport = new net::TCPClientSocket(addr);
diff --git a/net/socket/ssl_test_util.cc b/net/socket/ssl_test_util.cc
index 298db77..f6dc15e 100644
--- a/net/socket/ssl_test_util.cc
+++ b/net/socket/ssl_test_util.cc
@@ -266,7 +266,7 @@ bool TestServerLauncher::WaitToStart(const std::string& host_name, int port) {
   net::AddressList addr;
   scoped_refptr<net::HostResolver> resolver(net::CreateSystemHostResolver());
   net::HostResolver::RequestInfo info(host_name, port);
-  int rv = resolver->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver->Resolve(info, &addr, NULL, NULL, NULL);
   if (rv != net::OK)
     return false;
 
diff --git a/net/socket/tcp_client_socket_pool.cc b/net/socket/tcp_client_socket_pool.cc
index 46aab4d..ae080dd 100644
--- a/net/socket/tcp_client_socket_pool.cc
+++ b/net/socket/tcp_client_socket_pool.cc
@@ -89,7 +89,7 @@ int TCPConnectJob::DoLoop(int result) {
 int TCPConnectJob::DoResolveHost() {
   set_load_state(LOAD_STATE_RESOLVING_HOST);
   next_state_ = kStateResolveHostComplete;
-  return resolver_.Resolve(NULL, resolve_info_, &addresses_, &callback_);
+  return resolver_.Resolve(resolve_info_, &addresses_, &callback_, NULL);
 }
 
 int TCPConnectJob::DoResolveHostComplete(int result) {
@@ -149,14 +149,14 @@ TCPClientSocketPool::TCPClientSocketPool(
 TCPClientSocketPool::~TCPClientSocketPool() {}
 
 int TCPClientSocketPool::RequestSocket(
-    LoadLog* load_log,
     const std::string& group_name,
     const HostResolver::RequestInfo& resolve_info,
     int priority,
     ClientSocketHandle* handle,
-    CompletionCallback* callback) {
+    CompletionCallback* callback,
+    LoadLog* load_log) {
   return base_->RequestSocket(
-      load_log, group_name, resolve_info, priority, handle, callback);
+      group_name, resolve_info, priority, handle, callback, load_log);
 }
 
 void TCPClientSocketPool::CancelRequest(
diff --git a/net/socket/tcp_client_socket_pool.h b/net/socket/tcp_client_socket_pool.h
index 55a2f63..8533d0e 100644
--- a/net/socket/tcp_client_socket_pool.h
+++ b/net/socket/tcp_client_socket_pool.h
@@ -80,12 +80,12 @@ class TCPClientSocketPool : public ClientSocketPool {
 
   // ClientSocketPool methods:
 
-  virtual int RequestSocket(LoadLog* load_log,
-                            const std::string& group_name,
+  virtual int RequestSocket(const std::string& group_name,
                             const HostResolver::RequestInfo& resolve_info,
                             int priority,
                             ClientSocketHandle* handle,
-                            CompletionCallback* callback);
+                            CompletionCallback* callback,
+                            LoadLog* load_log);
 
   virtual void CancelRequest(const std::string& group_name,
                              const ClientSocketHandle* handle);
diff --git a/net/socket/tcp_client_socket_pool_unittest.cc b/net/socket/tcp_client_socket_pool_unittest.cc
index 649790a..9dd3974 100644
--- a/net/socket/tcp_client_socket_pool_unittest.cc
+++ b/net/socket/tcp_client_socket_pool_unittest.cc
@@ -209,7 +209,7 @@ TEST_F(TCPClientSocketPoolTest, Basic) {
   TestCompletionCallback callback;
   ClientSocketHandle handle(pool_.get());
   HostResolver::RequestInfo info("www.google.com", 80);
-  int rv = handle.Init(NULL, "a", info, 0, &callback);
+  int rv = handle.Init("a", info, 0, &callback, NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ -226,7 +226,7 @@ TEST_F(TCPClientSocketPoolTest, InitHostResolutionFailure) {
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   HostResolver::RequestInfo info("unresolvable.host.name", 80);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", info, kDefaultPriority, &req));
+            req.handle()->Init("a", info, kDefaultPriority, &req, NULL));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req.WaitForResult());
 }
 
@@ -236,13 +236,13 @@ TEST_F(TCPClientSocketPoolTest, InitConnectionFailure) {
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   HostResolver::RequestInfo info("a", 80);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", info, kDefaultPriority, &req));
+            req.handle()->Init("a", info, kDefaultPriority, &req, NULL));
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
 
   // Make the host resolutions complete synchronously this time.
   host_resolver_->set_synchronous_mode(true);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            req.handle()->Init(NULL, "a", info, kDefaultPriority, &req));
+            req.handle()->Init("a", info, kDefaultPriority, &req, NULL));
 }
 
 TEST_F(TCPClientSocketPoolTest, PendingRequests) {
@@ -348,7 +348,7 @@ TEST_F(TCPClientSocketPoolTest, CancelRequestClearGroup) {
   TestSocketRequest req(pool_.get(), &request_order_, &completion_count_);
   HostResolver::RequestInfo info("www.google.com", 80);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", info, kDefaultPriority, &req));
+            req.handle()->Init("a", info, kDefaultPriority, &req, NULL));
   req.handle()->Reset();
 
   PlatformThread::Sleep(100);
@@ -367,9 +367,9 @@ TEST_F(TCPClientSocketPoolTest, TwoRequestsCancelOne) {
 
   HostResolver::RequestInfo info("www.google.com", 80);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init(NULL, "a", info, kDefaultPriority, &req));
+            req.handle()->Init("a", info, kDefaultPriority, &req, NULL));
   EXPECT_EQ(ERR_IO_PENDING,
-            req2.handle()->Init(NULL, "a", info, kDefaultPriority, &req2));
+            req2.handle()->Init("a", info, kDefaultPriority, &req2, NULL));
 
   req.handle()->Reset();
 
@@ -386,13 +386,13 @@ TEST_F(TCPClientSocketPoolTest, ConnectCancelConnect) {
 
   HostResolver::RequestInfo info("www.google.com", 80);
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init(NULL, "a", info, kDefaultPriority, &callback));
+            handle.Init("a", info, kDefaultPriority, &callback, NULL));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init(NULL, "a", info, kDefaultPriority, &callback2));
+            handle.Init("a", info, kDefaultPriority, &callback2, NULL));
 
   host_resolver_->set_synchronous_mode(true);
   // At this point, handle has two ConnectingSockets out for it.  Due to the
@@ -481,8 +481,8 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
     if (!within_callback_) {
       handle_->Reset();
       within_callback_ = true;
-      int rv = handle_->Init(NULL, "a",
-          HostResolver::RequestInfo("www.google.com", 80), 0, this);
+      int rv = handle_->Init(
+          "a", HostResolver::RequestInfo("www.google.com", 80), 0, this, NULL);
       EXPECT_EQ(OK, rv);
     }
   }
@@ -500,8 +500,8 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
 TEST_F(TCPClientSocketPoolTest, RequestTwice) {
   ClientSocketHandle handle(pool_.get());
   RequestSocketCallback callback(&handle);
-  int rv = handle.Init(NULL, "a",
-      HostResolver::RequestInfo("www.google.com", 80), 0, &callback);
+  int rv = handle.Init(
+      "a", HostResolver::RequestInfo("www.google.com", 80), 0, &callback, NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   // The callback is going to request "www.google.com". We want it to complete
diff --git a/net/socket/tcp_client_socket_unittest.cc b/net/socket/tcp_client_socket_unittest.cc
index c2a8495..14d2305 100644
--- a/net/socket/tcp_client_socket_unittest.cc
+++ b/net/socket/tcp_client_socket_unittest.cc
@@ -88,7 +88,7 @@ void TCPClientSocketTest::SetUp() {
   AddressList addr;
   scoped_refptr<HostResolver> resolver(CreateSystemHostResolver());
   HostResolver::RequestInfo info("localhost", listen_port_);
-  int rv = resolver->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver->Resolve(info, &addr, NULL, NULL, NULL);
   CHECK(rv == OK);
   sock_.reset(new TCPClientSocket(addr));
 }
diff --git a/net/socket/tcp_pinger_unittest.cc b/net/socket/tcp_pinger_unittest.cc
index 0ca1138..1714ebe 100644
--- a/net/socket/tcp_pinger_unittest.cc
+++ b/net/socket/tcp_pinger_unittest.cc
@@ -68,7 +68,7 @@ TEST_F(TCPPingerTest, Ping) {
   scoped_refptr<net::HostResolver> resolver(net::CreateSystemHostResolver());
 
   net::HostResolver::RequestInfo info("localhost", listen_port_);
-  int rv = resolver->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver->Resolve(info, &addr, NULL, NULL, NULL);
   EXPECT_EQ(rv, net::OK);
 
   net::TCPPinger pinger(addr);
@@ -84,7 +84,7 @@ TEST_F(TCPPingerTest, PingFail) {
   listen_sock_ = NULL;
 
   net::HostResolver::RequestInfo info("localhost", listen_port_);
-  int rv = resolver->Resolve(NULL, info, &addr, NULL, NULL);
+  int rv = resolver->Resolve(info, &addr, NULL, NULL, NULL);
   EXPECT_EQ(rv, net::OK);
 
   net::TCPPinger pinger(addr);