Introduce a callback in ClientSocketPool::RequestSockets()

Currently there is a bug that a preconnect job can block subsequent
requests which can use an existing IP based pooled SpdySession.

This is caused because the HttpStreamFactory::Job’s
|spdy_session_request_| for the preconnect is deleted soon after the
HttpStreamFactory::Job for the preconnect is started.

  HttpStreamFactory::Job::DoLoop()
    HttpStreamFactory::Job::DoInitConnection()
      HttpStreamFactory::Job::DoInitConnectionImpl()
        existing_spdy_session_ =
            session_->spdy_session_pool()->RequestSession(
              ..., &spdy_session_request_, ...);
        if (job_type_ == PRECONNECT) {
          // This always returns OK
          return PreconnectSocketsForHttpRequest(...);
        }
    HttpStreamFactory::Job::DoInitConnectionComplete()
      spdy_session_request_.reset();

So SpdySessionPool::OnHostResolutionComplete() can’t run the logic of
IP based pooling when Chrome receives the host resolver result.

  OnHostResolutionCallbackResult
      SpdySessionPool::OnHostResolutionComplete(...) {
    if (spdy_session_request_map_.find(key) ==
          spdy_session_request_map_.end()) {
      return OnHostResolutionCallbackResult::kContinue;
    }
    ...
  }

To fix this issue, this CL introduces a callback in
ClientSocketPool::RequestSockets(). PreconnectSocketsForHttpRequest()
will return ERR_IO_PENDING when any pending connect jobs are created.
And the callback will be called after the all pending connect jobs are
deleted. So |spdy_session_request_| will be kept alive until that.

Bug: 1320608
Change-Id: I6590bb836be2bf4654336519e4eabdc93490676d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3670414
Commit-Queue: Tsuyoshi Horo <[email protected]>
Reviewed-by: Yutaka Hirano <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1009972}
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index 80ff89b5..ae102ac 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -3530,8 +3530,11 @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -3566,6 +3569,7 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
+  EXPECT_THAT(preconnect_callback.WaitForResult(), IsOk());
   EXPECT_THAT(callback1.WaitForResult(), IsOk());
   EXPECT_THAT(callback2.WaitForResult(), IsOk());
   handle1.Reset();
@@ -3600,8 +3604,11 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
 
   EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
@@ -3626,6 +3633,7 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
+  EXPECT_THAT(preconnect_callback.WaitForResult(), IsOk());
   EXPECT_THAT(callback1.WaitForResult(), IsOk());
   EXPECT_THAT(callback2.WaitForResult(), IsOk());
   handle1.Reset();
@@ -3679,8 +3687,9 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                CompletionOnceCallback(), NetLogWithSource()));
 
   EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
@@ -3710,8 +3719,11 @@
 
   ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
-                        kDefaultMaxSockets, NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(
+                TestGroupId("a"), params_, absl::nullopt, kDefaultMaxSockets,
+                preconnect_callback.callback(), NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(kDefaultMaxSockets,
@@ -3727,10 +3739,14 @@
 
   ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("b")));
 
-  pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
-                        kDefaultMaxSockets, NetLogWithSource());
+  EXPECT_EQ(OK,
+            pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
+                                  kDefaultMaxSockets, CompletionOnceCallback(),
+                                  NetLogWithSource()));
 
   ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("b")));
+
+  EXPECT_THAT(preconnect_callback.WaitForResult(), IsOk());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
@@ -3739,8 +3755,12 @@
 
   ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
-                        kDefaultMaxSockets - 1, NetLogWithSource());
+  TestCompletionCallback preconnect_callback1;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
+                                  kDefaultMaxSockets - 1,
+                                  preconnect_callback1.callback(),
+                                  NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(kDefaultMaxSockets - 1,
@@ -3757,12 +3777,18 @@
 
   ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("b")));
 
-  pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
-                        kDefaultMaxSockets, NetLogWithSource());
+  TestCompletionCallback preconnect_callback2;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(
+                TestGroupId("b"), params_, absl::nullopt, kDefaultMaxSockets,
+                preconnect_callback2.callback(), NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("b")));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
   EXPECT_FALSE(pool_->IsStalled());
+
+  EXPECT_THAT(preconnect_callback1.WaitForResult(), IsOk());
+  EXPECT_THAT(preconnect_callback2.WaitForResult(), IsOk());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
@@ -3788,8 +3814,11 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
 
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
@@ -3797,6 +3826,8 @@
   EXPECT_EQ(1u,
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
+
+  EXPECT_THAT(preconnect_callback.WaitForResult(), IsOk());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
@@ -3822,8 +3853,11 @@
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
 
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
@@ -3832,14 +3866,18 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
+
+  EXPECT_THAT(preconnect_callback.WaitForResult(), IsOk());
 }
 
 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
-                        kDefaultMaxSocketsPerGroup, NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
+                                kDefaultMaxSocketsPerGroup,
+                                CompletionOnceCallback(), NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -3850,8 +3888,10 @@
   EXPECT_EQ(kDefaultMaxSocketsPerGroup,
             static_cast<int>(pool_->IdleSocketCountInGroup(TestGroupId("a"))));
 
-  pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
-                        kDefaultMaxSocketsPerGroup, NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("b"), params_, absl::nullopt,
+                                kDefaultMaxSocketsPerGroup,
+                                CompletionOnceCallback(), NetLogWithSource()));
 
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("b")));
   EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
