Make ClientSocketHandle::Init() typesafe.

Introduce a REGISTER_SOCKET_PARAMS_FOR_POOL macro to register valid SocketParams for a ClientSocketPool subtype.
Update HttpNetworkSession's ClientSocketPool to return the concrete TCPClientSocketPool instead of the parent interface.  Renamed the member variable&accessor.
Updated tests.
BUG=http://crbug.com/13289

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

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

12 files changed, 153 insertions, 120 deletions

diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index 7f7dd61..4d9802a 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -2075,7 +2075,7 @@ void HttpCache::CloseIdleConnections() {
       static_cast<net::HttpNetworkLayer*>(network_layer_.get());
   HttpNetworkSession* session = network->GetSession();
   if (session) {
-    session->connection_pool()->CloseIdleSockets();
+    session->tcp_socket_pool()->CloseIdleSockets();
   }
 }
 
diff --git a/net/http/http_network_layer.cc b/net/http/http_network_layer.cc
index 9d1509d..7f5c142 100644
--- a/net/http/http_network_layer.cc
+++ b/net/http/http_network_layer.cc
@@ -69,7 +69,7 @@ void HttpNetworkLayer::Suspend(bool suspend) {
   suspended_ = suspend;
 
   if (suspend && session_)
-    session_->connection_pool()->CloseIdleSockets();
+    session_->tcp_socket_pool()->CloseIdleSockets();
 }
 
 HttpNetworkSession* HttpNetworkLayer::GetSession() {
diff --git a/net/http/http_network_session.cc b/net/http/http_network_session.cc
index b705766..b7d32c2 100644
--- a/net/http/http_network_session.cc
+++ b/net/http/http_network_session.cc
@@ -18,7 +18,7 @@ HttpNetworkSession::HttpNetworkSession(
     HostResolver* host_resolver,
     ProxyService* proxy_service,
     ClientSocketFactory* client_socket_factory)
-    : connection_pool_(new TCPClientSocketPool(
+    : tcp_socket_pool_(new TCPClientSocketPool(
           max_sockets_, max_sockets_per_group_, host_resolver,
           client_socket_factory)),
       host_resolver_(host_resolver),
diff --git a/net/http/http_network_session.h b/net/http/http_network_session.h
index 08e90ce..b6327c6 100644
--- a/net/http/http_network_session.h
+++ b/net/http/http_network_session.h
@@ -27,9 +27,8 @@ class HttpNetworkSession : public base::RefCounted<HttpNetworkSession> {
   SSLClientAuthCache* ssl_client_auth_cache() {
     return &ssl_client_auth_cache_;
   }
-  // TODO(willchan): Look at making this return a TCPClientSocketPool instead so
-  // we can get type safety information.
-  ClientSocketPool* connection_pool() { return connection_pool_; }
+
+  TCPClientSocketPool* tcp_socket_pool() { return tcp_socket_pool_; }
   HostResolver* host_resolver() { return host_resolver_; }
   ProxyService* proxy_service() { return proxy_service_; }
 #if defined(OS_WIN)
@@ -51,7 +50,7 @@ class HttpNetworkSession : public base::RefCounted<HttpNetworkSession> {
 
   HttpAuthCache auth_cache_;
   SSLClientAuthCache ssl_client_auth_cache_;
-  scoped_refptr<ClientSocketPool> connection_pool_;
+  scoped_refptr<TCPClientSocketPool> tcp_socket_pool_;
   scoped_refptr<HostResolver> host_resolver_;
   scoped_refptr<ProxyService> proxy_service_;
 #if defined(OS_WIN)
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index 669ab35..7d2e6da 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -628,7 +628,7 @@ int HttpNetworkTransaction::DoInitConnection() {
   }
 
   int rv = connection_.Init(connection_group, resolve_info, request_->priority,
-                            &io_callback_, session_->connection_pool(), NULL);
+                            &io_callback_, session_->tcp_socket_pool(), NULL);
   return rv;
 }
 
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index ac10c99..164450e 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -165,10 +165,9 @@ std::string MockGetHostName() {
   return "WTC-WIN7";
 }
 
-class CaptureGroupNameSocketPool : public ClientSocketPool {
+class CaptureGroupNameSocketPool : public TCPClientSocketPool {
  public:
-  CaptureGroupNameSocketPool() {
-  }
+  CaptureGroupNameSocketPool() : TCPClientSocketPool(0, 0, NULL, NULL) {}
   const std::string last_group_name_received() const {
     return last_group_name_;
   }
@@ -1873,11 +1872,11 @@ TEST_F(HttpNetworkTransactionTest, DontRecycleTCPSocketForSSLTunnel) {
 
   // We now check to make sure the TCPClientSocket was not added back to
   // the pool.
-  EXPECT_EQ(0, session->connection_pool()->IdleSocketCount());
+  EXPECT_EQ(0, session->tcp_socket_pool()->IdleSocketCount());
   trans.reset();
   MessageLoop::current()->RunAllPending();
   // Make sure that the socket didn't get recycled after calling the destructor.
-  EXPECT_EQ(0, session->connection_pool()->IdleSocketCount());
+  EXPECT_EQ(0, session->tcp_socket_pool()->IdleSocketCount());
 }
 
 // Make sure that we recycle a socket after reading all of the response body.
@@ -1921,7 +1920,7 @@ TEST_F(HttpNetworkTransactionTest, RecycleSocket) {
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 200 OK", status_line);
 
-  EXPECT_EQ(0, session->connection_pool()->IdleSocketCount());
+  EXPECT_EQ(0, session->tcp_socket_pool()->IdleSocketCount());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -1933,7 +1932,7 @@ TEST_F(HttpNetworkTransactionTest, RecycleSocket) {
   MessageLoop::current()->RunAllPending();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, session->connection_pool()->IdleSocketCount());
+  EXPECT_EQ(1, session->tcp_socket_pool()->IdleSocketCount());
 }
 
 // Make sure that we recycle a socket after a zero-length response.
@@ -1979,7 +1978,7 @@ TEST_F(HttpNetworkTransactionTest, RecycleSocketAfterZeroContentLength) {
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 204 No Content", status_line);
 
-  EXPECT_EQ(0, session->connection_pool()->IdleSocketCount());
+  EXPECT_EQ(0, session->tcp_socket_pool()->IdleSocketCount());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
@@ -1991,7 +1990,7 @@ TEST_F(HttpNetworkTransactionTest, RecycleSocketAfterZeroContentLength) {
   MessageLoop::current()->RunAllPending();
 
   // We now check to make sure the socket was added back to the pool.
-  EXPECT_EQ(1, session->connection_pool()->IdleSocketCount());
+  EXPECT_EQ(1, session->tcp_socket_pool()->IdleSocketCount());
 }
 
 TEST_F(HttpNetworkTransactionTest, ResendRequestOnWriteBodyError) {
@@ -3330,7 +3329,7 @@ TEST_F(HttpNetworkTransactionTest, GroupNameForProxyConnections) {
         new CaptureGroupNameSocketPool());
 
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
-    session->connection_pool_ = conn_pool.get();
+    session->tcp_socket_pool_ = conn_pool.get();
 
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(
diff --git a/net/socket/client_socket_handle.h b/net/socket/client_socket_handle.h
index c58e832..ce0a001 100644
--- a/net/socket/client_socket_handle.h
+++ b/net/socket/client_socket_handle.h
@@ -130,8 +130,6 @@ class ClientSocketHandle {
 };
 
 // Template function implementation:
-// TODO(willchan): Register valid (SocketParams,PoolType) pairs to provide
-// type safety.
 template <typename SocketParams, typename PoolType>
 int ClientSocketHandle::Init(const std::string& group_name,
                              const SocketParams& socket_params,
@@ -140,6 +138,10 @@ int ClientSocketHandle::Init(const std::string& group_name,
                              PoolType* pool,
                              LoadLog* load_log) {
   CHECK(!group_name.empty());
+  // Note that this will result in a link error if the SocketParams has not been
+  // registered for the PoolType via REGISTER_SOCKET_PARAMS_FOR_POOL (defined in
+  // client_socket_pool.h).
+  CheckIsValidSocketParamsForPool<PoolType, SocketParams>();
   ResetInternal(true);
   pool_ = pool;
   group_name_ = group_name;
diff --git a/net/socket/client_socket_pool.h b/net/socket/client_socket_pool.h
index ffb34b7..2c55e91 100644
--- a/net/socket/client_socket_pool.h
+++ b/net/socket/client_socket_pool.h
@@ -91,6 +91,22 @@ class ClientSocketPool : public base::RefCounted<ClientSocketPool> {
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPool);
 };
 
+// Declaration, but no definition.  ClientSocketPool subclasses should indicate
+// valid SocketParams via the REGISTER_SOCKET_PARAMS_FOR_POOL macro below, which
+// will provide a definition of CheckIsValidSocketParamsForPool for the
+// ClientSocketPool subtype and SocketParams pair.  Trying to use a SocketParams
+// type that has not been registered with the corresponding ClientSocketPool
+// subtype will result in a link time error stating that
+// CheckIsValidSocketParamsForPool with those template parameters is undefined.
+template <typename PoolType, typename SocketParams>
+void CheckIsValidSocketParamsForPool();
+
+// Provides an empty definition for CheckIsValidSocketParamsForPool() which
+// should be optimized out by the compiler.
+#define REGISTER_SOCKET_PARAMS_FOR_POOL(pool_type, socket_params)         \
+template<>                                                                \
+inline void CheckIsValidSocketParamsForPool<pool_type, socket_params>() {}
+
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_H_
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index 840ca36..93673c62 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -297,6 +297,12 @@ class TestClientSocketPool : public ClientSocketPool {
   DISALLOW_COPY_AND_ASSIGN(TestClientSocketPool);
 };
 
+}  // namespace
+
+REGISTER_SOCKET_PARAMS_FOR_POOL(TestClientSocketPool, const void*);
+
+namespace {
+
 void MockClientSocketFactory::SignalJobs() {
   for (std::vector<TestConnectJob*>::iterator it = waiting_jobs_.begin();
        it != waiting_jobs_.end(); ++it) {
@@ -355,7 +361,8 @@ class ClientSocketPoolBaseTest : public ClientSocketPoolTest {
   }
 
   int StartRequest(const std::string& group_name, int priority) {
-    return StartRequestUsingPool(pool_.get(), group_name, priority);
+    return StartRequestUsingPool<TestClientSocketPool, const void*>(
+        pool_.get(), group_name, priority, NULL);
   }
 
   virtual void TearDown() {
@@ -376,6 +383,18 @@ class ClientSocketPoolBaseTest : public ClientSocketPoolTest {
   scoped_refptr<TestClientSocketPool> pool_;
 };
 
+// Helper function which explicitly specifies the template parameters, since
+// the compiler will infer (in this case, incorrectly) that NULL is of type int.
+int InitHandle(ClientSocketHandle* handle,
+               const std::string& group_name,
+               int priority,
+               CompletionCallback* callback,
+               TestClientSocketPool* pool,
+               LoadLog* load_log) {
+  return handle->Init<const void*, TestClientSocketPool>(
+      group_name, NULL, priority, callback, pool, load_log);
+}
+
 // Even though a timeout is specified, it doesn't time out on a synchronous
 // completion.
 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
@@ -416,8 +435,8 @@ TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
-  EXPECT_EQ(OK, handle.Init("a", ignored_request_info_, kDefaultPriority,
-                            &callback, pool_.get(), NULL));
+  EXPECT_EQ(OK, InitHandle(&handle, "a", kDefaultPriority,
+                           &callback, pool_.get(), NULL));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   handle.Reset();
@@ -428,8 +447,7 @@ TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
-  int rv = req.handle()->Init(
-      "a", ignored_request_info_, 0, &req, pool_.get(), NULL);
+  int rv = InitHandle(req.handle(), "a", 0, &req, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(OK, req.WaitForResult());
@@ -444,8 +462,8 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            req.handle()->Init("a", ignored_request_info_,
-                               kDefaultPriority, &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
 }
 
 TEST_F(ClientSocketPoolBaseTest, InitConnectionAsynchronousFailure) {
@@ -454,8 +472,8 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionAsynchronousFailure) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", ignored_request_info_, kDefaultPriority,
-                               &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
 }
@@ -746,8 +764,8 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", ignored_request_info_,
-                               kDefaultPriority, &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
   req.handle()->Reset();
 }
 
@@ -759,11 +777,11 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
   TestSocketRequest req2(&request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", ignored_request_info_,
-                               kDefaultPriority, &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
   EXPECT_EQ(ERR_IO_PENDING,
-            req2.handle()->Init("a", ignored_request_info_,
-                                kDefaultPriority, &req2, pool_.get(), NULL));
+            InitHandle(req2.handle(), "a", kDefaultPriority, &req2,
+                       pool_.get(), NULL));
 
   req.handle()->Reset();
 
@@ -780,15 +798,15 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
   TestSocketRequest req(&request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", ignored_request_info_,
-                        kDefaultPriority, &callback, pool_.get(), NULL));
+            InitHandle(&handle, "a", kDefaultPriority, &callback,
+                       pool_.get(), NULL));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", ignored_request_info_,
-                        kDefaultPriority, &callback2, pool_.get(), NULL));
+            InitHandle(&handle, "a", kDefaultPriority, &callback2,
+                       pool_.get(), NULL));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
@@ -834,7 +852,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
 class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
  public:
   RequestSocketCallback(ClientSocketHandle* handle,
-                        ClientSocketPool* pool,
+                        TestClientSocketPool* pool,
                         TestConnectJobFactory* test_connect_job_factory,
                         TestConnectJob::JobType next_job_type)
       : handle_(handle),
@@ -851,9 +869,8 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
       test_connect_job_factory_->set_job_type(next_job_type_);
       handle_->Reset();
       within_callback_ = true;
-      int rv = handle_->Init(
-          "a", HostResolver::RequestInfo("www.google.com", 80),
-          kDefaultPriority, this, pool_.get(), NULL);
+      int rv = InitHandle(
+          handle_, "a", kDefaultPriority, this, pool_.get(), NULL);
       switch (next_job_type_) {
         case TestConnectJob::kMockJob:
           EXPECT_EQ(OK, rv);
@@ -874,7 +891,7 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
 
  private:
   ClientSocketHandle* const handle_;
-  const scoped_refptr<ClientSocketPool> pool_;
+  const scoped_refptr<TestClientSocketPool> pool_;
   bool within_callback_;
   TestConnectJobFactory* const test_connect_job_factory_;
   TestConnectJob::JobType next_job_type_;
@@ -889,9 +906,8 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_,
       TestConnectJob::kMockPendingJob);
-  int rv = handle.Init(
-      "a", ignored_request_info_, kDefaultPriority, &callback,
-      pool_.get(), NULL);
+  int rv = InitHandle(&handle, "a", kDefaultPriority, &callback,
+                      pool_.get(), NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -905,9 +921,8 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
-  int rv = handle.Init(
-      "a", ignored_request_info_, kDefaultPriority, &callback,
-      pool_.get(), NULL);
+  int rv = InitHandle(&handle, "a", kDefaultPriority, &callback,
+                      pool_.get(), NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -969,15 +984,15 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req(&request_order_, &completion_count_);
-  int rv = req.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req, pool_.get(), NULL);
+  int rv = InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                      pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   req.handle()->Reset();
 
-  rv = req.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req, pool_.get(), NULL);
+  rv = InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                  pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req.WaitForResult());
 
@@ -997,14 +1012,14 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
 
   // Start job 1 (async error).
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = req1.handle()->Init("a", ignored_request_info_,
-                               kDefaultPriority, &req1, pool_.get(), NULL);
+  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1,
+                      pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Start job 2 (async error).
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = req2.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req2, pool_.get(), NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2,
+                  pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
@@ -1012,8 +1027,8 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
 
   // Request 3 does not have a ConnectJob yet.  It's just pending.
   TestSocketRequest req3(&request_order_, &completion_count_);
-  rv = req3.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req3, pool_.get(), NULL);
+  rv = InitHandle(
+      req3.handle(), "a", kDefaultPriority, &req3, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
@@ -1040,8 +1055,8 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = req1.handle()->Init("a", ignored_request_info_, kDefaultPriority,
-                               &req1, pool_.get(), NULL);
+  int rv = InitHandle(req1.handle(), "a", kDefaultPriority, &req1,
+                      pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
@@ -1049,8 +1064,8 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = req2.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req2, pool_.get(), NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2,
+                  pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   req1.handle()->Reset();
   MessageLoop::current()->RunAllPending();  // Run the DoReleaseSocket()
@@ -1059,8 +1074,8 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
   // will use the idle socket).
 
   TestSocketRequest req3(&request_order_, &completion_count_);
-  rv = req3.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req3, pool_.get(), NULL);
+  rv = InitHandle(req3.handle(), "a", kDefaultPriority, &req3,
+                  pool_.get(), NULL);
   EXPECT_EQ(OK, rv);
 
   EXPECT_FALSE(req2.handle()->socket());
@@ -1155,8 +1170,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, BasicSynchronous) {
 
   TestCompletionCallback callback;
   ClientSocketHandle handle;
-  EXPECT_EQ(OK, handle.Init("a", ignored_request_info_, kDefaultPriority,
-                            &callback, pool_.get(), NULL));
+  EXPECT_EQ(OK, InitHandle(&handle, "a", kDefaultPriority, &callback,
+                           pool_.get(), NULL));
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   handle.Reset();
@@ -1167,8 +1182,7 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, BasicAsynchronous) {
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
-  int rv = req.handle()->Init("a", ignored_request_info_, 0, &req,
-                              pool_.get(), NULL);
+  int rv = InitHandle(req.handle(), "a", 0, &req, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(OK, req.WaitForResult());
@@ -1183,8 +1197,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, InitConnectionFailure) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
-            req.handle()->Init("a", ignored_request_info_,
-                               kDefaultPriority, &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
 }
 
 TEST_F(ClientSocketPoolBaseTest_LateBinding,
@@ -1194,8 +1208,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding,
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", ignored_request_info_, kDefaultPriority,
-                               &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
 }
@@ -1259,8 +1273,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, CancelRequestClearGroup) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   TestSocketRequest req(&request_order_, &completion_count_);
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", ignored_request_info_,
-                               kDefaultPriority, &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
   req.handle()->Reset();
 }
 
@@ -1272,11 +1286,11 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, TwoRequestsCancelOne) {
   TestSocketRequest req2(&request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            req.handle()->Init("a", ignored_request_info_,
-                               kDefaultPriority, &req, pool_.get(), NULL));
+            InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                       pool_.get(), NULL));
   EXPECT_EQ(ERR_IO_PENDING,
-            req2.handle()->Init("a", ignored_request_info_,
-                                kDefaultPriority, &req2, pool_.get(), NULL));
+            InitHandle(req2.handle(), "a", kDefaultPriority, &req2,
+                       pool_.get(), NULL));
 
   req.handle()->Reset();
 
