OLD | NEW |
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/socket/client_socket_pool_base.h" | 5 #include "net/socket/client_socket_pool_base.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "base/compiler_specific.h" | 8 #include "base/compiler_specific.h" |
9 #include "base/message_loop.h" | 9 #include "base/message_loop.h" |
10 #include "base/platform_thread.h" | 10 #include "base/platform_thread.h" |
11 #include "base/scoped_vector.h" | 11 #include "base/scoped_vector.h" |
12 #include "net/base/load_log.h" | 12 #include "net/base/net_log.h" |
13 #include "net/base/load_log_unittest.h" | 13 #include "net/base/net_log_unittest.h" |
14 #include "net/base/load_log_util.h" | |
15 #include "net/base/net_errors.h" | 14 #include "net/base/net_errors.h" |
16 #include "net/base/request_priority.h" | 15 #include "net/base/request_priority.h" |
17 #include "net/base/test_completion_callback.h" | 16 #include "net/base/test_completion_callback.h" |
18 #include "net/socket/client_socket.h" | 17 #include "net/socket/client_socket.h" |
19 #include "net/socket/client_socket_factory.h" | 18 #include "net/socket/client_socket_factory.h" |
20 #include "net/socket/client_socket_handle.h" | 19 #include "net/socket/client_socket_handle.h" |
21 #include "net/socket/socket_test_util.h" | 20 #include "net/socket/socket_test_util.h" |
22 #include "testing/gtest/include/gtest/gtest.h" | 21 #include "testing/gtest/include/gtest/gtest.h" |
23 | 22 |
24 namespace net { | 23 namespace net { |
(...skipping 19 matching lines...) Expand all Loading... |
44 | 43 |
45 virtual int Write( | 44 virtual int Write( |
46 IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) { | 45 IOBuffer* /* buf */, int /* len */, CompletionCallback* /* callback */) { |
47 return ERR_UNEXPECTED; | 46 return ERR_UNEXPECTED; |
48 } | 47 } |
49 virtual bool SetReceiveBufferSize(int32 size) { return true; }; | 48 virtual bool SetReceiveBufferSize(int32 size) { return true; }; |
50 virtual bool SetSendBufferSize(int32 size) { return true; }; | 49 virtual bool SetSendBufferSize(int32 size) { return true; }; |
51 | 50 |
52 // ClientSocket methods: | 51 // ClientSocket methods: |
53 | 52 |
54 virtual int Connect(CompletionCallback* callback, LoadLog* load_log) { | 53 virtual int Connect(CompletionCallback* callback, const BoundNetLog& net_log)
{ |
55 connected_ = true; | 54 connected_ = true; |
56 return OK; | 55 return OK; |
57 } | 56 } |
58 | 57 |
59 virtual void Disconnect() { connected_ = false; } | 58 virtual void Disconnect() { connected_ = false; } |
60 virtual bool IsConnected() const { return connected_; } | 59 virtual bool IsConnected() const { return connected_; } |
61 virtual bool IsConnectedAndIdle() const { return connected_; } | 60 virtual bool IsConnectedAndIdle() const { return connected_; } |
62 | 61 |
63 virtual int GetPeerAddress(AddressList* /* address */) const { | 62 virtual int GetPeerAddress(AddressList* /* address */) const { |
64 return ERR_UNEXPECTED; | 63 return ERR_UNEXPECTED; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
109 kMockWaitingJob, | 108 kMockWaitingJob, |
110 kMockAdvancingLoadStateJob, | 109 kMockAdvancingLoadStateJob, |
111 }; | 110 }; |
112 | 111 |
113 TestConnectJob(JobType job_type, | 112 TestConnectJob(JobType job_type, |
114 const std::string& group_name, | 113 const std::string& group_name, |
115 const TestClientSocketPoolBase::Request& request, | 114 const TestClientSocketPoolBase::Request& request, |
116 base::TimeDelta timeout_duration, | 115 base::TimeDelta timeout_duration, |
117 ConnectJob::Delegate* delegate, | 116 ConnectJob::Delegate* delegate, |
118 MockClientSocketFactory* client_socket_factory, | 117 MockClientSocketFactory* client_socket_factory, |
119 LoadLog* load_log) | 118 const BoundNetLog& net_log) |
120 : ConnectJob(group_name, timeout_duration, delegate, load_log), | 119 : ConnectJob(group_name, timeout_duration, delegate, net_log), |
121 job_type_(job_type), | 120 job_type_(job_type), |
122 client_socket_factory_(client_socket_factory), | 121 client_socket_factory_(client_socket_factory), |
123 method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)), | 122 method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)), |
124 load_state_(LOAD_STATE_IDLE) {} | 123 load_state_(LOAD_STATE_IDLE) {} |
125 | 124 |
126 void Signal() { | 125 void Signal() { |
127 DoConnect(waiting_success_, true /* async */); | 126 DoConnect(waiting_success_, true /* async */); |
128 } | 127 } |
129 | 128 |
130 virtual LoadState GetLoadState() const { return load_state_; } | 129 virtual LoadState GetLoadState() const { return load_state_; } |
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
243 void set_timeout_duration(base::TimeDelta timeout_duration) { | 242 void set_timeout_duration(base::TimeDelta timeout_duration) { |
244 timeout_duration_ = timeout_duration; | 243 timeout_duration_ = timeout_duration; |
245 } | 244 } |
246 | 245 |
247 // ConnectJobFactory methods: | 246 // ConnectJobFactory methods: |
248 | 247 |
249 virtual ConnectJob* NewConnectJob( | 248 virtual ConnectJob* NewConnectJob( |
250 const std::string& group_name, | 249 const std::string& group_name, |
251 const TestClientSocketPoolBase::Request& request, | 250 const TestClientSocketPoolBase::Request& request, |
252 ConnectJob::Delegate* delegate, | 251 ConnectJob::Delegate* delegate, |
253 LoadLog* load_log) const { | 252 const BoundNetLog& net_log) const { |
254 return new TestConnectJob(job_type_, | 253 return new TestConnectJob(job_type_, |
255 group_name, | 254 group_name, |
256 request, | 255 request, |
257 timeout_duration_, | 256 timeout_duration_, |
258 delegate, | 257 delegate, |
259 client_socket_factory_, | 258 client_socket_factory_, |
260 load_log); | 259 net_log); |
261 } | 260 } |
262 | 261 |
263 private: | 262 private: |
264 TestConnectJob::JobType job_type_; | 263 TestConnectJob::JobType job_type_; |
265 base::TimeDelta timeout_duration_; | 264 base::TimeDelta timeout_duration_; |
266 MockClientSocketFactory* const client_socket_factory_; | 265 MockClientSocketFactory* const client_socket_factory_; |
267 | 266 |
268 DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory); | 267 DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory); |
269 }; | 268 }; |
270 | 269 |
271 class TestClientSocketPool : public ClientSocketPool { | 270 class TestClientSocketPool : public ClientSocketPool { |
272 public: | 271 public: |
273 TestClientSocketPool( | 272 TestClientSocketPool( |
274 int max_sockets, | 273 int max_sockets, |
275 int max_sockets_per_group, | 274 int max_sockets_per_group, |
276 base::TimeDelta unused_idle_socket_timeout, | 275 base::TimeDelta unused_idle_socket_timeout, |
277 base::TimeDelta used_idle_socket_timeout, | 276 base::TimeDelta used_idle_socket_timeout, |
278 TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory) | 277 TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory) |
279 : base_(max_sockets, max_sockets_per_group, | 278 : base_(max_sockets, max_sockets_per_group, |
280 unused_idle_socket_timeout, used_idle_socket_timeout, | 279 unused_idle_socket_timeout, used_idle_socket_timeout, |
281 connect_job_factory, NULL) {} | 280 connect_job_factory, NULL) {} |
282 | 281 |
283 virtual int RequestSocket( | 282 virtual int RequestSocket( |
284 const std::string& group_name, | 283 const std::string& group_name, |
285 const void* params, | 284 const void* params, |
286 net::RequestPriority priority, | 285 net::RequestPriority priority, |
287 ClientSocketHandle* handle, | 286 ClientSocketHandle* handle, |
288 CompletionCallback* callback, | 287 CompletionCallback* callback, |
289 LoadLog* load_log) { | 288 const BoundNetLog& net_log) { |
290 return base_.RequestSocket( | 289 return base_.RequestSocket( |
291 group_name, params, priority, handle, callback, load_log); | 290 group_name, params, priority, handle, callback, net_log); |
292 } | 291 } |
293 | 292 |
294 virtual void CancelRequest( | 293 virtual void CancelRequest( |
295 const std::string& group_name, | 294 const std::string& group_name, |
296 const ClientSocketHandle* handle) { | 295 const ClientSocketHandle* handle) { |
297 base_.CancelRequest(group_name, handle); | 296 base_.CancelRequest(group_name, handle); |
298 } | 297 } |
299 | 298 |
300 virtual void ReleaseSocket( | 299 virtual void ReleaseSocket( |
301 const std::string& group_name, | 300 const std::string& group_name, |
(...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
436 scoped_refptr<TestClientSocketPool> pool_; | 435 scoped_refptr<TestClientSocketPool> pool_; |
437 }; | 436 }; |
438 | 437 |
439 // Helper function which explicitly specifies the template parameters, since | 438 // Helper function which explicitly specifies the template parameters, since |
440 // the compiler will infer (in this case, incorrectly) that NULL is of type int. | 439 // the compiler will infer (in this case, incorrectly) that NULL is of type int. |
441 int InitHandle(ClientSocketHandle* handle, | 440 int InitHandle(ClientSocketHandle* handle, |
442 const std::string& group_name, | 441 const std::string& group_name, |
443 net::RequestPriority priority, | 442 net::RequestPriority priority, |
444 CompletionCallback* callback, | 443 CompletionCallback* callback, |
445 TestClientSocketPool* pool, | 444 TestClientSocketPool* pool, |
446 LoadLog* load_log) { | 445 const BoundNetLog& net_log) { |
447 return handle->Init<TestSocketParams, TestClientSocketPool>( | 446 return handle->Init<TestSocketParams, TestClientSocketPool>( |
448 group_name, NULL, priority, callback, pool, load_log); | 447 group_name, NULL, priority, callback, pool, net_log); |
449 } | 448 } |
450 | 449 |
451 // Even though a timeout is specified, it doesn't time out on a synchronous | 450 // Even though a timeout is specified, it doesn't time out on a synchronous |
452 // completion. | 451 // completion. |
453 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) { | 452 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) { |
454 TestConnectJobDelegate delegate; | 453 TestConnectJobDelegate delegate; |
455 ClientSocketHandle ignored; | 454 ClientSocketHandle ignored; |
456 TestClientSocketPoolBase::Request request( | 455 TestClientSocketPoolBase::Request request( |
457 &ignored, NULL, kDefaultPriority, NULL, NULL); | 456 &ignored, NULL, kDefaultPriority, NULL, NULL); |
458 scoped_ptr<TestConnectJob> job( | 457 scoped_ptr<TestConnectJob> job( |
459 new TestConnectJob(TestConnectJob::kMockJob, | 458 new TestConnectJob(TestConnectJob::kMockJob, |
460 "a", | 459 "a", |
461 request, | 460 request, |
462 base::TimeDelta::FromMicroseconds(1), | 461 base::TimeDelta::FromMicroseconds(1), |
463 &delegate, | 462 &delegate, |
464 &client_socket_factory_, | 463 &client_socket_factory_, |
465 NULL)); | 464 NULL)); |
466 EXPECT_EQ(OK, job->Connect()); | 465 EXPECT_EQ(OK, job->Connect()); |
467 } | 466 } |
468 | 467 |
469 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) { | 468 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) { |
470 TestConnectJobDelegate delegate; | 469 TestConnectJobDelegate delegate; |
471 ClientSocketHandle ignored; | 470 ClientSocketHandle ignored; |
472 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 471 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
| 472 |
473 TestClientSocketPoolBase::Request request( | 473 TestClientSocketPoolBase::Request request( |
474 &ignored, NULL, kDefaultPriority, NULL, NULL); | 474 &ignored, NULL, kDefaultPriority, NULL, NULL); |
475 // Deleted by TestConnectJobDelegate. | 475 // Deleted by TestConnectJobDelegate. |
476 TestConnectJob* job = | 476 TestConnectJob* job = |
477 new TestConnectJob(TestConnectJob::kMockPendingJob, | 477 new TestConnectJob(TestConnectJob::kMockPendingJob, |
478 "a", | 478 "a", |
479 request, | 479 request, |
480 base::TimeDelta::FromMicroseconds(1), | 480 base::TimeDelta::FromMicroseconds(1), |
481 &delegate, | 481 &delegate, |
482 &client_socket_factory_, | 482 &client_socket_factory_, |
483 log); | 483 log.bound()); |
484 ASSERT_EQ(ERR_IO_PENDING, job->Connect()); | 484 ASSERT_EQ(ERR_IO_PENDING, job->Connect()); |
485 PlatformThread::Sleep(1); | 485 PlatformThread::Sleep(1); |
486 EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult()); | 486 EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult()); |
487 | 487 |
488 EXPECT_EQ(3u, log->entries().size()); | 488 EXPECT_EQ(3u, log.entries().size()); |
489 EXPECT_TRUE(LogContainsBeginEvent( | 489 EXPECT_TRUE(LogContainsBeginEvent( |
490 *log, 0, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 490 log.entries(), 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
491 EXPECT_TRUE(LogContainsEvent( | 491 EXPECT_TRUE(LogContainsEvent( |
492 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT, | 492 log.entries(), 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT, |
493 LoadLog::PHASE_NONE)); | 493 NetLog::PHASE_NONE)); |
494 EXPECT_TRUE(LogContainsEndEvent( | 494 EXPECT_TRUE(LogContainsEndEvent( |
495 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 495 log.entries(), 2, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
496 } | 496 } |
497 | 497 |
498 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) { | 498 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) { |
499 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 499 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
500 | 500 |
501 TestCompletionCallback callback; | 501 TestCompletionCallback callback; |
502 ClientSocketHandle handle; | 502 ClientSocketHandle handle; |
503 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 503 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
| 504 |
504 EXPECT_EQ(OK, InitHandle(&handle, "a", kDefaultPriority, | 505 EXPECT_EQ(OK, InitHandle(&handle, "a", kDefaultPriority, |
505 &callback, pool_.get(), log)); | 506 &callback, pool_.get(), log.bound())); |
506 EXPECT_TRUE(handle.is_initialized()); | 507 EXPECT_TRUE(handle.is_initialized()); |
507 EXPECT_TRUE(handle.socket()); | 508 EXPECT_TRUE(handle.socket()); |
508 handle.Reset(); | 509 handle.Reset(); |
509 | 510 |
510 EXPECT_EQ(4u, log->entries().size()); | 511 EXPECT_EQ(5u, log.entries().size()); |
511 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); | |
512 EXPECT_TRUE(LogContainsBeginEvent( | 512 EXPECT_TRUE(LogContainsBeginEvent( |
513 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 513 log.entries(), 0, NetLog::TYPE_SOCKET_POOL)); |
| 514 EXPECT_TRUE(LogContainsBeginEvent( |
| 515 log.entries(), 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
514 EXPECT_TRUE(LogContainsEndEvent( | 516 EXPECT_TRUE(LogContainsEndEvent( |
515 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 517 log.entries(), 2, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
516 EXPECT_TRUE(LogContainsEndEvent(*log, 3, LoadLog::TYPE_SOCKET_POOL)); | 518 EXPECT_TRUE(LogContainsEvent( |
| 519 log.entries(), 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_ID, |
| 520 NetLog::PHASE_NONE)); |
| 521 EXPECT_TRUE(LogContainsEndEvent( |
| 522 log.entries(), 4, NetLog::TYPE_SOCKET_POOL)); |
517 } | 523 } |
518 | 524 |
519 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { | 525 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { |
520 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 526 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
521 | 527 |
522 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); | 528 connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob); |
523 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 529 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
| 530 |
524 TestSocketRequest req(&request_order_, &completion_count_); | 531 TestSocketRequest req(&request_order_, &completion_count_); |
525 EXPECT_EQ(ERR_CONNECTION_FAILED, | 532 EXPECT_EQ(ERR_CONNECTION_FAILED, |
526 InitHandle(req.handle(), "a", kDefaultPriority, &req, | 533 InitHandle(req.handle(), "a", kDefaultPriority, &req, |
527 pool_.get(), log)); | 534 pool_.get(), log.bound())); |
528 | 535 |
529 EXPECT_EQ(4u, log->entries().size()); | 536 EXPECT_EQ(5u, log.entries().size()); |
530 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); | 537 EXPECT_TRUE(LogContainsBeginEvent(log.entries(), 0, NetLog::TYPE_SOCKET_POOL))
; |
531 EXPECT_TRUE(LogContainsBeginEvent( | 538 EXPECT_TRUE(LogContainsBeginEvent( |
532 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 539 log.entries(), 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
533 EXPECT_TRUE(LogContainsEndEvent( | 540 EXPECT_TRUE(LogContainsEndEvent( |
534 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 541 log.entries(), 2, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
535 EXPECT_TRUE(LogContainsEndEvent(*log, 3, LoadLog::TYPE_SOCKET_POOL)); | 542 EXPECT_TRUE(LogContainsEndEvent(log.entries(), 4, NetLog::TYPE_SOCKET_POOL)); |
536 } | 543 } |
537 | 544 |
538 TEST_F(ClientSocketPoolBaseTest, TotalLimit) { | 545 TEST_F(ClientSocketPoolBaseTest, TotalLimit) { |
539 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 546 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
540 | 547 |
541 // TODO(eroman): Check that the LoadLog contains this event. | 548 // TODO(eroman): Check that the NetLog contains this event. |
542 | 549 |
543 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 550 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); |
544 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); | 551 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); |
545 EXPECT_EQ(OK, StartRequest("c", kDefaultPriority)); | 552 EXPECT_EQ(OK, StartRequest("c", kDefaultPriority)); |
546 EXPECT_EQ(OK, StartRequest("d", kDefaultPriority)); | 553 EXPECT_EQ(OK, StartRequest("d", kDefaultPriority)); |
547 | 554 |
548 EXPECT_EQ(static_cast<int>(requests_.size()), | 555 EXPECT_EQ(static_cast<int>(requests_.size()), |
549 client_socket_factory_.allocation_count()); | 556 client_socket_factory_.allocation_count()); |
550 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); | 557 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); |
551 | 558 |
(...skipping 15 matching lines...) Expand all Loading... |
567 EXPECT_EQ(6, GetOrderOfRequest(6)); | 574 EXPECT_EQ(6, GetOrderOfRequest(6)); |
568 EXPECT_EQ(7, GetOrderOfRequest(7)); | 575 EXPECT_EQ(7, GetOrderOfRequest(7)); |
569 | 576 |
570 // Make sure we test order of all requests made. | 577 // Make sure we test order of all requests made. |
571 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8)); | 578 EXPECT_EQ(kIndexOutOfBounds, GetOrderOfRequest(8)); |
572 } | 579 } |
573 | 580 |
574 TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) { | 581 TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) { |
575 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 582 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
576 | 583 |
577 // TODO(eroman): Check that the LoadLog contains this event. | 584 // TODO(eroman): Check that the NetLog contains this event. |
578 | 585 |
579 // Reach all limits: max total sockets, and max sockets per group. | 586 // Reach all limits: max total sockets, and max sockets per group. |
580 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 587 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); |
581 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); | 588 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); |
582 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); | 589 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); |
583 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); | 590 EXPECT_EQ(OK, StartRequest("b", kDefaultPriority)); |
584 | 591 |
585 EXPECT_EQ(static_cast<int>(requests_.size()), | 592 EXPECT_EQ(static_cast<int>(requests_.size()), |
586 client_socket_factory_.allocation_count()); | 593 client_socket_factory_.allocation_count()); |
587 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); | 594 EXPECT_EQ(requests_.size() - kDefaultMaxSockets, completion_count_); |
(...skipping 516 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1104 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); | 1111 EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a")); |
1105 pool_->CloseIdleSockets(); | 1112 pool_->CloseIdleSockets(); |
1106 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); | 1113 EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a")); |
1107 } | 1114 } |
1108 | 1115 |
1109 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) { | 1116 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) { |
1110 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1117 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1111 | 1118 |
1112 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1119 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1113 TestSocketRequest req(&request_order_, &completion_count_); | 1120 TestSocketRequest req(&request_order_, &completion_count_); |
1114 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 1121 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
1115 int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), log); | 1122 int rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), log.bound())
; |
1116 EXPECT_EQ(ERR_IO_PENDING, rv); | 1123 EXPECT_EQ(ERR_IO_PENDING, rv); |
1117 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle())); | 1124 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle())); |
1118 EXPECT_EQ(OK, req.WaitForResult()); | 1125 EXPECT_EQ(OK, req.WaitForResult()); |
1119 EXPECT_TRUE(req.handle()->is_initialized()); | 1126 EXPECT_TRUE(req.handle()->is_initialized()); |
1120 EXPECT_TRUE(req.handle()->socket()); | 1127 EXPECT_TRUE(req.handle()->socket()); |
1121 req.handle()->Reset(); | 1128 req.handle()->Reset(); |
1122 | 1129 |
1123 EXPECT_EQ(6u, log->entries().size()); | 1130 EXPECT_EQ(7u, log.entries().size()); |
1124 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); | |
1125 EXPECT_TRUE(LogContainsBeginEvent( | 1131 EXPECT_TRUE(LogContainsBeginEvent( |
1126 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 1132 log.entries(), 0, NetLog::TYPE_SOCKET_POOL)); |
| 1133 EXPECT_TRUE(LogContainsBeginEvent( |
| 1134 log.entries(), 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
1127 EXPECT_TRUE(LogContainsEndEvent( | 1135 EXPECT_TRUE(LogContainsEndEvent( |
1128 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 1136 log.entries(), 2, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
1129 EXPECT_TRUE(LogContainsEvent( | 1137 EXPECT_TRUE(LogContainsEvent( |
1130 *log, 3, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | 1138 log.entries(), 3, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE)); |
1131 EXPECT_TRUE(LogContainsEndEvent( | 1139 EXPECT_TRUE(LogContainsEndEvent( |
1132 *log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 1140 log.entries(), 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
1133 EXPECT_TRUE(LogContainsEndEvent( | 1141 EXPECT_TRUE(LogContainsEndEvent( |
1134 *log, 5, LoadLog::TYPE_SOCKET_POOL)); | 1142 log.entries(), 6, NetLog::TYPE_SOCKET_POOL)); |
1135 } | 1143 } |
1136 | 1144 |
1137 TEST_F(ClientSocketPoolBaseTest, | 1145 TEST_F(ClientSocketPoolBaseTest, |
1138 InitConnectionAsynchronousFailure) { | 1146 InitConnectionAsynchronousFailure) { |
1139 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1147 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1140 | 1148 |
1141 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); | 1149 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob); |
1142 TestSocketRequest req(&request_order_, &completion_count_); | 1150 TestSocketRequest req(&request_order_, &completion_count_); |
1143 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 1151 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
1144 EXPECT_EQ(ERR_IO_PENDING, | 1152 EXPECT_EQ(ERR_IO_PENDING, |
1145 InitHandle(req.handle(), "a", kDefaultPriority, &req, | 1153 InitHandle(req.handle(), "a", kDefaultPriority, &req, |
1146 pool_.get(), log)); | 1154 pool_.get(), log.bound())); |
1147 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle())); | 1155 EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", req.handle())); |
1148 EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult()); | 1156 EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult()); |
1149 | 1157 |
1150 EXPECT_EQ(6u, log->entries().size()); | 1158 EXPECT_EQ(7u, log.entries().size()); |
1151 EXPECT_TRUE(LogContainsBeginEvent(*log, 0, LoadLog::TYPE_SOCKET_POOL)); | |
1152 EXPECT_TRUE(LogContainsBeginEvent( | 1159 EXPECT_TRUE(LogContainsBeginEvent( |
1153 *log, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 1160 log.entries(), 0, NetLog::TYPE_SOCKET_POOL)); |
| 1161 EXPECT_TRUE(LogContainsBeginEvent( |
| 1162 log.entries(), 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
1154 EXPECT_TRUE(LogContainsEndEvent( | 1163 EXPECT_TRUE(LogContainsEndEvent( |
1155 *log, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 1164 log.entries(), 2, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
1156 EXPECT_TRUE(LogContainsEvent( | 1165 EXPECT_TRUE(LogContainsEvent( |
1157 *log, 3, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | 1166 log.entries(), 3, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE)); |
1158 EXPECT_TRUE(LogContainsEndEvent( | 1167 EXPECT_TRUE(LogContainsEndEvent( |
1159 *log, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | 1168 log.entries(), 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
1160 EXPECT_TRUE(LogContainsEndEvent( | 1169 EXPECT_TRUE(LogContainsEndEvent( |
1161 *log, 5, LoadLog::TYPE_SOCKET_POOL)); | 1170 log.entries(), 6, NetLog::TYPE_SOCKET_POOL)); |
1162 } | 1171 } |
1163 | 1172 |
1164 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) { | 1173 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) { |
1165 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1174 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1166 | 1175 |
1167 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1176 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1168 TestSocketRequest req(&request_order_, &completion_count_); | 1177 TestSocketRequest req(&request_order_, &completion_count_); |
1169 TestSocketRequest req2(&request_order_, &completion_count_); | 1178 TestSocketRequest req2(&request_order_, &completion_count_); |
1170 | 1179 |
1171 scoped_refptr<LoadLog> log1(new LoadLog(LoadLog::kUnbounded)); | 1180 CapturingBoundNetLog log1(CapturingNetLog::kUnbounded); |
1172 EXPECT_EQ(ERR_IO_PENDING, | 1181 EXPECT_EQ(ERR_IO_PENDING, |
1173 InitHandle(req.handle(), "a", kDefaultPriority, &req, | 1182 InitHandle(req.handle(), "a", kDefaultPriority, &req, |
1174 pool_.get(), log1)); | 1183 pool_.get(), log1.bound())); |
1175 scoped_refptr<LoadLog> log2(new LoadLog(LoadLog::kUnbounded)); | 1184 CapturingBoundNetLog log2(CapturingNetLog::kUnbounded); |
1176 EXPECT_EQ(ERR_IO_PENDING, | 1185 EXPECT_EQ(ERR_IO_PENDING, |
1177 InitHandle(req2.handle(), "a", kDefaultPriority, &req2, | 1186 InitHandle(req2.handle(), "a", kDefaultPriority, &req2, |
1178 pool_.get(), log2)); | 1187 pool_.get(), log2.bound())); |
1179 | 1188 |
1180 req.handle()->Reset(); | 1189 req.handle()->Reset(); |
1181 | 1190 |
1182 EXPECT_EQ(3u, log1->entries().size()); | 1191 EXPECT_EQ(4u, log1.entries().size()); |
1183 EXPECT_TRUE(LogContainsBeginEvent(*log1, 0, LoadLog::TYPE_SOCKET_POOL)); | 1192 EXPECT_TRUE(LogContainsBeginEvent( |
| 1193 log1.entries(), 0, NetLog::TYPE_SOCKET_POOL)); |
| 1194 EXPECT_TRUE(LogContainsBeginEvent( |
| 1195 log1.entries(), 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB)); |
1184 EXPECT_TRUE(LogContainsEvent( | 1196 EXPECT_TRUE(LogContainsEvent( |
1185 *log1, 1, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | 1197 log1.entries(), 2, NetLog::TYPE_CANCELLED, NetLog::PHASE_NONE)); |
1186 EXPECT_TRUE(LogContainsEndEvent(*log1, 2, LoadLog::TYPE_SOCKET_POOL)); | 1198 EXPECT_TRUE(LogContainsEndEvent(log1.entries(), 3, NetLog::TYPE_SOCKET_POOL)); |
1187 | 1199 |
1188 // At this point, request 2 is just waiting for the connect job to finish. | 1200 // At this point, request 2 is just waiting for the connect job to finish. |
1189 EXPECT_EQ(1u, log2->entries().size()); | |
1190 EXPECT_TRUE(LogContainsBeginEvent(*log2, 0, LoadLog::TYPE_SOCKET_POOL)); | |
1191 | 1201 |
1192 EXPECT_EQ(OK, req2.WaitForResult()); | 1202 EXPECT_EQ(OK, req2.WaitForResult()); |
1193 req2.handle()->Reset(); | 1203 req2.handle()->Reset(); |
1194 | 1204 |
1195 // Now request 2 has actually finished. | 1205 // Now request 2 has actually finished. |
1196 EXPECT_EQ(6u, log2->entries().size()); | 1206 // TODO(eroman): Add back log expectations. |
1197 EXPECT_TRUE(LogContainsBeginEvent(*log2, 0, LoadLog::TYPE_SOCKET_POOL)); | |
1198 EXPECT_TRUE(LogContainsBeginEvent( | |
1199 *log2, 1, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | |
1200 EXPECT_TRUE(LogContainsEndEvent( | |
1201 *log2, 2, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | |
1202 EXPECT_TRUE(LogContainsEvent( | |
1203 *log2, 3, LoadLog::TYPE_CANCELLED, LoadLog::PHASE_NONE)); | |
1204 EXPECT_TRUE(LogContainsEndEvent( | |
1205 *log2, 4, LoadLog::TYPE_SOCKET_POOL_CONNECT_JOB)); | |
1206 EXPECT_TRUE(LogContainsEndEvent( | |
1207 *log2, 5, LoadLog::TYPE_SOCKET_POOL)); | |
1208 | |
1209 } | 1207 } |
1210 | 1208 |
1211 TEST_F(ClientSocketPoolBaseTest, CancelRequestLimitsJobs) { | 1209 TEST_F(ClientSocketPoolBaseTest, CancelRequestLimitsJobs) { |
1212 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); | 1210 CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup); |
1213 | 1211 |
1214 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); | 1212 connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob); |
1215 | 1213 |
1216 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); | 1214 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); |
1217 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); | 1215 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); |
1218 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); | 1216 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); |
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1368 // soon-to-be-pending tasks waiting. | 1366 // soon-to-be-pending tasks waiting. |
1369 PlatformThread::Sleep(10); | 1367 PlatformThread::Sleep(10); |
1370 MessageLoop::current()->RunAllPending(); | 1368 MessageLoop::current()->RunAllPending(); |
1371 | 1369 |
1372 ASSERT_EQ(2, pool_->IdleSocketCount()); | 1370 ASSERT_EQ(2, pool_->IdleSocketCount()); |
1373 | 1371 |
1374 // Invoke the idle socket cleanup check. Only one socket should be left, the | 1372 // Invoke the idle socket cleanup check. Only one socket should be left, the |
1375 // used socket. Request it to make sure that it's used. | 1373 // used socket. Request it to make sure that it's used. |
1376 | 1374 |
1377 pool_->CleanupTimedOutIdleSockets(); | 1375 pool_->CleanupTimedOutIdleSockets(); |
1378 scoped_refptr<LoadLog> log(new LoadLog(LoadLog::kUnbounded)); | 1376 CapturingBoundNetLog log(CapturingNetLog::kUnbounded); |
1379 rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), log); | 1377 rv = InitHandle(req.handle(), "a", LOWEST, &req, pool_.get(), log.bound()); |
1380 EXPECT_EQ(OK, rv); | 1378 EXPECT_EQ(OK, rv); |
1381 EXPECT_TRUE(req.handle()->is_reused()); | 1379 EXPECT_TRUE(req.handle()->is_reused()); |
1382 EXPECT_TRUE(LogContainsEntryWithType( | 1380 EXPECT_TRUE(LogContainsEntryWithType( |
1383 *log, 1, LoadLog::Entry::TYPE_STRING_LITERAL)) | 1381 log.entries(), 1, NetLog::Entry::TYPE_STRING_LITERAL)); |
1384 << LoadLogUtil::PrettyPrintAsEventTree(log); | |
1385 } | 1382 } |
1386 | 1383 |
1387 // Make sure that we process all pending requests even when we're stalling | 1384 // Make sure that we process all pending requests even when we're stalling |
1388 // because of multiple releasing disconnected sockets. | 1385 // because of multiple releasing disconnected sockets. |
1389 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) { | 1386 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) { |
1390 CreatePoolWithIdleTimeouts( | 1387 CreatePoolWithIdleTimeouts( |
1391 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, | 1388 kDefaultMaxSockets, kDefaultMaxSocketsPerGroup, |
1392 base::TimeDelta(), // Time out unused sockets immediately. | 1389 base::TimeDelta(), // Time out unused sockets immediately. |
1393 base::TimeDelta::FromDays(1)); // Don't time out used sockets. | 1390 base::TimeDelta::FromDays(1)); // Don't time out used sockets. |
1394 | 1391 |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1506 EXPECT_EQ(ERR_IO_PENDING, | 1503 EXPECT_EQ(ERR_IO_PENDING, |
1507 InitHandle(request.handle(), "a", kDefaultPriority, &request, | 1504 InitHandle(request.handle(), "a", kDefaultPriority, &request, |
1508 pool_.get(), NULL)); | 1505 pool_.get(), NULL)); |
1509 | 1506 |
1510 EXPECT_EQ(OK, request.WaitForResult()); | 1507 EXPECT_EQ(OK, request.WaitForResult()); |
1511 } | 1508 } |
1512 | 1509 |
1513 } // namespace | 1510 } // namespace |
1514 | 1511 |
1515 } // namespace net | 1512 } // namespace net |
OLD | NEW |