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

Issues Search
    My Issues | Starred     Open | Closed | All

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

Issue 992733002: Remove //net (except for Android test stuff) and sdch (Closed) Base URL: git@github.com:domokit/mojo.git@master
Patch Set: Created 5 years, 9 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
« no previous file with comments | « net/socket/client_socket_pool_base.cc ('k') | net/socket/client_socket_pool_histograms.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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
3 // found in the LICENSE file.
4
5 #include "net/socket/client_socket_pool_base.h"
6
7 #include <vector>
8
9 #include "base/bind.h"
10 #include "base/bind_helpers.h"
11 #include "base/callback.h"
12 #include "base/memory/ref_counted.h"
13 #include "base/memory/scoped_vector.h"
14 #include "base/memory/weak_ptr.h"
15 #include "base/message_loop/message_loop.h"
16 #include "base/run_loop.h"
17 #include "base/strings/string_number_conversions.h"
18 #include "base/strings/stringprintf.h"
19 #include "base/threading/platform_thread.h"
20 #include "base/values.h"
21 #include "net/base/load_timing_info.h"
22 #include "net/base/load_timing_info_test_util.h"
23 #include "net/base/net_errors.h"
24 #include "net/base/net_log.h"
25 #include "net/base/net_log_unittest.h"
26 #include "net/base/request_priority.h"
27 #include "net/base/test_completion_callback.h"
28 #include "net/http/http_response_headers.h"
29 #include "net/socket/client_socket_factory.h"
30 #include "net/socket/client_socket_handle.h"
31 #include "net/socket/client_socket_pool_histograms.h"
32 #include "net/socket/socket_test_util.h"
33 #include "net/socket/ssl_client_socket.h"
34 #include "net/socket/stream_socket.h"
35 #include "net/udp/datagram_client_socket.h"
36 #include "testing/gmock/include/gmock/gmock.h"
37 #include "testing/gtest/include/gtest/gtest.h"
38
39 using ::testing::Invoke;
40 using ::testing::Return;
41
42 namespace net {
43
44 namespace {
45
46 const int kDefaultMaxSockets = 4;
47 const int kDefaultMaxSocketsPerGroup = 2;
48
49 // Make sure |handle| sets load times correctly when it has been assigned a
50 // reused socket.
51 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
52 LoadTimingInfo load_timing_info;
53 // Only pass true in as |is_reused|, as in general, HttpStream types should
54 // have stricter concepts of reuse than socket pools.
55 EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
56
57 EXPECT_EQ(true, load_timing_info.socket_reused);
58 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
59
60 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
61 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
62 }
63
64 // Make sure |handle| sets load times correctly when it has been assigned a
65 // fresh socket. Also runs TestLoadTimingInfoConnectedReused, since the owner
66 // of a connection where |is_reused| is false may consider the connection
67 // reused.
68 void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) {
69 EXPECT_FALSE(handle.is_reused());
70
71 LoadTimingInfo load_timing_info;
72 EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
73
74 EXPECT_FALSE(load_timing_info.socket_reused);
75 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
76
77 ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
78 CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
79 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
80
81 TestLoadTimingInfoConnectedReused(handle);
82 }
83
84 // Make sure |handle| sets load times correctly, in the case that it does not
85 // currently have a socket.
86 void TestLoadTimingInfoNotConnected(const ClientSocketHandle& handle) {
87 // Should only be set to true once a socket is assigned, if at all.
88 EXPECT_FALSE(handle.is_reused());
89
90 LoadTimingInfo load_timing_info;
91 EXPECT_FALSE(handle.GetLoadTimingInfo(false, &load_timing_info));
92
93 EXPECT_FALSE(load_timing_info.socket_reused);
94 EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
95
96 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
97 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
98 }
99
100 class TestSocketParams : public base::RefCounted<TestSocketParams> {
101 public:
102 explicit TestSocketParams(bool ignore_limits)
103 : ignore_limits_(ignore_limits) {}
104
105 bool ignore_limits() { return ignore_limits_; }
106
107 private:
108 friend class base::RefCounted<TestSocketParams>;
109 ~TestSocketParams() {}
110
111 const bool ignore_limits_;
112 };
113 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
114
115 class MockClientSocket : public StreamSocket {
116 public:
117 explicit MockClientSocket(net::NetLog* net_log)
118 : connected_(false),
119 has_unread_data_(false),
120 net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
121 was_used_to_convey_data_(false) {
122 }
123
124 // Sets whether the socket has unread data. If true, the next call to Read()
125 // will return 1 byte and IsConnectedAndIdle() will return false.
126 void set_has_unread_data(bool has_unread_data) {
127 has_unread_data_ = has_unread_data;
128 }
129
130 // Socket implementation.
131 int Read(IOBuffer* /* buf */,
132 int len,
133 const CompletionCallback& /* callback */) override {
134 if (has_unread_data_ && len > 0) {
135 has_unread_data_ = false;
136 was_used_to_convey_data_ = true;
137 return 1;
138 }
139 return ERR_UNEXPECTED;
140 }
141
142 int Write(IOBuffer* /* buf */,
143 int len,
144 const CompletionCallback& /* callback */) override {
145 was_used_to_convey_data_ = true;
146 return len;
147 }
148 int SetReceiveBufferSize(int32 size) override { return OK; }
149 int SetSendBufferSize(int32 size) override { return OK; }
150
151 // StreamSocket implementation.
152 int Connect(const CompletionCallback& callback) override {
153 connected_ = true;
154 return OK;
155 }
156
157 void Disconnect() override { connected_ = false; }
158 bool IsConnected() const override { return connected_; }
159 bool IsConnectedAndIdle() const override {
160 return connected_ && !has_unread_data_;
161 }
162
163 int GetPeerAddress(IPEndPoint* /* address */) const override {
164 return ERR_UNEXPECTED;
165 }
166
167 int GetLocalAddress(IPEndPoint* /* address */) const override {
168 return ERR_UNEXPECTED;
169 }
170
171 const BoundNetLog& NetLog() const override { return net_log_; }
172
173 void SetSubresourceSpeculation() override {}
174 void SetOmniboxSpeculation() override {}
175 bool WasEverUsed() const override { return was_used_to_convey_data_; }
176 bool UsingTCPFastOpen() const override { return false; }
177 bool WasNpnNegotiated() const override { return false; }
178 NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
179 bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
180
181 private:
182 bool connected_;
183 bool has_unread_data_;
184 BoundNetLog net_log_;
185 bool was_used_to_convey_data_;
186
187 DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
188 };
189
190 class TestConnectJob;
191
192 class MockClientSocketFactory : public ClientSocketFactory {
193 public:
194 MockClientSocketFactory() : allocation_count_(0) {}
195
196 scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
197 DatagramSocket::BindType bind_type,
198 const RandIntCallback& rand_int_cb,
199 NetLog* net_log,
200 const NetLog::Source& source) override {
201 NOTREACHED();
202 return scoped_ptr<DatagramClientSocket>();
203 }
204
205 scoped_ptr<StreamSocket> CreateTransportClientSocket(
206 const AddressList& addresses,
207 NetLog* /* net_log */,
208 const NetLog::Source& /*source*/) override {
209 allocation_count_++;
210 return scoped_ptr<StreamSocket>();
211 }
212
213 scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
214 scoped_ptr<ClientSocketHandle> transport_socket,
215 const HostPortPair& host_and_port,
216 const SSLConfig& ssl_config,
217 const SSLClientSocketContext& context) override {
218 NOTIMPLEMENTED();
219 return scoped_ptr<SSLClientSocket>();
220 }
221
222 void ClearSSLSessionCache() override { NOTIMPLEMENTED(); }
223
224 void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); }
225
226 void SignalJobs();
227
228 void SignalJob(size_t job);
229
230 void SetJobLoadState(size_t job, LoadState load_state);
231
232 int allocation_count() const { return allocation_count_; }
233
234 private:
235 int allocation_count_;
236 std::vector<TestConnectJob*> waiting_jobs_;
237 };
238
239 class TestConnectJob : public ConnectJob {
240 public:
241 enum JobType {
242 kMockJob,
243 kMockFailingJob,
244 kMockPendingJob,
245 kMockPendingFailingJob,
246 kMockWaitingJob,
247 kMockRecoverableJob,
248 kMockPendingRecoverableJob,
249 kMockAdditionalErrorStateJob,
250 kMockPendingAdditionalErrorStateJob,
251 kMockUnreadDataJob,
252 };
253
254 // The kMockPendingJob uses a slight delay before allowing the connect
255 // to complete.
256 static const int kPendingConnectDelay = 2;
257
258 TestConnectJob(JobType job_type,
259 const std::string& group_name,
260 const TestClientSocketPoolBase::Request& request,
261 base::TimeDelta timeout_duration,
262 ConnectJob::Delegate* delegate,
263 MockClientSocketFactory* client_socket_factory,
264 NetLog* net_log)
265 : ConnectJob(group_name, timeout_duration, request.priority(), delegate,
266 BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
267 job_type_(job_type),
268 client_socket_factory_(client_socket_factory),
269 load_state_(LOAD_STATE_IDLE),
270 store_additional_error_state_(false),
271 weak_factory_(this) {
272 }
273
274 void Signal() {
275 DoConnect(waiting_success_, true /* async */, false /* recoverable */);
276 }
277
278 void set_load_state(LoadState load_state) { load_state_ = load_state; }
279
280 // From ConnectJob:
281
282 LoadState GetLoadState() const override { return load_state_; }
283
284 void GetAdditionalErrorState(ClientSocketHandle* handle) override {
285 if (store_additional_error_state_) {
286 // Set all of the additional error state fields in some way.
287 handle->set_is_ssl_error(true);
288 HttpResponseInfo info;
289 info.headers = new HttpResponseHeaders(std::string());
290 handle->set_ssl_error_response_info(info);
291 }
292 }
293
294 private:
295 // From ConnectJob:
296
297 int ConnectInternal() override {
298 AddressList ignored;
299 client_socket_factory_->CreateTransportClientSocket(
300 ignored, NULL, net::NetLog::Source());
301 SetSocket(
302 scoped_ptr<StreamSocket>(new MockClientSocket(net_log().net_log())));
303 switch (job_type_) {
304 case kMockJob:
305 return DoConnect(true /* successful */, false /* sync */,
306 false /* recoverable */);
307 case kMockFailingJob:
308 return DoConnect(false /* error */, false /* sync */,
309 false /* recoverable */);
310 case kMockPendingJob:
311 set_load_state(LOAD_STATE_CONNECTING);
312
313 // Depending on execution timings, posting a delayed task can result
314 // in the task getting executed the at the earliest possible
315 // opportunity or only after returning once from the message loop and
316 // then a second call into the message loop. In order to make behavior
317 // more deterministic, we change the default delay to 2ms. This should
318 // always require us to wait for the second call into the message loop.
319 //
320 // N.B. The correct fix for this and similar timing problems is to
321 // abstract time for the purpose of unittests. Unfortunately, we have
322 // a lot of third-party components that directly call the various
323 // time functions, so this change would be rather invasive.
324 base::MessageLoop::current()->PostDelayedTask(
325 FROM_HERE,
326 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
327 weak_factory_.GetWeakPtr(),
328 true /* successful */,
329 true /* async */,
330 false /* recoverable */),
331 base::TimeDelta::FromMilliseconds(kPendingConnectDelay));
332 return ERR_IO_PENDING;
333 case kMockPendingFailingJob:
334 set_load_state(LOAD_STATE_CONNECTING);
335 base::MessageLoop::current()->PostDelayedTask(
336 FROM_HERE,
337 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
338 weak_factory_.GetWeakPtr(),
339 false /* error */,
340 true /* async */,
341 false /* recoverable */),
342 base::TimeDelta::FromMilliseconds(2));
343 return ERR_IO_PENDING;
344 case kMockWaitingJob:
345 set_load_state(LOAD_STATE_CONNECTING);
346 client_socket_factory_->WaitForSignal(this);
347 waiting_success_ = true;
348 return ERR_IO_PENDING;
349 case kMockRecoverableJob:
350 return DoConnect(false /* error */, false /* sync */,
351 true /* recoverable */);
352 case kMockPendingRecoverableJob:
353 set_load_state(LOAD_STATE_CONNECTING);
354 base::MessageLoop::current()->PostDelayedTask(
355 FROM_HERE,
356 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
357 weak_factory_.GetWeakPtr(),
358 false /* error */,
359 true /* async */,
360 true /* recoverable */),
361 base::TimeDelta::FromMilliseconds(2));
362 return ERR_IO_PENDING;
363 case kMockAdditionalErrorStateJob:
364 store_additional_error_state_ = true;
365 return DoConnect(false /* error */, false /* sync */,
366 false /* recoverable */);
367 case kMockPendingAdditionalErrorStateJob:
368 set_load_state(LOAD_STATE_CONNECTING);
369 store_additional_error_state_ = true;
370 base::MessageLoop::current()->PostDelayedTask(
371 FROM_HERE,
372 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
373 weak_factory_.GetWeakPtr(),
374 false /* error */,
375 true /* async */,
376 false /* recoverable */),
377 base::TimeDelta::FromMilliseconds(2));
378 return ERR_IO_PENDING;
379 case kMockUnreadDataJob: {
380 int ret = DoConnect(true /* successful */, false /* sync */,
381 false /* recoverable */);
382 static_cast<MockClientSocket*>(socket())->set_has_unread_data(true);
383 return ret;
384 }
385 default:
386 NOTREACHED();
387 SetSocket(scoped_ptr<StreamSocket>());
388 return ERR_FAILED;
389 }
390 }
391
392 int DoConnect(bool succeed, bool was_async, bool recoverable) {
393 int result = OK;
394 if (succeed) {
395 socket()->Connect(CompletionCallback());
396 } else if (recoverable) {
397 result = ERR_PROXY_AUTH_REQUESTED;
398 } else {
399 result = ERR_CONNECTION_FAILED;
400 SetSocket(scoped_ptr<StreamSocket>());
401 }
402
403 if (was_async)
404 NotifyDelegateOfCompletion(result);
405 return result;
406 }
407
408 bool waiting_success_;
409 const JobType job_type_;
410 MockClientSocketFactory* const client_socket_factory_;
411 LoadState load_state_;
412 bool store_additional_error_state_;
413
414 base::WeakPtrFactory<TestConnectJob> weak_factory_;
415
416 DISALLOW_COPY_AND_ASSIGN(TestConnectJob);
417 };
418
419 class TestConnectJobFactory
420 : public TestClientSocketPoolBase::ConnectJobFactory {
421 public:
422 TestConnectJobFactory(MockClientSocketFactory* client_socket_factory,
423 NetLog* net_log)
424 : job_type_(TestConnectJob::kMockJob),
425 job_types_(NULL),
426 client_socket_factory_(client_socket_factory),
427 net_log_(net_log) {
428 }
429
430 ~TestConnectJobFactory() override {}
431
432 void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; }
433
434 void set_job_types(std::list<TestConnectJob::JobType>* job_types) {
435 job_types_ = job_types;
436 CHECK(!job_types_->empty());
437 }
438
439 void set_timeout_duration(base::TimeDelta timeout_duration) {
440 timeout_duration_ = timeout_duration;
441 }
442
443 // ConnectJobFactory implementation.
444
445 scoped_ptr<ConnectJob> NewConnectJob(
446 const std::string& group_name,
447 const TestClientSocketPoolBase::Request& request,
448 ConnectJob::Delegate* delegate) const override {
449 EXPECT_TRUE(!job_types_ || !job_types_->empty());
450 TestConnectJob::JobType job_type = job_type_;
451 if (job_types_ && !job_types_->empty()) {
452 job_type = job_types_->front();
453 job_types_->pop_front();
454 }
455 return scoped_ptr<ConnectJob>(new TestConnectJob(job_type,
456 group_name,
457 request,
458 timeout_duration_,
459 delegate,
460 client_socket_factory_,
461 net_log_));
462 }
463
464 base::TimeDelta ConnectionTimeout() const override {
465 return timeout_duration_;
466 }
467
468 private:
469 TestConnectJob::JobType job_type_;
470 std::list<TestConnectJob::JobType>* job_types_;
471 base::TimeDelta timeout_duration_;
472 MockClientSocketFactory* const client_socket_factory_;
473 NetLog* net_log_;
474
475 DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory);
476 };
477
478 class TestClientSocketPool : public ClientSocketPool {
479 public:
480 typedef TestSocketParams SocketParams;
481
482 TestClientSocketPool(
483 int max_sockets,
484 int max_sockets_per_group,
485 ClientSocketPoolHistograms* histograms,
486 base::TimeDelta unused_idle_socket_timeout,
487 base::TimeDelta used_idle_socket_timeout,
488 TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory)
489 : base_(NULL, max_sockets, max_sockets_per_group, histograms,
490 unused_idle_socket_timeout, used_idle_socket_timeout,
491 connect_job_factory) {}
492
493 ~TestClientSocketPool() override {}
494
495 int RequestSocket(const std::string& group_name,
496 const void* params,
497 net::RequestPriority priority,
498 ClientSocketHandle* handle,
499 const CompletionCallback& callback,
500 const BoundNetLog& net_log) override {
501 const scoped_refptr<TestSocketParams>* casted_socket_params =
502 static_cast<const scoped_refptr<TestSocketParams>*>(params);
503 return base_.RequestSocket(group_name, *casted_socket_params, priority,
504 handle, callback, net_log);
505 }
506
507 void RequestSockets(const std::string& group_name,
508 const void* params,
509 int num_sockets,
510 const BoundNetLog& net_log) override {
511 const scoped_refptr<TestSocketParams>* casted_params =
512 static_cast<const scoped_refptr<TestSocketParams>*>(params);
513
514 base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
515 }
516
517 void CancelRequest(const std::string& group_name,
518 ClientSocketHandle* handle) override {
519 base_.CancelRequest(group_name, handle);
520 }
521
522 void ReleaseSocket(const std::string& group_name,
523 scoped_ptr<StreamSocket> socket,
524 int id) override {
525 base_.ReleaseSocket(group_name, socket.Pass(), id);
526 }
527
528 void FlushWithError(int error) override { base_.FlushWithError(error); }
529
530 bool IsStalled() const override { return base_.IsStalled(); }
531
532 void CloseIdleSockets() override { base_.CloseIdleSockets(); }
533
534 int IdleSocketCount() const override { return base_.idle_socket_count(); }
535
536 int IdleSocketCountInGroup(const std::string& group_name) const override {
537 return base_.IdleSocketCountInGroup(group_name);
538 }
539
540 LoadState GetLoadState(const std::string& group_name,
541 const ClientSocketHandle* handle) const override {
542 return base_.GetLoadState(group_name, handle);
543 }
544
545 void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override {
546 base_.AddHigherLayeredPool(higher_pool);
547 }
548
549 void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) override {
550 base_.RemoveHigherLayeredPool(higher_pool);
551 }
552
553 base::DictionaryValue* GetInfoAsValue(
554 const std::string& name,
555 const std::string& type,
556 bool include_nested_pools) const override {
557 return base_.GetInfoAsValue(name, type);
558 }
559
560 base::TimeDelta ConnectionTimeout() const override {
561 return base_.ConnectionTimeout();
562 }
563
564 ClientSocketPoolHistograms* histograms() const override {
565 return base_.histograms();
566 }
567
568 const TestClientSocketPoolBase* base() const { return &base_; }
569
570 int NumUnassignedConnectJobsInGroup(const std::string& group_name) const {
571 return base_.NumUnassignedConnectJobsInGroup(group_name);
572 }
573
574 int NumConnectJobsInGroup(const std::string& group_name) const {
575 return base_.NumConnectJobsInGroup(group_name);
576 }
577
578 int NumActiveSocketsInGroup(const std::string& group_name) const {
579 return base_.NumActiveSocketsInGroup(group_name);
580 }
581
582 bool HasGroup(const std::string& group_name) const {
583 return base_.HasGroup(group_name);
584 }
585
586 void CleanupTimedOutIdleSockets() { base_.CleanupIdleSockets(false); }
587
588 void EnableConnectBackupJobs() { base_.EnableConnectBackupJobs(); }
589
590 bool CloseOneIdleConnectionInHigherLayeredPool() {
591 return base_.CloseOneIdleConnectionInHigherLayeredPool();
592 }
593
594 private:
595 TestClientSocketPoolBase base_;
596
597 DISALLOW_COPY_AND_ASSIGN(TestClientSocketPool);
598 };
599
600 } // namespace
601
602 namespace {
603
604 void MockClientSocketFactory::SignalJobs() {
605 for (std::vector<TestConnectJob*>::iterator it = waiting_jobs_.begin();
606 it != waiting_jobs_.end(); ++it) {
607 (*it)->Signal();
608 }
609 waiting_jobs_.clear();
610 }
611
612 void MockClientSocketFactory::SignalJob(size_t job) {
613 ASSERT_LT(job, waiting_jobs_.size());
614 waiting_jobs_[job]->Signal();
615 waiting_jobs_.erase(waiting_jobs_.begin() + job);
616 }
617
618 void MockClientSocketFactory::SetJobLoadState(size_t job,
619 LoadState load_state) {
620 ASSERT_LT(job, waiting_jobs_.size());
621 waiting_jobs_[job]->set_load_state(load_state);
622 }
623
624 class TestConnectJobDelegate : public ConnectJob::Delegate {
625 public:
626 TestConnectJobDelegate()
627 : have_result_(false), waiting_for_result_(false), result_(OK) {}
628 ~TestConnectJobDelegate() override {}
629
630 void OnConnectJobComplete(int result, ConnectJob* job) override {
631 result_ = result;
632 scoped_ptr<ConnectJob> owned_job(job);
633 scoped_ptr<StreamSocket> socket = owned_job->PassSocket();
634 // socket.get() should be NULL iff result != OK
635 EXPECT_EQ(socket == NULL, result != OK);
636 have_result_ = true;
637 if (waiting_for_result_)
638 base::MessageLoop::current()->Quit();
639 }
640
641 int WaitForResult() {
642 DCHECK(!waiting_for_result_);
643 while (!have_result_) {
644 waiting_for_result_ = true;
645 base::MessageLoop::current()->Run();
646 waiting_for_result_ = false;
647 }
648 have_result_ = false; // auto-reset for next callback
649 return result_;
650 }
651
652 private:
653 bool have_result_;
654 bool waiting_for_result_;
655 int result_;
656 };
657
658 class ClientSocketPoolBaseTest : public testing::Test {
659 protected:
660 ClientSocketPoolBaseTest()
661 : params_(new TestSocketParams(false /* ignore_limits */)),
662 histograms_("ClientSocketPoolTest") {
663 connect_backup_jobs_enabled_ =
664 internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled();
665 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true);
666 cleanup_timer_enabled_ =
667 internal::ClientSocketPoolBaseHelper::cleanup_timer_enabled();
668 }
669
670 ~ClientSocketPoolBaseTest() override {
671 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
672 connect_backup_jobs_enabled_);
673 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(
674 cleanup_timer_enabled_);
675 }
676
677 void CreatePool(int max_sockets, int max_sockets_per_group) {
678 CreatePoolWithIdleTimeouts(
679 max_sockets,
680 max_sockets_per_group,
681 ClientSocketPool::unused_idle_socket_timeout(),
682 ClientSocketPool::used_idle_socket_timeout());
683 }
684
685 void CreatePoolWithIdleTimeouts(
686 int max_sockets, int max_sockets_per_group,
687 base::TimeDelta unused_idle_socket_timeout,
688 base::TimeDelta used_idle_socket_timeout) {
689 DCHECK(!pool_.get());
690 connect_job_factory_ = new TestConnectJobFactory(&client_socket_factory_,
691 &net_log_);
692 pool_.reset(new TestClientSocketPool(max_sockets,
693 max_sockets_per_group,
694 &histograms_,
695 unused_idle_socket_timeout,
696 used_idle_socket_timeout,
697 connect_job_factory_));
698 }
699
700 int StartRequestWithParams(
701 const std::string& group_name,
702 RequestPriority priority,
703 const scoped_refptr<TestSocketParams>& params) {
704 return test_base_.StartRequestUsingPool(
705 pool_.get(), group_name, priority, params);
706 }
707
708 int StartRequest(const std::string& group_name, RequestPriority priority) {
709 return StartRequestWithParams(group_name, priority, params_);
710 }
711
712 int GetOrderOfRequest(size_t index) const {
713 return test_base_.GetOrderOfRequest(index);
714 }
715
716 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
717 return test_base_.ReleaseOneConnection(keep_alive);
718 }
719
720 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) {
721 test_base_.ReleaseAllConnections(keep_alive);
722 }
723
724 TestSocketRequest* request(int i) { return test_base_.request(i); }
725 size_t requests_size() const { return test_base_.requests_size(); }
726 ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); }
727 size_t completion_count() const { return test_base_.completion_count(); }
728
729 CapturingNetLog net_log_;
730 bool connect_backup_jobs_enabled_;
731 bool cleanup_timer_enabled_;
732 MockClientSocketFactory client_socket_factory_;
733 TestConnectJobFactory* connect_job_factory_;
734 scoped_refptr<TestSocketParams> params_;
735 ClientSocketPoolHistograms histograms_;
736 scoped_ptr<TestClientSocketPool> pool_;
737 ClientSocketPoolTest test_base_;
738 };
739
740 // Even though a timeout is specified, it doesn't time out on a synchronous
741 // completion.
742 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
743 TestConnectJobDelegate delegate;
744 ClientSocketHandle ignored;
745 TestClientSocketPoolBase::Request request(
746 &ignored, CompletionCallback(), DEFAULT_PRIORITY,
747 internal::ClientSocketPoolBaseHelper::NORMAL,
748 false, params_, BoundNetLog());
749 scoped_ptr<TestConnectJob> job(
750 new TestConnectJob(TestConnectJob::kMockJob,
751 "a",
752 request,
753 base::TimeDelta::FromMicroseconds(1),
754 &delegate,
755 &client_socket_factory_,
756 NULL));
757 EXPECT_EQ(OK, job->Connect());
758 }
759
760 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
761 TestConnectJobDelegate delegate;
762 ClientSocketHandle ignored;
763 CapturingNetLog log;
764
765 TestClientSocketPoolBase::Request request(
766 &ignored, CompletionCallback(), DEFAULT_PRIORITY,
767 internal::ClientSocketPoolBaseHelper::NORMAL,
768 false, params_, BoundNetLog());
769 // Deleted by TestConnectJobDelegate.
770 TestConnectJob* job =
771 new TestConnectJob(TestConnectJob::kMockPendingJob,
772 "a",
773 request,
774 base::TimeDelta::FromMicroseconds(1),
775 &delegate,
776 &client_socket_factory_,
777 &log);
778 ASSERT_EQ(ERR_IO_PENDING, job->Connect());
779 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
780 EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult());
781
782 CapturingNetLog::CapturedEntryList entries;
783 log.GetEntries(&entries);
784
785 EXPECT_EQ(6u, entries.size());
786 EXPECT_TRUE(LogContainsBeginEvent(
787 entries, 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
788 EXPECT_TRUE(LogContainsBeginEvent(
789 entries, 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
790 EXPECT_TRUE(LogContainsEvent(
791 entries, 2, NetLog::TYPE_CONNECT_JOB_SET_SOCKET,
792 NetLog::PHASE_NONE));
793 EXPECT_TRUE(LogContainsEvent(
794 entries, 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
795 NetLog::PHASE_NONE));
796 EXPECT_TRUE(LogContainsEndEvent(
797 entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
798 EXPECT_TRUE(LogContainsEndEvent(
799 entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
800 }
801
802 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
803 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
804
805 TestCompletionCallback callback;
806 ClientSocketHandle handle;
807 CapturingBoundNetLog log;
808 TestLoadTimingInfoNotConnected(handle);
809
810 EXPECT_EQ(OK,
811 handle.Init("a",
812 params_,
813 DEFAULT_PRIORITY,
814 callback.callback(),
815 pool_.get(),
816 log.bound()));
817 EXPECT_TRUE(handle.is_initialized());
818 EXPECT_TRUE(handle.socket());
819 TestLoadTimingInfoConnectedNotReused(handle);
820
821 handle.Reset();
822 TestLoadTimingInfoNotConnected(handle);
823
824 CapturingNetLog::CapturedEntryList entries;
825 log.GetEntries(&entries);
826
827 EXPECT_EQ(4u, entries.size());
828 EXPECT_TRUE(LogContainsBeginEvent(
829 entries, 0, NetLog::TYPE_SOCKET_POOL));
830 EXPECT_TRUE(LogContainsEvent(
831 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
832 NetLog::PHASE_NONE));
833 EXPECT_TRUE(LogContainsEvent(
834 entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
835 NetLog::PHASE_NONE));
836 EXPECT_TRUE(LogContainsEndEvent(
837 entries, 3, NetLog::TYPE_SOCKET_POOL));
838 }
839
840 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
841 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
842
843 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
844 CapturingBoundNetLog log;
845
846 ClientSocketHandle handle;
847 TestCompletionCallback callback;
848 // Set the additional error state members to ensure that they get cleared.
849 handle.set_is_ssl_error(true);
850 HttpResponseInfo info;
851 info.headers = new HttpResponseHeaders(std::string());
852 handle.set_ssl_error_response_info(info);
853 EXPECT_EQ(ERR_CONNECTION_FAILED,
854 handle.Init("a",
855 params_,
856 DEFAULT_PRIORITY,
857 callback.callback(),
858 pool_.get(),
859 log.bound()));
860 EXPECT_FALSE(handle.socket());
861 EXPECT_FALSE(handle.is_ssl_error());
862 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
863 TestLoadTimingInfoNotConnected(handle);
864
865 CapturingNetLog::CapturedEntryList entries;
866 log.GetEntries(&entries);
867
868 EXPECT_EQ(3u, entries.size());
869 EXPECT_TRUE(LogContainsBeginEvent(
870 entries, 0, NetLog::TYPE_SOCKET_POOL));
871 EXPECT_TRUE(LogContainsEvent(
872 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
873 NetLog::PHASE_NONE));
874 EXPECT_TRUE(LogContainsEndEvent(
875 entries, 2, NetLog::TYPE_SOCKET_POOL));
876 }
877
878 TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
879 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
880
881 // TODO(eroman): Check that the NetLog contains this event.
882
883 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
884 EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
885 EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
886 EXPECT_EQ(OK, StartRequest("d", DEFAULT_PRIORITY));
887
888 EXPECT_EQ(static_cast<int>(requests_size()),
889 client_socket_factory_.allocation_count());
890 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
891
892 EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
893 EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", DEFAULT_PRIORITY));
894 EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", DEFAULT_PRIORITY));
895
896 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
897
898 EXPECT_EQ(static_cast<int>(requests_size()),
899 client_socket_factory_.allocation_count());
900 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
901
902 EXPECT_EQ(1, GetOrderOfRequest(1));
903 EXPECT_EQ(2, GetOrderOfRequest(2));
904 EXPECT_EQ(3, GetOrderOfRequest(3));
905 EXPECT_EQ(4, GetOrderOfRequest(4));
906 EXPECT_EQ(5, GetOrderOfRequest(5));
907 EXPECT_EQ(6, GetOrderOfRequest(6));
908 EXPECT_EQ(7, GetOrderOfRequest(7));
909
910 // Make sure we test order of all requests made.
911 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
912 }
913
914 TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) {
915 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
916
917 // TODO(eroman): Check that the NetLog contains this event.
918
919 // Reach all limits: max total sockets, and max sockets per group.
920 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
921 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
922 EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
923 EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
924
925 EXPECT_EQ(static_cast<int>(requests_size()),
926 client_socket_factory_.allocation_count());
927 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
928
929 // Now create a new group and verify that we don't starve it.
930 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
931
932 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
933
934 EXPECT_EQ(static_cast<int>(requests_size()),
935 client_socket_factory_.allocation_count());
936 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
937
938 EXPECT_EQ(1, GetOrderOfRequest(1));
939 EXPECT_EQ(2, GetOrderOfRequest(2));
940 EXPECT_EQ(3, GetOrderOfRequest(3));
941 EXPECT_EQ(4, GetOrderOfRequest(4));
942 EXPECT_EQ(5, GetOrderOfRequest(5));
943
944 // Make sure we test order of all requests made.
945 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6));
946 }
947
948 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsPriority) {
949 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
950
951 EXPECT_EQ(OK, StartRequest("b", LOWEST));
952 EXPECT_EQ(OK, StartRequest("a", MEDIUM));
953 EXPECT_EQ(OK, StartRequest("b", HIGHEST));
954 EXPECT_EQ(OK, StartRequest("a", LOWEST));
955
956 EXPECT_EQ(static_cast<int>(requests_size()),
957 client_socket_factory_.allocation_count());
958
959 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", LOWEST));
960 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
961 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST));
962
963 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
964
965 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
966
967 // First 4 requests don't have to wait, and finish in order.
968 EXPECT_EQ(1, GetOrderOfRequest(1));
969 EXPECT_EQ(2, GetOrderOfRequest(2));
970 EXPECT_EQ(3, GetOrderOfRequest(3));
971 EXPECT_EQ(4, GetOrderOfRequest(4));
972
973 // Request ("b", HIGHEST) has the highest priority, then ("a", MEDIUM),
974 // and then ("c", LOWEST).
975 EXPECT_EQ(7, GetOrderOfRequest(5));
976 EXPECT_EQ(6, GetOrderOfRequest(6));
977 EXPECT_EQ(5, GetOrderOfRequest(7));
978
979 // Make sure we test order of all requests made.
980 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9));
981 }
982
983 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsGroupLimit) {
984 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
985
986 EXPECT_EQ(OK, StartRequest("a", LOWEST));
987 EXPECT_EQ(OK, StartRequest("a", LOW));
988 EXPECT_EQ(OK, StartRequest("b", HIGHEST));
989 EXPECT_EQ(OK, StartRequest("b", MEDIUM));
990
991 EXPECT_EQ(static_cast<int>(requests_size()),
992 client_socket_factory_.allocation_count());
993
994 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", MEDIUM));
995 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
996 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST));
997
998 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
999
1000 EXPECT_EQ(static_cast<int>(requests_size()),
1001 client_socket_factory_.allocation_count());
1002 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
1003
1004 // First 4 requests don't have to wait, and finish in order.
1005 EXPECT_EQ(1, GetOrderOfRequest(1));
1006 EXPECT_EQ(2, GetOrderOfRequest(2));
1007 EXPECT_EQ(3, GetOrderOfRequest(3));
1008 EXPECT_EQ(4, GetOrderOfRequest(4));
1009
1010 // Request ("b", 7) has the highest priority, but we can't make new socket for
1011 // group "b", because it has reached the per-group limit. Then we make
1012 // socket for ("c", 6), because it has higher priority than ("a", 4),
1013 // and we still can't make a socket for group "b".
1014 EXPECT_EQ(5, GetOrderOfRequest(5));
1015 EXPECT_EQ(6, GetOrderOfRequest(6));
1016 EXPECT_EQ(7, GetOrderOfRequest(7));
1017
1018 // Make sure we test order of all requests made.
1019 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
1020 }
1021
1022 // Make sure that we count connecting sockets against the total limit.
1023 TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
1024 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1025
1026 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1027 EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
1028 EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
1029
1030 // Create one asynchronous request.
1031 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1032 EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", DEFAULT_PRIORITY));
1033
1034 // We post all of our delayed tasks with a 2ms delay. I.e. they don't
1035 // actually become pending until 2ms after they have been created. In order
1036 // to flush all tasks, we need to wait so that we know there are no
1037 // soon-to-be-pending tasks waiting.
1038 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
1039 base::MessageLoop::current()->RunUntilIdle();
1040
1041 // The next synchronous request should wait for its turn.
1042 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1043 EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
1044
1045 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1046
1047 EXPECT_EQ(static_cast<int>(requests_size()),
1048 client_socket_factory_.allocation_count());
1049
1050 EXPECT_EQ(1, GetOrderOfRequest(1));
1051 EXPECT_EQ(2, GetOrderOfRequest(2));
1052 EXPECT_EQ(3, GetOrderOfRequest(3));
1053 EXPECT_EQ(4, GetOrderOfRequest(4));
1054 EXPECT_EQ(5, GetOrderOfRequest(5));
1055
1056 // Make sure we test order of all requests made.
1057 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6));
1058 }
1059
1060 TEST_F(ClientSocketPoolBaseTest, CorrectlyCountStalledGroups) {
1061 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
1062 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1063
1064 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1065 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1066 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1067 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1068
1069 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1070
1071 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1072
1073 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", DEFAULT_PRIORITY));
1074 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
1075
1076 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1077
1078 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1079 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
1080 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1081 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
1082 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1083 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1084 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
1085 }
1086
1087 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
1088 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
1089 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1090
1091 ClientSocketHandle handle;
1092 TestCompletionCallback callback;
1093 EXPECT_EQ(ERR_IO_PENDING,
1094 handle.Init("a",
1095 params_,
1096 DEFAULT_PRIORITY,
1097 callback.callback(),
1098 pool_.get(),
1099 BoundNetLog()));
1100
1101 ClientSocketHandle handles[4];
1102 for (size_t i = 0; i < arraysize(handles); ++i) {
1103 TestCompletionCallback callback;
1104 EXPECT_EQ(ERR_IO_PENDING,
1105 handles[i].Init("b",
1106 params_,
1107 DEFAULT_PRIORITY,
1108 callback.callback(),
1109 pool_.get(),
1110 BoundNetLog()));
1111 }
1112
1113 // One will be stalled, cancel all the handles now.
1114 // This should hit the OnAvailableSocketSlot() code where we previously had
1115 // stalled groups, but no longer have any.
1116 for (size_t i = 0; i < arraysize(handles); ++i)
1117 handles[i].Reset();
1118 }
1119
1120 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
1121 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1122 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1123
1124 {
1125 ClientSocketHandle handles[kDefaultMaxSockets];
1126 TestCompletionCallback callbacks[kDefaultMaxSockets];
1127 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1128 EXPECT_EQ(OK, handles[i].Init(base::IntToString(i),
1129 params_,
1130 DEFAULT_PRIORITY,
1131 callbacks[i].callback(),
1132 pool_.get(),
1133 BoundNetLog()));
1134 }
1135
1136 // Force a stalled group.
1137 ClientSocketHandle stalled_handle;
1138 TestCompletionCallback callback;
1139 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
1140 params_,
1141 DEFAULT_PRIORITY,
1142 callback.callback(),
1143 pool_.get(),
1144 BoundNetLog()));
1145
1146 // Cancel the stalled request.
1147 stalled_handle.Reset();
1148
1149 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1150 EXPECT_EQ(0, pool_->IdleSocketCount());
1151
1152 // Dropping out of scope will close all handles and return them to idle.
1153 }
1154
1155 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1156 EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount());
1157 }
1158
1159 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
1160 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1161 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1162
1163 {
1164 ClientSocketHandle handles[kDefaultMaxSockets];
1165 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1166 TestCompletionCallback callback;
1167 EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i),
1168 params_,
1169 DEFAULT_PRIORITY,
1170 callback.callback(),
1171 pool_.get(),
1172 BoundNetLog()));
1173 }
1174
1175 // Force a stalled group.
1176 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1177 ClientSocketHandle stalled_handle;
1178 TestCompletionCallback callback;
1179 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
1180 params_,
1181 DEFAULT_PRIORITY,
1182 callback.callback(),
1183 pool_.get(),
1184 BoundNetLog()));
1185
1186 // Since it is stalled, it should have no connect jobs.
1187 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
1188 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
1189
1190 // Cancel the stalled request.
1191 handles[0].Reset();
1192
1193 // Now we should have a connect job.
1194 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("foo"));
1195 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
1196
1197 // The stalled socket should connect.
1198 EXPECT_EQ(OK, callback.WaitForResult());
1199
1200 EXPECT_EQ(kDefaultMaxSockets + 1,
1201 client_socket_factory_.allocation_count());
1202 EXPECT_EQ(0, pool_->IdleSocketCount());
1203 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
1204 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
1205
1206 // Dropping out of scope will close all handles and return them to idle.
1207 }
1208
1209 EXPECT_EQ(1, pool_->IdleSocketCount());
1210 }
1211
1212 TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
1213 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1214 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1215
1216 ClientSocketHandle stalled_handle;
1217 TestCompletionCallback callback;
1218 {
1219 EXPECT_FALSE(pool_->IsStalled());
1220 ClientSocketHandle handles[kDefaultMaxSockets];
1221 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1222 TestCompletionCallback callback;
1223 EXPECT_EQ(OK, handles[i].Init(base::StringPrintf(
1224 "Take 2: %d", i),
1225 params_,
1226 DEFAULT_PRIORITY,
1227 callback.callback(),
1228 pool_.get(),
1229 BoundNetLog()));
1230 }
1231
1232 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1233 EXPECT_EQ(0, pool_->IdleSocketCount());
1234 EXPECT_FALSE(pool_->IsStalled());
1235
1236 // Now we will hit the socket limit.
1237 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
1238 params_,
1239 DEFAULT_PRIORITY,
1240 callback.callback(),
1241 pool_.get(),
1242 BoundNetLog()));
1243 EXPECT_TRUE(pool_->IsStalled());
1244
1245 // Dropping out of scope will close all handles and return them to idle.
1246 }
1247
1248 // But if we wait for it, the released idle sockets will be closed in
1249 // preference of the waiting request.
1250 EXPECT_EQ(OK, callback.WaitForResult());
1251
1252 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
1253 EXPECT_EQ(3, pool_->IdleSocketCount());
1254 }
1255
1256 // Regression test for http://crbug.com/40952.
1257 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
1258 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1259 pool_->EnableConnectBackupJobs();
1260 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1261
1262 for (int i = 0; i < kDefaultMaxSockets; ++i) {
1263 ClientSocketHandle handle;
1264 TestCompletionCallback callback;
1265 EXPECT_EQ(OK, handle.Init(base::IntToString(i),
1266 params_,
1267 DEFAULT_PRIORITY,
1268 callback.callback(),
1269 pool_.get(),
1270 BoundNetLog()));
1271 }
1272
1273 // Flush all the DoReleaseSocket tasks.
1274 base::MessageLoop::current()->RunUntilIdle();
1275
1276 // Stall a group. Set a pending job so it'll trigger a backup job if we don't
1277 // reuse a socket.
1278 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1279 ClientSocketHandle handle;
1280 TestCompletionCallback callback;
1281
1282 // "0" is special here, since it should be the first entry in the sorted map,
1283 // which is the one which we would close an idle socket for. We shouldn't
1284 // close an idle socket though, since we should reuse the idle socket.
1285 EXPECT_EQ(OK, handle.Init("0",
1286 params_,
1287 DEFAULT_PRIORITY,
1288 callback.callback(),
1289 pool_.get(),
1290 BoundNetLog()));
1291
1292 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1293 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
1294 }
1295
1296 TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
1297 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1298
1299 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1300 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1301 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", IDLE));
1302 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1303 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1304 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1305 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1306 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1307
1308 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
1309
1310 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1311 client_socket_factory_.allocation_count());
1312 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1313 completion_count());
1314
1315 EXPECT_EQ(1, GetOrderOfRequest(1));
1316 EXPECT_EQ(2, GetOrderOfRequest(2));
1317 EXPECT_EQ(8, GetOrderOfRequest(3));
1318 EXPECT_EQ(6, GetOrderOfRequest(4));
1319 EXPECT_EQ(4, GetOrderOfRequest(5));
1320 EXPECT_EQ(3, GetOrderOfRequest(6));
1321 EXPECT_EQ(5, GetOrderOfRequest(7));
1322 EXPECT_EQ(7, GetOrderOfRequest(8));
1323
1324 // Make sure we test order of all requests made.
1325 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9));
1326 }
1327
1328 TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) {
1329 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1330
1331 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1332 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1333 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1334 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1335 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1336 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1337 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1338
1339 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1340
1341 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i)
1342 EXPECT_EQ(OK, request(i)->WaitForResult());
1343
1344 EXPECT_EQ(static_cast<int>(requests_size()),
1345 client_socket_factory_.allocation_count());
1346 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1347 completion_count());
1348 }
1349
1350 // This test will start up a RequestSocket() and then immediately Cancel() it.
1351 // The pending connect job will be cancelled and should not call back into
1352 // ClientSocketPoolBase.
1353 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
1354 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1355
1356 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1357 ClientSocketHandle handle;
1358 TestCompletionCallback callback;
1359 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
1360 params_,
1361 DEFAULT_PRIORITY,
1362 callback.callback(),
1363 pool_.get(),
1364 BoundNetLog()));
1365 handle.Reset();
1366 }
1367
1368 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
1369 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1370
1371 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1372 ClientSocketHandle handle;
1373 TestCompletionCallback callback;
1374
1375 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
1376 params_,
1377 DEFAULT_PRIORITY,
1378 callback.callback(),
1379 pool_.get(),
1380 BoundNetLog()));
1381
1382 handle.Reset();
1383
1384 TestCompletionCallback callback2;
1385 EXPECT_EQ(ERR_IO_PENDING,
1386 handle.Init("a",
1387 params_,
1388 DEFAULT_PRIORITY,
1389 callback2.callback(),
1390 pool_.get(),
1391 BoundNetLog()));
1392
1393 EXPECT_EQ(OK, callback2.WaitForResult());
1394 EXPECT_FALSE(callback.have_result());
1395
1396 handle.Reset();
1397 }
1398
1399 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
1400 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1401
1402 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1403 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1404 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1405 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1406 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1407 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1408 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1409
1410 // Cancel a request.
1411 size_t index_to_cancel = kDefaultMaxSocketsPerGroup + 2;
1412 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
1413 (*requests())[index_to_cancel]->handle()->Reset();
1414
1415 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
1416
1417 EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1418 client_socket_factory_.allocation_count());
1419 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup - 1,
1420 completion_count());
1421
1422 EXPECT_EQ(1, GetOrderOfRequest(1));
1423 EXPECT_EQ(2, GetOrderOfRequest(2));
1424 EXPECT_EQ(5, GetOrderOfRequest(3));
1425 EXPECT_EQ(3, GetOrderOfRequest(4));
1426 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
1427 GetOrderOfRequest(5)); // Canceled request.
1428 EXPECT_EQ(4, GetOrderOfRequest(6));
1429 EXPECT_EQ(6, GetOrderOfRequest(7));
1430
1431 // Make sure we test order of all requests made.
1432 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
1433 }
1434
1435 class RequestSocketCallback : public TestCompletionCallbackBase {
1436 public:
1437 RequestSocketCallback(ClientSocketHandle* handle,
1438 TestClientSocketPool* pool,
1439 TestConnectJobFactory* test_connect_job_factory,
1440 TestConnectJob::JobType next_job_type)
1441 : handle_(handle),
1442 pool_(pool),
1443 within_callback_(false),
1444 test_connect_job_factory_(test_connect_job_factory),
1445 next_job_type_(next_job_type),
1446 callback_(base::Bind(&RequestSocketCallback::OnComplete,
1447 base::Unretained(this))) {
1448 }
1449
1450 ~RequestSocketCallback() override {}
1451
1452 const CompletionCallback& callback() const { return callback_; }
1453
1454 private:
1455 void OnComplete(int result) {
1456 SetResult(result);
1457 ASSERT_EQ(OK, result);
1458
1459 if (!within_callback_) {
1460 test_connect_job_factory_->set_job_type(next_job_type_);
1461
1462 // Don't allow reuse of the socket. Disconnect it and then release it and
1463 // run through the MessageLoop once to get it completely released.
1464 handle_->socket()->Disconnect();
1465 handle_->Reset();
1466 {
1467 // TODO: Resolve conflicting intentions of stopping recursion with the
1468 // |!within_callback_| test (above) and the call to |RunUntilIdle()|
1469 // below. http://crbug.com/114130.
1470 base::MessageLoop::ScopedNestableTaskAllower allow(
1471 base::MessageLoop::current());
1472 base::MessageLoop::current()->RunUntilIdle();
1473 }
1474 within_callback_ = true;
1475 TestCompletionCallback next_job_callback;
1476 scoped_refptr<TestSocketParams> params(
1477 new TestSocketParams(false /* ignore_limits */));
1478 int rv = handle_->Init("a",
1479 params,
1480 DEFAULT_PRIORITY,
1481 next_job_callback.callback(),
1482 pool_,
1483 BoundNetLog());
1484 switch (next_job_type_) {
1485 case TestConnectJob::kMockJob:
1486 EXPECT_EQ(OK, rv);
1487 break;
1488 case TestConnectJob::kMockPendingJob:
1489 EXPECT_EQ(ERR_IO_PENDING, rv);
1490
1491 // For pending jobs, wait for new socket to be created. This makes
1492 // sure there are no more pending operations nor any unclosed sockets
1493 // when the test finishes.
1494 // We need to give it a little bit of time to run, so that all the
1495 // operations that happen on timers (e.g. cleanup of idle
1496 // connections) can execute.
1497 {
1498 base::MessageLoop::ScopedNestableTaskAllower allow(
1499 base::MessageLoop::current());
1500 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
1501 EXPECT_EQ(OK, next_job_callback.WaitForResult());
1502 }
1503 break;
1504 default:
1505 FAIL() << "Unexpected job type: " << next_job_type_;
1506 break;
1507 }
1508 }
1509 }
1510
1511 ClientSocketHandle* const handle_;
1512 TestClientSocketPool* const pool_;
1513 bool within_callback_;
1514 TestConnectJobFactory* const test_connect_job_factory_;
1515 TestConnectJob::JobType next_job_type_;
1516 CompletionCallback callback_;
1517 };
1518
1519 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
1520 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1521
1522 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1523 ClientSocketHandle handle;
1524 RequestSocketCallback callback(
1525 &handle, pool_.get(), connect_job_factory_,
1526 TestConnectJob::kMockPendingJob);
1527 int rv = handle.Init("a",
1528 params_,
1529 DEFAULT_PRIORITY,
1530 callback.callback(),
1531 pool_.get(),
1532 BoundNetLog());
1533 ASSERT_EQ(ERR_IO_PENDING, rv);
1534
1535 EXPECT_EQ(OK, callback.WaitForResult());
1536 }
1537
1538 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
1539 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1540
1541 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1542 ClientSocketHandle handle;
1543 RequestSocketCallback callback(
1544 &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
1545 int rv = handle.Init("a",
1546 params_,
1547 DEFAULT_PRIORITY,
1548 callback.callback(),
1549 pool_.get(),
1550 BoundNetLog());
1551 ASSERT_EQ(ERR_IO_PENDING, rv);
1552
1553 EXPECT_EQ(OK, callback.WaitForResult());
1554 }
1555
1556 // Make sure that pending requests get serviced after active requests get
1557 // cancelled.
1558 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
1559 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1560
1561 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1562
1563 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1564 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1565 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1566 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1567 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1568 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1569 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1570
1571 // Now, kDefaultMaxSocketsPerGroup requests should be active.
1572 // Let's cancel them.
1573 for (int i = 0; i < kDefaultMaxSocketsPerGroup; ++i) {
1574 ASSERT_FALSE(request(i)->handle()->is_initialized());
1575 request(i)->handle()->Reset();
1576 }
1577
1578 // Let's wait for the rest to complete now.
1579 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i) {
1580 EXPECT_EQ(OK, request(i)->WaitForResult());
1581 request(i)->handle()->Reset();
1582 }
1583
1584 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1585 completion_count());
1586 }
1587
1588 // Make sure that pending requests get serviced after active requests fail.
1589 TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) {
1590 const size_t kMaxSockets = 5;
1591 CreatePool(kMaxSockets, kDefaultMaxSocketsPerGroup);
1592
1593 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1594
1595 const size_t kNumberOfRequests = 2 * kDefaultMaxSocketsPerGroup + 1;
1596 ASSERT_LE(kNumberOfRequests, kMaxSockets); // Otherwise the test will hang.
1597
1598 // Queue up all the requests
1599 for (size_t i = 0; i < kNumberOfRequests; ++i)
1600 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1601
1602 for (size_t i = 0; i < kNumberOfRequests; ++i)
1603 EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult());
1604 }
1605
1606 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
1607 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1608
1609 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1610
1611 ClientSocketHandle handle;
1612 TestCompletionCallback callback;
1613 int rv = handle.Init("a",
1614 params_,
1615 DEFAULT_PRIORITY,
1616 callback.callback(),
1617 pool_.get(),
1618 BoundNetLog());
1619 EXPECT_EQ(ERR_IO_PENDING, rv);
1620
1621 // Cancel the active request.
1622 handle.Reset();
1623
1624 rv = handle.Init("a",
1625 params_,
1626 DEFAULT_PRIORITY,
1627 callback.callback(),
1628 pool_.get(),
1629 BoundNetLog());
1630 EXPECT_EQ(ERR_IO_PENDING, rv);
1631 EXPECT_EQ(OK, callback.WaitForResult());
1632
1633 EXPECT_FALSE(handle.is_reused());
1634 TestLoadTimingInfoConnectedNotReused(handle);
1635 EXPECT_EQ(2, client_socket_factory_.allocation_count());
1636 }
1637
1638 // Regression test for http://crbug.com/17985.
1639 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
1640 const int kMaxSockets = 3;
1641 const int kMaxSocketsPerGroup = 2;
1642 CreatePool(kMaxSockets, kMaxSocketsPerGroup);
1643
1644 const RequestPriority kHighPriority = HIGHEST;
1645
1646 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1647 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1648
1649 // This is going to be a pending request in an otherwise empty group.
1650 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1651
1652 // Reach the maximum socket limit.
1653 EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
1654
1655 // Create a stalled group with high priorities.
1656 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority));
1657 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority));
1658
1659 // Release the first two sockets from "a". Because this is a keepalive,
1660 // the first release will unblock the pending request for "a". The
1661 // second release will unblock a request for "c", becaue it is the next
1662 // high priority socket.
1663 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1664 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1665
1666 // Closing idle sockets should not get us into trouble, but in the bug
1667 // we were hitting a CHECK here.
1668 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
1669 pool_->CloseIdleSockets();
1670
1671 // Run the released socket wakeups.
1672 base::MessageLoop::current()->RunUntilIdle();
1673 }
1674
1675 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
1676 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1677
1678 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1679 ClientSocketHandle handle;
1680 TestCompletionCallback callback;
1681 CapturingBoundNetLog log;
1682 int rv = handle.Init("a",
1683 params_,
1684 LOWEST,
1685 callback.callback(),
1686 pool_.get(),
1687 log.bound());
1688 EXPECT_EQ(ERR_IO_PENDING, rv);
1689 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
1690 TestLoadTimingInfoNotConnected(handle);
1691
1692 EXPECT_EQ(OK, callback.WaitForResult());
1693 EXPECT_TRUE(handle.is_initialized());
1694 EXPECT_TRUE(handle.socket());
1695 TestLoadTimingInfoConnectedNotReused(handle);
1696
1697 handle.Reset();
1698 TestLoadTimingInfoNotConnected(handle);
1699
1700 CapturingNetLog::CapturedEntryList entries;
1701 log.GetEntries(&entries);
1702
1703 EXPECT_EQ(4u, entries.size());
1704 EXPECT_TRUE(LogContainsBeginEvent(
1705 entries, 0, NetLog::TYPE_SOCKET_POOL));
1706 EXPECT_TRUE(LogContainsEvent(
1707 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
1708 NetLog::PHASE_NONE));
1709 EXPECT_TRUE(LogContainsEvent(
1710 entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
1711 NetLog::PHASE_NONE));
1712 EXPECT_TRUE(LogContainsEndEvent(
1713 entries, 3, NetLog::TYPE_SOCKET_POOL));
1714 }
1715
1716 TEST_F(ClientSocketPoolBaseTest,
1717 InitConnectionAsynchronousFailure) {
1718 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1719
1720 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1721 ClientSocketHandle handle;
1722 TestCompletionCallback callback;
1723 CapturingBoundNetLog log;
1724 // Set the additional error state members to ensure that they get cleared.
1725 handle.set_is_ssl_error(true);
1726 HttpResponseInfo info;
1727 info.headers = new HttpResponseHeaders(std::string());
1728 handle.set_ssl_error_response_info(info);
1729 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
1730 params_,
1731 DEFAULT_PRIORITY,
1732 callback.callback(),
1733 pool_.get(),
1734 log.bound()));
1735 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
1736 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
1737 EXPECT_FALSE(handle.is_ssl_error());
1738 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
1739
1740 CapturingNetLog::CapturedEntryList entries;
1741 log.GetEntries(&entries);
1742
1743 EXPECT_EQ(3u, entries.size());
1744 EXPECT_TRUE(LogContainsBeginEvent(
1745 entries, 0, NetLog::TYPE_SOCKET_POOL));
1746 EXPECT_TRUE(LogContainsEvent(
1747 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
1748 NetLog::PHASE_NONE));
1749 EXPECT_TRUE(LogContainsEndEvent(
1750 entries, 2, NetLog::TYPE_SOCKET_POOL));
1751 }
1752
1753 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
1754 // TODO(eroman): Add back the log expectations! Removed them because the
1755 // ordering is difficult, and some may fire during destructor.
1756 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1757
1758 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1759 ClientSocketHandle handle;
1760 TestCompletionCallback callback;
1761 ClientSocketHandle handle2;
1762 TestCompletionCallback callback2;
1763
1764 EXPECT_EQ(ERR_IO_PENDING,
1765 handle.Init("a",
1766 params_,
1767 DEFAULT_PRIORITY,
1768 callback.callback(),
1769 pool_.get(),
1770 BoundNetLog()));
1771 CapturingBoundNetLog log2;
1772 EXPECT_EQ(ERR_IO_PENDING,
1773 handle2.Init("a",
1774 params_,
1775 DEFAULT_PRIORITY,
1776 callback2.callback(),
1777 pool_.get(),
1778 BoundNetLog()));
1779
1780 handle.Reset();
1781
1782
1783 // At this point, request 2 is just waiting for the connect job to finish.
1784
1785 EXPECT_EQ(OK, callback2.WaitForResult());
1786 handle2.Reset();
1787
1788 // Now request 2 has actually finished.
1789 // TODO(eroman): Add back log expectations.
1790 }
1791
1792 TEST_F(ClientSocketPoolBaseTest, CancelRequestLimitsJobs) {
1793 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1794
1795 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1796
1797 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1798 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1799 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1800 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1801
1802 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1803 (*requests())[2]->handle()->Reset();
1804 (*requests())[3]->handle()->Reset();
1805 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1806
1807 (*requests())[1]->handle()->Reset();
1808 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1809
1810 (*requests())[0]->handle()->Reset();
1811 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1812 }
1813
1814 // When requests and ConnectJobs are not coupled, the request will get serviced
1815 // by whatever comes first.
1816 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
1817 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1818
1819 // Start job 1 (async OK)
1820 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1821
1822 std::vector<TestSocketRequest*> request_order;
1823 size_t completion_count; // unused
1824 TestSocketRequest req1(&request_order, &completion_count);
1825 int rv = req1.handle()->Init("a",
1826 params_,
1827 DEFAULT_PRIORITY,
1828 req1.callback(), pool_.get(),
1829 BoundNetLog());
1830 EXPECT_EQ(ERR_IO_PENDING, rv);
1831 EXPECT_EQ(OK, req1.WaitForResult());
1832
1833 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending
1834 // without a job.
1835 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1836
1837 TestSocketRequest req2(&request_order, &completion_count);
1838 rv = req2.handle()->Init("a",
1839 params_,
1840 DEFAULT_PRIORITY,
1841 req2.callback(),
1842 pool_.get(),
1843 BoundNetLog());
1844 EXPECT_EQ(ERR_IO_PENDING, rv);
1845 TestSocketRequest req3(&request_order, &completion_count);
1846 rv = req3.handle()->Init("a",
1847 params_,
1848 DEFAULT_PRIORITY,
1849 req3.callback(),
1850 pool_.get(),
1851 BoundNetLog());
1852 EXPECT_EQ(ERR_IO_PENDING, rv);
1853
1854 // Both Requests 2 and 3 are pending. We release socket 1 which should
1855 // service request 2. Request 3 should still be waiting.
1856 req1.handle()->Reset();
1857 // Run the released socket wakeups.
1858 base::MessageLoop::current()->RunUntilIdle();
1859 ASSERT_TRUE(req2.handle()->socket());
1860 EXPECT_EQ(OK, req2.WaitForResult());
1861 EXPECT_FALSE(req3.handle()->socket());
1862
1863 // Signal job 2, which should service request 3.
1864
1865 client_socket_factory_.SignalJobs();
1866 EXPECT_EQ(OK, req3.WaitForResult());
1867
1868 ASSERT_EQ(3U, request_order.size());
1869 EXPECT_EQ(&req1, request_order[0]);
1870 EXPECT_EQ(&req2, request_order[1]);
1871 EXPECT_EQ(&req3, request_order[2]);
1872 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
1873 }
1874
1875 // The requests are not coupled to the jobs. So, the requests should finish in
1876 // their priority / insertion order.
1877 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
1878 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1879 // First two jobs are async.
1880 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1881
1882 std::vector<TestSocketRequest*> request_order;
1883 size_t completion_count; // unused
1884 TestSocketRequest req1(&request_order, &completion_count);
1885 int rv = req1.handle()->Init("a",
1886 params_,
1887 DEFAULT_PRIORITY,
1888 req1.callback(),
1889 pool_.get(),
1890 BoundNetLog());
1891 EXPECT_EQ(ERR_IO_PENDING, rv);
1892
1893 TestSocketRequest req2(&request_order, &completion_count);
1894 rv = req2.handle()->Init("a",
1895 params_,
1896 DEFAULT_PRIORITY,
1897 req2.callback(),
1898 pool_.get(),
1899 BoundNetLog());
1900 EXPECT_EQ(ERR_IO_PENDING, rv);
1901
1902 // The pending job is sync.
1903 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1904
1905 TestSocketRequest req3(&request_order, &completion_count);
1906 rv = req3.handle()->Init("a",
1907 params_,
1908 DEFAULT_PRIORITY,
1909 req3.callback(),
1910 pool_.get(),
1911 BoundNetLog());
1912 EXPECT_EQ(ERR_IO_PENDING, rv);
1913
1914 EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
1915 EXPECT_EQ(OK, req2.WaitForResult());
1916 EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult());
1917
1918 ASSERT_EQ(3U, request_order.size());
1919 EXPECT_EQ(&req1, request_order[0]);
1920 EXPECT_EQ(&req2, request_order[1]);
1921 EXPECT_EQ(&req3, request_order[2]);
1922 }
1923
1924 // Test GetLoadState in the case there's only one socket request.
1925 TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) {
1926 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1927 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1928
1929 ClientSocketHandle handle;
1930 TestCompletionCallback callback;
1931 int rv = handle.Init("a",
1932 params_,
1933 DEFAULT_PRIORITY,
1934 callback.callback(),
1935 pool_.get(),
1936 BoundNetLog());
1937 EXPECT_EQ(ERR_IO_PENDING, rv);
1938 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1939
1940 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
1941 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
1942
1943 // No point in completing the connection, since ClientSocketHandles only
1944 // expect the LoadState to be checked while connecting.
1945 }
1946
1947 // Test GetLoadState in the case there are two socket requests.
1948 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
1949 CreatePool(2, 2);
1950 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1951
1952 ClientSocketHandle handle;
1953 TestCompletionCallback callback;
1954 int rv = handle.Init("a",
1955 params_,
1956 DEFAULT_PRIORITY,
1957 callback.callback(),
1958 pool_.get(),
1959 BoundNetLog());
1960 EXPECT_EQ(ERR_IO_PENDING, rv);
1961
1962 ClientSocketHandle handle2;
1963 TestCompletionCallback callback2;
1964 rv = handle2.Init("a",
1965 params_,
1966 DEFAULT_PRIORITY,
1967 callback2.callback(),
1968 pool_.get(),
1969 BoundNetLog());
1970 EXPECT_EQ(ERR_IO_PENDING, rv);
1971
1972 // If the first Job is in an earlier state than the second, the state of
1973 // the second job should be used for both handles.
1974 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
1975 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1976 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
1977
1978 // If the second Job is in an earlier state than the second, the state of
1979 // the first job should be used for both handles.
1980 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
1981 // One request is farther
1982 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
1983 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
1984
1985 // Farthest along job connects and the first request gets the socket. The
1986 // second handle switches to the state of the remaining ConnectJob.
1987 client_socket_factory_.SignalJob(0);
1988 EXPECT_EQ(OK, callback.WaitForResult());
1989 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
1990 }
1991
1992 // Test GetLoadState in the case the per-group limit is reached.
1993 TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
1994 CreatePool(2, 1);
1995 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1996
1997 ClientSocketHandle handle;
1998 TestCompletionCallback callback;
1999 int rv = handle.Init("a",
2000 params_,
2001 MEDIUM,
2002 callback.callback(),
2003 pool_.get(),
2004 BoundNetLog());
2005 EXPECT_EQ(ERR_IO_PENDING, rv);
2006 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2007
2008 // Request another socket from the same pool, buth with a higher priority.
2009 // The first request should now be stalled at the socket group limit.
2010 ClientSocketHandle handle2;
2011 TestCompletionCallback callback2;
2012 rv = handle2.Init("a",
2013 params_,
2014 HIGHEST,
2015 callback2.callback(),
2016 pool_.get(),
2017 BoundNetLog());
2018 EXPECT_EQ(ERR_IO_PENDING, rv);
2019 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2020 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
2021
2022 // The first handle should remain stalled as the other socket goes through
2023 // the connect process.
2024
2025 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2026 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2027 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
2028
2029 client_socket_factory_.SignalJob(0);
2030 EXPECT_EQ(OK, callback2.WaitForResult());
2031 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2032
2033 // Closing the second socket should cause the stalled handle to finally get a
2034 // ConnectJob.
2035 handle2.socket()->Disconnect();
2036 handle2.Reset();
2037 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2038 }
2039
2040 // Test GetLoadState in the case the per-pool limit is reached.
2041 TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
2042 CreatePool(2, 2);
2043 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2044
2045 ClientSocketHandle handle;
2046 TestCompletionCallback callback;
2047 int rv = handle.Init("a",
2048 params_,
2049 DEFAULT_PRIORITY,
2050 callback.callback(),
2051 pool_.get(),
2052 BoundNetLog());
2053 EXPECT_EQ(ERR_IO_PENDING, rv);
2054
2055 // Request for socket from another pool.
2056 ClientSocketHandle handle2;
2057 TestCompletionCallback callback2;
2058 rv = handle2.Init("b",
2059 params_,
2060 DEFAULT_PRIORITY,
2061 callback2.callback(),
2062 pool_.get(),
2063 BoundNetLog());
2064 EXPECT_EQ(ERR_IO_PENDING, rv);
2065
2066 // Request another socket from the first pool. Request should stall at the
2067 // socket pool limit.
2068 ClientSocketHandle handle3;
2069 TestCompletionCallback callback3;
2070 rv = handle3.Init("a",
2071 params_,
2072 DEFAULT_PRIORITY,
2073 callback2.callback(),
2074 pool_.get(),
2075 BoundNetLog());
2076 EXPECT_EQ(ERR_IO_PENDING, rv);
2077
2078 // The third handle should remain stalled as the other sockets in its group
2079 // goes through the connect process.
2080
2081 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2082 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2083
2084 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2085 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
2086 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2087
2088 client_socket_factory_.SignalJob(0);
2089 EXPECT_EQ(OK, callback.WaitForResult());
2090 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2091
2092 // Closing a socket should allow the stalled handle to finally get a new
2093 // ConnectJob.
2094 handle.socket()->Disconnect();
2095 handle.Reset();
2096 EXPECT_EQ(LOAD_STATE_CONNECTING, handle3.GetLoadState());
2097 }
2098
2099 TEST_F(ClientSocketPoolBaseTest, Recoverable) {
2100 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2101 connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob);
2102
2103 ClientSocketHandle handle;
2104 TestCompletionCallback callback;
2105 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED,
2106 handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(),
2107 pool_.get(), BoundNetLog()));
2108 EXPECT_TRUE(handle.is_initialized());
2109 EXPECT_TRUE(handle.socket());
2110 }
2111
2112 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) {
2113 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2114
2115 connect_job_factory_->set_job_type(
2116 TestConnectJob::kMockPendingRecoverableJob);
2117 ClientSocketHandle handle;
2118 TestCompletionCallback callback;
2119 EXPECT_EQ(ERR_IO_PENDING,
2120 handle.Init("a",
2121 params_,
2122 DEFAULT_PRIORITY,
2123 callback.callback(),
2124 pool_.get(),
2125 BoundNetLog()));
2126 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2127 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
2128 EXPECT_TRUE(handle.is_initialized());
2129 EXPECT_TRUE(handle.socket());
2130 }
2131
2132 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
2133 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2134 connect_job_factory_->set_job_type(
2135 TestConnectJob::kMockAdditionalErrorStateJob);
2136
2137 ClientSocketHandle handle;
2138 TestCompletionCallback callback;
2139 EXPECT_EQ(ERR_CONNECTION_FAILED,
2140 handle.Init("a",
2141 params_,
2142 DEFAULT_PRIORITY,
2143 callback.callback(),
2144 pool_.get(),
2145 BoundNetLog()));
2146 EXPECT_FALSE(handle.is_initialized());
2147 EXPECT_FALSE(handle.socket());
2148 EXPECT_TRUE(handle.is_ssl_error());
2149 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
2150 }
2151
2152 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
2153 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2154
2155 connect_job_factory_->set_job_type(
2156 TestConnectJob::kMockPendingAdditionalErrorStateJob);
2157 ClientSocketHandle handle;
2158 TestCompletionCallback callback;
2159 EXPECT_EQ(ERR_IO_PENDING,
2160 handle.Init("a",
2161 params_,
2162 DEFAULT_PRIORITY,
2163 callback.callback(),
2164 pool_.get(),
2165 BoundNetLog()));
2166 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2167 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
2168 EXPECT_FALSE(handle.is_initialized());
2169 EXPECT_FALSE(handle.socket());
2170 EXPECT_TRUE(handle.is_ssl_error());
2171 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
2172 }
2173
2174 // Make sure we can reuse sockets when the cleanup timer is disabled.
2175 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) {
2176 // Disable cleanup timer.
2177 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
2178
2179 CreatePoolWithIdleTimeouts(
2180 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2181 base::TimeDelta(), // Time out unused sockets immediately.
2182 base::TimeDelta::FromDays(1)); // Don't time out used sockets.
2183
2184 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2185
2186 ClientSocketHandle handle;
2187 TestCompletionCallback callback;
2188 int rv = handle.Init("a",
2189 params_,
2190 LOWEST,
2191 callback.callback(),
2192 pool_.get(),
2193 BoundNetLog());
2194 ASSERT_EQ(ERR_IO_PENDING, rv);
2195 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2196 ASSERT_EQ(OK, callback.WaitForResult());
2197
2198 // Use and release the socket.
2199 EXPECT_EQ(1, handle.socket()->Write(NULL, 1, CompletionCallback()));
2200 TestLoadTimingInfoConnectedNotReused(handle);
2201 handle.Reset();
2202
2203 // Should now have one idle socket.
2204 ASSERT_EQ(1, pool_->IdleSocketCount());
2205
2206 // Request a new socket. This should reuse the old socket and complete
2207 // synchronously.
2208 CapturingBoundNetLog log;
2209 rv = handle.Init("a",
2210 params_,
2211 LOWEST,
2212 CompletionCallback(),
2213 pool_.get(),
2214 log.bound());
2215 ASSERT_EQ(OK, rv);
2216 EXPECT_TRUE(handle.is_reused());
2217 TestLoadTimingInfoConnectedReused(handle);
2218
2219 ASSERT_TRUE(pool_->HasGroup("a"));
2220 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2221 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
2222
2223 CapturingNetLog::CapturedEntryList entries;
2224 log.GetEntries(&entries);
2225 EXPECT_TRUE(LogContainsEntryWithType(
2226 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
2227 }
2228
2229 // Make sure we cleanup old unused sockets when the cleanup timer is disabled.
2230 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerNoReuse) {
2231 // Disable cleanup timer.
2232 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
2233
2234 CreatePoolWithIdleTimeouts(
2235 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2236 base::TimeDelta(), // Time out unused sockets immediately
2237 base::TimeDelta()); // Time out used sockets immediately
2238
2239 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2240
2241 // Startup two mock pending connect jobs, which will sit in the MessageLoop.
2242
2243 ClientSocketHandle handle;
2244 TestCompletionCallback callback;
2245 int rv = handle.Init("a",
2246 params_,
2247 LOWEST,
2248 callback.callback(),
2249 pool_.get(),
2250 BoundNetLog());
2251 ASSERT_EQ(ERR_IO_PENDING, rv);
2252 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2253
2254 ClientSocketHandle handle2;
2255 TestCompletionCallback callback2;
2256 rv = handle2.Init("a",
2257 params_,
2258 LOWEST,
2259 callback2.callback(),
2260 pool_.get(),
2261 BoundNetLog());
2262 ASSERT_EQ(ERR_IO_PENDING, rv);
2263 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
2264
2265 // Cancel one of the requests. Wait for the other, which will get the first
2266 // job. Release the socket. Run the loop again to make sure the second
2267 // socket is sitting idle and the first one is released (since ReleaseSocket()
2268 // just posts a DoReleaseSocket() task).
2269
2270 handle.Reset();
2271 ASSERT_EQ(OK, callback2.WaitForResult());
2272 // Use the socket.
2273 EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
2274 handle2.Reset();
2275
2276 // We post all of our delayed tasks with a 2ms delay. I.e. they don't
2277 // actually become pending until 2ms after they have been created. In order
2278 // to flush all tasks, we need to wait so that we know there are no
2279 // soon-to-be-pending tasks waiting.
2280 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
2281 base::MessageLoop::current()->RunUntilIdle();
2282
2283 // Both sockets should now be idle.
2284 ASSERT_EQ(2, pool_->IdleSocketCount());
2285
2286 // Request a new socket. This should cleanup the unused and timed out ones.
2287 // A new socket will be created rather than reusing the idle one.
2288 CapturingBoundNetLog log;
2289 TestCompletionCallback callback3;
2290 rv = handle.Init("a",
2291 params_,
2292 LOWEST,
2293 callback3.callback(),
2294 pool_.get(),
2295 log.bound());
2296 ASSERT_EQ(ERR_IO_PENDING, rv);
2297 ASSERT_EQ(OK, callback3.WaitForResult());
2298 EXPECT_FALSE(handle.is_reused());
2299
2300 // Make sure the idle socket is closed.
2301 ASSERT_TRUE(pool_->HasGroup("a"));
2302 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2303 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
2304
2305 CapturingNetLog::CapturedEntryList entries;
2306 log.GetEntries(&entries);
2307 EXPECT_FALSE(LogContainsEntryWithType(
2308 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
2309 }
2310
2311 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
2312 CreatePoolWithIdleTimeouts(
2313 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2314 base::TimeDelta(), // Time out unused sockets immediately.
2315 base::TimeDelta::FromDays(1)); // Don't time out used sockets.
2316
2317 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2318
2319 // Startup two mock pending connect jobs, which will sit in the MessageLoop.
2320
2321 ClientSocketHandle handle;
2322 TestCompletionCallback callback;
2323 int rv = handle.Init("a",
2324 params_,
2325 LOWEST,
2326 callback.callback(),
2327 pool_.get(),
2328 BoundNetLog());
2329 EXPECT_EQ(ERR_IO_PENDING, rv);
2330 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2331
2332 ClientSocketHandle handle2;
2333 TestCompletionCallback callback2;
2334 rv = handle2.Init("a",
2335 params_,
2336 LOWEST,
2337 callback2.callback(),
2338 pool_.get(),
2339 BoundNetLog());
2340 EXPECT_EQ(ERR_IO_PENDING, rv);
2341 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
2342
2343 // Cancel one of the requests. Wait for the other, which will get the first
2344 // job. Release the socket. Run the loop again to make sure the second
2345 // socket is sitting idle and the first one is released (since ReleaseSocket()
2346 // just posts a DoReleaseSocket() task).
2347
2348 handle.Reset();
2349 EXPECT_EQ(OK, callback2.WaitForResult());
2350 // Use the socket.
2351 EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
2352 handle2.Reset();
2353
2354 // We post all of our delayed tasks with a 2ms delay. I.e. they don't
2355 // actually become pending until 2ms after they have been created. In order
2356 // to flush all tasks, we need to wait so that we know there are no
2357 // soon-to-be-pending tasks waiting.
2358 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
2359 base::MessageLoop::current()->RunUntilIdle();
2360
2361 ASSERT_EQ(2, pool_->IdleSocketCount());
2362
2363 // Invoke the idle socket cleanup check. Only one socket should be left, the
2364 // used socket. Request it to make sure that it's used.
2365
2366 pool_->CleanupTimedOutIdleSockets();
2367 CapturingBoundNetLog log;
2368 rv = handle.Init("a",
2369 params_,
2370 LOWEST,
2371 callback.callback(),
2372 pool_.get(),
2373 log.bound());
2374 EXPECT_EQ(OK, rv);
2375 EXPECT_TRUE(handle.is_reused());
2376
2377 CapturingNetLog::CapturedEntryList entries;
2378 log.GetEntries(&entries);
2379 EXPECT_TRUE(LogContainsEntryWithType(
2380 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
2381 }
2382
2383 // Make sure that we process all pending requests even when we're stalling
2384 // because of multiple releasing disconnected sockets.
2385 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
2386 CreatePoolWithIdleTimeouts(
2387 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2388 base::TimeDelta(), // Time out unused sockets immediately.
2389 base::TimeDelta::FromDays(1)); // Don't time out used sockets.
2390
2391 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2392
2393 // Startup 4 connect jobs. Two of them will be pending.
2394
2395 ClientSocketHandle handle;
2396 TestCompletionCallback callback;
2397 int rv = handle.Init("a",
2398 params_,
2399 LOWEST,
2400 callback.callback(),
2401 pool_.get(),
2402 BoundNetLog());
2403 EXPECT_EQ(OK, rv);
2404
2405 ClientSocketHandle handle2;
2406 TestCompletionCallback callback2;
2407 rv = handle2.Init("a",
2408 params_,
2409 LOWEST,
2410 callback2.callback(),
2411 pool_.get(),
2412 BoundNetLog());
2413 EXPECT_EQ(OK, rv);
2414
2415 ClientSocketHandle handle3;
2416 TestCompletionCallback callback3;
2417 rv = handle3.Init("a",
2418 params_,
2419 LOWEST,
2420 callback3.callback(),
2421 pool_.get(),
2422 BoundNetLog());
2423 EXPECT_EQ(ERR_IO_PENDING, rv);
2424
2425 ClientSocketHandle handle4;
2426 TestCompletionCallback callback4;
2427 rv = handle4.Init("a",
2428 params_,
2429 LOWEST,
2430 callback4.callback(),
2431 pool_.get(),
2432 BoundNetLog());
2433 EXPECT_EQ(ERR_IO_PENDING, rv);
2434
2435 // Release two disconnected sockets.
2436
2437 handle.socket()->Disconnect();
2438 handle.Reset();
2439 handle2.socket()->Disconnect();
2440 handle2.Reset();
2441
2442 EXPECT_EQ(OK, callback3.WaitForResult());
2443 EXPECT_FALSE(handle3.is_reused());
2444 EXPECT_EQ(OK, callback4.WaitForResult());
2445 EXPECT_FALSE(handle4.is_reused());
2446 }
2447
2448 // Regression test for http://crbug.com/42267.
2449 // When DoReleaseSocket() is processed for one socket, it is blocked because the
2450 // other stalled groups all have releasing sockets, so no progress can be made.
2451 TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) {
2452 CreatePoolWithIdleTimeouts(
2453 4 /* socket limit */, 4 /* socket limit per group */,
2454 base::TimeDelta(), // Time out unused sockets immediately.
2455 base::TimeDelta::FromDays(1)); // Don't time out used sockets.
2456
2457 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2458
2459 // Max out the socket limit with 2 per group.
2460
2461 ClientSocketHandle handle_a[4];
2462 TestCompletionCallback callback_a[4];
2463 ClientSocketHandle handle_b[4];
2464 TestCompletionCallback callback_b[4];
2465
2466 for (int i = 0; i < 2; ++i) {
2467 EXPECT_EQ(OK, handle_a[i].Init("a",
2468 params_,
2469 LOWEST,
2470 callback_a[i].callback(),
2471 pool_.get(),
2472 BoundNetLog()));
2473 EXPECT_EQ(OK, handle_b[i].Init("b",
2474 params_,
2475 LOWEST,
2476 callback_b[i].callback(),
2477 pool_.get(),
2478 BoundNetLog()));
2479 }
2480
2481 // Make 4 pending requests, 2 per group.
2482
2483 for (int i = 2; i < 4; ++i) {
2484 EXPECT_EQ(ERR_IO_PENDING,
2485 handle_a[i].Init("a",
2486 params_,
2487 LOWEST,
2488 callback_a[i].callback(),
2489 pool_.get(),
2490 BoundNetLog()));
2491 EXPECT_EQ(ERR_IO_PENDING,
2492 handle_b[i].Init("b",
2493 params_,
2494 LOWEST,
2495 callback_b[i].callback(),
2496 pool_.get(),
2497 BoundNetLog()));
2498 }
2499
2500 // Release b's socket first. The order is important, because in
2501 // DoReleaseSocket(), we'll process b's released socket, and since both b and
2502 // a are stalled, but 'a' is lower lexicographically, we'll process group 'a'
2503 // first, which has a releasing socket, so it refuses to start up another
2504 // ConnectJob. So, we used to infinite loop on this.
2505 handle_b[0].socket()->Disconnect();
2506 handle_b[0].Reset();
2507 handle_a[0].socket()->Disconnect();
2508 handle_a[0].Reset();
2509
2510 // Used to get stuck here.
2511 base::MessageLoop::current()->RunUntilIdle();
2512
2513 handle_b[1].socket()->Disconnect();
2514 handle_b[1].Reset();
2515 handle_a[1].socket()->Disconnect();
2516 handle_a[1].Reset();
2517
2518 for (int i = 2; i < 4; ++i) {
2519 EXPECT_EQ(OK, callback_b[i].WaitForResult());
2520 EXPECT_EQ(OK, callback_a[i].WaitForResult());
2521 }
2522 }
2523
2524 TEST_F(ClientSocketPoolBaseTest,
2525 ReleasingDisconnectedSocketsMaintainsPriorityOrder) {
2526 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2527
2528 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2529
2530 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2531 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2532 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2533 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2534
2535 EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
2536 EXPECT_EQ(OK, (*requests())[1]->WaitForResult());
2537 EXPECT_EQ(2u, completion_count());
2538
2539 // Releases one connection.
2540 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
2541 EXPECT_EQ(OK, (*requests())[2]->WaitForResult());
2542
2543 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
2544 EXPECT_EQ(OK, (*requests())[3]->WaitForResult());
2545 EXPECT_EQ(4u, completion_count());
2546
2547 EXPECT_EQ(1, GetOrderOfRequest(1));
2548 EXPECT_EQ(2, GetOrderOfRequest(2));
2549 EXPECT_EQ(3, GetOrderOfRequest(3));
2550 EXPECT_EQ(4, GetOrderOfRequest(4));
2551
2552 // Make sure we test order of all requests made.
2553 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5));
2554 }
2555
2556 class TestReleasingSocketRequest : public TestCompletionCallbackBase {
2557 public:
2558 TestReleasingSocketRequest(TestClientSocketPool* pool,
2559 int expected_result,
2560 bool reset_releasing_handle)
2561 : pool_(pool),
2562 expected_result_(expected_result),
2563 reset_releasing_handle_(reset_releasing_handle),
2564 callback_(base::Bind(&TestReleasingSocketRequest::OnComplete,
2565 base::Unretained(this))) {
2566 }
2567
2568 ~TestReleasingSocketRequest() override {}
2569
2570 ClientSocketHandle* handle() { return &handle_; }
2571
2572 const CompletionCallback& callback() const { return callback_; }
2573
2574 private:
2575 void OnComplete(int result) {
2576 SetResult(result);
2577 if (reset_releasing_handle_)
2578 handle_.Reset();
2579
2580 scoped_refptr<TestSocketParams> con_params(
2581 new TestSocketParams(false /* ignore_limits */));
2582 EXPECT_EQ(expected_result_,
2583 handle2_.Init("a", con_params, DEFAULT_PRIORITY,
2584 callback2_.callback(), pool_, BoundNetLog()));
2585 }
2586
2587 TestClientSocketPool* const pool_;
2588 int expected_result_;
2589 bool reset_releasing_handle_;
2590 ClientSocketHandle handle_;
2591 ClientSocketHandle handle2_;
2592 CompletionCallback callback_;
2593 TestCompletionCallback callback2_;
2594 };
2595
2596
2597 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
2598 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2599
2600 EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
2601 EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
2602 EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
2603
2604 EXPECT_EQ(static_cast<int>(requests_size()),
2605 client_socket_factory_.allocation_count());
2606
2607 connect_job_factory_->set_job_type(
2608 TestConnectJob::kMockPendingAdditionalErrorStateJob);
2609 TestReleasingSocketRequest req(pool_.get(), OK, false);
2610 EXPECT_EQ(ERR_IO_PENDING,
2611 req.handle()->Init("a", params_, DEFAULT_PRIORITY, req.callback(),
2612 pool_.get(), BoundNetLog()));
2613 // The next job should complete synchronously
2614 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2615
2616 EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
2617 EXPECT_FALSE(req.handle()->is_initialized());
2618 EXPECT_FALSE(req.handle()->socket());
2619 EXPECT_TRUE(req.handle()->is_ssl_error());
2620 EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL);
2621 }
2622
2623 // http://crbug.com/44724 regression test.
2624 // We start releasing the pool when we flush on network change. When that
2625 // happens, the only active references are in the ClientSocketHandles. When a
2626 // ConnectJob completes and calls back into the last ClientSocketHandle, that
2627 // callback can release the last reference and delete the pool. After the
2628 // callback finishes, we go back to the stack frame within the now-deleted pool.
2629 // Executing any code that refers to members of the now-deleted pool can cause
2630 // crashes.
2631 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
2632 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2633 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
2634
2635 ClientSocketHandle handle;
2636 TestCompletionCallback callback;
2637 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2638 params_,
2639 DEFAULT_PRIORITY,
2640 callback.callback(),
2641 pool_.get(),
2642 BoundNetLog()));
2643
2644 pool_->FlushWithError(ERR_NETWORK_CHANGED);
2645
2646 // We'll call back into this now.
2647 callback.WaitForResult();
2648 }
2649
2650 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
2651 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2652 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2653
2654 ClientSocketHandle handle;
2655 TestCompletionCallback callback;
2656 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2657 params_,
2658 DEFAULT_PRIORITY,
2659 callback.callback(),
2660 pool_.get(),
2661 BoundNetLog()));
2662 EXPECT_EQ(OK, callback.WaitForResult());
2663 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
2664
2665 pool_->FlushWithError(ERR_NETWORK_CHANGED);
2666
2667 handle.Reset();
2668 base::MessageLoop::current()->RunUntilIdle();
2669
2670 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2671 params_,
2672 DEFAULT_PRIORITY,
2673 callback.callback(),
2674 pool_.get(),
2675 BoundNetLog()));
2676 EXPECT_EQ(OK, callback.WaitForResult());
2677 EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
2678 }
2679
2680 class ConnectWithinCallback : public TestCompletionCallbackBase {
2681 public:
2682 ConnectWithinCallback(
2683 const std::string& group_name,
2684 const scoped_refptr<TestSocketParams>& params,
2685 TestClientSocketPool* pool)
2686 : group_name_(group_name),
2687 params_(params),
2688 pool_(pool),
2689 callback_(base::Bind(&ConnectWithinCallback::OnComplete,
2690 base::Unretained(this))) {
2691 }
2692
2693 ~ConnectWithinCallback() override {}
2694
2695 int WaitForNestedResult() {
2696 return nested_callback_.WaitForResult();
2697 }
2698
2699 const CompletionCallback& callback() const { return callback_; }
2700
2701 private:
2702 void OnComplete(int result) {
2703 SetResult(result);
2704 EXPECT_EQ(ERR_IO_PENDING,
2705 handle_.Init(group_name_,
2706 params_,
2707 DEFAULT_PRIORITY,
2708 nested_callback_.callback(),
2709 pool_,
2710 BoundNetLog()));
2711 }
2712
2713 const std::string group_name_;
2714 const scoped_refptr<TestSocketParams> params_;
2715 TestClientSocketPool* const pool_;
2716 ClientSocketHandle handle_;
2717 CompletionCallback callback_;
2718 TestCompletionCallback nested_callback_;
2719
2720 DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback);
2721 };
2722
2723 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
2724 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2725
2726 // First job will be waiting until it gets aborted.
2727 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2728
2729 ClientSocketHandle handle;
2730 ConnectWithinCallback callback("a", params_, pool_.get());
2731 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2732 params_,
2733 DEFAULT_PRIORITY,
2734 callback.callback(),
2735 pool_.get(),
2736 BoundNetLog()));
2737
2738 // Second job will be started during the first callback, and will
2739 // asynchronously complete with OK.
2740 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2741 pool_->FlushWithError(ERR_NETWORK_CHANGED);
2742 EXPECT_EQ(ERR_NETWORK_CHANGED, callback.WaitForResult());
2743 EXPECT_EQ(OK, callback.WaitForNestedResult());
2744 }
2745
2746 // Cancel a pending socket request while we're at max sockets,
2747 // and verify that the backup socket firing doesn't cause a crash.
2748 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
2749 // Max 4 sockets globally, max 4 sockets per group.
2750 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2751 pool_->EnableConnectBackupJobs();
2752
2753 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
2754 // timer.
2755 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2756 ClientSocketHandle handle;
2757 TestCompletionCallback callback;
2758 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
2759 params_,
2760 DEFAULT_PRIORITY,
2761 callback.callback(),
2762 pool_.get(),
2763 BoundNetLog()));
2764
2765 // Start (MaxSockets - 1) connected sockets to reach max sockets.
2766 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2767 ClientSocketHandle handles[kDefaultMaxSockets];
2768 for (int i = 1; i < kDefaultMaxSockets; ++i) {
2769 TestCompletionCallback callback;
2770 EXPECT_EQ(OK, handles[i].Init("bar",
2771 params_,
2772 DEFAULT_PRIORITY,
2773 callback.callback(),
2774 pool_.get(),
2775 BoundNetLog()));
2776 }
2777
2778 base::MessageLoop::current()->RunUntilIdle();
2779
2780 // Cancel the pending request.
2781 handle.Reset();
2782
2783 // Wait for the backup timer to fire (add some slop to ensure it fires)
2784 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2785 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2786
2787 base::MessageLoop::current()->RunUntilIdle();
2788 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
2789 }
2790
2791 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
2792 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2793 pool_->EnableConnectBackupJobs();
2794
2795 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
2796 // timer.
2797 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2798 ClientSocketHandle handle;
2799 TestCompletionCallback callback;
2800 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
2801 params_,
2802 DEFAULT_PRIORITY,
2803 callback.callback(),
2804 pool_.get(),
2805 BoundNetLog()));
2806 ASSERT_TRUE(pool_->HasGroup("bar"));
2807 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
2808 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar"));
2809
2810 // Cancel the socket request. This should cancel the backup timer. Wait for
2811 // the backup time to see if it indeed got canceled.
2812 handle.Reset();
2813 // Wait for the backup timer to fire (add some slop to ensure it fires)
2814 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2815 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2816 base::MessageLoop::current()->RunUntilIdle();
2817 ASSERT_TRUE(pool_->HasGroup("bar"));
2818 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
2819 }
2820
2821 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
2822 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2823 pool_->EnableConnectBackupJobs();
2824
2825 // Create the first socket and set to ERR_IO_PENDING. This starts the backup
2826 // timer.
2827 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2828 ClientSocketHandle handle;
2829 TestCompletionCallback callback;
2830 EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
2831 params_,
2832 DEFAULT_PRIORITY,
2833 callback.callback(),
2834 pool_.get(),
2835 BoundNetLog()));
2836 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2837 ClientSocketHandle handle2;
2838 TestCompletionCallback callback2;
2839 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar",
2840 params_,
2841 DEFAULT_PRIORITY,
2842 callback2.callback(),
2843 pool_.get(),
2844 BoundNetLog()));
2845 ASSERT_TRUE(pool_->HasGroup("bar"));
2846 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
2847
2848 // Cancel request 1 and then complete request 2. With the requests finished,
2849 // the backup timer should be cancelled.
2850 handle.Reset();
2851 EXPECT_EQ(OK, callback2.WaitForResult());
2852 // Wait for the backup timer to fire (add some slop to ensure it fires)
2853 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2854 ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2855 base::MessageLoop::current()->RunUntilIdle();
2856 }
2857
2858 // Test delayed socket binding for the case where we have two connects,
2859 // and while one is waiting on a connect, the other frees up.
2860 // The socket waiting on a connect should switch immediately to the freed
2861 // up socket.
2862 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
2863 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2864 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2865
2866 ClientSocketHandle handle1;
2867 TestCompletionCallback callback;
2868 EXPECT_EQ(ERR_IO_PENDING,
2869 handle1.Init("a",
2870 params_,
2871 DEFAULT_PRIORITY,
2872 callback.callback(),
2873 pool_.get(),
2874 BoundNetLog()));
2875 EXPECT_EQ(OK, callback.WaitForResult());
2876
2877 // No idle sockets, no pending jobs.
2878 EXPECT_EQ(0, pool_->IdleSocketCount());
2879 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2880
2881 // Create a second socket to the same host, but this one will wait.
2882 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2883 ClientSocketHandle handle2;
2884 EXPECT_EQ(ERR_IO_PENDING,
2885 handle2.Init("a",
2886 params_,
2887 DEFAULT_PRIORITY,
2888 callback.callback(),
2889 pool_.get(),
2890 BoundNetLog()));
2891 // No idle sockets, and one connecting job.
2892 EXPECT_EQ(0, pool_->IdleSocketCount());
2893 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2894
2895 // Return the first handle to the pool. This will initiate the delayed
2896 // binding.
2897 handle1.Reset();
2898
2899 base::MessageLoop::current()->RunUntilIdle();
2900
2901 // Still no idle sockets, still one pending connect job.
2902 EXPECT_EQ(0, pool_->IdleSocketCount());
2903 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2904
2905 // The second socket connected, even though it was a Waiting Job.
2906 EXPECT_EQ(OK, callback.WaitForResult());
2907
2908 // And we can see there is still one job waiting.
2909 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2910
2911 // Finally, signal the waiting Connect.
2912 client_socket_factory_.SignalJobs();
2913 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2914
2915 base::MessageLoop::current()->RunUntilIdle();
2916 }
2917
2918 // Test delayed socket binding when a group is at capacity and one
2919 // of the group's sockets frees up.
2920 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
2921 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2922 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2923
2924 ClientSocketHandle handle1;
2925 TestCompletionCallback callback;
2926 EXPECT_EQ(ERR_IO_PENDING,
2927 handle1.Init("a",
2928 params_,
2929 DEFAULT_PRIORITY,
2930 callback.callback(),
2931 pool_.get(),
2932 BoundNetLog()));
2933 EXPECT_EQ(OK, callback.WaitForResult());
2934
2935 // No idle sockets, no pending jobs.
2936 EXPECT_EQ(0, pool_->IdleSocketCount());
2937 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2938
2939 // Create a second socket to the same host, but this one will wait.
2940 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2941 ClientSocketHandle handle2;
2942 EXPECT_EQ(ERR_IO_PENDING,
2943 handle2.Init("a",
2944 params_,
2945 DEFAULT_PRIORITY,
2946 callback.callback(),
2947 pool_.get(),
2948 BoundNetLog()));
2949 // No idle sockets, and one connecting job.
2950 EXPECT_EQ(0, pool_->IdleSocketCount());
2951 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2952
2953 // Return the first handle to the pool. This will initiate the delayed
2954 // binding.
2955 handle1.Reset();
2956
2957 base::MessageLoop::current()->RunUntilIdle();
2958
2959 // Still no idle sockets, still one pending connect job.
2960 EXPECT_EQ(0, pool_->IdleSocketCount());
2961 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2962
2963 // The second socket connected, even though it was a Waiting Job.
2964 EXPECT_EQ(OK, callback.WaitForResult());
2965
2966 // And we can see there is still one job waiting.
2967 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2968
2969 // Finally, signal the waiting Connect.
2970 client_socket_factory_.SignalJobs();
2971 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2972
2973 base::MessageLoop::current()->RunUntilIdle();
2974 }
2975
2976 // Test out the case where we have one socket connected, one
2977 // connecting, when the first socket finishes and goes idle.
2978 // Although the second connection is pending, the second request
2979 // should complete, by taking the first socket's idle socket.
2980 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
2981 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2982 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2983
2984 ClientSocketHandle handle1;
2985 TestCompletionCallback callback;
2986 EXPECT_EQ(ERR_IO_PENDING,
2987 handle1.Init("a",
2988 params_,
2989 DEFAULT_PRIORITY,
2990 callback.callback(),
2991 pool_.get(),
2992 BoundNetLog()));
2993 EXPECT_EQ(OK, callback.WaitForResult());
2994
2995 // No idle sockets, no pending jobs.
2996 EXPECT_EQ(0, pool_->IdleSocketCount());
2997 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2998
2999 // Create a second socket to the same host, but this one will wait.
3000 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3001 ClientSocketHandle handle2;
3002 EXPECT_EQ(ERR_IO_PENDING,
3003 handle2.Init("a",
3004 params_,
3005 DEFAULT_PRIORITY,
3006 callback.callback(),
3007 pool_.get(),
3008 BoundNetLog()));
3009 // No idle sockets, and one connecting job.
3010 EXPECT_EQ(0, pool_->IdleSocketCount());
3011 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3012
3013 // Return the first handle to the pool. This will initiate the delayed
3014 // binding.
3015 handle1.Reset();
3016
3017 base::MessageLoop::current()->RunUntilIdle();
3018
3019 // Still no idle sockets, still one pending connect job.
3020 EXPECT_EQ(0, pool_->IdleSocketCount());
3021 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3022
3023 // The second socket connected, even though it was a Waiting Job.
3024 EXPECT_EQ(OK, callback.WaitForResult());
3025
3026 // And we can see there is still one job waiting.
3027 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3028
3029 // Finally, signal the waiting Connect.
3030 client_socket_factory_.SignalJobs();
3031 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3032
3033 base::MessageLoop::current()->RunUntilIdle();
3034 }
3035
3036 // Cover the case where on an available socket slot, we have one pending
3037 // request that completes synchronously, thereby making the Group empty.
3038 TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
3039 const int kUnlimitedSockets = 100;
3040 const int kOneSocketPerGroup = 1;
3041 CreatePool(kUnlimitedSockets, kOneSocketPerGroup);
3042
3043 // Make the first request asynchronous fail.
3044 // This will free up a socket slot later.
3045 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
3046
3047 ClientSocketHandle handle1;
3048 TestCompletionCallback callback1;
3049 EXPECT_EQ(ERR_IO_PENDING,
3050 handle1.Init("a",
3051 params_,
3052 DEFAULT_PRIORITY,
3053 callback1.callback(),
3054 pool_.get(),
3055 BoundNetLog()));
3056 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3057
3058 // Make the second request synchronously fail. This should make the Group
3059 // empty.
3060 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3061 ClientSocketHandle handle2;
3062 TestCompletionCallback callback2;
3063 // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail
3064 // when created.
3065 EXPECT_EQ(ERR_IO_PENDING,
3066 handle2.Init("a",
3067 params_,
3068 DEFAULT_PRIORITY,
3069 callback2.callback(),
3070 pool_.get(),
3071 BoundNetLog()));
3072
3073 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3074
3075 EXPECT_EQ(ERR_CONNECTION_FAILED, callback1.WaitForResult());
3076 EXPECT_EQ(ERR_CONNECTION_FAILED, callback2.WaitForResult());
3077 EXPECT_FALSE(pool_->HasGroup("a"));
3078 }
3079
3080 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
3081 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3082
3083 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3084
3085 ClientSocketHandle handle1;
3086 TestCompletionCallback callback1;
3087 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3088 params_,
3089 DEFAULT_PRIORITY,
3090 callback1.callback(),
3091 pool_.get(),
3092 BoundNetLog()));
3093
3094 ClientSocketHandle handle2;
3095 TestCompletionCallback callback2;
3096 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3097 params_,
3098 DEFAULT_PRIORITY,
3099 callback2.callback(),
3100 pool_.get(),
3101 BoundNetLog()));
3102 ClientSocketHandle handle3;
3103 TestCompletionCallback callback3;
3104 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
3105 params_,
3106 DEFAULT_PRIORITY,
3107 callback3.callback(),
3108 pool_.get(),
3109 BoundNetLog()));
3110
3111 EXPECT_EQ(OK, callback1.WaitForResult());
3112 EXPECT_EQ(OK, callback2.WaitForResult());
3113 EXPECT_EQ(OK, callback3.WaitForResult());
3114
3115 // Use the socket.
3116 EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback()));
3117 EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback()));
3118
3119 handle1.Reset();
3120 handle2.Reset();
3121 handle3.Reset();
3122
3123 EXPECT_EQ(OK, handle1.Init("a",
3124 params_,
3125 DEFAULT_PRIORITY,
3126 callback1.callback(),
3127 pool_.get(),
3128 BoundNetLog()));
3129 EXPECT_EQ(OK, handle2.Init("a",
3130 params_,
3131 DEFAULT_PRIORITY,
3132 callback2.callback(),
3133 pool_.get(),
3134 BoundNetLog()));
3135 EXPECT_EQ(OK, handle3.Init("a",
3136 params_,
3137 DEFAULT_PRIORITY,
3138 callback3.callback(),
3139 pool_.get(),
3140 BoundNetLog()));
3141
3142 EXPECT_TRUE(handle1.socket()->WasEverUsed());
3143 EXPECT_TRUE(handle2.socket()->WasEverUsed());
3144 EXPECT_FALSE(handle3.socket()->WasEverUsed());
3145 }
3146
3147 TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
3148 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3149 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3150
3151 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3152
3153 ASSERT_TRUE(pool_->HasGroup("a"));
3154 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3155 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3156 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3157
3158 ClientSocketHandle handle1;
3159 TestCompletionCallback callback1;
3160 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3161 params_,
3162 DEFAULT_PRIORITY,
3163 callback1.callback(),
3164 pool_.get(),
3165 BoundNetLog()));
3166
3167 ClientSocketHandle handle2;
3168 TestCompletionCallback callback2;
3169 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3170 params_,
3171 DEFAULT_PRIORITY,
3172 callback2.callback(),
3173 pool_.get(),
3174 BoundNetLog()));
3175
3176 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3177 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3178 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3179
3180 EXPECT_EQ(OK, callback1.WaitForResult());
3181 EXPECT_EQ(OK, callback2.WaitForResult());
3182 handle1.Reset();
3183 handle2.Reset();
3184
3185 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3186 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3187 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3188 }
3189
3190 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
3191 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3192 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3193
3194 ClientSocketHandle handle1;
3195 TestCompletionCallback callback1;
3196 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3197 params_,
3198 DEFAULT_PRIORITY,
3199 callback1.callback(),
3200 pool_.get(),
3201 BoundNetLog()));
3202
3203 ASSERT_TRUE(pool_->HasGroup("a"));
3204 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3205 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3206 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3207
3208 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3209
3210 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3211 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3212 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3213
3214 ClientSocketHandle handle2;
3215 TestCompletionCallback callback2;
3216 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3217 params_,
3218 DEFAULT_PRIORITY,
3219 callback2.callback(),
3220 pool_.get(),
3221 BoundNetLog()));
3222
3223 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3224 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3225 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3226
3227 EXPECT_EQ(OK, callback1.WaitForResult());
3228 EXPECT_EQ(OK, callback2.WaitForResult());
3229 handle1.Reset();
3230 handle2.Reset();
3231
3232 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3233 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3234 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3235 }
3236
3237 TEST_F(ClientSocketPoolBaseTest,
3238 RequestSocketsWhenAlreadyHaveMultipleConnectJob) {
3239 CreatePool(4, 4);
3240 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3241
3242 ClientSocketHandle handle1;
3243 TestCompletionCallback callback1;
3244 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3245 params_,
3246 DEFAULT_PRIORITY,
3247 callback1.callback(),
3248 pool_.get(),
3249 BoundNetLog()));
3250
3251 ClientSocketHandle handle2;
3252 TestCompletionCallback callback2;
3253 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3254 params_,
3255 DEFAULT_PRIORITY,
3256 callback2.callback(),
3257 pool_.get(),
3258 BoundNetLog()));
3259
3260 ClientSocketHandle handle3;
3261 TestCompletionCallback callback3;
3262 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
3263 params_,
3264 DEFAULT_PRIORITY,
3265 callback3.callback(),
3266 pool_.get(),
3267 BoundNetLog()));
3268
3269 ASSERT_TRUE(pool_->HasGroup("a"));
3270 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3271 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3272 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3273
3274 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3275
3276 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3277 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3278 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3279
3280 EXPECT_EQ(OK, callback1.WaitForResult());
3281 EXPECT_EQ(OK, callback2.WaitForResult());
3282 EXPECT_EQ(OK, callback3.WaitForResult());
3283 handle1.Reset();
3284 handle2.Reset();
3285 handle3.Reset();
3286
3287 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3288 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3289 EXPECT_EQ(3, pool_->IdleSocketCountInGroup("a"));
3290 }
3291
3292 TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
3293 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3294 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3295
3296 ASSERT_FALSE(pool_->HasGroup("a"));
3297
3298 pool_->RequestSockets("a", &params_, kDefaultMaxSockets,
3299 BoundNetLog());
3300
3301 ASSERT_TRUE(pool_->HasGroup("a"));
3302 EXPECT_EQ(kDefaultMaxSockets, pool_->NumConnectJobsInGroup("a"));
3303 EXPECT_EQ(kDefaultMaxSockets, pool_->NumUnassignedConnectJobsInGroup("a"));
3304
3305 ASSERT_FALSE(pool_->HasGroup("b"));
3306
3307 pool_->RequestSockets("b", &params_, kDefaultMaxSockets,
3308 BoundNetLog());
3309
3310 ASSERT_FALSE(pool_->HasGroup("b"));
3311 }
3312
3313 TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
3314 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3315 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3316
3317 ASSERT_FALSE(pool_->HasGroup("a"));
3318
3319 pool_->RequestSockets("a", &params_, kDefaultMaxSockets - 1,
3320 BoundNetLog());
3321
3322 ASSERT_TRUE(pool_->HasGroup("a"));
3323 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->NumConnectJobsInGroup("a"));
3324 EXPECT_EQ(kDefaultMaxSockets - 1,
3325 pool_->NumUnassignedConnectJobsInGroup("a"));
3326 EXPECT_FALSE(pool_->IsStalled());
3327
3328 ASSERT_FALSE(pool_->HasGroup("b"));
3329
3330 pool_->RequestSockets("b", &params_, kDefaultMaxSockets,
3331 BoundNetLog());
3332
3333 ASSERT_TRUE(pool_->HasGroup("b"));
3334 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b"));
3335 EXPECT_FALSE(pool_->IsStalled());
3336 }
3337
3338 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
3339 CreatePool(4, 4);
3340 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3341
3342 ClientSocketHandle handle1;
3343 TestCompletionCallback callback1;
3344 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3345 params_,
3346 DEFAULT_PRIORITY,
3347 callback1.callback(),
3348 pool_.get(),
3349 BoundNetLog()));
3350 ASSERT_EQ(OK, callback1.WaitForResult());
3351 handle1.Reset();
3352
3353 ASSERT_TRUE(pool_->HasGroup("a"));
3354 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3355 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3356 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3357
3358 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3359
3360 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3361 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3362 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3363 }
3364
3365 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
3366 CreatePool(4, 4);
3367 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3368
3369 ClientSocketHandle handle1;
3370 TestCompletionCallback callback1;
3371 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3372 params_,
3373 DEFAULT_PRIORITY,
3374 callback1.callback(),
3375 pool_.get(),
3376 BoundNetLog()));
3377 ASSERT_EQ(OK, callback1.WaitForResult());
3378
3379 ASSERT_TRUE(pool_->HasGroup("a"));
3380 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3381 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3382 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3383 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3384
3385 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3386
3387 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3388 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3389 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3390 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3391 }
3392
3393 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
3394 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3395 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3396
3397 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3398 BoundNetLog());
3399
3400 ASSERT_TRUE(pool_->HasGroup("a"));
3401 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3402 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3403 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("a"));
3404
3405 pool_->RequestSockets("b", &params_, kDefaultMaxSocketsPerGroup,
3406 BoundNetLog());
3407
3408 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3409 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3410 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("b"));
3411 }
3412
3413 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronousError) {
3414 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3415 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3416
3417 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3418 BoundNetLog());
3419
3420 ASSERT_FALSE(pool_->HasGroup("a"));
3421
3422 connect_job_factory_->set_job_type(
3423 TestConnectJob::kMockAdditionalErrorStateJob);
3424 pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3425 BoundNetLog());
3426
3427 ASSERT_FALSE(pool_->HasGroup("a"));
3428 }
3429
3430 TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
3431 CreatePool(4, 4);
3432 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3433
3434 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3435
3436 ASSERT_TRUE(pool_->HasGroup("a"));
3437 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3438 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3439 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3440
3441 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3442 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3443 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3444 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3445
3446 ClientSocketHandle handle1;
3447 TestCompletionCallback callback1;
3448 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3449 params_,
3450 DEFAULT_PRIORITY,
3451 callback1.callback(),
3452 pool_.get(),
3453 BoundNetLog()));
3454 ASSERT_EQ(OK, callback1.WaitForResult());
3455
3456 ClientSocketHandle handle2;
3457 TestCompletionCallback callback2;
3458 int rv = handle2.Init("a",
3459 params_,
3460 DEFAULT_PRIORITY,
3461 callback2.callback(),
3462 pool_.get(),
3463 BoundNetLog());
3464 if (rv != OK) {
3465 EXPECT_EQ(ERR_IO_PENDING, rv);
3466 EXPECT_EQ(OK, callback2.WaitForResult());
3467 }
3468
3469 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3470 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3471 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("a"));
3472 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3473
3474 handle1.Reset();
3475 handle2.Reset();
3476
3477 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3478 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3479 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3480
3481 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3482 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3483 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3484 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3485 }
3486
3487 TEST_F(ClientSocketPoolBaseTest, RequestSocketsDifferentNumSockets) {
3488 CreatePool(4, 4);
3489 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3490
3491 pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3492
3493 ASSERT_TRUE(pool_->HasGroup("a"));
3494 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3495 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3496 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3497
3498 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3499 EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3500 EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3501 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3502
3503 pool_->RequestSockets("a", &params_, 3, BoundNetLog());
3504 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3505 EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
3506 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3507
3508 pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3509 EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3510 EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
3511 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3512 }
3513
3514 TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
3515 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3516 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3517
3518 pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3519
3520 ASSERT_TRUE(pool_->HasGroup("a"));
3521 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3522 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3523 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3524
3525 ClientSocketHandle handle1;
3526 TestCompletionCallback callback1;
3527 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3528 params_,
3529 DEFAULT_PRIORITY,
3530 callback1.callback(),
3531 pool_.get(),
3532 BoundNetLog()));
3533
3534 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3535 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3536 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3537
3538 ASSERT_EQ(OK, callback1.WaitForResult());
3539
3540 // Make sure if a preconnected socket is not fully connected when a request
3541 // starts, it has a connect start time.
3542 TestLoadTimingInfoConnectedNotReused(handle1);
3543 handle1.Reset();
3544
3545 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3546 }
3547
3548 // Checks that fully connected preconnect jobs have no connect times, and are
3549 // marked as reused.
3550 TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
3551 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3552 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3553 pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3554
3555 ASSERT_TRUE(pool_->HasGroup("a"));
3556 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3557 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3558 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3559
3560 ClientSocketHandle handle;
3561 TestCompletionCallback callback;
3562 EXPECT_EQ(OK, handle.Init("a",
3563 params_,
3564 DEFAULT_PRIORITY,
3565 callback.callback(),
3566 pool_.get(),
3567 BoundNetLog()));
3568
3569 // Make sure the idle socket was used.
3570 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3571
3572 TestLoadTimingInfoConnectedReused(handle);
3573 handle.Reset();
3574 TestLoadTimingInfoNotConnected(handle);
3575 }
3576
3577 // http://crbug.com/64940 regression test.
3578 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
3579 const int kMaxTotalSockets = 3;
3580 const int kMaxSocketsPerGroup = 2;
3581 CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup);
3582 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3583
3584 // Note that group name ordering matters here. "a" comes before "b", so
3585 // CloseOneIdleSocket() will try to close "a"'s idle socket.
3586
3587 // Set up one idle socket in "a".
3588 ClientSocketHandle handle1;
3589 TestCompletionCallback callback1;
3590 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3591 params_,
3592 DEFAULT_PRIORITY,
3593 callback1.callback(),
3594 pool_.get(),
3595 BoundNetLog()));
3596
3597 ASSERT_EQ(OK, callback1.WaitForResult());
3598 handle1.Reset();
3599 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3600
3601 // Set up two active sockets in "b".
3602 ClientSocketHandle handle2;
3603 TestCompletionCallback callback2;
3604 EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b",
3605 params_,
3606 DEFAULT_PRIORITY,
3607 callback1.callback(),
3608 pool_.get(),
3609 BoundNetLog()));
3610 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b",
3611 params_,
3612 DEFAULT_PRIORITY,
3613 callback2.callback(),
3614 pool_.get(),
3615 BoundNetLog()));
3616
3617 ASSERT_EQ(OK, callback1.WaitForResult());
3618 ASSERT_EQ(OK, callback2.WaitForResult());
3619 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
3620 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3621 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
3622
3623 // Now we have 1 idle socket in "a" and 2 active sockets in "b". This means
3624 // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3.
3625 // Requesting 2 preconnected sockets for "a" should fail to allocate any more
3626 // sockets for "a", and "b" should still have 2 active sockets.
3627
3628 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3629 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3630 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3631 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3632 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3633 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3634 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3635 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
3636 EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
3637
3638 // Now release the 2 active sockets for "b". This will give us 1 idle socket
3639 // in "a" and 2 idle sockets in "b". Requesting 2 preconnected sockets for
3640 // "a" should result in closing 1 for "b".
3641 handle1.Reset();
3642 handle2.Reset();
3643 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("b"));
3644 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
3645
3646 pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3647 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3648 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3649 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3650 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3651 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3652 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3653 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("b"));
3654 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
3655 }
3656
3657 TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) {
3658 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3659 pool_->EnableConnectBackupJobs();
3660
3661 // Make the ConnectJob hang until it times out, shorten the timeout.
3662 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3663 connect_job_factory_->set_timeout_duration(
3664 base::TimeDelta::FromMilliseconds(500));
3665 pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3666 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3667 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3668 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3669
3670 // Verify the backup timer doesn't create a backup job, by making
3671 // the backup job a pending job instead of a waiting job, so it
3672 // *would* complete if it were created.
3673 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3674 base::MessageLoop::current()->PostDelayedTask(
3675 FROM_HERE,
3676 base::MessageLoop::QuitClosure(),
3677 base::TimeDelta::FromSeconds(1));
3678 base::MessageLoop::current()->Run();
3679 EXPECT_FALSE(pool_->HasGroup("a"));
3680 }
3681
3682 TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
3683 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3684 pool_->EnableConnectBackupJobs();
3685
3686 // Make the ConnectJob hang forever.
3687 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3688 pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3689 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3690 EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3691 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3692 base::MessageLoop::current()->RunUntilIdle();
3693
3694 // Make the backup job be a pending job, so it completes normally.
3695 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3696 ClientSocketHandle handle;
3697 TestCompletionCallback callback;
3698 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
3699 params_,
3700 DEFAULT_PRIORITY,
3701 callback.callback(),
3702 pool_.get(),
3703 BoundNetLog()));
3704 // Timer has started, but the backup connect job shouldn't be created yet.
3705 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3706 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3707 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3708 EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3709 ASSERT_EQ(OK, callback.WaitForResult());
3710
3711 // The hung connect job should still be there, but everything else should be
3712 // complete.
3713 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3714 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3715 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3716 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3717 }
3718
3719 // Tests that a preconnect that starts out with unread data can still be used.
3720 // http://crbug.com/334467
3721 TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
3722 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3723 connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob);
3724
3725 pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3726
3727 ASSERT_TRUE(pool_->HasGroup("a"));
3728 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3729 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3730 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3731
3732 // Fail future jobs to be sure that handle receives the preconnected socket
3733 // rather than closing it and making a new one.
3734 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3735 ClientSocketHandle handle;
3736 TestCompletionCallback callback;
3737 EXPECT_EQ(OK, handle.Init("a",
3738 params_,
3739 DEFAULT_PRIORITY,
3740 callback.callback(),
3741 pool_.get(),
3742 BoundNetLog()));
3743
3744 ASSERT_TRUE(pool_->HasGroup("a"));
3745 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3746 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3747 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3748
3749 // Drain the pending read.
3750 EXPECT_EQ(1, handle.socket()->Read(NULL, 1, CompletionCallback()));
3751
3752 TestLoadTimingInfoConnectedReused(handle);
3753 handle.Reset();
3754
3755 // The socket should be usable now that it's idle again.
3756 EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3757 }
3758
3759 class MockLayeredPool : public HigherLayeredPool {
3760 public:
3761 MockLayeredPool(TestClientSocketPool* pool,
3762 const std::string& group_name)
3763 : pool_(pool),
3764 group_name_(group_name),
3765 can_release_connection_(true) {
3766 pool_->AddHigherLayeredPool(this);
3767 }
3768
3769 ~MockLayeredPool() {
3770 pool_->RemoveHigherLayeredPool(this);
3771 }
3772
3773 int RequestSocket(TestClientSocketPool* pool) {
3774 scoped_refptr<TestSocketParams> params(
3775 new TestSocketParams(false /* ignore_limits */));
3776 return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
3777 callback_.callback(), pool, BoundNetLog());
3778 }
3779
3780 int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
3781 scoped_refptr<TestSocketParams> params(
3782 new TestSocketParams(true /* ignore_limits */));
3783 return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
3784 callback_.callback(), pool, BoundNetLog());
3785 }
3786
3787 bool ReleaseOneConnection() {
3788 if (!handle_.is_initialized() || !can_release_connection_) {
3789 return false;
3790 }
3791 handle_.socket()->Disconnect();
3792 handle_.Reset();
3793 return true;
3794 }
3795
3796 void set_can_release_connection(bool can_release_connection) {
3797 can_release_connection_ = can_release_connection;
3798 }
3799
3800 MOCK_METHOD0(CloseOneIdleConnection, bool());
3801
3802 private:
3803 TestClientSocketPool* const pool_;
3804 ClientSocketHandle handle_;
3805 TestCompletionCallback callback_;
3806 const std::string group_name_;
3807 bool can_release_connection_;
3808 };
3809
3810 TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) {
3811 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3812 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3813
3814 MockLayeredPool mock_layered_pool(pool_.get(), "foo");
3815 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3816 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3817 .WillOnce(Return(false));
3818 EXPECT_FALSE(pool_->CloseOneIdleConnectionInHigherLayeredPool());
3819 }
3820
3821 TEST_F(ClientSocketPoolBaseTest, ForciblyCloseIdleSocketsHeldByLayeredPool) {
3822 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3823 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3824
3825 MockLayeredPool mock_layered_pool(pool_.get(), "foo");
3826 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3827 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3828 .WillOnce(Invoke(&mock_layered_pool,
3829 &MockLayeredPool::ReleaseOneConnection));
3830 EXPECT_TRUE(pool_->CloseOneIdleConnectionInHigherLayeredPool());
3831 }
3832
3833 // Tests the basic case of closing an idle socket in a higher layered pool when
3834 // a new request is issued and the lower layer pool is stalled.
3835 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
3836 CreatePool(1, 1);
3837 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3838
3839 MockLayeredPool mock_layered_pool(pool_.get(), "foo");
3840 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3841 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3842 .WillOnce(Invoke(&mock_layered_pool,
3843 &MockLayeredPool::ReleaseOneConnection));
3844 ClientSocketHandle handle;
3845 TestCompletionCallback callback;
3846 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
3847 params_,
3848 DEFAULT_PRIORITY,
3849 callback.callback(),
3850 pool_.get(),
3851 BoundNetLog()));
3852 EXPECT_EQ(OK, callback.WaitForResult());
3853 }
3854
3855 // Same as above, but the idle socket is in the same group as the stalled
3856 // socket, and closes the only other request in its group when closing requests
3857 // in higher layered pools. This generally shouldn't happen, but it may be
3858 // possible if a higher level pool issues a request and the request is
3859 // subsequently cancelled. Even if it's not possible, best not to crash.
3860 TEST_F(ClientSocketPoolBaseTest,
3861 CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) {
3862 CreatePool(2, 2);
3863 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3864
3865 // Need a socket in another group for the pool to be stalled (If a group
3866 // has the maximum number of connections already, it's not stalled).
3867 ClientSocketHandle handle1;
3868 TestCompletionCallback callback1;
3869 EXPECT_EQ(OK, handle1.Init("group1",
3870 params_,
3871 DEFAULT_PRIORITY,
3872 callback1.callback(),
3873 pool_.get(),
3874 BoundNetLog()));
3875
3876 MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3877 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3878 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3879 .WillOnce(Invoke(&mock_layered_pool,
3880 &MockLayeredPool::ReleaseOneConnection));
3881 ClientSocketHandle handle;
3882 TestCompletionCallback callback2;
3883 EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2",
3884 params_,
3885 DEFAULT_PRIORITY,
3886 callback2.callback(),
3887 pool_.get(),
3888 BoundNetLog()));
3889 EXPECT_EQ(OK, callback2.WaitForResult());
3890 }
3891
3892 // Tests the case when an idle socket can be closed when a new request is
3893 // issued, and the new request belongs to a group that was previously stalled.
3894 TEST_F(ClientSocketPoolBaseTest,
3895 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) {
3896 CreatePool(2, 2);
3897 std::list<TestConnectJob::JobType> job_types;
3898 job_types.push_back(TestConnectJob::kMockJob);
3899 job_types.push_back(TestConnectJob::kMockJob);
3900 job_types.push_back(TestConnectJob::kMockJob);
3901 job_types.push_back(TestConnectJob::kMockJob);
3902 connect_job_factory_->set_job_types(&job_types);
3903
3904 ClientSocketHandle handle1;
3905 TestCompletionCallback callback1;
3906 EXPECT_EQ(OK, handle1.Init("group1",
3907 params_,
3908 DEFAULT_PRIORITY,
3909 callback1.callback(),
3910 pool_.get(),
3911 BoundNetLog()));
3912
3913 MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3914 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3915 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3916 .WillRepeatedly(Invoke(&mock_layered_pool,
3917 &MockLayeredPool::ReleaseOneConnection));
3918 mock_layered_pool.set_can_release_connection(false);
3919
3920 // The third request is made when the socket pool is in a stalled state.
3921 ClientSocketHandle handle3;
3922 TestCompletionCallback callback3;
3923 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
3924 params_,
3925 DEFAULT_PRIORITY,
3926 callback3.callback(),
3927 pool_.get(),
3928 BoundNetLog()));
3929
3930 base::RunLoop().RunUntilIdle();
3931 EXPECT_FALSE(callback3.have_result());
3932
3933 // The fourth request is made when the pool is no longer stalled. The third
3934 // request should be serviced first, since it was issued first and has the
3935 // same priority.
3936 mock_layered_pool.set_can_release_connection(true);
3937 ClientSocketHandle handle4;
3938 TestCompletionCallback callback4;
3939 EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
3940 params_,
3941 DEFAULT_PRIORITY,
3942 callback4.callback(),
3943 pool_.get(),
3944 BoundNetLog()));
3945 EXPECT_EQ(OK, callback3.WaitForResult());
3946 EXPECT_FALSE(callback4.have_result());
3947
3948 // Closing a handle should free up another socket slot.
3949 handle1.Reset();
3950 EXPECT_EQ(OK, callback4.WaitForResult());
3951 }
3952
3953 // Tests the case when an idle socket can be closed when a new request is
3954 // issued, and the new request belongs to a group that was previously stalled.
3955 //
3956 // The two differences from the above test are that the stalled requests are not
3957 // in the same group as the layered pool's request, and the the fourth request
3958 // has a higher priority than the third one, so gets a socket first.
3959 TEST_F(ClientSocketPoolBaseTest,
3960 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) {
3961 CreatePool(2, 2);
3962 std::list<TestConnectJob::JobType> job_types;
3963 job_types.push_back(TestConnectJob::kMockJob);
3964 job_types.push_back(TestConnectJob::kMockJob);
3965 job_types.push_back(TestConnectJob::kMockJob);
3966 job_types.push_back(TestConnectJob::kMockJob);
3967 connect_job_factory_->set_job_types(&job_types);
3968
3969 ClientSocketHandle handle1;
3970 TestCompletionCallback callback1;
3971 EXPECT_EQ(OK, handle1.Init("group1",
3972 params_,
3973 DEFAULT_PRIORITY,
3974 callback1.callback(),
3975 pool_.get(),
3976 BoundNetLog()));
3977
3978 MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3979 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3980 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3981 .WillRepeatedly(Invoke(&mock_layered_pool,
3982 &MockLayeredPool::ReleaseOneConnection));
3983 mock_layered_pool.set_can_release_connection(false);
3984
3985 // The third request is made when the socket pool is in a stalled state.
3986 ClientSocketHandle handle3;
3987 TestCompletionCallback callback3;
3988 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
3989 params_,
3990 MEDIUM,
3991 callback3.callback(),
3992 pool_.get(),
3993 BoundNetLog()));
3994
3995 base::RunLoop().RunUntilIdle();
3996 EXPECT_FALSE(callback3.have_result());
3997
3998 // The fourth request is made when the pool is no longer stalled. This
3999 // request has a higher priority than the third request, so is serviced first.
4000 mock_layered_pool.set_can_release_connection(true);
4001 ClientSocketHandle handle4;
4002 TestCompletionCallback callback4;
4003 EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
4004 params_,
4005 HIGHEST,
4006 callback4.callback(),
4007 pool_.get(),
4008 BoundNetLog()));
4009 EXPECT_EQ(OK, callback4.WaitForResult());
4010 EXPECT_FALSE(callback3.have_result());
4011
4012 // Closing a handle should free up another socket slot.
4013 handle1.Reset();
4014 EXPECT_EQ(OK, callback3.WaitForResult());
4015 }
4016
4017 TEST_F(ClientSocketPoolBaseTest,
4018 CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) {
4019 CreatePool(1, 1);
4020 connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
4021
4022 MockLayeredPool mock_layered_pool1(pool_.get(), "foo");
4023 EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get()));
4024 EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection())
4025 .WillRepeatedly(Invoke(&mock_layered_pool1,
4026 &MockLayeredPool::ReleaseOneConnection));
4027 MockLayeredPool mock_layered_pool2(pool_.get(), "bar");
4028 EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()));
4029 EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection())
4030 .WillRepeatedly(Invoke(&mock_layered_pool2,
4031 &MockLayeredPool::ReleaseOneConnection));
4032 ClientSocketHandle handle;
4033 TestCompletionCallback callback;
4034 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
4035 params_,
4036 DEFAULT_PRIORITY,
4037 callback.callback(),
4038 pool_.get(),
4039 BoundNetLog()));
4040 EXPECT_EQ(OK, callback.WaitForResult());
4041 }
4042
4043 // Test that when a socket pool and group are at their limits, a request
4044 // with |ignore_limits| triggers creation of a new socket, and gets the socket
4045 // instead of a request with the same priority that was issued earlier, but
4046 // that does not have |ignore_limits| set.
4047 TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) {
4048 scoped_refptr<TestSocketParams> params_ignore_limits(
4049 new TestSocketParams(true /* ignore_limits */));
4050 CreatePool(1, 1);
4051
4052 // Issue a request to reach the socket pool limit.
4053 EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
4054 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4055
4056 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
4057
4058 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4059 params_));
4060 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4061
4062 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4063 params_ignore_limits));
4064 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
4065
4066 EXPECT_EQ(OK, request(2)->WaitForResult());
4067 EXPECT_FALSE(request(1)->have_result());
4068 }
4069
4070 // Test that when a socket pool and group are at their limits, a ConnectJob
4071 // issued for a request with |ignore_limits| set is not cancelled when a request
4072 // without |ignore_limits| issued to the same group is cancelled.
4073 TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) {
4074 scoped_refptr<TestSocketParams> params_ignore_limits(
4075 new TestSocketParams(true /* ignore_limits */));
4076 CreatePool(1, 1);
4077
4078 // Issue a request to reach the socket pool limit.
4079 EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
4080 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4081
4082 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
4083
4084 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4085 params_));
4086 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4087
4088 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4089 params_ignore_limits));
4090 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
4091
4092 // Cancel the pending request without ignore_limits set. The ConnectJob
4093 // should not be cancelled.
4094 request(1)->handle()->Reset();
4095 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
4096
4097 EXPECT_EQ(OK, request(2)->WaitForResult());
4098 EXPECT_FALSE(request(1)->have_result());
4099 }
4100
4101 } // namespace
4102
4103 } // namespace net
OLDNEW
« no previous file with comments | « net/socket/client_socket_pool_base.cc ('k') | net/socket/client_socket_pool_histograms.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698