Implements new, more robust design for communicating between SSLConnectJobs.

net/socket/ssl_client_socket_pool_unittest.cc

 // Copyright (c) 2012 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/http/http_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "net/base/auth.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
@@ skipping 104 matching lines @@
                                 &http_proxy_histograms_,
                                 &host_resolver_,
                                 &transport_socket_pool_,
                                 NULL,
                                 NULL) {
     scoped_refptr<SSLConfigService> ssl_config_service(
         new SSLConfigServiceDefaults);
     ssl_config_service->GetSSLConfig(&ssl_config_);
   }
 
-  void CreatePool(bool transport_pool, bool http_proxy_pool, bool socks_pool) {
+  void CreatePool(bool transport_pool,
+                  bool http_proxy_pool,
+                  bool socks_pool,
+                  bool enable_ssl_connect_job_waiting) {

[Ryan Sleevi, 2014/07/25 01:36:37]

Why make this an argument to CreatePool? You could just make it a member
variable to set before CreatePool, and thus have to update fewer call sites.

[mshelley, 2014/07/26 00:58:27]

Done.

     ssl_histograms_.reset(new ClientSocketPoolHistograms("SSLUnitTest"));
     pool_.reset(new SSLClientSocketPool(
         kMaxSockets,
         kMaxSocketsPerGroup,
         ssl_histograms_.get(),
         NULL /* host_resolver */,
         NULL /* cert_verifier */,
         NULL /* server_bound_cert_service */,
         NULL /* transport_security_state */,
         NULL /* cert_transparency_verifier */,
         std::string() /* ssl_session_cache_shard */,
         &socket_factory_,
         transport_pool ? &transport_socket_pool_ : NULL,
         socks_pool ? &socks_socket_pool_ : NULL,
         http_proxy_pool ? &http_proxy_socket_pool_ : NULL,
         NULL,
+        enable_ssl_connect_job_waiting,
         NULL));
   }
 
   scoped_refptr<SSLSocketParams> SSLParams(ProxyServer::Scheme proxy,
                                            bool want_spdy_over_npn) {
     return make_scoped_refptr(new SSLSocketParams(
         proxy == ProxyServer::SCHEME_DIRECT ? direct_transport_socket_params_
                                             : NULL,
         proxy == ProxyServer::SCHEME_SOCKS5 ? socks_socket_params_ : NULL,
         proxy == ProxyServer::SCHEME_HTTP ? http_proxy_socket_params_ : NULL,
@@ skipping 62 matching lines @@
   scoped_ptr<ClientSocketPoolHistograms> ssl_histograms_;
   scoped_ptr<SSLClientSocketPool> pool_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     NextProto,
     SSLClientSocketPoolTest,
     testing::Values(kProtoDeprecatedSPDY2,
                     kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
 
+// Tests that the final socket will connect even if all sockets
+// prior to it fail.

[Ryan Sleevi, 2014/07/25 01:36:37]

More detail is needed in this comment, explaining a bit more about the overall
flow, and then what each "chunk" is doing.

[mshelley, 2014/07/26 00:58:28]

Done.

+TEST_P(SSLClientSocketPoolTest, AllSocketsFailButLast) {
+  StaticSocketDataProvider data1;
+  StaticSocketDataProvider data2;
+  StaticSocketDataProvider data3;
+  StaticSocketDataProvider data4;
+  socket_factory_.AddSocketDataProvider(&data1);
+  socket_factory_.AddSocketDataProvider(&data2);
+  socket_factory_.AddSocketDataProvider(&data3);
+  socket_factory_.AddSocketDataProvider(&data4);
+  socket_factory_.AddSocketDataProvider(&data4);
+  socket_factory_.AddSocketDataProvider(&data4);
+  socket_factory_.AddSocketDataProvider(&data4);
+  socket_factory_.AddSocketDataProvider(&data4);
+  SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
+  ssl.is_in_session_cache = false;
+  SSLSocketDataProvider ssl2(ASYNC, ERR_SSL_PROTOCOL_ERROR);
+  ssl2.is_in_session_cache = true;
+  SSLSocketDataProvider ssl3(ASYNC, ERR_SSL_PROTOCOL_ERROR);
+  ssl3.is_in_session_cache = true;
+  SSLSocketDataProvider ssl4(ASYNC, OK);
+  ssl4.is_in_session_cache = true;
+
+  socket_factory_.AddSSLSocketDataProvider(&ssl);
+  socket_factory_.AddSSLSocketDataProvider(&ssl2);
+  socket_factory_.AddSSLSocketDataProvider(&ssl3);
+  socket_factory_.AddSSLSocketDataProvider(&ssl4);
+  socket_factory_.AddSSLSocketDataProvider(&ssl4);
+  socket_factory_.AddSSLSocketDataProvider(&ssl4);
+  socket_factory_.AddSSLSocketDataProvider(&ssl4);
+  socket_factory_.AddSSLSocketDataProvider(&ssl4);
+
+  CreatePool(true, false, false, true);
+
+  scoped_refptr<SSLSocketParams> params1 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params2 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params3 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params4 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  ClientSocketHandle handle1;
+  ClientSocketHandle handle2;
+  ClientSocketHandle handle3;
+  ClientSocketHandle handle4;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
+  TestCompletionCallback callback4;
+
+  handle1.Init(
+      "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
+  handle2.Init(
+      "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
+  handle3.Init(
+      "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
+  handle4.Init(
+      "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
+
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<MockSSLClientSocket*> sockets =
+      socket_factory_.ssl_client_sockets();
+
+  // Only the last socket should have connected.
+  EXPECT_FALSE(handle1.socket());
+  EXPECT_FALSE(handle2.socket());
+  EXPECT_FALSE(handle3.socket());
+  EXPECT_TRUE(handle4.socket()->IsConnected());
+}
+
+// Tests that sockets will still connect in parellel if the

[Ryan Sleevi, 2014/07/25 01:36:37]

parallel

[mshelley, 2014/07/26 00:58:27]

Done.

+// EnableSSLConnectJobWaiting flag is not enabled.
+TEST_P(SSLClientSocketPoolTest, SocketsConnectWithoutFlag) {
+  StaticSocketDataProvider data1;
+  StaticSocketDataProvider data2;
+  StaticSocketDataProvider data3;
+  socket_factory_.AddSocketDataProvider(&data1);
+  socket_factory_.AddSocketDataProvider(&data2);
+  socket_factory_.AddSocketDataProvider(&data3);
+
+  SSLSocketDataProvider ssl(ASYNC, OK);
+  ssl.is_in_session_cache = false;
+  ssl.should_block_on_connect = true;
+  SSLSocketDataProvider ssl2(ASYNC, OK);
+  ssl2.is_in_session_cache = true;
+  ssl2.should_block_on_connect = true;
+  SSLSocketDataProvider ssl3(ASYNC, OK);
+  ssl3.is_in_session_cache = true;
+  ssl3.should_block_on_connect = true;
+  socket_factory_.AddSSLSocketDataProvider(&ssl);
+  socket_factory_.AddSSLSocketDataProvider(&ssl2);
+  socket_factory_.AddSSLSocketDataProvider(&ssl3);
+
+  CreatePool(true, false, false, false);
+
+  scoped_refptr<SSLSocketParams> params1 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params2 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params3 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  ClientSocketHandle handle1;
+  ClientSocketHandle handle2;
+  ClientSocketHandle handle3;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
+
+  handle1.Init(
+      "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
+  handle2.Init(
+      "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
+  handle3.Init(
+      "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
+
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<MockSSLClientSocket*> sockets =
+      socket_factory_.ssl_client_sockets();
+
+  // All sockets should have started their connections.
+  for (std::vector<MockSSLClientSocket*>::iterator it = sockets.begin();
+       it != sockets.end();
+       ++it) {
+    EXPECT_TRUE((*it)->IsConnected());
+    (*it)->RestartPausedConnect();

[Ryan Sleevi, 2014/07/25 01:36:37]

This is... Surprising. I'm not sure I understand why this is, other than perhaps
for testing. But it seems to 'break' the normal API, hence weirdness.

[mshelley, 2014/07/26 00:58:27]

The idea here was to confirm that every socket started connecting immediately --
i.e. the sockets behaved as they usually would without SSLConnectJob waiting
enabled. Then, I restart all of the sockets so that I can confirm that they
actually connect successfully. 

However, I just realized that I should probably be restarting the sockets in a
separate for loop, because here I technically restart the leading job
(potentially allowing it to finish its connection) before checking to see that
the other jobs have started to connect. 

+  }
+
+  callback3.WaitForResult();

[Ryan Sleevi, 2014/07/25 01:36:37]

Mention why you don't check callback1/2

[mshelley, 2014/07/26 00:58:27]

I was assuming that since 1/2 begin before 3, they would finish before 3.
Therefore, I'd only need to check 3. I'm starting to think that might not
necessarily be the case now, so I should probably check all of them..

+
+  EXPECT_TRUE(handle1.socket()->IsConnected());
+  EXPECT_TRUE(handle2.socket()->IsConnected());
+  EXPECT_TRUE(handle3.socket()->IsConnected());
+}
+
+// Tests that the pool deleting an SSLConnectJob will not cause a crash,
+// or prevent pending sockets from connecting.
+TEST_P(SSLClientSocketPoolTest, DeletedSSLConnectJob) {
+  StaticSocketDataProvider data1;
+  StaticSocketDataProvider data2;
+  StaticSocketDataProvider data3;
+  socket_factory_.AddSocketDataProvider(&data1);
+  socket_factory_.AddSocketDataProvider(&data2);
+  socket_factory_.AddSocketDataProvider(&data3);
+
+  SSLSocketDataProvider ssl(ASYNC, OK);
+  ssl.is_in_session_cache = false;
+  ssl.should_block_on_connect = true;
+  SSLSocketDataProvider ssl2(ASYNC, OK);
+  ssl2.is_in_session_cache = false;
+  SSLSocketDataProvider ssl3(ASYNC, OK);
+  ssl3.is_in_session_cache = false;
+  socket_factory_.AddSSLSocketDataProvider(&ssl);
+  socket_factory_.AddSSLSocketDataProvider(&ssl2);
+  socket_factory_.AddSSLSocketDataProvider(&ssl3);
+
+  CreatePool(true, false, false, true);
+
+  scoped_refptr<SSLSocketParams> params1 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params2 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params3 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  ClientSocketHandle handle1;
+  ClientSocketHandle handle2;
+  ClientSocketHandle handle3;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
+
+  handle1.Init(
+      "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
+  handle2.Init(
+      "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
+  handle3.Init(
+      "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
+
+  // Allow the connections to proceed until the first socket has started
+  // connecting.
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<MockSSLClientSocket*> sockets =
+      socket_factory_.ssl_client_sockets();
+
+  pool_->CancelRequest("b", &handle2);
+
+  sockets[0]->RestartPausedConnect();
+
+  callback3.WaitForResult();
+
+  EXPECT_TRUE(handle1.socket()->IsConnected());
+  EXPECT_FALSE(handle2.socket());
+  EXPECT_TRUE(handle3.socket()->IsConnected());
+}
+
+// Tests that all pending sockets still connect when the pool deletes a pending
+// SSLConnectJob which immediately followed a failed leading connection.
+TEST_P(SSLClientSocketPoolTest, DeletedSocketAfterFail) {
+  StaticSocketDataProvider data1;
+  StaticSocketDataProvider data2;
+  StaticSocketDataProvider data3;
+  socket_factory_.AddSocketDataProvider(&data1);
+  socket_factory_.AddSocketDataProvider(&data2);
+  socket_factory_.AddSocketDataProvider(&data3);
+
+  SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
+  ssl.is_in_session_cache = false;
+  ssl.should_block_on_connect = true;
+  SSLSocketDataProvider ssl2(ASYNC, OK);
+  ssl2.is_in_session_cache = false;
+  SSLSocketDataProvider ssl3(ASYNC, OK);
+  ssl3.is_in_session_cache = false;
+  socket_factory_.AddSSLSocketDataProvider(&ssl);
+  socket_factory_.AddSSLSocketDataProvider(&ssl2);
+  socket_factory_.AddSSLSocketDataProvider(&ssl3);
+
+  CreatePool(true, false, false, true);
+
+  scoped_refptr<SSLSocketParams> params1 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params2 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params3 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  ClientSocketHandle handle1;
+  ClientSocketHandle handle2;
+  ClientSocketHandle handle3;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
+
+  handle1.Init(
+      "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
+  handle2.Init(
+      "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
+  handle3.Init(
+      "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
+
+  // Allow the connections to proceed until the first socket has started
+  // connecting.
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<MockSSLClientSocket*> sockets =
+      socket_factory_.ssl_client_sockets();
+
+  pool_->CancelRequest("b", &handle2);
+
+  sockets[0]->RestartPausedConnect();
+
+  callback3.WaitForResult();
+
+  EXPECT_TRUE(handle1.socket()->IsConnected());
+  EXPECT_FALSE(handle2.socket());
+  EXPECT_TRUE(handle3.socket()->IsConnected());
+}
+
+// Make sure that sockets still connect after the leader socket's
+// connection fails.
+TEST_P(SSLClientSocketPoolTest, SimultaneousConnectJobsFail) {
+  StaticSocketDataProvider data1;
+  StaticSocketDataProvider data2;
+  StaticSocketDataProvider data3;
+  StaticSocketDataProvider data4;
+  StaticSocketDataProvider data5;
+  socket_factory_.AddSocketDataProvider(&data1);
+  socket_factory_.AddSocketDataProvider(&data2);
+  socket_factory_.AddSocketDataProvider(&data3);
+  socket_factory_.AddSocketDataProvider(&data4);
+  socket_factory_.AddSocketDataProvider(&data5);
+  SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
+  ssl.is_in_session_cache = false;
+  ssl.should_block_on_connect = true;
+  SSLSocketDataProvider ssl2(ASYNC, OK);
+  ssl2.is_in_session_cache = false;
+  ssl2.should_block_on_connect = true;
+  SSLSocketDataProvider ssl3(ASYNC, OK);
+  ssl3.is_in_session_cache = false;
+  SSLSocketDataProvider ssl4(ASYNC, OK);
+  ssl4.is_in_session_cache = false;
+  SSLSocketDataProvider ssl5(ASYNC, OK);
+  ssl5.is_in_session_cache = false;
+
+  socket_factory_.AddSSLSocketDataProvider(&ssl);
+  socket_factory_.AddSSLSocketDataProvider(&ssl2);
+  socket_factory_.AddSSLSocketDataProvider(&ssl3);
+  socket_factory_.AddSSLSocketDataProvider(&ssl4);
+  socket_factory_.AddSSLSocketDataProvider(&ssl5);
+
+  CreatePool(true, false, false, true);
+  scoped_refptr<SSLSocketParams> params1 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params2 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params3 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params4 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  ClientSocketHandle handle1;
+  ClientSocketHandle handle2;
+  ClientSocketHandle handle3;
+  ClientSocketHandle handle4;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
+  TestCompletionCallback callback4;
+  handle1.Init(
+      "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
+  handle2.Init(
+      "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
+  handle3.Init(
+      "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
+  handle4.Init(
+      "b", params4, MEDIUM, callback4.callback(), pool_.get(), BoundNetLog());
+
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<MockSSLClientSocket*> sockets =
+      socket_factory_.ssl_client_sockets();
+
+  // The first socket's connection should have failed, and no other sockets
+  // should have connected yet.
+  for (std::vector<MockSSLClientSocket*>::iterator it = sockets.begin();
+       it != sockets.end();
+       ++it) {
+    EXPECT_FALSE((*it)->IsConnected());
+  }
+
+  // Allow the first socket to resume it's connection process.
+  sockets[0]->RestartPausedConnect();
+
+  base::RunLoop().RunUntilIdle();
+
+  // The second socket should have connected.
+  EXPECT_TRUE(sockets[1]->IsConnected());
+
+  // Allow the second socket to continue its connection.
+  sockets[1]->RestartPausedConnect();
+
+  callback4.WaitForResult();
+
+  // Pending connections should ultimately succeed.
+  for (std::vector<MockSSLClientSocket*>::iterator it = ++sockets.begin();
+       it != sockets.end();
+       ++it) {
+    EXPECT_TRUE((*it)->IsConnected());
+  }
+}
+
+// Make sure that no sockets connect before the "leader" socket,
+// given that the leader has a successful connection.
+TEST_P(SSLClientSocketPoolTest, SimultaneousConnectJobsSuccess) {
+  StaticSocketDataProvider data1;
+  StaticSocketDataProvider data2;
+  StaticSocketDataProvider data3;
+  socket_factory_.AddSocketDataProvider(&data1);
+  socket_factory_.AddSocketDataProvider(&data2);
+  socket_factory_.AddSocketDataProvider(&data3);
+
+  SSLSocketDataProvider ssl(ASYNC, OK);
+  ssl.is_in_session_cache = false;
+  ssl.should_block_on_connect = true;
+  SSLSocketDataProvider ssl2(ASYNC, OK);
+  ssl2.is_in_session_cache = false;
+  SSLSocketDataProvider ssl3(ASYNC, OK);
+  ssl3.is_in_session_cache = false;
+  socket_factory_.AddSSLSocketDataProvider(&ssl);
+  socket_factory_.AddSSLSocketDataProvider(&ssl2);
+  socket_factory_.AddSSLSocketDataProvider(&ssl3);
+
+  CreatePool(true, false, false, true);
+
+  scoped_refptr<SSLSocketParams> params1 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params2 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  scoped_refptr<SSLSocketParams> params3 =
+      SSLParams(ProxyServer::SCHEME_DIRECT, false);
+  ClientSocketHandle handle1;
+  ClientSocketHandle handle2;
+  ClientSocketHandle handle3;
+  TestCompletionCallback callback1;
+  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
+
+  handle1.Init(
+      "b", params1, MEDIUM, callback1.callback(), pool_.get(), BoundNetLog());
+  handle2.Init(
+      "b", params2, MEDIUM, callback2.callback(), pool_.get(), BoundNetLog());
+  handle3.Init(
+      "b", params3, MEDIUM, callback3.callback(), pool_.get(), BoundNetLog());
+
+  // Allow the connections to proceed until the first socket has finished
+  // connecting.
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<MockSSLClientSocket*> sockets =
+      socket_factory_.ssl_client_sockets();
+
+  EXPECT_TRUE(sockets[0]->IsConnected());
+  for (std::vector<MockSSLClientSocket*>::iterator it = ++sockets.begin();
+       it != sockets.end();
+       ++it) {
+    EXPECT_FALSE((*it)->IsConnected());
+  }
+
+  sockets[0]->RestartPausedConnect();
+
+  callback3.WaitForResult();
+
+  EXPECT_TRUE(handle1.socket()->IsConnected());
+  EXPECT_TRUE(handle2.socket()->IsConnected());
+  EXPECT_TRUE(handle3.socket()->IsConnected());
+}
+
 TEST_P(SSLClientSocketPoolTest, TCPFail) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
   socket_factory_.AddSocketDataProvider(&data);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     false);
 
   ClientSocketHandle handle;
   int rv = handle.Init("a", params, MEDIUM, CompletionCallback(), pool_.get(),
                        BoundNetLog());
   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
 }
 
 TEST_P(SSLClientSocketPoolTest, TCPFailAsync) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
   socket_factory_.AddSocketDataProvider(&data);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
 }
 
 TEST_P(SSLClientSocketPoolTest, BasicDirect) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
 }
 
 // Make sure that SSLConnectJob passes on its priority to its
 // socket request on Init (for the DIRECT case).
 TEST_P(SSLClientSocketPoolTest, SetSocketRequestPriorityOnInitDirect) {
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params =
       SSLParams(ProxyServer::SCHEME_DIRECT, false);
 
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     RequestPriority priority = static_cast<RequestPriority>(i);
     StaticSocketDataProvider data;
     data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
     socket_factory_.AddSocketDataProvider(&data);
     SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
     socket_factory_.AddSSLSocketDataProvider(&ssl);
 
     ClientSocketHandle handle;
     TestCompletionCallback callback;
     EXPECT_EQ(OK, handle.Init("a", params, priority, callback.callback(),
                               pool_.get(), BoundNetLog()));
     EXPECT_EQ(priority, transport_socket_pool_.last_request_priority());
     handle.socket()->Disconnect();
   }
 }
 
 TEST_P(SSLClientSocketPoolTest, BasicDirectAsync) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
 }
 
 TEST_P(SSLClientSocketPoolTest, DirectCertError) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, ERR_CERT_COMMON_NAME_INVALID);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(ERR_CERT_COMMON_NAME_INVALID, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
 }
 
 TEST_P(SSLClientSocketPoolTest, DirectSSLError) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, ERR_SSL_PROTOCOL_ERROR);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(ERR_SSL_PROTOCOL_ERROR, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_TRUE(handle.is_ssl_error());
 }
 
 TEST_P(SSLClientSocketPoolTest, DirectWithNPN) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(kProtoHTTP11);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
 }
 
 TEST_P(SSLClientSocketPoolTest, DirectNoSPDY) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(kProtoHTTP11);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     true);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(ERR_NPN_NEGOTIATION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_TRUE(handle.is_ssl_error());
 }
 
 TEST_P(SSLClientSocketPoolTest, DirectGotSPDY) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(GetParam());
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     true);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ skipping 11 matching lines @@
   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 }
 
 TEST_P(SSLClientSocketPoolTest, DirectGotBonusSPDY) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(GetParam());
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_DIRECT,
                                                     true);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfo(handle);
 
   SSLClientSocket* ssl_socket = static_cast<SSLClientSocket*>(handle.socket());
   EXPECT_TRUE(ssl_socket->WasNpnNegotiated());
   std::string proto;
   std::string server_protos;
   ssl_socket->GetNextProto(&proto, &server_protos);
   EXPECT_EQ(GetParam(), SSLClientSocket::NextProtoFromString(proto));
 }
 
 TEST_P(SSLClientSocketPoolTest, SOCKSFail) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
   socket_factory_.AddSocketDataProvider(&data);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
 }
 
 TEST_P(SSLClientSocketPoolTest, SOCKSFailAsync) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
   socket_factory_.AddSocketDataProvider(&data);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
 }
 
 TEST_P(SSLClientSocketPoolTest, SOCKSBasic) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
   // don't go through the real logic, unlike in the HTTP proxy tests.
   TestLoadTimingInfo(handle);
 }
 
 // Make sure that SSLConnectJob passes on its priority to its
 // transport socket on Init (for the SOCKS_PROXY case).
 TEST_P(SSLClientSocketPoolTest, SetTransportPriorityOnInitSOCKS) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params =
       SSLParams(ProxyServer::SCHEME_SOCKS5, false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, callback.callback(),
                             pool_.get(), BoundNetLog()));
   EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority());
 }
 
 TEST_P(SSLClientSocketPoolTest, SOCKSBasicAsync) {
   StaticSocketDataProvider data;
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_SOCKS5,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   // SOCKS5 generally has no DNS times, but the mock SOCKS5 sockets used here
   // don't go through the real logic, unlike in the HTTP proxy tests.
   TestLoadTimingInfo(handle);
 }
 
 TEST_P(SSLClientSocketPoolTest, HttpProxyFail) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(SYNCHRONOUS, ERR_CONNECTION_FAILED));
   socket_factory_.AddSocketDataProvider(&data);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
   EXPECT_FALSE(handle.is_ssl_error());
 }
 
 TEST_P(SSLClientSocketPoolTest, HttpProxyFailAsync) {
   StaticSocketDataProvider data;
   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_FAILED));
   socket_factory_.AddSocketDataProvider(&data);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ skipping 16 matching lines @@
       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_factory_.AddSocketDataProvider(&data);
   AddAuthToCache();
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
@@ skipping 14 matching lines @@
       MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_factory_.AddSocketDataProvider(&data);
   AddAuthToCache();
   SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params =
       SSLParams(ProxyServer::SCHEME_HTTP, false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(OK, handle.Init("a", params, HIGHEST, callback.callback(),
                             pool_.get(), BoundNetLog()));
   EXPECT_EQ(HIGHEST, transport_socket_pool_.last_request_priority());
 }
 
 TEST_P(SSLClientSocketPoolTest, HttpProxyBasicAsync) {
   MockWrite writes[] = {
       MockWrite("CONNECT host:80 HTTP/1.1\r\n"
                 "Host: host\r\n"
                 "Proxy-Connection: keep-alive\r\n"
                 "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
   MockRead reads[] = {
       MockRead("HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   socket_factory_.AddSocketDataProvider(&data);
   AddAuthToCache();
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ skipping 15 matching lines @@
       MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10\r\n\r\n"),
       MockRead("0123456789"),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), writes,
                                 arraysize(writes));
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(false, true /* http proxy pool */, true /* socks pool */);
+  CreatePool(false, true /* http proxy pool */, true /* socks pool */, false);
   scoped_refptr<SSLSocketParams> params = SSLParams(ProxyServer::SCHEME_HTTP,
                                                     false);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   int rv = handle.Init(
       "a", params, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
@@ skipping 48 matching lines @@
       MockRead(ASYNC, ERR_IO_PENDING),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.cert = X509Certificate::CreateFromBytes(
       reinterpret_cast<const char*>(webkit_der), sizeof(webkit_der));
   ssl.SetNextProto(GetParam());
   socket_factory_.AddSSLSocketDataProvider(&ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   base::WeakPtr<SpdySession> spdy_session =
       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
 
   EXPECT_TRUE(
       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
   EXPECT_FALSE(
       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
   EXPECT_TRUE(
       HasSpdySession(session_->spdy_session_pool(), test_hosts[2].key));
 
@@ skipping 36 matching lines @@
         PRIVACY_MODE_DISABLED);
   }
 
   MockRead reads[] = {
       MockRead(ASYNC, ERR_IO_PENDING),
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&data);
   socket_factory_.AddSSLSocketDataProvider(ssl);
 
-  CreatePool(true /* tcp pool */, false, false);
+  CreatePool(true /* tcp pool */, false, false, false);
   base::WeakPtr<SpdySession> spdy_session =
       CreateSecureSpdySession(session_, test_hosts[0].key, BoundNetLog());
 
   EXPECT_TRUE(
       HasSpdySession(session_->spdy_session_pool(), test_hosts[0].key));
   EXPECT_FALSE(
       HasSpdySession(session_->spdy_session_pool(), test_hosts[1].key));
 
   session_->spdy_session_pool()->CloseAllSessions();
 }
@@ skipping 15 matching lines @@
   ssl.channel_id_sent = true;
   ssl.SetNextProto(GetParam());
   TestIPPoolingDisabled(&ssl);
 }
 
 // It would be nice to also test the timeouts in SSLClientSocketPool.
 
 }  // namespace
 
 }  // namespace net