@@ -3866,15 +3906,20 @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
-                        kDefaultMaxSocketsPerGroup, NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
+                                kDefaultMaxSocketsPerGroup,
+                                CompletionOnceCallback(), NetLogWithSource()));
 
   ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
 
   connect_job_factory_->set_job_type(
       TestConnectJob::kMockAdditionalErrorStateJob);
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
-                        kDefaultMaxSocketsPerGroup, NetLogWithSource());
+
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt,
+                                kDefaultMaxSocketsPerGroup,
+                                CompletionOnceCallback(), NetLogWithSource()));
 
   ASSERT_FALSE(pool_->HasGroupForTesting(TestGroupId("a")));
 }
@@ -3883,8 +3928,11 @@
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -3895,8 +3943,9 @@
   EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                CompletionOnceCallback(), NetLogWithSource()));
   EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(2u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -3935,6 +3984,7 @@
                    pool_.get(), NetLogWithSource()));
   client_socket_factory_.SignalJob(0);
   EXPECT_THAT(callback2.WaitForResult(), IsOk());
+  EXPECT_THAT(preconnect_callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
@@ -3955,8 +4005,9 @@
   EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                CompletionOnceCallback(), NetLogWithSource()));
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -3970,8 +4021,11 @@
   CreatePool(4, 4);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback1;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                  preconnect_callback1.callback(),
+                                  NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -3981,8 +4035,11 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback2;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                  preconnect_callback2.callback(),
+                                  NetLogWithSource()));
   EXPECT_EQ(2u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(2u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -3990,8 +4047,11 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 3,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback3;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 3,
+                                  preconnect_callback3.callback(),
+                                  NetLogWithSource()));
   EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(3u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -3999,8 +4059,9 @@
             pool_->NumUnassignedConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->IdleSocketCountInGroup(TestGroupId("a")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                CompletionOnceCallback(), NetLogWithSource()));
   EXPECT_EQ(3u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(3u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -4013,8 +4074,11 @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -4042,6 +4106,7 @@
 
   client_socket_factory_.SignalJobs();
   EXPECT_THAT(callback1.WaitForResult(), IsOk());
+  EXPECT_THAT(preconnect_callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
@@ -4064,8 +4129,10 @@
 TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                CompletionOnceCallback(), NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -4169,8 +4236,9 @@
   // Requesting 2 preconnected sockets for "a" should fail to allocate any more
   // sockets for "a", and "b" should still have 2 active sockets.
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                CompletionOnceCallback(), NetLogWithSource()));
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -4194,8 +4262,11 @@
   EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(TestGroupId("b")));
   EXPECT_EQ(0, pool_->NumActiveSocketsInGroupForTesting(TestGroupId("b")));
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 2,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -4219,8 +4290,11 @@
   // Make the ConnectJob hang until it times out, shorten the timeout.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
   connect_job_factory_->set_timeout_duration(base::Milliseconds(500));
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -4245,8 +4319,11 @@
 
   // Make the ConnectJob hang forever.
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumNeverAssignedConnectJobsInGroupForTesting(
                     TestGroupId("a")));
@@ -4292,8 +4369,9 @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                CompletionOnceCallback(), NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(0u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -4418,8 +4496,11 @@
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
 
-  pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
-                        NetLogWithSource());
+  TestCompletionCallback preconnect_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            pool_->RequestSockets(TestGroupId("a"), params_, absl::nullopt, 1,
+                                  preconnect_callback.callback(),
+                                  NetLogWithSource()));
 
   ASSERT_TRUE(pool_->HasGroupForTesting(TestGroupId("a")));
   EXPECT_EQ(1u, pool_->NumConnectJobsInGroupForTesting(TestGroupId("a")));
@@ -5727,10 +5808,13 @@
   const ClientSocketPool::GroupId kGroupId = GetGroupId();
   const ClientSocketPool::GroupId kGroupIdInPartition = GetGroupIdInPartition();
 
-  pool_->RequestSockets(kGroupId, params_, absl::nullopt, 2,
-                        NetLogWithSource());
-  pool_->RequestSockets(kGroupIdInPartition, params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(kGroupId, params_, absl::nullopt, 2,
+                                CompletionOnceCallback(), NetLogWithSource()));
+
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(kGroupIdInPartition, params_, absl::nullopt, 2,
+                                CompletionOnceCallback(), NetLogWithSource()));
   ASSERT_TRUE(pool_->HasGroupForTesting(kGroupId));
   ASSERT_TRUE(pool_->HasGroupForTesting(kGroupIdInPartition));
   EXPECT_EQ(4, pool_->IdleSocketCount());
@@ -5751,8 +5835,9 @@
   const ClientSocketPool::GroupId kOtherGroupId =
       TestGroupId("b", 443, url::kHttpsScheme);
 
-  pool_->RequestSockets(kOtherGroupId, params_, absl::nullopt, 2,
-                        NetLogWithSource());
+  EXPECT_EQ(
+      OK, pool_->RequestSockets(kOtherGroupId, params_, absl::nullopt, 2,
+                                CompletionOnceCallback(), NetLogWithSource()));
   ASSERT_TRUE(pool_->HasGroupForTesting(kOtherGroupId));
   EXPECT_EQ(2, pool_->IdleSocketCount());
   EXPECT_EQ(2u, pool_->IdleSocketCountInGroup(kOtherGroupId));