Chromium Code Reviews Chromium Code Reviews
Issue 1580903002:
Convert ignore_limits from a SocketParam to a socket request argument. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master| 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 a467f49e6013cec34ab9781c034cd6884ac83d3b..33cdaf2d85f3f07068155dbaee472a033f868ccf 100644 |
| --- a/net/socket/client_socket_pool_base_unittest.cc |
| +++ b/net/socket/client_socket_pool_base_unittest.cc |
| @@ -107,16 +107,11 @@ void TestLoadTimingInfoNotConnected(const ClientSocketHandle& handle) { |
| class TestSocketParams : public base::RefCounted<TestSocketParams> { |
| public: |
| - explicit TestSocketParams(bool ignore_limits) |
| - : ignore_limits_(ignore_limits) {} |
| - |
| - bool ignore_limits() { return ignore_limits_; } |
| + explicit TestSocketParams() {} |
| private: |
| friend class base::RefCounted<TestSocketParams>; |
| ~TestSocketParams() {} |
| - |
| - const bool ignore_limits_; |
| }; |
| typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase; |
| @@ -278,14 +273,17 @@ class TestConnectJob : public ConnectJob { |
| ConnectJob::Delegate* delegate, |
| MockClientSocketFactory* client_socket_factory, |
| NetLog* net_log) |
| - : ConnectJob(group_name, timeout_duration, request.priority(), delegate, |
| + : ConnectJob(group_name, |
| + timeout_duration, |
| + request.priority(), |
| + request.ignore_limits(), |
| + delegate, |
| BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)), |
| job_type_(job_type), |
| client_socket_factory_(client_socket_factory), |
| load_state_(LOAD_STATE_IDLE), |
| store_additional_error_state_(false), |
| - weak_factory_(this) { |
| - } |
| + weak_factory_(this) {} |
| void Signal() { |
| DoConnect(waiting_success_, true /* async */, false /* recoverable */); |
| @@ -505,13 +503,14 @@ class TestClientSocketPool : public ClientSocketPool { |
| int RequestSocket(const std::string& group_name, |
| const void* params, |
| RequestPriority priority, |
| + IgnoreLimits ignore_limits, |
| ClientSocketHandle* handle, |
| const CompletionCallback& callback, |
| const BoundNetLog& 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, |
| - handle, callback, net_log); |
| + ignore_limits, handle, callback, net_log); |
| } |
| void RequestSockets(const std::string& group_name, |
| @@ -663,8 +662,7 @@ class TestConnectJobDelegate : public ConnectJob::Delegate { |
| class ClientSocketPoolBaseTest : public testing::Test { |
| protected: |
| - ClientSocketPoolBaseTest() |
| - : params_(new TestSocketParams(false /* ignore_limits */)) { |
| + ClientSocketPoolBaseTest() : params_(new TestSocketParams()) { |
| connect_backup_jobs_enabled_ = |
| internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled(); |
| internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true); |
| @@ -701,16 +699,17 @@ class ClientSocketPoolBaseTest : public testing::Test { |
| connect_job_factory_)); |
| } |
| - int StartRequestWithParams( |
| + int StartRequestWithIgnoreLimits( |
| const std::string& group_name, |
| RequestPriority priority, |
| - const scoped_refptr<TestSocketParams>& params) { |
| - return test_base_.StartRequestUsingPool( |
| - pool_.get(), group_name, priority, params); |
| + ClientSocketPool::IgnoreLimits ignore_limits) { |
| + return test_base_.StartRequestUsingPool(pool_.get(), group_name, priority, |
| + ignore_limits, params_); |
| } |
| int StartRequest(const std::string& group_name, RequestPriority priority) { |
| - return StartRequestWithParams(group_name, priority, params_); |
| + return StartRequestWithIgnoreLimits( |
| + group_name, priority, ClientSocketPool::IgnoreLimits::DISABLED); |
| } |
| int GetOrderOfRequest(size_t index) const { |
| @@ -749,8 +748,8 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) { |
| ClientSocketHandle ignored; |
| TestClientSocketPoolBase::Request request( |
| &ignored, CompletionCallback(), DEFAULT_PRIORITY, |
| - internal::ClientSocketPoolBaseHelper::NORMAL, |
| - false, params_, BoundNetLog()); |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog()); |
| scoped_ptr<TestConnectJob> job( |
| new TestConnectJob(TestConnectJob::kMockJob, |
| "a", |
| @@ -769,8 +768,8 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) { |
| TestClientSocketPoolBase::Request request( |
| &ignored, CompletionCallback(), DEFAULT_PRIORITY, |
| - internal::ClientSocketPoolBaseHelper::NORMAL, |
| - false, params_, BoundNetLog()); |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog()); |
| // Deleted by TestConnectJobDelegate. |
| TestConnectJob* job = |
| new TestConnectJob(TestConnectJob::kMockPendingJob, |
| @@ -812,13 +811,9 @@ TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) { |
| BoundTestNetLog log; |
| TestLoadTimingInfoNotConnected(handle); |
| - EXPECT_EQ(OK, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - log.bound())); |
| + EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), log.bound())); |
| EXPECT_TRUE(handle.is_initialized()); |
| EXPECT_TRUE(handle.socket()); |
| TestLoadTimingInfoConnectedNotReused(handle); |
| @@ -856,12 +851,9 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { |
| info.headers = new HttpResponseHeaders(std::string()); |
| handle.set_ssl_error_response_info(info); |
| EXPECT_EQ(ERR_CONNECTION_FAILED, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - log.bound())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), log.bound())); |
| EXPECT_FALSE(handle.socket()); |
| EXPECT_FALSE(handle.is_ssl_error()); |
| EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL); |
| @@ -1096,23 +1088,17 @@ TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| 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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handles[i].Init("b", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| } |
| // One will be stalled, cancel all the handles now. |
| @@ -1130,23 +1116,20 @@ 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, |
| - callbacks[i].callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handles[i].Init( |
| + base::IntToString(i), params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callbacks[i].callback(), pool_.get(), BoundNetLog())); |
| } |
| // Force a stalled group. |
| ClientSocketHandle stalled_handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ( |
| + ERR_IO_PENDING, |
| + stalled_handle.Init("foo", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // Cancel the stalled request. |
| stalled_handle.Reset(); |
| @@ -1169,24 +1152,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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ( |
| + ERR_IO_PENDING, |
| + handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| } |
| // 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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ( |
| + ERR_IO_PENDING, |
| + stalled_handle.Init("foo", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // Since it is stalled, it should have no connect jobs. |
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo")); |
| @@ -1225,13 +1206,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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ( |
| + OK, handles[i].Init(base::StringPrintf("Take 2: %d", i), params_, |
| + DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| } |
| EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); |
| @@ -1239,12 +1218,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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ( |
| + ERR_IO_PENDING, |
| + stalled_handle.Init("foo", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_TRUE(pool_->IsStalled()); |
| // Dropping out of scope will close all handles and return them to idle. |
| @@ -1267,12 +1245,9 @@ 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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle.Init(base::IntToString(i), params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| } |
| // Flush all the DoReleaseSocket tasks. |
| @@ -1287,12 +1262,9 @@ 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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle.Init("0", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); |
| EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount()); |
| @@ -1361,12 +1333,10 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
|
eroman
2016/01/27 20:15:13
Might consider an overload for Init() that doesn't
mmenke
2016/01/27 20:37:27
I prefer to avoid overloads, just because it's eas
eroman
2016/01/27 20:40:21
ok, i figured as much
|
| + callback.callback(), pool_.get(), BoundNetLog())); |
| handle.Reset(); |
| } |
| @@ -1377,23 +1347,18 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| handle.Reset(); |
| TestCompletionCallback callback2; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback2.WaitForResult()); |
| EXPECT_FALSE(callback.have_result()); |
| @@ -1457,11 +1422,11 @@ void RequestSocketOnComplete(ClientSocketHandle* handle, |
| handle->socket()->Disconnect(); |
| handle->Reset(); |
| - scoped_refptr<TestSocketParams> params( |
| - new TestSocketParams(false /* ignore_limits */)); |
| + scoped_refptr<TestSocketParams> params(new TestSocketParams()); |
| TestCompletionCallback callback; |
| - int rv = |
| - handle->Init("a", params, LOWEST, nested_callback, pool, BoundNetLog()); |
| + int rv = handle->Init("a", params, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + nested_callback, pool, BoundNetLog()); |
| if (rv != ERR_IO_PENDING) { |
| DCHECK_EQ(TestConnectJob::kMockJob, next_job_type); |
| nested_callback.Run(rv); |
| @@ -1480,7 +1445,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) { |
| ClientSocketHandle handle; |
| TestCompletionCallback second_result_callback; |
| int rv = handle.Init( |
| - "a", params_, DEFAULT_PRIORITY, |
| + "a", params_, DEFAULT_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED, |
| base::Bind(&RequestSocketOnComplete, &handle, pool_.get(), |
| connect_job_factory_, TestConnectJob::kMockPendingJob, |
| second_result_callback.callback()), |
| @@ -1500,7 +1465,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) { |
| ClientSocketHandle handle; |
| TestCompletionCallback second_result_callback; |
| int rv = handle.Init( |
| - "a", params_, DEFAULT_PRIORITY, |
| + "a", params_, DEFAULT_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED, |
| base::Bind(&RequestSocketOnComplete, &handle, pool_.get(), |
| connect_job_factory_, TestConnectJob::kMockPendingJob, |
| second_result_callback.callback()), |
| @@ -1567,23 +1532,17 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| // Cancel the active request. |
| handle.Reset(); |
| - rv = handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| @@ -1636,12 +1595,9 @@ TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| BoundTestNetLog log; |
| - int rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - callback.callback(), |
| - pool_.get(), |
| - log.bound()); |
| + int rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), log.bound()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
| TestLoadTimingInfoNotConnected(handle); |
| @@ -1683,12 +1639,10 @@ TEST_F(ClientSocketPoolBaseTest, |
| HttpResponseInfo info; |
| info.headers = new HttpResponseHeaders(std::string()); |
| handle.set_ssl_error_response_info(info); |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - log.bound())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), log.bound())); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
| EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
| EXPECT_FALSE(handle.is_ssl_error()); |
| @@ -1735,20 +1689,14 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) { |
| TestCompletionCallback callback2; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| BoundTestNetLog log2; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| handle.Reset(); |
| @@ -1795,11 +1743,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, |
| - req1.callback(), pool_.get(), |
| - BoundNetLog()); |
| + int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + req1.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(OK, req1.WaitForResult()); |
| @@ -1808,20 +1754,14 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
| TestSocketRequest req2(&request_order, &completion_count); |
| - rv = req2.handle()->Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - req2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + req2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| TestSocketRequest req3(&request_order, &completion_count); |
| - rv = req3.handle()->Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - req3.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + req3.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| // Both Requests 2 and 3 are pending. We release socket 1 which should |
| @@ -1855,33 +1795,24 @@ 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, |
| - req1.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + req1.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| TestSocketRequest req2(&request_order, &completion_count); |
| - rv = req2.handle()->Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - req2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + req2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| // The pending job is sync. |
| connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
| TestSocketRequest req3(&request_order, &completion_count); |
| - rv = req3.handle()->Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - req3.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + req3.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult()); |
| @@ -1901,12 +1832,9 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); |
| @@ -1925,15 +1853,17 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(), |
| - pool_.get(), BoundNetLog()); |
| + int rv = handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - rv = handle2.Init("a", params_, DEFAULT_PRIORITY, callback2.callback(), |
| - pool_.get(), BoundNetLog()); |
| + rv = handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST); |
| @@ -1956,14 +1886,16 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequestsChangeSecondRequestState) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(), |
| - pool_.get(), BoundNetLog()); |
| + int rv = handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - rv = handle2.Init("a", params_, DEFAULT_PRIORITY, callback2.callback(), |
| - pool_.get(), BoundNetLog()); |
| + rv = handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST); |
| @@ -1984,12 +1916,9 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - MEDIUM, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, MEDIUM, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); |
| @@ -1997,12 +1926,9 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) { |
| // The first request should now be stalled at the socket group limit. |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - rv = handle2.Init("a", |
| - params_, |
| - HIGHEST, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle2.Init("a", params_, HIGHEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState()); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState()); |
| @@ -2032,35 +1958,26 @@ TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| // Request for socket from another pool. |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - rv = handle2.Init("b", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle2.Init("b", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| // Request another socket from the first pool. Request should stall at the |
| // socket pool limit. |
| ClientSocketHandle handle3; |
| TestCompletionCallback callback3; |
| - rv = handle3.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle3.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| // The third handle should remain stalled as the other sockets in its group |
| @@ -2091,8 +2008,9 @@ TEST_F(ClientSocketPoolBaseTest, Recoverable) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, |
| - handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(), |
| - pool_.get(), BoundNetLog())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_TRUE(handle.is_initialized()); |
| EXPECT_TRUE(handle.socket()); |
| } |
| @@ -2105,12 +2023,9 @@ TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
| EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); |
| EXPECT_TRUE(handle.is_initialized()); |
| @@ -2125,12 +2040,9 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_CONNECTION_FAILED, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_FALSE(handle.is_initialized()); |
| EXPECT_FALSE(handle.socket()); |
| EXPECT_TRUE(handle.is_ssl_error()); |
| @@ -2145,12 +2057,9 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
| EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
| EXPECT_FALSE(handle.is_initialized()); |
| @@ -2173,12 +2082,9 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| ASSERT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
| ASSERT_EQ(OK, callback.WaitForResult()); |
| @@ -2194,12 +2100,9 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) { |
| // Request a new socket. This should reuse the old socket and complete |
| // synchronously. |
| BoundTestNetLog log; |
| - rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - CompletionCallback(), |
| - pool_.get(), |
| - log.bound()); |
| + rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + CompletionCallback(), pool_.get(), log.bound()); |
| ASSERT_EQ(OK, rv); |
| EXPECT_TRUE(handle.is_reused()); |
| TestLoadTimingInfoConnectedReused(handle); |
| @@ -2236,23 +2139,17 @@ TEST_F(ClientSocketPoolBaseTest, MAYBE_DisableCleanupTimerNoReuse) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| ASSERT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - rv = handle2.Init("a", |
| - params_, |
| - LOWEST, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle2.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| ASSERT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); |
| @@ -2281,12 +2178,9 @@ TEST_F(ClientSocketPoolBaseTest, MAYBE_DisableCleanupTimerNoReuse) { |
| // A new socket will be created rather than reusing the idle one. |
| BoundTestNetLog log; |
| TestCompletionCallback callback3; |
| - rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - callback3.callback(), |
| - pool_.get(), |
| - log.bound()); |
| + rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback3.callback(), pool_.get(), log.bound()); |
| ASSERT_EQ(ERR_IO_PENDING, rv); |
| ASSERT_EQ(OK, callback3.WaitForResult()); |
| EXPECT_FALSE(handle.is_reused()); |
| @@ -2314,23 +2208,17 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - rv = handle2.Init("a", |
| - params_, |
| - LOWEST, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle2.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); |
| @@ -2359,12 +2247,9 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) { |
| pool_->CleanupTimedOutIdleSockets(); |
| BoundTestNetLog log; |
| - rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - callback.callback(), |
| - pool_.get(), |
| - log.bound()); |
| + rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), log.bound()); |
| EXPECT_EQ(OK, rv); |
| EXPECT_TRUE(handle.is_reused()); |
| @@ -2388,42 +2273,30 @@ TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - int rv = handle.Init("a", |
| - params_, |
| - LOWEST, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(OK, rv); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - rv = handle2.Init("a", |
| - params_, |
| - LOWEST, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle2.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(OK, rv); |
| ClientSocketHandle handle3; |
| TestCompletionCallback callback3; |
| - rv = handle3.Init("a", |
| - params_, |
| - LOWEST, |
| - callback3.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle3.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback3.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| ClientSocketHandle handle4; |
| TestCompletionCallback callback4; |
| - rv = handle4.Init("a", |
| - params_, |
| - LOWEST, |
| - callback4.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + rv = handle4.Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback4.callback(), pool_.get(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| // Release two disconnected sockets. |
| @@ -2458,37 +2331,29 @@ TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) { |
| TestCompletionCallback callback_b[4]; |
| for (int i = 0; i < 2; ++i) { |
| - EXPECT_EQ(OK, handle_a[i].Init("a", |
| - params_, |
| - LOWEST, |
| - callback_a[i].callback(), |
| - pool_.get(), |
| + EXPECT_EQ(OK, handle_a[i].Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback_a[i].callback(), pool_.get(), |
| BoundNetLog())); |
| - EXPECT_EQ(OK, handle_b[i].Init("b", |
| - params_, |
| - LOWEST, |
| - callback_b[i].callback(), |
| - pool_.get(), |
| + EXPECT_EQ(OK, handle_b[i].Init("b", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback_b[i].callback(), pool_.get(), |
| BoundNetLog())); |
| } |
| // 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, |
| - callback_a[i].callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| - EXPECT_EQ(ERR_IO_PENDING, |
| - handle_b[i].Init("b", |
| - params_, |
| - LOWEST, |
| - callback_b[i].callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ( |
| + ERR_IO_PENDING, |
| + handle_a[i].Init("a", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback_a[i].callback(), pool_.get(), BoundNetLog())); |
| + EXPECT_EQ( |
| + ERR_IO_PENDING, |
| + handle_b[i].Init("b", params_, LOWEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback_b[i].callback(), pool_.get(), BoundNetLog())); |
| } |
| // Release b's socket first. The order is important, because in |
| @@ -2571,10 +2436,10 @@ class TestReleasingSocketRequest : public TestCompletionCallbackBase { |
| if (reset_releasing_handle_) |
| handle_.Reset(); |
| - scoped_refptr<TestSocketParams> con_params( |
| - new TestSocketParams(false /* ignore_limits */)); |
| + scoped_refptr<TestSocketParams> con_params(new TestSocketParams()); |
| EXPECT_EQ(expected_result_, |
| handle2_.Init("a", con_params, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| callback2_.callback(), pool_, BoundNetLog())); |
| } |
| @@ -2602,8 +2467,9 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) { |
| TestConnectJob::kMockPendingAdditionalErrorStateJob); |
| TestReleasingSocketRequest req(pool_.get(), OK, false); |
| EXPECT_EQ(ERR_IO_PENDING, |
| - req.handle()->Init("a", params_, DEFAULT_PRIORITY, req.callback(), |
| - pool_.get(), BoundNetLog())); |
| + req.handle()->Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + req.callback(), pool_.get(), BoundNetLog())); |
| // The next job should complete synchronously |
| connect_job_factory_->set_job_type(TestConnectJob::kMockJob); |
| @@ -2628,12 +2494,10 @@ TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| pool_->FlushWithError(ERR_NETWORK_CHANGED); |
| @@ -2647,12 +2511,10 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); |
| @@ -2661,12 +2523,10 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) { |
| handle.Reset(); |
| base::MessageLoop::current()->RunUntilIdle(); |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); |
| } |
| @@ -2696,12 +2556,9 @@ class ConnectWithinCallback : public TestCompletionCallbackBase { |
| void OnComplete(int result) { |
| SetResult(result); |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle_.Init(group_name_, |
| - params_, |
| - DEFAULT_PRIORITY, |
| - nested_callback_.callback(), |
| - pool_, |
| - BoundNetLog())); |
| + handle_.Init(group_name_, params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + nested_callback_.callback(), pool_, BoundNetLog())); |
| } |
| const std::string group_name_; |
| @@ -2722,12 +2579,10 @@ TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) { |
| ClientSocketHandle handle; |
| ConnectWithinCallback callback("a", params_, pool_.get()); |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // Second job will be started during the first callback, and will |
| // asynchronously complete with OK. |
| @@ -2749,24 +2604,20 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("bar", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // 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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, |
| + handles[i].Init("bar", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| } |
| base::MessageLoop::current()->RunUntilIdle(); |
| @@ -2791,12 +2642,10 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("bar", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_TRUE(pool_->HasGroup("bar")); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar")); |
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar")); |
| @@ -2821,21 +2670,17 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("bar", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle2.Init("bar", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_TRUE(pool_->HasGroup("bar")); |
| EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar")); |
| @@ -2860,12 +2705,9 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| // No idle sockets, no pending jobs. |
| @@ -2876,12 +2718,9 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
| ClientSocketHandle handle2; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // No idle sockets, and one connecting job. |
| EXPECT_EQ(0, pool_->IdleSocketCount()); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| @@ -2918,12 +2757,9 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| // No idle sockets, no pending jobs. |
| @@ -2934,12 +2770,9 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
| ClientSocketHandle handle2; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // No idle sockets, and one connecting job. |
| EXPECT_EQ(0, pool_->IdleSocketCount()); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| @@ -2978,12 +2811,9 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| // No idle sockets, no pending jobs. |
| @@ -2994,12 +2824,9 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); |
| ClientSocketHandle handle2; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // No idle sockets, and one connecting job. |
| EXPECT_EQ(0, pool_->IdleSocketCount()); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| @@ -3041,12 +2868,9 @@ TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| EXPECT_EQ(ERR_IO_PENDING, |
| - handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| // Make the second request synchronously fail. This should make the Group |
| @@ -3057,12 +2881,9 @@ TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) { |
| // 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, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| @@ -3078,29 +2899,23 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| ClientSocketHandle handle3; |
| TestCompletionCallback callback3; |
| - EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback3.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle3.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback3.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback1.WaitForResult()); |
| EXPECT_EQ(OK, callback2.WaitForResult()); |
| @@ -3114,24 +2929,15 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) { |
| handle2.Reset(); |
| handle3.Reset(); |
| - EXPECT_EQ(OK, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| - EXPECT_EQ(OK, handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| - EXPECT_EQ(OK, handle3.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback3.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| + EXPECT_EQ(OK, handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| + EXPECT_EQ(OK, handle3.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback3.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_TRUE(handle1.socket()->WasEverUsed()); |
| EXPECT_TRUE(handle2.socket()->WasEverUsed()); |
| @@ -3151,21 +2957,17 @@ TEST_F(ClientSocketPoolBaseTest, RequestSockets) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); |
| @@ -3187,12 +2989,10 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_TRUE(pool_->HasGroup("a")); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| @@ -3207,12 +3007,10 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) { |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); |
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); |
| @@ -3235,30 +3033,24 @@ TEST_F(ClientSocketPoolBaseTest, |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| ClientSocketHandle handle3; |
| TestCompletionCallback callback3; |
| - EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback3.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle3.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback3.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_TRUE(pool_->HasGroup("a")); |
| EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); |
| @@ -3335,12 +3127,10 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_EQ(OK, callback1.WaitForResult()); |
| handle1.Reset(); |
| @@ -3362,12 +3152,10 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_EQ(OK, callback1.WaitForResult()); |
| ASSERT_TRUE(pool_->HasGroup("a")); |
| @@ -3439,22 +3227,17 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_EQ(OK, callback1.WaitForResult()); |
| ClientSocketHandle handle2; |
| TestCompletionCallback callback2; |
| - int rv = handle2.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog()); |
| + int rv = handle2.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog()); |
| if (rv != OK) { |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| EXPECT_EQ(OK, callback2.WaitForResult()); |
| @@ -3518,12 +3301,10 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) { |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); |
| @@ -3553,12 +3334,9 @@ TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) { |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(OK, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // Make sure the idle socket was used. |
| EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
| @@ -3581,12 +3359,10 @@ 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, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_EQ(OK, callback1.WaitForResult()); |
| handle1.Reset(); |
| @@ -3595,18 +3371,14 @@ 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, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle1.Init("b", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle2.Init("b", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_EQ(OK, callback1.WaitForResult()); |
| ASSERT_EQ(OK, callback2.WaitForResult()); |
| @@ -3688,12 +3460,10 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) { |
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| // 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")); |
| @@ -3727,12 +3497,9 @@ 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, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| ASSERT_TRUE(pool_->HasGroup("a")); |
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
| @@ -3764,16 +3531,16 @@ class MockLayeredPool : public HigherLayeredPool { |
| } |
| int RequestSocket(TestClientSocketPool* pool) { |
| - scoped_refptr<TestSocketParams> params( |
| - new TestSocketParams(false /* ignore_limits */)); |
| + scoped_refptr<TestSocketParams> params(new TestSocketParams()); |
| return handle_.Init(group_name_, params, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| callback_.callback(), pool, BoundNetLog()); |
| } |
| int RequestSocketWithoutLimits(TestClientSocketPool* pool) { |
| - scoped_refptr<TestSocketParams> params( |
| - new TestSocketParams(true /* ignore_limits */)); |
| + scoped_refptr<TestSocketParams> params(new TestSocketParams()); |
| return handle_.Init(group_name_, params, MAXIMUM_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::ENABLED, |
| callback_.callback(), pool, BoundNetLog()); |
| } |
| @@ -3836,12 +3603,10 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) { |
| &MockLayeredPool::ReleaseOneConnection)); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| } |
| @@ -3859,12 +3624,9 @@ 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, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| MockLayeredPool mock_layered_pool(pool_.get(), "group2"); |
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); |
| @@ -3873,12 +3635,10 @@ TEST_F(ClientSocketPoolBaseTest, |
| &MockLayeredPool::ReleaseOneConnection)); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback2; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback2.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("group2", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback2.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback2.WaitForResult()); |
| } |
| @@ -3896,12 +3656,9 @@ TEST_F(ClientSocketPoolBaseTest, |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(OK, handle1.Init("group1", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| MockLayeredPool mock_layered_pool(pool_.get(), "group2"); |
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); |
| @@ -3913,12 +3670,10 @@ 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, |
| - callback3.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle3.Init("group3", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback3.callback(), pool_.get(), BoundNetLog())); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(callback3.have_result()); |
| @@ -3929,12 +3684,10 @@ 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, |
| - callback4.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle4.Init("group3", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback4.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback3.WaitForResult()); |
| EXPECT_FALSE(callback4.have_result()); |
| @@ -3961,12 +3714,9 @@ TEST_F(ClientSocketPoolBaseTest, |
| ClientSocketHandle handle1; |
| TestCompletionCallback callback1; |
| - EXPECT_EQ(OK, handle1.Init("group1", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback1.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback1.callback(), pool_.get(), BoundNetLog())); |
| MockLayeredPool mock_layered_pool(pool_.get(), "group2"); |
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); |
| @@ -3978,12 +3728,10 @@ 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, |
| - callback3.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle3.Init("group3", params_, MEDIUM, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback3.callback(), pool_.get(), BoundNetLog())); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(callback3.have_result()); |
| @@ -3993,12 +3741,10 @@ 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, |
| - callback4.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle4.Init("group3", params_, HIGHEST, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback4.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback4.WaitForResult()); |
| EXPECT_FALSE(callback3.have_result()); |
| @@ -4024,12 +3770,10 @@ TEST_F(ClientSocketPoolBaseTest, |
| &MockLayeredPool::ReleaseOneConnection)); |
| ClientSocketHandle handle; |
| TestCompletionCallback callback; |
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", |
| - params_, |
| - DEFAULT_PRIORITY, |
| - callback.callback(), |
| - pool_.get(), |
| - BoundNetLog())); |
| + EXPECT_EQ(ERR_IO_PENDING, |
| + handle.Init("a", params_, DEFAULT_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED, |
| + callback.callback(), pool_.get(), BoundNetLog())); |
| EXPECT_EQ(OK, callback.WaitForResult()); |
| } |
| @@ -4038,22 +3782,26 @@ TEST_F(ClientSocketPoolBaseTest, |
| // instead of a request with the same priority that was issued earlier, but |
| // that does not have |ignore_limits| set. |
| TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) { |
| - scoped_refptr<TestSocketParams> params_ignore_limits( |
| - new TestSocketParams(true /* ignore_limits */)); |
| CreatePool(1, 1); |
| // Issue a request to reach the socket pool limit. |
| - EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_)); |
| + EXPECT_EQ( |
| + OK, StartRequestWithIgnoreLimits( |
| + "a", MAXIMUM_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED)); |
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY, |
| - params_)); |
| + EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits( |
| + "a", MAXIMUM_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED)); |
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY, |
| - params_ignore_limits)); |
| + // Issue a request that ignores the limits, so a new ConnectJob is |
| + // created. |
| + EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits( |
| + "a", MAXIMUM_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::ENABLED)); |
| ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| EXPECT_EQ(OK, request(2)->WaitForResult()); |
| @@ -4064,22 +3812,26 @@ TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) { |
| // issued for a request with |ignore_limits| set is not cancelled when a request |
| // without |ignore_limits| issued to the same group is cancelled. |
| TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) { |
| - scoped_refptr<TestSocketParams> params_ignore_limits( |
| - new TestSocketParams(true /* ignore_limits */)); |
| CreatePool(1, 1); |
| // Issue a request to reach the socket pool limit. |
| - EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_)); |
| + EXPECT_EQ( |
| + OK, StartRequestWithIgnoreLimits( |
| + "a", MAXIMUM_PRIORITY, ClientSocketPool::IgnoreLimits::DISABLED)); |
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY, |
| - params_)); |
| + EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits( |
| + "a", MAXIMUM_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::DISABLED)); |
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); |
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY, |
| - params_ignore_limits)); |
| + // Issue a request that ignores the limits, so a new ConnectJob is |
| + // created. |
| + EXPECT_EQ(ERR_IO_PENDING, StartRequestWithIgnoreLimits( |
| + "a", MAXIMUM_PRIORITY, |
| + ClientSocketPool::IgnoreLimits::ENABLED)); |
| ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); |
| // Cancel the pending request without ignore_limits set. The ConnectJob |
