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/stream_socket.h" 34 #include "testing/gmock/include/gmock/gmock.h" 35 #include "testing/gtest/include/gtest/gtest.h" 36 37 using ::testing::Invoke; 38 using ::testing::Return; 39 40 namespace net { 41 42 namespace { 43 44 const int kDefaultMaxSockets = 4; 45 const int kDefaultMaxSocketsPerGroup = 2; 46 const net::RequestPriority kDefaultPriority = MEDIUM; 47 48 // Make sure |handle| sets load times correctly when it has been assigned a 49 // reused socket. 50 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) { 51 LoadTimingInfo load_timing_info; 52 // Only pass true in as |is_reused|, as in general, HttpStream types should 53 // have stricter concepts of reuse than socket pools. 54 EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info)); 55 56 EXPECT_EQ(true, load_timing_info.socket_reused); 57 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 58 59 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); 60 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); 61 } 62 63 // Make sure |handle| sets load times correctly when it has been assigned a 64 // fresh socket. Also runs TestLoadTimingInfoConnectedReused, since the owner 65 // of a connection where |is_reused| is false may consider the connection 66 // reused. 67 void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) { 68 EXPECT_FALSE(handle.is_reused()); 69 70 LoadTimingInfo load_timing_info; 71 EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info)); 72 73 EXPECT_FALSE(load_timing_info.socket_reused); 74 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 75 76 ExpectConnectTimingHasTimes(load_timing_info.connect_timing, 77 CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY); 78 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); 79 80 TestLoadTimingInfoConnectedReused(handle); 81 } 82 83 // Make sure |handle| sets load times correctly, in the case that it does not 84 // currently have a socket. 85 void TestLoadTimingInfoNotConnected(const ClientSocketHandle& handle) { 86 // Should only be set to true once a socket is assigned, if at all. 87 EXPECT_FALSE(handle.is_reused()); 88 89 LoadTimingInfo load_timing_info; 90 EXPECT_FALSE(handle.GetLoadTimingInfo(false, &load_timing_info)); 91 92 EXPECT_FALSE(load_timing_info.socket_reused); 93 EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 94 95 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); 96 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); 97 } 98 99 class TestSocketParams : public base::RefCounted<TestSocketParams> { 100 public: 101 TestSocketParams() : ignore_limits_(false) {} 102 103 void set_ignore_limits(bool ignore_limits) { 104 ignore_limits_ = ignore_limits; 105 } 106 bool ignore_limits() { return ignore_limits_; } 107 108 private: 109 friend class base::RefCounted<TestSocketParams>; 110 ~TestSocketParams() {} 111 112 bool ignore_limits_; 113 }; 114 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase; 115 116 class MockClientSocket : public StreamSocket { 117 public: 118 explicit MockClientSocket(net::NetLog* net_log) 119 : connected_(false), 120 net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)), 121 was_used_to_convey_data_(false) { 122 } 123 124 // Socket implementation. 125 virtual int Read( 126 IOBuffer* /* buf */, int len, 127 const CompletionCallback& /* callback */) OVERRIDE { 128 return ERR_UNEXPECTED; 129 } 130 131 virtual int Write( 132 IOBuffer* /* buf */, int len, 133 const CompletionCallback& /* callback */) OVERRIDE { 134 was_used_to_convey_data_ = true; 135 return len; 136 } 137 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } 138 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } 139 140 // StreamSocket implementation. 141 virtual int Connect(const CompletionCallback& callback) OVERRIDE { 142 connected_ = true; 143 return OK; 144 } 145 146 virtual void Disconnect() OVERRIDE { connected_ = false; } 147 virtual bool IsConnected() const OVERRIDE { return connected_; } 148 virtual bool IsConnectedAndIdle() const OVERRIDE { return connected_; } 149 150 virtual int GetPeerAddress(IPEndPoint* /* address */) const OVERRIDE { 151 return ERR_UNEXPECTED; 152 } 153 154 virtual int GetLocalAddress(IPEndPoint* /* address */) const OVERRIDE { 155 return ERR_UNEXPECTED; 156 } 157 158 virtual const BoundNetLog& NetLog() const OVERRIDE { 159 return net_log_; 160 } 161 162 virtual void SetSubresourceSpeculation() OVERRIDE {} 163 virtual void SetOmniboxSpeculation() OVERRIDE {} 164 virtual bool WasEverUsed() const OVERRIDE { 165 return was_used_to_convey_data_; 166 } 167 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } 168 virtual bool WasNpnNegotiated() const OVERRIDE { 169 return false; 170 } 171 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { 172 return kProtoUnknown; 173 } 174 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { 175 return false; 176 } 177 178 private: 179 bool connected_; 180 BoundNetLog net_log_; 181 bool was_used_to_convey_data_; 182 183 DISALLOW_COPY_AND_ASSIGN(MockClientSocket); 184 }; 185 186 class TestConnectJob; 187 188 class MockClientSocketFactory : public ClientSocketFactory { 189 public: 190 MockClientSocketFactory() : allocation_count_(0) {} 191 192 virtual DatagramClientSocket* CreateDatagramClientSocket( 193 DatagramSocket::BindType bind_type, 194 const RandIntCallback& rand_int_cb, 195 NetLog* net_log, 196 const NetLog::Source& source) OVERRIDE { 197 NOTREACHED(); 198 return NULL; 199 } 200 201 virtual StreamSocket* CreateTransportClientSocket( 202 const AddressList& addresses, 203 NetLog* /* net_log */, 204 const NetLog::Source& /*source*/) OVERRIDE { 205 allocation_count_++; 206 return NULL; 207 } 208 209 virtual SSLClientSocket* CreateSSLClientSocket( 210 ClientSocketHandle* transport_socket, 211 const HostPortPair& host_and_port, 212 const SSLConfig& ssl_config, 213 const SSLClientSocketContext& context) OVERRIDE { 214 NOTIMPLEMENTED(); 215 return NULL; 216 } 217 218 virtual void ClearSSLSessionCache() OVERRIDE { 219 NOTIMPLEMENTED(); 220 } 221 222 void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); } 223 224 void SignalJobs(); 225 226 void SignalJob(size_t job); 227 228 void SetJobLoadState(size_t job, LoadState load_state); 229 230 int allocation_count() const { return allocation_count_; } 231 232 private: 233 int allocation_count_; 234 std::vector<TestConnectJob*> waiting_jobs_; 235 }; 236 237 class TestConnectJob : public ConnectJob { 238 public: 239 enum JobType { 240 kMockJob, 241 kMockFailingJob, 242 kMockPendingJob, 243 kMockPendingFailingJob, 244 kMockWaitingJob, 245 kMockRecoverableJob, 246 kMockPendingRecoverableJob, 247 kMockAdditionalErrorStateJob, 248 kMockPendingAdditionalErrorStateJob, 249 }; 250 251 // The kMockPendingJob uses a slight delay before allowing the connect 252 // to complete. 253 static const int kPendingConnectDelay = 2; 254 255 TestConnectJob(JobType job_type, 256 const std::string& group_name, 257 const TestClientSocketPoolBase::Request& request, 258 base::TimeDelta timeout_duration, 259 ConnectJob::Delegate* delegate, 260 MockClientSocketFactory* client_socket_factory, 261 NetLog* net_log) 262 : ConnectJob(group_name, timeout_duration, delegate, 263 BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)), 264 job_type_(job_type), 265 client_socket_factory_(client_socket_factory), 266 weak_factory_(this), 267 load_state_(LOAD_STATE_IDLE), 268 store_additional_error_state_(false) {} 269 270 void Signal() { 271 DoConnect(waiting_success_, true /* async */, false /* recoverable */); 272 } 273 274 void set_load_state(LoadState load_state) { load_state_ = load_state; } 275 276 // From ConnectJob: 277 278 virtual LoadState GetLoadState() const OVERRIDE { return load_state_; } 279 280 virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE { 281 if (store_additional_error_state_) { 282 // Set all of the additional error state fields in some way. 283 handle->set_is_ssl_error(true); 284 HttpResponseInfo info; 285 info.headers = new HttpResponseHeaders(std::string()); 286 handle->set_ssl_error_response_info(info); 287 } 288 } 289 290 private: 291 // From ConnectJob: 292 293 virtual int ConnectInternal() OVERRIDE { 294 AddressList ignored; 295 client_socket_factory_->CreateTransportClientSocket( 296 ignored, NULL, net::NetLog::Source()); 297 set_socket(new MockClientSocket(net_log().net_log())); 298 switch (job_type_) { 299 case kMockJob: 300 return DoConnect(true /* successful */, false /* sync */, 301 false /* recoverable */); 302 case kMockFailingJob: 303 return DoConnect(false /* error */, false /* sync */, 304 false /* recoverable */); 305 case kMockPendingJob: 306 set_load_state(LOAD_STATE_CONNECTING); 307 308 // Depending on execution timings, posting a delayed task can result 309 // in the task getting executed the at the earliest possible 310 // opportunity or only after returning once from the message loop and 311 // then a second call into the message loop. In order to make behavior 312 // more deterministic, we change the default delay to 2ms. This should 313 // always require us to wait for the second call into the message loop. 314 // 315 // N.B. The correct fix for this and similar timing problems is to 316 // abstract time for the purpose of unittests. Unfortunately, we have 317 // a lot of third-party components that directly call the various 318 // time functions, so this change would be rather invasive. 319 base::MessageLoop::current()->PostDelayedTask( 320 FROM_HERE, 321 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect), 322 weak_factory_.GetWeakPtr(), 323 true /* successful */, 324 true /* async */, 325 false /* recoverable */), 326 base::TimeDelta::FromMilliseconds(kPendingConnectDelay)); 327 return ERR_IO_PENDING; 328 case kMockPendingFailingJob: 329 set_load_state(LOAD_STATE_CONNECTING); 330 base::MessageLoop::current()->PostDelayedTask( 331 FROM_HERE, 332 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect), 333 weak_factory_.GetWeakPtr(), 334 false /* error */, 335 true /* async */, 336 false /* recoverable */), 337 base::TimeDelta::FromMilliseconds(2)); 338 return ERR_IO_PENDING; 339 case kMockWaitingJob: 340 set_load_state(LOAD_STATE_CONNECTING); 341 client_socket_factory_->WaitForSignal(this); 342 waiting_success_ = true; 343 return ERR_IO_PENDING; 344 case kMockRecoverableJob: 345 return DoConnect(false /* error */, false /* sync */, 346 true /* recoverable */); 347 case kMockPendingRecoverableJob: 348 set_load_state(LOAD_STATE_CONNECTING); 349 base::MessageLoop::current()->PostDelayedTask( 350 FROM_HERE, 351 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect), 352 weak_factory_.GetWeakPtr(), 353 false /* error */, 354 true /* async */, 355 true /* recoverable */), 356 base::TimeDelta::FromMilliseconds(2)); 357 return ERR_IO_PENDING; 358 case kMockAdditionalErrorStateJob: 359 store_additional_error_state_ = true; 360 return DoConnect(false /* error */, false /* sync */, 361 false /* recoverable */); 362 case kMockPendingAdditionalErrorStateJob: 363 set_load_state(LOAD_STATE_CONNECTING); 364 store_additional_error_state_ = true; 365 base::MessageLoop::current()->PostDelayedTask( 366 FROM_HERE, 367 base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect), 368 weak_factory_.GetWeakPtr(), 369 false /* error */, 370 true /* async */, 371 false /* recoverable */), 372 base::TimeDelta::FromMilliseconds(2)); 373 return ERR_IO_PENDING; 374 default: 375 NOTREACHED(); 376 set_socket(NULL); 377 return ERR_FAILED; 378 } 379 } 380 381 int DoConnect(bool succeed, bool was_async, bool recoverable) { 382 int result = OK; 383 if (succeed) { 384 socket()->Connect(CompletionCallback()); 385 } else if (recoverable) { 386 result = ERR_PROXY_AUTH_REQUESTED; 387 } else { 388 result = ERR_CONNECTION_FAILED; 389 set_socket(NULL); 390 } 391 392 if (was_async) 393 NotifyDelegateOfCompletion(result); 394 return result; 395 } 396 397 bool waiting_success_; 398 const JobType job_type_; 399 MockClientSocketFactory* const client_socket_factory_; 400 base::WeakPtrFactory<TestConnectJob> weak_factory_; 401 LoadState load_state_; 402 bool store_additional_error_state_; 403 404 DISALLOW_COPY_AND_ASSIGN(TestConnectJob); 405 }; 406 407 class TestConnectJobFactory 408 : public TestClientSocketPoolBase::ConnectJobFactory { 409 public: 410 TestConnectJobFactory(MockClientSocketFactory* client_socket_factory, 411 NetLog* net_log) 412 : job_type_(TestConnectJob::kMockJob), 413 job_types_(NULL), 414 client_socket_factory_(client_socket_factory), 415 net_log_(net_log) { 416 } 417 418 virtual ~TestConnectJobFactory() {} 419 420 void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; } 421 422 void set_job_types(std::list<TestConnectJob::JobType>* job_types) { 423 job_types_ = job_types; 424 CHECK(!job_types_->empty()); 425 } 426 427 void set_timeout_duration(base::TimeDelta timeout_duration) { 428 timeout_duration_ = timeout_duration; 429 } 430 431 // ConnectJobFactory implementation. 432 433 virtual ConnectJob* NewConnectJob( 434 const std::string& group_name, 435 const TestClientSocketPoolBase::Request& request, 436 ConnectJob::Delegate* delegate) const OVERRIDE { 437 EXPECT_TRUE(!job_types_ || !job_types_->empty()); 438 TestConnectJob::JobType job_type = job_type_; 439 if (job_types_ && !job_types_->empty()) { 440 job_type = job_types_->front(); 441 job_types_->pop_front(); 442 } 443 return new TestConnectJob(job_type, 444 group_name, 445 request, 446 timeout_duration_, 447 delegate, 448 client_socket_factory_, 449 net_log_); 450 } 451 452 virtual base::TimeDelta ConnectionTimeout() const OVERRIDE { 453 return timeout_duration_; 454 } 455 456 private: 457 TestConnectJob::JobType job_type_; 458 std::list<TestConnectJob::JobType>* job_types_; 459 base::TimeDelta timeout_duration_; 460 MockClientSocketFactory* const client_socket_factory_; 461 NetLog* net_log_; 462 463 DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory); 464 }; 465 466 class TestClientSocketPool : public ClientSocketPool { 467 public: 468 TestClientSocketPool( 469 int max_sockets, 470 int max_sockets_per_group, 471 ClientSocketPoolHistograms* histograms, 472 base::TimeDelta unused_idle_socket_timeout, 473 base::TimeDelta used_idle_socket_timeout, 474 TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory) 475 : base_(max_sockets, max_sockets_per_group, histograms, 476 unused_idle_socket_timeout, used_idle_socket_timeout, 477 connect_job_factory) {} 478 479 virtual ~TestClientSocketPool() {} 480 481 virtual int RequestSocket( 482 const std::string& group_name, 483 const void* params, 484 net::RequestPriority priority, 485 ClientSocketHandle* handle, 486 const CompletionCallback& callback, 487 const BoundNetLog& net_log) OVERRIDE { 488 const scoped_refptr<TestSocketParams>* casted_socket_params = 489 static_cast<const scoped_refptr<TestSocketParams>*>(params); 490 return base_.RequestSocket(group_name, *casted_socket_params, priority, 491 handle, callback, net_log); 492 } 493 494 virtual void RequestSockets(const std::string& group_name, 495 const void* params, 496 int num_sockets, 497 const BoundNetLog& net_log) OVERRIDE { 498 const scoped_refptr<TestSocketParams>* casted_params = 499 static_cast<const scoped_refptr<TestSocketParams>*>(params); 500 501 base_.RequestSockets(group_name, *casted_params, num_sockets, net_log); 502 } 503 504 virtual void CancelRequest( 505 const std::string& group_name, 506 ClientSocketHandle* handle) OVERRIDE { 507 base_.CancelRequest(group_name, handle); 508 } 509 510 virtual void ReleaseSocket( 511 const std::string& group_name, 512 StreamSocket* socket, 513 int id) OVERRIDE { 514 base_.ReleaseSocket(group_name, socket, id); 515 } 516 517 virtual void FlushWithError(int error) OVERRIDE { 518 base_.FlushWithError(error); 519 } 520 521 virtual bool IsStalled() const OVERRIDE { 522 return base_.IsStalled(); 523 } 524 525 virtual void CloseIdleSockets() OVERRIDE { 526 base_.CloseIdleSockets(); 527 } 528 529 virtual int IdleSocketCount() const OVERRIDE { 530 return base_.idle_socket_count(); 531 } 532 533 virtual int IdleSocketCountInGroup( 534 const std::string& group_name) const OVERRIDE { 535 return base_.IdleSocketCountInGroup(group_name); 536 } 537 538 virtual LoadState GetLoadState( 539 const std::string& group_name, 540 const ClientSocketHandle* handle) const OVERRIDE { 541 return base_.GetLoadState(group_name, handle); 542 } 543 544 virtual void AddLayeredPool(LayeredPool* pool) OVERRIDE { 545 base_.AddLayeredPool(pool); 546 } 547 548 virtual void RemoveLayeredPool(LayeredPool* pool) OVERRIDE { 549 base_.RemoveLayeredPool(pool); 550 } 551 552 virtual base::DictionaryValue* GetInfoAsValue( 553 const std::string& name, 554 const std::string& type, 555 bool include_nested_pools) const OVERRIDE { 556 return base_.GetInfoAsValue(name, type); 557 } 558 559 virtual base::TimeDelta ConnectionTimeout() const OVERRIDE { 560 return base_.ConnectionTimeout(); 561 } 562 563 virtual ClientSocketPoolHistograms* histograms() const OVERRIDE { 564 return base_.histograms(); 565 } 566 567 const TestClientSocketPoolBase* base() const { return &base_; } 568 569 int NumUnassignedConnectJobsInGroup(const std::string& group_name) const { 570 return base_.NumUnassignedConnectJobsInGroup(group_name); 571 } 572 573 int NumConnectJobsInGroup(const std::string& group_name) const { 574 return base_.NumConnectJobsInGroup(group_name); 575 } 576 577 int NumActiveSocketsInGroup(const std::string& group_name) const { 578 return base_.NumActiveSocketsInGroup(group_name); 579 } 580 581 bool HasGroup(const std::string& group_name) const { 582 return base_.HasGroup(group_name); 583 } 584 585 void CleanupTimedOutIdleSockets() { base_.CleanupIdleSockets(false); } 586 587 void EnableConnectBackupJobs() { base_.EnableConnectBackupJobs(); } 588 589 bool CloseOneIdleConnectionInLayeredPool() { 590 return base_.CloseOneIdleConnectionInLayeredPool(); 591 } 592 593 private: 594 TestClientSocketPoolBase base_; 595 596 DISALLOW_COPY_AND_ASSIGN(TestClientSocketPool); 597 }; 598 599 } // namespace 600 601 REGISTER_SOCKET_PARAMS_FOR_POOL(TestClientSocketPool, TestSocketParams); 602 603 namespace { 604 605 void MockClientSocketFactory::SignalJobs() { 606 for (std::vector<TestConnectJob*>::iterator it = waiting_jobs_.begin(); 607 it != waiting_jobs_.end(); ++it) { 608 (*it)->Signal(); 609 } 610 waiting_jobs_.clear(); 611 } 612 613 void MockClientSocketFactory::SignalJob(size_t job) { 614 ASSERT_LT(job, waiting_jobs_.size()); 615 waiting_jobs_[job]->Signal(); 616 waiting_jobs_.erase(waiting_jobs_.begin() + job); 617 } 618 619 void MockClientSocketFactory::SetJobLoadState(size_t job, 620 LoadState load_state) { 621 ASSERT_LT(job, waiting_jobs_.size()); 622 waiting_jobs_[job]->set_load_state(load_state); 623 } 624 625 class TestConnectJobDelegate : public ConnectJob::Delegate { 626 public: 627 TestConnectJobDelegate() 628 : have_result_(false), waiting_for_result_(false), result_(OK) {} 629 virtual ~TestConnectJobDelegate() {} 630 631 virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE { 632 result_ = result; 633 scoped_ptr<StreamSocket> socket(job->ReleaseSocket()); 634 // socket.get() should be NULL iff result != OK 635 EXPECT_EQ(socket.get() == NULL, result != OK); 636 delete job; 637 have_result_ = true; 638 if (waiting_for_result_) 639 base::MessageLoop::current()->Quit(); 640 } 641 642 int WaitForResult() { 643 DCHECK(!waiting_for_result_); 644 while (!have_result_) { 645 waiting_for_result_ = true; 646 base::MessageLoop::current()->Run(); 647 waiting_for_result_ = false; 648 } 649 have_result_ = false; // auto-reset for next callback 650 return result_; 651 } 652 653 private: 654 bool have_result_; 655 bool waiting_for_result_; 656 int result_; 657 }; 658 659 class ClientSocketPoolBaseTest : public testing::Test { 660 protected: 661 ClientSocketPoolBaseTest() 662 : params_(new TestSocketParams()), 663 histograms_("ClientSocketPoolTest") { 664 connect_backup_jobs_enabled_ = 665 internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled(); 666 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true); 667 cleanup_timer_enabled_ = 668 internal::ClientSocketPoolBaseHelper::cleanup_timer_enabled(); 669 } 670 671 virtual ~ClientSocketPoolBaseTest() { 672 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled( 673 connect_backup_jobs_enabled_); 674 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled( 675 cleanup_timer_enabled_); 676 } 677 678 void CreatePool(int max_sockets, int max_sockets_per_group) { 679 CreatePoolWithIdleTimeouts( 680 max_sockets, 681 max_sockets_per_group, 682 ClientSocketPool::unused_idle_socket_timeout(), 683 ClientSocketPool::used_idle_socket_timeout()); 684 } 685 686 void CreatePoolWithIdleTimeouts( 687 int max_sockets, int max_sockets_per_group, 688 base::TimeDelta unused_idle_socket_timeout, 689 base::TimeDelta used_idle_socket_timeout) { 690 DCHECK(!pool_.get()); 691 connect_job_factory_ = new TestConnectJobFactory(&client_socket_factory_, 692 &net_log_); 693 pool_.reset(new TestClientSocketPool(max_sockets, 694 max_sockets_per_group, 695 &histograms_, 696 unused_idle_socket_timeout, 697 used_idle_socket_timeout, 698 connect_job_factory_)); 699 } 700 701 int StartRequestWithParams( 702 const std::string& group_name, 703 RequestPriority priority, 704 const scoped_refptr<TestSocketParams>& params) { 705 return test_base_.StartRequestUsingPool< 706 TestClientSocketPool, TestSocketParams>( 707 pool_.get(), group_name, priority, params); 708 } 709 710 int StartRequest(const std::string& group_name, RequestPriority priority) { 711 return StartRequestWithParams(group_name, priority, params_); 712 } 713 714 int GetOrderOfRequest(size_t index) const { 715 return test_base_.GetOrderOfRequest(index); 716 } 717 718 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) { 719 return test_base_.ReleaseOneConnection(keep_alive); 720 } 721 722 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) { 723 test_base_.ReleaseAllConnections(keep_alive); 724 } 725 726 TestSocketRequest* request(int i) { return test_base_.request(i); } 727 size_t requests_size() const { return test_base_.requests_size(); } 728 ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); } 729 size_t completion_count() const { return test_base_.completion_count(); } 730 731 CapturingNetLog net_log_; 732 bool connect_backup_jobs_enabled_; 733 bool cleanup_timer_enabled_; 734 MockClientSocketFactory client_socket_factory_; 735 TestConnectJobFactory* connect_job_factory_; 736 scoped_refptr<TestSocketParams> params_; 737 ClientSocketPoolHistograms histograms_; 738 scoped_ptr<TestClientSocketPool> pool_; 739 ClientSocketPoolTest test_base_; 740 }; 741 742 // Even though a timeout is specified, it doesn't time out on a synchronous 743 // completion. 744 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) { 745 TestConnectJobDelegate delegate; 746 ClientSocketHandle ignored; 747 TestClientSocketPoolBase::Request request( 748 &ignored, CompletionCallback(), kDefaultPriority, 749 internal::ClientSocketPoolBaseHelper::NORMAL, 750 false, params_, BoundNetLog()); 751 scoped_ptr<TestConnectJob> job( 752 new TestConnectJob(TestConnectJob::kMockJob, 753 "a", 754 request, 755 base::TimeDelta::FromMicroseconds(1), 756 &delegate, 757 &client_socket_factory_, 758 NULL)); 759 EXPECT_EQ(OK, job->Connect()); 760 } 761 762 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) { 763 TestConnectJobDelegate delegate; 764 ClientSocketHandle ignored; 765 CapturingNetLog log; 766 767 TestClientSocketPoolBase::Request request( 768 &ignored, CompletionCallback(), kDefaultPriority, 769 internal::ClientSocketPoolBaseHelper::NORMAL, 770 false, params_, BoundNetLog()); 771 // Deleted by TestConnectJobDelegate. 772 TestConnectJob* job = 773 new TestConnectJob(TestConnectJob::kMockPendingJob, 774 "a", 775 request, 776 base::TimeDelta::FromMicroseconds(1), 777 &delegate, 778 &client_socket_factory_, 779 &log); 780 ASSERT_EQ(ERR_IO_PENDING, job->Connect()); 781 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1)); 782 EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult()); 783 784 CapturingNetLog::CapturedEntryList entries; 785 log.GetEntries(&entries); 786 787 EXPECT_EQ(6u, entries.size()); 788 EXPECT_TRUE(LogContainsBeginEvent( 789 entries, 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 790 EXPECT_TRUE(LogContainsBeginEvent( 791 entries, 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT)); 792 EXPECT_TRUE(LogContainsEvent( 793 entries, 2, NetLog::TYPE_CONNECT_JOB_SET_SOCKET, 794 NetLog::PHASE_NONE)); 795 EXPECT_TRUE(LogContainsEvent( 796 entries, 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT, 797 NetLog::PHASE_NONE)); 798 EXPECT_TRUE(LogContainsEndEvent( 799 entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT)); 800 EXPECT_TRUE(LogContainsEndEvent( 801 entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 802 } 803 804 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) { 805 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 806 807 TestCompletionCallback callback; 808 ClientSocketHandle handle; 809 CapturingBoundNetLog log; 810 TestLoadTimingInfoNotConnected(handle); 811 812 EXPECT_EQ(OK, 813 handle.Init("a", 814 params_, 815 kDefaultPriority, 816 callback.callback(), 817 pool_.get(), 818 log.bound())); 819 EXPECT_TRUE(handle.is_initialized()); 820 EXPECT_TRUE(handle.socket()); 821 TestLoadTimingInfoConnectedNotReused(handle); 822 823 handle.Reset(); 824 TestLoadTimingInfoNotConnected(handle); 825 826 CapturingNetLog::CapturedEntryList entries; 827 log.GetEntries(&entries); 828 829 EXPECT_EQ(4u, entries.size()); 830 EXPECT_TRUE(LogContainsBeginEvent( 831 entries, 0, NetLog::TYPE_SOCKET_POOL)); 832 EXPECT_TRUE(LogContainsEvent( 833 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, 834 NetLog::PHASE_NONE)); 835 EXPECT_TRUE(LogContainsEvent( 836 entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET, 837 NetLog::PHASE_NONE)); 838 EXPECT_TRUE(LogContainsEndEvent( 839 entries, 3, NetLog::TYPE_SOCKET_POOL)); 840 } 841 842 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { 843 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 844 845 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); 846 CapturingBoundNetLog log; 847 848 ClientSocketHandle handle; 849 TestCompletionCallback callback; 850 // Set the additional error state members to ensure that they get cleared. 851 handle.set_is_ssl_error(true); 852 HttpResponseInfo info; 853 info.headers = new HttpResponseHeaders(std::string()); 854 handle.set_ssl_error_response_info(info); 855 EXPECT_EQ(ERR_CONNECTION_FAILED, 856 handle.Init("a", 857 params_, 858 kDefaultPriority, 859 callback.callback(), 860 pool_.get(), 861 log.bound())); 862 EXPECT_FALSE(handle.socket()); 863 EXPECT_FALSE(handle.is_ssl_error()); 864 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL); 865 TestLoadTimingInfoNotConnected(handle); 866 867 CapturingNetLog::CapturedEntryList entries; 868 log.GetEntries(&entries); 869 870 EXPECT_EQ(3u, entries.size()); 871 EXPECT_TRUE(LogContainsBeginEvent( 872 entries, 0, NetLog::TYPE_SOCKET_POOL)); 873 EXPECT_TRUE(LogContainsEvent( 874 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, 875 NetLog::PHASE_NONE)); 876 EXPECT_TRUE(LogContainsEndEvent( 877 entries, 2, NetLog::TYPE_SOCKET_POOL)); 878 } 879 880 TEST_F(ClientSocketPoolBaseTest, TotalLimit) { 881 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 882 883 // TODO(eroman): Check that the NetLog contains this event. 884 885 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 886 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 887 EXPECT_EQ(OK, StartRequest("c", kDefaultPriority)); 888 EXPECT_EQ(OK, StartRequest("d", kDefaultPriority)); 889 890 EXPECT_EQ(static_cast<int>(requests_size()), 891 client_socket_factory_.allocation_count()); 892 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count()); 893 894 EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority)); 895 EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", kDefaultPriority)); 896 EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", kDefaultPriority)); 897 898 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 899 900 EXPECT_EQ(static_cast<int>(requests_size()), 901 client_socket_factory_.allocation_count()); 902 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count()); 903 904 EXPECT_EQ(1, GetOrderOfRequest(1)); 905 EXPECT_EQ(2, GetOrderOfRequest(2)); 906 EXPECT_EQ(3, GetOrderOfRequest(3)); 907 EXPECT_EQ(4, GetOrderOfRequest(4)); 908 EXPECT_EQ(5, GetOrderOfRequest(5)); 909 EXPECT_EQ(6, GetOrderOfRequest(6)); 910 EXPECT_EQ(7, GetOrderOfRequest(7)); 911 912 // Make sure we test order of all requests made. 913 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8)); 914 } 915 916 TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) { 917 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 918 919 // TODO(eroman): Check that the NetLog contains this event. 920 921 // Reach all limits: max total sockets, and max sockets per group. 922 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 923 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 924 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 925 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 926 927 EXPECT_EQ(static_cast<int>(requests_size()), 928 client_socket_factory_.allocation_count()); 929 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count()); 930 931 // Now create a new group and verify that we don't starve it. 932 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority)); 933 934 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 935 936 EXPECT_EQ(static_cast<int>(requests_size()), 937 client_socket_factory_.allocation_count()); 938 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count()); 939 940 EXPECT_EQ(1, GetOrderOfRequest(1)); 941 EXPECT_EQ(2, GetOrderOfRequest(2)); 942 EXPECT_EQ(3, GetOrderOfRequest(3)); 943 EXPECT_EQ(4, GetOrderOfRequest(4)); 944 EXPECT_EQ(5, GetOrderOfRequest(5)); 945 946 // Make sure we test order of all requests made. 947 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6)); 948 } 949 950 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsPriority) { 951 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 952 953 EXPECT_EQ(OK, StartRequest("b", LOWEST)); 954 EXPECT_EQ(OK, StartRequest("a", MEDIUM)); 955 EXPECT_EQ(OK, StartRequest("b", HIGHEST)); 956 EXPECT_EQ(OK, StartRequest("a", LOWEST)); 957 958 EXPECT_EQ(static_cast<int>(requests_size()), 959 client_socket_factory_.allocation_count()); 960 961 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", LOWEST)); 962 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 963 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST)); 964 965 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 966 967 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count()); 968 969 // First 4 requests don't have to wait, and finish in order. 970 EXPECT_EQ(1, GetOrderOfRequest(1)); 971 EXPECT_EQ(2, GetOrderOfRequest(2)); 972 EXPECT_EQ(3, GetOrderOfRequest(3)); 973 EXPECT_EQ(4, GetOrderOfRequest(4)); 974 975 // Request ("b", HIGHEST) has the highest priority, then ("a", MEDIUM), 976 // and then ("c", LOWEST). 977 EXPECT_EQ(7, GetOrderOfRequest(5)); 978 EXPECT_EQ(6, GetOrderOfRequest(6)); 979 EXPECT_EQ(5, GetOrderOfRequest(7)); 980 981 // Make sure we test order of all requests made. 982 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9)); 983 } 984 985 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsGroupLimit) { 986 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 987 988 EXPECT_EQ(OK, StartRequest("a", LOWEST)); 989 EXPECT_EQ(OK, StartRequest("a", LOW)); 990 EXPECT_EQ(OK, StartRequest("b", HIGHEST)); 991 EXPECT_EQ(OK, StartRequest("b", MEDIUM)); 992 993 EXPECT_EQ(static_cast<int>(requests_size()), 994 client_socket_factory_.allocation_count()); 995 996 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", MEDIUM)); 997 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 998 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST)); 999 1000 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 1001 1002 EXPECT_EQ(static_cast<int>(requests_size()), 1003 client_socket_factory_.allocation_count()); 1004 EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count()); 1005 1006 // First 4 requests don't have to wait, and finish in order. 1007 EXPECT_EQ(1, GetOrderOfRequest(1)); 1008 EXPECT_EQ(2, GetOrderOfRequest(2)); 1009 EXPECT_EQ(3, GetOrderOfRequest(3)); 1010 EXPECT_EQ(4, GetOrderOfRequest(4)); 1011 1012 // Request ("b", 7) has the highest priority, but we can't make new socket for 1013 // group "b", because it has reached the per-group limit. Then we make 1014 // socket for ("c", 6), because it has higher priority than ("a", 4), 1015 // and we still can't make a socket for group "b". 1016 EXPECT_EQ(5, GetOrderOfRequest(5)); 1017 EXPECT_EQ(6, GetOrderOfRequest(6)); 1018 EXPECT_EQ(7, GetOrderOfRequest(7)); 1019 1020 // Make sure we test order of all requests made. 1021 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8)); 1022 } 1023 1024 // Make sure that we count connecting sockets against the total limit. 1025 TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) { 1026 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1027 1028 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1029 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 1030 EXPECT_EQ(OK, StartRequest("c", kDefaultPriority)); 1031 1032 // Create one asynchronous request. 1033 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1034 EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", kDefaultPriority)); 1035 1036 // We post all of our delayed tasks with a 2ms delay. I.e. they don't 1037 // actually become pending until 2ms after they have been created. In order 1038 // to flush all tasks, we need to wait so that we know there are no 1039 // soon-to-be-pending tasks waiting. 1040 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); 1041 base::MessageLoop::current()->RunUntilIdle(); 1042 1043 // The next synchronous request should wait for its turn. 1044 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1045 EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority)); 1046 1047 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 1048 1049 EXPECT_EQ(static_cast<int>(requests_size()), 1050 client_socket_factory_.allocation_count()); 1051 1052 EXPECT_EQ(1, GetOrderOfRequest(1)); 1053 EXPECT_EQ(2, GetOrderOfRequest(2)); 1054 EXPECT_EQ(3, GetOrderOfRequest(3)); 1055 EXPECT_EQ(4, GetOrderOfRequest(4)); 1056 EXPECT_EQ(5, GetOrderOfRequest(5)); 1057 1058 // Make sure we test order of all requests made. 1059 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6)); 1060 } 1061 1062 TEST_F(ClientSocketPoolBaseTest, CorrectlyCountStalledGroups) { 1063 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 1064 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1065 1066 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1067 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1068 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1069 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1070 1071 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1072 1073 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1074 1075 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", kDefaultPriority)); 1076 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority)); 1077 1078 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1079 1080 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); 1081 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count()); 1082 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); 1083 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count()); 1084 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); 1085 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); 1086 EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count()); 1087 } 1088 1089 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) { 1090 CreatePool(kDefaultMaxSockets, kDefaultMaxSockets); 1091 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1092 1093 ClientSocketHandle handle; 1094 TestCompletionCallback callback; 1095 EXPECT_EQ(ERR_IO_PENDING, 1096 handle.Init("a", 1097 params_, 1098 kDefaultPriority, 1099 callback.callback(), 1100 pool_.get(), 1101 BoundNetLog())); 1102 1103 ClientSocketHandle handles[4]; 1104 for (size_t i = 0; i < arraysize(handles); ++i) { 1105 TestCompletionCallback callback; 1106 EXPECT_EQ(ERR_IO_PENDING, 1107 handles[i].Init("b", 1108 params_, 1109 kDefaultPriority, 1110 callback.callback(), 1111 pool_.get(), 1112 BoundNetLog())); 1113 } 1114 1115 // One will be stalled, cancel all the handles now. 1116 // This should hit the OnAvailableSocketSlot() code where we previously had 1117 // stalled groups, but no longer have any. 1118 for (size_t i = 0; i < arraysize(handles); ++i) 1119 handles[i].Reset(); 1120 } 1121 1122 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) { 1123 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1124 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1125 1126 { 1127 ClientSocketHandle handles[kDefaultMaxSockets]; 1128 TestCompletionCallback callbacks[kDefaultMaxSockets]; 1129 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1130 EXPECT_EQ(OK, handles[i].Init(base::IntToString(i), 1131 params_, 1132 kDefaultPriority, 1133 callbacks[i].callback(), 1134 pool_.get(), 1135 BoundNetLog())); 1136 } 1137 1138 // Force a stalled group. 1139 ClientSocketHandle stalled_handle; 1140 TestCompletionCallback callback; 1141 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", 1142 params_, 1143 kDefaultPriority, 1144 callback.callback(), 1145 pool_.get(), 1146 BoundNetLog())); 1147 1148 // Cancel the stalled request. 1149 stalled_handle.Reset(); 1150 1151 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1152 EXPECT_EQ(0, pool_->IdleSocketCount()); 1153 1154 // Dropping out of scope will close all handles and return them to idle. 1155 } 1156 1157 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1158 EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount()); 1159 } 1160 1161 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) { 1162 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1163 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1164 1165 { 1166 ClientSocketHandle handles[kDefaultMaxSockets]; 1167 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1168 TestCompletionCallback callback; 1169 EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i), 1170 params_, 1171 kDefaultPriority, 1172 callback.callback(), 1173 pool_.get(), 1174 BoundNetLog())); 1175 } 1176 1177 // Force a stalled group. 1178 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1179 ClientSocketHandle stalled_handle; 1180 TestCompletionCallback callback; 1181 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", 1182 params_, 1183 kDefaultPriority, 1184 callback.callback(), 1185 pool_.get(), 1186 BoundNetLog())); 1187 1188 // Since it is stalled, it should have no connect jobs. 1189 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo")); 1190 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo")); 1191 1192 // Cancel the stalled request. 1193 handles[0].Reset(); 1194 1195 // Now we should have a connect job. 1196 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("foo")); 1197 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo")); 1198 1199 // The stalled socket should connect. 1200 EXPECT_EQ(OK, callback.WaitForResult()); 1201 1202 EXPECT_EQ(kDefaultMaxSockets + 1, 1203 client_socket_factory_.allocation_count()); 1204 EXPECT_EQ(0, pool_->IdleSocketCount()); 1205 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo")); 1206 EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo")); 1207 1208 // Dropping out of scope will close all handles and return them to idle. 1209 } 1210 1211 EXPECT_EQ(1, pool_->IdleSocketCount()); 1212 } 1213 1214 TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) { 1215 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1216 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1217 1218 ClientSocketHandle stalled_handle; 1219 TestCompletionCallback callback; 1220 { 1221 EXPECT_FALSE(pool_->IsStalled()); 1222 ClientSocketHandle handles[kDefaultMaxSockets]; 1223 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1224 TestCompletionCallback callback; 1225 EXPECT_EQ(OK, handles[i].Init(base::StringPrintf( 1226 "Take 2: %d", i), 1227 params_, 1228 kDefaultPriority, 1229 callback.callback(), 1230 pool_.get(), 1231 BoundNetLog())); 1232 } 1233 1234 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1235 EXPECT_EQ(0, pool_->IdleSocketCount()); 1236 EXPECT_FALSE(pool_->IsStalled()); 1237 1238 // Now we will hit the socket limit. 1239 EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo", 1240 params_, 1241 kDefaultPriority, 1242 callback.callback(), 1243 pool_.get(), 1244 BoundNetLog())); 1245 EXPECT_TRUE(pool_->IsStalled()); 1246 1247 // Dropping out of scope will close all handles and return them to idle. 1248 } 1249 1250 // But if we wait for it, the released idle sockets will be closed in 1251 // preference of the waiting request. 1252 EXPECT_EQ(OK, callback.WaitForResult()); 1253 1254 EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count()); 1255 EXPECT_EQ(3, pool_->IdleSocketCount()); 1256 } 1257 1258 // Regression test for http://crbug.com/40952. 1259 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) { 1260 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1261 pool_->EnableConnectBackupJobs(); 1262 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1263 1264 for (int i = 0; i < kDefaultMaxSockets; ++i) { 1265 ClientSocketHandle handle; 1266 TestCompletionCallback callback; 1267 EXPECT_EQ(OK, handle.Init(base::IntToString(i), 1268 params_, 1269 kDefaultPriority, 1270 callback.callback(), 1271 pool_.get(), 1272 BoundNetLog())); 1273 } 1274 1275 // Flush all the DoReleaseSocket tasks. 1276 base::MessageLoop::current()->RunUntilIdle(); 1277 1278 // Stall a group. Set a pending job so it'll trigger a backup job if we don't 1279 // reuse a socket. 1280 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1281 ClientSocketHandle handle; 1282 TestCompletionCallback callback; 1283 1284 // "0" is special here, since it should be the first entry in the sorted map, 1285 // which is the one which we would close an idle socket for. We shouldn't 1286 // close an idle socket though, since we should reuse the idle socket. 1287 EXPECT_EQ(OK, handle.Init("0", 1288 params_, 1289 kDefaultPriority, 1290 callback.callback(), 1291 pool_.get(), 1292 BoundNetLog())); 1293 1294 EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count()); 1295 EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount()); 1296 } 1297 1298 TEST_F(ClientSocketPoolBaseTest, PendingRequests) { 1299 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1300 1301 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1302 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1303 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", IDLE)); 1304 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1305 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 1306 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 1307 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 1308 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1309 1310 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); 1311 1312 EXPECT_EQ(kDefaultMaxSocketsPerGroup, 1313 client_socket_factory_.allocation_count()); 1314 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup, 1315 completion_count()); 1316 1317 EXPECT_EQ(1, GetOrderOfRequest(1)); 1318 EXPECT_EQ(2, GetOrderOfRequest(2)); 1319 EXPECT_EQ(8, GetOrderOfRequest(3)); 1320 EXPECT_EQ(6, GetOrderOfRequest(4)); 1321 EXPECT_EQ(4, GetOrderOfRequest(5)); 1322 EXPECT_EQ(3, GetOrderOfRequest(6)); 1323 EXPECT_EQ(5, GetOrderOfRequest(7)); 1324 EXPECT_EQ(7, GetOrderOfRequest(8)); 1325 1326 // Make sure we test order of all requests made. 1327 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9)); 1328 } 1329 1330 TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) { 1331 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1332 1333 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1334 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1335 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1336 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 1337 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 1338 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 1339 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1340 1341 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 1342 1343 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i) 1344 EXPECT_EQ(OK, request(i)->WaitForResult()); 1345 1346 EXPECT_EQ(static_cast<int>(requests_size()), 1347 client_socket_factory_.allocation_count()); 1348 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup, 1349 completion_count()); 1350 } 1351 1352 // This test will start up a RequestSocket() and then immediately Cancel() it. 1353 // The pending connect job will be cancelled and should not call back into 1354 // ClientSocketPoolBase. 1355 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) { 1356 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1357 1358 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1359 ClientSocketHandle handle; 1360 TestCompletionCallback callback; 1361 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", 1362 params_, 1363 kDefaultPriority, 1364 callback.callback(), 1365 pool_.get(), 1366 BoundNetLog())); 1367 handle.Reset(); 1368 } 1369 1370 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) { 1371 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1372 1373 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1374 ClientSocketHandle handle; 1375 TestCompletionCallback callback; 1376 1377 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", 1378 params_, 1379 kDefaultPriority, 1380 callback.callback(), 1381 pool_.get(), 1382 BoundNetLog())); 1383 1384 handle.Reset(); 1385 1386 TestCompletionCallback callback2; 1387 EXPECT_EQ(ERR_IO_PENDING, 1388 handle.Init("a", 1389 params_, 1390 kDefaultPriority, 1391 callback2.callback(), 1392 pool_.get(), 1393 BoundNetLog())); 1394 1395 EXPECT_EQ(OK, callback2.WaitForResult()); 1396 EXPECT_FALSE(callback.have_result()); 1397 1398 handle.Reset(); 1399 } 1400 1401 TEST_F(ClientSocketPoolBaseTest, CancelRequest) { 1402 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1403 1404 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1405 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1406 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1407 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 1408 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 1409 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 1410 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1411 1412 // Cancel a request. 1413 size_t index_to_cancel = kDefaultMaxSocketsPerGroup + 2; 1414 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized()); 1415 (*requests())[index_to_cancel]->handle()->Reset(); 1416 1417 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); 1418 1419 EXPECT_EQ(kDefaultMaxSocketsPerGroup, 1420 client_socket_factory_.allocation_count()); 1421 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup - 1, 1422 completion_count()); 1423 1424 EXPECT_EQ(1, GetOrderOfRequest(1)); 1425 EXPECT_EQ(2, GetOrderOfRequest(2)); 1426 EXPECT_EQ(5, GetOrderOfRequest(3)); 1427 EXPECT_EQ(3, GetOrderOfRequest(4)); 1428 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, 1429 GetOrderOfRequest(5)); // Canceled request. 1430 EXPECT_EQ(4, GetOrderOfRequest(6)); 1431 EXPECT_EQ(6, GetOrderOfRequest(7)); 1432 1433 // Make sure we test order of all requests made. 1434 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8)); 1435 } 1436 1437 class RequestSocketCallback : public TestCompletionCallbackBase { 1438 public: 1439 RequestSocketCallback(ClientSocketHandle* handle, 1440 TestClientSocketPool* pool, 1441 TestConnectJobFactory* test_connect_job_factory, 1442 TestConnectJob::JobType next_job_type) 1443 : handle_(handle), 1444 pool_(pool), 1445 within_callback_(false), 1446 test_connect_job_factory_(test_connect_job_factory), 1447 next_job_type_(next_job_type), 1448 callback_(base::Bind(&RequestSocketCallback::OnComplete, 1449 base::Unretained(this))) { 1450 } 1451 1452 virtual ~RequestSocketCallback() {} 1453 1454 const CompletionCallback& callback() const { return callback_; } 1455 1456 private: 1457 void OnComplete(int result) { 1458 SetResult(result); 1459 ASSERT_EQ(OK, result); 1460 1461 if (!within_callback_) { 1462 test_connect_job_factory_->set_job_type(next_job_type_); 1463 1464 // Don't allow reuse of the socket. Disconnect it and then release it and 1465 // run through the MessageLoop once to get it completely released. 1466 handle_->socket()->Disconnect(); 1467 handle_->Reset(); 1468 { 1469 // TODO: Resolve conflicting intentions of stopping recursion with the 1470 // |!within_callback_| test (above) and the call to |RunUntilIdle()| 1471 // below. http://crbug.com/114130. 1472 base::MessageLoop::ScopedNestableTaskAllower allow( 1473 base::MessageLoop::current()); 1474 base::MessageLoop::current()->RunUntilIdle(); 1475 } 1476 within_callback_ = true; 1477 TestCompletionCallback next_job_callback; 1478 scoped_refptr<TestSocketParams> params(new TestSocketParams()); 1479 int rv = handle_->Init("a", 1480 params, 1481 kDefaultPriority, 1482 next_job_callback.callback(), 1483 pool_, 1484 BoundNetLog()); 1485 switch (next_job_type_) { 1486 case TestConnectJob::kMockJob: 1487 EXPECT_EQ(OK, rv); 1488 break; 1489 case TestConnectJob::kMockPendingJob: 1490 EXPECT_EQ(ERR_IO_PENDING, rv); 1491 1492 // For pending jobs, wait for new socket to be created. This makes 1493 // sure there are no more pending operations nor any unclosed sockets 1494 // when the test finishes. 1495 // We need to give it a little bit of time to run, so that all the 1496 // operations that happen on timers (e.g. cleanup of idle 1497 // connections) can execute. 1498 { 1499 base::MessageLoop::ScopedNestableTaskAllower allow( 1500 base::MessageLoop::current()); 1501 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); 1502 EXPECT_EQ(OK, next_job_callback.WaitForResult()); 1503 } 1504 break; 1505 default: 1506 FAIL() << "Unexpected job type: " << next_job_type_; 1507 break; 1508 } 1509 } 1510 } 1511 1512 ClientSocketHandle* const handle_; 1513 TestClientSocketPool* const pool_; 1514 bool within_callback_; 1515 TestConnectJobFactory* const test_connect_job_factory_; 1516 TestConnectJob::JobType next_job_type_; 1517 CompletionCallback callback_; 1518 }; 1519 1520 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) { 1521 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1522 1523 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1524 ClientSocketHandle handle; 1525 RequestSocketCallback callback( 1526 &handle, pool_.get(), connect_job_factory_, 1527 TestConnectJob::kMockPendingJob); 1528 int rv = handle.Init("a", 1529 params_, 1530 kDefaultPriority, 1531 callback.callback(), 1532 pool_.get(), 1533 BoundNetLog()); 1534 ASSERT_EQ(ERR_IO_PENDING, rv); 1535 1536 EXPECT_EQ(OK, callback.WaitForResult()); 1537 } 1538 1539 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) { 1540 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1541 1542 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1543 ClientSocketHandle handle; 1544 RequestSocketCallback callback( 1545 &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob); 1546 int rv = handle.Init("a", 1547 params_, 1548 kDefaultPriority, 1549 callback.callback(), 1550 pool_.get(), 1551 BoundNetLog()); 1552 ASSERT_EQ(ERR_IO_PENDING, rv); 1553 1554 EXPECT_EQ(OK, callback.WaitForResult()); 1555 } 1556 1557 // Make sure that pending requests get serviced after active requests get 1558 // cancelled. 1559 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) { 1560 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1561 1562 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1563 1564 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1565 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1566 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1567 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1568 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1569 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1570 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1571 1572 // Now, kDefaultMaxSocketsPerGroup requests should be active. 1573 // Let's cancel them. 1574 for (int i = 0; i < kDefaultMaxSocketsPerGroup; ++i) { 1575 ASSERT_FALSE(request(i)->handle()->is_initialized()); 1576 request(i)->handle()->Reset(); 1577 } 1578 1579 // Let's wait for the rest to complete now. 1580 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i) { 1581 EXPECT_EQ(OK, request(i)->WaitForResult()); 1582 request(i)->handle()->Reset(); 1583 } 1584 1585 EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup, 1586 completion_count()); 1587 } 1588 1589 // Make sure that pending requests get serviced after active requests fail. 1590 TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) { 1591 const size_t kMaxSockets = 5; 1592 CreatePool(kMaxSockets, kDefaultMaxSocketsPerGroup); 1593 1594 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 1595 1596 const size_t kNumberOfRequests = 2 * kDefaultMaxSocketsPerGroup + 1; 1597 ASSERT_LE(kNumberOfRequests, kMaxSockets); // Otherwise the test will hang. 1598 1599 // Queue up all the requests 1600 for (size_t i = 0; i < kNumberOfRequests; ++i) 1601 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1602 1603 for (size_t i = 0; i < kNumberOfRequests; ++i) 1604 EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult()); 1605 } 1606 1607 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) { 1608 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1609 1610 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1611 1612 ClientSocketHandle handle; 1613 TestCompletionCallback callback; 1614 int rv = handle.Init("a", 1615 params_, 1616 kDefaultPriority, 1617 callback.callback(), 1618 pool_.get(), 1619 BoundNetLog()); 1620 EXPECT_EQ(ERR_IO_PENDING, rv); 1621 1622 // Cancel the active request. 1623 handle.Reset(); 1624 1625 rv = handle.Init("a", 1626 params_, 1627 kDefaultPriority, 1628 callback.callback(), 1629 pool_.get(), 1630 BoundNetLog()); 1631 EXPECT_EQ(ERR_IO_PENDING, rv); 1632 EXPECT_EQ(OK, callback.WaitForResult()); 1633 1634 EXPECT_FALSE(handle.is_reused()); 1635 TestLoadTimingInfoConnectedNotReused(handle); 1636 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 1637 } 1638 1639 // Regression test for http://crbug.com/17985. 1640 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) { 1641 const int kMaxSockets = 3; 1642 const int kMaxSocketsPerGroup = 2; 1643 CreatePool(kMaxSockets, kMaxSocketsPerGroup); 1644 1645 const RequestPriority kHighPriority = HIGHEST; 1646 1647 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1648 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1649 1650 // This is going to be a pending request in an otherwise empty group. 1651 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1652 1653 // Reach the maximum socket limit. 1654 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 1655 1656 // Create a stalled group with high priorities. 1657 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority)); 1658 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority)); 1659 1660 // Release the first two sockets from "a". Because this is a keepalive, 1661 // the first release will unblock the pending request for "a". The 1662 // second release will unblock a request for "c", becaue it is the next 1663 // high priority socket. 1664 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); 1665 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE)); 1666 1667 // Closing idle sockets should not get us into trouble, but in the bug 1668 // we were hitting a CHECK here. 1669 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 1670 pool_->CloseIdleSockets(); 1671 1672 // Run the released socket wakeups. 1673 base::MessageLoop::current()->RunUntilIdle(); 1674 } 1675 1676 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) { 1677 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1678 1679 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1680 ClientSocketHandle handle; 1681 TestCompletionCallback callback; 1682 CapturingBoundNetLog log; 1683 int rv = handle.Init("a", 1684 params_, 1685 LOWEST, 1686 callback.callback(), 1687 pool_.get(), 1688 log.bound()); 1689 EXPECT_EQ(ERR_IO_PENDING, rv); 1690 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 1691 TestLoadTimingInfoNotConnected(handle); 1692 1693 EXPECT_EQ(OK, callback.WaitForResult()); 1694 EXPECT_TRUE(handle.is_initialized()); 1695 EXPECT_TRUE(handle.socket()); 1696 TestLoadTimingInfoConnectedNotReused(handle); 1697 1698 handle.Reset(); 1699 TestLoadTimingInfoNotConnected(handle); 1700 1701 CapturingNetLog::CapturedEntryList entries; 1702 log.GetEntries(&entries); 1703 1704 EXPECT_EQ(4u, entries.size()); 1705 EXPECT_TRUE(LogContainsBeginEvent( 1706 entries, 0, NetLog::TYPE_SOCKET_POOL)); 1707 EXPECT_TRUE(LogContainsEvent( 1708 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, 1709 NetLog::PHASE_NONE)); 1710 EXPECT_TRUE(LogContainsEvent( 1711 entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET, 1712 NetLog::PHASE_NONE)); 1713 EXPECT_TRUE(LogContainsEndEvent( 1714 entries, 3, NetLog::TYPE_SOCKET_POOL)); 1715 } 1716 1717 TEST_F(ClientSocketPoolBaseTest, 1718 InitConnectionAsynchronousFailure) { 1719 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1720 1721 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 1722 ClientSocketHandle handle; 1723 TestCompletionCallback callback; 1724 CapturingBoundNetLog log; 1725 // Set the additional error state members to ensure that they get cleared. 1726 handle.set_is_ssl_error(true); 1727 HttpResponseInfo info; 1728 info.headers = new HttpResponseHeaders(std::string()); 1729 handle.set_ssl_error_response_info(info); 1730 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", 1731 params_, 1732 kDefaultPriority, 1733 callback.callback(), 1734 pool_.get(), 1735 log.bound())); 1736 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 1737 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 1738 EXPECT_FALSE(handle.is_ssl_error()); 1739 EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL); 1740 1741 CapturingNetLog::CapturedEntryList entries; 1742 log.GetEntries(&entries); 1743 1744 EXPECT_EQ(3u, entries.size()); 1745 EXPECT_TRUE(LogContainsBeginEvent( 1746 entries, 0, NetLog::TYPE_SOCKET_POOL)); 1747 EXPECT_TRUE(LogContainsEvent( 1748 entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB, 1749 NetLog::PHASE_NONE)); 1750 EXPECT_TRUE(LogContainsEndEvent( 1751 entries, 2, NetLog::TYPE_SOCKET_POOL)); 1752 } 1753 1754 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) { 1755 // TODO(eroman): Add back the log expectations! Removed them because the 1756 // ordering is difficult, and some may fire during destructor. 1757 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1758 1759 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1760 ClientSocketHandle handle; 1761 TestCompletionCallback callback; 1762 ClientSocketHandle handle2; 1763 TestCompletionCallback callback2; 1764 1765 EXPECT_EQ(ERR_IO_PENDING, 1766 handle.Init("a", 1767 params_, 1768 kDefaultPriority, 1769 callback.callback(), 1770 pool_.get(), 1771 BoundNetLog())); 1772 CapturingBoundNetLog log2; 1773 EXPECT_EQ(ERR_IO_PENDING, 1774 handle2.Init("a", 1775 params_, 1776 kDefaultPriority, 1777 callback2.callback(), 1778 pool_.get(), 1779 BoundNetLog())); 1780 1781 handle.Reset(); 1782 1783 1784 // At this point, request 2 is just waiting for the connect job to finish. 1785 1786 EXPECT_EQ(OK, callback2.WaitForResult()); 1787 handle2.Reset(); 1788 1789 // Now request 2 has actually finished. 1790 // TODO(eroman): Add back log expectations. 1791 } 1792 1793 TEST_F(ClientSocketPoolBaseTest, CancelRequestLimitsJobs) { 1794 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1795 1796 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1797 1798 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1799 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 1800 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 1801 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 1802 1803 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a")); 1804 (*requests())[2]->handle()->Reset(); 1805 (*requests())[3]->handle()->Reset(); 1806 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a")); 1807 1808 (*requests())[1]->handle()->Reset(); 1809 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a")); 1810 1811 (*requests())[0]->handle()->Reset(); 1812 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a")); 1813 } 1814 1815 // When requests and ConnectJobs are not coupled, the request will get serviced 1816 // by whatever comes first. 1817 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) { 1818 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1819 1820 // Start job 1 (async OK) 1821 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1822 1823 std::vector<TestSocketRequest*> request_order; 1824 size_t completion_count; // unused 1825 TestSocketRequest req1(&request_order, &completion_count); 1826 int rv = req1.handle()->Init("a", 1827 params_, 1828 kDefaultPriority, 1829 req1.callback(), pool_.get(), 1830 BoundNetLog()); 1831 EXPECT_EQ(ERR_IO_PENDING, rv); 1832 EXPECT_EQ(OK, req1.WaitForResult()); 1833 1834 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending 1835 // without a job. 1836 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1837 1838 TestSocketRequest req2(&request_order, &completion_count); 1839 rv = req2.handle()->Init("a", 1840 params_, 1841 kDefaultPriority, 1842 req2.callback(), 1843 pool_.get(), 1844 BoundNetLog()); 1845 EXPECT_EQ(ERR_IO_PENDING, rv); 1846 TestSocketRequest req3(&request_order, &completion_count); 1847 rv = req3.handle()->Init("a", 1848 params_, 1849 kDefaultPriority, 1850 req3.callback(), 1851 pool_.get(), 1852 BoundNetLog()); 1853 EXPECT_EQ(ERR_IO_PENDING, rv); 1854 1855 // Both Requests 2 and 3 are pending. We release socket 1 which should 1856 // service request 2. Request 3 should still be waiting. 1857 req1.handle()->Reset(); 1858 // Run the released socket wakeups. 1859 base::MessageLoop::current()->RunUntilIdle(); 1860 ASSERT_TRUE(req2.handle()->socket()); 1861 EXPECT_EQ(OK, req2.WaitForResult()); 1862 EXPECT_FALSE(req3.handle()->socket()); 1863 1864 // Signal job 2, which should service request 3. 1865 1866 client_socket_factory_.SignalJobs(); 1867 EXPECT_EQ(OK, req3.WaitForResult()); 1868 1869 ASSERT_EQ(3U, request_order.size()); 1870 EXPECT_EQ(&req1, request_order[0]); 1871 EXPECT_EQ(&req2, request_order[1]); 1872 EXPECT_EQ(&req3, request_order[2]); 1873 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 1874 } 1875 1876 // The requests are not coupled to the jobs. So, the requests should finish in 1877 // their priority / insertion order. 1878 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) { 1879 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1880 // First two jobs are async. 1881 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 1882 1883 std::vector<TestSocketRequest*> request_order; 1884 size_t completion_count; // unused 1885 TestSocketRequest req1(&request_order, &completion_count); 1886 int rv = req1.handle()->Init("a", 1887 params_, 1888 kDefaultPriority, 1889 req1.callback(), 1890 pool_.get(), 1891 BoundNetLog()); 1892 EXPECT_EQ(ERR_IO_PENDING, rv); 1893 1894 TestSocketRequest req2(&request_order, &completion_count); 1895 rv = req2.handle()->Init("a", 1896 params_, 1897 kDefaultPriority, 1898 req2.callback(), 1899 pool_.get(), 1900 BoundNetLog()); 1901 EXPECT_EQ(ERR_IO_PENDING, rv); 1902 1903 // The pending job is sync. 1904 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1905 1906 TestSocketRequest req3(&request_order, &completion_count); 1907 rv = req3.handle()->Init("a", 1908 params_, 1909 kDefaultPriority, 1910 req3.callback(), 1911 pool_.get(), 1912 BoundNetLog()); 1913 EXPECT_EQ(ERR_IO_PENDING, rv); 1914 1915 EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult()); 1916 EXPECT_EQ(OK, req2.WaitForResult()); 1917 EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult()); 1918 1919 ASSERT_EQ(3U, request_order.size()); 1920 EXPECT_EQ(&req1, request_order[0]); 1921 EXPECT_EQ(&req2, request_order[1]); 1922 EXPECT_EQ(&req3, request_order[2]); 1923 } 1924 1925 // Test GetLoadState in the case there's only one socket request. 1926 TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) { 1927 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1928 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1929 1930 ClientSocketHandle handle; 1931 TestCompletionCallback callback; 1932 int rv = handle.Init("a", 1933 params_, 1934 kDefaultPriority, 1935 callback.callback(), 1936 pool_.get(), 1937 BoundNetLog()); 1938 EXPECT_EQ(ERR_IO_PENDING, rv); 1939 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 1940 1941 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE); 1942 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState()); 1943 1944 // No point in completing the connection, since ClientSocketHandles only 1945 // expect the LoadState to be checked while connecting. 1946 } 1947 1948 // Test GetLoadState in the case there are two socket requests. 1949 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) { 1950 CreatePool(2, 2); 1951 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1952 1953 ClientSocketHandle handle; 1954 TestCompletionCallback callback; 1955 int rv = handle.Init("a", 1956 params_, 1957 kDefaultPriority, 1958 callback.callback(), 1959 pool_.get(), 1960 BoundNetLog()); 1961 EXPECT_EQ(ERR_IO_PENDING, rv); 1962 1963 ClientSocketHandle handle2; 1964 TestCompletionCallback callback2; 1965 rv = handle2.Init("a", 1966 params_, 1967 kDefaultPriority, 1968 callback2.callback(), 1969 pool_.get(), 1970 BoundNetLog()); 1971 EXPECT_EQ(ERR_IO_PENDING, rv); 1972 1973 // If the first Job is in an earlier state than the second, the state of 1974 // the second job should be used for both handles. 1975 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST); 1976 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 1977 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState()); 1978 1979 // If the second Job is in an earlier state than the second, the state of 1980 // the first job should be used for both handles. 1981 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE); 1982 // One request is farther 1983 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState()); 1984 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState()); 1985 1986 // Farthest along job connects and the first request gets the socket. The 1987 // second handle switches to the state of the remaining ConnectJob. 1988 client_socket_factory_.SignalJob(0); 1989 EXPECT_EQ(OK, callback.WaitForResult()); 1990 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState()); 1991 } 1992 1993 // Test GetLoadState in the case the per-group limit is reached. 1994 TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) { 1995 CreatePool(2, 1); 1996 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1997 1998 ClientSocketHandle handle; 1999 TestCompletionCallback callback; 2000 int rv = handle.Init("a", 2001 params_, 2002 MEDIUM, 2003 callback.callback(), 2004 pool_.get(), 2005 BoundNetLog()); 2006 EXPECT_EQ(ERR_IO_PENDING, rv); 2007 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 2008 2009 // Request another socket from the same pool, buth with a higher priority. 2010 // The first request should now be stalled at the socket group limit. 2011 ClientSocketHandle handle2; 2012 TestCompletionCallback callback2; 2013 rv = handle2.Init("a", 2014 params_, 2015 HIGHEST, 2016 callback2.callback(), 2017 pool_.get(), 2018 BoundNetLog()); 2019 EXPECT_EQ(ERR_IO_PENDING, rv); 2020 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState()); 2021 EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState()); 2022 2023 // The first handle should remain stalled as the other socket goes through 2024 // the connect process. 2025 2026 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE); 2027 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState()); 2028 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState()); 2029 2030 client_socket_factory_.SignalJob(0); 2031 EXPECT_EQ(OK, callback2.WaitForResult()); 2032 EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState()); 2033 2034 // Closing the second socket should cause the stalled handle to finally get a 2035 // ConnectJob. 2036 handle2.socket()->Disconnect(); 2037 handle2.Reset(); 2038 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 2039 } 2040 2041 // Test GetLoadState in the case the per-pool limit is reached. 2042 TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) { 2043 CreatePool(2, 2); 2044 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 2045 2046 ClientSocketHandle handle; 2047 TestCompletionCallback callback; 2048 int rv = handle.Init("a", 2049 params_, 2050 kDefaultPriority, 2051 callback.callback(), 2052 pool_.get(), 2053 BoundNetLog()); 2054 EXPECT_EQ(ERR_IO_PENDING, rv); 2055 2056 // Request for socket from another pool. 2057 ClientSocketHandle handle2; 2058 TestCompletionCallback callback2; 2059 rv = handle2.Init("b", 2060 params_, 2061 kDefaultPriority, 2062 callback2.callback(), 2063 pool_.get(), 2064 BoundNetLog()); 2065 EXPECT_EQ(ERR_IO_PENDING, rv); 2066 2067 // Request another socket from the first pool. Request should stall at the 2068 // socket pool limit. 2069 ClientSocketHandle handle3; 2070 TestCompletionCallback callback3; 2071 rv = handle3.Init("a", 2072 params_, 2073 kDefaultPriority, 2074 callback2.callback(), 2075 pool_.get(), 2076 BoundNetLog()); 2077 EXPECT_EQ(ERR_IO_PENDING, rv); 2078 2079 // The third handle should remain stalled as the other sockets in its group 2080 // goes through the connect process. 2081 2082 EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState()); 2083 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState()); 2084 2085 client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE); 2086 EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState()); 2087 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState()); 2088 2089 client_socket_factory_.SignalJob(0); 2090 EXPECT_EQ(OK, callback.WaitForResult()); 2091 EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState()); 2092 2093 // Closing a socket should allow the stalled handle to finally get a new 2094 // ConnectJob. 2095 handle.socket()->Disconnect(); 2096 handle.Reset(); 2097 EXPECT_EQ(LOAD_STATE_CONNECTING, handle3.GetLoadState()); 2098 } 2099 2100 TEST_F(ClientSocketPoolBaseTest, Recoverable) { 2101 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2102 connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob); 2103 2104 ClientSocketHandle handle; 2105 TestCompletionCallback callback; 2106 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, 2107 handle.Init("a", params_, kDefaultPriority, callback.callback(), 2108 pool_.get(), BoundNetLog())); 2109 EXPECT_TRUE(handle.is_initialized()); 2110 EXPECT_TRUE(handle.socket()); 2111 } 2112 2113 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) { 2114 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2115 2116 connect_job_factory_->set_job_type( 2117 TestConnectJob::kMockPendingRecoverableJob); 2118 ClientSocketHandle handle; 2119 TestCompletionCallback callback; 2120 EXPECT_EQ(ERR_IO_PENDING, 2121 handle.Init("a", 2122 params_, 2123 kDefaultPriority, 2124 callback.callback(), 2125 pool_.get(), 2126 BoundNetLog())); 2127 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2128 EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult()); 2129 EXPECT_TRUE(handle.is_initialized()); 2130 EXPECT_TRUE(handle.socket()); 2131 } 2132 2133 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) { 2134 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2135 connect_job_factory_->set_job_type( 2136 TestConnectJob::kMockAdditionalErrorStateJob); 2137 2138 ClientSocketHandle handle; 2139 TestCompletionCallback callback; 2140 EXPECT_EQ(ERR_CONNECTION_FAILED, 2141 handle.Init("a", 2142 params_, 2143 kDefaultPriority, 2144 callback.callback(), 2145 pool_.get(), 2146 BoundNetLog())); 2147 EXPECT_FALSE(handle.is_initialized()); 2148 EXPECT_FALSE(handle.socket()); 2149 EXPECT_TRUE(handle.is_ssl_error()); 2150 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); 2151 } 2152 2153 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) { 2154 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2155 2156 connect_job_factory_->set_job_type( 2157 TestConnectJob::kMockPendingAdditionalErrorStateJob); 2158 ClientSocketHandle handle; 2159 TestCompletionCallback callback; 2160 EXPECT_EQ(ERR_IO_PENDING, 2161 handle.Init("a", 2162 params_, 2163 kDefaultPriority, 2164 callback.callback(), 2165 pool_.get(), 2166 BoundNetLog())); 2167 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2168 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 2169 EXPECT_FALSE(handle.is_initialized()); 2170 EXPECT_FALSE(handle.socket()); 2171 EXPECT_TRUE(handle.is_ssl_error()); 2172 EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL); 2173 } 2174 2175 // Make sure we can reuse sockets when the cleanup timer is disabled. 2176 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) { 2177 // Disable cleanup timer. 2178 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false); 2179 2180 CreatePoolWithIdleTimeouts( 2181 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, 2182 base::TimeDelta(), // Time out unused sockets immediately. 2183 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 2184 2185 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2186 2187 ClientSocketHandle handle; 2188 TestCompletionCallback callback; 2189 int rv = handle.Init("a", 2190 params_, 2191 LOWEST, 2192 callback.callback(), 2193 pool_.get(), 2194 BoundNetLog()); 2195 ASSERT_EQ(ERR_IO_PENDING, rv); 2196 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2197 ASSERT_EQ(OK, callback.WaitForResult()); 2198 2199 // Use and release the socket. 2200 EXPECT_EQ(1, handle.socket()->Write(NULL, 1, CompletionCallback())); 2201 TestLoadTimingInfoConnectedNotReused(handle); 2202 handle.Reset(); 2203 2204 // Should now have one idle socket. 2205 ASSERT_EQ(1, pool_->IdleSocketCount()); 2206 2207 // Request a new socket. This should reuse the old socket and complete 2208 // synchronously. 2209 CapturingBoundNetLog log; 2210 rv = handle.Init("a", 2211 params_, 2212 LOWEST, 2213 CompletionCallback(), 2214 pool_.get(), 2215 log.bound()); 2216 ASSERT_EQ(OK, rv); 2217 EXPECT_TRUE(handle.is_reused()); 2218 TestLoadTimingInfoConnectedReused(handle); 2219 2220 ASSERT_TRUE(pool_->HasGroup("a")); 2221 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 2222 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); 2223 2224 CapturingNetLog::CapturedEntryList entries; 2225 log.GetEntries(&entries); 2226 EXPECT_TRUE(LogContainsEntryWithType( 2227 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET)); 2228 } 2229 2230 // Make sure we cleanup old unused sockets when the cleanup timer is disabled. 2231 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerNoReuse) { 2232 // Disable cleanup timer. 2233 internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false); 2234 2235 CreatePoolWithIdleTimeouts( 2236 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, 2237 base::TimeDelta(), // Time out unused sockets immediately 2238 base::TimeDelta()); // Time out used sockets immediately 2239 2240 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2241 2242 // Startup two mock pending connect jobs, which will sit in the MessageLoop. 2243 2244 ClientSocketHandle handle; 2245 TestCompletionCallback callback; 2246 int rv = handle.Init("a", 2247 params_, 2248 LOWEST, 2249 callback.callback(), 2250 pool_.get(), 2251 BoundNetLog()); 2252 ASSERT_EQ(ERR_IO_PENDING, rv); 2253 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2254 2255 ClientSocketHandle handle2; 2256 TestCompletionCallback callback2; 2257 rv = handle2.Init("a", 2258 params_, 2259 LOWEST, 2260 callback2.callback(), 2261 pool_.get(), 2262 BoundNetLog()); 2263 ASSERT_EQ(ERR_IO_PENDING, rv); 2264 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); 2265 2266 // Cancel one of the requests. Wait for the other, which will get the first 2267 // job. Release the socket. Run the loop again to make sure the second 2268 // socket is sitting idle and the first one is released (since ReleaseSocket() 2269 // just posts a DoReleaseSocket() task). 2270 2271 handle.Reset(); 2272 ASSERT_EQ(OK, callback2.WaitForResult()); 2273 // Use the socket. 2274 EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback())); 2275 handle2.Reset(); 2276 2277 // We post all of our delayed tasks with a 2ms delay. I.e. they don't 2278 // actually become pending until 2ms after they have been created. In order 2279 // to flush all tasks, we need to wait so that we know there are no 2280 // soon-to-be-pending tasks waiting. 2281 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); 2282 base::MessageLoop::current()->RunUntilIdle(); 2283 2284 // Both sockets should now be idle. 2285 ASSERT_EQ(2, pool_->IdleSocketCount()); 2286 2287 // Request a new socket. This should cleanup the unused and timed out ones. 2288 // A new socket will be created rather than reusing the idle one. 2289 CapturingBoundNetLog log; 2290 TestCompletionCallback callback3; 2291 rv = handle.Init("a", 2292 params_, 2293 LOWEST, 2294 callback3.callback(), 2295 pool_.get(), 2296 log.bound()); 2297 ASSERT_EQ(ERR_IO_PENDING, rv); 2298 ASSERT_EQ(OK, callback3.WaitForResult()); 2299 EXPECT_FALSE(handle.is_reused()); 2300 2301 // Make sure the idle socket is closed. 2302 ASSERT_TRUE(pool_->HasGroup("a")); 2303 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 2304 EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a")); 2305 2306 CapturingNetLog::CapturedEntryList entries; 2307 log.GetEntries(&entries); 2308 EXPECT_FALSE(LogContainsEntryWithType( 2309 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET)); 2310 } 2311 2312 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) { 2313 CreatePoolWithIdleTimeouts( 2314 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, 2315 base::TimeDelta(), // Time out unused sockets immediately. 2316 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 2317 2318 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2319 2320 // Startup two mock pending connect jobs, which will sit in the MessageLoop. 2321 2322 ClientSocketHandle handle; 2323 TestCompletionCallback callback; 2324 int rv = handle.Init("a", 2325 params_, 2326 LOWEST, 2327 callback.callback(), 2328 pool_.get(), 2329 BoundNetLog()); 2330 EXPECT_EQ(ERR_IO_PENDING, rv); 2331 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle)); 2332 2333 ClientSocketHandle handle2; 2334 TestCompletionCallback callback2; 2335 rv = handle2.Init("a", 2336 params_, 2337 LOWEST, 2338 callback2.callback(), 2339 pool_.get(), 2340 BoundNetLog()); 2341 EXPECT_EQ(ERR_IO_PENDING, rv); 2342 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2)); 2343 2344 // Cancel one of the requests. Wait for the other, which will get the first 2345 // job. Release the socket. Run the loop again to make sure the second 2346 // socket is sitting idle and the first one is released (since ReleaseSocket() 2347 // just posts a DoReleaseSocket() task). 2348 2349 handle.Reset(); 2350 EXPECT_EQ(OK, callback2.WaitForResult()); 2351 // Use the socket. 2352 EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback())); 2353 handle2.Reset(); 2354 2355 // We post all of our delayed tasks with a 2ms delay. I.e. they don't 2356 // actually become pending until 2ms after they have been created. In order 2357 // to flush all tasks, we need to wait so that we know there are no 2358 // soon-to-be-pending tasks waiting. 2359 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10)); 2360 base::MessageLoop::current()->RunUntilIdle(); 2361 2362 ASSERT_EQ(2, pool_->IdleSocketCount()); 2363 2364 // Invoke the idle socket cleanup check. Only one socket should be left, the 2365 // used socket. Request it to make sure that it's used. 2366 2367 pool_->CleanupTimedOutIdleSockets(); 2368 CapturingBoundNetLog log; 2369 rv = handle.Init("a", 2370 params_, 2371 LOWEST, 2372 callback.callback(), 2373 pool_.get(), 2374 log.bound()); 2375 EXPECT_EQ(OK, rv); 2376 EXPECT_TRUE(handle.is_reused()); 2377 2378 CapturingNetLog::CapturedEntryList entries; 2379 log.GetEntries(&entries); 2380 EXPECT_TRUE(LogContainsEntryWithType( 2381 entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET)); 2382 } 2383 2384 // Make sure that we process all pending requests even when we're stalling 2385 // because of multiple releasing disconnected sockets. 2386 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) { 2387 CreatePoolWithIdleTimeouts( 2388 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, 2389 base::TimeDelta(), // Time out unused sockets immediately. 2390 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 2391 2392 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 2393 2394 // Startup 4 connect jobs. Two of them will be pending. 2395 2396 ClientSocketHandle handle; 2397 TestCompletionCallback callback; 2398 int rv = handle.Init("a", 2399 params_, 2400 LOWEST, 2401 callback.callback(), 2402 pool_.get(), 2403 BoundNetLog()); 2404 EXPECT_EQ(OK, rv); 2405 2406 ClientSocketHandle handle2; 2407 TestCompletionCallback callback2; 2408 rv = handle2.Init("a", 2409 params_, 2410 LOWEST, 2411 callback2.callback(), 2412 pool_.get(), 2413 BoundNetLog()); 2414 EXPECT_EQ(OK, rv); 2415 2416 ClientSocketHandle handle3; 2417 TestCompletionCallback callback3; 2418 rv = handle3.Init("a", 2419 params_, 2420 LOWEST, 2421 callback3.callback(), 2422 pool_.get(), 2423 BoundNetLog()); 2424 EXPECT_EQ(ERR_IO_PENDING, rv); 2425 2426 ClientSocketHandle handle4; 2427 TestCompletionCallback callback4; 2428 rv = handle4.Init("a", 2429 params_, 2430 LOWEST, 2431 callback4.callback(), 2432 pool_.get(), 2433 BoundNetLog()); 2434 EXPECT_EQ(ERR_IO_PENDING, rv); 2435 2436 // Release two disconnected sockets. 2437 2438 handle.socket()->Disconnect(); 2439 handle.Reset(); 2440 handle2.socket()->Disconnect(); 2441 handle2.Reset(); 2442 2443 EXPECT_EQ(OK, callback3.WaitForResult()); 2444 EXPECT_FALSE(handle3.is_reused()); 2445 EXPECT_EQ(OK, callback4.WaitForResult()); 2446 EXPECT_FALSE(handle4.is_reused()); 2447 } 2448 2449 // Regression test for http://crbug.com/42267. 2450 // When DoReleaseSocket() is processed for one socket, it is blocked because the 2451 // other stalled groups all have releasing sockets, so no progress can be made. 2452 TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) { 2453 CreatePoolWithIdleTimeouts( 2454 4 /* socket limit */, 4 /* socket limit per group */, 2455 base::TimeDelta(), // Time out unused sockets immediately. 2456 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 2457 2458 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 2459 2460 // Max out the socket limit with 2 per group. 2461 2462 ClientSocketHandle handle_a[4]; 2463 TestCompletionCallback callback_a[4]; 2464 ClientSocketHandle handle_b[4]; 2465 TestCompletionCallback callback_b[4]; 2466 2467 for (int i = 0; i < 2; ++i) { 2468 EXPECT_EQ(OK, handle_a[i].Init("a", 2469 params_, 2470 LOWEST, 2471 callback_a[i].callback(), 2472 pool_.get(), 2473 BoundNetLog())); 2474 EXPECT_EQ(OK, handle_b[i].Init("b", 2475 params_, 2476 LOWEST, 2477 callback_b[i].callback(), 2478 pool_.get(), 2479 BoundNetLog())); 2480 } 2481 2482 // Make 4 pending requests, 2 per group. 2483 2484 for (int i = 2; i < 4; ++i) { 2485 EXPECT_EQ(ERR_IO_PENDING, 2486 handle_a[i].Init("a", 2487 params_, 2488 LOWEST, 2489 callback_a[i].callback(), 2490 pool_.get(), 2491 BoundNetLog())); 2492 EXPECT_EQ(ERR_IO_PENDING, 2493 handle_b[i].Init("b", 2494 params_, 2495 LOWEST, 2496 callback_b[i].callback(), 2497 pool_.get(), 2498 BoundNetLog())); 2499 } 2500 2501 // Release b's socket first. The order is important, because in 2502 // DoReleaseSocket(), we'll process b's released socket, and since both b and 2503 // a are stalled, but 'a' is lower lexicographically, we'll process group 'a' 2504 // first, which has a releasing socket, so it refuses to start up another 2505 // ConnectJob. So, we used to infinite loop on this. 2506 handle_b[0].socket()->Disconnect(); 2507 handle_b[0].Reset(); 2508 handle_a[0].socket()->Disconnect(); 2509 handle_a[0].Reset(); 2510 2511 // Used to get stuck here. 2512 base::MessageLoop::current()->RunUntilIdle(); 2513 2514 handle_b[1].socket()->Disconnect(); 2515 handle_b[1].Reset(); 2516 handle_a[1].socket()->Disconnect(); 2517 handle_a[1].Reset(); 2518 2519 for (int i = 2; i < 4; ++i) { 2520 EXPECT_EQ(OK, callback_b[i].WaitForResult()); 2521 EXPECT_EQ(OK, callback_a[i].WaitForResult()); 2522 } 2523 } 2524 2525 TEST_F(ClientSocketPoolBaseTest, 2526 ReleasingDisconnectedSocketsMaintainsPriorityOrder) { 2527 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 2528 2529 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 2530 2531 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 2532 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 2533 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 2534 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 2535 2536 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); 2537 EXPECT_EQ(OK, (*requests())[1]->WaitForResult()); 2538 EXPECT_EQ(2u, completion_count()); 2539 2540 // Releases one connection. 2541 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE)); 2542 EXPECT_EQ(OK, (*requests())[2]->WaitForResult()); 2543 2544 EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE)); 2545 EXPECT_EQ(OK, (*requests())[3]->WaitForResult()); 2546 EXPECT_EQ(4u, completion_count()); 2547 2548 EXPECT_EQ(1, GetOrderOfRequest(1)); 2549 EXPECT_EQ(2, GetOrderOfRequest(2)); 2550 EXPECT_EQ(3, GetOrderOfRequest(3)); 2551 EXPECT_EQ(4, GetOrderOfRequest(4)); 2552 2553 // Make sure we test order of all requests made. 2554 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5)); 2555 } 2556 2557 class TestReleasingSocketRequest : public TestCompletionCallbackBase { 2558 public: 2559 TestReleasingSocketRequest(TestClientSocketPool* pool, 2560 int expected_result, 2561 bool reset_releasing_handle) 2562 : pool_(pool), 2563 expected_result_(expected_result), 2564 reset_releasing_handle_(reset_releasing_handle), 2565 callback_(base::Bind(&TestReleasingSocketRequest::OnComplete, 2566 base::Unretained(this))) { 2567 } 2568 2569 virtual ~TestReleasingSocketRequest() {} 2570 2571 ClientSocketHandle* handle() { return &handle_; } 2572 2573 const CompletionCallback& callback() const { return callback_; } 2574 2575 private: 2576 void OnComplete(int result) { 2577 SetResult(result); 2578 if (reset_releasing_handle_) 2579 handle_.Reset(); 2580 2581 scoped_refptr<TestSocketParams> con_params(new TestSocketParams()); 2582 EXPECT_EQ(expected_result_, 2583 handle2_.Init("a", con_params, kDefaultPriority, 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", kDefaultPriority)); 2601 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 2602 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 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_, kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 virtual ~ConnectWithinCallback() {} 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 3126 callback1.callback(), 3127 pool_.get(), 3128 BoundNetLog())); 3129 EXPECT_EQ(OK, handle2.Init("a", 3130 params_, 3131 kDefaultPriority, 3132 callback2.callback(), 3133 pool_.get(), 3134 BoundNetLog())); 3135 EXPECT_EQ(OK, handle3.Init("a", 3136 params_, 3137 kDefaultPriority, 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", ¶ms_, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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", ¶ms_, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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 kDefaultPriority, 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", ¶ms_, 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 kDefaultPriority, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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 kDefaultPriority, 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 kDefaultPriority, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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 kDefaultPriority, 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 preconneced 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", ¶ms_, 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 kDefaultPriority, 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 kDefaultPriority, 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 kDefaultPriority, 3607 callback1.callback(), 3608 pool_.get(), 3609 BoundNetLog())); 3610 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b", 3611 params_, 3612 kDefaultPriority, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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", ¶ms_, 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 kDefaultPriority, 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 class MockLayeredPool : public LayeredPool { 3720 public: 3721 MockLayeredPool(TestClientSocketPool* pool, 3722 const std::string& group_name) 3723 : pool_(pool), 3724 params_(new TestSocketParams), 3725 group_name_(group_name), 3726 can_release_connection_(true) { 3727 pool_->AddLayeredPool(this); 3728 } 3729 3730 ~MockLayeredPool() { 3731 pool_->RemoveLayeredPool(this); 3732 } 3733 3734 int RequestSocket(TestClientSocketPool* pool) { 3735 return handle_.Init(group_name_, params_, kDefaultPriority, 3736 callback_.callback(), pool, BoundNetLog()); 3737 } 3738 3739 int RequestSocketWithoutLimits(TestClientSocketPool* pool) { 3740 params_->set_ignore_limits(true); 3741 return handle_.Init(group_name_, params_, kDefaultPriority, 3742 callback_.callback(), pool, BoundNetLog()); 3743 } 3744 3745 bool ReleaseOneConnection() { 3746 if (!handle_.is_initialized() || !can_release_connection_) { 3747 return false; 3748 } 3749 handle_.socket()->Disconnect(); 3750 handle_.Reset(); 3751 return true; 3752 } 3753 3754 void set_can_release_connection(bool can_release_connection) { 3755 can_release_connection_ = can_release_connection; 3756 } 3757 3758 MOCK_METHOD0(CloseOneIdleConnection, bool()); 3759 3760 private: 3761 TestClientSocketPool* const pool_; 3762 scoped_refptr<TestSocketParams> params_; 3763 ClientSocketHandle handle_; 3764 TestCompletionCallback callback_; 3765 const std::string group_name_; 3766 bool can_release_connection_; 3767 }; 3768 3769 TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) { 3770 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3771 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3772 3773 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); 3774 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); 3775 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3776 .WillOnce(Return(false)); 3777 EXPECT_FALSE(pool_->CloseOneIdleConnectionInLayeredPool()); 3778 } 3779 3780 TEST_F(ClientSocketPoolBaseTest, ForciblyCloseIdleSocketsHeldByLayeredPool) { 3781 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 3782 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3783 3784 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); 3785 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); 3786 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3787 .WillOnce(Invoke(&mock_layered_pool, 3788 &MockLayeredPool::ReleaseOneConnection)); 3789 EXPECT_TRUE(pool_->CloseOneIdleConnectionInLayeredPool()); 3790 } 3791 3792 // Tests the basic case of closing an idle socket in a higher layered pool when 3793 // a new request is issued and the lower layer pool is stalled. 3794 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) { 3795 CreatePool(1, 1); 3796 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3797 3798 MockLayeredPool mock_layered_pool(pool_.get(), "foo"); 3799 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); 3800 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3801 .WillOnce(Invoke(&mock_layered_pool, 3802 &MockLayeredPool::ReleaseOneConnection)); 3803 ClientSocketHandle handle; 3804 TestCompletionCallback callback; 3805 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", 3806 params_, 3807 kDefaultPriority, 3808 callback.callback(), 3809 pool_.get(), 3810 BoundNetLog())); 3811 EXPECT_EQ(OK, callback.WaitForResult()); 3812 } 3813 3814 // Same as above, but the idle socket is in the same group as the stalled 3815 // socket, and closes the only other request in its group when closing requests 3816 // in higher layered pools. This generally shouldn't happen, but it may be 3817 // possible if a higher level pool issues a request and the request is 3818 // subsequently cancelled. Even if it's not possible, best not to crash. 3819 TEST_F(ClientSocketPoolBaseTest, 3820 CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) { 3821 CreatePool(2, 2); 3822 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3823 3824 // Need a socket in another group for the pool to be stalled (If a group 3825 // has the maximum number of connections already, it's not stalled). 3826 ClientSocketHandle handle1; 3827 TestCompletionCallback callback1; 3828 EXPECT_EQ(OK, handle1.Init("group1", 3829 params_, 3830 kDefaultPriority, 3831 callback1.callback(), 3832 pool_.get(), 3833 BoundNetLog())); 3834 3835 MockLayeredPool mock_layered_pool(pool_.get(), "group2"); 3836 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); 3837 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3838 .WillOnce(Invoke(&mock_layered_pool, 3839 &MockLayeredPool::ReleaseOneConnection)); 3840 ClientSocketHandle handle; 3841 TestCompletionCallback callback2; 3842 EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2", 3843 params_, 3844 kDefaultPriority, 3845 callback2.callback(), 3846 pool_.get(), 3847 BoundNetLog())); 3848 EXPECT_EQ(OK, callback2.WaitForResult()); 3849 } 3850 3851 // Tests the case when an idle socket can be closed when a new request is 3852 // issued, and the new request belongs to a group that was previously stalled. 3853 TEST_F(ClientSocketPoolBaseTest, 3854 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) { 3855 CreatePool(2, 2); 3856 std::list<TestConnectJob::JobType> job_types; 3857 job_types.push_back(TestConnectJob::kMockJob); 3858 job_types.push_back(TestConnectJob::kMockJob); 3859 job_types.push_back(TestConnectJob::kMockJob); 3860 job_types.push_back(TestConnectJob::kMockJob); 3861 connect_job_factory_->set_job_types(&job_types); 3862 3863 ClientSocketHandle handle1; 3864 TestCompletionCallback callback1; 3865 EXPECT_EQ(OK, handle1.Init("group1", 3866 params_, 3867 kDefaultPriority, 3868 callback1.callback(), 3869 pool_.get(), 3870 BoundNetLog())); 3871 3872 MockLayeredPool mock_layered_pool(pool_.get(), "group2"); 3873 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); 3874 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3875 .WillRepeatedly(Invoke(&mock_layered_pool, 3876 &MockLayeredPool::ReleaseOneConnection)); 3877 mock_layered_pool.set_can_release_connection(false); 3878 3879 // The third request is made when the socket pool is in a stalled state. 3880 ClientSocketHandle handle3; 3881 TestCompletionCallback callback3; 3882 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3", 3883 params_, 3884 kDefaultPriority, 3885 callback3.callback(), 3886 pool_.get(), 3887 BoundNetLog())); 3888 3889 base::RunLoop().RunUntilIdle(); 3890 EXPECT_FALSE(callback3.have_result()); 3891 3892 // The fourth request is made when the pool is no longer stalled. The third 3893 // request should be serviced first, since it was issued first and has the 3894 // same priority. 3895 mock_layered_pool.set_can_release_connection(true); 3896 ClientSocketHandle handle4; 3897 TestCompletionCallback callback4; 3898 EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3", 3899 params_, 3900 kDefaultPriority, 3901 callback4.callback(), 3902 pool_.get(), 3903 BoundNetLog())); 3904 EXPECT_EQ(OK, callback3.WaitForResult()); 3905 EXPECT_FALSE(callback4.have_result()); 3906 3907 // Closing a handle should free up another socket slot. 3908 handle1.Reset(); 3909 EXPECT_EQ(OK, callback4.WaitForResult()); 3910 } 3911 3912 // Tests the case when an idle socket can be closed when a new request is 3913 // issued, and the new request belongs to a group that was previously stalled. 3914 // 3915 // The two differences from the above test are that the stalled requests are not 3916 // in the same group as the layered pool's request, and the the fourth request 3917 // has a higher priority than the third one, so gets a socket first. 3918 TEST_F(ClientSocketPoolBaseTest, 3919 CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) { 3920 CreatePool(2, 2); 3921 std::list<TestConnectJob::JobType> job_types; 3922 job_types.push_back(TestConnectJob::kMockJob); 3923 job_types.push_back(TestConnectJob::kMockJob); 3924 job_types.push_back(TestConnectJob::kMockJob); 3925 job_types.push_back(TestConnectJob::kMockJob); 3926 connect_job_factory_->set_job_types(&job_types); 3927 3928 ClientSocketHandle handle1; 3929 TestCompletionCallback callback1; 3930 EXPECT_EQ(OK, handle1.Init("group1", 3931 params_, 3932 kDefaultPriority, 3933 callback1.callback(), 3934 pool_.get(), 3935 BoundNetLog())); 3936 3937 MockLayeredPool mock_layered_pool(pool_.get(), "group2"); 3938 EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get())); 3939 EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()) 3940 .WillRepeatedly(Invoke(&mock_layered_pool, 3941 &MockLayeredPool::ReleaseOneConnection)); 3942 mock_layered_pool.set_can_release_connection(false); 3943 3944 // The third request is made when the socket pool is in a stalled state. 3945 ClientSocketHandle handle3; 3946 TestCompletionCallback callback3; 3947 EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3", 3948 params_, 3949 MEDIUM, 3950 callback3.callback(), 3951 pool_.get(), 3952 BoundNetLog())); 3953 3954 base::RunLoop().RunUntilIdle(); 3955 EXPECT_FALSE(callback3.have_result()); 3956 3957 // The fourth request is made when the pool is no longer stalled. This 3958 // request has a higher priority than the third request, so is serviced first. 3959 mock_layered_pool.set_can_release_connection(true); 3960 ClientSocketHandle handle4; 3961 TestCompletionCallback callback4; 3962 EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3", 3963 params_, 3964 HIGHEST, 3965 callback4.callback(), 3966 pool_.get(), 3967 BoundNetLog())); 3968 EXPECT_EQ(OK, callback4.WaitForResult()); 3969 EXPECT_FALSE(callback3.have_result()); 3970 3971 // Closing a handle should free up another socket slot. 3972 handle1.Reset(); 3973 EXPECT_EQ(OK, callback3.WaitForResult()); 3974 } 3975 3976 TEST_F(ClientSocketPoolBaseTest, 3977 CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) { 3978 CreatePool(1, 1); 3979 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 3980 3981 MockLayeredPool mock_layered_pool1(pool_.get(), "foo"); 3982 EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get())); 3983 EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection()) 3984 .WillRepeatedly(Invoke(&mock_layered_pool1, 3985 &MockLayeredPool::ReleaseOneConnection)); 3986 MockLayeredPool mock_layered_pool2(pool_.get(), "bar"); 3987 EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get())); 3988 EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection()) 3989 .WillRepeatedly(Invoke(&mock_layered_pool2, 3990 &MockLayeredPool::ReleaseOneConnection)); 3991 ClientSocketHandle handle; 3992 TestCompletionCallback callback; 3993 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", 3994 params_, 3995 kDefaultPriority, 3996 callback.callback(), 3997 pool_.get(), 3998 BoundNetLog())); 3999 EXPECT_EQ(OK, callback.WaitForResult()); 4000 } 4001 4002 // Test that when a socket pool and group are at their limits, a request 4003 // with |ignore_limits| triggers creation of a new socket, and gets the socket 4004 // instead of a request with the same priority that was issued earlier, but 4005 // that does not have |ignore_limits| set. 4006 TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) { 4007 scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams()); 4008 params_ignore_limits->set_ignore_limits(true); 4009 CreatePool(1, 1); 4010 4011 // Issue a request to reach the socket pool limit. 4012 EXPECT_EQ(OK, StartRequestWithParams("a", kDefaultPriority, params_)); 4013 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 4014 4015 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 4016 4017 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", kDefaultPriority, 4018 params_)); 4019 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 4020 4021 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", kDefaultPriority, 4022 params_ignore_limits)); 4023 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); 4024 4025 EXPECT_EQ(OK, request(2)->WaitForResult()); 4026 EXPECT_FALSE(request(1)->have_result()); 4027 } 4028 4029 // Test that when a socket pool and group are at their limits, a request with 4030 // |ignore_limits| set triggers creation of a new socket, and gets the socket 4031 // instead of a request with a higher priority that was issued earlier, but 4032 // that does not have |ignore_limits| set. 4033 TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsLowPriority) { 4034 scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams()); 4035 params_ignore_limits->set_ignore_limits(true); 4036 CreatePool(1, 1); 4037 4038 // Issue a request to reach the socket pool limit. 4039 EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_)); 4040 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 4041 4042 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 4043 4044 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_)); 4045 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 4046 4047 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", LOW, 4048 params_ignore_limits)); 4049 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); 4050 4051 EXPECT_EQ(OK, request(2)->WaitForResult()); 4052 EXPECT_FALSE(request(1)->have_result()); 4053 } 4054 4055 // Test that when a socket pool and group are at their limits, a request with 4056 // |ignore_limits| set triggers creation of a new socket, and gets the socket 4057 // instead of a request with a higher priority that was issued later and 4058 // does not have |ignore_limits| set. 4059 TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsLowPriority2) { 4060 scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams()); 4061 params_ignore_limits->set_ignore_limits(true); 4062 CreatePool(1, 1); 4063 4064 // Issue a request to reach the socket pool limit. 4065 EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_)); 4066 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 4067 4068 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 4069 4070 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", LOW, 4071 params_ignore_limits)); 4072 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); 4073 4074 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_)); 4075 EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a")); 4076 4077 EXPECT_EQ(OK, request(1)->WaitForResult()); 4078 EXPECT_FALSE(request(2)->have_result()); 4079 } 4080 4081 // Test that when a socket pool and group are at their limits, a ConnectJob 4082 // issued for a request with |ignore_limits| set is not cancelled when a request 4083 // without |ignore_limits| issued to the same group is cancelled. 4084 TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) { 4085 scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams()); 4086 params_ignore_limits->set_ignore_limits(true); 4087 CreatePool(1, 1); 4088 4089 // Issue a request to reach the socket pool limit. 4090 EXPECT_EQ(OK, StartRequestWithParams("a", HIGHEST, params_)); 4091 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 4092 4093 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 4094 4095 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_)); 4096 EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a")); 4097 4098 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, 4099 params_ignore_limits)); 4100 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); 4101 4102 // Cancel the pending request without ignore_limits set. The ConnectJob 4103 // should not be cancelled. 4104 request(1)->handle()->Reset(); 4105 ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a")); 4106 4107 EXPECT_EQ(OK, request(2)->WaitForResult()); 4108 EXPECT_FALSE(request(1)->have_result()); 4109 } 4110 4111 // More involved test of ignore limits. Issues a bunch of requests and later 4112 // checks the order in which they receive sockets. 4113 TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsOrder) { 4114 scoped_refptr<TestSocketParams> params_ignore_limits(new TestSocketParams()); 4115 params_ignore_limits->set_ignore_limits(true); 4116 CreatePool(1, 1); 4117 4118 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 4119 4120 // Requests 0 and 1 do not have ignore_limits set, so they finish last. Since 4121 // the maximum number of sockets per pool is 1, the second requests does not 4122 // trigger a ConnectJob. 4123 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_)); 4124 EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", HIGHEST, params_)); 4125 4126 // Requests 2 and 3 have ignore_limits set, but have a low priority, so they 4127 // finish just before the first two. 4128 EXPECT_EQ(ERR_IO_PENDING, 4129 StartRequestWithParams("a", LOW, params_ignore_limits)); 4130 EXPECT_EQ(ERR_IO_PENDING, 4131 StartRequestWithParams("a", LOW, params_ignore_limits)); 4132 4133 // Request 4 finishes first, since it is high priority and ignores limits. 4134 EXPECT_EQ(ERR_IO_PENDING, 4135 StartRequestWithParams("a", HIGHEST, params_ignore_limits)); 4136 4137 // Request 5 and 6 are cancelled right after starting. This should result in 4138 // creating two ConnectJobs. Since only one request (Request 1) did not 4139 // result in creating a ConnectJob, only one of the ConnectJobs should be 4140 // cancelled when the requests are. 4141 EXPECT_EQ(ERR_IO_PENDING, 4142 StartRequestWithParams("a", HIGHEST, params_ignore_limits)); 4143 EXPECT_EQ(ERR_IO_PENDING, 4144 StartRequestWithParams("a", HIGHEST, params_ignore_limits)); 4145 EXPECT_EQ(6, pool_->NumConnectJobsInGroup("a")); 4146 request(5)->handle()->Reset(); 4147 EXPECT_EQ(6, pool_->NumConnectJobsInGroup("a")); 4148 request(6)->handle()->Reset(); 4149 ASSERT_EQ(5, pool_->NumConnectJobsInGroup("a")); 4150 4151 // Wait for the last request to get a socket. 4152 EXPECT_EQ(OK, request(1)->WaitForResult()); 4153 4154 // Check order in which requests received sockets. 4155 // These are 1-based indices, while request(x) uses 0-based indices. 4156 EXPECT_EQ(1, GetOrderOfRequest(5)); 4157 EXPECT_EQ(2, GetOrderOfRequest(3)); 4158 EXPECT_EQ(3, GetOrderOfRequest(4)); 4159 EXPECT_EQ(4, GetOrderOfRequest(1)); 4160 EXPECT_EQ(5, GetOrderOfRequest(2)); 4161 } 4162 4163 } // namespace 4164 4165 } // namespace net 4166