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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/socket/client_socket_pool_base_unittest.cc

Issue 51683002: [Net] Assert that URLRequests with LOAD_IGNORE_LIMITS have MAXIMUM_PRIORITY (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Rebase onto 51953002 Created 7 years, 2 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
« content/browser/loader/resource_scheduler.cc ('K') | « net/socket/client_socket_pool_base.cc ('k') | net/url_request/url_fetcher_core.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 bbeca2f3e11df92fe03015e70bcd809a71207a9d..2ede376f7a7756b5923395d6e916726689682255 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -45,7 +45,6 @@ namespace {
const int kDefaultMaxSockets = 4;
const int kDefaultMaxSocketsPerGroup = 2;
-const net::RequestPriority kDefaultPriority = MEDIUM;
// Make sure |handle| sets load times correctly when it has been assigned a
// reused socket.
@@ -98,20 +97,19 @@ void TestLoadTimingInfoNotConnected(const ClientSocketHandle& handle) {
ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
}
+enum LimitsBehavior { IGNORE_LIMITS, RESPECT_LIMITS };
+
class TestSocketParams : public base::RefCounted<TestSocketParams> {
public:
- TestSocketParams() : ignore_limits_(false) {}
+ explicit TestSocketParams(LimitsBehavior behavior) : behavior_(behavior) {}
- void set_ignore_limits(bool ignore_limits) {
- ignore_limits_ = ignore_limits;
- }
- bool ignore_limits() { return ignore_limits_; }
+ bool ignore_limits() { return behavior_ == IGNORE_LIMITS; }
private:
friend class base::RefCounted<TestSocketParams>;
~TestSocketParams() {}
- bool ignore_limits_;
+ LimitsBehavior behavior_;
};
typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
@@ -663,7 +661,7 @@ class TestConnectJobDelegate : public ConnectJob::Delegate {
class ClientSocketPoolBaseTest : public testing::Test {
protected:
ClientSocketPoolBaseTest()
- : params_(new TestSocketParams()),
+ : params_(new TestSocketParams(RESPECT_LIMITS)),
histograms_("ClientSocketPoolTest") {
connect_backup_jobs_enabled_ =
internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled();
@@ -748,7 +746,7 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
TestConnectJobDelegate delegate;
ClientSocketHandle ignored;
TestClientSocketPoolBase::Request request(
- &ignored, CompletionCallback(), kDefaultPriority,
+ &ignored, CompletionCallback(), DEFAULT_PRIORITY,
internal::ClientSocketPoolBaseHelper::NORMAL,
false, params_, BoundNetLog());
scoped_ptr<TestConnectJob> job(
@@ -768,7 +766,7 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
CapturingNetLog log;
TestClientSocketPoolBase::Request request(
- &ignored, CompletionCallback(), kDefaultPriority,
+ &ignored, CompletionCallback(), DEFAULT_PRIORITY,
internal::ClientSocketPoolBaseHelper::NORMAL,
false, params_, BoundNetLog());
// Deleted by TestConnectJobDelegate.
@@ -815,7 +813,7 @@ TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
EXPECT_EQ(OK,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
log.bound()));
@@ -858,7 +856,7 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
EXPECT_EQ(ERR_CONNECTION_FAILED,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
log.bound()));
@@ -885,18 +883,18 @@ TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
// TODO(eroman): Check that the NetLog contains this event.
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("c", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("d", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("d", DEFAULT_PRIORITY));
EXPECT_EQ(static_cast<int>(requests_size()),
client_socket_factory_.allocation_count());
EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", DEFAULT_PRIORITY));
ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
@@ -922,17 +920,17 @@ TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) {
// TODO(eroman): Check that the NetLog contains this event.
// Reach all limits: max total sockets, and max sockets per group.
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
EXPECT_EQ(static_cast<int>(requests_size()),
client_socket_factory_.allocation_count());
EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
// Now create a new group and verify that we don't starve it.
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
@@ -1028,13 +1026,13 @@ TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsGroupLimit) {
TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("c", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
// Create one asynchronous request.
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", DEFAULT_PRIORITY));
// We post all of our delayed tasks with a 2ms delay. I.e. they don't
// actually become pending until 2ms after they have been created. In order
@@ -1045,7 +1043,7 @@ TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
// The next synchronous request should wait for its turn.
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
@@ -1066,17 +1064,17 @@ TEST_F(ClientSocketPoolBaseTest, CorrectlyCountStalledGroups) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
@@ -1098,7 +1096,7 @@ TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1109,7 +1107,7 @@ TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
EXPECT_EQ(ERR_IO_PENDING,
handles[i].Init("b",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1132,7 +1130,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
for (int i = 0; i < kDefaultMaxSockets; ++i) {
EXPECT_EQ(OK, handles[i].Init(base::IntToString(i),
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callbacks[i].callback(),
pool_.get(),
BoundNetLog()));
@@ -1143,7 +1141,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1171,7 +1169,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i),
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1183,7 +1181,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1228,7 +1226,7 @@ TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
EXPECT_EQ(OK, handles[i].Init(base::StringPrintf(
"Take 2: %d", i),
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1241,7 +1239,7 @@ TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
// Now we will hit the socket limit.
EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1269,7 +1267,7 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
TestCompletionCallback callback;
EXPECT_EQ(OK, handle.Init(base::IntToString(i),
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1289,7 +1287,7 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
// close an idle socket though, since we should reuse the idle socket.
EXPECT_EQ(OK, handle.Init("0",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1301,8 +1299,8 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", IDLE));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
@@ -1333,8 +1331,8 @@ TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
@@ -1363,7 +1361,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1379,7 +1377,7 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1390,7 +1388,7 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -1404,8 +1402,8 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
@@ -1478,10 +1476,11 @@ class RequestSocketCallback : public TestCompletionCallbackBase {
}
within_callback_ = true;
TestCompletionCallback next_job_callback;
- scoped_refptr<TestSocketParams> params(new TestSocketParams());
+ scoped_refptr<TestSocketParams> params(
+ new TestSocketParams(RESPECT_LIMITS));
int rv = handle_->Init("a",
params,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
next_job_callback.callback(),
pool_,
BoundNetLog());
@@ -1530,7 +1529,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
TestConnectJob::kMockPendingJob);
int rv = handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog());
@@ -1548,7 +1547,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
&handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
int rv = handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog());
@@ -1564,13 +1563,13 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
// Now, kDefaultMaxSocketsPerGroup requests should be active.
// Let's cancel them.
@@ -1601,7 +1600,7 @@ TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) {
// Queue up all the requests
for (size_t i = 0; i < kNumberOfRequests; ++i)
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
for (size_t i = 0; i < kNumberOfRequests; ++i)
EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult());
@@ -1616,7 +1615,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
TestCompletionCallback callback;
int rv = handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog());
@@ -1627,7 +1626,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
rv = handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog());
@@ -1647,14 +1646,14 @@ TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
const RequestPriority kHighPriority = HIGHEST;
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
// This is going to be a pending request in an otherwise empty group.
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
// Reach the maximum socket limit.
- EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
// Create a stalled group with high priorities.
EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority));
@@ -1732,7 +1731,7 @@ TEST_F(ClientSocketPoolBaseTest,
handle.set_ssl_error_response_info(info);
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
log.bound()));
@@ -1768,7 +1767,7 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -1776,7 +1775,7 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -1828,7 +1827,7 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
TestSocketRequest req1(&request_order, &completion_count);
int rv = req1.handle()->Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
req1.callback(), pool_.get(),
BoundNetLog());
EXPECT_EQ(ERR_IO_PENDING, rv);
@@ -1841,7 +1840,7 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
TestSocketRequest req2(&request_order, &completion_count);
rv = req2.handle()->Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
req2.callback(),
pool_.get(),
BoundNetLog());
@@ -1849,7 +1848,7 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
TestSocketRequest req3(&request_order, &completion_count);
rv = req3.handle()->Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
req3.callback(),
pool_.get(),
BoundNetLog());
@@ -1888,7 +1887,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
TestSocketRequest req1(&request_order, &completion_count);
int rv = req1.handle()->Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
req1.callback(),
pool_.get(),
BoundNetLog());
@@ -1897,7 +1896,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
TestSocketRequest req2(&request_order, &completion_count);
rv = req2.handle()->Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
req2.callback(),
pool_.get(),
BoundNetLog());
@@ -1909,7 +1908,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
TestSocketRequest req3(&request_order, &completion_count);
rv = req3.handle()->Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
req3.callback(),
pool_.get(),
BoundNetLog());
@@ -1934,7 +1933,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) {
TestCompletionCallback callback;
int rv = handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog());
@@ -1957,7 +1956,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
TestCompletionCallback callback;
int rv = handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog());
@@ -1967,7 +1966,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
TestCompletionCallback callback2;
rv = handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog());
@@ -2050,7 +2049,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
TestCompletionCallback callback;
int rv = handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog());
@@ -2061,7 +2060,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
TestCompletionCallback callback2;
rv = handle2.Init("b",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog());
@@ -2073,7 +2072,7 @@ TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
TestCompletionCallback callback3;
rv = handle3.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog());
@@ -2107,7 +2106,7 @@ TEST_F(ClientSocketPoolBaseTest, Recoverable) {
ClientSocketHandle handle;
TestCompletionCallback callback;
EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED,
- handle.Init("a", params_, kDefaultPriority, callback.callback(),
+ handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(),
pool_.get(), BoundNetLog()));
EXPECT_TRUE(handle.is_initialized());
EXPECT_TRUE(handle.socket());
@@ -2123,7 +2122,7 @@ TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2143,7 +2142,7 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
EXPECT_EQ(ERR_CONNECTION_FAILED,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2163,7 +2162,7 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
EXPECT_EQ(ERR_IO_PENDING,
handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2531,10 +2530,10 @@ TEST_F(ClientSocketPoolBaseTest,
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
EXPECT_EQ(OK, (*requests())[1]->WaitForResult());
@@ -2581,9 +2580,10 @@ class TestReleasingSocketRequest : public TestCompletionCallbackBase {
if (reset_releasing_handle_)
handle_.Reset();
- scoped_refptr<TestSocketParams> con_params(new TestSocketParams());
+ scoped_refptr<TestSocketParams> con_params(
+ new TestSocketParams(RESPECT_LIMITS));
EXPECT_EQ(expected_result_,
- handle2_.Init("a", con_params, kDefaultPriority,
+ handle2_.Init("a", con_params, DEFAULT_PRIORITY,
callback2_.callback(), pool_, BoundNetLog()));
}
@@ -2600,9 +2600,9 @@ class TestReleasingSocketRequest : public TestCompletionCallbackBase {
TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
- EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
- EXPECT_EQ(OK, StartRequest("b", kDefaultPriority));
+ EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
+ EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
EXPECT_EQ(static_cast<int>(requests_size()),
client_socket_factory_.allocation_count());
@@ -2611,7 +2611,7 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
TestConnectJob::kMockPendingAdditionalErrorStateJob);
TestReleasingSocketRequest req(pool_.get(), OK, false);
EXPECT_EQ(ERR_IO_PENDING,
- req.handle()->Init("a", params_, kDefaultPriority, req.callback(),
+ req.handle()->Init("a", params_, DEFAULT_PRIORITY, req.callback(),
pool_.get(), BoundNetLog()));
// The next job should complete synchronously
connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
@@ -2639,7 +2639,7 @@ TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2658,7 +2658,7 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2672,7 +2672,7 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2707,7 +2707,7 @@ class ConnectWithinCallback : public TestCompletionCallbackBase {
EXPECT_EQ(ERR_IO_PENDING,
handle_.Init(group_name_,
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
nested_callback_.callback(),
pool_,
BoundNetLog()));
@@ -2733,7 +2733,7 @@ TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
ConnectWithinCallback callback("a", params_, pool_.get());
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2760,7 +2760,7 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2772,7 +2772,7 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
TestCompletionCallback callback;
EXPECT_EQ(OK, handles[i].Init("bar",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2802,7 +2802,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2832,7 +2832,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2841,7 +2841,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -2871,7 +2871,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
EXPECT_EQ(ERR_IO_PENDING,
handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2887,7 +2887,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2929,7 +2929,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
EXPECT_EQ(ERR_IO_PENDING,
handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2945,7 +2945,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -2989,7 +2989,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
EXPECT_EQ(ERR_IO_PENDING,
handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -3005,7 +3005,7 @@ TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -3052,7 +3052,7 @@ TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
EXPECT_EQ(ERR_IO_PENDING,
handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3068,7 +3068,7 @@ TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
EXPECT_EQ(ERR_IO_PENDING,
handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -3089,7 +3089,7 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3098,7 +3098,7 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -3106,7 +3106,7 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
TestCompletionCallback callback3;
EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback3.callback(),
pool_.get(),
BoundNetLog()));
@@ -3125,19 +3125,19 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
EXPECT_EQ(OK, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
EXPECT_EQ(OK, handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
EXPECT_EQ(OK, handle3.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback3.callback(),
pool_.get(),
BoundNetLog()));
@@ -3162,7 +3162,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3171,7 +3171,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -3198,7 +3198,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3218,7 +3218,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -3246,7 +3246,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3255,7 +3255,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -3264,7 +3264,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback3;
EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback3.callback(),
pool_.get(),
BoundNetLog()));
@@ -3346,7 +3346,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3373,7 +3373,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3450,7 +3450,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3460,7 +3460,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
TestCompletionCallback callback2;
int rv = handle2.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog());
@@ -3529,7 +3529,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3564,7 +3564,7 @@ TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
TestCompletionCallback callback;
EXPECT_EQ(OK, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -3592,7 +3592,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
TestCompletionCallback callback1;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3606,13 +3606,13 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -3700,7 +3700,7 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -3724,7 +3724,6 @@ class MockLayeredPool : public HigherLayeredPool {
MockLayeredPool(TestClientSocketPool* pool,
const std::string& group_name)
: pool_(pool),
- params_(new TestSocketParams),
group_name_(group_name),
can_release_connection_(true) {
pool_->AddHigherLayeredPool(this);
@@ -3735,13 +3734,16 @@ class MockLayeredPool : public HigherLayeredPool {
}
int RequestSocket(TestClientSocketPool* pool) {
- return handle_.Init(group_name_, params_, kDefaultPriority,
+ scoped_refptr<TestSocketParams> params(
+ new TestSocketParams(RESPECT_LIMITS));
+ return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
callback_.callback(), pool, BoundNetLog());
}
int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
- params_->set_ignore_limits(true);
- return handle_.Init(group_name_, params_, kDefaultPriority,
+ scoped_refptr<TestSocketParams> params(
+ new TestSocketParams(IGNORE_LIMITS));
+ return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
callback_.callback(), pool, BoundNetLog());
}
@@ -3762,7 +3764,6 @@ class MockLayeredPool : public HigherLayeredPool {
private:
TestClientSocketPool* const pool_;
- scoped_refptr<TestSocketParams> params_;
ClientSocketHandle handle_;
TestCompletionCallback callback_;
const std::string group_name_;
@@ -3807,7 +3808,7 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -3830,7 +3831,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback1;
EXPECT_EQ(OK, handle1.Init("group1",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3844,7 +3845,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback2;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback2.callback(),
pool_.get(),
BoundNetLog()));
@@ -3867,7 +3868,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback1;
EXPECT_EQ(OK, handle1.Init("group1",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3884,7 +3885,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback3;
EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback3.callback(),
pool_.get(),
BoundNetLog()));
@@ -3900,7 +3901,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback4;
EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback4.callback(),
pool_.get(),
BoundNetLog()));
@@ -3932,7 +3933,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback1;
EXPECT_EQ(OK, handle1.Init("group1",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback1.callback(),
pool_.get(),
BoundNetLog()));
@@ -3995,7 +3996,7 @@ TEST_F(ClientSocketPoolBaseTest,
TestCompletionCallback callback;
EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
params_,
- kDefaultPriority,
+ DEFAULT_PRIORITY,
callback.callback(),
pool_.get(),
BoundNetLog()));
@@ -4007,21 +4008,21 @@ 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());
- params_ignore_limits->set_ignore_limits(true);
+ scoped_refptr<TestSocketParams> params_ignore_limits(
+ new TestSocketParams(IGNORE_LIMITS));
CreatePool(1, 1);
// Issue a request to reach the socket pool limit.
- EXPECT_EQ(OK, StartRequestWithParams("a", kDefaultPriority, params_));
+ EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", kDefaultPriority,
+ EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
params_));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", kDefaultPriority,
+ EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
params_ignore_limits));
ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -4029,76 +4030,25 @@ TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) {
EXPECT_FALSE(request(1)->have_result());
}
-// Test that when a socket pool and group are at their limits, a request with
-// |ignore_limits| set triggers creation of a new socket, and gets the socket
-// instead of a request with a higher priority that was issued earlier, but
-// that does not have |ignore_limits| set.
-TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsLowPriority) {
- scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams());
- params_ignore_limits->set_ignore_limits(true);
- CreatePool(1, 1);
-
- // Issue a request to reach the socket pool limit.
- EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_));
- EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
-
- connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
- EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
-
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", LOW,
- params_ignore_limits));
- ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
-
- EXPECT_EQ(OK, request(2)->WaitForResult());
- EXPECT_FALSE(request(1)->have_result());
-}
-
-// Test that when a socket pool and group are at their limits, a request with
-// |ignore_limits| set triggers creation of a new socket, and gets the socket
-// instead of a request with a higher priority that was issued later and
-// does not have |ignore_limits| set.
-TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsLowPriority2) {
- scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams());
- params_ignore_limits->set_ignore_limits(true);
- CreatePool(1, 1);
-
- // Issue a request to reach the socket pool limit.
- EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_));
- EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
-
- connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", LOW,
- params_ignore_limits));
- ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
-
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
- EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
-
- EXPECT_EQ(OK, request(1)->WaitForResult());
- EXPECT_FALSE(request(2)->have_result());
-}
-
// Test that when a socket pool and group are at their limits, a ConnectJob
// 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());
- params_ignore_limits->set_ignore_limits(true);
+ scoped_refptr<TestSocketParams> params_ignore_limits(
+ new TestSocketParams(IGNORE_LIMITS));
CreatePool(1, 1);
// Issue a request to reach the socket pool limit.
- EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_));
+ EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
+ EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
+ params_));
EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST,
+ EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
params_ignore_limits));
ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
@@ -4111,58 +4061,6 @@ TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) {
EXPECT_FALSE(request(1)->have_result());
}
-// More involved test of ignore limits. Issues a bunch of requests and later
-// checks the order in which they receive sockets.
-TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsOrder) {
- scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams());
- params_ignore_limits->set_ignore_limits(true);
- CreatePool(1, 1);
-
- connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
-
- // Requests 0 and 1 do not have ignore_limits set, so they finish last. Since
- // the maximum number of sockets per pool is 1, the second requests does not
- // trigger a ConnectJob.
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
- EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_));
-
- // Requests 2 and 3 have ignore_limits set, but have a low priority, so they
- // finish just before the first two.
- EXPECT_EQ(ERR_IO_PENDING,
- StartRequestWithParams("a", LOW, params_ignore_limits));
- EXPECT_EQ(ERR_IO_PENDING,
- StartRequestWithParams("a", LOW, params_ignore_limits));
-
- // Request 4 finishes first, since it is high priority and ignores limits.
- EXPECT_EQ(ERR_IO_PENDING,
- StartRequestWithParams("a", HIGHEST, params_ignore_limits));
-
- // Request 5 and 6 are cancelled right after starting. This should result in
- // creating two ConnectJobs. Since only one request (Request 1) did not
- // result in creating a ConnectJob, only one of the ConnectJobs should be
- // cancelled when the requests are.
- EXPECT_EQ(ERR_IO_PENDING,
- StartRequestWithParams("a", HIGHEST, params_ignore_limits));
- EXPECT_EQ(ERR_IO_PENDING,
- StartRequestWithParams("a", HIGHEST, params_ignore_limits));
- EXPECT_EQ(6, pool_->NumConnectJobsInGroup("a"));
- request(5)->handle()->Reset();
- EXPECT_EQ(6, pool_->NumConnectJobsInGroup("a"));
- request(6)->handle()->Reset();
- ASSERT_EQ(5, pool_->NumConnectJobsInGroup("a"));
-
- // Wait for the last request to get a socket.
- EXPECT_EQ(OK, request(1)->WaitForResult());
-
- // Check order in which requests received sockets.
- // These are 1-based indices, while request(x) uses 0-based indices.
- EXPECT_EQ(1, GetOrderOfRequest(5));
- EXPECT_EQ(2, GetOrderOfRequest(3));
- EXPECT_EQ(3, GetOrderOfRequest(4));
- EXPECT_EQ(4, GetOrderOfRequest(1));
- EXPECT_EQ(5, GetOrderOfRequest(2));
-}
-
} // namespace
} // namespace net
« content/browser/loader/resource_scheduler.cc ('K') | « net/socket/client_socket_pool_base.cc ('k') | net/url_request/url_fetcher_core.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698