1 // Copyright (c) 2009 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 "base/compiler_specific.h" 8 #include "base/message_loop.h" 9 #include "base/platform_thread.h" 10 #include "base/scoped_vector.h" 11 #include "net/base/load_log.h" 12 #include "net/base/load_log_unittest.h" 13 #include "net/base/net_errors.h" 14 #include "net/base/request_priority.h" 15 #include "net/base/test_completion_callback.h" 16 #include "net/socket/client_socket.h" 17 #include "net/socket/client_socket_factory.h" 18 #include "net/socket/client_socket_handle.h" 19 #include "net/socket/socket_test_util.h" 20 #include "testing/gtest/include/gtest/gtest.h" 21 22 namespace net { 23 24 namespace { 25 26 const int kDefaultMaxSockets = 4; 27 const int kDefaultMaxSocketsPerGroup = 2; 28 const net::RequestPriority kDefaultPriority = MEDIUM; 29 30 typedef ClientSocketPoolBase<const void*> TestClientSocketPoolBase; 31 32 class MockClientSocket : public ClientSocket { 33 public: 34 MockClientSocket() : connected_(false) {} 35 36 // Socket methods: 37 virtual int Read( 38 IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) { 39 return ERR_UNEXPECTED; 40 } 41 42 virtual int Write( 43 IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) { 44 return ERR_UNEXPECTED; 45 } 46 virtual bool SetReceiveBufferSize(int32 size) { return true; }; 47 virtual bool SetSendBufferSize(int32 size) { return true; }; 48 49 // ClientSocket methods: 50 51 virtual int Connect(CompletionCallback* callback, LoadLog* load_log) { 52 connected_ = true; 53 return OK; 54 } 55 56 virtual void Disconnect() { connected_ = false; } 57 virtual bool IsConnected() const { return connected_; } 58 virtual bool IsConnectedAndIdle() const { return connected_; } 59 60 virtual int GetPeerName(struct sockaddr* /* name */, 61 socklen_t* /* namelen */) { 62 return ERR_UNEXPECTED; 63 } 64 65 private: 66 bool connected_; 67 68 DISALLOW_COPY_AND_ASSIGN(MockClientSocket); 69 }; 70 71 class TestConnectJob; 72 73 class MockClientSocketFactory : public ClientSocketFactory { 74 public: 75 MockClientSocketFactory() : allocation_count_(0) {} 76 77 virtual ClientSocket* CreateTCPClientSocket(const AddressList& addresses) { 78 allocation_count_++; 79 return NULL; 80 } 81 82 virtual SSLClientSocket* CreateSSLClientSocket( 83 ClientSocket* transport_socket, 84 const std::string& hostname, 85 const SSLConfig& ssl_config) { 86 NOTIMPLEMENTED(); 87 return NULL; 88 } 89 90 void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); } 91 void SignalJobs(); 92 93 int allocation_count() const { return allocation_count_; } 94 95 private: 96 int allocation_count_; 97 std::vector<TestConnectJob*> waiting_jobs_; 98 }; 99 100 class TestConnectJob : public ConnectJob { 101 public: 102 enum JobType { 103 kMockJob, 104 kMockFailingJob, 105 kMockPendingJob, 106 kMockPendingFailingJob, 107 kMockWaitingJob, 108 kMockAdvancingLoadStateJob, 109 }; 110 111 TestConnectJob(JobType job_type, 112 const std::string& group_name, 113 const TestClientSocketPoolBase::Request& request, 114 base::TimeDelta timeout_duration, 115 ConnectJob::Delegate* delegate, 116 MockClientSocketFactory* client_socket_factory, 117 LoadLog* load_log) 118 : ConnectJob(group_name, timeout_duration, delegate, load_log), 119 job_type_(job_type), 120 client_socket_factory_(client_socket_factory), 121 method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)), 122 load_state_(LOAD_STATE_IDLE) {} 123 124 void Signal() { 125 DoConnect(waiting_success_, true /* async */); 126 } 127 128 virtual LoadState GetLoadState() const { return load_state_; } 129 130 private: 131 // ConnectJob methods: 132 133 virtual int ConnectInternal() { 134 AddressList ignored; 135 client_socket_factory_->CreateTCPClientSocket(ignored); 136 set_socket(new MockClientSocket()); 137 switch (job_type_) { 138 case kMockJob: 139 return DoConnect(true /* successful */, false /* sync */); 140 case kMockFailingJob: 141 return DoConnect(false /* error */, false /* sync */); 142 case kMockPendingJob: 143 set_load_state(LOAD_STATE_CONNECTING); 144 145 // Depending on execution timings, posting a delayed task can result 146 // in the task getting executed the at the earliest possible 147 // opportunity or only after returning once from the message loop and 148 // then a second call into the message loop. In order to make behavior 149 // more deterministic, we change the default delay to 2ms. This should 150 // always require us to wait for the second call into the message loop. 151 // 152 // N.B. The correct fix for this and similar timing problems is to 153 // abstract time for the purpose of unittests. Unfortunately, we have 154 // a lot of third-party components that directly call the various 155 // time functions, so this change would be rather invasive. 156 MessageLoop::current()->PostDelayedTask( 157 FROM_HERE, 158 method_factory_.NewRunnableMethod( 159 &TestConnectJob::DoConnect, 160 true /* successful */, 161 true /* async */), 162 2); 163 return ERR_IO_PENDING; 164 case kMockPendingFailingJob: 165 set_load_state(LOAD_STATE_CONNECTING); 166 MessageLoop::current()->PostDelayedTask( 167 FROM_HERE, 168 method_factory_.NewRunnableMethod( 169 &TestConnectJob::DoConnect, 170 false /* error */, 171 true /* async */), 172 2); 173 return ERR_IO_PENDING; 174 case kMockWaitingJob: 175 client_socket_factory_->WaitForSignal(this); 176 waiting_success_ = true; 177 return ERR_IO_PENDING; 178 case kMockAdvancingLoadStateJob: 179 MessageLoop::current()->PostDelayedTask( 180 FROM_HERE, 181 method_factory_.NewRunnableMethod( 182 &TestConnectJob::AdvanceLoadState, load_state_), 183 2); 184 return ERR_IO_PENDING; 185 default: 186 NOTREACHED(); 187 set_socket(NULL); 188 return ERR_FAILED; 189 } 190 } 191 192 void set_load_state(LoadState load_state) { load_state_ = load_state; } 193 194 int DoConnect(bool succeed, bool was_async) { 195 int result = ERR_CONNECTION_FAILED; 196 if (succeed) { 197 result = OK; 198 socket()->Connect(NULL, NULL); 199 } else { 200 set_socket(NULL); 201 } 202 203 if (was_async) 204 NotifyDelegateOfCompletion(result); 205 return result; 206 } 207 208 void AdvanceLoadState(LoadState state) { 209 int tmp = state; 210 tmp++; 211 state = static_cast<LoadState>(tmp); 212 set_load_state(state); 213 // Post a delayed task so RunAllPending() won't run it. 214 MessageLoop::current()->PostDelayedTask( 215 FROM_HERE, 216 method_factory_.NewRunnableMethod(&TestConnectJob::AdvanceLoadState, 217 state), 218 1 /* 1ms delay */); 219 } 220 221 bool waiting_success_; 222 const JobType job_type_; 223 MockClientSocketFactory* const client_socket_factory_; 224 ScopedRunnableMethodFactory<TestConnectJob> method_factory_; 225 LoadState load_state_; 226 227 DISALLOW_COPY_AND_ASSIGN(TestConnectJob); 228 }; 229 230 class TestConnectJobFactory 231 : public TestClientSocketPoolBase::ConnectJobFactory { 232 public: 233 explicit TestConnectJobFactory(MockClientSocketFactory* client_socket_factory) 234 : job_type_(TestConnectJob::kMockJob), 235 client_socket_factory_(client_socket_factory) {} 236 237 virtual ~TestConnectJobFactory() {} 238 239 void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; } 240 241 void set_timeout_duration(base::TimeDelta timeout_duration) { 242 timeout_duration_ = timeout_duration; 243 } 244 245 // ConnectJobFactory methods: 246 247 virtual ConnectJob* NewConnectJob( 248 const std::string& group_name, 249 const TestClientSocketPoolBase::Request& request, 250 ConnectJob::Delegate* delegate, 251 LoadLog* load_log) const { 252 return new TestConnectJob(job_type_, 253 group_name, 254 request, 255 timeout_duration_, 256 delegate, 257 client_socket_factory_, 258 load_log); 259 } 260 261 private: 262 TestConnectJob::JobType job_type_; 263 base::TimeDelta timeout_duration_; 264 MockClientSocketFactory* const client_socket_factory_; 265 266 DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory); 267 }; 268 269 class TestClientSocketPool : public ClientSocketPool { 270 public: 271 TestClientSocketPool( 272 int max_sockets, 273 int max_sockets_per_group, 274 base::TimeDelta unused_idle_socket_timeout, 275 base::TimeDelta used_idle_socket_timeout, 276 TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory) 277 : base_(max_sockets, max_sockets_per_group, 278 unused_idle_socket_timeout, used_idle_socket_timeout, 279 connect_job_factory, NULL) {} 280 281 virtual int RequestSocket( 282 const std::string& group_name, 283 const void* params, 284 net::RequestPriority priority, 285 ClientSocketHandle* handle, 286 CompletionCallback* callback, 287 LoadLog* load_log) { 288 return base_.RequestSocket( 289 group_name, params, priority, handle, callback, load_log); 290 } 291 292 virtual void CancelRequest( 293 const std::string& group_name, 294 const ClientSocketHandle* handle) { 295 base_.CancelRequest(group_name, handle); 296 } 297 298 virtual void ReleaseSocket( 299 const std::string& group_name, 300 ClientSocket* socket) { 301 base_.ReleaseSocket(group_name, socket); 302 } 303 304 virtual void CloseIdleSockets() { 305 base_.CloseIdleSockets(); 306 } 307 308 virtual int IdleSocketCount() const { return base_.idle_socket_count(); } 309 310 virtual int IdleSocketCountInGroup(const std::string& group_name) const { 311 return base_.IdleSocketCountInGroup(group_name); 312 } 313 314 virtual LoadState GetLoadState(const std::string& group_name, 315 const ClientSocketHandle* handle) const { 316 return base_.GetLoadState(group_name, handle); 317 } 318 319 const TestClientSocketPoolBase* base() const { return &base_; } 320 321 int NumConnectJobsInGroup(const std::string& group_name) const { 322 return base_.NumConnectJobsInGroup(group_name); 323 } 324 325 void CleanupTimedOutIdleSockets() { base_.CleanupIdleSockets(false); } 326 327 private: 328 ~TestClientSocketPool() {} 329 330 TestClientSocketPoolBase base_; 331 332 DISALLOW_COPY_AND_ASSIGN(TestClientSocketPool); 333 }; 334 335 } // namespace 336 337 REGISTER_SOCKET_PARAMS_FOR_POOL(TestClientSocketPool, const void*); 338 339 namespace { 340 341 void MockClientSocketFactory::SignalJobs() { 342 for (std::vector<TestConnectJob*>::iterator it = waiting_jobs_.begin(); 343 it != waiting_jobs_.end(); ++it) { 344 (*it)->Signal(); 345 } 346 waiting_jobs_.clear(); 347 } 348 349 class TestConnectJobDelegate : public ConnectJob::Delegate { 350 public: 351 TestConnectJobDelegate() 352 : have_result_(false), waiting_for_result_(false), result_(OK) {} 353 virtual ~TestConnectJobDelegate() {} 354 355 virtual void OnConnectJobComplete(int result, ConnectJob* job) { 356 result_ = result; 357 scoped_ptr<ClientSocket> socket(job->ReleaseSocket()); 358 // socket.get() should be NULL iff result != OK 359 EXPECT_EQ(socket.get() == NULL, result != OK); 360 delete job; 361 have_result_ = true; 362 if (waiting_for_result_) 363 MessageLoop::current()->Quit(); 364 } 365 366 int WaitForResult() { 367 DCHECK(!waiting_for_result_); 368 while (!have_result_) { 369 waiting_for_result_ = true; 370 MessageLoop::current()->Run(); 371 waiting_for_result_ = false; 372 } 373 have_result_ = false; // auto-reset for next callback 374 return result_; 375 } 376 377 private: 378 bool have_result_; 379 bool waiting_for_result_; 380 int result_; 381 }; 382 383 class ClientSocketPoolBaseTest : public ClientSocketPoolTest { 384 protected: 385 ClientSocketPoolBaseTest() {} 386 387 void CreatePool(int max_sockets, int max_sockets_per_group) { 388 CreatePoolWithIdleTimeouts( 389 max_sockets, 390 max_sockets_per_group, 391 base::TimeDelta::FromSeconds(kUnusedIdleSocketTimeout), 392 base::TimeDelta::FromSeconds(kUsedIdleSocketTimeout)); 393 } 394 395 void CreatePoolWithIdleTimeouts( 396 int max_sockets, int max_sockets_per_group, 397 base::TimeDelta unused_idle_socket_timeout, 398 base::TimeDelta used_idle_socket_timeout) { 399 DCHECK(!pool_.get()); 400 connect_job_factory_ = new TestConnectJobFactory(&client_socket_factory_); 401 pool_ = new TestClientSocketPool(max_sockets, 402 max_sockets_per_group, 403 unused_idle_socket_timeout, 404 used_idle_socket_timeout, 405 connect_job_factory_); 406 } 407 408 int StartRequest(const std::string& group_name, 409 net::RequestPriority priority) { 410 return StartRequestUsingPool<TestClientSocketPool, const void*>( 411 pool_.get(), group_name, priority, NULL); 412 } 413 414 virtual void TearDown() { 415 // We post all of our delayed tasks with a 2ms delay. I.e. they don't 416 // actually become pending until 2ms after they have been created. In order 417 // to flush all tasks, we need to wait so that we know there are no 418 // soon-to-be-pending tasks waiting. 419 PlatformThread::Sleep(10); 420 MessageLoop::current()->RunAllPending(); 421 422 // Need to delete |pool_| before we turn late binding back off. We also need 423 // to delete |requests_| because the pool is reference counted and requests 424 // keep reference to it. 425 // TODO(willchan): Remove this part when late binding becomes the default. 426 pool_ = NULL; 427 requests_.reset(); 428 429 ClientSocketPoolTest::TearDown(); 430 } 431 432 MockClientSocketFactory client_socket_factory_; 433 TestConnectJobFactory* connect_job_factory_; 434 scoped_refptr<TestClientSocketPool> pool_; 435 }; 436 437 // Helper function which explicitly specifies the template parameters, since 438 // the compiler will infer (in this case, incorrectly) that NULL is of type int. 439 int InitHandle(ClientSocketHandle* handle, 440 const std::string& group_name, 441 net::RequestPriority priority, 442 CompletionCallback* callback, 443 TestClientSocketPool* pool, 444 LoadLog* load_log) { 445 return handle->Init<const void*, TestClientSocketPool>( 446 group_name, NULL, priority, callback, pool, load_log); 447 } 448 449 // Even though a timeout is specified, it doesn't time out on a synchronous 450 // completion. 451 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) { 452 TestConnectJobDelegate delegate; 453 ClientSocketHandle ignored; 454 TestClientSocketPoolBase::Request request( 455 &ignored, NULL, kDefaultPriority, NULL, NULL); 456 scoped_ptr<TestConnectJob> job( 457 new TestConnectJob(TestConnectJob::kMockJob, 458 "a", 459 request, 460 base::TimeDelta::FromMicroseconds(1), 461 &delegate, 462 &client_socket_factory_, 463 NULL)); 464 EXPECT_EQ(OK, job->Connect()); 465 } 466 467 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) { 468 TestConnectJobDelegate delegate; 469 ClientSocketHandle ignored; 470 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); 471 TestClientSocketPoolBase::Request request( 472 &ignored, NULL, kDefaultPriority, NULL, NULL); 473 // Deleted by TestConnectJobDelegate. 474 TestConnectJob* job = 475 new TestConnectJob(TestConnectJob::kMockPendingJob, 476 "a", 477 request, 478 base::TimeDelta::FromMicroseconds(1), 479 &delegate, 480 &client_socket_factory_, 481 log); 482 ASSERT_EQ(ERR_IO_PENDING, job->Connect()); 483 PlatformThread::Sleep(1); 484 EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult()); 485 486 EXPECT_EQ(3u, log->entries().size()); 487 EXPECT_TRUE(LogContainsBeginEvent( 488 *log, 0, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 489 EXPECT_TRUE(LogContainsEvent( 490 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT, 491 LoadLog::PHASE_NONE)); 492 EXPECT_TRUE(LogContainsEndEvent( 493 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 494 } 495 496 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) { 497 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 498 499 TestCompletionCallback callback; 500 ClientSocketHandle handle; 501 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); 502 EXPECT_EQ(OK, InitHandle(&handle, "a", kDefaultPriority, 503 &callback, pool_.get(), log)); 504 EXPECT_TRUE(handle.is_initialized()); 505 EXPECT_TRUE(handle.socket()); 506 handle.Reset(); 507 508 EXPECT_EQ(4u, log->entries().size()); 509 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); 510 EXPECT_TRUE(LogContainsBeginEvent( 511 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 512 EXPECT_TRUE(LogContainsEndEvent( 513 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 514 EXPECT_TRUE(LogContainsEndEvent(*log, 3, LoadLog::TYPE_SOCKET_POOL)); 515 } 516 517 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { 518 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 519 520 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); 521 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); 522 TestSocketRequest req(&request_order_, &completion_count_); 523 EXPECT_EQ(ERR_CONNECTION_FAILED, 524 InitHandle(req.handle(), "a", kDefaultPriority, &req, 525 pool_.get(), log)); 526 527 EXPECT_EQ(4u, log->entries().size()); 528 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); 529 EXPECT_TRUE(LogContainsBeginEvent( 530 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 531 EXPECT_TRUE(LogContainsEndEvent( 532 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 533 EXPECT_TRUE(LogContainsEndEvent(*log, 3, LoadLog::TYPE_SOCKET_POOL)); 534 } 535 536 TEST_F(ClientSocketPoolBaseTest, TotalLimit) { 537 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 538 539 // TODO(eroman): Check that the LoadLog contains this event. 540 541 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 542 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 543 EXPECT_EQ(OK, StartRequest("c", kDefaultPriority)); 544 EXPECT_EQ(OK, StartRequest("d", kDefaultPriority)); 545 546 EXPECT_EQ(static_cast<int>(requests_.size()), 547 client_socket_factory_.allocation_count()); 548 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); 549 550 EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority)); 551 EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", kDefaultPriority)); 552 EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", kDefaultPriority)); 553 554 ReleaseAllConnections(KEEP_ALIVE); 555 556 EXPECT_EQ(static_cast<int>(requests_.size()), 557 client_socket_factory_.allocation_count()); 558 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); 559 560 EXPECT_EQ(1, GetOrderOfRequest(1)); 561 EXPECT_EQ(2, GetOrderOfRequest(2)); 562 EXPECT_EQ(3, GetOrderOfRequest(3)); 563 EXPECT_EQ(4, GetOrderOfRequest(4)); 564 EXPECT_EQ(5, GetOrderOfRequest(5)); 565 EXPECT_EQ(6, GetOrderOfRequest(6)); 566 EXPECT_EQ(7, GetOrderOfRequest(7)); 567 568 // Make sure we test order of all requests made. 569 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8)); 570 } 571 572 TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) { 573 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 574 575 // TODO(eroman): Check that the LoadLog contains this event. 576 577 // Reach all limits: max total sockets, and max sockets per group. 578 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 579 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 580 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 581 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 582 583 EXPECT_EQ(static_cast<int>(requests_.size()), 584 client_socket_factory_.allocation_count()); 585 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); 586 587 // Now create a new group and verify that we don't starve it. 588 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority)); 589 590 ReleaseAllConnections(KEEP_ALIVE); 591 592 EXPECT_EQ(static_cast<int>(requests_.size()), 593 client_socket_factory_.allocation_count()); 594 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); 595 596 EXPECT_EQ(1, GetOrderOfRequest(1)); 597 EXPECT_EQ(2, GetOrderOfRequest(2)); 598 EXPECT_EQ(3, GetOrderOfRequest(3)); 599 EXPECT_EQ(4, GetOrderOfRequest(4)); 600 EXPECT_EQ(5, GetOrderOfRequest(5)); 601 602 // Make sure we test order of all requests made. 603 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(6)); 604 } 605 606 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsPriority) { 607 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 608 609 EXPECT_EQ(OK, StartRequest("b", LOWEST)); 610 EXPECT_EQ(OK, StartRequest("a", MEDIUM)); 611 EXPECT_EQ(OK, StartRequest("b", HIGHEST)); 612 EXPECT_EQ(OK, StartRequest("a", LOWEST)); 613 614 EXPECT_EQ(static_cast<int>(requests_.size()), 615 client_socket_factory_.allocation_count()); 616 617 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", LOWEST)); 618 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 619 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST)); 620 621 ReleaseAllConnections(KEEP_ALIVE); 622 623 // We're re-using one socket for group "a", and one for "b". 624 EXPECT_EQ(static_cast<int>(requests_.size()) - 2, 625 client_socket_factory_.allocation_count()); 626 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); 627 628 // First 4 requests don't have to wait, and finish in order. 629 EXPECT_EQ(1, GetOrderOfRequest(1)); 630 EXPECT_EQ(2, GetOrderOfRequest(2)); 631 EXPECT_EQ(3, GetOrderOfRequest(3)); 632 EXPECT_EQ(4, GetOrderOfRequest(4)); 633 634 // Request ("b", HIGHEST) has the highest priority, then ("a", MEDIUM), 635 // and then ("c", LOWEST). 636 EXPECT_EQ(7, GetOrderOfRequest(5)); 637 EXPECT_EQ(6, GetOrderOfRequest(6)); 638 EXPECT_EQ(5, GetOrderOfRequest(7)); 639 640 // Make sure we test order of all requests made. 641 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8)); 642 } 643 644 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsGroupLimit) { 645 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 646 647 EXPECT_EQ(OK, StartRequest("a", LOWEST)); 648 EXPECT_EQ(OK, StartRequest("a", LOW)); 649 EXPECT_EQ(OK, StartRequest("b", HIGHEST)); 650 EXPECT_EQ(OK, StartRequest("b", MEDIUM)); 651 652 EXPECT_EQ(static_cast<int>(requests_.size()), 653 client_socket_factory_.allocation_count()); 654 655 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", MEDIUM)); 656 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 657 EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST)); 658 659 ReleaseAllConnections(KEEP_ALIVE); 660 661 // We're re-using one socket for group "a", and one for "b". 662 EXPECT_EQ(static_cast<int>(requests_.size()) - 2, 663 client_socket_factory_.allocation_count()); 664 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); 665 666 // First 4 requests don't have to wait, and finish in order. 667 EXPECT_EQ(1, GetOrderOfRequest(1)); 668 EXPECT_EQ(2, GetOrderOfRequest(2)); 669 EXPECT_EQ(3, GetOrderOfRequest(3)); 670 EXPECT_EQ(4, GetOrderOfRequest(4)); 671 672 // Request ("b", 7) has the highest priority, but we can't make new socket for 673 // group "b", because it has reached the per-group limit. Then we make 674 // socket for ("c", 6), because it has higher priority than ("a", 4), 675 // and we still can't make a socket for group "b". 676 EXPECT_EQ(5, GetOrderOfRequest(5)); 677 EXPECT_EQ(6, GetOrderOfRequest(6)); 678 EXPECT_EQ(7, GetOrderOfRequest(7)); 679 680 // Make sure we test order of all requests made. 681 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8)); 682 } 683 684 // Make sure that we count connecting sockets against the total limit. 685 TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) { 686 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 687 688 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 689 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 690 EXPECT_EQ(OK, StartRequest("c", kDefaultPriority)); 691 692 // Create one asynchronous request. 693 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 694 EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", kDefaultPriority)); 695 696 // We post all of our delayed tasks with a 2ms delay. I.e. they don't 697 // actually become pending until 2ms after they have been created. In order 698 // to flush all tasks, we need to wait so that we know there are no 699 // soon-to-be-pending tasks waiting. 700 PlatformThread::Sleep(10); 701 MessageLoop::current()->RunAllPending(); 702 703 // The next synchronous request should wait for its turn. 704 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 705 EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", kDefaultPriority)); 706 707 ReleaseAllConnections(KEEP_ALIVE); 708 709 EXPECT_EQ(static_cast<int>(requests_.size()), 710 client_socket_factory_.allocation_count()); 711 712 EXPECT_EQ(1, GetOrderOfRequest(1)); 713 EXPECT_EQ(2, GetOrderOfRequest(2)); 714 EXPECT_EQ(3, GetOrderOfRequest(3)); 715 EXPECT_EQ(4, GetOrderOfRequest(4)); 716 EXPECT_EQ(5, GetOrderOfRequest(5)); 717 718 // Make sure we test order of all requests made. 719 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(6)); 720 } 721 722 // Inside ClientSocketPoolBase we have a may_have_stalled_group flag, 723 // which tells it to use more expensive, but accurate, group selection 724 // algorithm. Make sure it doesn't get stuck in the "on" state. 725 TEST_F(ClientSocketPoolBaseTest, MayHaveStalledGroupReset) { 726 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 727 728 EXPECT_FALSE(pool_->base()->may_have_stalled_group()); 729 730 // Reach group socket limit. 731 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 732 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 733 EXPECT_FALSE(pool_->base()->may_have_stalled_group()); 734 735 // Reach total limit, but don't request more sockets. 736 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 737 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 738 EXPECT_FALSE(pool_->base()->may_have_stalled_group()); 739 740 // Request one more socket while we are at the maximum sockets limit. 741 // This should flip the may_have_stalled_group flag. 742 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority)); 743 EXPECT_TRUE(pool_->base()->may_have_stalled_group()); 744 745 // After releasing first connection for "a", we're still at the 746 // maximum sockets limit, but every group's pending queue is empty, 747 // so we reset the flag. 748 EXPECT_TRUE(ReleaseOneConnection(KEEP_ALIVE)); 749 EXPECT_FALSE(pool_->base()->may_have_stalled_group()); 750 751 // Requesting additional socket while at the total limit should 752 // flip the flag back to "on". 753 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kDefaultPriority)); 754 EXPECT_TRUE(pool_->base()->may_have_stalled_group()); 755 756 // We'll request one more socket to verify that we don't reset the flag 757 // too eagerly. 758 EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", kDefaultPriority)); 759 EXPECT_TRUE(pool_->base()->may_have_stalled_group()); 760 761 // We're at the maximum socket limit, and still have one request pending 762 // for "d". Flag should be "on". 763 EXPECT_TRUE(ReleaseOneConnection(KEEP_ALIVE)); 764 EXPECT_TRUE(pool_->base()->may_have_stalled_group()); 765 766 // Now every group's pending queue should be empty again. 767 EXPECT_TRUE(ReleaseOneConnection(KEEP_ALIVE)); 768 EXPECT_FALSE(pool_->base()->may_have_stalled_group()); 769 770 ReleaseAllConnections(KEEP_ALIVE); 771 EXPECT_FALSE(pool_->base()->may_have_stalled_group()); 772 } 773 774 TEST_F(ClientSocketPoolBaseTest, PendingRequests) { 775 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 776 777 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 778 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 779 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 780 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 781 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 782 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 783 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 784 785 ReleaseAllConnections(KEEP_ALIVE); 786 787 EXPECT_EQ(kDefaultMaxSocketsPerGroup, 788 client_socket_factory_.allocation_count()); 789 EXPECT_EQ(requests_.size() - kDefaultMaxSocketsPerGroup, completion_count_); 790 791 EXPECT_EQ(1, GetOrderOfRequest(1)); 792 EXPECT_EQ(2, GetOrderOfRequest(2)); 793 EXPECT_EQ(6, GetOrderOfRequest(3)); 794 EXPECT_EQ(4, GetOrderOfRequest(4)); 795 EXPECT_EQ(3, GetOrderOfRequest(5)); 796 EXPECT_EQ(5, GetOrderOfRequest(6)); 797 EXPECT_EQ(7, GetOrderOfRequest(7)); 798 799 // Make sure we test order of all requests made. 800 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8)); 801 } 802 803 TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) { 804 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 805 806 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 807 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 808 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 809 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 810 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 811 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 812 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 813 814 ReleaseAllConnections(NO_KEEP_ALIVE); 815 816 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_.size(); ++i) 817 EXPECT_EQ(OK, requests_[i]->WaitForResult()); 818 819 EXPECT_EQ(static_cast<int>(requests_.size()), 820 client_socket_factory_.allocation_count()); 821 EXPECT_EQ(requests_.size() - kDefaultMaxSocketsPerGroup, completion_count_); 822 } 823 824 // This test will start up a RequestSocket() and then immediately Cancel() it. 825 // The pending connect job will be cancelled and should not call back into 826 // ClientSocketPoolBase. 827 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) { 828 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 829 830 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 831 TestSocketRequest req(&request_order_, &completion_count_); 832 EXPECT_EQ(ERR_IO_PENDING, 833 InitHandle(req.handle(), "a", kDefaultPriority, &req, 834 pool_.get(), NULL)); 835 req.handle()->Reset(); 836 } 837 838 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) { 839 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 840 841 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 842 ClientSocketHandle handle; 843 TestCompletionCallback callback; 844 TestSocketRequest req(&request_order_, &completion_count_); 845 846 EXPECT_EQ(ERR_IO_PENDING, 847 InitHandle(&handle, "a", kDefaultPriority, &callback, 848 pool_.get(), NULL)); 849 850 handle.Reset(); 851 852 TestCompletionCallback callback2; 853 EXPECT_EQ(ERR_IO_PENDING, 854 InitHandle(&handle, "a", kDefaultPriority, &callback2, 855 pool_.get(), NULL)); 856 857 EXPECT_EQ(OK, callback2.WaitForResult()); 858 EXPECT_FALSE(callback.have_result()); 859 860 handle.Reset(); 861 } 862 863 TEST_F(ClientSocketPoolBaseTest, CancelRequest) { 864 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 865 866 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 867 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 868 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 869 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 870 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 871 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 872 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 873 874 // Cancel a request. 875 size_t index_to_cancel = kDefaultMaxSocketsPerGroup + 2; 876 EXPECT_FALSE(requests_[index_to_cancel]->handle()->is_initialized()); 877 requests_[index_to_cancel]->handle()->Reset(); 878 879 ReleaseAllConnections(KEEP_ALIVE); 880 881 EXPECT_EQ(kDefaultMaxSocketsPerGroup, 882 client_socket_factory_.allocation_count()); 883 EXPECT_EQ(requests_.size() - kDefaultMaxSocketsPerGroup - 1, 884 completion_count_); 885 886 EXPECT_EQ(1, GetOrderOfRequest(1)); 887 EXPECT_EQ(2, GetOrderOfRequest(2)); 888 EXPECT_EQ(5, GetOrderOfRequest(3)); 889 EXPECT_EQ(3, GetOrderOfRequest(4)); 890 EXPECT_EQ(kRequestNotFound, GetOrderOfRequest(5)); // Canceled request. 891 EXPECT_EQ(4, GetOrderOfRequest(6)); 892 EXPECT_EQ(6, GetOrderOfRequest(7)); 893 894 // Make sure we test order of all requests made. 895 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8)); 896 } 897 898 class RequestSocketCallback : public CallbackRunner< Tuple1<int> > { 899 public: 900 RequestSocketCallback(ClientSocketHandle* handle, 901 TestClientSocketPool* pool, 902 TestConnectJobFactory* test_connect_job_factory, 903 TestConnectJob::JobType next_job_type) 904 : handle_(handle), 905 pool_(pool), 906 within_callback_(false), 907 test_connect_job_factory_(test_connect_job_factory), 908 next_job_type_(next_job_type) {} 909 910 virtual void RunWithParams(const Tuple1<int>& params) { 911 callback_.RunWithParams(params); 912 ASSERT_EQ(OK, params.a); 913 914 if (!within_callback_) { 915 test_connect_job_factory_->set_job_type(next_job_type_); 916 917 // Don't allow reuse of the socket. Disconnect it and then release it and 918 // run through the MessageLoop once to get it completely released. 919 handle_->socket()->Disconnect(); 920 handle_->Reset(); 921 { 922 MessageLoop::ScopedNestableTaskAllower nestable( 923 MessageLoop::current()); 924 MessageLoop::current()->RunAllPending(); 925 } 926 within_callback_ = true; 927 TestCompletionCallback next_job_callback; 928 int rv = InitHandle( 929 handle_, "a", kDefaultPriority, &next_job_callback, pool_.get(), 930 NULL); 931 switch (next_job_type_) { 932 case TestConnectJob::kMockJob: 933 EXPECT_EQ(OK, rv); 934 break; 935 case TestConnectJob::kMockPendingJob: 936 EXPECT_EQ(ERR_IO_PENDING, rv); 937 938 // For pending jobs, wait for new socket to be created. This makes 939 // sure there are no more pending operations nor any unclosed sockets 940 // when the test finishes. 941 // We need to give it a little bit of time to run, so that all the 942 // operations that happen on timers (e.g. cleanup of idle 943 // connections) can execute. 944 { 945 MessageLoop::ScopedNestableTaskAllower nestable( 946 MessageLoop::current()); 947 PlatformThread::Sleep(10); 948 EXPECT_EQ(OK, next_job_callback.WaitForResult()); 949 } 950 break; 951 default: 952 FAIL() << "Unexpected job type: " << next_job_type_; 953 break; 954 } 955 } 956 } 957 958 int WaitForResult() { 959 return callback_.WaitForResult(); 960 } 961 962 private: 963 ClientSocketHandle* const handle_; 964 const scoped_refptr<TestClientSocketPool> pool_; 965 bool within_callback_; 966 TestConnectJobFactory* const test_connect_job_factory_; 967 TestConnectJob::JobType next_job_type_; 968 TestCompletionCallback callback_; 969 }; 970 971 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) { 972 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 973 974 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 975 ClientSocketHandle handle; 976 RequestSocketCallback callback( 977 &handle, pool_.get(), connect_job_factory_, 978 TestConnectJob::kMockPendingJob); 979 int rv = InitHandle(&handle, "a", kDefaultPriority, &callback, 980 pool_.get(), NULL); 981 ASSERT_EQ(ERR_IO_PENDING, rv); 982 983 EXPECT_EQ(OK, callback.WaitForResult()); 984 } 985 986 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) { 987 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 988 989 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 990 ClientSocketHandle handle; 991 RequestSocketCallback callback( 992 &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob); 993 int rv = InitHandle(&handle, "a", kDefaultPriority, &callback, 994 pool_.get(), NULL); 995 ASSERT_EQ(ERR_IO_PENDING, rv); 996 997 EXPECT_EQ(OK, callback.WaitForResult()); 998 } 999 1000 // Make sure that pending requests get serviced after active requests get 1001 // cancelled. 1002 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) { 1003 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1004 1005 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1006 1007 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1008 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1009 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1010 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1011 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1012 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1013 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1014 1015 // Now, kDefaultMaxSocketsPerGroup requests should be active. 1016 // Let's cancel them. 1017 for (int i = 0; i < kDefaultMaxSocketsPerGroup; ++i) { 1018 ASSERT_FALSE(requests_[i]->handle()->is_initialized()); 1019 requests_[i]->handle()->Reset(); 1020 } 1021 1022 // Let's wait for the rest to complete now. 1023 for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_.size(); ++i) { 1024 EXPECT_EQ(OK, requests_[i]->WaitForResult()); 1025 requests_[i]->handle()->Reset(); 1026 } 1027 1028 EXPECT_EQ(requests_.size() - kDefaultMaxSocketsPerGroup, completion_count_); 1029 } 1030 1031 // Make sure that pending requests get serviced after active requests fail. 1032 TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) { 1033 const size_t kMaxSockets = 5; 1034 CreatePool(kMaxSockets, kDefaultMaxSocketsPerGroup); 1035 1036 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 1037 1038 const size_t kNumberOfRequests = 2 * kDefaultMaxSocketsPerGroup + 1; 1039 ASSERT_LE(kNumberOfRequests, kMaxSockets); // Otherwise the test will hang. 1040 1041 // Queue up all the requests 1042 for (size_t i = 0; i < kNumberOfRequests; ++i) 1043 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1044 1045 for (size_t i = 0; i < kNumberOfRequests; ++i) 1046 EXPECT_EQ(ERR_CONNECTION_FAILED, requests_[i]->WaitForResult()); 1047 } 1048 1049 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) { 1050 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1051 1052 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1053 1054 TestSocketRequest req(&request_order_, &completion_count_); 1055 int rv = InitHandle(req.handle(), "a", kDefaultPriority, &req, 1056 pool_.get(), NULL); 1057 EXPECT_EQ(ERR_IO_PENDING, rv); 1058 1059 // Cancel the active request. 1060 req.handle()->Reset(); 1061 1062 rv = InitHandle(req.handle(), "a", kDefaultPriority, &req, 1063 pool_.get(), NULL); 1064 EXPECT_EQ(ERR_IO_PENDING, rv); 1065 EXPECT_EQ(OK, req.WaitForResult()); 1066 1067 EXPECT_FALSE(req.handle()->is_reused()); 1068 EXPECT_EQ(1U, completion_count_); 1069 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 1070 } 1071 1072 // Regression test for http://crbug.com/17985. 1073 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) { 1074 const int kMaxSockets = 3; 1075 const int kMaxSocketsPerGroup = 2; 1076 CreatePool(kMaxSockets, kMaxSocketsPerGroup); 1077 1078 const RequestPriority kHighPriority = HIGHEST; 1079 1080 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1081 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 1082 1083 // This is going to be a pending request in an otherwise empty group. 1084 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 1085 1086 // Reach the maximum socket limit. 1087 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); 1088 1089 // Create a stalled group with high priorities. 1090 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority)); 1091 EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority)); 1092 EXPECT_TRUE(pool_->base()->may_have_stalled_group()); 1093 1094 // Release the first two sockets from "a", which will make room 1095 // for requests from "c". After that "a" will have no active sockets 1096 // and one pending request. 1097 EXPECT_TRUE(ReleaseOneConnection(KEEP_ALIVE)); 1098 EXPECT_TRUE(ReleaseOneConnection(KEEP_ALIVE)); 1099 1100 // Closing idle sockets should not get us into trouble, but in the bug 1101 // we were hitting a CHECK here. 1102 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); 1103 pool_->CloseIdleSockets(); 1104 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 1105 } 1106 1107 class ClientSocketPoolBaseTest_LateBinding : public ClientSocketPoolBaseTest { 1108 protected: 1109 virtual void SetUp() { 1110 ClientSocketPoolBaseTest::SetUp(); 1111 } 1112 }; 1113 1114 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) { 1115 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1116 1117 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1118 TestSocketRequest req(&request_order_, &completion_count_); 1119 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); 1120 int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), log); 1121 EXPECT_EQ(ERR_IO_PENDING, rv); 1122 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle())); 1123 EXPECT_EQ(OK, req.WaitForResult()); 1124 EXPECT_TRUE(req.handle()->is_initialized()); 1125 EXPECT_TRUE(req.handle()->socket()); 1126 req.handle()->Reset(); 1127 1128 EXPECT_EQ(6u, log->entries().size()); 1129 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); 1130 EXPECT_TRUE(LogContainsBeginEvent( 1131 *log, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1132 EXPECT_TRUE(LogContainsEndEvent( 1133 *log, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1134 EXPECT_TRUE(LogContainsBeginEvent( 1135 *log, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 1136 EXPECT_TRUE(LogContainsEndEvent( 1137 *log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 1138 EXPECT_TRUE(LogContainsEndEvent( 1139 *log, 5, LoadLog::TYPE_SOCKET_POOL)); 1140 } 1141 1142 TEST_F(ClientSocketPoolBaseTest, 1143 InitConnectionAsynchronousFailure) { 1144 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1145 1146 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 1147 TestSocketRequest req(&request_order_, &completion_count_); 1148 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); 1149 EXPECT_EQ(ERR_IO_PENDING, 1150 InitHandle(req.handle(), "a", kDefaultPriority, &req, 1151 pool_.get(), log)); 1152 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle())); 1153 EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult()); 1154 1155 EXPECT_EQ(6u, log->entries().size()); 1156 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); 1157 EXPECT_TRUE(LogContainsBeginEvent( 1158 *log, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1159 EXPECT_TRUE(LogContainsEndEvent( 1160 *log, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1161 EXPECT_TRUE(LogContainsBeginEvent( 1162 *log, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 1163 EXPECT_TRUE(LogContainsEndEvent( 1164 *log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 1165 EXPECT_TRUE(LogContainsEndEvent(*log, 5, LoadLog::TYPE_SOCKET_POOL)); 1166 } 1167 1168 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) { 1169 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1170 1171 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1172 TestSocketRequest req(&request_order_, &completion_count_); 1173 TestSocketRequest req2(&request_order_, &completion_count_); 1174 1175 scoped_refptr<LoadLog> log1(new LoadLog(LoadLog::kUnbounded)); 1176 EXPECT_EQ(ERR_IO_PENDING, 1177 InitHandle(req.handle(), "a", kDefaultPriority, &req, 1178 pool_.get(), log1)); 1179 scoped_refptr<LoadLog> log2(new LoadLog(LoadLog::kUnbounded)); 1180 EXPECT_EQ(ERR_IO_PENDING, 1181 InitHandle(req2.handle(), "a", kDefaultPriority, &req2, 1182 pool_.get(), log2)); 1183 1184 req.handle()->Reset(); 1185 1186 EXPECT_EQ(5u, log1->entries().size()); 1187 EXPECT_TRUE(LogContainsBeginEvent(*log1, 0, LoadLog::TYPE_SOCKET_POOL)); 1188 EXPECT_TRUE(LogContainsBeginEvent( 1189 *log1, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1190 EXPECT_TRUE(LogContainsEndEvent( 1191 *log1, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1192 EXPECT_TRUE(LogContainsEvent( 1193 *log1, 3, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); 1194 EXPECT_TRUE(LogContainsEndEvent(*log1, 4, LoadLog::TYPE_SOCKET_POOL)); 1195 1196 // At this point, request 2 is just waiting for the connect job to finish. 1197 EXPECT_EQ(2u, log2->entries().size()); 1198 EXPECT_TRUE(LogContainsBeginEvent(*log2, 0, LoadLog::TYPE_SOCKET_POOL)); 1199 EXPECT_TRUE(LogContainsBeginEvent( 1200 *log2, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1201 1202 EXPECT_EQ(OK, req2.WaitForResult()); 1203 req2.handle()->Reset(); 1204 1205 // Now request 2 has actually finished. 1206 EXPECT_EQ(6u, log2->entries().size()); 1207 EXPECT_TRUE(LogContainsBeginEvent(*log2, 0, LoadLog::TYPE_SOCKET_POOL)); 1208 EXPECT_TRUE(LogContainsBeginEvent( 1209 *log2, 1, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1210 EXPECT_TRUE(LogContainsEndEvent( 1211 *log1, 2, LoadLog::TYPE_SOCKET_POOL_WAITING_IN_QUEUE)); 1212 EXPECT_TRUE(LogContainsBeginEvent( 1213 *log2, 3, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 1214 EXPECT_TRUE(LogContainsEndEvent( 1215 *log2, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); 1216 EXPECT_TRUE(LogContainsEndEvent(*log2, 5, LoadLog::TYPE_SOCKET_POOL)); 1217 1218 } 1219 1220 TEST_F(ClientSocketPoolBaseTest, CancelRequestLimitsJobs) { 1221 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1222 1223 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1224 1225 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 1226 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 1227 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 1228 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 1229 1230 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a")); 1231 requests_[2]->handle()->Reset(); 1232 requests_[3]->handle()->Reset(); 1233 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a")); 1234 1235 requests_[1]->handle()->Reset(); 1236 EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a")); 1237 1238 requests_[0]->handle()->Reset(); 1239 EXPECT_EQ(kDefaultMaxSocketsPerGroup - 1, pool_->NumConnectJobsInGroup("a")); 1240 } 1241 1242 // When requests and ConnectJobs are not coupled, the request will get serviced 1243 // by whatever comes first. 1244 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) { 1245 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1246 1247 // Start job 1 (async OK) 1248 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1249 1250 TestSocketRequest req1(&request_order_, &completion_count_); 1251 int rv = InitHandle(req1.handle(), "a", kDefaultPriority, 1252 &req1, pool_.get(), NULL); 1253 EXPECT_EQ(ERR_IO_PENDING, rv); 1254 EXPECT_EQ(OK, req1.WaitForResult()); 1255 1256 // Job 1 finished OK. Start job 2 (also async OK). Request 3 is pending 1257 // without a job. 1258 connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob); 1259 1260 TestSocketRequest req2(&request_order_, &completion_count_); 1261 rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, 1262 pool_.get(), NULL); 1263 EXPECT_EQ(ERR_IO_PENDING, rv); 1264 TestSocketRequest req3(&request_order_, &completion_count_); 1265 rv = InitHandle( 1266 req3.handle(), "a", kDefaultPriority, &req3, pool_.get(), NULL); 1267 EXPECT_EQ(ERR_IO_PENDING, rv); 1268 1269 // Both Requests 2 and 3 are pending. We release socket 1 which should 1270 // service request 2. Request 3 should still be waiting. 1271 req1.handle()->Reset(); 1272 MessageLoop::current()->RunAllPending(); // Run the DoReleaseSocket() 1273 ASSERT_TRUE(req2.handle()->socket()); 1274 EXPECT_EQ(OK, req2.WaitForResult()); 1275 EXPECT_FALSE(req3.handle()->socket()); 1276 1277 // Signal job 2, which should service request 3. 1278 1279 client_socket_factory_.SignalJobs(); 1280 EXPECT_EQ(OK, req3.WaitForResult()); 1281 1282 ASSERT_EQ(3U, request_order_.size()); 1283 EXPECT_EQ(&req1, request_order_[0]); 1284 EXPECT_EQ(&req2, request_order_[1]); 1285 EXPECT_EQ(&req3, request_order_[2]); 1286 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); 1287 } 1288 1289 // The requests are not coupled to the jobs. So, the requests should finish in 1290 // their priority / insertion order. 1291 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) { 1292 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1293 // First two jobs are async. 1294 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); 1295 1296 TestSocketRequest req1(&request_order_, &completion_count_); 1297 int rv = InitHandle( 1298 req1.handle(), "a", kDefaultPriority, &req1, pool_.get(), NULL); 1299 EXPECT_EQ(ERR_IO_PENDING, rv); 1300 1301 TestSocketRequest req2(&request_order_, &completion_count_); 1302 rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, 1303 pool_.get(), NULL); 1304 EXPECT_EQ(ERR_IO_PENDING, rv); 1305 1306 // The pending job is sync. 1307 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1308 1309 TestSocketRequest req3(&request_order_, &completion_count_); 1310 rv = InitHandle( 1311 req3.handle(), "a", kDefaultPriority, &req3, pool_.get(), NULL); 1312 EXPECT_EQ(ERR_IO_PENDING, rv); 1313 1314 EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult()); 1315 EXPECT_EQ(OK, req2.WaitForResult()); 1316 EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult()); 1317 1318 ASSERT_EQ(3U, request_order_.size()); 1319 EXPECT_EQ(&req1, request_order_[0]); 1320 EXPECT_EQ(&req2, request_order_[1]); 1321 EXPECT_EQ(&req3, request_order_[2]); 1322 } 1323 1324 TEST_F(ClientSocketPoolBaseTest, DISABLED_LoadState) { 1325 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); 1326 connect_job_factory_->set_job_type( 1327 TestConnectJob::kMockAdvancingLoadStateJob); 1328 1329 TestSocketRequest req1(&request_order_, &completion_count_); 1330 int rv = InitHandle( 1331 req1.handle(), "a", kDefaultPriority, &req1, pool_.get(), NULL); 1332 EXPECT_EQ(ERR_IO_PENDING, rv); 1333 EXPECT_EQ(LOAD_STATE_IDLE, req1.handle()->GetLoadState()); 1334 1335 MessageLoop::current()->RunAllPending(); 1336 1337 TestSocketRequest req2(&request_order_, &completion_count_); 1338 rv = InitHandle(req2.handle(), "a", kDefaultPriority, &req2, 1339 pool_.get(), NULL); 1340 EXPECT_EQ(ERR_IO_PENDING, rv); 1341 EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, req1.handle()->GetLoadState()); 1342 EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, req2.handle()->GetLoadState()); 1343 } 1344 1345 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) { 1346 CreatePoolWithIdleTimeouts( 1347 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, 1348 base::TimeDelta(), // Time out unused sockets immediately. 1349 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 1350 1351 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); 1352 1353 // Startup two mock pending connect jobs, which will sit in the MessageLoop. 1354 1355 TestSocketRequest req(&request_order_, &completion_count_); 1356 int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), NULL); 1357 EXPECT_EQ(ERR_IO_PENDING, rv); 1358 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle())); 1359 1360 TestSocketRequest req2(&request_order_, &completion_count_); 1361 rv = InitHandle(req2.handle(), "a", LOWEST, &req2, pool_.get(), NULL); 1362 EXPECT_EQ(ERR_IO_PENDING, rv); 1363 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req2.handle())); 1364 1365 // Cancel one of the requests. Wait for the other, which will get the first 1366 // job. Release the socket. Run the loop again to make sure the second 1367 // socket is sitting idle and the first one is released (since ReleaseSocket() 1368 // just posts a DoReleaseSocket() task). 1369 1370 req.handle()->Reset(); 1371 EXPECT_EQ(OK, req2.WaitForResult()); 1372 req2.handle()->Reset(); 1373 1374 // We post all of our delayed tasks with a 2ms delay. I.e. they don't 1375 // actually become pending until 2ms after they have been created. In order 1376 // to flush all tasks, we need to wait so that we know there are no 1377 // soon-to-be-pending tasks waiting. 1378 PlatformThread::Sleep(10); 1379 MessageLoop::current()->RunAllPending(); 1380 1381 ASSERT_EQ(2, pool_->IdleSocketCount()); 1382 1383 // Invoke the idle socket cleanup check. Only one socket should be left, the 1384 // used socket. Request it to make sure that it's used. 1385 1386 pool_->CleanupTimedOutIdleSockets(); 1387 rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), NULL); 1388 EXPECT_EQ(OK, rv); 1389 EXPECT_TRUE(req.handle()->is_reused()); 1390 } 1391 1392 // Make sure that we process all pending requests even when we're stalling 1393 // because of multiple releasing disconnected sockets. 1394 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) { 1395 CreatePoolWithIdleTimeouts( 1396 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, 1397 base::TimeDelta(), // Time out unused sockets immediately. 1398 base::TimeDelta::FromDays(1)); // Don't time out used sockets. 1399 1400 connect_job_factory_->set_job_type(TestConnectJob::kMockJob); 1401 1402 // Startup 4 connect jobs. Two of them will be pending. 1403 1404 TestSocketRequest req(&request_order_, &completion_count_); 1405 int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), NULL); 1406 EXPECT_EQ(OK, rv); 1407 1408 TestSocketRequest req2(&request_order_, &completion_count_); 1409 rv = InitHandle(req2.handle(), "a", LOWEST, &req2, pool_.get(), NULL); 1410 EXPECT_EQ(OK, rv); 1411 1412 TestSocketRequest req3(&request_order_, &completion_count_); 1413 rv = InitHandle(req3.handle(), "a", LOWEST, &req3, pool_.get(), NULL); 1414 EXPECT_EQ(ERR_IO_PENDING, rv); 1415 1416 TestSocketRequest req4(&request_order_, &completion_count_); 1417 rv = InitHandle(req4.handle(), "a", LOWEST, &req4, pool_.get(), NULL); 1418 EXPECT_EQ(ERR_IO_PENDING, rv); 1419 1420 // Release two disconnected sockets. 1421 1422 req.handle()->socket()->Disconnect(); 1423 req.handle()->Reset(); 1424 req2.handle()->socket()->Disconnect(); 1425 req2.handle()->Reset(); 1426 1427 EXPECT_EQ(OK, req3.WaitForResult()); 1428 EXPECT_FALSE(req3.handle()->is_reused()); 1429 EXPECT_EQ(OK, req4.WaitForResult()); 1430 EXPECT_FALSE(req4.handle()->is_reused()); 1431 } 1432 1433 } // namespace 1434 1435 } // namespace net 1436