@@ -1293,15 +1307,15 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, ConnectCancelConnect) {
   TestSocketRequest req(&request_order_, &completion_count_);
 
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", ignored_request_info_,
-                        kDefaultPriority, &callback, pool_.get(), NULL));
+            InitHandle(&handle, "a", kDefaultPriority, &callback,
+                       pool_.get(), NULL));
 
   handle.Reset();
 
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
-            handle.Init("a", ignored_request_info_,
-                        kDefaultPriority, &callback2, pool_.get(), NULL));
+            InitHandle(&handle, "a", kDefaultPriority, &callback2,
+                       pool_.get(), NULL));
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(callback.have_result());
@@ -1374,9 +1388,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, RequestPendingJobTwice) {
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_,
       TestConnectJob::kMockPendingJob);
-  int rv = handle.Init(
-      "a", ignored_request_info_, kDefaultPriority, &callback,
-      pool_.get(), NULL);
+  int rv = InitHandle(
+      &handle, "a", kDefaultPriority, &callback, pool_.get(), NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(OK, callback.WaitForResult());
@@ -1390,8 +1403,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, RequestPendingJobThenSynchronous) {
   ClientSocketHandle handle;
   RequestSocketCallback callback(
       &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
-  int rv = handle.Init(
-      "a", ignored_request_info_, kDefaultPriority, &callback,
+  int rv = InitHandle(
+      &handle, "a", kDefaultPriority, &callback,
       pool_.get(), NULL);
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
@@ -1457,15 +1470,15 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding,
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req(&request_order_, &completion_count_);
-  int rv = req.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req, pool_.get(), NULL);
+  int rv = InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                      pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Cancel the active request.
   req.handle()->Reset();
 
-  rv = req.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req, pool_.get(), NULL);
+  rv = InitHandle(req.handle(), "a", kDefaultPriority, &req,
+                  pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req.WaitForResult());
 
@@ -1483,8 +1496,8 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, ReleaseSockets) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = req1.handle()->Init("a", ignored_request_info_, kDefaultPriority,
-                               &req1, pool_.get(), NULL);
+  int rv = InitHandle(req1.handle(), "a", kDefaultPriority,
+                      &req1, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, req1.WaitForResult());
 
