Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(242)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/socket/client_socket_pool_base_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« components/data_reduction_proxy/core/browser/data_reduction_proxy_config.h ('K') | « net/socket/client_socket_pool_base.cc ('k') | net/socket/client_socket_pool_manager.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/socket/client_socket_pool_base_unittest.cc
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index 9007dd21d9ab5d5809dd49cf96fe382c225bf26a..21be2f1e3150ca27fbaad0a755a4f02f924fd6e2 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -127,7 +127,7 @@ class MockClientSocket : public StreamSocket {
explicit MockClientSocket(net::NetLog* net_log)
: connected_(false),
has_unread_data_(false),
- net_log_(BoundNetLog::Make(net_log, NetLogSourceType::SOCKET)),
+ net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)),
was_used_to_convey_data_(false) {}
// Sets whether the socket has unread data. If true, the next call to Read()
@@ -177,7 +177,7 @@ class MockClientSocket : public StreamSocket {
return ERR_UNEXPECTED;
}
- const BoundNetLog& NetLog() const override { return net_log_; }
+ const NetLogWithSource& NetLog() const override { return net_log_; }
void SetSubresourceSpeculation() override {}
void SetOmniboxSpeculation() override {}
@@ -198,7 +198,7 @@ class MockClientSocket : public StreamSocket {
private:
bool connected_;
bool has_unread_data_;
- BoundNetLog net_log_;
+ NetLogWithSource net_log_;
bool was_used_to_convey_data_;
DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
@@ -281,12 +281,13 @@ class TestConnectJob : public ConnectJob {
ConnectJob::Delegate* delegate,
MockClientSocketFactory* client_socket_factory,
NetLog* net_log)
- : ConnectJob(group_name,
- timeout_duration,
- request.priority(),
- request.respect_limits(),
- delegate,
- BoundNetLog::Make(net_log, NetLogSourceType::CONNECT_JOB)),
+ : ConnectJob(
+ group_name,
+ timeout_duration,
+ request.priority(),
+ request.respect_limits(),
+ delegate,
+ NetLogWithSource::Make(net_log, NetLogSourceType::CONNECT_JOB)),
job_type_(job_type),
client_socket_factory_(client_socket_factory),
load_state_(LOAD_STATE_IDLE),
@@ -510,7 +511,7 @@ class TestClientSocketPool : public ClientSocketPool {
RespectLimits respect_limits,
ClientSocketHandle* handle,
const CompletionCallback& callback,
- const BoundNetLog& net_log) override {
+ const NetLogWithSource& net_log) override {
const scoped_refptr<TestSocketParams>* casted_socket_params =
static_cast<const scoped_refptr<TestSocketParams>*>(params);
return base_.RequestSocket(group_name, *casted_socket_params, priority,
@@ -520,7 +521,7 @@ class TestClientSocketPool : public ClientSocketPool {
void RequestSockets(const std::string& group_name,
const void* params,
int num_sockets,
- const BoundNetLog& net_log) override {
+ const NetLogWithSource& net_log) override {
const scoped_refptr<TestSocketParams>* casted_params =
static_cast<const scoped_refptr<TestSocketParams>*>(params);
@@ -748,7 +749,8 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
TestClientSocketPoolBase::Request request(
&ignored, CompletionCallback(), DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog());
+ internal::ClientSocketPoolBaseHelper::NORMAL, params_,
+ NetLogWithSource());
std::unique_ptr<TestConnectJob> job(
new TestConnectJob(TestConnectJob::kMockJob, "a", request,
base::TimeDelta::FromMicroseconds(1), &delegate,
@@ -764,7 +766,8 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
TestClientSocketPoolBase::Request request(
&ignored, CompletionCallback(), DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog());
+ internal::ClientSocketPoolBaseHelper::NORMAL, params_,
+ NetLogWithSource());
// Deleted by TestConnectJobDelegate.
TestConnectJob* job =
new TestConnectJob(TestConnectJob::kMockPendingJob,
@@ -1081,15 +1084,16 @@ TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
ClientSocketHandle handles[4];
for (size_t i = 0; i < arraysize(handles); ++i) {
TestCompletionCallback callback;
- EXPECT_EQ(ERR_IO_PENDING,
- handles[i].Init("b", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handles[i].Init("b", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(), NetLogWithSource()));
}
// One will be stalled, cancel all the handles now.
@@ -1107,20 +1111,21 @@ TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
ClientSocketHandle handles[kDefaultMaxSockets];
TestCompletionCallback callbacks[kDefaultMaxSockets];
for (int i = 0; i < kDefaultMaxSockets; ++i) {
- EXPECT_EQ(OK, handles[i].Init(
- base::IntToString(i), params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callbacks[i].callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK,
+ handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callbacks[i].callback(), pool_.get(),
+ NetLogWithSource()));
}
// Force a stalled group.
ClientSocketHandle stalled_handle;
TestCompletionCallback callback;
- EXPECT_EQ(
- ERR_IO_PENDING,
- stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING,
+ stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(),
+ NetLogWithSource()));
// Cancel the stalled request.
stalled_handle.Reset();
@@ -1143,22 +1148,22 @@ TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
ClientSocketHandle handles[kDefaultMaxSockets];
for (int i = 0; i < kDefaultMaxSockets; ++i) {
TestCompletionCallback callback;
- EXPECT_EQ(
- ERR_IO_PENDING,
- handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING,
+ handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(),
+ NetLogWithSource()));
}
// Force a stalled group.
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
ClientSocketHandle stalled_handle;
TestCompletionCallback callback;
- EXPECT_EQ(
- ERR_IO_PENDING,
- stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING,
+ stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(),
+ NetLogWithSource()));
// Since it is stalled, it should have no connect jobs.
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
@@ -1197,11 +1202,11 @@ TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
ClientSocketHandle handles[kDefaultMaxSockets];
for (int i = 0; i < kDefaultMaxSockets; ++i) {
TestCompletionCallback callback;
- EXPECT_EQ(
- OK, handles[i].Init(base::StringPrintf("Take 2: %d", i), params_,
- DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK, handles[i].Init(base::StringPrintf("Take 2: %d", i),
+ params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(),
+ NetLogWithSource()));
}
EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
@@ -1209,11 +1214,11 @@ TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
EXPECT_FALSE(pool_->IsStalled());
// Now we will hit the socket limit.
- EXPECT_EQ(
- ERR_IO_PENDING,
- stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING,
+ stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(),
+ NetLogWithSource()));
EXPECT_TRUE(pool_->IsStalled());
// Dropping out of scope will close all handles and return them to idle.
@@ -1236,9 +1241,10 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
for (int i = 0; i < kDefaultMaxSockets; ++i) {
ClientSocketHandle handle;
TestCompletionCallback callback;
- EXPECT_EQ(OK, handle.Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ OK, handle.Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(), NetLogWithSource()));
}
// Flush all the DoReleaseSocket tasks.
@@ -1253,9 +1259,10 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
// "0" is special here, since it should be the first entry in the sorted map,
// which is the one which we would close an idle socket for. We shouldn't
// close an idle socket though, since we should reuse the idle socket.
- EXPECT_EQ(OK, handle.Init("0", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK,
+ handle.Init("0", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
@@ -1327,7 +1334,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
handle.Reset();
}
@@ -1341,7 +1348,7 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
handle.Reset();
@@ -1349,7 +1356,7 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ callback2.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback2.WaitForResult(), IsOk());
EXPECT_FALSE(callback.have_result());
@@ -1417,7 +1424,7 @@ void RequestSocketOnComplete(ClientSocketHandle* handle,
TestCompletionCallback callback;
int rv = handle->Init("a", params, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- nested_callback, pool, BoundNetLog());
+ nested_callback, pool, NetLogWithSource());
if (rv != ERR_IO_PENDING) {
DCHECK_EQ(TestConnectJob::kMockJob, next_job_type);
nested_callback.Run(rv);
@@ -1440,7 +1447,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
connect_job_factory_, TestConnectJob::kMockPendingJob,
second_result_callback.callback()),
- pool_.get(), BoundNetLog());
+ pool_.get(), NetLogWithSource());
ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_THAT(second_result_callback.WaitForResult(), IsOk());
@@ -1460,7 +1467,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
connect_job_factory_, TestConnectJob::kMockPendingJob,
second_result_callback.callback()),
- pool_.get(), BoundNetLog());
+ pool_.get(), NetLogWithSource());
ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_THAT(second_result_callback.WaitForResult(), IsOk());
@@ -1525,7 +1532,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Cancel the active request.
@@ -1533,7 +1540,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
rv = handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_THAT(callback.WaitForResult(), IsOk());
@@ -1678,12 +1685,13 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
BoundTestNetLog log2;
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
handle.Reset();
@@ -1730,9 +1738,9 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
std::vector<TestSocketRequest*> request_order;
size_t completion_count; // unused
TestSocketRequest req1(&request_order, &completion_count);
- int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- req1.callback(), pool_.get(), BoundNetLog());
+ int rv = req1.handle()->Init(
+ "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED,
+ req1.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_THAT(req1.WaitForResult(), IsOk());
@@ -1743,12 +1751,12 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
TestSocketRequest req2(&request_order, &completion_count);
rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- req2.callback(), pool_.get(), BoundNetLog());
+ req2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
TestSocketRequest req3(&request_order, &completion_count);
rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- req3.callback(), pool_.get(), BoundNetLog());
+ req3.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Both Requests 2 and 3 are pending. We release socket 1 which should
@@ -1782,15 +1790,15 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
std::vector<TestSocketRequest*> request_order;
size_t completion_count; // unused
TestSocketRequest req1(&request_order, &completion_count);
- int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- req1.callback(), pool_.get(), BoundNetLog());
+ int rv = req1.handle()->Init(
+ "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED,
+ req1.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
TestSocketRequest req2(&request_order, &completion_count);
rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- req2.callback(), pool_.get(), BoundNetLog());
+ req2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// The pending job is sync.
@@ -1799,7 +1807,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
TestSocketRequest req3(&request_order, &completion_count);
rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- req3.callback(), pool_.get(), BoundNetLog());
+ req3.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_THAT(req1.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
@@ -1821,7 +1829,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
@@ -1842,7 +1850,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
@@ -1850,7 +1858,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
TestCompletionCallback callback2;
rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
@@ -1875,14 +1883,14 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequestsChangeSecondRequestState) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
ClientSocketHandle handle2;
TestCompletionCallback callback2;
rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
@@ -1905,7 +1913,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, MEDIUM,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
@@ -1915,7 +1923,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
TestCompletionCallback callback2;
rv = handle2.Init("a", params_, HIGHEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
@@ -1947,7 +1955,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Request for socket from another pool.
@@ -1955,7 +1963,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
TestCompletionCallback callback2;
rv = handle2.Init("b", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Request another socket from the first pool. Request should stall at the
@@ -1964,7 +1972,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
TestCompletionCallback callback3;
rv = handle3.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// The third handle should remain stalled as the other sockets in its group
@@ -1997,7 +2005,7 @@ TEST_F(ClientSocketPoolBaseTest, Recoverable) {
EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_TRUE(handle.is_initialized());
EXPECT_TRUE(handle.socket());
}
@@ -2012,7 +2020,7 @@ TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_AUTH_REQUESTED));
EXPECT_TRUE(handle.is_initialized());
@@ -2029,7 +2037,7 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
EXPECT_EQ(ERR_CONNECTION_FAILED,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_FALSE(handle.is_initialized());
EXPECT_FALSE(handle.socket());
EXPECT_TRUE(handle.is_ssl_error());
@@ -2046,7 +2054,7 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
EXPECT_FALSE(handle.is_initialized());
@@ -2068,7 +2076,7 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSocketsReuse) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
ASSERT_THAT(callback.WaitForResult(), IsOk());
@@ -2124,7 +2132,7 @@ TEST_F(ClientSocketPoolBaseTest, MAYBE_CleanupTimedOutIdleSocketsNoReuse) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
@@ -2132,7 +2140,7 @@ TEST_F(ClientSocketPoolBaseTest, MAYBE_CleanupTimedOutIdleSocketsNoReuse) {
TestCompletionCallback callback2;
rv = handle2.Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
@@ -2195,28 +2203,28 @@ TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
TestCompletionCallback callback;
int rv = handle.Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog());
+ callback.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsOk());
ClientSocketHandle handle2;
TestCompletionCallback callback2;
rv = handle2.Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsOk());
ClientSocketHandle handle3;
TestCompletionCallback callback3;
rv = handle3.Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback3.callback(), pool_.get(), BoundNetLog());
+ callback3.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
ClientSocketHandle handle4;
TestCompletionCallback callback4;
rv = handle4.Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
- callback4.callback(), pool_.get(), BoundNetLog());
+ callback4.callback(), pool_.get(), NetLogWithSource());
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
// Release two disconnected sockets.
@@ -2254,26 +2262,26 @@ TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) {
EXPECT_EQ(OK, handle_a[i].Init("a", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
callback_a[i].callback(), pool_.get(),
- BoundNetLog()));
+ NetLogWithSource()));
EXPECT_EQ(OK, handle_b[i].Init("b", params_, LOWEST,
ClientSocketPool::RespectLimits::ENABLED,
callback_b[i].callback(), pool_.get(),
- BoundNetLog()));
+ NetLogWithSource()));
}
// Make 4 pending requests, 2 per group.
for (int i = 2; i < 4; ++i) {
- EXPECT_EQ(
- ERR_IO_PENDING,
- handle_a[i].Init("a", params_, LOWEST,
- ClientSocketPool::RespectLimits::ENABLED,
- callback_a[i].callback(), pool_.get(), BoundNetLog()));
- EXPECT_EQ(
- ERR_IO_PENDING,
- handle_b[i].Init("b", params_, LOWEST,
- ClientSocketPool::RespectLimits::ENABLED,
- callback_b[i].callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING,
+ handle_a[i].Init("a", params_, LOWEST,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback_a[i].callback(), pool_.get(),
+ NetLogWithSource()));
+ EXPECT_EQ(ERR_IO_PENDING,
+ handle_b[i].Init("b", params_, LOWEST,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback_b[i].callback(), pool_.get(),
+ NetLogWithSource()));
}
// Release b's socket first. The order is important, because in
@@ -2360,7 +2368,7 @@ class TestReleasingSocketRequest : public TestCompletionCallbackBase {
EXPECT_EQ(expected_result_,
handle2_.Init("a", con_params, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2_.callback(), pool_, BoundNetLog()));
+ callback2_.callback(), pool_, NetLogWithSource()));
}
TestClientSocketPool* const pool_;
@@ -2386,10 +2394,11 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
connect_job_factory_->set_job_type(
TestConnectJob::kMockPendingAdditionalErrorStateJob);
TestReleasingSocketRequest req(pool_.get(), OK, false);
- EXPECT_EQ(ERR_IO_PENDING,
- req.handle()->Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- req.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ req.handle()->Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ req.callback(), pool_.get(), NetLogWithSource()));
// The next job should complete synchronously
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
@@ -2417,7 +2426,7 @@ TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
pool_->FlushWithError(ERR_NETWORK_CHANGED);
@@ -2434,7 +2443,7 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
@@ -2446,7 +2455,7 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
}
@@ -2475,10 +2484,11 @@ class ConnectWithinCallback : public TestCompletionCallbackBase {
private:
void OnComplete(int result) {
SetResult(result);
- EXPECT_EQ(ERR_IO_PENDING,
- handle_.Init(group_name_, params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- nested_callback_.callback(), pool_, BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle_.Init(group_name_, params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ nested_callback_.callback(), pool_, NetLogWithSource()));
}
const std::string group_name_;
@@ -2502,7 +2512,7 @@ TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
// Second job will be started during the first callback, and will
// asynchronously complete with OK.
@@ -2527,17 +2537,17 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("bar", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
// Start (MaxSockets - 1) connected sockets to reach max sockets.
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
ClientSocketHandle handles[kDefaultMaxSockets];
for (int i = 1; i < kDefaultMaxSockets; ++i) {
TestCompletionCallback callback;
- EXPECT_EQ(OK,
- handles[i].Init("bar", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK, handles[i].Init("bar", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(),
+ NetLogWithSource()));
}
base::RunLoop().RunUntilIdle();
@@ -2565,7 +2575,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("bar", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
ASSERT_TRUE(pool_->HasGroup("bar"));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar"));
@@ -2593,14 +2603,15 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("bar", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
ClientSocketHandle handle2;
TestCompletionCallback callback2;
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("bar", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("bar", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
ASSERT_TRUE(pool_->HasGroup("bar"));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
@@ -2627,7 +2638,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
EXPECT_EQ(ERR_IO_PENDING,
handle1.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// No idle sockets, no pending jobs.
@@ -2640,7 +2651,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
// No idle sockets, and one connecting job.
EXPECT_EQ(0, pool_->IdleSocketCount());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -2679,7 +2690,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
EXPECT_EQ(ERR_IO_PENDING,
handle1.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// No idle sockets, no pending jobs.
@@ -2692,7 +2703,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
// No idle sockets, and one connecting job.
EXPECT_EQ(0, pool_->IdleSocketCount());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -2733,7 +2744,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
EXPECT_EQ(ERR_IO_PENDING,
handle1.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
// No idle sockets, no pending jobs.
@@ -2746,7 +2757,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
// No idle sockets, and one connecting job.
EXPECT_EQ(0, pool_->IdleSocketCount());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -2787,10 +2798,11 @@ TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
// Make the second request synchronously fail. This should make the Group
@@ -2800,10 +2812,11 @@ TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
TestCompletionCallback callback2;
// It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail
// when created.
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -2819,23 +2832,26 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ClientSocketHandle handle2;
TestCompletionCallback callback2;
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
ClientSocketHandle handle3;
TestCompletionCallback callback3;
- EXPECT_EQ(ERR_IO_PENDING,
- handle3.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback3.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle3.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback3.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback1.WaitForResult(), IsOk());
EXPECT_THAT(callback2.WaitForResult(), IsOk());
@@ -2849,15 +2865,18 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
handle2.Reset();
handle3.Reset();
- EXPECT_EQ(OK, handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
- EXPECT_EQ(OK, handle2.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
- EXPECT_EQ(OK, handle3.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback3.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ OK, handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
+ EXPECT_EQ(
+ OK, handle2.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
+ EXPECT_EQ(
+ OK, handle3.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback3.callback(), pool_.get(), NetLogWithSource()));
EXPECT_TRUE(handle1.socket()->WasEverUsed());
EXPECT_TRUE(handle2.socket()->WasEverUsed());
@@ -2868,7 +2887,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
@@ -2877,17 +2896,19 @@ TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ClientSocketHandle handle2;
TestCompletionCallback callback2;
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -2909,17 +2930,18 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -2927,10 +2949,11 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
ClientSocketHandle handle2;
TestCompletionCallback callback2;
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -2953,31 +2976,34 @@ TEST_F(ClientSocketPoolBaseTest,
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ClientSocketHandle handle2;
TestCompletionCallback callback2;
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
ClientSocketHandle handle3;
TestCompletionCallback callback3;
- EXPECT_EQ(ERR_IO_PENDING,
- handle3.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback3.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle3.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback3.callback(), pool_.get(), NetLogWithSource()));
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3001,8 +3027,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
ASSERT_FALSE(pool_->HasGroup("a"));
- pool_->RequestSockets("a", &params_, kDefaultMaxSockets,
- BoundNetLog());
+ pool_->RequestSockets("a", &params_, kDefaultMaxSockets, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(kDefaultMaxSockets, pool_->NumConnectJobsInGroup("a"));
@@ -3010,8 +3035,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
ASSERT_FALSE(pool_->HasGroup("b"));
- pool_->RequestSockets("b", &params_, kDefaultMaxSockets,
- BoundNetLog());
+ pool_->RequestSockets("b", &params_, kDefaultMaxSockets, NetLogWithSource());
ASSERT_FALSE(pool_->HasGroup("b"));
}
@@ -3023,7 +3047,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
ASSERT_FALSE(pool_->HasGroup("a"));
pool_->RequestSockets("a", &params_, kDefaultMaxSockets - 1,
- BoundNetLog());
+ NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(kDefaultMaxSockets - 1, pool_->NumConnectJobsInGroup("a"));
@@ -3033,8 +3057,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
ASSERT_FALSE(pool_->HasGroup("b"));
- pool_->RequestSockets("b", &params_, kDefaultMaxSockets,
- BoundNetLog());
+ pool_->RequestSockets("b", &params_, kDefaultMaxSockets, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("b"));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b"));
@@ -3047,10 +3070,11 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ASSERT_THAT(callback1.WaitForResult(), IsOk());
handle1.Reset();
@@ -3059,7 +3083,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3072,10 +3096,11 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ASSERT_THAT(callback1.WaitForResult(), IsOk());
ASSERT_TRUE(pool_->HasGroup("a"));
@@ -3084,7 +3109,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3097,7 +3122,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
- BoundNetLog());
+ NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
@@ -3105,7 +3130,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("a"));
pool_->RequestSockets("b", &params_, kDefaultMaxSocketsPerGroup,
- BoundNetLog());
+ NetLogWithSource());
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
@@ -3117,14 +3142,14 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronousError) {
connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
- BoundNetLog());
+ NetLogWithSource());
ASSERT_FALSE(pool_->HasGroup("a"));
connect_job_factory_->set_job_type(
TestConnectJob::kMockAdditionalErrorStateJob);
pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
- BoundNetLog());
+ NetLogWithSource());
ASSERT_FALSE(pool_->HasGroup("a"));
}
@@ -3133,31 +3158,32 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
CreatePool(4, 4);
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ASSERT_THAT(callback1.WaitForResult(), IsOk());
ClientSocketHandle handle2;
TestCompletionCallback callback2;
int rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog());
+ callback2.callback(), pool_.get(), NetLogWithSource());
if (rv != OK) {
EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
EXPECT_THAT(callback2.WaitForResult(), IsOk());
@@ -3175,7 +3201,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
@@ -3185,24 +3211,24 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsDifferentNumSockets) {
CreatePool(4, 4);
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- pool_->RequestSockets("a", &params_, 1, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 3, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 3, NetLogWithSource());
EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
- pool_->RequestSockets("a", &params_, 1, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
@@ -3212,7 +3238,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- pool_->RequestSockets("a", &params_, 1, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -3221,10 +3247,11 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3245,7 +3272,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
- pool_->RequestSockets("a", &params_, 1, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
@@ -3254,9 +3281,10 @@ TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
ClientSocketHandle handle;
TestCompletionCallback callback;
- EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK,
+ handle.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(), NetLogWithSource()));
// Make sure the idle socket was used.
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
@@ -3279,10 +3307,11 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
// Set up one idle socket in "a".
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
ASSERT_THAT(callback1.WaitForResult(), IsOk());
handle1.Reset();
@@ -3291,14 +3320,16 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
// Set up two active sockets in "b".
ClientSocketHandle handle2;
TestCompletionCallback callback2;
- EXPECT_EQ(ERR_IO_PENDING,
- handle1.Init("b", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
- EXPECT_EQ(ERR_IO_PENDING,
- handle2.Init("b", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle1.Init("b", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle2.Init("b", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback2.callback(), pool_.get(), NetLogWithSource()));
ASSERT_THAT(callback1.WaitForResult(), IsOk());
ASSERT_THAT(callback2.WaitForResult(), IsOk());
@@ -3311,7 +3342,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
// 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("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
@@ -3329,7 +3360,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
EXPECT_EQ(2, pool_->IdleSocketCountInGroup("b"));
EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
- pool_->RequestSockets("a", &params_, 2, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
@@ -3348,7 +3379,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) {
connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
connect_job_factory_->set_timeout_duration(
base::TimeDelta::FromMilliseconds(500));
- pool_->RequestSockets("a", &params_, 1, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
@@ -3370,7 +3401,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
// Make the ConnectJob hang forever.
connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
- pool_->RequestSockets("a", &params_, 1, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
@@ -3383,7 +3414,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
// Timer has started, but the backup connect job shouldn't be created yet.
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3405,7 +3436,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob);
- pool_->RequestSockets("a", &params_, 1, BoundNetLog());
+ pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
@@ -3417,9 +3448,10 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
ClientSocketHandle handle;
TestCompletionCallback callback;
- EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK,
+ handle.Init("a", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback.callback(), pool_.get(), NetLogWithSource()));
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
@@ -3454,14 +3486,14 @@ class MockLayeredPool : public HigherLayeredPool {
scoped_refptr<TestSocketParams> params(new TestSocketParams());
return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback_.callback(), pool, BoundNetLog());
+ callback_.callback(), pool, NetLogWithSource());
}
int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
scoped_refptr<TestSocketParams> params(new TestSocketParams());
return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
ClientSocketPool::RespectLimits::DISABLED,
- callback_.callback(), pool, BoundNetLog());
+ callback_.callback(), pool, NetLogWithSource());
}
bool ReleaseOneConnection() {
@@ -3526,7 +3558,7 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
}
@@ -3544,9 +3576,10 @@ TEST_F(ClientSocketPoolBaseTest,
// has the maximum number of connections already, it's not stalled).
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
MockLayeredPool mock_layered_pool(pool_.get(), "group2");
EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
@@ -3558,7 +3591,7 @@ TEST_F(ClientSocketPoolBaseTest,
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("group2", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback2.callback(), pool_.get(), BoundNetLog()));
+ callback2.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback2.WaitForResult(), IsOk());
}
@@ -3576,9 +3609,10 @@ TEST_F(ClientSocketPoolBaseTest,
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
MockLayeredPool mock_layered_pool(pool_.get(), "group2");
EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
@@ -3590,10 +3624,11 @@ TEST_F(ClientSocketPoolBaseTest,
// The third request is made when the socket pool is in a stalled state.
ClientSocketHandle handle3;
TestCompletionCallback callback3;
- EXPECT_EQ(ERR_IO_PENDING,
- handle3.Init("group3", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback3.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle3.Init("group3", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback3.callback(), pool_.get(), NetLogWithSource()));
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(callback3.have_result());
@@ -3604,10 +3639,11 @@ TEST_F(ClientSocketPoolBaseTest,
mock_layered_pool.set_can_release_connection(true);
ClientSocketHandle handle4;
TestCompletionCallback callback4;
- EXPECT_EQ(ERR_IO_PENDING,
- handle4.Init("group3", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback4.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle4.Init("group3", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback4.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback3.WaitForResult(), IsOk());
EXPECT_FALSE(callback4.have_result());
@@ -3634,9 +3670,10 @@ TEST_F(ClientSocketPoolBaseTest,
ClientSocketHandle handle1;
TestCompletionCallback callback1;
- EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
- ClientSocketPool::RespectLimits::ENABLED,
- callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback1.callback(), pool_.get(), NetLogWithSource()));
MockLayeredPool mock_layered_pool(pool_.get(), "group2");
EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
@@ -3648,10 +3685,11 @@ TEST_F(ClientSocketPoolBaseTest,
// The third request is made when the socket pool is in a stalled state.
ClientSocketHandle handle3;
TestCompletionCallback callback3;
- EXPECT_EQ(ERR_IO_PENDING,
- handle3.Init("group3", params_, MEDIUM,
- ClientSocketPool::RespectLimits::ENABLED,
- callback3.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle3.Init("group3", params_, MEDIUM,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback3.callback(), pool_.get(), NetLogWithSource()));
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(callback3.have_result());
@@ -3661,10 +3699,11 @@ TEST_F(ClientSocketPoolBaseTest,
mock_layered_pool.set_can_release_connection(true);
ClientSocketHandle handle4;
TestCompletionCallback callback4;
- EXPECT_EQ(ERR_IO_PENDING,
- handle4.Init("group3", params_, HIGHEST,
- ClientSocketPool::RespectLimits::ENABLED,
- callback4.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ handle4.Init("group3", params_, HIGHEST,
+ ClientSocketPool::RespectLimits::ENABLED,
+ callback4.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback4.WaitForResult(), IsOk());
EXPECT_FALSE(callback3.have_result());
@@ -3694,7 +3733,7 @@ TEST_F(ClientSocketPoolBaseTest,
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a", params_, DEFAULT_PRIORITY,
ClientSocketPool::RespectLimits::ENABLED,
- callback.callback(), pool_.get(), BoundNetLog()));
+ callback.callback(), pool_.get(), NetLogWithSource()));
EXPECT_THAT(callback.WaitForResult(), IsOk());
}
« components/data_reduction_proxy/core/browser/data_reduction_proxy_config.h ('K') | « net/socket/client_socket_pool_base.cc ('k') | net/socket/client_socket_pool_manager.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698