summaryrefslogtreecommitdiffstats
path: root/net/socket/tcp_client_socket_pool_unittest.cc
diff options
context:
space:
mode:
Diffstat (limited to 'net/socket/tcp_client_socket_pool_unittest.cc')
-rw-r--r--net/socket/tcp_client_socket_pool_unittest.cc206
1 files changed, 106 insertions, 100 deletions
diff --git a/net/socket/tcp_client_socket_pool_unittest.cc b/net/socket/tcp_client_socket_pool_unittest.cc
index ddcd5bf..1e701aa 100644
--- a/net/socket/tcp_client_socket_pool_unittest.cc
+++ b/net/socket/tcp_client_socket_pool_unittest.cc
@@ -273,7 +273,7 @@ class MockClientSocketFactory : public ClientSocketFactory {
int client_socket_index_max_;
};
-class TCPClientSocketPoolTest : public ClientSocketPoolTest {
+class TCPClientSocketPoolTest : public testing::Test {
protected:
TCPClientSocketPoolTest()
: params_(new TCPSocketParams(HostPortPair("www.google.com", 80),
@@ -282,32 +282,49 @@ class TCPClientSocketPoolTest : public ClientSocketPoolTest {
LOW, GURL(), false)),
histograms_(new ClientSocketPoolHistograms("TCPUnitTest")),
host_resolver_(new MockHostResolver),
- pool_(new TCPClientSocketPool(kMaxSockets,
- kMaxSocketsPerGroup,
- histograms_,
- host_resolver_,
- &client_socket_factory_,
- NULL)) {
+ pool_(kMaxSockets,
+ kMaxSocketsPerGroup,
+ histograms_.get(),
+ host_resolver_,
+ &client_socket_factory_,
+ NULL) {
}
int StartRequest(const std::string& group_name, RequestPriority priority) {
scoped_refptr<TCPSocketParams> params = new TCPSocketParams(
HostPortPair("www.google.com", 80), MEDIUM, GURL(), false);
- return StartRequestUsingPool(pool_, group_name, priority, params);
+ return test_base_.StartRequestUsingPool(
+ &pool_, group_name, priority, params);
}
+ int GetOrderOfRequest(size_t index) {
+ return test_base_.GetOrderOfRequest(index);
+ }
+
+ bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
+ return test_base_.ReleaseOneConnection(keep_alive);
+ }
+
+ void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) {
+ test_base_.ReleaseAllConnections(keep_alive);
+ }
+
+ ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); }
+ size_t completion_count() const { return test_base_.completion_count(); }
+
scoped_refptr<TCPSocketParams> params_;
scoped_refptr<TCPSocketParams> low_params_;
- scoped_refptr<ClientSocketPoolHistograms> histograms_;
+ scoped_ptr<ClientSocketPoolHistograms> histograms_;
scoped_refptr<MockHostResolver> host_resolver_;
MockClientSocketFactory client_socket_factory_;
- scoped_refptr<TCPClientSocketPool> pool_;
+ TCPClientSocketPool pool_;
+ ClientSocketPoolTest test_base_;
};
TEST_F(TCPClientSocketPoolTest, Basic) {
TestCompletionCallback callback;
ClientSocketHandle handle;
- int rv = handle.Init("a", low_params_, LOW, &callback, pool_, BoundNetLog());
+ int rv = handle.Init("a", low_params_, LOW, &callback, &pool_, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_FALSE(handle.is_initialized());
EXPECT_FALSE(handle.socket());
@@ -321,34 +338,36 @@ TEST_F(TCPClientSocketPoolTest, Basic) {
TEST_F(TCPClientSocketPoolTest, InitHostResolutionFailure) {
host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
- TestSocketRequest req(&request_order_, &completion_count_);
+ TestCompletionCallback callback;
+ ClientSocketHandle handle;
scoped_refptr<TCPSocketParams> dest = new TCPSocketParams(
"unresolvable.host.name", 80, kDefaultPriority, GURL(), false);
EXPECT_EQ(ERR_IO_PENDING,
- req.handle()->Init("a", dest, kDefaultPriority, &req, pool_,
- BoundNetLog()));
- EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req.WaitForResult());
+ handle.Init("a", dest, kDefaultPriority, &callback, &pool_,
+ BoundNetLog()));
+ EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
}
TEST_F(TCPClientSocketPoolTest, InitConnectionFailure) {
client_socket_factory_.set_client_socket_type(
MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
- TestSocketRequest req(&request_order_, &completion_count_);
- EXPECT_EQ(ERR_IO_PENDING, req.handle()->Init("a", params_, kDefaultPriority,
- &req, pool_, BoundNetLog()));
- EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
+ TestCompletionCallback callback;
+ ClientSocketHandle handle;
+ EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
+ &callback, &pool_, BoundNetLog()));
+ EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
// Make the host resolutions complete synchronously this time.
host_resolver_->set_synchronous_mode(true);
- EXPECT_EQ(ERR_CONNECTION_FAILED, req.handle()->Init("a", params_,
- kDefaultPriority, &req,
- pool_, BoundNetLog()));
+ EXPECT_EQ(ERR_CONNECTION_FAILED, handle.Init("a", params_,
+ kDefaultPriority, &callback,
+ &pool_, BoundNetLog()));
}
TEST_F(TCPClientSocketPoolTest, PendingRequests) {
// First request finishes asynchronously.
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, requests_[0]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
// Make all subsequent host resolutions complete synchronously.
host_resolver_->set_synchronous_mode(true);
@@ -372,12 +391,12 @@ TEST_F(TCPClientSocketPoolTest, PendingRequests) {
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
- ReleaseAllConnections(KEEP_ALIVE);
+ ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count());
// One initial asynchronous request and then 10 pending requests.
- EXPECT_EQ(11U, completion_count_);
+ EXPECT_EQ(11U, completion_count());
// First part of requests, all with the same priority, finishes in FIFO order.
EXPECT_EQ(1, GetOrderOfRequest(1));
@@ -400,13 +419,13 @@ TEST_F(TCPClientSocketPoolTest, PendingRequests) {
EXPECT_EQ(9, GetOrderOfRequest(16));
// Make sure we test order of all requests made.
- EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(17));
+ EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
}
TEST_F(TCPClientSocketPoolTest, PendingRequests_NoKeepAlive) {
// First request finishes asynchronously.
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, requests_[0]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
// Make all subsequent host resolutions complete synchronously.
host_resolver_->set_synchronous_mode(true);
@@ -425,53 +444,48 @@ TEST_F(TCPClientSocketPoolTest, PendingRequests_NoKeepAlive) {
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- ReleaseAllConnections(NO_KEEP_ALIVE);
+ ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
// The pending requests should finish successfully.
- EXPECT_EQ(OK, requests_[6]->WaitForResult());
- EXPECT_EQ(OK, requests_[7]->WaitForResult());
- EXPECT_EQ(OK, requests_[8]->WaitForResult());
- EXPECT_EQ(OK, requests_[9]->WaitForResult());
- EXPECT_EQ(OK, requests_[10]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[6]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[7]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[8]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[9]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[10]->WaitForResult());
- EXPECT_EQ(static_cast<int>(requests_.size()),
+ EXPECT_EQ(static_cast<int>(requests()->size()),
client_socket_factory_.allocation_count());
// First asynchronous request, and then last 5 pending requests.
- EXPECT_EQ(6U, completion_count_);
+ EXPECT_EQ(6U, completion_count());
}
// This test will start up a RequestSocket() and then immediately Cancel() it.
// The pending host resolution will eventually complete, and destroy the
// ClientSocketPool which will crash if the group was not cleared properly.
TEST_F(TCPClientSocketPoolTest, CancelRequestClearGroup) {
- TestSocketRequest req(&request_order_, &completion_count_);
- EXPECT_EQ(ERR_IO_PENDING, req.handle()->Init("a", params_, kDefaultPriority,
- &req, pool_, BoundNetLog()));
- req.handle()->Reset();
-
- // There is a race condition here. If the worker pool doesn't post the task
- // before we get here, then this might not run ConnectingSocket::OnIOComplete
- // and therefore leak the canceled ConnectingSocket. However, other tests
- // after this will call MessageLoop::RunAllPending() which should prevent a
- // leak, unless the worker thread takes longer than all of them.
- PlatformThread::Sleep(10);
- MessageLoop::current()->RunAllPending();
+ TestCompletionCallback callback;
+ ClientSocketHandle handle;
+ EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
+ &callback, &pool_, BoundNetLog()));
+ handle.Reset();
}
TEST_F(TCPClientSocketPoolTest, TwoRequestsCancelOne) {
- TestSocketRequest req(&request_order_, &completion_count_);
- TestSocketRequest req2(&request_order_, &completion_count_);
+ ClientSocketHandle handle;
+ TestCompletionCallback callback;
+ ClientSocketHandle handle2;
+ TestCompletionCallback callback2;
- EXPECT_EQ(ERR_IO_PENDING, req.handle()->Init("a", params_, kDefaultPriority,
- &req, pool_, BoundNetLog()));
- EXPECT_EQ(ERR_IO_PENDING, req2.handle()->Init("a", params_, kDefaultPriority,
- &req2, pool_, BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
+ &callback, &pool_, BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", params_, kDefaultPriority,
+ &callback2, &pool_, BoundNetLog()));
- req.handle()->Reset();
+ handle.Reset();
- EXPECT_EQ(OK, req2.WaitForResult());
- req2.handle()->Reset();
+ EXPECT_EQ(OK, callback2.WaitForResult());
+ handle2.Reset();
}
TEST_F(TCPClientSocketPoolTest, ConnectCancelConnect) {
@@ -479,16 +493,14 @@ TEST_F(TCPClientSocketPoolTest, ConnectCancelConnect) {
MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET);
ClientSocketHandle handle;
TestCompletionCallback callback;
- TestSocketRequest req(&request_order_, &completion_count_);
-
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
- &callback, pool_, BoundNetLog()));
+ &callback, &pool_, BoundNetLog()));
handle.Reset();
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority,
- &callback2, pool_, BoundNetLog()));
+ &callback2, &pool_, BoundNetLog()));
host_resolver_->set_synchronous_mode(true);
// At this point, handle has two ConnectingSockets out for it. Due to the
@@ -509,7 +521,7 @@ TEST_F(TCPClientSocketPoolTest, ConnectCancelConnect) {
TEST_F(TCPClientSocketPoolTest, CancelRequest) {
// First request finishes asynchronously.
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, requests_[0]->WaitForResult());
+ EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
// Make all subsequent host resolutions complete synchronously.
host_resolver_->set_synchronous_mode(true);
@@ -534,14 +546,14 @@ TEST_F(TCPClientSocketPoolTest, CancelRequest) {
// Cancel a request.
size_t index_to_cancel = kMaxSocketsPerGroup + 2;
- EXPECT_FALSE(requests_[index_to_cancel]->handle()->is_initialized());
- requests_[index_to_cancel]->handle()->Reset();
+ EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
+ (*requests())[index_to_cancel]->handle()->Reset();
- ReleaseAllConnections(KEEP_ALIVE);
+ ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
EXPECT_EQ(kMaxSocketsPerGroup,
client_socket_factory_.allocation_count());
- EXPECT_EQ(requests_.size() - kMaxSocketsPerGroup, completion_count_);
+ EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count());
EXPECT_EQ(1, GetOrderOfRequest(1));
EXPECT_EQ(2, GetOrderOfRequest(2));
@@ -551,7 +563,8 @@ TEST_F(TCPClientSocketPoolTest, CancelRequest) {
EXPECT_EQ(6, GetOrderOfRequest(6));
EXPECT_EQ(14, GetOrderOfRequest(7));
EXPECT_EQ(7, GetOrderOfRequest(8));
- EXPECT_EQ(kRequestNotFound, GetOrderOfRequest(9)); // Canceled request.
+ EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
+ GetOrderOfRequest(9)); // Canceled request.
EXPECT_EQ(9, GetOrderOfRequest(10));
EXPECT_EQ(10, GetOrderOfRequest(11));
EXPECT_EQ(11, GetOrderOfRequest(12));
@@ -561,7 +574,7 @@ TEST_F(TCPClientSocketPoolTest, CancelRequest) {
EXPECT_EQ(15, GetOrderOfRequest(16));
// Make sure we test order of all requests made.
- EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(17));
+ EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
}
class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
@@ -588,8 +601,7 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
within_callback_ = true;
scoped_refptr<TCPSocketParams> dest = new TCPSocketParams(
HostPortPair("www.google.com", 80), LOWEST, GURL(), false);
- int rv = handle_->Init("a", dest, LOWEST, this, pool_,
- BoundNetLog());
+ int rv = handle_->Init("a", dest, LOWEST, this, pool_, BoundNetLog());
EXPECT_EQ(OK, rv);
}
}
@@ -600,17 +612,17 @@ class RequestSocketCallback : public CallbackRunner< Tuple1<int> > {
private:
ClientSocketHandle* const handle_;
- const scoped_refptr<TCPClientSocketPool> pool_;
+ TCPClientSocketPool* const pool_;
bool within_callback_;
TestCompletionCallback callback_;
};
TEST_F(TCPClientSocketPoolTest, RequestTwice) {
ClientSocketHandle handle;
- RequestSocketCallback callback(&handle, pool_.get());
+ RequestSocketCallback callback(&handle, &pool_);
scoped_refptr<TCPSocketParams> dest = new TCPSocketParams(
HostPortPair("www.google.com", 80), LOWEST, GURL(), false);
- int rv = handle.Init("a", dest, LOWEST, &callback, pool_,
+ int rv = handle.Init("a", dest, LOWEST, &callback, &pool_,
BoundNetLog());
ASSERT_EQ(ERR_IO_PENDING, rv);
@@ -641,17 +653,17 @@ TEST_F(TCPClientSocketPoolTest, CancelActiveRequestWithPendingRequests) {
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
// Now, kMaxSocketsPerGroup requests should be active. Let's cancel them.
- ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests_.size()));
+ ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size()));
for (int i = 0; i < kMaxSocketsPerGroup; i++)
- requests_[i]->handle()->Reset();
+ (*requests())[i]->handle()->Reset();
// Let's wait for the rest to complete now.
- for (size_t i = kMaxSocketsPerGroup; i < requests_.size(); ++i) {
- EXPECT_EQ(OK, requests_[i]->WaitForResult());
- requests_[i]->handle()->Reset();
+ for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) {
+ EXPECT_EQ(OK, (*requests())[i]->WaitForResult());
+ (*requests())[i]->handle()->Reset();
}
- EXPECT_EQ(requests_.size() - kMaxSocketsPerGroup, completion_count_);
+ EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count());
}
// Make sure that pending requests get serviced after active requests fail.
@@ -667,13 +679,13 @@ TEST_F(TCPClientSocketPoolTest, FailingActiveRequestWithPendingRequests) {
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
for (int i = 0; i < kNumRequests; i++)
- EXPECT_EQ(ERR_CONNECTION_FAILED, requests_[i]->WaitForResult());
+ EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult());
}
TEST_F(TCPClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) {
TestCompletionCallback callback;
ClientSocketHandle handle;
- int rv = handle.Init("a", low_params_, LOW, &callback, pool_, BoundNetLog());
+ int rv = handle.Init("a", low_params_, LOW, &callback, &pool_, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_FALSE(handle.is_initialized());
EXPECT_FALSE(handle.socket());
@@ -688,13 +700,13 @@ TEST_F(TCPClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) {
MessageLoop::current()->RunAllPending();
// Now we should have 1 idle socket.
- EXPECT_EQ(1, pool_->IdleSocketCount());
+ EXPECT_EQ(1, pool_.IdleSocketCount());
// After an IP address change, we should have 0 idle sockets.
NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
MessageLoop::current()->RunAllPending(); // Notification happens async.
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
}
TEST_F(TCPClientSocketPoolTest, BackupSocketConnect) {
@@ -724,11 +736,11 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketConnect) {
for (size_t index = 0; index < arraysize(cases); ++index) {
client_socket_factory_.set_client_socket_types(cases[index], 2);
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
TestCompletionCallback callback;
ClientSocketHandle handle;
- int rv = handle.Init("b", low_params_, LOW, &callback, pool_,
+ int rv = handle.Init("b", low_params_, LOW, &callback, &pool_,
BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_FALSE(handle.is_initialized());
@@ -748,17 +760,11 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketConnect) {
EXPECT_TRUE(handle.socket());
// One socket is stalled, the other is active.
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
handle.Reset();
// Close all pending connect jobs and existing sockets.
- pool_->Flush();
-
- // TODO(mbelshe): Flush has a bug. UIt doesn't clean out pending connect
- // jobs. When they complete, they become idle sockets. For now, continue
- // to replace the pool_. But we really need to fix Flush().
- pool_ = new TCPClientSocketPool(kMaxSockets, kMaxSocketsPerGroup,
- histograms_, host_resolver_, &client_socket_factory_, NULL);
+ pool_.Flush();
}
}
@@ -771,11 +777,11 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketCancel) {
enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT };
for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) {
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
TestCompletionCallback callback;
ClientSocketHandle handle;
- int rv = handle.Init("c", low_params_, LOW, &callback, pool_,
+ int rv = handle.Init("c", low_params_, LOW, &callback, &pool_,
BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_FALSE(handle.is_initialized());
@@ -799,7 +805,7 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketCancel) {
EXPECT_FALSE(handle.socket());
// One socket is stalled, the other is active.
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
}
}
@@ -816,11 +822,11 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketFailAfterStall) {
client_socket_factory_.set_client_socket_types(case_types, 2);
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
TestCompletionCallback callback;
ClientSocketHandle handle;
- int rv = handle.Init("b", low_params_, LOW, &callback, pool_, BoundNetLog());
+ int rv = handle.Init("b", low_params_, LOW, &callback, &pool_, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_FALSE(handle.is_initialized());
EXPECT_FALSE(handle.socket());
@@ -841,7 +847,7 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketFailAfterStall) {
EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
EXPECT_FALSE(handle.is_initialized());
EXPECT_FALSE(handle.socket());
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
handle.Reset();
// Reset for the next case.
@@ -861,11 +867,11 @@ TEST_F(TCPClientSocketPoolTest, BackupSocketFailAfterDelay) {
client_socket_factory_.set_client_socket_types(case_types, 2);
- EXPECT_EQ(0, pool_->IdleSocketCount());
+ EXPECT_EQ(0, pool_.IdleSocketCount());
TestCompletionCallback callback;
ClientSocketHandle handle;
- int rv = handle.Init("b", low_params_, LOW, &callback, pool_, BoundNetLog());
+ int rv = handle.Init("b", low_params_, LOW, &callback, &pool_, BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_FALSE(handle.is_initialized());
EXPECT_FALSE(handle.socket());
generated by cgit v1.1 at 2025-05-31 00:07:55 +0000