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

Side by Side Diff: net/socket/client_socket_pool_base_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 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 unified diff | Download patch
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/socket/client_socket_pool_base.h" 5 #include "net/socket/client_socket_pool_base.h"
6 6
7 #include <stdint.h> 7 #include <stdint.h>
8 #include <utility> 8 #include <utility>
9 #include <vector> 9 #include <vector>
10 10
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after
120 friend class base::RefCounted<TestSocketParams>; 120 friend class base::RefCounted<TestSocketParams>;
121 ~TestSocketParams() {} 121 ~TestSocketParams() {}
122 }; 122 };
123 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase; 123 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
124 124
125 class MockClientSocket : public StreamSocket { 125 class MockClientSocket : public StreamSocket {
126 public: 126 public:
127 explicit MockClientSocket(net::NetLog* net_log) 127 explicit MockClientSocket(net::NetLog* net_log)
128 : connected_(false), 128 : connected_(false),
129 has_unread_data_(false), 129 has_unread_data_(false),
130 net_log_(BoundNetLog::Make(net_log, NetLogSourceType::SOCKET)), 130 net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::SOCKET)),
131 was_used_to_convey_data_(false) {} 131 was_used_to_convey_data_(false) {}
132 132
133 // Sets whether the socket has unread data. If true, the next call to Read() 133 // Sets whether the socket has unread data. If true, the next call to Read()
134 // will return 1 byte and IsConnectedAndIdle() will return false. 134 // will return 1 byte and IsConnectedAndIdle() will return false.
135 void set_has_unread_data(bool has_unread_data) { 135 void set_has_unread_data(bool has_unread_data) {
136 has_unread_data_ = has_unread_data; 136 has_unread_data_ = has_unread_data;
137 } 137 }
138 138
139 // Socket implementation. 139 // Socket implementation.
140 int Read(IOBuffer* /* buf */, 140 int Read(IOBuffer* /* buf */,
(...skipping 29 matching lines...) Expand all
170 } 170 }
171 171
172 int GetPeerAddress(IPEndPoint* /* address */) const override { 172 int GetPeerAddress(IPEndPoint* /* address */) const override {
173 return ERR_UNEXPECTED; 173 return ERR_UNEXPECTED;
174 } 174 }
175 175
176 int GetLocalAddress(IPEndPoint* /* address */) const override { 176 int GetLocalAddress(IPEndPoint* /* address */) const override {
177 return ERR_UNEXPECTED; 177 return ERR_UNEXPECTED;
178 } 178 }
179 179
180 const BoundNetLog& NetLog() const override { return net_log_; } 180 const NetLogWithSource& NetLog() const override { return net_log_; }
181 181
182 void SetSubresourceSpeculation() override {} 182 void SetSubresourceSpeculation() override {}
183 void SetOmniboxSpeculation() override {} 183 void SetOmniboxSpeculation() override {}
184 bool WasEverUsed() const override { return was_used_to_convey_data_; } 184 bool WasEverUsed() const override { return was_used_to_convey_data_; }
185 bool WasNpnNegotiated() const override { return false; } 185 bool WasNpnNegotiated() const override { return false; }
186 NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; } 186 NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
187 bool GetSSLInfo(SSLInfo* ssl_info) override { return false; } 187 bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
188 void GetConnectionAttempts(ConnectionAttempts* out) const override { 188 void GetConnectionAttempts(ConnectionAttempts* out) const override {
189 out->clear(); 189 out->clear();
190 } 190 }
191 void ClearConnectionAttempts() override {} 191 void ClearConnectionAttempts() override {}
192 void AddConnectionAttempts(const ConnectionAttempts& attempts) override {} 192 void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
193 int64_t GetTotalReceivedBytes() const override { 193 int64_t GetTotalReceivedBytes() const override {
194 NOTIMPLEMENTED(); 194 NOTIMPLEMENTED();
195 return 0; 195 return 0;
196 } 196 }
197 197
198 private: 198 private:
199 bool connected_; 199 bool connected_;
200 bool has_unread_data_; 200 bool has_unread_data_;
201 BoundNetLog net_log_; 201 NetLogWithSource net_log_;
202 bool was_used_to_convey_data_; 202 bool was_used_to_convey_data_;
203 203
204 DISALLOW_COPY_AND_ASSIGN(MockClientSocket); 204 DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
205 }; 205 };
206 206
207 class TestConnectJob; 207 class TestConnectJob;
208 208
209 class MockClientSocketFactory : public ClientSocketFactory { 209 class MockClientSocketFactory : public ClientSocketFactory {
210 public: 210 public:
211 MockClientSocketFactory() : allocation_count_(0) {} 211 MockClientSocketFactory() : allocation_count_(0) {}
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after
274 // to complete. 274 // to complete.
275 static const int kPendingConnectDelay = 2; 275 static const int kPendingConnectDelay = 2;
276 276
277 TestConnectJob(JobType job_type, 277 TestConnectJob(JobType job_type,
278 const std::string& group_name, 278 const std::string& group_name,
279 const TestClientSocketPoolBase::Request& request, 279 const TestClientSocketPoolBase::Request& request,
280 base::TimeDelta timeout_duration, 280 base::TimeDelta timeout_duration,
281 ConnectJob::Delegate* delegate, 281 ConnectJob::Delegate* delegate,
282 MockClientSocketFactory* client_socket_factory, 282 MockClientSocketFactory* client_socket_factory,
283 NetLog* net_log) 283 NetLog* net_log)
284 : ConnectJob(group_name, 284 : ConnectJob(
285 timeout_duration, 285 group_name,
286 request.priority(), 286 timeout_duration,
287 request.respect_limits(), 287 request.priority(),
288 delegate, 288 request.respect_limits(),
289 BoundNetLog::Make(net_log, NetLogSourceType::CONNECT_JOB)), 289 delegate,
290 NetLogWithSource::Make(net_log, NetLogSourceType::CONNECT_JOB)),
290 job_type_(job_type), 291 job_type_(job_type),
291 client_socket_factory_(client_socket_factory), 292 client_socket_factory_(client_socket_factory),
292 load_state_(LOAD_STATE_IDLE), 293 load_state_(LOAD_STATE_IDLE),
293 store_additional_error_state_(false), 294 store_additional_error_state_(false),
294 weak_factory_(this) {} 295 weak_factory_(this) {}
295 296
296 void Signal() { 297 void Signal() {
297 DoConnect(waiting_success_, true /* async */, false /* recoverable */); 298 DoConnect(waiting_success_, true /* async */, false /* recoverable */);
298 } 299 }
299 300
(...skipping 203 matching lines...) Expand 10 before | Expand all | Expand 10 after
503 connect_job_factory) {} 504 connect_job_factory) {}
504 505
505 ~TestClientSocketPool() override {} 506 ~TestClientSocketPool() override {}
506 507
507 int RequestSocket(const std::string& group_name, 508 int RequestSocket(const std::string& group_name,
508 const void* params, 509 const void* params,
509 RequestPriority priority, 510 RequestPriority priority,
510 RespectLimits respect_limits, 511 RespectLimits respect_limits,
511 ClientSocketHandle* handle, 512 ClientSocketHandle* handle,
512 const CompletionCallback& callback, 513 const CompletionCallback& callback,
513 const BoundNetLog& net_log) override { 514 const NetLogWithSource& net_log) override {
514 const scoped_refptr<TestSocketParams>* casted_socket_params = 515 const scoped_refptr<TestSocketParams>* casted_socket_params =
515 static_cast<const scoped_refptr<TestSocketParams>*>(params); 516 static_cast<const scoped_refptr<TestSocketParams>*>(params);
516 return base_.RequestSocket(group_name, *casted_socket_params, priority, 517 return base_.RequestSocket(group_name, *casted_socket_params, priority,
517 respect_limits, handle, callback, net_log); 518 respect_limits, handle, callback, net_log);
518 } 519 }
519 520
520 void RequestSockets(const std::string& group_name, 521 void RequestSockets(const std::string& group_name,
521 const void* params, 522 const void* params,
522 int num_sockets, 523 int num_sockets,
523 const BoundNetLog& net_log) override { 524 const NetLogWithSource& net_log) override {
524 const scoped_refptr<TestSocketParams>* casted_params = 525 const scoped_refptr<TestSocketParams>* casted_params =
525 static_cast<const scoped_refptr<TestSocketParams>*>(params); 526 static_cast<const scoped_refptr<TestSocketParams>*>(params);
526 527
527 base_.RequestSockets(group_name, *casted_params, num_sockets, net_log); 528 base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
528 } 529 }
529 530
530 void CancelRequest(const std::string& group_name, 531 void CancelRequest(const std::string& group_name,
531 ClientSocketHandle* handle) override { 532 ClientSocketHandle* handle) override {
532 base_.CancelRequest(group_name, handle); 533 base_.CancelRequest(group_name, handle);
533 } 534 }
(...skipping 207 matching lines...) Expand 10 before | Expand all | Expand 10 after
741 }; 742 };
742 743
743 // Even though a timeout is specified, it doesn't time out on a synchronous 744 // Even though a timeout is specified, it doesn't time out on a synchronous
744 // completion. 745 // completion.
745 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) { 746 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
746 TestConnectJobDelegate delegate; 747 TestConnectJobDelegate delegate;
747 ClientSocketHandle ignored; 748 ClientSocketHandle ignored;
748 TestClientSocketPoolBase::Request request( 749 TestClientSocketPoolBase::Request request(
749 &ignored, CompletionCallback(), DEFAULT_PRIORITY, 750 &ignored, CompletionCallback(), DEFAULT_PRIORITY,
750 ClientSocketPool::RespectLimits::ENABLED, 751 ClientSocketPool::RespectLimits::ENABLED,
751 internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog()); 752 internal::ClientSocketPoolBaseHelper::NORMAL, params_,
753 NetLogWithSource());
752 std::unique_ptr<TestConnectJob> job( 754 std::unique_ptr<TestConnectJob> job(
753 new TestConnectJob(TestConnectJob::kMockJob, "a", request, 755 new TestConnectJob(TestConnectJob::kMockJob, "a", request,
754 base::TimeDelta::FromMicroseconds(1), &delegate, 756 base::TimeDelta::FromMicroseconds(1), &delegate,
755 &client_socket_factory_, NULL)); 757 &client_socket_factory_, NULL));
756 EXPECT_THAT(job->Connect(), IsOk()); 758 EXPECT_THAT(job->Connect(), IsOk());
757 } 759 }
758 760
759 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) { 761 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
760 TestConnectJobDelegate delegate; 762 TestConnectJobDelegate delegate;
761 ClientSocketHandle ignored; 763 ClientSocketHandle ignored;
762 TestNetLog log; 764 TestNetLog log;
763 765
764 TestClientSocketPoolBase::Request request( 766 TestClientSocketPoolBase::Request request(
765 &ignored, CompletionCallback(), DEFAULT_PRIORITY, 767 &ignored, CompletionCallback(), DEFAULT_PRIORITY,
766 ClientSocketPool::RespectLimits::ENABLED, 768 ClientSocketPool::RespectLimits::ENABLED,
767 internal::ClientSocketPoolBaseHelper::NORMAL, params_, BoundNetLog()); 769 internal::ClientSocketPoolBaseHelper::NORMAL, params_,
770 NetLogWithSource());
768 // Deleted by TestConnectJobDelegate. 771 // Deleted by TestConnectJobDelegate.
769 TestConnectJob* job = 772 TestConnectJob* job =
770 new TestConnectJob(TestConnectJob::kMockPendingJob, 773 new TestConnectJob(TestConnectJob::kMockPendingJob,
771 "a", 774 "a",
772 request, 775 request,
773 base::TimeDelta::FromMicroseconds(1), 776 base::TimeDelta::FromMicroseconds(1),
774 &delegate, 777 &delegate,
775 &client_socket_factory_, 778 &client_socket_factory_,
776 &log); 779 &log);
777 ASSERT_THAT(job->Connect(), IsError(ERR_IO_PENDING)); 780 ASSERT_THAT(job->Connect(), IsError(ERR_IO_PENDING));
(...skipping 296 matching lines...) Expand 10 before | Expand all | Expand 10 after
1074 1077
1075 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) { 1078 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
1076 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 1079 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
1077 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1080 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1078 1081
1079 ClientSocketHandle handle; 1082 ClientSocketHandle handle;
1080 TestCompletionCallback callback; 1083 TestCompletionCallback callback;
1081 EXPECT_EQ(ERR_IO_PENDING, 1084 EXPECT_EQ(ERR_IO_PENDING,
1082 handle.Init("a", params_, DEFAULT_PRIORITY, 1085 handle.Init("a", params_, DEFAULT_PRIORITY,
1083 ClientSocketPool::RespectLimits::ENABLED, 1086 ClientSocketPool::RespectLimits::ENABLED,
1084 callback.callback(), pool_.get(), BoundNetLog())); 1087 callback.callback(), pool_.get(), NetLogWithSource()));
1085 1088
1086 ClientSocketHandle handles[4]; 1089 ClientSocketHandle handles[4];
1087 for (size_t i = 0; i < arraysize(handles); ++i) { 1090 for (size_t i = 0; i < arraysize(handles); ++i) {
1088 TestCompletionCallback callback; 1091 TestCompletionCallback callback;
1089 EXPECT_EQ(ERR_IO_PENDING, 1092 EXPECT_EQ(
1090 handles[i].Init("b", params_, DEFAULT_PRIORITY, 1093 ERR_IO_PENDING,
1091 ClientSocketPool::RespectLimits::ENABLED, 1094 handles[i].Init("b", params_, DEFAULT_PRIORITY,
1092 callback.callback(), pool_.get(), BoundNetLog())); 1095 ClientSocketPool::RespectLimits::ENABLED,
1096 callback.callback(), pool_.get(), NetLogWithSource()));
1093 } 1097 }
1094 1098
1095 // One will be stalled, cancel all the handles now. 1099 // One will be stalled, cancel all the handles now.
1096 // This should hit the OnAvailableSocketSlot() code where we previously had 1100 // This should hit the OnAvailableSocketSlot() code where we previously had
1097 // stalled groups, but no longer have any. 1101 // stalled groups, but no longer have any.
1098 for (size_t i = 0; i < arraysize(handles); ++i) 1102 for (size_t i = 0; i < arraysize(handles); ++i)
1099 handles[i].Reset(); 1103 handles[i].Reset();
1100 } 1104 }
1101 1105
1102 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) { 1106 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
1103 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1107 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1104 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1108 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1105 1109
1106 { 1110 {
1107 ClientSocketHandle handles[kDefaultMaxSockets]; 1111 ClientSocketHandle handles[kDefaultMaxSockets];
1108 TestCompletionCallback callbacks[kDefaultMaxSockets]; 1112 TestCompletionCallback callbacks[kDefaultMaxSockets];
1109 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1113 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1110 EXPECT_EQ(OK, handles[i].Init( 1114 EXPECT_EQ(OK,
1111 base::IntToString(i), params_, DEFAULT_PRIORITY, 1115 handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
1112 ClientSocketPool::RespectLimits::ENABLED, 1116 ClientSocketPool::RespectLimits::ENABLED,
1113 callbacks[i].callback(), pool_.get(), BoundNetLog())); 1117 callbacks[i].callback(), pool_.get(),
1118 NetLogWithSource()));
1114 } 1119 }
1115 1120
1116 // Force a stalled group. 1121 // Force a stalled group.
1117 ClientSocketHandle stalled_handle; 1122 ClientSocketHandle stalled_handle;
1118 TestCompletionCallback callback; 1123 TestCompletionCallback callback;
1119 EXPECT_EQ( 1124 EXPECT_EQ(ERR_IO_PENDING,
1120 ERR_IO_PENDING, 1125 stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
1121 stalled_handle.Init("foo", params_, DEFAULT_PRIORITY, 1126 ClientSocketPool::RespectLimits::ENABLED,
1122 ClientSocketPool::RespectLimits::ENABLED, 1127 callback.callback(), pool_.get(),
1123 callback.callback(), pool_.get(), BoundNetLog())); 1128 NetLogWithSource()));
1124 1129
1125 // Cancel the stalled request. 1130 // Cancel the stalled request.
1126 stalled_handle.Reset(); 1131 stalled_handle.Reset();
1127 1132
1128 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1133 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1129 EXPECT_EQ(0, pool_->IdleSocketCount()); 1134 EXPECT_EQ(0, pool_->IdleSocketCount());
1130 1135
1131 // Dropping out of scope will close all handles and return them to idle. 1136 // Dropping out of scope will close all handles and return them to idle.
1132 } 1137 }
1133 1138
1134 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1139 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1135 EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount()); 1140 EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount());
1136 } 1141 }
1137 1142
1138 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) { 1143 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
1139 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1144 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1140 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1145 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1141 1146
1142 { 1147 {
1143 ClientSocketHandle handles[kDefaultMaxSockets]; 1148 ClientSocketHandle handles[kDefaultMaxSockets];
1144 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1149 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1145 TestCompletionCallback callback; 1150 TestCompletionCallback callback;
1146 EXPECT_EQ( 1151 EXPECT_EQ(ERR_IO_PENDING,
1147 ERR_IO_PENDING, 1152 handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
1148 handles[i].Init(base::IntToString(i), params_, DEFAULT_PRIORITY, 1153 ClientSocketPool::RespectLimits::ENABLED,
1149 ClientSocketPool::RespectLimits::ENABLED, 1154 callback.callback(), pool_.get(),
1150 callback.callback(), pool_.get(), BoundNetLog())); 1155 NetLogWithSource()));
1151 } 1156 }
1152 1157
1153 // Force a stalled group. 1158 // Force a stalled group.
1154 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1159 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1155 ClientSocketHandle stalled_handle; 1160 ClientSocketHandle stalled_handle;
1156 TestCompletionCallback callback; 1161 TestCompletionCallback callback;
1157 EXPECT_EQ( 1162 EXPECT_EQ(ERR_IO_PENDING,
1158 ERR_IO_PENDING, 1163 stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
1159 stalled_handle.Init("foo", params_, DEFAULT_PRIORITY, 1164 ClientSocketPool::RespectLimits::ENABLED,
1160 ClientSocketPool::RespectLimits::ENABLED, 1165 callback.callback(), pool_.get(),
1161 callback.callback(), pool_.get(), BoundNetLog())); 1166 NetLogWithSource()));
1162 1167
1163 // Since it is stalled, it should have no connect jobs. 1168 // Since it is stalled, it should have no connect jobs.
1164 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo")); 1169 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
1165 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo")); 1170 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
1166 1171
1167 // Cancel the stalled request. 1172 // Cancel the stalled request.
1168 handles[0].Reset(); 1173 handles[0].Reset();
1169 1174
1170 // Now we should have a connect job. 1175 // Now we should have a connect job.
1171 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("foo")); 1176 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("foo"));
(...skipping 18 matching lines...) Expand all
1190 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1195 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1191 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1196 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1192 1197
1193 ClientSocketHandle stalled_handle; 1198 ClientSocketHandle stalled_handle;
1194 TestCompletionCallback callback; 1199 TestCompletionCallback callback;
1195 { 1200 {
1196 EXPECT_FALSE(pool_->IsStalled()); 1201 EXPECT_FALSE(pool_->IsStalled());
1197 ClientSocketHandle handles[kDefaultMaxSockets]; 1202 ClientSocketHandle handles[kDefaultMaxSockets];
1198 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1203 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1199 TestCompletionCallback callback; 1204 TestCompletionCallback callback;
1200 EXPECT_EQ( 1205 EXPECT_EQ(OK, handles[i].Init(base::StringPrintf("Take 2: %d", i),
1201 OK, handles[i].Init(base::StringPrintf("Take 2: %d", i), params_, 1206 params_, DEFAULT_PRIORITY,
1202 DEFAULT_PRIORITY, 1207 ClientSocketPool::RespectLimits::ENABLED,
1203 ClientSocketPool::RespectLimits::ENABLED, 1208 callback.callback(), pool_.get(),
1204 callback.callback(), pool_.get(), BoundNetLog())); 1209 NetLogWithSource()));
1205 } 1210 }
1206 1211
1207 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1212 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1208 EXPECT_EQ(0, pool_->IdleSocketCount()); 1213 EXPECT_EQ(0, pool_->IdleSocketCount());
1209 EXPECT_FALSE(pool_->IsStalled()); 1214 EXPECT_FALSE(pool_->IsStalled());
1210 1215
1211 // Now we will hit the socket limit. 1216 // Now we will hit the socket limit.
1212 EXPECT_EQ( 1217 EXPECT_EQ(ERR_IO_PENDING,
1213 ERR_IO_PENDING, 1218 stalled_handle.Init("foo", params_, DEFAULT_PRIORITY,
1214 stalled_handle.Init("foo", params_, DEFAULT_PRIORITY, 1219 ClientSocketPool::RespectLimits::ENABLED,
1215 ClientSocketPool::RespectLimits::ENABLED, 1220 callback.callback(), pool_.get(),
1216 callback.callback(), pool_.get(), BoundNetLog())); 1221 NetLogWithSource()));
1217 EXPECT_TRUE(pool_->IsStalled()); 1222 EXPECT_TRUE(pool_->IsStalled());
1218 1223
1219 // Dropping out of scope will close all handles and return them to idle. 1224 // Dropping out of scope will close all handles and return them to idle.
1220 } 1225 }
1221 1226
1222 // But if we wait for it, the released idle sockets will be closed in 1227 // But if we wait for it, the released idle sockets will be closed in
1223 // preference of the waiting request. 1228 // preference of the waiting request.
1224 EXPECT_THAT(callback.WaitForResult(), IsOk()); 1229 EXPECT_THAT(callback.WaitForResult(), IsOk());
1225 1230
1226 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count()); 1231 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
1227 EXPECT_EQ(3, pool_->IdleSocketCount()); 1232 EXPECT_EQ(3, pool_->IdleSocketCount());
1228 } 1233 }
1229 1234
1230 // Regression test for http://crbug.com/40952. 1235 // Regression test for http://crbug.com/40952.
1231 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) { 1236 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
1232 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1237 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1233 pool_->EnableConnectBackupJobs(); 1238 pool_->EnableConnectBackupJobs();
1234 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1239 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1235 1240
1236 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1241 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1237 ClientSocketHandle handle; 1242 ClientSocketHandle handle;
1238 TestCompletionCallback callback; 1243 TestCompletionCallback callback;
1239 EXPECT_EQ(OK, handle.Init(base::IntToString(i), params_, DEFAULT_PRIORITY, 1244 EXPECT_EQ(
1240 ClientSocketPool::RespectLimits::ENABLED, 1245 OK, handle.Init(base::IntToString(i), params_, DEFAULT_PRIORITY,
1241 callback.callback(), pool_.get(), BoundNetLog())); 1246 ClientSocketPool::RespectLimits::ENABLED,
1247 callback.callback(), pool_.get(), NetLogWithSource()));
1242 } 1248 }
1243 1249
1244 // Flush all the DoReleaseSocket tasks. 1250 // Flush all the DoReleaseSocket tasks.
1245 base::RunLoop().RunUntilIdle(); 1251 base::RunLoop().RunUntilIdle();
1246 1252
1247 // Stall a group. Set a pending job so it'll trigger a backup job if we don't 1253 // Stall a group. Set a pending job so it'll trigger a backup job if we don't
1248 // reuse a socket. 1254 // reuse a socket.
1249 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1255 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1250 ClientSocketHandle handle; 1256 ClientSocketHandle handle;
1251 TestCompletionCallback callback; 1257 TestCompletionCallback callback;
1252 1258
1253 // "0" is special here, since it should be the first entry in the sorted map, 1259 // "0" is special here, since it should be the first entry in the sorted map,
1254 // which is the one which we would close an idle socket for. We shouldn't 1260 // which is the one which we would close an idle socket for. We shouldn't
1255 // close an idle socket though, since we should reuse the idle socket. 1261 // close an idle socket though, since we should reuse the idle socket.
1256 EXPECT_EQ(OK, handle.Init("0", params_, DEFAULT_PRIORITY, 1262 EXPECT_EQ(OK,
1257 ClientSocketPool::RespectLimits::ENABLED, 1263 handle.Init("0", params_, DEFAULT_PRIORITY,
1258 callback.callback(), pool_.get(), BoundNetLog())); 1264 ClientSocketPool::RespectLimits::ENABLED,
1265 callback.callback(), pool_.get(), NetLogWithSource()));
1259 1266
1260 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1267 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1261 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount()); 1268 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
1262 } 1269 }
1263 1270
1264 TEST_F(ClientSocketPoolBaseTest, PendingRequests) { 1271 TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
1265 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1272 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1266 1273
1267 EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk()); 1274 EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk());
1268 EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk()); 1275 EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk());
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
1320 // ClientSocketPoolBase. 1327 // ClientSocketPoolBase.
1321 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) { 1328 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
1322 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1329 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1323 1330
1324 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1331 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1325 ClientSocketHandle handle; 1332 ClientSocketHandle handle;
1326 TestCompletionCallback callback; 1333 TestCompletionCallback callback;
1327 EXPECT_EQ(ERR_IO_PENDING, 1334 EXPECT_EQ(ERR_IO_PENDING,
1328 handle.Init("a", params_, DEFAULT_PRIORITY, 1335 handle.Init("a", params_, DEFAULT_PRIORITY,
1329 ClientSocketPool::RespectLimits::ENABLED, 1336 ClientSocketPool::RespectLimits::ENABLED,
1330 callback.callback(), pool_.get(), BoundNetLog())); 1337 callback.callback(), pool_.get(), NetLogWithSource()));
1331 handle.Reset(); 1338 handle.Reset();
1332 } 1339 }
1333 1340
1334 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) { 1341 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
1335 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1342 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1336 1343
1337 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1344 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1338 ClientSocketHandle handle; 1345 ClientSocketHandle handle;
1339 TestCompletionCallback callback; 1346 TestCompletionCallback callback;
1340 1347
1341 EXPECT_EQ(ERR_IO_PENDING, 1348 EXPECT_EQ(ERR_IO_PENDING,
1342 handle.Init("a", params_, DEFAULT_PRIORITY, 1349 handle.Init("a", params_, DEFAULT_PRIORITY,
1343 ClientSocketPool::RespectLimits::ENABLED, 1350 ClientSocketPool::RespectLimits::ENABLED,
1344 callback.callback(), pool_.get(), BoundNetLog())); 1351 callback.callback(), pool_.get(), NetLogWithSource()));
1345 1352
1346 handle.Reset(); 1353 handle.Reset();
1347 1354
1348 TestCompletionCallback callback2; 1355 TestCompletionCallback callback2;
1349 EXPECT_EQ(ERR_IO_PENDING, 1356 EXPECT_EQ(ERR_IO_PENDING,
1350 handle.Init("a", params_, DEFAULT_PRIORITY, 1357 handle.Init("a", params_, DEFAULT_PRIORITY,
1351 ClientSocketPool::RespectLimits::ENABLED, 1358 ClientSocketPool::RespectLimits::ENABLED,
1352 callback2.callback(), pool_.get(), BoundNetLog())); 1359 callback2.callback(), pool_.get(), NetLogWithSource()));
1353 1360
1354 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 1361 EXPECT_THAT(callback2.WaitForResult(), IsOk());
1355 EXPECT_FALSE(callback.have_result()); 1362 EXPECT_FALSE(callback.have_result());
1356 1363
1357 handle.Reset(); 1364 handle.Reset();
1358 } 1365 }
1359 1366
1360 TEST_F(ClientSocketPoolBaseTest, CancelRequest) { 1367 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
1361 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1368 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1362 1369
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after
1410 1417
1411 // Don't allow reuse of the socket. Disconnect it and then release it. 1418 // Don't allow reuse of the socket. Disconnect it and then release it.
1412 if (handle->socket()) 1419 if (handle->socket())
1413 handle->socket()->Disconnect(); 1420 handle->socket()->Disconnect();
1414 handle->Reset(); 1421 handle->Reset();
1415 1422
1416 scoped_refptr<TestSocketParams> params(new TestSocketParams()); 1423 scoped_refptr<TestSocketParams> params(new TestSocketParams());
1417 TestCompletionCallback callback; 1424 TestCompletionCallback callback;
1418 int rv = handle->Init("a", params, LOWEST, 1425 int rv = handle->Init("a", params, LOWEST,
1419 ClientSocketPool::RespectLimits::ENABLED, 1426 ClientSocketPool::RespectLimits::ENABLED,
1420 nested_callback, pool, BoundNetLog()); 1427 nested_callback, pool, NetLogWithSource());
1421 if (rv != ERR_IO_PENDING) { 1428 if (rv != ERR_IO_PENDING) {
1422 DCHECK_EQ(TestConnectJob::kMockJob, next_job_type); 1429 DCHECK_EQ(TestConnectJob::kMockJob, next_job_type);
1423 nested_callback.Run(rv); 1430 nested_callback.Run(rv);
1424 } else { 1431 } else {
1425 DCHECK_EQ(TestConnectJob::kMockPendingJob, next_job_type); 1432 DCHECK_EQ(TestConnectJob::kMockPendingJob, next_job_type);
1426 } 1433 }
1427 } 1434 }
1428 1435
1429 // Tests the case where a second socket is requested in a completion callback, 1436 // Tests the case where a second socket is requested in a completion callback,
1430 // and the second socket connects asynchronously. Reuses the same 1437 // and the second socket connects asynchronously. Reuses the same
1431 // ClientSocketHandle for the second socket, after disconnecting the first. 1438 // ClientSocketHandle for the second socket, after disconnecting the first.
1432 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) { 1439 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
1433 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1440 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1434 1441
1435 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1442 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1436 ClientSocketHandle handle; 1443 ClientSocketHandle handle;
1437 TestCompletionCallback second_result_callback; 1444 TestCompletionCallback second_result_callback;
1438 int rv = handle.Init( 1445 int rv = handle.Init(
1439 "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED, 1446 "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED,
1440 base::Bind(&RequestSocketOnComplete, &handle, pool_.get(), 1447 base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
1441 connect_job_factory_, TestConnectJob::kMockPendingJob, 1448 connect_job_factory_, TestConnectJob::kMockPendingJob,
1442 second_result_callback.callback()), 1449 second_result_callback.callback()),
1443 pool_.get(), BoundNetLog()); 1450 pool_.get(), NetLogWithSource());
1444 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 1451 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
1445 1452
1446 EXPECT_THAT(second_result_callback.WaitForResult(), IsOk()); 1453 EXPECT_THAT(second_result_callback.WaitForResult(), IsOk());
1447 } 1454 }
1448 1455
1449 // Tests the case where a second socket is requested in a completion callback, 1456 // Tests the case where a second socket is requested in a completion callback,
1450 // and the second socket connects synchronously. Reuses the same 1457 // and the second socket connects synchronously. Reuses the same
1451 // ClientSocketHandle for the second socket, after disconnecting the first. 1458 // ClientSocketHandle for the second socket, after disconnecting the first.
1452 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) { 1459 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
1453 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1460 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1454 1461
1455 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1462 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1456 ClientSocketHandle handle; 1463 ClientSocketHandle handle;
1457 TestCompletionCallback second_result_callback; 1464 TestCompletionCallback second_result_callback;
1458 int rv = handle.Init( 1465 int rv = handle.Init(
1459 "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED, 1466 "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED,
1460 base::Bind(&RequestSocketOnComplete, &handle, pool_.get(), 1467 base::Bind(&RequestSocketOnComplete, &handle, pool_.get(),
1461 connect_job_factory_, TestConnectJob::kMockPendingJob, 1468 connect_job_factory_, TestConnectJob::kMockPendingJob,
1462 second_result_callback.callback()), 1469 second_result_callback.callback()),
1463 pool_.get(), BoundNetLog()); 1470 pool_.get(), NetLogWithSource());
1464 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 1471 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
1465 1472
1466 EXPECT_THAT(second_result_callback.WaitForResult(), IsOk()); 1473 EXPECT_THAT(second_result_callback.WaitForResult(), IsOk());
1467 } 1474 }
1468 1475
1469 // Make sure that pending requests get serviced after active requests get 1476 // Make sure that pending requests get serviced after active requests get
1470 // cancelled. 1477 // cancelled.
1471 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) { 1478 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
1472 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1479 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1473 1480
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
1518 1525
1519 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) { 1526 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
1520 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1527 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1521 1528
1522 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1529 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1523 1530
1524 ClientSocketHandle handle; 1531 ClientSocketHandle handle;
1525 TestCompletionCallback callback; 1532 TestCompletionCallback callback;
1526 int rv = handle.Init("a", params_, DEFAULT_PRIORITY, 1533 int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
1527 ClientSocketPool::RespectLimits::ENABLED, 1534 ClientSocketPool::RespectLimits::ENABLED,
1528 callback.callback(), pool_.get(), BoundNetLog()); 1535 callback.callback(), pool_.get(), NetLogWithSource());
1529 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1536 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1530 1537
1531 // Cancel the active request. 1538 // Cancel the active request.
1532 handle.Reset(); 1539 handle.Reset();
1533 1540
1534 rv = handle.Init("a", params_, DEFAULT_PRIORITY, 1541 rv = handle.Init("a", params_, DEFAULT_PRIORITY,
1535 ClientSocketPool::RespectLimits::ENABLED, 1542 ClientSocketPool::RespectLimits::ENABLED,
1536 callback.callback(), pool_.get(), BoundNetLog()); 1543 callback.callback(), pool_.get(), NetLogWithSource());
1537 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1544 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1538 EXPECT_THAT(callback.WaitForResult(), IsOk()); 1545 EXPECT_THAT(callback.WaitForResult(), IsOk());
1539 1546
1540 EXPECT_FALSE(handle.is_reused()); 1547 EXPECT_FALSE(handle.is_reused());
1541 TestLoadTimingInfoConnectedNotReused(handle); 1548 TestLoadTimingInfoConnectedNotReused(handle);
1542 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 1549 EXPECT_EQ(2, client_socket_factory_.allocation_count());
1543 } 1550 }
1544 1551
1545 // Regression test for http://crbug.com/17985. 1552 // Regression test for http://crbug.com/17985.
1546 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) { 1553 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after
1671 1678
1672 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1679 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1673 ClientSocketHandle handle; 1680 ClientSocketHandle handle;
1674 TestCompletionCallback callback; 1681 TestCompletionCallback callback;
1675 ClientSocketHandle handle2; 1682 ClientSocketHandle handle2;
1676 TestCompletionCallback callback2; 1683 TestCompletionCallback callback2;
1677 1684
1678 EXPECT_EQ(ERR_IO_PENDING, 1685 EXPECT_EQ(ERR_IO_PENDING,
1679 handle.Init("a", params_, DEFAULT_PRIORITY, 1686 handle.Init("a", params_, DEFAULT_PRIORITY,
1680 ClientSocketPool::RespectLimits::ENABLED, 1687 ClientSocketPool::RespectLimits::ENABLED,
1681 callback.callback(), pool_.get(), BoundNetLog())); 1688 callback.callback(), pool_.get(), NetLogWithSource()));
1682 BoundTestNetLog log2; 1689 BoundTestNetLog log2;
1683 EXPECT_EQ(ERR_IO_PENDING, 1690 EXPECT_EQ(
1684 handle2.Init("a", params_, DEFAULT_PRIORITY, 1691 ERR_IO_PENDING,
1685 ClientSocketPool::RespectLimits::ENABLED, 1692 handle2.Init("a", params_, DEFAULT_PRIORITY,
1686 callback2.callback(), pool_.get(), BoundNetLog())); 1693 ClientSocketPool::RespectLimits::ENABLED,
1694 callback2.callback(), pool_.get(), NetLogWithSource()));
1687 1695
1688 handle.Reset(); 1696 handle.Reset();
1689 1697
1690 1698
1691 // At this point, request 2 is just waiting for the connect job to finish. 1699 // At this point, request 2 is just waiting for the connect job to finish.
1692 1700
1693 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 1701 EXPECT_THAT(callback2.WaitForResult(), IsOk());
1694 handle2.Reset(); 1702 handle2.Reset();
1695 1703
1696 // Now request 2 has actually finished. 1704 // Now request 2 has actually finished.
(...skipping 26 matching lines...) Expand all
1723 // by whatever comes first. 1731 // by whatever comes first.
1724 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) { 1732 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
1725 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1733 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1726 1734
1727 // Start job 1 (async OK) 1735 // Start job 1 (async OK)
1728 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1736 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1729 1737
1730 std::vector<TestSocketRequest*> request_order; 1738 std::vector<TestSocketRequest*> request_order;
1731 size_t completion_count; // unused 1739 size_t completion_count; // unused
1732 TestSocketRequest req1(&request_order, &completion_count); 1740 TestSocketRequest req1(&request_order, &completion_count);
1733 int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY, 1741 int rv = req1.handle()->Init(
1734 ClientSocketPool::RespectLimits::ENABLED, 1742 "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED,
1735 req1.callback(), pool_.get(), BoundNetLog()); 1743 req1.callback(), pool_.get(), NetLogWithSource());
1736 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1744 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1737 EXPECT_THAT(req1.WaitForResult(), IsOk()); 1745 EXPECT_THAT(req1.WaitForResult(), IsOk());
1738 1746
1739 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending 1747 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending
1740 // without a job. 1748 // without a job.
1741 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1749 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1742 1750
1743 TestSocketRequest req2(&request_order, &completion_count); 1751 TestSocketRequest req2(&request_order, &completion_count);
1744 rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY, 1752 rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY,
1745 ClientSocketPool::RespectLimits::ENABLED, 1753 ClientSocketPool::RespectLimits::ENABLED,
1746 req2.callback(), pool_.get(), BoundNetLog()); 1754 req2.callback(), pool_.get(), NetLogWithSource());
1747 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1755 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1748 TestSocketRequest req3(&request_order, &completion_count); 1756 TestSocketRequest req3(&request_order, &completion_count);
1749 rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY, 1757 rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY,
1750 ClientSocketPool::RespectLimits::ENABLED, 1758 ClientSocketPool::RespectLimits::ENABLED,
1751 req3.callback(), pool_.get(), BoundNetLog()); 1759 req3.callback(), pool_.get(), NetLogWithSource());
1752 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1760 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1753 1761
1754 // Both Requests 2 and 3 are pending. We release socket 1 which should 1762 // Both Requests 2 and 3 are pending. We release socket 1 which should
1755 // service request 2. Request 3 should still be waiting. 1763 // service request 2. Request 3 should still be waiting.
1756 req1.handle()->Reset(); 1764 req1.handle()->Reset();
1757 // Run the released socket wakeups. 1765 // Run the released socket wakeups.
1758 base::RunLoop().RunUntilIdle(); 1766 base::RunLoop().RunUntilIdle();
1759 ASSERT_TRUE(req2.handle()->socket()); 1767 ASSERT_TRUE(req2.handle()->socket());
1760 EXPECT_THAT(req2.WaitForResult(), IsOk()); 1768 EXPECT_THAT(req2.WaitForResult(), IsOk());
1761 EXPECT_FALSE(req3.handle()->socket()); 1769 EXPECT_FALSE(req3.handle()->socket());
(...skipping 13 matching lines...) Expand all
1775 // The requests are not coupled to the jobs. So, the requests should finish in 1783 // The requests are not coupled to the jobs. So, the requests should finish in
1776 // their priority / insertion order. 1784 // their priority / insertion order.
1777 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) { 1785 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
1778 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1786 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1779 // First two jobs are async. 1787 // First two jobs are async.
1780 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 1788 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1781 1789
1782 std::vector<TestSocketRequest*> request_order; 1790 std::vector<TestSocketRequest*> request_order;
1783 size_t completion_count; // unused 1791 size_t completion_count; // unused
1784 TestSocketRequest req1(&request_order, &completion_count); 1792 TestSocketRequest req1(&request_order, &completion_count);
1785 int rv = req1.handle()->Init("a", params_, DEFAULT_PRIORITY, 1793 int rv = req1.handle()->Init(
1786 ClientSocketPool::RespectLimits::ENABLED, 1794 "a", params_, DEFAULT_PRIORITY, ClientSocketPool::RespectLimits::ENABLED,
1787 req1.callback(), pool_.get(), BoundNetLog()); 1795 req1.callback(), pool_.get(), NetLogWithSource());
1788 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1796 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1789 1797
1790 TestSocketRequest req2(&request_order, &completion_count); 1798 TestSocketRequest req2(&request_order, &completion_count);
1791 rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY, 1799 rv = req2.handle()->Init("a", params_, DEFAULT_PRIORITY,
1792 ClientSocketPool::RespectLimits::ENABLED, 1800 ClientSocketPool::RespectLimits::ENABLED,
1793 req2.callback(), pool_.get(), BoundNetLog()); 1801 req2.callback(), pool_.get(), NetLogWithSource());
1794 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1802 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1795 1803
1796 // The pending job is sync. 1804 // The pending job is sync.
1797 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1805 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1798 1806
1799 TestSocketRequest req3(&request_order, &completion_count); 1807 TestSocketRequest req3(&request_order, &completion_count);
1800 rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY, 1808 rv = req3.handle()->Init("a", params_, DEFAULT_PRIORITY,
1801 ClientSocketPool::RespectLimits::ENABLED, 1809 ClientSocketPool::RespectLimits::ENABLED,
1802 req3.callback(), pool_.get(), BoundNetLog()); 1810 req3.callback(), pool_.get(), NetLogWithSource());
1803 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1811 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1804 1812
1805 EXPECT_THAT(req1.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); 1813 EXPECT_THAT(req1.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
1806 EXPECT_THAT(req2.WaitForResult(), IsOk()); 1814 EXPECT_THAT(req2.WaitForResult(), IsOk());
1807 EXPECT_THAT(req3.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); 1815 EXPECT_THAT(req3.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
1808 1816
1809 ASSERT_EQ(3U, request_order.size()); 1817 ASSERT_EQ(3U, request_order.size());
1810 EXPECT_EQ(&req1, request_order[0]); 1818 EXPECT_EQ(&req1, request_order[0]);
1811 EXPECT_EQ(&req2, request_order[1]); 1819 EXPECT_EQ(&req2, request_order[1]);
1812 EXPECT_EQ(&req3, request_order[2]); 1820 EXPECT_EQ(&req3, request_order[2]);
1813 } 1821 }
1814 1822
1815 // Test GetLoadState in the case there's only one socket request. 1823 // Test GetLoadState in the case there's only one socket request.
1816 TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) { 1824 TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) {
1817 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1825 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1818 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1826 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1819 1827
1820 ClientSocketHandle handle; 1828 ClientSocketHandle handle;
1821 TestCompletionCallback callback; 1829 TestCompletionCallback callback;
1822 int rv = handle.Init("a", params_, DEFAULT_PRIORITY, 1830 int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
1823 ClientSocketPool::RespectLimits::ENABLED, 1831 ClientSocketPool::RespectLimits::ENABLED,
1824 callback.callback(), pool_.get(), BoundNetLog()); 1832 callback.callback(), pool_.get(), NetLogWithSource());
1825 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1833 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1826 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 1834 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1827 1835
1828 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE); 1836 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
1829 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState()); 1837 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
1830 1838
1831 // No point in completing the connection, since ClientSocketHandles only 1839 // No point in completing the connection, since ClientSocketHandles only
1832 // expect the LoadState to be checked while connecting. 1840 // expect the LoadState to be checked while connecting.
1833 } 1841 }
1834 1842
1835 // Test GetLoadState in the case there are two socket requests. 1843 // Test GetLoadState in the case there are two socket requests.
1836 // Only the first connection in the pool should affect the pool's load status. 1844 // Only the first connection in the pool should affect the pool's load status.
1837 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) { 1845 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
1838 CreatePool(2, 2); 1846 CreatePool(2, 2);
1839 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1847 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1840 1848
1841 ClientSocketHandle handle; 1849 ClientSocketHandle handle;
1842 TestCompletionCallback callback; 1850 TestCompletionCallback callback;
1843 int rv = handle.Init("a", params_, DEFAULT_PRIORITY, 1851 int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
1844 ClientSocketPool::RespectLimits::ENABLED, 1852 ClientSocketPool::RespectLimits::ENABLED,
1845 callback.callback(), pool_.get(), BoundNetLog()); 1853 callback.callback(), pool_.get(), NetLogWithSource());
1846 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1854 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1847 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST); 1855 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
1848 1856
1849 ClientSocketHandle handle2; 1857 ClientSocketHandle handle2;
1850 TestCompletionCallback callback2; 1858 TestCompletionCallback callback2;
1851 rv = handle2.Init("a", params_, DEFAULT_PRIORITY, 1859 rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
1852 ClientSocketPool::RespectLimits::ENABLED, 1860 ClientSocketPool::RespectLimits::ENABLED,
1853 callback2.callback(), pool_.get(), BoundNetLog()); 1861 callback2.callback(), pool_.get(), NetLogWithSource());
1854 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1862 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1855 client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST); 1863 client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
1856 1864
1857 // Check that both handles report the state of the first job. 1865 // Check that both handles report the state of the first job.
1858 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle.GetLoadState()); 1866 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle.GetLoadState());
1859 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState()); 1867 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState());
1860 1868
1861 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_CONNECTING); 1869 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_CONNECTING);
1862 1870
1863 // Check that both handles change to LOAD_STATE_CONNECTING. 1871 // Check that both handles change to LOAD_STATE_CONNECTING.
1864 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 1872 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1865 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState()); 1873 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
1866 } 1874 }
1867 1875
1868 // Test that the second connection request does not affect the pool's load 1876 // Test that the second connection request does not affect the pool's load
1869 // status. 1877 // status.
1870 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequestsChangeSecondRequestState) { 1878 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequestsChangeSecondRequestState) {
1871 CreatePool(2, 2); 1879 CreatePool(2, 2);
1872 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1880 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1873 1881
1874 ClientSocketHandle handle; 1882 ClientSocketHandle handle;
1875 TestCompletionCallback callback; 1883 TestCompletionCallback callback;
1876 int rv = handle.Init("a", params_, DEFAULT_PRIORITY, 1884 int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
1877 ClientSocketPool::RespectLimits::ENABLED, 1885 ClientSocketPool::RespectLimits::ENABLED,
1878 callback.callback(), pool_.get(), BoundNetLog()); 1886 callback.callback(), pool_.get(), NetLogWithSource());
1879 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1887 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1880 1888
1881 ClientSocketHandle handle2; 1889 ClientSocketHandle handle2;
1882 TestCompletionCallback callback2; 1890 TestCompletionCallback callback2;
1883 rv = handle2.Init("a", params_, DEFAULT_PRIORITY, 1891 rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
1884 ClientSocketPool::RespectLimits::ENABLED, 1892 ClientSocketPool::RespectLimits::ENABLED,
1885 callback2.callback(), pool_.get(), BoundNetLog()); 1893 callback2.callback(), pool_.get(), NetLogWithSource());
1886 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1894 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1887 client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST); 1895 client_socket_factory_.SetJobLoadState(1, LOAD_STATE_RESOLVING_HOST);
1888 1896
1889 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 1897 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1890 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState()); 1898 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
1891 1899
1892 // First job connects and the first request gets the socket. The 1900 // First job connects and the first request gets the socket. The
1893 // second handle switches to the state of the remaining ConnectJob. 1901 // second handle switches to the state of the remaining ConnectJob.
1894 client_socket_factory_.SignalJob(0); 1902 client_socket_factory_.SignalJob(0);
1895 EXPECT_THAT(callback.WaitForResult(), IsOk()); 1903 EXPECT_THAT(callback.WaitForResult(), IsOk());
1896 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState()); 1904 EXPECT_EQ(LOAD_STATE_RESOLVING_HOST, handle2.GetLoadState());
1897 } 1905 }
1898 1906
1899 // Test GetLoadState in the case the per-group limit is reached. 1907 // Test GetLoadState in the case the per-group limit is reached.
1900 TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) { 1908 TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
1901 CreatePool(2, 1); 1909 CreatePool(2, 1);
1902 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1910 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1903 1911
1904 ClientSocketHandle handle; 1912 ClientSocketHandle handle;
1905 TestCompletionCallback callback; 1913 TestCompletionCallback callback;
1906 int rv = handle.Init("a", params_, MEDIUM, 1914 int rv = handle.Init("a", params_, MEDIUM,
1907 ClientSocketPool::RespectLimits::ENABLED, 1915 ClientSocketPool::RespectLimits::ENABLED,
1908 callback.callback(), pool_.get(), BoundNetLog()); 1916 callback.callback(), pool_.get(), NetLogWithSource());
1909 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1917 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1910 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 1918 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1911 1919
1912 // Request another socket from the same pool, buth with a higher priority. 1920 // Request another socket from the same pool, buth with a higher priority.
1913 // The first request should now be stalled at the socket group limit. 1921 // The first request should now be stalled at the socket group limit.
1914 ClientSocketHandle handle2; 1922 ClientSocketHandle handle2;
1915 TestCompletionCallback callback2; 1923 TestCompletionCallback callback2;
1916 rv = handle2.Init("a", params_, HIGHEST, 1924 rv = handle2.Init("a", params_, HIGHEST,
1917 ClientSocketPool::RespectLimits::ENABLED, 1925 ClientSocketPool::RespectLimits::ENABLED,
1918 callback2.callback(), pool_.get(), BoundNetLog()); 1926 callback2.callback(), pool_.get(), NetLogWithSource());
1919 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1927 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1920 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState()); 1928 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
1921 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState()); 1929 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
1922 1930
1923 // The first handle should remain stalled as the other socket goes through 1931 // The first handle should remain stalled as the other socket goes through
1924 // the connect process. 1932 // the connect process.
1925 1933
1926 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE); 1934 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
1927 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState()); 1935 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
1928 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState()); 1936 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
(...skipping 11 matching lines...) Expand all
1940 1948
1941 // Test GetLoadState in the case the per-pool limit is reached. 1949 // Test GetLoadState in the case the per-pool limit is reached.
1942 TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) { 1950 TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
1943 CreatePool(2, 2); 1951 CreatePool(2, 2);
1944 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1952 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1945 1953
1946 ClientSocketHandle handle; 1954 ClientSocketHandle handle;
1947 TestCompletionCallback callback; 1955 TestCompletionCallback callback;
1948 int rv = handle.Init("a", params_, DEFAULT_PRIORITY, 1956 int rv = handle.Init("a", params_, DEFAULT_PRIORITY,
1949 ClientSocketPool::RespectLimits::ENABLED, 1957 ClientSocketPool::RespectLimits::ENABLED,
1950 callback.callback(), pool_.get(), BoundNetLog()); 1958 callback.callback(), pool_.get(), NetLogWithSource());
1951 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1959 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1952 1960
1953 // Request for socket from another pool. 1961 // Request for socket from another pool.
1954 ClientSocketHandle handle2; 1962 ClientSocketHandle handle2;
1955 TestCompletionCallback callback2; 1963 TestCompletionCallback callback2;
1956 rv = handle2.Init("b", params_, DEFAULT_PRIORITY, 1964 rv = handle2.Init("b", params_, DEFAULT_PRIORITY,
1957 ClientSocketPool::RespectLimits::ENABLED, 1965 ClientSocketPool::RespectLimits::ENABLED,
1958 callback2.callback(), pool_.get(), BoundNetLog()); 1966 callback2.callback(), pool_.get(), NetLogWithSource());
1959 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1967 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1960 1968
1961 // Request another socket from the first pool. Request should stall at the 1969 // Request another socket from the first pool. Request should stall at the
1962 // socket pool limit. 1970 // socket pool limit.
1963 ClientSocketHandle handle3; 1971 ClientSocketHandle handle3;
1964 TestCompletionCallback callback3; 1972 TestCompletionCallback callback3;
1965 rv = handle3.Init("a", params_, DEFAULT_PRIORITY, 1973 rv = handle3.Init("a", params_, DEFAULT_PRIORITY,
1966 ClientSocketPool::RespectLimits::ENABLED, 1974 ClientSocketPool::RespectLimits::ENABLED,
1967 callback2.callback(), pool_.get(), BoundNetLog()); 1975 callback2.callback(), pool_.get(), NetLogWithSource());
1968 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 1976 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
1969 1977
1970 // The third handle should remain stalled as the other sockets in its group 1978 // The third handle should remain stalled as the other sockets in its group
1971 // goes through the connect process. 1979 // goes through the connect process.
1972 1980
1973 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 1981 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1974 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState()); 1982 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
1975 1983
1976 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE); 1984 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
1977 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState()); 1985 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
(...skipping 12 matching lines...) Expand all
1990 1998
1991 TEST_F(ClientSocketPoolBaseTest, Recoverable) { 1999 TEST_F(ClientSocketPoolBaseTest, Recoverable) {
1992 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2000 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1993 connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob); 2001 connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob);
1994 2002
1995 ClientSocketHandle handle; 2003 ClientSocketHandle handle;
1996 TestCompletionCallback callback; 2004 TestCompletionCallback callback;
1997 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, 2005 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED,
1998 handle.Init("a", params_, DEFAULT_PRIORITY, 2006 handle.Init("a", params_, DEFAULT_PRIORITY,
1999 ClientSocketPool::RespectLimits::ENABLED, 2007 ClientSocketPool::RespectLimits::ENABLED,
2000 callback.callback(), pool_.get(), BoundNetLog())); 2008 callback.callback(), pool_.get(), NetLogWithSource()));
2001 EXPECT_TRUE(handle.is_initialized()); 2009 EXPECT_TRUE(handle.is_initialized());
2002 EXPECT_TRUE(handle.socket()); 2010 EXPECT_TRUE(handle.socket());
2003 } 2011 }
2004 2012
2005 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) { 2013 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) {
2006 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2014 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2007 2015
2008 connect_job_factory_->set_job_type( 2016 connect_job_factory_->set_job_type(
2009 TestConnectJob::kMockPendingRecoverableJob); 2017 TestConnectJob::kMockPendingRecoverableJob);
2010 ClientSocketHandle handle; 2018 ClientSocketHandle handle;
2011 TestCompletionCallback callback; 2019 TestCompletionCallback callback;
2012 EXPECT_EQ(ERR_IO_PENDING, 2020 EXPECT_EQ(ERR_IO_PENDING,
2013 handle.Init("a", params_, DEFAULT_PRIORITY, 2021 handle.Init("a", params_, DEFAULT_PRIORITY,
2014 ClientSocketPool::RespectLimits::ENABLED, 2022 ClientSocketPool::RespectLimits::ENABLED,
2015 callback.callback(), pool_.get(), BoundNetLog())); 2023 callback.callback(), pool_.get(), NetLogWithSource()));
2016 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2024 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2017 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_AUTH_REQUESTED)); 2025 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_PROXY_AUTH_REQUESTED));
2018 EXPECT_TRUE(handle.is_initialized()); 2026 EXPECT_TRUE(handle.is_initialized());
2019 EXPECT_TRUE(handle.socket()); 2027 EXPECT_TRUE(handle.socket());
2020 } 2028 }
2021 2029
2022 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) { 2030 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
2023 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2031 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2024 connect_job_factory_->set_job_type( 2032 connect_job_factory_->set_job_type(
2025 TestConnectJob::kMockAdditionalErrorStateJob); 2033 TestConnectJob::kMockAdditionalErrorStateJob);
2026 2034
2027 ClientSocketHandle handle; 2035 ClientSocketHandle handle;
2028 TestCompletionCallback callback; 2036 TestCompletionCallback callback;
2029 EXPECT_EQ(ERR_CONNECTION_FAILED, 2037 EXPECT_EQ(ERR_CONNECTION_FAILED,
2030 handle.Init("a", params_, DEFAULT_PRIORITY, 2038 handle.Init("a", params_, DEFAULT_PRIORITY,
2031 ClientSocketPool::RespectLimits::ENABLED, 2039 ClientSocketPool::RespectLimits::ENABLED,
2032 callback.callback(), pool_.get(), BoundNetLog())); 2040 callback.callback(), pool_.get(), NetLogWithSource()));
2033 EXPECT_FALSE(handle.is_initialized()); 2041 EXPECT_FALSE(handle.is_initialized());
2034 EXPECT_FALSE(handle.socket()); 2042 EXPECT_FALSE(handle.socket());
2035 EXPECT_TRUE(handle.is_ssl_error()); 2043 EXPECT_TRUE(handle.is_ssl_error());
2036 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); 2044 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
2037 } 2045 }
2038 2046
2039 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) { 2047 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
2040 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2048 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2041 2049
2042 connect_job_factory_->set_job_type( 2050 connect_job_factory_->set_job_type(
2043 TestConnectJob::kMockPendingAdditionalErrorStateJob); 2051 TestConnectJob::kMockPendingAdditionalErrorStateJob);
2044 ClientSocketHandle handle; 2052 ClientSocketHandle handle;
2045 TestCompletionCallback callback; 2053 TestCompletionCallback callback;
2046 EXPECT_EQ(ERR_IO_PENDING, 2054 EXPECT_EQ(ERR_IO_PENDING,
2047 handle.Init("a", params_, DEFAULT_PRIORITY, 2055 handle.Init("a", params_, DEFAULT_PRIORITY,
2048 ClientSocketPool::RespectLimits::ENABLED, 2056 ClientSocketPool::RespectLimits::ENABLED,
2049 callback.callback(), pool_.get(), BoundNetLog())); 2057 callback.callback(), pool_.get(), NetLogWithSource()));
2050 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2058 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2051 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); 2059 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
2052 EXPECT_FALSE(handle.is_initialized()); 2060 EXPECT_FALSE(handle.is_initialized());
2053 EXPECT_FALSE(handle.socket()); 2061 EXPECT_FALSE(handle.socket());
2054 EXPECT_TRUE(handle.is_ssl_error()); 2062 EXPECT_TRUE(handle.is_ssl_error());
2055 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); 2063 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
2056 } 2064 }
2057 2065
2058 // Make sure we can reuse sockets. 2066 // Make sure we can reuse sockets.
2059 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSocketsReuse) { 2067 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSocketsReuse) {
2060 CreatePoolWithIdleTimeouts( 2068 CreatePoolWithIdleTimeouts(
2061 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, 2069 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2062 base::TimeDelta(), // Time out unused sockets immediately. 2070 base::TimeDelta(), // Time out unused sockets immediately.
2063 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 2071 base::TimeDelta::FromDays(1)); // Don't time out used sockets.
2064 2072
2065 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2073 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2066 2074
2067 ClientSocketHandle handle; 2075 ClientSocketHandle handle;
2068 TestCompletionCallback callback; 2076 TestCompletionCallback callback;
2069 int rv = handle.Init("a", params_, LOWEST, 2077 int rv = handle.Init("a", params_, LOWEST,
2070 ClientSocketPool::RespectLimits::ENABLED, 2078 ClientSocketPool::RespectLimits::ENABLED,
2071 callback.callback(), pool_.get(), BoundNetLog()); 2079 callback.callback(), pool_.get(), NetLogWithSource());
2072 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 2080 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
2073 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2081 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2074 ASSERT_THAT(callback.WaitForResult(), IsOk()); 2082 ASSERT_THAT(callback.WaitForResult(), IsOk());
2075 2083
2076 // Use and release the socket. 2084 // Use and release the socket.
2077 EXPECT_EQ(1, handle.socket()->Write(NULL, 1, CompletionCallback())); 2085 EXPECT_EQ(1, handle.socket()->Write(NULL, 1, CompletionCallback()));
2078 TestLoadTimingInfoConnectedNotReused(handle); 2086 TestLoadTimingInfoConnectedNotReused(handle);
2079 handle.Reset(); 2087 handle.Reset();
2080 2088
2081 // Should now have one idle socket. 2089 // Should now have one idle socket.
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
2117 base::TimeDelta()); // Time out used sockets immediately 2125 base::TimeDelta()); // Time out used sockets immediately
2118 2126
2119 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2127 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2120 2128
2121 // Startup two mock pending connect jobs, which will sit in the MessageLoop. 2129 // Startup two mock pending connect jobs, which will sit in the MessageLoop.
2122 2130
2123 ClientSocketHandle handle; 2131 ClientSocketHandle handle;
2124 TestCompletionCallback callback; 2132 TestCompletionCallback callback;
2125 int rv = handle.Init("a", params_, LOWEST, 2133 int rv = handle.Init("a", params_, LOWEST,
2126 ClientSocketPool::RespectLimits::ENABLED, 2134 ClientSocketPool::RespectLimits::ENABLED,
2127 callback.callback(), pool_.get(), BoundNetLog()); 2135 callback.callback(), pool_.get(), NetLogWithSource());
2128 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 2136 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
2129 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2137 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2130 2138
2131 ClientSocketHandle handle2; 2139 ClientSocketHandle handle2;
2132 TestCompletionCallback callback2; 2140 TestCompletionCallback callback2;
2133 rv = handle2.Init("a", params_, LOWEST, 2141 rv = handle2.Init("a", params_, LOWEST,
2134 ClientSocketPool::RespectLimits::ENABLED, 2142 ClientSocketPool::RespectLimits::ENABLED,
2135 callback2.callback(), pool_.get(), BoundNetLog()); 2143 callback2.callback(), pool_.get(), NetLogWithSource());
2136 ASSERT_THAT(rv, IsError(ERR_IO_PENDING)); 2144 ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
2137 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); 2145 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
2138 2146
2139 // Cancel one of the requests. Wait for the other, which will get the first 2147 // Cancel one of the requests. Wait for the other, which will get the first
2140 // job. Release the socket. Run the loop again to make sure the second 2148 // job. Release the socket. Run the loop again to make sure the second
2141 // socket is sitting idle and the first one is released (since ReleaseSocket() 2149 // socket is sitting idle and the first one is released (since ReleaseSocket()
2142 // just posts a DoReleaseSocket() task). 2150 // just posts a DoReleaseSocket() task).
2143 2151
2144 handle.Reset(); 2152 handle.Reset();
2145 ASSERT_THAT(callback2.WaitForResult(), IsOk()); 2153 ASSERT_THAT(callback2.WaitForResult(), IsOk());
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
2188 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 2196 base::TimeDelta::FromDays(1)); // Don't time out used sockets.
2189 2197
2190 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 2198 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2191 2199
2192 // Startup 4 connect jobs. Two of them will be pending. 2200 // Startup 4 connect jobs. Two of them will be pending.
2193 2201
2194 ClientSocketHandle handle; 2202 ClientSocketHandle handle;
2195 TestCompletionCallback callback; 2203 TestCompletionCallback callback;
2196 int rv = handle.Init("a", params_, LOWEST, 2204 int rv = handle.Init("a", params_, LOWEST,
2197 ClientSocketPool::RespectLimits::ENABLED, 2205 ClientSocketPool::RespectLimits::ENABLED,
2198 callback.callback(), pool_.get(), BoundNetLog()); 2206 callback.callback(), pool_.get(), NetLogWithSource());
2199 EXPECT_THAT(rv, IsOk()); 2207 EXPECT_THAT(rv, IsOk());
2200 2208
2201 ClientSocketHandle handle2; 2209 ClientSocketHandle handle2;
2202 TestCompletionCallback callback2; 2210 TestCompletionCallback callback2;
2203 rv = handle2.Init("a", params_, LOWEST, 2211 rv = handle2.Init("a", params_, LOWEST,
2204 ClientSocketPool::RespectLimits::ENABLED, 2212 ClientSocketPool::RespectLimits::ENABLED,
2205 callback2.callback(), pool_.get(), BoundNetLog()); 2213 callback2.callback(), pool_.get(), NetLogWithSource());
2206 EXPECT_THAT(rv, IsOk()); 2214 EXPECT_THAT(rv, IsOk());
2207 2215
2208 ClientSocketHandle handle3; 2216 ClientSocketHandle handle3;
2209 TestCompletionCallback callback3; 2217 TestCompletionCallback callback3;
2210 rv = handle3.Init("a", params_, LOWEST, 2218 rv = handle3.Init("a", params_, LOWEST,
2211 ClientSocketPool::RespectLimits::ENABLED, 2219 ClientSocketPool::RespectLimits::ENABLED,
2212 callback3.callback(), pool_.get(), BoundNetLog()); 2220 callback3.callback(), pool_.get(), NetLogWithSource());
2213 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 2221 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2214 2222
2215 ClientSocketHandle handle4; 2223 ClientSocketHandle handle4;
2216 TestCompletionCallback callback4; 2224 TestCompletionCallback callback4;
2217 rv = handle4.Init("a", params_, LOWEST, 2225 rv = handle4.Init("a", params_, LOWEST,
2218 ClientSocketPool::RespectLimits::ENABLED, 2226 ClientSocketPool::RespectLimits::ENABLED,
2219 callback4.callback(), pool_.get(), BoundNetLog()); 2227 callback4.callback(), pool_.get(), NetLogWithSource());
2220 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 2228 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
2221 2229
2222 // Release two disconnected sockets. 2230 // Release two disconnected sockets.
2223 2231
2224 handle.socket()->Disconnect(); 2232 handle.socket()->Disconnect();
2225 handle.Reset(); 2233 handle.Reset();
2226 handle2.socket()->Disconnect(); 2234 handle2.socket()->Disconnect();
2227 handle2.Reset(); 2235 handle2.Reset();
2228 2236
2229 EXPECT_THAT(callback3.WaitForResult(), IsOk()); 2237 EXPECT_THAT(callback3.WaitForResult(), IsOk());
(...skipping 17 matching lines...) Expand all
2247 2255
2248 ClientSocketHandle handle_a[4]; 2256 ClientSocketHandle handle_a[4];
2249 TestCompletionCallback callback_a[4]; 2257 TestCompletionCallback callback_a[4];
2250 ClientSocketHandle handle_b[4]; 2258 ClientSocketHandle handle_b[4];
2251 TestCompletionCallback callback_b[4]; 2259 TestCompletionCallback callback_b[4];
2252 2260
2253 for (int i = 0; i < 2; ++i) { 2261 for (int i = 0; i < 2; ++i) {
2254 EXPECT_EQ(OK, handle_a[i].Init("a", params_, LOWEST, 2262 EXPECT_EQ(OK, handle_a[i].Init("a", params_, LOWEST,
2255 ClientSocketPool::RespectLimits::ENABLED, 2263 ClientSocketPool::RespectLimits::ENABLED,
2256 callback_a[i].callback(), pool_.get(), 2264 callback_a[i].callback(), pool_.get(),
2257 BoundNetLog())); 2265 NetLogWithSource()));
2258 EXPECT_EQ(OK, handle_b[i].Init("b", params_, LOWEST, 2266 EXPECT_EQ(OK, handle_b[i].Init("b", params_, LOWEST,
2259 ClientSocketPool::RespectLimits::ENABLED, 2267 ClientSocketPool::RespectLimits::ENABLED,
2260 callback_b[i].callback(), pool_.get(), 2268 callback_b[i].callback(), pool_.get(),
2261 BoundNetLog())); 2269 NetLogWithSource()));
2262 } 2270 }
2263 2271
2264 // Make 4 pending requests, 2 per group. 2272 // Make 4 pending requests, 2 per group.
2265 2273
2266 for (int i = 2; i < 4; ++i) { 2274 for (int i = 2; i < 4; ++i) {
2267 EXPECT_EQ( 2275 EXPECT_EQ(ERR_IO_PENDING,
2268 ERR_IO_PENDING, 2276 handle_a[i].Init("a", params_, LOWEST,
2269 handle_a[i].Init("a", params_, LOWEST, 2277 ClientSocketPool::RespectLimits::ENABLED,
2270 ClientSocketPool::RespectLimits::ENABLED, 2278 callback_a[i].callback(), pool_.get(),
2271 callback_a[i].callback(), pool_.get(), BoundNetLog())); 2279 NetLogWithSource()));
2272 EXPECT_EQ( 2280 EXPECT_EQ(ERR_IO_PENDING,
2273 ERR_IO_PENDING, 2281 handle_b[i].Init("b", params_, LOWEST,
2274 handle_b[i].Init("b", params_, LOWEST, 2282 ClientSocketPool::RespectLimits::ENABLED,
2275 ClientSocketPool::RespectLimits::ENABLED, 2283 callback_b[i].callback(), pool_.get(),
2276 callback_b[i].callback(), pool_.get(), BoundNetLog())); 2284 NetLogWithSource()));
2277 } 2285 }
2278 2286
2279 // Release b's socket first. The order is important, because in 2287 // Release b's socket first. The order is important, because in
2280 // DoReleaseSocket(), we'll process b's released socket, and since both b and 2288 // DoReleaseSocket(), we'll process b's released socket, and since both b and
2281 // a are stalled, but 'a' is lower lexicographically, we'll process group 'a' 2289 // a are stalled, but 'a' is lower lexicographically, we'll process group 'a'
2282 // first, which has a releasing socket, so it refuses to start up another 2290 // first, which has a releasing socket, so it refuses to start up another
2283 // ConnectJob. So, we used to infinite loop on this. 2291 // ConnectJob. So, we used to infinite loop on this.
2284 handle_b[0].socket()->Disconnect(); 2292 handle_b[0].socket()->Disconnect();
2285 handle_b[0].Reset(); 2293 handle_b[0].Reset();
2286 handle_a[0].socket()->Disconnect(); 2294 handle_a[0].socket()->Disconnect();
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after
2353 private: 2361 private:
2354 void OnComplete(int result) { 2362 void OnComplete(int result) {
2355 SetResult(result); 2363 SetResult(result);
2356 if (reset_releasing_handle_) 2364 if (reset_releasing_handle_)
2357 handle_.Reset(); 2365 handle_.Reset();
2358 2366
2359 scoped_refptr<TestSocketParams> con_params(new TestSocketParams()); 2367 scoped_refptr<TestSocketParams> con_params(new TestSocketParams());
2360 EXPECT_EQ(expected_result_, 2368 EXPECT_EQ(expected_result_,
2361 handle2_.Init("a", con_params, DEFAULT_PRIORITY, 2369 handle2_.Init("a", con_params, DEFAULT_PRIORITY,
2362 ClientSocketPool::RespectLimits::ENABLED, 2370 ClientSocketPool::RespectLimits::ENABLED,
2363 callback2_.callback(), pool_, BoundNetLog())); 2371 callback2_.callback(), pool_, NetLogWithSource()));
2364 } 2372 }
2365 2373
2366 TestClientSocketPool* const pool_; 2374 TestClientSocketPool* const pool_;
2367 int expected_result_; 2375 int expected_result_;
2368 bool reset_releasing_handle_; 2376 bool reset_releasing_handle_;
2369 ClientSocketHandle handle_; 2377 ClientSocketHandle handle_;
2370 ClientSocketHandle handle2_; 2378 ClientSocketHandle handle2_;
2371 CompletionCallback callback_; 2379 CompletionCallback callback_;
2372 TestCompletionCallback callback2_; 2380 TestCompletionCallback callback2_;
2373 }; 2381 };
2374 2382
2375 2383
2376 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) { 2384 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
2377 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2385 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2378 2386
2379 EXPECT_THAT(StartRequest("b", DEFAULT_PRIORITY), IsOk()); 2387 EXPECT_THAT(StartRequest("b", DEFAULT_PRIORITY), IsOk());
2380 EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk()); 2388 EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk());
2381 EXPECT_THAT(StartRequest("b", DEFAULT_PRIORITY), IsOk()); 2389 EXPECT_THAT(StartRequest("b", DEFAULT_PRIORITY), IsOk());
2382 2390
2383 EXPECT_EQ(static_cast<int>(requests_size()), 2391 EXPECT_EQ(static_cast<int>(requests_size()),
2384 client_socket_factory_.allocation_count()); 2392 client_socket_factory_.allocation_count());
2385 2393
2386 connect_job_factory_->set_job_type( 2394 connect_job_factory_->set_job_type(
2387 TestConnectJob::kMockPendingAdditionalErrorStateJob); 2395 TestConnectJob::kMockPendingAdditionalErrorStateJob);
2388 TestReleasingSocketRequest req(pool_.get(), OK, false); 2396 TestReleasingSocketRequest req(pool_.get(), OK, false);
2389 EXPECT_EQ(ERR_IO_PENDING, 2397 EXPECT_EQ(
2390 req.handle()->Init("a", params_, DEFAULT_PRIORITY, 2398 ERR_IO_PENDING,
2391 ClientSocketPool::RespectLimits::ENABLED, 2399 req.handle()->Init("a", params_, DEFAULT_PRIORITY,
2392 req.callback(), pool_.get(), BoundNetLog())); 2400 ClientSocketPool::RespectLimits::ENABLED,
2401 req.callback(), pool_.get(), NetLogWithSource()));
2393 // The next job should complete synchronously 2402 // The next job should complete synchronously
2394 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 2403 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2395 2404
2396 EXPECT_THAT(req.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); 2405 EXPECT_THAT(req.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
2397 EXPECT_FALSE(req.handle()->is_initialized()); 2406 EXPECT_FALSE(req.handle()->is_initialized());
2398 EXPECT_FALSE(req.handle()->socket()); 2407 EXPECT_FALSE(req.handle()->socket());
2399 EXPECT_TRUE(req.handle()->is_ssl_error()); 2408 EXPECT_TRUE(req.handle()->is_ssl_error());
2400 EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL); 2409 EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL);
2401 } 2410 }
2402 2411
2403 // http://crbug.com/44724 regression test. 2412 // http://crbug.com/44724 regression test.
2404 // We start releasing the pool when we flush on network change. When that 2413 // We start releasing the pool when we flush on network change. When that
2405 // happens, the only active references are in the ClientSocketHandles. When a 2414 // happens, the only active references are in the ClientSocketHandles. When a
2406 // ConnectJob completes and calls back into the last ClientSocketHandle, that 2415 // ConnectJob completes and calls back into the last ClientSocketHandle, that
2407 // callback can release the last reference and delete the pool. After the 2416 // callback can release the last reference and delete the pool. After the
2408 // callback finishes, we go back to the stack frame within the now-deleted pool. 2417 // callback finishes, we go back to the stack frame within the now-deleted pool.
2409 // Executing any code that refers to members of the now-deleted pool can cause 2418 // Executing any code that refers to members of the now-deleted pool can cause
2410 // crashes. 2419 // crashes.
2411 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) { 2420 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
2412 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2421 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2413 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 2422 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
2414 2423
2415 ClientSocketHandle handle; 2424 ClientSocketHandle handle;
2416 TestCompletionCallback callback; 2425 TestCompletionCallback callback;
2417 EXPECT_EQ(ERR_IO_PENDING, 2426 EXPECT_EQ(ERR_IO_PENDING,
2418 handle.Init("a", params_, DEFAULT_PRIORITY, 2427 handle.Init("a", params_, DEFAULT_PRIORITY,
2419 ClientSocketPool::RespectLimits::ENABLED, 2428 ClientSocketPool::RespectLimits::ENABLED,
2420 callback.callback(), pool_.get(), BoundNetLog())); 2429 callback.callback(), pool_.get(), NetLogWithSource()));
2421 2430
2422 pool_->FlushWithError(ERR_NETWORK_CHANGED); 2431 pool_->FlushWithError(ERR_NETWORK_CHANGED);
2423 2432
2424 // We'll call back into this now. 2433 // We'll call back into this now.
2425 callback.WaitForResult(); 2434 callback.WaitForResult();
2426 } 2435 }
2427 2436
2428 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) { 2437 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
2429 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2438 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2430 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2439 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2431 2440
2432 ClientSocketHandle handle; 2441 ClientSocketHandle handle;
2433 TestCompletionCallback callback; 2442 TestCompletionCallback callback;
2434 EXPECT_EQ(ERR_IO_PENDING, 2443 EXPECT_EQ(ERR_IO_PENDING,
2435 handle.Init("a", params_, DEFAULT_PRIORITY, 2444 handle.Init("a", params_, DEFAULT_PRIORITY,
2436 ClientSocketPool::RespectLimits::ENABLED, 2445 ClientSocketPool::RespectLimits::ENABLED,
2437 callback.callback(), pool_.get(), BoundNetLog())); 2446 callback.callback(), pool_.get(), NetLogWithSource()));
2438 EXPECT_THAT(callback.WaitForResult(), IsOk()); 2447 EXPECT_THAT(callback.WaitForResult(), IsOk());
2439 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); 2448 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
2440 2449
2441 pool_->FlushWithError(ERR_NETWORK_CHANGED); 2450 pool_->FlushWithError(ERR_NETWORK_CHANGED);
2442 2451
2443 handle.Reset(); 2452 handle.Reset();
2444 base::RunLoop().RunUntilIdle(); 2453 base::RunLoop().RunUntilIdle();
2445 2454
2446 EXPECT_EQ(ERR_IO_PENDING, 2455 EXPECT_EQ(ERR_IO_PENDING,
2447 handle.Init("a", params_, DEFAULT_PRIORITY, 2456 handle.Init("a", params_, DEFAULT_PRIORITY,
2448 ClientSocketPool::RespectLimits::ENABLED, 2457 ClientSocketPool::RespectLimits::ENABLED,
2449 callback.callback(), pool_.get(), BoundNetLog())); 2458 callback.callback(), pool_.get(), NetLogWithSource()));
2450 EXPECT_THAT(callback.WaitForResult(), IsOk()); 2459 EXPECT_THAT(callback.WaitForResult(), IsOk());
2451 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type()); 2460 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
2452 } 2461 }
2453 2462
2454 class ConnectWithinCallback : public TestCompletionCallbackBase { 2463 class ConnectWithinCallback : public TestCompletionCallbackBase {
2455 public: 2464 public:
2456 ConnectWithinCallback( 2465 ConnectWithinCallback(
2457 const std::string& group_name, 2466 const std::string& group_name,
2458 const scoped_refptr<TestSocketParams>& params, 2467 const scoped_refptr<TestSocketParams>& params,
2459 TestClientSocketPool* pool) 2468 TestClientSocketPool* pool)
2460 : group_name_(group_name), 2469 : group_name_(group_name),
2461 params_(params), 2470 params_(params),
2462 pool_(pool), 2471 pool_(pool),
2463 callback_(base::Bind(&ConnectWithinCallback::OnComplete, 2472 callback_(base::Bind(&ConnectWithinCallback::OnComplete,
2464 base::Unretained(this))) { 2473 base::Unretained(this))) {
2465 } 2474 }
2466 2475
2467 ~ConnectWithinCallback() override {} 2476 ~ConnectWithinCallback() override {}
2468 2477
2469 int WaitForNestedResult() { 2478 int WaitForNestedResult() {
2470 return nested_callback_.WaitForResult(); 2479 return nested_callback_.WaitForResult();
2471 } 2480 }
2472 2481
2473 const CompletionCallback& callback() const { return callback_; } 2482 const CompletionCallback& callback() const { return callback_; }
2474 2483
2475 private: 2484 private:
2476 void OnComplete(int result) { 2485 void OnComplete(int result) {
2477 SetResult(result); 2486 SetResult(result);
2478 EXPECT_EQ(ERR_IO_PENDING, 2487 EXPECT_EQ(
2479 handle_.Init(group_name_, params_, DEFAULT_PRIORITY, 2488 ERR_IO_PENDING,
2480 ClientSocketPool::RespectLimits::ENABLED, 2489 handle_.Init(group_name_, params_, DEFAULT_PRIORITY,
2481 nested_callback_.callback(), pool_, BoundNetLog())); 2490 ClientSocketPool::RespectLimits::ENABLED,
2491 nested_callback_.callback(), pool_, NetLogWithSource()));
2482 } 2492 }
2483 2493
2484 const std::string group_name_; 2494 const std::string group_name_;
2485 const scoped_refptr<TestSocketParams> params_; 2495 const scoped_refptr<TestSocketParams> params_;
2486 TestClientSocketPool* const pool_; 2496 TestClientSocketPool* const pool_;
2487 ClientSocketHandle handle_; 2497 ClientSocketHandle handle_;
2488 CompletionCallback callback_; 2498 CompletionCallback callback_;
2489 TestCompletionCallback nested_callback_; 2499 TestCompletionCallback nested_callback_;
2490 2500
2491 DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback); 2501 DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback);
2492 }; 2502 };
2493 2503
2494 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) { 2504 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
2495 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2505 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2496 2506
2497 // First job will be waiting until it gets aborted. 2507 // First job will be waiting until it gets aborted.
2498 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2508 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2499 2509
2500 ClientSocketHandle handle; 2510 ClientSocketHandle handle;
2501 ConnectWithinCallback callback("a", params_, pool_.get()); 2511 ConnectWithinCallback callback("a", params_, pool_.get());
2502 EXPECT_EQ(ERR_IO_PENDING, 2512 EXPECT_EQ(ERR_IO_PENDING,
2503 handle.Init("a", params_, DEFAULT_PRIORITY, 2513 handle.Init("a", params_, DEFAULT_PRIORITY,
2504 ClientSocketPool::RespectLimits::ENABLED, 2514 ClientSocketPool::RespectLimits::ENABLED,
2505 callback.callback(), pool_.get(), BoundNetLog())); 2515 callback.callback(), pool_.get(), NetLogWithSource()));
2506 2516
2507 // Second job will be started during the first callback, and will 2517 // Second job will be started during the first callback, and will
2508 // asynchronously complete with OK. 2518 // asynchronously complete with OK.
2509 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2519 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2510 pool_->FlushWithError(ERR_NETWORK_CHANGED); 2520 pool_->FlushWithError(ERR_NETWORK_CHANGED);
2511 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NETWORK_CHANGED)); 2521 EXPECT_THAT(callback.WaitForResult(), IsError(ERR_NETWORK_CHANGED));
2512 EXPECT_THAT(callback.WaitForNestedResult(), IsOk()); 2522 EXPECT_THAT(callback.WaitForNestedResult(), IsOk());
2513 } 2523 }
2514 2524
2515 // Cancel a pending socket request while we're at max sockets, 2525 // Cancel a pending socket request while we're at max sockets,
2516 // and verify that the backup socket firing doesn't cause a crash. 2526 // and verify that the backup socket firing doesn't cause a crash.
2517 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) { 2527 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
2518 // Max 4 sockets globally, max 4 sockets per group. 2528 // Max 4 sockets globally, max 4 sockets per group.
2519 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 2529 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2520 pool_->EnableConnectBackupJobs(); 2530 pool_->EnableConnectBackupJobs();
2521 2531
2522 // Create the first socket and set to ERR_IO_PENDING. This starts the backup 2532 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
2523 // timer. 2533 // timer.
2524 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2534 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2525 ClientSocketHandle handle; 2535 ClientSocketHandle handle;
2526 TestCompletionCallback callback; 2536 TestCompletionCallback callback;
2527 EXPECT_EQ(ERR_IO_PENDING, 2537 EXPECT_EQ(ERR_IO_PENDING,
2528 handle.Init("bar", params_, DEFAULT_PRIORITY, 2538 handle.Init("bar", params_, DEFAULT_PRIORITY,
2529 ClientSocketPool::RespectLimits::ENABLED, 2539 ClientSocketPool::RespectLimits::ENABLED,
2530 callback.callback(), pool_.get(), BoundNetLog())); 2540 callback.callback(), pool_.get(), NetLogWithSource()));
2531 2541
2532 // Start (MaxSockets - 1) connected sockets to reach max sockets. 2542 // Start (MaxSockets - 1) connected sockets to reach max sockets.
2533 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 2543 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2534 ClientSocketHandle handles[kDefaultMaxSockets]; 2544 ClientSocketHandle handles[kDefaultMaxSockets];
2535 for (int i = 1; i < kDefaultMaxSockets; ++i) { 2545 for (int i = 1; i < kDefaultMaxSockets; ++i) {
2536 TestCompletionCallback callback; 2546 TestCompletionCallback callback;
2537 EXPECT_EQ(OK, 2547 EXPECT_EQ(OK, handles[i].Init("bar", params_, DEFAULT_PRIORITY,
2538 handles[i].Init("bar", params_, DEFAULT_PRIORITY, 2548 ClientSocketPool::RespectLimits::ENABLED,
2539 ClientSocketPool::RespectLimits::ENABLED, 2549 callback.callback(), pool_.get(),
2540 callback.callback(), pool_.get(), BoundNetLog())); 2550 NetLogWithSource()));
2541 } 2551 }
2542 2552
2543 base::RunLoop().RunUntilIdle(); 2553 base::RunLoop().RunUntilIdle();
2544 2554
2545 // Cancel the pending request. 2555 // Cancel the pending request.
2546 handle.Reset(); 2556 handle.Reset();
2547 2557
2548 // Wait for the backup timer to fire (add some slop to ensure it fires) 2558 // Wait for the backup timer to fire (add some slop to ensure it fires)
2549 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 2559 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2550 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3)); 2560 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2551 2561
2552 base::RunLoop().RunUntilIdle(); 2562 base::RunLoop().RunUntilIdle();
2553 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 2563 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
2554 } 2564 }
2555 2565
2556 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) { 2566 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
2557 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 2567 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2558 pool_->EnableConnectBackupJobs(); 2568 pool_->EnableConnectBackupJobs();
2559 2569
2560 // Create the first socket and set to ERR_IO_PENDING. This starts the backup 2570 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
2561 // timer. 2571 // timer.
2562 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2572 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2563 ClientSocketHandle handle; 2573 ClientSocketHandle handle;
2564 TestCompletionCallback callback; 2574 TestCompletionCallback callback;
2565 EXPECT_EQ(ERR_IO_PENDING, 2575 EXPECT_EQ(ERR_IO_PENDING,
2566 handle.Init("bar", params_, DEFAULT_PRIORITY, 2576 handle.Init("bar", params_, DEFAULT_PRIORITY,
2567 ClientSocketPool::RespectLimits::ENABLED, 2577 ClientSocketPool::RespectLimits::ENABLED,
2568 callback.callback(), pool_.get(), BoundNetLog())); 2578 callback.callback(), pool_.get(), NetLogWithSource()));
2569 ASSERT_TRUE(pool_->HasGroup("bar")); 2579 ASSERT_TRUE(pool_->HasGroup("bar"));
2570 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar")); 2580 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
2571 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar")); 2581 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar"));
2572 2582
2573 // Cancel the socket request. This should cancel the backup timer. Wait for 2583 // Cancel the socket request. This should cancel the backup timer. Wait for
2574 // the backup time to see if it indeed got canceled. 2584 // the backup time to see if it indeed got canceled.
2575 handle.Reset(); 2585 handle.Reset();
2576 // Wait for the backup timer to fire (add some slop to ensure it fires) 2586 // Wait for the backup timer to fire (add some slop to ensure it fires)
2577 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 2587 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2578 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3)); 2588 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2579 base::RunLoop().RunUntilIdle(); 2589 base::RunLoop().RunUntilIdle();
2580 ASSERT_TRUE(pool_->HasGroup("bar")); 2590 ASSERT_TRUE(pool_->HasGroup("bar"));
2581 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar")); 2591 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
2582 } 2592 }
2583 2593
2584 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) { 2594 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
2585 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 2595 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2586 pool_->EnableConnectBackupJobs(); 2596 pool_->EnableConnectBackupJobs();
2587 2597
2588 // Create the first socket and set to ERR_IO_PENDING. This starts the backup 2598 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
2589 // timer. 2599 // timer.
2590 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2600 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2591 ClientSocketHandle handle; 2601 ClientSocketHandle handle;
2592 TestCompletionCallback callback; 2602 TestCompletionCallback callback;
2593 EXPECT_EQ(ERR_IO_PENDING, 2603 EXPECT_EQ(ERR_IO_PENDING,
2594 handle.Init("bar", params_, DEFAULT_PRIORITY, 2604 handle.Init("bar", params_, DEFAULT_PRIORITY,
2595 ClientSocketPool::RespectLimits::ENABLED, 2605 ClientSocketPool::RespectLimits::ENABLED,
2596 callback.callback(), pool_.get(), BoundNetLog())); 2606 callback.callback(), pool_.get(), NetLogWithSource()));
2597 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2607 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2598 ClientSocketHandle handle2; 2608 ClientSocketHandle handle2;
2599 TestCompletionCallback callback2; 2609 TestCompletionCallback callback2;
2600 EXPECT_EQ(ERR_IO_PENDING, 2610 EXPECT_EQ(
2601 handle2.Init("bar", params_, DEFAULT_PRIORITY, 2611 ERR_IO_PENDING,
2602 ClientSocketPool::RespectLimits::ENABLED, 2612 handle2.Init("bar", params_, DEFAULT_PRIORITY,
2603 callback2.callback(), pool_.get(), BoundNetLog())); 2613 ClientSocketPool::RespectLimits::ENABLED,
2614 callback2.callback(), pool_.get(), NetLogWithSource()));
2604 ASSERT_TRUE(pool_->HasGroup("bar")); 2615 ASSERT_TRUE(pool_->HasGroup("bar"));
2605 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar")); 2616 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
2606 2617
2607 // Cancel request 1 and then complete request 2. With the requests finished, 2618 // Cancel request 1 and then complete request 2. With the requests finished,
2608 // the backup timer should be cancelled. 2619 // the backup timer should be cancelled.
2609 handle.Reset(); 2620 handle.Reset();
2610 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 2621 EXPECT_THAT(callback2.WaitForResult(), IsOk());
2611 // Wait for the backup timer to fire (add some slop to ensure it fires) 2622 // Wait for the backup timer to fire (add some slop to ensure it fires)
2612 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 2623 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2613 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3)); 2624 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2614 base::RunLoop().RunUntilIdle(); 2625 base::RunLoop().RunUntilIdle();
2615 } 2626 }
2616 2627
2617 // Test delayed socket binding for the case where we have two connects, 2628 // Test delayed socket binding for the case where we have two connects,
2618 // and while one is waiting on a connect, the other frees up. 2629 // and while one is waiting on a connect, the other frees up.
2619 // The socket waiting on a connect should switch immediately to the freed 2630 // The socket waiting on a connect should switch immediately to the freed
2620 // up socket. 2631 // up socket.
2621 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) { 2632 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
2622 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2633 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2623 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2634 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2624 2635
2625 ClientSocketHandle handle1; 2636 ClientSocketHandle handle1;
2626 TestCompletionCallback callback; 2637 TestCompletionCallback callback;
2627 EXPECT_EQ(ERR_IO_PENDING, 2638 EXPECT_EQ(ERR_IO_PENDING,
2628 handle1.Init("a", params_, DEFAULT_PRIORITY, 2639 handle1.Init("a", params_, DEFAULT_PRIORITY,
2629 ClientSocketPool::RespectLimits::ENABLED, 2640 ClientSocketPool::RespectLimits::ENABLED,
2630 callback.callback(), pool_.get(), BoundNetLog())); 2641 callback.callback(), pool_.get(), NetLogWithSource()));
2631 EXPECT_THAT(callback.WaitForResult(), IsOk()); 2642 EXPECT_THAT(callback.WaitForResult(), IsOk());
2632 2643
2633 // No idle sockets, no pending jobs. 2644 // No idle sockets, no pending jobs.
2634 EXPECT_EQ(0, pool_->IdleSocketCount()); 2645 EXPECT_EQ(0, pool_->IdleSocketCount());
2635 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 2646 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2636 2647
2637 // Create a second socket to the same host, but this one will wait. 2648 // Create a second socket to the same host, but this one will wait.
2638 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2649 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2639 ClientSocketHandle handle2; 2650 ClientSocketHandle handle2;
2640 EXPECT_EQ(ERR_IO_PENDING, 2651 EXPECT_EQ(ERR_IO_PENDING,
2641 handle2.Init("a", params_, DEFAULT_PRIORITY, 2652 handle2.Init("a", params_, DEFAULT_PRIORITY,
2642 ClientSocketPool::RespectLimits::ENABLED, 2653 ClientSocketPool::RespectLimits::ENABLED,
2643 callback.callback(), pool_.get(), BoundNetLog())); 2654 callback.callback(), pool_.get(), NetLogWithSource()));
2644 // No idle sockets, and one connecting job. 2655 // No idle sockets, and one connecting job.
2645 EXPECT_EQ(0, pool_->IdleSocketCount()); 2656 EXPECT_EQ(0, pool_->IdleSocketCount());
2646 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 2657 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2647 2658
2648 // Return the first handle to the pool. This will initiate the delayed 2659 // Return the first handle to the pool. This will initiate the delayed
2649 // binding. 2660 // binding.
2650 handle1.Reset(); 2661 handle1.Reset();
2651 2662
2652 base::RunLoop().RunUntilIdle(); 2663 base::RunLoop().RunUntilIdle();
2653 2664
(...skipping 18 matching lines...) Expand all
2672 // of the group's sockets frees up. 2683 // of the group's sockets frees up.
2673 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) { 2684 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
2674 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2685 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2675 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2686 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2676 2687
2677 ClientSocketHandle handle1; 2688 ClientSocketHandle handle1;
2678 TestCompletionCallback callback; 2689 TestCompletionCallback callback;
2679 EXPECT_EQ(ERR_IO_PENDING, 2690 EXPECT_EQ(ERR_IO_PENDING,
2680 handle1.Init("a", params_, DEFAULT_PRIORITY, 2691 handle1.Init("a", params_, DEFAULT_PRIORITY,
2681 ClientSocketPool::RespectLimits::ENABLED, 2692 ClientSocketPool::RespectLimits::ENABLED,
2682 callback.callback(), pool_.get(), BoundNetLog())); 2693 callback.callback(), pool_.get(), NetLogWithSource()));
2683 EXPECT_THAT(callback.WaitForResult(), IsOk()); 2694 EXPECT_THAT(callback.WaitForResult(), IsOk());
2684 2695
2685 // No idle sockets, no pending jobs. 2696 // No idle sockets, no pending jobs.
2686 EXPECT_EQ(0, pool_->IdleSocketCount()); 2697 EXPECT_EQ(0, pool_->IdleSocketCount());
2687 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 2698 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2688 2699
2689 // Create a second socket to the same host, but this one will wait. 2700 // Create a second socket to the same host, but this one will wait.
2690 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2701 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2691 ClientSocketHandle handle2; 2702 ClientSocketHandle handle2;
2692 EXPECT_EQ(ERR_IO_PENDING, 2703 EXPECT_EQ(ERR_IO_PENDING,
2693 handle2.Init("a", params_, DEFAULT_PRIORITY, 2704 handle2.Init("a", params_, DEFAULT_PRIORITY,
2694 ClientSocketPool::RespectLimits::ENABLED, 2705 ClientSocketPool::RespectLimits::ENABLED,
2695 callback.callback(), pool_.get(), BoundNetLog())); 2706 callback.callback(), pool_.get(), NetLogWithSource()));
2696 // No idle sockets, and one connecting job. 2707 // No idle sockets, and one connecting job.
2697 EXPECT_EQ(0, pool_->IdleSocketCount()); 2708 EXPECT_EQ(0, pool_->IdleSocketCount());
2698 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 2709 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2699 2710
2700 // Return the first handle to the pool. This will initiate the delayed 2711 // Return the first handle to the pool. This will initiate the delayed
2701 // binding. 2712 // binding.
2702 handle1.Reset(); 2713 handle1.Reset();
2703 2714
2704 base::RunLoop().RunUntilIdle(); 2715 base::RunLoop().RunUntilIdle();
2705 2716
(...skipping 20 matching lines...) Expand all
2726 // should complete, by taking the first socket's idle socket. 2737 // should complete, by taking the first socket's idle socket.
2727 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) { 2738 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
2728 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2739 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2729 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2740 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2730 2741
2731 ClientSocketHandle handle1; 2742 ClientSocketHandle handle1;
2732 TestCompletionCallback callback; 2743 TestCompletionCallback callback;
2733 EXPECT_EQ(ERR_IO_PENDING, 2744 EXPECT_EQ(ERR_IO_PENDING,
2734 handle1.Init("a", params_, DEFAULT_PRIORITY, 2745 handle1.Init("a", params_, DEFAULT_PRIORITY,
2735 ClientSocketPool::RespectLimits::ENABLED, 2746 ClientSocketPool::RespectLimits::ENABLED,
2736 callback.callback(), pool_.get(), BoundNetLog())); 2747 callback.callback(), pool_.get(), NetLogWithSource()));
2737 EXPECT_THAT(callback.WaitForResult(), IsOk()); 2748 EXPECT_THAT(callback.WaitForResult(), IsOk());
2738 2749
2739 // No idle sockets, no pending jobs. 2750 // No idle sockets, no pending jobs.
2740 EXPECT_EQ(0, pool_->IdleSocketCount()); 2751 EXPECT_EQ(0, pool_->IdleSocketCount());
2741 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 2752 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2742 2753
2743 // Create a second socket to the same host, but this one will wait. 2754 // Create a second socket to the same host, but this one will wait.
2744 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2755 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2745 ClientSocketHandle handle2; 2756 ClientSocketHandle handle2;
2746 EXPECT_EQ(ERR_IO_PENDING, 2757 EXPECT_EQ(ERR_IO_PENDING,
2747 handle2.Init("a", params_, DEFAULT_PRIORITY, 2758 handle2.Init("a", params_, DEFAULT_PRIORITY,
2748 ClientSocketPool::RespectLimits::ENABLED, 2759 ClientSocketPool::RespectLimits::ENABLED,
2749 callback.callback(), pool_.get(), BoundNetLog())); 2760 callback.callback(), pool_.get(), NetLogWithSource()));
2750 // No idle sockets, and one connecting job. 2761 // No idle sockets, and one connecting job.
2751 EXPECT_EQ(0, pool_->IdleSocketCount()); 2762 EXPECT_EQ(0, pool_->IdleSocketCount());
2752 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 2763 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2753 2764
2754 // Return the first handle to the pool. This will initiate the delayed 2765 // Return the first handle to the pool. This will initiate the delayed
2755 // binding. 2766 // binding.
2756 handle1.Reset(); 2767 handle1.Reset();
2757 2768
2758 base::RunLoop().RunUntilIdle(); 2769 base::RunLoop().RunUntilIdle();
2759 2770
(...skipping 20 matching lines...) Expand all
2780 const int kUnlimitedSockets = 100; 2791 const int kUnlimitedSockets = 100;
2781 const int kOneSocketPerGroup = 1; 2792 const int kOneSocketPerGroup = 1;
2782 CreatePool(kUnlimitedSockets, kOneSocketPerGroup); 2793 CreatePool(kUnlimitedSockets, kOneSocketPerGroup);
2783 2794
2784 // Make the first request asynchronous fail. 2795 // Make the first request asynchronous fail.
2785 // This will free up a socket slot later. 2796 // This will free up a socket slot later.
2786 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 2797 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
2787 2798
2788 ClientSocketHandle handle1; 2799 ClientSocketHandle handle1;
2789 TestCompletionCallback callback1; 2800 TestCompletionCallback callback1;
2790 EXPECT_EQ(ERR_IO_PENDING, 2801 EXPECT_EQ(
2791 handle1.Init("a", params_, DEFAULT_PRIORITY, 2802 ERR_IO_PENDING,
2792 ClientSocketPool::RespectLimits::ENABLED, 2803 handle1.Init("a", params_, DEFAULT_PRIORITY,
2793 callback1.callback(), pool_.get(), BoundNetLog())); 2804 ClientSocketPool::RespectLimits::ENABLED,
2805 callback1.callback(), pool_.get(), NetLogWithSource()));
2794 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 2806 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2795 2807
2796 // Make the second request synchronously fail. This should make the Group 2808 // Make the second request synchronously fail. This should make the Group
2797 // empty. 2809 // empty.
2798 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); 2810 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
2799 ClientSocketHandle handle2; 2811 ClientSocketHandle handle2;
2800 TestCompletionCallback callback2; 2812 TestCompletionCallback callback2;
2801 // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail 2813 // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail
2802 // when created. 2814 // when created.
2803 EXPECT_EQ(ERR_IO_PENDING, 2815 EXPECT_EQ(
2804 handle2.Init("a", params_, DEFAULT_PRIORITY, 2816 ERR_IO_PENDING,
2805 ClientSocketPool::RespectLimits::ENABLED, 2817 handle2.Init("a", params_, DEFAULT_PRIORITY,
2806 callback2.callback(), pool_.get(), BoundNetLog())); 2818 ClientSocketPool::RespectLimits::ENABLED,
2819 callback2.callback(), pool_.get(), NetLogWithSource()));
2807 2820
2808 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 2821 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2809 2822
2810 EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); 2823 EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
2811 EXPECT_THAT(callback2.WaitForResult(), IsError(ERR_CONNECTION_FAILED)); 2824 EXPECT_THAT(callback2.WaitForResult(), IsError(ERR_CONNECTION_FAILED));
2812 EXPECT_FALSE(pool_->HasGroup("a")); 2825 EXPECT_FALSE(pool_->HasGroup("a"));
2813 } 2826 }
2814 2827
2815 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) { 2828 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
2816 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 2829 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2817 2830
2818 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2831 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2819 2832
2820 ClientSocketHandle handle1; 2833 ClientSocketHandle handle1;
2821 TestCompletionCallback callback1; 2834 TestCompletionCallback callback1;
2822 EXPECT_EQ(ERR_IO_PENDING, 2835 EXPECT_EQ(
2823 handle1.Init("a", params_, DEFAULT_PRIORITY, 2836 ERR_IO_PENDING,
2824 ClientSocketPool::RespectLimits::ENABLED, 2837 handle1.Init("a", params_, DEFAULT_PRIORITY,
2825 callback1.callback(), pool_.get(), BoundNetLog())); 2838 ClientSocketPool::RespectLimits::ENABLED,
2839 callback1.callback(), pool_.get(), NetLogWithSource()));
2826 2840
2827 ClientSocketHandle handle2; 2841 ClientSocketHandle handle2;
2828 TestCompletionCallback callback2; 2842 TestCompletionCallback callback2;
2829 EXPECT_EQ(ERR_IO_PENDING, 2843 EXPECT_EQ(
2830 handle2.Init("a", params_, DEFAULT_PRIORITY, 2844 ERR_IO_PENDING,
2831 ClientSocketPool::RespectLimits::ENABLED, 2845 handle2.Init("a", params_, DEFAULT_PRIORITY,
2832 callback2.callback(), pool_.get(), BoundNetLog())); 2846 ClientSocketPool::RespectLimits::ENABLED,
2847 callback2.callback(), pool_.get(), NetLogWithSource()));
2833 ClientSocketHandle handle3; 2848 ClientSocketHandle handle3;
2834 TestCompletionCallback callback3; 2849 TestCompletionCallback callback3;
2835 EXPECT_EQ(ERR_IO_PENDING, 2850 EXPECT_EQ(
2836 handle3.Init("a", params_, DEFAULT_PRIORITY, 2851 ERR_IO_PENDING,
2837 ClientSocketPool::RespectLimits::ENABLED, 2852 handle3.Init("a", params_, DEFAULT_PRIORITY,
2838 callback3.callback(), pool_.get(), BoundNetLog())); 2853 ClientSocketPool::RespectLimits::ENABLED,
2854 callback3.callback(), pool_.get(), NetLogWithSource()));
2839 2855
2840 EXPECT_THAT(callback1.WaitForResult(), IsOk()); 2856 EXPECT_THAT(callback1.WaitForResult(), IsOk());
2841 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 2857 EXPECT_THAT(callback2.WaitForResult(), IsOk());
2842 EXPECT_THAT(callback3.WaitForResult(), IsOk()); 2858 EXPECT_THAT(callback3.WaitForResult(), IsOk());
2843 2859
2844 // Use the socket. 2860 // Use the socket.
2845 EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback())); 2861 EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback()));
2846 EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback())); 2862 EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback()));
2847 2863
2848 handle1.Reset(); 2864 handle1.Reset();
2849 handle2.Reset(); 2865 handle2.Reset();
2850 handle3.Reset(); 2866 handle3.Reset();
2851 2867
2852 EXPECT_EQ(OK, handle1.Init("a", params_, DEFAULT_PRIORITY, 2868 EXPECT_EQ(
2853 ClientSocketPool::RespectLimits::ENABLED, 2869 OK, handle1.Init("a", params_, DEFAULT_PRIORITY,
2854 callback1.callback(), pool_.get(), BoundNetLog())); 2870 ClientSocketPool::RespectLimits::ENABLED,
2855 EXPECT_EQ(OK, handle2.Init("a", params_, DEFAULT_PRIORITY, 2871 callback1.callback(), pool_.get(), NetLogWithSource()));
2856 ClientSocketPool::RespectLimits::ENABLED, 2872 EXPECT_EQ(
2857 callback2.callback(), pool_.get(), BoundNetLog())); 2873 OK, handle2.Init("a", params_, DEFAULT_PRIORITY,
2858 EXPECT_EQ(OK, handle3.Init("a", params_, DEFAULT_PRIORITY, 2874 ClientSocketPool::RespectLimits::ENABLED,
2859 ClientSocketPool::RespectLimits::ENABLED, 2875 callback2.callback(), pool_.get(), NetLogWithSource()));
2860 callback3.callback(), pool_.get(), BoundNetLog())); 2876 EXPECT_EQ(
2877 OK, handle3.Init("a", params_, DEFAULT_PRIORITY,
2878 ClientSocketPool::RespectLimits::ENABLED,
2879 callback3.callback(), pool_.get(), NetLogWithSource()));
2861 2880
2862 EXPECT_TRUE(handle1.socket()->WasEverUsed()); 2881 EXPECT_TRUE(handle1.socket()->WasEverUsed());
2863 EXPECT_TRUE(handle2.socket()->WasEverUsed()); 2882 EXPECT_TRUE(handle2.socket()->WasEverUsed());
2864 EXPECT_FALSE(handle3.socket()->WasEverUsed()); 2883 EXPECT_FALSE(handle3.socket()->WasEverUsed());
2865 } 2884 }
2866 2885
2867 TEST_F(ClientSocketPoolBaseTest, RequestSockets) { 2886 TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
2868 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2887 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2869 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2888 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2870 2889
2871 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 2890 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
2872 2891
2873 ASSERT_TRUE(pool_->HasGroup("a")); 2892 ASSERT_TRUE(pool_->HasGroup("a"));
2874 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); 2893 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
2875 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a")); 2894 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
2876 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 2895 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2877 2896
2878 ClientSocketHandle handle1; 2897 ClientSocketHandle handle1;
2879 TestCompletionCallback callback1; 2898 TestCompletionCallback callback1;
2880 EXPECT_EQ(ERR_IO_PENDING, 2899 EXPECT_EQ(
2881 handle1.Init("a", params_, DEFAULT_PRIORITY, 2900 ERR_IO_PENDING,
2882 ClientSocketPool::RespectLimits::ENABLED, 2901 handle1.Init("a", params_, DEFAULT_PRIORITY,
2883 callback1.callback(), pool_.get(), BoundNetLog())); 2902 ClientSocketPool::RespectLimits::ENABLED,
2903 callback1.callback(), pool_.get(), NetLogWithSource()));
2884 2904
2885 ClientSocketHandle handle2; 2905 ClientSocketHandle handle2;
2886 TestCompletionCallback callback2; 2906 TestCompletionCallback callback2;
2887 EXPECT_EQ(ERR_IO_PENDING, 2907 EXPECT_EQ(
2888 handle2.Init("a", params_, DEFAULT_PRIORITY, 2908 ERR_IO_PENDING,
2889 ClientSocketPool::RespectLimits::ENABLED, 2909 handle2.Init("a", params_, DEFAULT_PRIORITY,
2890 callback2.callback(), pool_.get(), BoundNetLog())); 2910 ClientSocketPool::RespectLimits::ENABLED,
2911 callback2.callback(), pool_.get(), NetLogWithSource()));
2891 2912
2892 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); 2913 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
2893 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 2914 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2894 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 2915 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2895 2916
2896 EXPECT_THAT(callback1.WaitForResult(), IsOk()); 2917 EXPECT_THAT(callback1.WaitForResult(), IsOk());
2897 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 2918 EXPECT_THAT(callback2.WaitForResult(), IsOk());
2898 handle1.Reset(); 2919 handle1.Reset();
2899 handle2.Reset(); 2920 handle2.Reset();
2900 2921
2901 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 2922 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2902 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 2923 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2903 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); 2924 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
2904 } 2925 }
2905 2926
2906 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) { 2927 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
2907 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2928 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2908 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2929 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2909 2930
2910 ClientSocketHandle handle1; 2931 ClientSocketHandle handle1;
2911 TestCompletionCallback callback1; 2932 TestCompletionCallback callback1;
2912 EXPECT_EQ(ERR_IO_PENDING, 2933 EXPECT_EQ(
2913 handle1.Init("a", params_, DEFAULT_PRIORITY, 2934 ERR_IO_PENDING,
2914 ClientSocketPool::RespectLimits::ENABLED, 2935 handle1.Init("a", params_, DEFAULT_PRIORITY,
2915 callback1.callback(), pool_.get(), BoundNetLog())); 2936 ClientSocketPool::RespectLimits::ENABLED,
2937 callback1.callback(), pool_.get(), NetLogWithSource()));
2916 2938
2917 ASSERT_TRUE(pool_->HasGroup("a")); 2939 ASSERT_TRUE(pool_->HasGroup("a"));
2918 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 2940 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2919 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 2941 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2920 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 2942 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2921 2943
2922 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 2944 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
2923 2945
2924 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); 2946 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
2925 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 2947 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
2926 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 2948 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2927 2949
2928 ClientSocketHandle handle2; 2950 ClientSocketHandle handle2;
2929 TestCompletionCallback callback2; 2951 TestCompletionCallback callback2;
2930 EXPECT_EQ(ERR_IO_PENDING, 2952 EXPECT_EQ(
2931 handle2.Init("a", params_, DEFAULT_PRIORITY, 2953 ERR_IO_PENDING,
2932 ClientSocketPool::RespectLimits::ENABLED, 2954 handle2.Init("a", params_, DEFAULT_PRIORITY,
2933 callback2.callback(), pool_.get(), BoundNetLog())); 2955 ClientSocketPool::RespectLimits::ENABLED,
2956 callback2.callback(), pool_.get(), NetLogWithSource()));
2934 2957
2935 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); 2958 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
2936 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 2959 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2937 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 2960 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2938 2961
2939 EXPECT_THAT(callback1.WaitForResult(), IsOk()); 2962 EXPECT_THAT(callback1.WaitForResult(), IsOk());
2940 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 2963 EXPECT_THAT(callback2.WaitForResult(), IsOk());
2941 handle1.Reset(); 2964 handle1.Reset();
2942 handle2.Reset(); 2965 handle2.Reset();
2943 2966
2944 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 2967 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2945 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 2968 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2946 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); 2969 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
2947 } 2970 }
2948 2971
2949 TEST_F(ClientSocketPoolBaseTest, 2972 TEST_F(ClientSocketPoolBaseTest,
2950 RequestSocketsWhenAlreadyHaveMultipleConnectJob) { 2973 RequestSocketsWhenAlreadyHaveMultipleConnectJob) {
2951 CreatePool(4, 4); 2974 CreatePool(4, 4);
2952 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2975 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2953 2976
2954 ClientSocketHandle handle1; 2977 ClientSocketHandle handle1;
2955 TestCompletionCallback callback1; 2978 TestCompletionCallback callback1;
2956 EXPECT_EQ(ERR_IO_PENDING, 2979 EXPECT_EQ(
2957 handle1.Init("a", params_, DEFAULT_PRIORITY, 2980 ERR_IO_PENDING,
2958 ClientSocketPool::RespectLimits::ENABLED, 2981 handle1.Init("a", params_, DEFAULT_PRIORITY,
2959 callback1.callback(), pool_.get(), BoundNetLog())); 2982 ClientSocketPool::RespectLimits::ENABLED,
2983 callback1.callback(), pool_.get(), NetLogWithSource()));
2960 2984
2961 ClientSocketHandle handle2; 2985 ClientSocketHandle handle2;
2962 TestCompletionCallback callback2; 2986 TestCompletionCallback callback2;
2963 EXPECT_EQ(ERR_IO_PENDING, 2987 EXPECT_EQ(
2964 handle2.Init("a", params_, DEFAULT_PRIORITY, 2988 ERR_IO_PENDING,
2965 ClientSocketPool::RespectLimits::ENABLED, 2989 handle2.Init("a", params_, DEFAULT_PRIORITY,
2966 callback2.callback(), pool_.get(), BoundNetLog())); 2990 ClientSocketPool::RespectLimits::ENABLED,
2991 callback2.callback(), pool_.get(), NetLogWithSource()));
2967 2992
2968 ClientSocketHandle handle3; 2993 ClientSocketHandle handle3;
2969 TestCompletionCallback callback3; 2994 TestCompletionCallback callback3;
2970 EXPECT_EQ(ERR_IO_PENDING, 2995 EXPECT_EQ(
2971 handle3.Init("a", params_, DEFAULT_PRIORITY, 2996 ERR_IO_PENDING,
2972 ClientSocketPool::RespectLimits::ENABLED, 2997 handle3.Init("a", params_, DEFAULT_PRIORITY,
2973 callback3.callback(), pool_.get(), BoundNetLog())); 2998 ClientSocketPool::RespectLimits::ENABLED,
2999 callback3.callback(), pool_.get(), NetLogWithSource()));
2974 3000
2975 ASSERT_TRUE(pool_->HasGroup("a")); 3001 ASSERT_TRUE(pool_->HasGroup("a"));
2976 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); 3002 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
2977 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3003 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2978 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3004 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2979 3005
2980 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3006 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
2981 3007
2982 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); 3008 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
2983 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3009 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2984 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3010 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2985 3011
2986 EXPECT_THAT(callback1.WaitForResult(), IsOk()); 3012 EXPECT_THAT(callback1.WaitForResult(), IsOk());
2987 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 3013 EXPECT_THAT(callback2.WaitForResult(), IsOk());
2988 EXPECT_THAT(callback3.WaitForResult(), IsOk()); 3014 EXPECT_THAT(callback3.WaitForResult(), IsOk());
2989 handle1.Reset(); 3015 handle1.Reset();
2990 handle2.Reset(); 3016 handle2.Reset();
2991 handle3.Reset(); 3017 handle3.Reset();
2992 3018
2993 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3019 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2994 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3020 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
2995 EXPECT_EQ(3, pool_->IdleSocketCountInGroup("a")); 3021 EXPECT_EQ(3, pool_->IdleSocketCountInGroup("a"));
2996 } 3022 }
2997 3023
2998 TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) { 3024 TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
2999 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 3025 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3000 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3026 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3001 3027
3002 ASSERT_FALSE(pool_->HasGroup("a")); 3028 ASSERT_FALSE(pool_->HasGroup("a"));
3003 3029
3004 pool_->RequestSockets("a", &params_, kDefaultMaxSockets, 3030 pool_->RequestSockets("a", &params_, kDefaultMaxSockets, NetLogWithSource());
3005 BoundNetLog());
3006 3031
3007 ASSERT_TRUE(pool_->HasGroup("a")); 3032 ASSERT_TRUE(pool_->HasGroup("a"));
3008 EXPECT_EQ(kDefaultMaxSockets, pool_->NumConnectJobsInGroup("a")); 3033 EXPECT_EQ(kDefaultMaxSockets, pool_->NumConnectJobsInGroup("a"));
3009 EXPECT_EQ(kDefaultMaxSockets, pool_->NumUnassignedConnectJobsInGroup("a")); 3034 EXPECT_EQ(kDefaultMaxSockets, pool_->NumUnassignedConnectJobsInGroup("a"));
3010 3035
3011 ASSERT_FALSE(pool_->HasGroup("b")); 3036 ASSERT_FALSE(pool_->HasGroup("b"));
3012 3037
3013 pool_->RequestSockets("b", &params_, kDefaultMaxSockets, 3038 pool_->RequestSockets("b", &params_, kDefaultMaxSockets, NetLogWithSource());
3014 BoundNetLog());
3015 3039
3016 ASSERT_FALSE(pool_->HasGroup("b")); 3040 ASSERT_FALSE(pool_->HasGroup("b"));
3017 } 3041 }
3018 3042
3019 TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) { 3043 TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
3020 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 3044 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3021 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3045 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3022 3046
3023 ASSERT_FALSE(pool_->HasGroup("a")); 3047 ASSERT_FALSE(pool_->HasGroup("a"));
3024 3048
3025 pool_->RequestSockets("a", &params_, kDefaultMaxSockets - 1, 3049 pool_->RequestSockets("a", &params_, kDefaultMaxSockets - 1,
3026 BoundNetLog()); 3050 NetLogWithSource());
3027 3051
3028 ASSERT_TRUE(pool_->HasGroup("a")); 3052 ASSERT_TRUE(pool_->HasGroup("a"));
3029 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->NumConnectJobsInGroup("a")); 3053 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->NumConnectJobsInGroup("a"));
3030 EXPECT_EQ(kDefaultMaxSockets - 1, 3054 EXPECT_EQ(kDefaultMaxSockets - 1,
3031 pool_->NumUnassignedConnectJobsInGroup("a")); 3055 pool_->NumUnassignedConnectJobsInGroup("a"));
3032 EXPECT_FALSE(pool_->IsStalled()); 3056 EXPECT_FALSE(pool_->IsStalled());
3033 3057
3034 ASSERT_FALSE(pool_->HasGroup("b")); 3058 ASSERT_FALSE(pool_->HasGroup("b"));
3035 3059
3036 pool_->RequestSockets("b", &params_, kDefaultMaxSockets, 3060 pool_->RequestSockets("b", &params_, kDefaultMaxSockets, NetLogWithSource());
3037 BoundNetLog());
3038 3061
3039 ASSERT_TRUE(pool_->HasGroup("b")); 3062 ASSERT_TRUE(pool_->HasGroup("b"));
3040 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b")); 3063 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b"));
3041 EXPECT_FALSE(pool_->IsStalled()); 3064 EXPECT_FALSE(pool_->IsStalled());
3042 } 3065 }
3043 3066
3044 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) { 3067 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
3045 CreatePool(4, 4); 3068 CreatePool(4, 4);
3046 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3069 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3047 3070
3048 ClientSocketHandle handle1; 3071 ClientSocketHandle handle1;
3049 TestCompletionCallback callback1; 3072 TestCompletionCallback callback1;
3050 EXPECT_EQ(ERR_IO_PENDING, 3073 EXPECT_EQ(
3051 handle1.Init("a", params_, DEFAULT_PRIORITY, 3074 ERR_IO_PENDING,
3052 ClientSocketPool::RespectLimits::ENABLED, 3075 handle1.Init("a", params_, DEFAULT_PRIORITY,
3053 callback1.callback(), pool_.get(), BoundNetLog())); 3076 ClientSocketPool::RespectLimits::ENABLED,
3077 callback1.callback(), pool_.get(), NetLogWithSource()));
3054 ASSERT_THAT(callback1.WaitForResult(), IsOk()); 3078 ASSERT_THAT(callback1.WaitForResult(), IsOk());
3055 handle1.Reset(); 3079 handle1.Reset();
3056 3080
3057 ASSERT_TRUE(pool_->HasGroup("a")); 3081 ASSERT_TRUE(pool_->HasGroup("a"));
3058 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3082 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3059 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3083 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3060 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3084 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3061 3085
3062 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3086 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3063 3087
3064 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3088 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3065 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 3089 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3066 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3090 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3067 } 3091 }
3068 3092
3069 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) { 3093 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
3070 CreatePool(4, 4); 3094 CreatePool(4, 4);
3071 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3095 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3072 3096
3073 ClientSocketHandle handle1; 3097 ClientSocketHandle handle1;
3074 TestCompletionCallback callback1; 3098 TestCompletionCallback callback1;
3075 EXPECT_EQ(ERR_IO_PENDING, 3099 EXPECT_EQ(
3076 handle1.Init("a", params_, DEFAULT_PRIORITY, 3100 ERR_IO_PENDING,
3077 ClientSocketPool::RespectLimits::ENABLED, 3101 handle1.Init("a", params_, DEFAULT_PRIORITY,
3078 callback1.callback(), pool_.get(), BoundNetLog())); 3102 ClientSocketPool::RespectLimits::ENABLED,
3103 callback1.callback(), pool_.get(), NetLogWithSource()));
3079 ASSERT_THAT(callback1.WaitForResult(), IsOk()); 3104 ASSERT_THAT(callback1.WaitForResult(), IsOk());
3080 3105
3081 ASSERT_TRUE(pool_->HasGroup("a")); 3106 ASSERT_TRUE(pool_->HasGroup("a"));
3082 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3107 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3083 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3108 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3084 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3109 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3085 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); 3110 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3086 3111
3087 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3112 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3088 3113
3089 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3114 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3090 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 3115 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3091 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3116 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3092 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); 3117 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3093 } 3118 }
3094 3119
3095 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) { 3120 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
3096 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3121 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3097 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3122 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3098 3123
3099 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup, 3124 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3100 BoundNetLog()); 3125 NetLogWithSource());
3101 3126
3102 ASSERT_TRUE(pool_->HasGroup("a")); 3127 ASSERT_TRUE(pool_->HasGroup("a"));
3103 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3128 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3104 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3129 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3105 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("a")); 3130 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("a"));
3106 3131
3107 pool_->RequestSockets("b", &params_, kDefaultMaxSocketsPerGroup, 3132 pool_->RequestSockets("b", &params_, kDefaultMaxSocketsPerGroup,
3108 BoundNetLog()); 3133 NetLogWithSource());
3109 3134
3110 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b")); 3135 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3111 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b")); 3136 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3112 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("b")); 3137 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("b"));
3113 } 3138 }
3114 3139
3115 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronousError) { 3140 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronousError) {
3116 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3141 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3117 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); 3142 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3118 3143
3119 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup, 3144 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3120 BoundNetLog()); 3145 NetLogWithSource());
3121 3146
3122 ASSERT_FALSE(pool_->HasGroup("a")); 3147 ASSERT_FALSE(pool_->HasGroup("a"));
3123 3148
3124 connect_job_factory_->set_job_type( 3149 connect_job_factory_->set_job_type(
3125 TestConnectJob::kMockAdditionalErrorStateJob); 3150 TestConnectJob::kMockAdditionalErrorStateJob);
3126 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup, 3151 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3127 BoundNetLog()); 3152 NetLogWithSource());
3128 3153
3129 ASSERT_FALSE(pool_->HasGroup("a")); 3154 ASSERT_FALSE(pool_->HasGroup("a"));
3130 } 3155 }
3131 3156
3132 TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) { 3157 TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
3133 CreatePool(4, 4); 3158 CreatePool(4, 4);
3134 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3159 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3135 3160
3136 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3161 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3137 3162
3138 ASSERT_TRUE(pool_->HasGroup("a")); 3163 ASSERT_TRUE(pool_->HasGroup("a"));
3139 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); 3164 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3140 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a")); 3165 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3141 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3166 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3142 3167
3143 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3168 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3144 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); 3169 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3145 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a")); 3170 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3146 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3171 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3147 3172
3148 ClientSocketHandle handle1; 3173 ClientSocketHandle handle1;
3149 TestCompletionCallback callback1; 3174 TestCompletionCallback callback1;
3150 EXPECT_EQ(ERR_IO_PENDING, 3175 EXPECT_EQ(
3151 handle1.Init("a", params_, DEFAULT_PRIORITY, 3176 ERR_IO_PENDING,
3152 ClientSocketPool::RespectLimits::ENABLED, 3177 handle1.Init("a", params_, DEFAULT_PRIORITY,
3153 callback1.callback(), pool_.get(), BoundNetLog())); 3178 ClientSocketPool::RespectLimits::ENABLED,
3179 callback1.callback(), pool_.get(), NetLogWithSource()));
3154 ASSERT_THAT(callback1.WaitForResult(), IsOk()); 3180 ASSERT_THAT(callback1.WaitForResult(), IsOk());
3155 3181
3156 ClientSocketHandle handle2; 3182 ClientSocketHandle handle2;
3157 TestCompletionCallback callback2; 3183 TestCompletionCallback callback2;
3158 int rv = handle2.Init("a", params_, DEFAULT_PRIORITY, 3184 int rv = handle2.Init("a", params_, DEFAULT_PRIORITY,
3159 ClientSocketPool::RespectLimits::ENABLED, 3185 ClientSocketPool::RespectLimits::ENABLED,
3160 callback2.callback(), pool_.get(), BoundNetLog()); 3186 callback2.callback(), pool_.get(), NetLogWithSource());
3161 if (rv != OK) { 3187 if (rv != OK) {
3162 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); 3188 EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
3163 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 3189 EXPECT_THAT(callback2.WaitForResult(), IsOk());
3164 } 3190 }
3165 3191
3166 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3192 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3167 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3193 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3168 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("a")); 3194 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("a"));
3169 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3195 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3170 3196
3171 handle1.Reset(); 3197 handle1.Reset();
3172 handle2.Reset(); 3198 handle2.Reset();
3173 3199
3174 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3200 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3175 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3201 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3176 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); 3202 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3177 3203
3178 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3204 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3179 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3205 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3180 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3206 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3181 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); 3207 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3182 } 3208 }
3183 3209
3184 TEST_F(ClientSocketPoolBaseTest, RequestSocketsDifferentNumSockets) { 3210 TEST_F(ClientSocketPoolBaseTest, RequestSocketsDifferentNumSockets) {
3185 CreatePool(4, 4); 3211 CreatePool(4, 4);
3186 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3212 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3187 3213
3188 pool_->RequestSockets("a", &params_, 1, BoundNetLog()); 3214 pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
3189 3215
3190 ASSERT_TRUE(pool_->HasGroup("a")); 3216 ASSERT_TRUE(pool_->HasGroup("a"));
3191 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3217 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3192 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 3218 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3193 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3219 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3194 3220
3195 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3221 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3196 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a")); 3222 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3197 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a")); 3223 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3198 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3224 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3199 3225
3200 pool_->RequestSockets("a", &params_, 3, BoundNetLog()); 3226 pool_->RequestSockets("a", &params_, 3, NetLogWithSource());
3201 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); 3227 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3202 EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a")); 3228 EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
3203 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3229 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3204 3230
3205 pool_->RequestSockets("a", &params_, 1, BoundNetLog()); 3231 pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
3206 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a")); 3232 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3207 EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a")); 3233 EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
3208 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3234 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3209 } 3235 }
3210 3236
3211 TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) { 3237 TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
3212 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3238 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3213 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3239 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3214 3240
3215 pool_->RequestSockets("a", &params_, 1, BoundNetLog()); 3241 pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
3216 3242
3217 ASSERT_TRUE(pool_->HasGroup("a")); 3243 ASSERT_TRUE(pool_->HasGroup("a"));
3218 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3244 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3219 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 3245 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3220 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3246 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3221 3247
3222 ClientSocketHandle handle1; 3248 ClientSocketHandle handle1;
3223 TestCompletionCallback callback1; 3249 TestCompletionCallback callback1;
3224 EXPECT_EQ(ERR_IO_PENDING, 3250 EXPECT_EQ(
3225 handle1.Init("a", params_, DEFAULT_PRIORITY, 3251 ERR_IO_PENDING,
3226 ClientSocketPool::RespectLimits::ENABLED, 3252 handle1.Init("a", params_, DEFAULT_PRIORITY,
3227 callback1.callback(), pool_.get(), BoundNetLog())); 3253 ClientSocketPool::RespectLimits::ENABLED,
3254 callback1.callback(), pool_.get(), NetLogWithSource()));
3228 3255
3229 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3256 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3230 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3257 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3231 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3258 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3232 3259
3233 ASSERT_THAT(callback1.WaitForResult(), IsOk()); 3260 ASSERT_THAT(callback1.WaitForResult(), IsOk());
3234 3261
3235 // Make sure if a preconnected socket is not fully connected when a request 3262 // Make sure if a preconnected socket is not fully connected when a request
3236 // starts, it has a connect start time. 3263 // starts, it has a connect start time.
3237 TestLoadTimingInfoConnectedNotReused(handle1); 3264 TestLoadTimingInfoConnectedNotReused(handle1);
3238 handle1.Reset(); 3265 handle1.Reset();
3239 3266
3240 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3267 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3241 } 3268 }
3242 3269
3243 // Checks that fully connected preconnect jobs have no connect times, and are 3270 // Checks that fully connected preconnect jobs have no connect times, and are
3244 // marked as reused. 3271 // marked as reused.
3245 TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) { 3272 TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
3246 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3273 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3247 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3274 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3248 pool_->RequestSockets("a", &params_, 1, BoundNetLog()); 3275 pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
3249 3276
3250 ASSERT_TRUE(pool_->HasGroup("a")); 3277 ASSERT_TRUE(pool_->HasGroup("a"));
3251 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3278 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3252 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3279 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3253 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3280 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3254 3281
3255 ClientSocketHandle handle; 3282 ClientSocketHandle handle;
3256 TestCompletionCallback callback; 3283 TestCompletionCallback callback;
3257 EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY, 3284 EXPECT_EQ(OK,
3258 ClientSocketPool::RespectLimits::ENABLED, 3285 handle.Init("a", params_, DEFAULT_PRIORITY,
3259 callback.callback(), pool_.get(), BoundNetLog())); 3286 ClientSocketPool::RespectLimits::ENABLED,
3287 callback.callback(), pool_.get(), NetLogWithSource()));
3260 3288
3261 // Make sure the idle socket was used. 3289 // Make sure the idle socket was used.
3262 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3290 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3263 3291
3264 TestLoadTimingInfoConnectedReused(handle); 3292 TestLoadTimingInfoConnectedReused(handle);
3265 handle.Reset(); 3293 handle.Reset();
3266 TestLoadTimingInfoNotConnected(handle); 3294 TestLoadTimingInfoNotConnected(handle);
3267 } 3295 }
3268 3296
3269 // http://crbug.com/64940 regression test. 3297 // http://crbug.com/64940 regression test.
3270 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) { 3298 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
3271 const int kMaxTotalSockets = 3; 3299 const int kMaxTotalSockets = 3;
3272 const int kMaxSocketsPerGroup = 2; 3300 const int kMaxSocketsPerGroup = 2;
3273 CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup); 3301 CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup);
3274 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3302 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3275 3303
3276 // Note that group name ordering matters here. "a" comes before "b", so 3304 // Note that group name ordering matters here. "a" comes before "b", so
3277 // CloseOneIdleSocket() will try to close "a"'s idle socket. 3305 // CloseOneIdleSocket() will try to close "a"'s idle socket.
3278 3306
3279 // Set up one idle socket in "a". 3307 // Set up one idle socket in "a".
3280 ClientSocketHandle handle1; 3308 ClientSocketHandle handle1;
3281 TestCompletionCallback callback1; 3309 TestCompletionCallback callback1;
3282 EXPECT_EQ(ERR_IO_PENDING, 3310 EXPECT_EQ(
3283 handle1.Init("a", params_, DEFAULT_PRIORITY, 3311 ERR_IO_PENDING,
3284 ClientSocketPool::RespectLimits::ENABLED, 3312 handle1.Init("a", params_, DEFAULT_PRIORITY,
3285 callback1.callback(), pool_.get(), BoundNetLog())); 3313 ClientSocketPool::RespectLimits::ENABLED,
3314 callback1.callback(), pool_.get(), NetLogWithSource()));
3286 3315
3287 ASSERT_THAT(callback1.WaitForResult(), IsOk()); 3316 ASSERT_THAT(callback1.WaitForResult(), IsOk());
3288 handle1.Reset(); 3317 handle1.Reset();
3289 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3318 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3290 3319
3291 // Set up two active sockets in "b". 3320 // Set up two active sockets in "b".
3292 ClientSocketHandle handle2; 3321 ClientSocketHandle handle2;
3293 TestCompletionCallback callback2; 3322 TestCompletionCallback callback2;
3294 EXPECT_EQ(ERR_IO_PENDING, 3323 EXPECT_EQ(
3295 handle1.Init("b", params_, DEFAULT_PRIORITY, 3324 ERR_IO_PENDING,
3296 ClientSocketPool::RespectLimits::ENABLED, 3325 handle1.Init("b", params_, DEFAULT_PRIORITY,
3297 callback1.callback(), pool_.get(), BoundNetLog())); 3326 ClientSocketPool::RespectLimits::ENABLED,
3298 EXPECT_EQ(ERR_IO_PENDING, 3327 callback1.callback(), pool_.get(), NetLogWithSource()));
3299 handle2.Init("b", params_, DEFAULT_PRIORITY, 3328 EXPECT_EQ(
3300 ClientSocketPool::RespectLimits::ENABLED, 3329 ERR_IO_PENDING,
3301 callback2.callback(), pool_.get(), BoundNetLog())); 3330 handle2.Init("b", params_, DEFAULT_PRIORITY,
3331 ClientSocketPool::RespectLimits::ENABLED,
3332 callback2.callback(), pool_.get(), NetLogWithSource()));
3302 3333
3303 ASSERT_THAT(callback1.WaitForResult(), IsOk()); 3334 ASSERT_THAT(callback1.WaitForResult(), IsOk());
3304 ASSERT_THAT(callback2.WaitForResult(), IsOk()); 3335 ASSERT_THAT(callback2.WaitForResult(), IsOk());
3305 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b")); 3336 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
3306 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b")); 3337 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3307 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b")); 3338 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
3308 3339
3309 // Now we have 1 idle socket in "a" and 2 active sockets in "b". This means 3340 // Now we have 1 idle socket in "a" and 2 active sockets in "b". This means
3310 // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3. 3341 // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3.
3311 // Requesting 2 preconnected sockets for "a" should fail to allocate any more 3342 // Requesting 2 preconnected sockets for "a" should fail to allocate any more
3312 // sockets for "a", and "b" should still have 2 active sockets. 3343 // sockets for "a", and "b" should still have 2 active sockets.
3313 3344
3314 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3345 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3315 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3346 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3316 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3347 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3317 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3348 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3318 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a")); 3349 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3319 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b")); 3350 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3320 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b")); 3351 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3321 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b")); 3352 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
3322 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b")); 3353 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
3323 3354
3324 // Now release the 2 active sockets for "b". This will give us 1 idle socket 3355 // Now release the 2 active sockets for "b". This will give us 1 idle socket
3325 // in "a" and 2 idle sockets in "b". Requesting 2 preconnected sockets for 3356 // in "a" and 2 idle sockets in "b". Requesting 2 preconnected sockets for
3326 // "a" should result in closing 1 for "b". 3357 // "a" should result in closing 1 for "b".
3327 handle1.Reset(); 3358 handle1.Reset();
3328 handle2.Reset(); 3359 handle2.Reset();
3329 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("b")); 3360 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("b"));
3330 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b")); 3361 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
3331 3362
3332 pool_->RequestSockets("a", &params_, 2, BoundNetLog()); 3363 pool_->RequestSockets("a", &params_, 2, NetLogWithSource());
3333 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3364 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3334 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 3365 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3335 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3366 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3336 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a")); 3367 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3337 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b")); 3368 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3338 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b")); 3369 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3339 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("b")); 3370 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("b"));
3340 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b")); 3371 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
3341 } 3372 }
3342 3373
3343 TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) { 3374 TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) {
3344 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3375 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3345 pool_->EnableConnectBackupJobs(); 3376 pool_->EnableConnectBackupJobs();
3346 3377
3347 // Make the ConnectJob hang until it times out, shorten the timeout. 3378 // Make the ConnectJob hang until it times out, shorten the timeout.
3348 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 3379 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3349 connect_job_factory_->set_timeout_duration( 3380 connect_job_factory_->set_timeout_duration(
3350 base::TimeDelta::FromMilliseconds(500)); 3381 base::TimeDelta::FromMilliseconds(500));
3351 pool_->RequestSockets("a", &params_, 1, BoundNetLog()); 3382 pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
3352 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3383 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3353 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 3384 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3354 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3385 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3355 3386
3356 // Verify the backup timer doesn't create a backup job, by making 3387 // Verify the backup timer doesn't create a backup job, by making
3357 // the backup job a pending job instead of a waiting job, so it 3388 // the backup job a pending job instead of a waiting job, so it
3358 // *would* complete if it were created. 3389 // *would* complete if it were created.
3359 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3390 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3360 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( 3391 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
3361 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(), 3392 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
3362 base::TimeDelta::FromSeconds(1)); 3393 base::TimeDelta::FromSeconds(1));
3363 base::RunLoop().Run(); 3394 base::RunLoop().Run();
3364 EXPECT_FALSE(pool_->HasGroup("a")); 3395 EXPECT_FALSE(pool_->HasGroup("a"));
3365 } 3396 }
3366 3397
3367 TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) { 3398 TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
3368 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3399 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3369 pool_->EnableConnectBackupJobs(); 3400 pool_->EnableConnectBackupJobs();
3370 3401
3371 // Make the ConnectJob hang forever. 3402 // Make the ConnectJob hang forever.
3372 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 3403 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3373 pool_->RequestSockets("a", &params_, 1, BoundNetLog()); 3404 pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
3374 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3405 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3375 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a")); 3406 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3376 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3407 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3377 base::RunLoop().RunUntilIdle(); 3408 base::RunLoop().RunUntilIdle();
3378 3409
3379 // Make the backup job be a pending job, so it completes normally. 3410 // Make the backup job be a pending job, so it completes normally.
3380 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 3411 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3381 ClientSocketHandle handle; 3412 ClientSocketHandle handle;
3382 TestCompletionCallback callback; 3413 TestCompletionCallback callback;
3383 EXPECT_EQ(ERR_IO_PENDING, 3414 EXPECT_EQ(ERR_IO_PENDING,
3384 handle.Init("a", params_, DEFAULT_PRIORITY, 3415 handle.Init("a", params_, DEFAULT_PRIORITY,
3385 ClientSocketPool::RespectLimits::ENABLED, 3416 ClientSocketPool::RespectLimits::ENABLED,
3386 callback.callback(), pool_.get(), BoundNetLog())); 3417 callback.callback(), pool_.get(), NetLogWithSource()));
3387 // Timer has started, but the backup connect job shouldn't be created yet. 3418 // Timer has started, but the backup connect job shouldn't be created yet.
3388 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3419 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3389 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3420 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3390 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3421 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3391 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a")); 3422 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3392 ASSERT_THAT(callback.WaitForResult(), IsOk()); 3423 ASSERT_THAT(callback.WaitForResult(), IsOk());
3393 3424
3394 // The hung connect job should still be there, but everything else should be 3425 // The hung connect job should still be there, but everything else should be
3395 // complete. 3426 // complete.
3396 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3427 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3397 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3428 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3398 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3429 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3399 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); 3430 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3400 } 3431 }
3401 3432
3402 // Tests that a preconnect that starts out with unread data can still be used. 3433 // Tests that a preconnect that starts out with unread data can still be used.
3403 // http://crbug.com/334467 3434 // http://crbug.com/334467
3404 TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) { 3435 TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
3405 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3436 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3406 connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob); 3437 connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob);
3407 3438
3408 pool_->RequestSockets("a", &params_, 1, BoundNetLog()); 3439 pool_->RequestSockets("a", &params_, 1, NetLogWithSource());
3409 3440
3410 ASSERT_TRUE(pool_->HasGroup("a")); 3441 ASSERT_TRUE(pool_->HasGroup("a"));
3411 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3442 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3412 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3443 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3413 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a")); 3444 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3414 3445
3415 // Fail future jobs to be sure that handle receives the preconnected socket 3446 // Fail future jobs to be sure that handle receives the preconnected socket
3416 // rather than closing it and making a new one. 3447 // rather than closing it and making a new one.
3417 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); 3448 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3418 ClientSocketHandle handle; 3449 ClientSocketHandle handle;
3419 TestCompletionCallback callback; 3450 TestCompletionCallback callback;
3420 EXPECT_EQ(OK, handle.Init("a", params_, DEFAULT_PRIORITY, 3451 EXPECT_EQ(OK,
3421 ClientSocketPool::RespectLimits::ENABLED, 3452 handle.Init("a", params_, DEFAULT_PRIORITY,
3422 callback.callback(), pool_.get(), BoundNetLog())); 3453 ClientSocketPool::RespectLimits::ENABLED,
3454 callback.callback(), pool_.get(), NetLogWithSource()));
3423 3455
3424 ASSERT_TRUE(pool_->HasGroup("a")); 3456 ASSERT_TRUE(pool_->HasGroup("a"));
3425 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 3457 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3426 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a")); 3458 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3427 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 3459 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3428 3460
3429 // Drain the pending read. 3461 // Drain the pending read.
3430 EXPECT_EQ(1, handle.socket()->Read(NULL, 1, CompletionCallback())); 3462 EXPECT_EQ(1, handle.socket()->Read(NULL, 1, CompletionCallback()));
3431 3463
3432 TestLoadTimingInfoConnectedReused(handle); 3464 TestLoadTimingInfoConnectedReused(handle);
(...skipping 14 matching lines...) Expand all
3447 } 3479 }
3448 3480
3449 ~MockLayeredPool() { 3481 ~MockLayeredPool() {
3450 pool_->RemoveHigherLayeredPool(this); 3482 pool_->RemoveHigherLayeredPool(this);
3451 } 3483 }
3452 3484
3453 int RequestSocket(TestClientSocketPool* pool) { 3485 int RequestSocket(TestClientSocketPool* pool) {
3454 scoped_refptr<TestSocketParams> params(new TestSocketParams()); 3486 scoped_refptr<TestSocketParams> params(new TestSocketParams());
3455 return handle_.Init(group_name_, params, DEFAULT_PRIORITY, 3487 return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
3456 ClientSocketPool::RespectLimits::ENABLED, 3488 ClientSocketPool::RespectLimits::ENABLED,
3457 callback_.callback(), pool, BoundNetLog()); 3489 callback_.callback(), pool, NetLogWithSource());
3458 } 3490 }
3459 3491
3460 int RequestSocketWithoutLimits(TestClientSocketPool* pool) { 3492 int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
3461 scoped_refptr<TestSocketParams> params(new TestSocketParams()); 3493 scoped_refptr<TestSocketParams> params(new TestSocketParams());
3462 return handle_.Init(group_name_, params, MAXIMUM_PRIORITY, 3494 return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
3463 ClientSocketPool::RespectLimits::DISABLED, 3495 ClientSocketPool::RespectLimits::DISABLED,
3464 callback_.callback(), pool, BoundNetLog()); 3496 callback_.callback(), pool, NetLogWithSource());
3465 } 3497 }
3466 3498
3467 bool ReleaseOneConnection() { 3499 bool ReleaseOneConnection() {
3468 if (!handle_.is_initialized() || !can_release_connection_) { 3500 if (!handle_.is_initialized() || !can_release_connection_) {
3469 return false; 3501 return false;
3470 } 3502 }
3471 handle_.socket()->Disconnect(); 3503 handle_.socket()->Disconnect();
3472 handle_.Reset(); 3504 handle_.Reset();
3473 return true; 3505 return true;
3474 } 3506 }
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
3519 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); 3551 MockLayeredPool mock_layered_pool(pool_.get(), "foo");
3520 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk()); 3552 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
3521 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3553 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3522 .WillOnce(Invoke(&mock_layered_pool, 3554 .WillOnce(Invoke(&mock_layered_pool,
3523 &MockLayeredPool::ReleaseOneConnection)); 3555 &MockLayeredPool::ReleaseOneConnection));
3524 ClientSocketHandle handle; 3556 ClientSocketHandle handle;
3525 TestCompletionCallback callback; 3557 TestCompletionCallback callback;
3526 EXPECT_EQ(ERR_IO_PENDING, 3558 EXPECT_EQ(ERR_IO_PENDING,
3527 handle.Init("a", params_, DEFAULT_PRIORITY, 3559 handle.Init("a", params_, DEFAULT_PRIORITY,
3528 ClientSocketPool::RespectLimits::ENABLED, 3560 ClientSocketPool::RespectLimits::ENABLED,
3529 callback.callback(), pool_.get(), BoundNetLog())); 3561 callback.callback(), pool_.get(), NetLogWithSource()));
3530 EXPECT_THAT(callback.WaitForResult(), IsOk()); 3562 EXPECT_THAT(callback.WaitForResult(), IsOk());
3531 } 3563 }
3532 3564
3533 // Same as above, but the idle socket is in the same group as the stalled 3565 // Same as above, but the idle socket is in the same group as the stalled
3534 // socket, and closes the only other request in its group when closing requests 3566 // socket, and closes the only other request in its group when closing requests
3535 // in higher layered pools. This generally shouldn't happen, but it may be 3567 // in higher layered pools. This generally shouldn't happen, but it may be
3536 // possible if a higher level pool issues a request and the request is 3568 // possible if a higher level pool issues a request and the request is
3537 // subsequently cancelled. Even if it's not possible, best not to crash. 3569 // subsequently cancelled. Even if it's not possible, best not to crash.
3538 TEST_F(ClientSocketPoolBaseTest, 3570 TEST_F(ClientSocketPoolBaseTest,
3539 CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) { 3571 CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) {
3540 CreatePool(2, 2); 3572 CreatePool(2, 2);
3541 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3573 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3542 3574
3543 // Need a socket in another group for the pool to be stalled (If a group 3575 // Need a socket in another group for the pool to be stalled (If a group
3544 // has the maximum number of connections already, it's not stalled). 3576 // has the maximum number of connections already, it's not stalled).
3545 ClientSocketHandle handle1; 3577 ClientSocketHandle handle1;
3546 TestCompletionCallback callback1; 3578 TestCompletionCallback callback1;
3547 EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY, 3579 EXPECT_EQ(
3548 ClientSocketPool::RespectLimits::ENABLED, 3580 OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
3549 callback1.callback(), pool_.get(), BoundNetLog())); 3581 ClientSocketPool::RespectLimits::ENABLED,
3582 callback1.callback(), pool_.get(), NetLogWithSource()));
3550 3583
3551 MockLayeredPool mock_layered_pool(pool_.get(), "group2"); 3584 MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3552 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk()); 3585 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
3553 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3586 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3554 .WillOnce(Invoke(&mock_layered_pool, 3587 .WillOnce(Invoke(&mock_layered_pool,
3555 &MockLayeredPool::ReleaseOneConnection)); 3588 &MockLayeredPool::ReleaseOneConnection));
3556 ClientSocketHandle handle; 3589 ClientSocketHandle handle;
3557 TestCompletionCallback callback2; 3590 TestCompletionCallback callback2;
3558 EXPECT_EQ(ERR_IO_PENDING, 3591 EXPECT_EQ(ERR_IO_PENDING,
3559 handle.Init("group2", params_, DEFAULT_PRIORITY, 3592 handle.Init("group2", params_, DEFAULT_PRIORITY,
3560 ClientSocketPool::RespectLimits::ENABLED, 3593 ClientSocketPool::RespectLimits::ENABLED,
3561 callback2.callback(), pool_.get(), BoundNetLog())); 3594 callback2.callback(), pool_.get(), NetLogWithSource()));
3562 EXPECT_THAT(callback2.WaitForResult(), IsOk()); 3595 EXPECT_THAT(callback2.WaitForResult(), IsOk());
3563 } 3596 }
3564 3597
3565 // Tests the case when an idle socket can be closed when a new request is 3598 // Tests the case when an idle socket can be closed when a new request is
3566 // issued, and the new request belongs to a group that was previously stalled. 3599 // issued, and the new request belongs to a group that was previously stalled.
3567 TEST_F(ClientSocketPoolBaseTest, 3600 TEST_F(ClientSocketPoolBaseTest,
3568 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) { 3601 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) {
3569 CreatePool(2, 2); 3602 CreatePool(2, 2);
3570 std::list<TestConnectJob::JobType> job_types; 3603 std::list<TestConnectJob::JobType> job_types;
3571 job_types.push_back(TestConnectJob::kMockJob); 3604 job_types.push_back(TestConnectJob::kMockJob);
3572 job_types.push_back(TestConnectJob::kMockJob); 3605 job_types.push_back(TestConnectJob::kMockJob);
3573 job_types.push_back(TestConnectJob::kMockJob); 3606 job_types.push_back(TestConnectJob::kMockJob);
3574 job_types.push_back(TestConnectJob::kMockJob); 3607 job_types.push_back(TestConnectJob::kMockJob);
3575 connect_job_factory_->set_job_types(&job_types); 3608 connect_job_factory_->set_job_types(&job_types);
3576 3609
3577 ClientSocketHandle handle1; 3610 ClientSocketHandle handle1;
3578 TestCompletionCallback callback1; 3611 TestCompletionCallback callback1;
3579 EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY, 3612 EXPECT_EQ(
3580 ClientSocketPool::RespectLimits::ENABLED, 3613 OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
3581 callback1.callback(), pool_.get(), BoundNetLog())); 3614 ClientSocketPool::RespectLimits::ENABLED,
3615 callback1.callback(), pool_.get(), NetLogWithSource()));
3582 3616
3583 MockLayeredPool mock_layered_pool(pool_.get(), "group2"); 3617 MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3584 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk()); 3618 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
3585 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3619 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3586 .WillRepeatedly(Invoke(&mock_layered_pool, 3620 .WillRepeatedly(Invoke(&mock_layered_pool,
3587 &MockLayeredPool::ReleaseOneConnection)); 3621 &MockLayeredPool::ReleaseOneConnection));
3588 mock_layered_pool.set_can_release_connection(false); 3622 mock_layered_pool.set_can_release_connection(false);
3589 3623
3590 // The third request is made when the socket pool is in a stalled state. 3624 // The third request is made when the socket pool is in a stalled state.
3591 ClientSocketHandle handle3; 3625 ClientSocketHandle handle3;
3592 TestCompletionCallback callback3; 3626 TestCompletionCallback callback3;
3593 EXPECT_EQ(ERR_IO_PENDING, 3627 EXPECT_EQ(
3594 handle3.Init("group3", params_, DEFAULT_PRIORITY, 3628 ERR_IO_PENDING,
3595 ClientSocketPool::RespectLimits::ENABLED, 3629 handle3.Init("group3", params_, DEFAULT_PRIORITY,
3596 callback3.callback(), pool_.get(), BoundNetLog())); 3630 ClientSocketPool::RespectLimits::ENABLED,
3631 callback3.callback(), pool_.get(), NetLogWithSource()));
3597 3632
3598 base::RunLoop().RunUntilIdle(); 3633 base::RunLoop().RunUntilIdle();
3599 EXPECT_FALSE(callback3.have_result()); 3634 EXPECT_FALSE(callback3.have_result());
3600 3635
3601 // The fourth request is made when the pool is no longer stalled. The third 3636 // The fourth request is made when the pool is no longer stalled. The third
3602 // request should be serviced first, since it was issued first and has the 3637 // request should be serviced first, since it was issued first and has the
3603 // same priority. 3638 // same priority.
3604 mock_layered_pool.set_can_release_connection(true); 3639 mock_layered_pool.set_can_release_connection(true);
3605 ClientSocketHandle handle4; 3640 ClientSocketHandle handle4;
3606 TestCompletionCallback callback4; 3641 TestCompletionCallback callback4;
3607 EXPECT_EQ(ERR_IO_PENDING, 3642 EXPECT_EQ(
3608 handle4.Init("group3", params_, DEFAULT_PRIORITY, 3643 ERR_IO_PENDING,
3609 ClientSocketPool::RespectLimits::ENABLED, 3644 handle4.Init("group3", params_, DEFAULT_PRIORITY,
3610 callback4.callback(), pool_.get(), BoundNetLog())); 3645 ClientSocketPool::RespectLimits::ENABLED,
3646 callback4.callback(), pool_.get(), NetLogWithSource()));
3611 EXPECT_THAT(callback3.WaitForResult(), IsOk()); 3647 EXPECT_THAT(callback3.WaitForResult(), IsOk());
3612 EXPECT_FALSE(callback4.have_result()); 3648 EXPECT_FALSE(callback4.have_result());
3613 3649
3614 // Closing a handle should free up another socket slot. 3650 // Closing a handle should free up another socket slot.
3615 handle1.Reset(); 3651 handle1.Reset();
3616 EXPECT_THAT(callback4.WaitForResult(), IsOk()); 3652 EXPECT_THAT(callback4.WaitForResult(), IsOk());
3617 } 3653 }
3618 3654
3619 // Tests the case when an idle socket can be closed when a new request is 3655 // Tests the case when an idle socket can be closed when a new request is
3620 // issued, and the new request belongs to a group that was previously stalled. 3656 // issued, and the new request belongs to a group that was previously stalled.
3621 // 3657 //
3622 // The two differences from the above test are that the stalled requests are not 3658 // The two differences from the above test are that the stalled requests are not
3623 // in the same group as the layered pool's request, and the the fourth request 3659 // in the same group as the layered pool's request, and the the fourth request
3624 // has a higher priority than the third one, so gets a socket first. 3660 // has a higher priority than the third one, so gets a socket first.
3625 TEST_F(ClientSocketPoolBaseTest, 3661 TEST_F(ClientSocketPoolBaseTest,
3626 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) { 3662 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) {
3627 CreatePool(2, 2); 3663 CreatePool(2, 2);
3628 std::list<TestConnectJob::JobType> job_types; 3664 std::list<TestConnectJob::JobType> job_types;
3629 job_types.push_back(TestConnectJob::kMockJob); 3665 job_types.push_back(TestConnectJob::kMockJob);
3630 job_types.push_back(TestConnectJob::kMockJob); 3666 job_types.push_back(TestConnectJob::kMockJob);
3631 job_types.push_back(TestConnectJob::kMockJob); 3667 job_types.push_back(TestConnectJob::kMockJob);
3632 job_types.push_back(TestConnectJob::kMockJob); 3668 job_types.push_back(TestConnectJob::kMockJob);
3633 connect_job_factory_->set_job_types(&job_types); 3669 connect_job_factory_->set_job_types(&job_types);
3634 3670
3635 ClientSocketHandle handle1; 3671 ClientSocketHandle handle1;
3636 TestCompletionCallback callback1; 3672 TestCompletionCallback callback1;
3637 EXPECT_EQ(OK, handle1.Init("group1", params_, DEFAULT_PRIORITY, 3673 EXPECT_EQ(
3638 ClientSocketPool::RespectLimits::ENABLED, 3674 OK, handle1.Init("group1", params_, DEFAULT_PRIORITY,
3639 callback1.callback(), pool_.get(), BoundNetLog())); 3675 ClientSocketPool::RespectLimits::ENABLED,
3676 callback1.callback(), pool_.get(), NetLogWithSource()));
3640 3677
3641 MockLayeredPool mock_layered_pool(pool_.get(), "group2"); 3678 MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3642 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk()); 3679 EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
3643 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3680 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3644 .WillRepeatedly(Invoke(&mock_layered_pool, 3681 .WillRepeatedly(Invoke(&mock_layered_pool,
3645 &MockLayeredPool::ReleaseOneConnection)); 3682 &MockLayeredPool::ReleaseOneConnection));
3646 mock_layered_pool.set_can_release_connection(false); 3683 mock_layered_pool.set_can_release_connection(false);
3647 3684
3648 // The third request is made when the socket pool is in a stalled state. 3685 // The third request is made when the socket pool is in a stalled state.
3649 ClientSocketHandle handle3; 3686 ClientSocketHandle handle3;
3650 TestCompletionCallback callback3; 3687 TestCompletionCallback callback3;
3651 EXPECT_EQ(ERR_IO_PENDING, 3688 EXPECT_EQ(
3652 handle3.Init("group3", params_, MEDIUM, 3689 ERR_IO_PENDING,
3653 ClientSocketPool::RespectLimits::ENABLED, 3690 handle3.Init("group3", params_, MEDIUM,
3654 callback3.callback(), pool_.get(), BoundNetLog())); 3691 ClientSocketPool::RespectLimits::ENABLED,
3692 callback3.callback(), pool_.get(), NetLogWithSource()));
3655 3693
3656 base::RunLoop().RunUntilIdle(); 3694 base::RunLoop().RunUntilIdle();
3657 EXPECT_FALSE(callback3.have_result()); 3695 EXPECT_FALSE(callback3.have_result());
3658 3696
3659 // The fourth request is made when the pool is no longer stalled. This 3697 // The fourth request is made when the pool is no longer stalled. This
3660 // request has a higher priority than the third request, so is serviced first. 3698 // request has a higher priority than the third request, so is serviced first.
3661 mock_layered_pool.set_can_release_connection(true); 3699 mock_layered_pool.set_can_release_connection(true);
3662 ClientSocketHandle handle4; 3700 ClientSocketHandle handle4;
3663 TestCompletionCallback callback4; 3701 TestCompletionCallback callback4;
3664 EXPECT_EQ(ERR_IO_PENDING, 3702 EXPECT_EQ(
3665 handle4.Init("group3", params_, HIGHEST, 3703 ERR_IO_PENDING,
3666 ClientSocketPool::RespectLimits::ENABLED, 3704 handle4.Init("group3", params_, HIGHEST,
3667 callback4.callback(), pool_.get(), BoundNetLog())); 3705 ClientSocketPool::RespectLimits::ENABLED,
3706 callback4.callback(), pool_.get(), NetLogWithSource()));
3668 EXPECT_THAT(callback4.WaitForResult(), IsOk()); 3707 EXPECT_THAT(callback4.WaitForResult(), IsOk());
3669 EXPECT_FALSE(callback3.have_result()); 3708 EXPECT_FALSE(callback3.have_result());
3670 3709
3671 // Closing a handle should free up another socket slot. 3710 // Closing a handle should free up another socket slot.
3672 handle1.Reset(); 3711 handle1.Reset();
3673 EXPECT_THAT(callback3.WaitForResult(), IsOk()); 3712 EXPECT_THAT(callback3.WaitForResult(), IsOk());
3674 } 3713 }
3675 3714
3676 TEST_F(ClientSocketPoolBaseTest, 3715 TEST_F(ClientSocketPoolBaseTest,
3677 CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) { 3716 CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) {
3678 CreatePool(1, 1); 3717 CreatePool(1, 1);
3679 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3718 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3680 3719
3681 MockLayeredPool mock_layered_pool1(pool_.get(), "foo"); 3720 MockLayeredPool mock_layered_pool1(pool_.get(), "foo");
3682 EXPECT_THAT(mock_layered_pool1.RequestSocket(pool_.get()), IsOk()); 3721 EXPECT_THAT(mock_layered_pool1.RequestSocket(pool_.get()), IsOk());
3683 EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection()) 3722 EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection())
3684 .WillRepeatedly(Invoke(&mock_layered_pool1, 3723 .WillRepeatedly(Invoke(&mock_layered_pool1,
3685 &MockLayeredPool::ReleaseOneConnection)); 3724 &MockLayeredPool::ReleaseOneConnection));
3686 MockLayeredPool mock_layered_pool2(pool_.get(), "bar"); 3725 MockLayeredPool mock_layered_pool2(pool_.get(), "bar");
3687 EXPECT_THAT(mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()), 3726 EXPECT_THAT(mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()),
3688 IsOk()); 3727 IsOk());
3689 EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection()) 3728 EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection())
3690 .WillRepeatedly(Invoke(&mock_layered_pool2, 3729 .WillRepeatedly(Invoke(&mock_layered_pool2,
3691 &MockLayeredPool::ReleaseOneConnection)); 3730 &MockLayeredPool::ReleaseOneConnection));
3692 ClientSocketHandle handle; 3731 ClientSocketHandle handle;
3693 TestCompletionCallback callback; 3732 TestCompletionCallback callback;
3694 EXPECT_EQ(ERR_IO_PENDING, 3733 EXPECT_EQ(ERR_IO_PENDING,
3695 handle.Init("a", params_, DEFAULT_PRIORITY, 3734 handle.Init("a", params_, DEFAULT_PRIORITY,
3696 ClientSocketPool::RespectLimits::ENABLED, 3735 ClientSocketPool::RespectLimits::ENABLED,
3697 callback.callback(), pool_.get(), BoundNetLog())); 3736 callback.callback(), pool_.get(), NetLogWithSource()));
3698 EXPECT_THAT(callback.WaitForResult(), IsOk()); 3737 EXPECT_THAT(callback.WaitForResult(), IsOk());
3699 } 3738 }
3700 3739
3701 // Test that when a socket pool and group are at their limits, a request 3740 // Test that when a socket pool and group are at their limits, a request
3702 // with RespectLimits::DISABLED triggers creation of a new socket, and gets the 3741 // with RespectLimits::DISABLED triggers creation of a new socket, and gets the
3703 // socket instead of a request with the same priority that was issued earlier, 3742 // socket instead of a request with the same priority that was issued earlier,
3704 // but has RespectLimits::ENABLED. 3743 // but has RespectLimits::ENABLED.
3705 TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) { 3744 TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) {
3706 CreatePool(1, 1); 3745 CreatePool(1, 1);
3707 3746
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
3760 request(1)->handle()->Reset(); 3799 request(1)->handle()->Reset();
3761 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); 3800 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3762 3801
3763 EXPECT_THAT(request(2)->WaitForResult(), IsOk()); 3802 EXPECT_THAT(request(2)->WaitForResult(), IsOk());
3764 EXPECT_FALSE(request(1)->have_result()); 3803 EXPECT_FALSE(request(1)->have_result());
3765 } 3804 }
3766 3805
3767 } // namespace 3806 } // namespace
3768 3807
3769 } // namespace net 3808 } // namespace net
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698