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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/socket/client_socket_pool_base_unittest.cc

Issue 1580903002: Convert ignore_limits from a SocketParam to a socket request argument. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: merge Created 4 years, 11 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
« net/http/http_proxy_client_socket_pool.h ('K') | « net/socket/client_socket_pool_base.cc ('k') | net/socket/client_socket_pool_manager.cc » ('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 a467f49e6013cec34ab9781c034cd6884ac83d3b..e86b8faa832b827d7fa4c53ccc487ad002115a66 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,
+ bool 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,15 @@ class ClientSocketPoolBaseTest : public testing::Test {
connect_job_factory_));
}
- int StartRequestWithParams(
- const std::string& group_name,
- RequestPriority priority,
- const scoped_refptr<TestSocketParams>& params) {
- return test_base_.StartRequestUsingPool(
- pool_.get(), group_name, priority, params);
+ int StartRequestWithIgnoreLimits(const std::string& group_name,
+ RequestPriority priority,
+ bool 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, false);
}
int GetOrderOfRequest(size_t index) const {
@@ -812,13 +809,8 @@ 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, false,
+ callback.callback(), pool_.get(), log.bound()));
EXPECT_TRUE(handle.is_initialized());
EXPECT_TRUE(handle.socket());
TestLoadTimingInfoConnectedNotReused(handle);
@@ -856,12 +848,8 @@ 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, false,
+ 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 +1084,15 @@ 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, false,
+ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
}
// One will be stalled, cancel all the handles now.
@@ -1130,23 +1110,18 @@ 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, false,
+ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
// Cancel the stalled request.
stalled_handle.Reset();
@@ -1169,24 +1144,20 @@ 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,
+ false, 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
// Since it is stalled, it should have no connect jobs.
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
@@ -1225,13 +1196,10 @@ 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, false, callback.callback(),
+ pool_.get(), BoundNetLog()));
}
EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
@@ -1239,12 +1207,10 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_TRUE(pool_->IsStalled());
// Dropping out of scope will close all handles and return them to idle.
@@ -1267,12 +1233,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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
}
// Flush all the DoReleaseSocket tasks.
@@ -1287,12 +1250,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
@@ -1361,12 +1320,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
handle.Reset();
}
@@ -1377,23 +1333,16 @@ 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, false,
+ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback2.WaitForResult());
EXPECT_FALSE(callback.have_result());
@@ -1457,11 +1406,10 @@ 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, false, nested_callback, pool,
+ BoundNetLog());
if (rv != ERR_IO_PENDING) {
DCHECK_EQ(TestConnectJob::kMockJob, next_job_type);
nested_callback.Run(rv);
@@ -1480,7 +1428,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
ClientSocketHandle handle;
TestCompletionCallback second_result_callback;
int rv = handle.Init(
- "a", params_, DEFAULT_PRIORITY,
+ "a", params_, DEFAULT_PRIORITY, false,
base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
connect_job_factory_, TestConnectJob::kMockPendingJob,
second_result_callback.callback()),
@@ -1500,7 +1448,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
ClientSocketHandle handle;
TestCompletionCallback second_result_callback;
int rv = handle.Init(
- "a", params_, DEFAULT_PRIORITY,
+ "a", params_, DEFAULT_PRIORITY, false,
base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
connect_job_factory_, TestConnectJob::kMockPendingJob,
second_result_callback.callback()),
@@ -1567,23 +1515,15 @@ 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, false,
+ 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, false, callback.callback(),
+ pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(OK, callback.WaitForResult());
@@ -1636,12 +1576,8 @@ 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, false, 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 +1619,9 @@ 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, false,
+ 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 +1668,12 @@ 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, false,
+ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
handle.Reset();
@@ -1795,11 +1720,8 @@ 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, false,
+ req1.callback(), pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(OK, req1.WaitForResult());
@@ -1808,20 +1730,12 @@ 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, false,
+ 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, false,
+ 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 +1769,21 @@ 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, false,
+ 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, false,
+ 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, false,
+ req3.callback(), pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
@@ -1901,12 +1803,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
@@ -1925,14 +1823,14 @@ 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, false,
+ 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(),
+ rv = handle2.Init("a", params_, DEFAULT_PRIORITY, false, callback2.callback(),
pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
@@ -1956,13 +1854,13 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
ClientSocketHandle handle2;
TestCompletionCallback callback2;
- rv = handle2.Init("a", params_, DEFAULT_PRIORITY, callback2.callback(),
+ rv = handle2.Init("a", params_, DEFAULT_PRIORITY, false, callback2.callback(),
pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
@@ -1984,12 +1882,8 @@ 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, false, callback.callback(),
+ pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
@@ -1997,12 +1891,8 @@ 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, false, 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 +1922,23 @@ 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, false,
+ 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, false, 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, false, 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 +1969,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_TRUE(handle.is_initialized());
EXPECT_TRUE(handle.socket());
}
@@ -2105,12 +1983,8 @@ 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, false,
+ 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 +1999,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_FALSE(handle.is_initialized());
EXPECT_FALSE(handle.socket());
EXPECT_TRUE(handle.is_ssl_error());
@@ -2145,12 +2015,8 @@ 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, false,
+ 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 +2039,8 @@ 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, false, 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 +2056,8 @@ 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, false, CompletionCallback(),
+ pool_.get(), log.bound());
ASSERT_EQ(OK, rv);
EXPECT_TRUE(handle.is_reused());
TestLoadTimingInfoConnectedReused(handle);
@@ -2236,23 +2094,15 @@ 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, false, 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, false, callback2.callback(),
+ pool_.get(), BoundNetLog());
ASSERT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
@@ -2281,12 +2131,8 @@ 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, false, callback3.callback(),
+ pool_.get(), log.bound());
ASSERT_EQ(ERR_IO_PENDING, rv);
ASSERT_EQ(OK, callback3.WaitForResult());
EXPECT_FALSE(handle.is_reused());
@@ -2314,23 +2160,15 @@ 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, false, 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, false, callback2.callback(),
+ pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
@@ -2359,12 +2197,8 @@ 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, false, callback.callback(),
+ pool_.get(), log.bound());
EXPECT_EQ(OK, rv);
EXPECT_TRUE(handle.is_reused());
@@ -2388,42 +2222,26 @@ 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, false, 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, false, 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, false, 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, false, callback4.callback(),
+ pool_.get(), BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
// Release two disconnected sockets.
@@ -2458,37 +2276,23 @@ 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, false,
+ 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, false,
+ 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, false,
+ callback_a[i].callback(),
+ pool_.get(), BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING, handle_b[i].Init("b", params_, LOWEST, false,
+ callback_b[i].callback(),
+ pool_.get(), BoundNetLog()));
}
// Release b's socket first. The order is important, because in
@@ -2571,10 +2375,9 @@ 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,
+ handle2_.Init("a", con_params, DEFAULT_PRIORITY, false,
callback2_.callback(), pool_, BoundNetLog()));
}
@@ -2602,8 +2405,8 @@ 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, false,
+ req.callback(), pool_.get(), BoundNetLog()));
// The next job should complete synchronously
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
@@ -2628,12 +2431,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
pool_->FlushWithError(ERR_NETWORK_CHANGED);
@@ -2647,12 +2447,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback.WaitForResult());
EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
@@ -2661,12 +2458,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback.WaitForResult());
EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
}
@@ -2696,12 +2490,8 @@ 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, false,
+ nested_callback_.callback(), pool_, BoundNetLog()));
}
const std::string group_name_;
@@ -2722,12 +2512,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
// Second job will be started during the first callback, and will
// asynchronously complete with OK.
@@ -2749,24 +2536,18 @@ 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, false,
+ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
}
base::MessageLoop::current()->RunUntilIdle();
@@ -2791,12 +2572,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
ASSERT_TRUE(pool_->HasGroup("bar"));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar"));
@@ -2821,21 +2599,15 @@ 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, false,
+ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
ASSERT_TRUE(pool_->HasGroup("bar"));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
@@ -2860,12 +2632,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback.WaitForResult());
// No idle sockets, no pending jobs.
@@ -2876,12 +2644,8 @@ 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, false,
+ 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 +2682,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback.WaitForResult());
// No idle sockets, no pending jobs.
@@ -2934,12 +2694,8 @@ 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, false,
+ 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 +2734,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback.WaitForResult());
// No idle sockets, no pending jobs.
@@ -2994,12 +2746,8 @@ 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, false,
+ 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 +2789,8 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
// Make the second request synchronously fail. This should make the Group
@@ -3057,12 +2801,8 @@ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -3078,29 +2818,20 @@ 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, false,
+ 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, false,
+ 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, false,
+ callback3.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback1.WaitForResult());
EXPECT_EQ(OK, callback2.WaitForResult());
@@ -3114,24 +2845,12 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK, handle2.Init("a", params_, DEFAULT_PRIORITY, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(OK, handle3.Init("a", params_, DEFAULT_PRIORITY, false,
+ callback3.callback(), pool_.get(), BoundNetLog()));
EXPECT_TRUE(handle1.socket()->WasEverUsed());
EXPECT_TRUE(handle2.socket()->WasEverUsed());
@@ -3151,21 +2870,15 @@ 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, false,
+ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3187,12 +2900,9 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -3207,12 +2917,9 @@ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3235,30 +2942,21 @@ 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, false,
+ 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, false,
+ 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, false,
+ callback3.callback(), pool_.get(), BoundNetLog()));
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
@@ -3335,12 +3033,9 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
ASSERT_EQ(OK, callback1.WaitForResult());
handle1.Reset();
@@ -3362,12 +3057,9 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
ASSERT_EQ(OK, callback1.WaitForResult());
ASSERT_TRUE(pool_->HasGroup("a"));
@@ -3439,22 +3131,15 @@ 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, false,
+ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog());
if (rv != OK) {
EXPECT_EQ(ERR_IO_PENDING, rv);
EXPECT_EQ(OK, callback2.WaitForResult());
@@ -3518,12 +3203,9 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
@@ -3553,12 +3235,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
// Make sure the idle socket was used.
EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
@@ -3581,12 +3259,9 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
ASSERT_EQ(OK, callback1.WaitForResult());
handle1.Reset();
@@ -3595,18 +3270,12 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
+ EXPECT_EQ(ERR_IO_PENDING,
+ handle2.Init("b", params_, DEFAULT_PRIORITY, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
ASSERT_EQ(OK, callback1.WaitForResult());
ASSERT_EQ(OK, callback2.WaitForResult());
@@ -3688,12 +3357,9 @@ 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, false,
+ 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 +3393,8 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
ASSERT_TRUE(pool_->HasGroup("a"));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
@@ -3764,17 +3426,16 @@ class MockLayeredPool : public HigherLayeredPool {
}
int RequestSocket(TestClientSocketPool* pool) {
- scoped_refptr<TestSocketParams> params(
- new TestSocketParams(false /* ignore_limits */));
- return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
+ scoped_refptr<TestSocketParams> params(new TestSocketParams());
+ return handle_.Init(group_name_, params, DEFAULT_PRIORITY, false,
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,
- callback_.callback(), pool, BoundNetLog());
+ true /* ignore_limits */, callback_.callback(), pool,
+ BoundNetLog());
}
bool ReleaseOneConnection() {
@@ -3836,12 +3497,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback.WaitForResult());
}
@@ -3859,12 +3517,8 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
MockLayeredPool mock_layered_pool(pool_.get(), "group2");
EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
@@ -3873,12 +3527,9 @@ 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, false,
+ callback2.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback2.WaitForResult());
}
@@ -3896,12 +3547,8 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
MockLayeredPool mock_layered_pool(pool_.get(), "group2");
EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
@@ -3913,12 +3560,9 @@ 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, false,
+ callback3.callback(), pool_.get(), BoundNetLog()));
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(callback3.have_result());
@@ -3929,12 +3573,9 @@ 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, false,
+ callback4.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback3.WaitForResult());
EXPECT_FALSE(callback4.have_result());
@@ -3961,12 +3602,8 @@ 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, false,
+ callback1.callback(), pool_.get(), BoundNetLog()));
MockLayeredPool mock_layered_pool(pool_.get(), "group2");
EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
@@ -3978,12 +3615,9 @@ 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, false, callback3.callback(),
+ pool_.get(), BoundNetLog()));
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(callback3.have_result());
@@ -3993,12 +3627,9 @@ 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, false,
+ callback4.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback4.WaitForResult());
EXPECT_FALSE(callback3.have_result());
@@ -4024,12 +3655,9 @@ 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, false,
+ callback.callback(), pool_.get(), BoundNetLog()));
EXPECT_EQ(OK, callback.WaitForResult());
}
@@ -4038,22 +3666,25 @@ 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,
+ false /* ignore_limits */));
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,
+ false /* ignore_limits */));
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,
+ true /* ignore_limits */));
ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
EXPECT_EQ(OK, request(2)->WaitForResult());
@@ -4064,22 +3695,25 @@ 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,
+ false /* ignore_limits */));
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,
+ false /* ignore_limits */));
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,
+ true /* ignore_limits */));
ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
// Cancel the pending request without ignore_limits set. The ConnectJob
« net/http/http_proxy_client_socket_pool.h ('K') | « net/socket/client_socket_pool_base.cc ('k') | net/socket/client_socket_pool_manager.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698