@@ -1493,12 +1506,12 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, ReleaseSockets) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = req2.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req2, pool_.get(), NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2,
+                  pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   TestSocketRequest req3(&request_order_, &completion_count_);
-  rv = req3.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req3, pool_.get(), NULL);
+  rv = InitHandle(
+      req3.handle(), "a", kDefaultPriority, &req3, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Both Requests 2 and 3 are pending.  We release socket 1 which should
@@ -1529,21 +1542,21 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, PendingJobCompletionOrder) {
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
 
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = req1.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req1, pool_.get(), NULL);
+  int rv = InitHandle(
+      req1.handle(), "a", kDefaultPriority, &req1, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = req2.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req2, pool_.get(), NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2,
+                  pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // The pending job is sync.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   TestSocketRequest req3(&request_order_, &completion_count_);
-  rv = req3.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req3, pool_.get(), NULL);
+  rv = InitHandle(
+      req3.handle(), "a", kDefaultPriority, &req3, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
@@ -1562,16 +1575,16 @@ TEST_F(ClientSocketPoolBaseTest_LateBinding, DISABLED_LoadState) {
       TestConnectJob::kMockAdvancingLoadStateJob);
 
   TestSocketRequest req1(&request_order_, &completion_count_);
-  int rv = req1.handle()->Init("a", ignored_request_info_, kDefaultPriority,
-                               &req1, pool_.get(), NULL);
+  int rv = InitHandle(
+      req1.handle(), "a", kDefaultPriority, &req1, pool_.get(), NULL);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(LOAD_STATE_IDLE, req1.handle()->GetLoadState());
 
   MessageLoop::current()->RunAllPending();
 
   TestSocketRequest req2(&request_order_, &completion_count_);
-  rv = req2.handle()->Init(
-      "a", ignored_request_info_, kDefaultPriority, &req2, pool_.get(), NULL);
+  rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2,
+                  pool_.get(), 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.h b/net/socket/socket_test_util.h
index 8307d44..76d4df1f 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -329,22 +329,20 @@ class ClientSocketPoolTest : public testing::Test {
   static const int kIndexOutOfBounds;
   static const int kRequestNotFound;
 
-  ClientSocketPoolTest() : ignored_request_info_("ignored", 80) {
-  }
-
   virtual void SetUp();
   virtual void TearDown();
 
-  template <typename PoolType>
+  template <typename PoolType, typename SocketParams>
   int StartRequestUsingPool(PoolType* socket_pool,
                             const std::string& group_name,
-                            int priority) {
+                            int priority,
+                            const SocketParams& socket_params) {
     DCHECK(socket_pool);
     TestSocketRequest* request = new TestSocketRequest(&request_order_,
                                                        &completion_count_);
     requests_.push_back(request);
     int rv = request->handle()->Init(
-        group_name, ignored_request_info_, priority, request,
+        group_name, socket_params, priority, request,
         socket_pool, NULL);
     if (rv != ERR_IO_PENDING)
       request_order_.push_back(request);
@@ -364,7 +362,6 @@ class ClientSocketPoolTest : public testing::Test {
   // Releases connections until there is nothing to release.
   void ReleaseAllConnections(KeepAlive keep_alive);
 
-  HostResolver::RequestInfo ignored_request_info_;
   ScopedVector<TestSocketRequest> requests_;
   std::vector<TestSocketRequest*> request_order_;
   size_t completion_count_;
diff --git a/net/socket/tcp_client_socket_pool.h b/net/socket/tcp_client_socket_pool.h
index 4532000..1437225 100644
--- a/net/socket/tcp_client_socket_pool.h
+++ b/net/socket/tcp_client_socket_pool.h
@@ -12,6 +12,7 @@
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "base/timer.h"
+#include "net/base/host_resolver.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/client_socket_pool.h"
 
@@ -104,6 +105,9 @@ class TCPClientSocketPool : public ClientSocketPool {
   virtual LoadState GetLoadState(const std::string& group_name,
                                  const ClientSocketHandle* handle) const;
 
+ protected:
+  virtual ~TCPClientSocketPool();
+
  private:
   typedef ClientSocketPoolBase<HostResolver::RequestInfo> PoolBase;
 
@@ -131,13 +135,13 @@ class TCPClientSocketPool : public ClientSocketPool {
     DISALLOW_COPY_AND_ASSIGN(TCPConnectJobFactory);
   };
 
-  virtual ~TCPClientSocketPool();
-
   PoolBase base_;
 
   DISALLOW_COPY_AND_ASSIGN(TCPClientSocketPool);
 };
 
+REGISTER_SOCKET_PARAMS_FOR_POOL(TCPClientSocketPool, HostResolver::RequestInfo)
+
 }  // namespace net
 
 #endif  // NET_SOCKET_TCP_CLIENT_SOCKET_POOL_H_
diff --git a/net/socket/tcp_client_socket_pool_unittest.cc b/net/socket/tcp_client_socket_pool_unittest.cc
index 4d679f9..86388f5 100644
--- a/net/socket/tcp_client_socket_pool_unittest.cc
+++ b/net/socket/tcp_client_socket_pool_unittest.cc
@@ -189,7 +189,8 @@ class MockClientSocketFactory : public ClientSocketFactory {
 class TCPClientSocketPoolTest : public ClientSocketPoolTest {
  protected:
   TCPClientSocketPoolTest()
-      : host_resolver_(new MockHostResolver),
+      : ignored_request_info_("ignored", 80),
+        host_resolver_(new MockHostResolver),
         pool_(new TCPClientSocketPool(kMaxSockets,
                                       kMaxSocketsPerGroup,
                                       host_resolver_,
@@ -197,9 +198,11 @@ class TCPClientSocketPoolTest : public ClientSocketPoolTest {
   }
 
   int StartRequest(const std::string& group_name, int priority) {
-    return StartRequestUsingPool(pool_.get(), group_name, priority);
+    return StartRequestUsingPool(
+        pool_.get(), group_name, priority, ignored_request_info_);
   }
 
+  HostResolver::RequestInfo ignored_request_info_;
   scoped_refptr<MockHostResolver> host_resolver_;
   MockClientSocketFactory client_socket_factory_;
   scoped_refptr<TCPClientSocketPool> pool_;