OLD | NEW |
---|---|
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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/transport_client_socket_pool.h" | 5 #include "net/socket/transport_client_socket_pool.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
csilv
2011/12/14 20:10:19
#include base/bind.h, base/bind_helpers.h
James Hawkins
2011/12/14 20:59:05
Done.
| |
8 #include "base/compiler_specific.h" | 8 #include "base/compiler_specific.h" |
9 #include "base/logging.h" | 9 #include "base/logging.h" |
10 #include "base/message_loop.h" | 10 #include "base/message_loop.h" |
11 #include "base/threading/platform_thread.h" | 11 #include "base/threading/platform_thread.h" |
12 #include "net/base/ip_endpoint.h" | 12 #include "net/base/ip_endpoint.h" |
13 #include "net/base/mock_host_resolver.h" | 13 #include "net/base/mock_host_resolver.h" |
14 #include "net/base/net_errors.h" | 14 #include "net/base/net_errors.h" |
15 #include "net/base/net_util.h" | 15 #include "net/base/net_util.h" |
16 #include "net/base/sys_addrinfo.h" | 16 #include "net/base/sys_addrinfo.h" |
17 #include "net/base/test_completion_callback.h" | 17 #include "net/base/test_completion_callback.h" |
(...skipping 476 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
494 ai = ai->ai_next; | 494 ai = ai->ai_next; |
495 EXPECT_EQ(AF_INET, ai->ai_family); | 495 EXPECT_EQ(AF_INET, ai->ai_family); |
496 ai = ai->ai_next; | 496 ai = ai->ai_next; |
497 EXPECT_EQ(AF_INET6, ai->ai_family); | 497 EXPECT_EQ(AF_INET6, ai->ai_family); |
498 ai = ai->ai_next; | 498 ai = ai->ai_next; |
499 EXPECT_EQ(AF_INET6, ai->ai_family); | 499 EXPECT_EQ(AF_INET6, ai->ai_family); |
500 EXPECT_TRUE(ai->ai_next == NULL); | 500 EXPECT_TRUE(ai->ai_next == NULL); |
501 } | 501 } |
502 | 502 |
503 TEST_F(TransportClientSocketPoolTest, Basic) { | 503 TEST_F(TransportClientSocketPoolTest, Basic) { |
504 TestOldCompletionCallback callback; | 504 TestCompletionCallback callback; |
505 ClientSocketHandle handle; | 505 ClientSocketHandle handle; |
506 int rv = handle.Init("a", low_params_, LOW, &callback, &pool_, BoundNetLog()); | 506 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_, |
507 BoundNetLog()); | |
507 EXPECT_EQ(ERR_IO_PENDING, rv); | 508 EXPECT_EQ(ERR_IO_PENDING, rv); |
508 EXPECT_FALSE(handle.is_initialized()); | 509 EXPECT_FALSE(handle.is_initialized()); |
509 EXPECT_FALSE(handle.socket()); | 510 EXPECT_FALSE(handle.socket()); |
510 | 511 |
511 EXPECT_EQ(OK, callback.WaitForResult()); | 512 EXPECT_EQ(OK, callback.WaitForResult()); |
512 EXPECT_TRUE(handle.is_initialized()); | 513 EXPECT_TRUE(handle.is_initialized()); |
513 EXPECT_TRUE(handle.socket()); | 514 EXPECT_TRUE(handle.socket()); |
514 | 515 |
515 handle.Reset(); | 516 handle.Reset(); |
516 } | 517 } |
517 | 518 |
518 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) { | 519 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) { |
519 host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name"); | 520 host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name"); |
520 TestOldCompletionCallback callback; | 521 TestCompletionCallback callback; |
521 ClientSocketHandle handle; | 522 ClientSocketHandle handle; |
522 HostPortPair host_port_pair("unresolvable.host.name", 80); | 523 HostPortPair host_port_pair("unresolvable.host.name", 80); |
523 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( | 524 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( |
524 host_port_pair, kDefaultPriority, false, false)); | 525 host_port_pair, kDefaultPriority, false, false)); |
525 EXPECT_EQ(ERR_IO_PENDING, | 526 EXPECT_EQ(ERR_IO_PENDING, |
526 handle.Init("a", dest, kDefaultPriority, &callback, &pool_, | 527 handle.Init("a", dest, kDefaultPriority, callback.callback(), |
527 BoundNetLog())); | 528 &pool_, BoundNetLog())); |
528 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult()); | 529 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult()); |
529 } | 530 } |
530 | 531 |
531 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) { | 532 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) { |
532 client_socket_factory_.set_client_socket_type( | 533 client_socket_factory_.set_client_socket_type( |
533 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET); | 534 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET); |
534 TestOldCompletionCallback callback; | 535 TestCompletionCallback callback; |
535 ClientSocketHandle handle; | 536 ClientSocketHandle handle; |
536 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority, | 537 EXPECT_EQ(ERR_IO_PENDING, |
537 &callback, &pool_, BoundNetLog())); | 538 handle.Init("a", params_, kDefaultPriority, callback.callback(), |
539 &pool_, BoundNetLog())); | |
538 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); | 540 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); |
539 | 541 |
540 // Make the host resolutions complete synchronously this time. | 542 // Make the host resolutions complete synchronously this time. |
541 host_resolver_->set_synchronous_mode(true); | 543 host_resolver_->set_synchronous_mode(true); |
542 EXPECT_EQ(ERR_CONNECTION_FAILED, handle.Init("a", params_, | 544 EXPECT_EQ(ERR_CONNECTION_FAILED, |
543 kDefaultPriority, &callback, | 545 handle.Init("a", params_, kDefaultPriority, callback.callback(), |
544 &pool_, BoundNetLog())); | 546 &pool_, BoundNetLog())); |
545 } | 547 } |
546 | 548 |
547 TEST_F(TransportClientSocketPoolTest, PendingRequests) { | 549 TEST_F(TransportClientSocketPoolTest, PendingRequests) { |
548 // First request finishes asynchronously. | 550 // First request finishes asynchronously. |
549 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 551 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
550 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); | 552 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); |
551 | 553 |
552 // Make all subsequent host resolutions complete synchronously. | 554 // Make all subsequent host resolutions complete synchronously. |
553 host_resolver_->set_synchronous_mode(true); | 555 host_resolver_->set_synchronous_mode(true); |
554 | 556 |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
637 client_socket_factory_.allocation_count()); | 639 client_socket_factory_.allocation_count()); |
638 | 640 |
639 // First asynchronous request, and then last 5 pending requests. | 641 // First asynchronous request, and then last 5 pending requests. |
640 EXPECT_EQ(6U, completion_count()); | 642 EXPECT_EQ(6U, completion_count()); |
641 } | 643 } |
642 | 644 |
643 // This test will start up a RequestSocket() and then immediately Cancel() it. | 645 // This test will start up a RequestSocket() and then immediately Cancel() it. |
644 // The pending host resolution will eventually complete, and destroy the | 646 // The pending host resolution will eventually complete, and destroy the |
645 // ClientSocketPool which will crash if the group was not cleared properly. | 647 // ClientSocketPool which will crash if the group was not cleared properly. |
646 TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) { | 648 TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) { |
647 TestOldCompletionCallback callback; | 649 TestCompletionCallback callback; |
648 ClientSocketHandle handle; | 650 ClientSocketHandle handle; |
649 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority, | 651 EXPECT_EQ(ERR_IO_PENDING, |
650 &callback, &pool_, BoundNetLog())); | 652 handle.Init("a", params_, kDefaultPriority, callback.callback(), |
653 &pool_, BoundNetLog())); | |
651 handle.Reset(); | 654 handle.Reset(); |
652 } | 655 } |
653 | 656 |
654 TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) { | 657 TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) { |
655 ClientSocketHandle handle; | 658 ClientSocketHandle handle; |
656 TestOldCompletionCallback callback; | 659 TestCompletionCallback callback; |
657 ClientSocketHandle handle2; | 660 ClientSocketHandle handle2; |
658 TestOldCompletionCallback callback2; | 661 TestCompletionCallback callback2; |
659 | 662 |
660 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority, | 663 EXPECT_EQ(ERR_IO_PENDING, |
661 &callback, &pool_, BoundNetLog())); | 664 handle.Init("a", params_, kDefaultPriority, callback.callback(), |
662 EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a", params_, kDefaultPriority, | 665 &pool_, BoundNetLog())); |
663 &callback2, &pool_, BoundNetLog())); | 666 EXPECT_EQ(ERR_IO_PENDING, |
667 handle2.Init("a", params_, kDefaultPriority, callback2.callback(), | |
668 &pool_, BoundNetLog())); | |
664 | 669 |
665 handle.Reset(); | 670 handle.Reset(); |
666 | 671 |
667 EXPECT_EQ(OK, callback2.WaitForResult()); | 672 EXPECT_EQ(OK, callback2.WaitForResult()); |
668 handle2.Reset(); | 673 handle2.Reset(); |
669 } | 674 } |
670 | 675 |
671 TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) { | 676 TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) { |
672 client_socket_factory_.set_client_socket_type( | 677 client_socket_factory_.set_client_socket_type( |
673 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); | 678 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); |
674 ClientSocketHandle handle; | 679 ClientSocketHandle handle; |
675 TestOldCompletionCallback callback; | 680 TestCompletionCallback callback; |
676 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority, | 681 EXPECT_EQ(ERR_IO_PENDING, |
677 &callback, &pool_, BoundNetLog())); | 682 handle.Init("a", params_, kDefaultPriority, callback.callback(), |
683 &pool_, BoundNetLog())); | |
678 | 684 |
679 handle.Reset(); | 685 handle.Reset(); |
680 | 686 |
681 TestOldCompletionCallback callback2; | 687 TestCompletionCallback callback2; |
682 EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, kDefaultPriority, | 688 EXPECT_EQ(ERR_IO_PENDING, |
683 &callback2, &pool_, BoundNetLog())); | 689 handle.Init("a", params_, kDefaultPriority, callback2.callback(), |
690 &pool_, BoundNetLog())); | |
684 | 691 |
685 host_resolver_->set_synchronous_mode(true); | 692 host_resolver_->set_synchronous_mode(true); |
686 // At this point, handle has two ConnectingSockets out for it. Due to the | 693 // At this point, handle has two ConnectingSockets out for it. Due to the |
687 // setting the mock resolver into synchronous mode, the host resolution for | 694 // setting the mock resolver into synchronous mode, the host resolution for |
688 // both will return in the same loop of the MessageLoop. The client socket | 695 // both will return in the same loop of the MessageLoop. The client socket |
689 // is a pending socket, so the Connect() will asynchronously complete on the | 696 // is a pending socket, so the Connect() will asynchronously complete on the |
690 // next loop of the MessageLoop. That means that the first | 697 // next loop of the MessageLoop. That means that the first |
691 // ConnectingSocket will enter OnIOComplete, and then the second one will. | 698 // ConnectingSocket will enter OnIOComplete, and then the second one will. |
692 // If the first one is not cancelled, it will advance the load state, and | 699 // If the first one is not cancelled, it will advance the load state, and |
693 // then the second one will crash. | 700 // then the second one will crash. |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
750 EXPECT_EQ(11, GetOrderOfRequest(12)); | 757 EXPECT_EQ(11, GetOrderOfRequest(12)); |
751 EXPECT_EQ(8, GetOrderOfRequest(13)); | 758 EXPECT_EQ(8, GetOrderOfRequest(13)); |
752 EXPECT_EQ(12, GetOrderOfRequest(14)); | 759 EXPECT_EQ(12, GetOrderOfRequest(14)); |
753 EXPECT_EQ(13, GetOrderOfRequest(15)); | 760 EXPECT_EQ(13, GetOrderOfRequest(15)); |
754 EXPECT_EQ(15, GetOrderOfRequest(16)); | 761 EXPECT_EQ(15, GetOrderOfRequest(16)); |
755 | 762 |
756 // Make sure we test order of all requests made. | 763 // Make sure we test order of all requests made. |
757 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); | 764 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); |
758 } | 765 } |
759 | 766 |
760 class RequestSocketCallback : public CallbackRunner< Tuple1<int> > { | 767 class RequestSocketCallback : public TestCompletionCallbackBase { |
761 public: | 768 public: |
762 RequestSocketCallback(ClientSocketHandle* handle, | 769 RequestSocketCallback(ClientSocketHandle* handle, |
763 TransportClientSocketPool* pool) | 770 TransportClientSocketPool* pool) |
764 : handle_(handle), | 771 : handle_(handle), |
765 pool_(pool), | 772 pool_(pool), |
766 within_callback_(false) {} | 773 within_callback_(false), |
774 ALLOW_THIS_IN_INITIALIZER_LIST(callback_( | |
775 base::Bind(&RequestSocketCallback::OnComplete, | |
776 base::Unretained(this)))) { | |
777 } | |
767 | 778 |
768 virtual void RunWithParams(const Tuple1<int>& params) { | 779 virtual ~RequestSocketCallback() {} |
769 callback_.RunWithParams(params); | 780 |
770 ASSERT_EQ(OK, params.a); | 781 const CompletionCallback& callback() const { return callback_; } |
782 | |
783 private: | |
784 void OnComplete(int result) { | |
785 ASSERT_EQ(OK, result); | |
771 | 786 |
772 if (!within_callback_) { | 787 if (!within_callback_) { |
773 // Don't allow reuse of the socket. Disconnect it and then release it and | 788 // Don't allow reuse of the socket. Disconnect it and then release it and |
774 // run through the MessageLoop once to get it completely released. | 789 // run through the MessageLoop once to get it completely released. |
775 handle_->socket()->Disconnect(); | 790 handle_->socket()->Disconnect(); |
776 handle_->Reset(); | 791 handle_->Reset(); |
777 { | 792 { |
778 MessageLoop::ScopedNestableTaskAllower nestable( | 793 MessageLoop::ScopedNestableTaskAllower nestable( |
779 MessageLoop::current()); | 794 MessageLoop::current()); |
780 MessageLoop::current()->RunAllPending(); | 795 MessageLoop::current()->RunAllPending(); |
781 } | 796 } |
782 within_callback_ = true; | 797 within_callback_ = true; |
783 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( | 798 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( |
784 HostPortPair("www.google.com", 80), LOWEST, false, false)); | 799 HostPortPair("www.google.com", 80), LOWEST, false, false)); |
785 int rv = handle_->Init("a", dest, LOWEST, this, pool_, BoundNetLog()); | 800 int rv = handle_->Init("a", dest, LOWEST, callback(), pool_, |
801 BoundNetLog()); | |
786 EXPECT_EQ(OK, rv); | 802 EXPECT_EQ(OK, rv); |
787 } | 803 } |
788 } | 804 } |
789 | 805 |
790 int WaitForResult() { | |
791 return callback_.WaitForResult(); | |
792 } | |
793 | |
794 private: | |
795 ClientSocketHandle* const handle_; | 806 ClientSocketHandle* const handle_; |
796 TransportClientSocketPool* const pool_; | 807 TransportClientSocketPool* const pool_; |
797 bool within_callback_; | 808 bool within_callback_; |
798 TestOldCompletionCallback callback_; | 809 CompletionCallback callback_; |
810 | |
811 DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback); | |
799 }; | 812 }; |
800 | 813 |
801 TEST_F(TransportClientSocketPoolTest, RequestTwice) { | 814 TEST_F(TransportClientSocketPoolTest, RequestTwice) { |
802 ClientSocketHandle handle; | 815 ClientSocketHandle handle; |
803 RequestSocketCallback callback(&handle, &pool_); | 816 RequestSocketCallback callback(&handle, &pool_); |
804 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( | 817 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( |
805 HostPortPair("www.google.com", 80), LOWEST, false, false)); | 818 HostPortPair("www.google.com", 80), LOWEST, false, false)); |
806 int rv = handle.Init("a", dest, LOWEST, &callback, &pool_, | 819 int rv = handle.Init("a", dest, LOWEST, callback.callback(), &pool_, |
807 BoundNetLog()); | 820 BoundNetLog()); |
808 ASSERT_EQ(ERR_IO_PENDING, rv); | 821 ASSERT_EQ(ERR_IO_PENDING, rv); |
809 | 822 |
810 // The callback is going to request "www.google.com". We want it to complete | 823 // The callback is going to request "www.google.com". We want it to complete |
811 // synchronously this time. | 824 // synchronously this time. |
812 host_resolver_->set_synchronous_mode(true); | 825 host_resolver_->set_synchronous_mode(true); |
813 | 826 |
814 EXPECT_EQ(OK, callback.WaitForResult()); | 827 EXPECT_EQ(OK, callback.WaitForResult()); |
815 | 828 |
816 handle.Reset(); | 829 handle.Reset(); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
857 | 870 |
858 // Queue up all the requests | 871 // Queue up all the requests |
859 for (int i = 0; i < kNumRequests; i++) | 872 for (int i = 0; i < kNumRequests; i++) |
860 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); | 873 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); |
861 | 874 |
862 for (int i = 0; i < kNumRequests; i++) | 875 for (int i = 0; i < kNumRequests; i++) |
863 EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult()); | 876 EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult()); |
864 } | 877 } |
865 | 878 |
866 TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) { | 879 TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) { |
867 TestOldCompletionCallback callback; | 880 TestCompletionCallback callback; |
868 ClientSocketHandle handle; | 881 ClientSocketHandle handle; |
869 int rv = handle.Init("a", low_params_, LOW, &callback, &pool_, BoundNetLog()); | 882 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_, |
883 BoundNetLog()); | |
870 EXPECT_EQ(ERR_IO_PENDING, rv); | 884 EXPECT_EQ(ERR_IO_PENDING, rv); |
871 EXPECT_FALSE(handle.is_initialized()); | 885 EXPECT_FALSE(handle.is_initialized()); |
872 EXPECT_FALSE(handle.socket()); | 886 EXPECT_FALSE(handle.socket()); |
873 | 887 |
874 EXPECT_EQ(OK, callback.WaitForResult()); | 888 EXPECT_EQ(OK, callback.WaitForResult()); |
875 EXPECT_TRUE(handle.is_initialized()); | 889 EXPECT_TRUE(handle.is_initialized()); |
876 EXPECT_TRUE(handle.socket()); | 890 EXPECT_TRUE(handle.socket()); |
877 | 891 |
878 handle.Reset(); | 892 handle.Reset(); |
879 | 893 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
912 MockClientSocketFactory::ClientSocketType* cases[2] = { | 926 MockClientSocketFactory::ClientSocketType* cases[2] = { |
913 case1_types, | 927 case1_types, |
914 case2_types | 928 case2_types |
915 }; | 929 }; |
916 | 930 |
917 for (size_t index = 0; index < arraysize(cases); ++index) { | 931 for (size_t index = 0; index < arraysize(cases); ++index) { |
918 client_socket_factory_.set_client_socket_types(cases[index], 2); | 932 client_socket_factory_.set_client_socket_types(cases[index], 2); |
919 | 933 |
920 EXPECT_EQ(0, pool_.IdleSocketCount()); | 934 EXPECT_EQ(0, pool_.IdleSocketCount()); |
921 | 935 |
922 TestOldCompletionCallback callback; | 936 TestCompletionCallback callback; |
923 ClientSocketHandle handle; | 937 ClientSocketHandle handle; |
924 int rv = handle.Init("b", low_params_, LOW, &callback, &pool_, | 938 int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_, |
925 BoundNetLog()); | 939 BoundNetLog()); |
926 EXPECT_EQ(ERR_IO_PENDING, rv); | 940 EXPECT_EQ(ERR_IO_PENDING, rv); |
927 EXPECT_FALSE(handle.is_initialized()); | 941 EXPECT_FALSE(handle.is_initialized()); |
928 EXPECT_FALSE(handle.socket()); | 942 EXPECT_FALSE(handle.socket()); |
929 | 943 |
930 // Create the first socket, set the timer. | 944 // Create the first socket, set the timer. |
931 MessageLoop::current()->RunAllPending(); | 945 MessageLoop::current()->RunAllPending(); |
932 | 946 |
933 // Wait for the backup socket timer to fire. | 947 // Wait for the backup socket timer to fire. |
934 base::PlatformThread::Sleep( | 948 base::PlatformThread::Sleep( |
(...skipping 19 matching lines...) Expand all Loading... | |
954 // of the backup socket, but then we cancelled the request after that. | 968 // of the backup socket, but then we cancelled the request after that. |
955 TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) { | 969 TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) { |
956 client_socket_factory_.set_client_socket_type( | 970 client_socket_factory_.set_client_socket_type( |
957 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET); | 971 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET); |
958 | 972 |
959 enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT }; | 973 enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT }; |
960 | 974 |
961 for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) { | 975 for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) { |
962 EXPECT_EQ(0, pool_.IdleSocketCount()); | 976 EXPECT_EQ(0, pool_.IdleSocketCount()); |
963 | 977 |
964 TestOldCompletionCallback callback; | 978 TestCompletionCallback callback; |
965 ClientSocketHandle handle; | 979 ClientSocketHandle handle; |
966 int rv = handle.Init("c", low_params_, LOW, &callback, &pool_, | 980 int rv = handle.Init("c", low_params_, LOW, callback.callback(), &pool_, |
967 BoundNetLog()); | 981 BoundNetLog()); |
968 EXPECT_EQ(ERR_IO_PENDING, rv); | 982 EXPECT_EQ(ERR_IO_PENDING, rv); |
969 EXPECT_FALSE(handle.is_initialized()); | 983 EXPECT_FALSE(handle.is_initialized()); |
970 EXPECT_FALSE(handle.socket()); | 984 EXPECT_FALSE(handle.socket()); |
971 | 985 |
972 // Create the first socket, set the timer. | 986 // Create the first socket, set the timer. |
973 MessageLoop::current()->RunAllPending(); | 987 MessageLoop::current()->RunAllPending(); |
974 | 988 |
975 if (index == CANCEL_AFTER_WAIT) { | 989 if (index == CANCEL_AFTER_WAIT) { |
976 // Wait for the backup socket timer to fire. | 990 // Wait for the backup socket timer to fire. |
(...skipping 22 matching lines...) Expand all Loading... | |
999 // The first socket will not connect. | 1013 // The first socket will not connect. |
1000 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, | 1014 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, |
1001 // The second socket will fail immediately. | 1015 // The second socket will fail immediately. |
1002 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET | 1016 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET |
1003 }; | 1017 }; |
1004 | 1018 |
1005 client_socket_factory_.set_client_socket_types(case_types, 2); | 1019 client_socket_factory_.set_client_socket_types(case_types, 2); |
1006 | 1020 |
1007 EXPECT_EQ(0, pool_.IdleSocketCount()); | 1021 EXPECT_EQ(0, pool_.IdleSocketCount()); |
1008 | 1022 |
1009 TestOldCompletionCallback callback; | 1023 TestCompletionCallback callback; |
1010 ClientSocketHandle handle; | 1024 ClientSocketHandle handle; |
1011 int rv = handle.Init("b", low_params_, LOW, &callback, &pool_, BoundNetLog()); | 1025 int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_, |
1026 BoundNetLog()); | |
1012 EXPECT_EQ(ERR_IO_PENDING, rv); | 1027 EXPECT_EQ(ERR_IO_PENDING, rv); |
1013 EXPECT_FALSE(handle.is_initialized()); | 1028 EXPECT_FALSE(handle.is_initialized()); |
1014 EXPECT_FALSE(handle.socket()); | 1029 EXPECT_FALSE(handle.socket()); |
1015 | 1030 |
1016 // Create the first socket, set the timer. | 1031 // Create the first socket, set the timer. |
1017 MessageLoop::current()->RunAllPending(); | 1032 MessageLoop::current()->RunAllPending(); |
1018 | 1033 |
1019 // Wait for the backup socket timer to fire. | 1034 // Wait for the backup socket timer to fire. |
1020 base::PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs); | 1035 base::PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs); |
1021 | 1036 |
(...skipping 23 matching lines...) Expand all Loading... | |
1045 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, | 1060 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, |
1046 // The second socket will not connect. | 1061 // The second socket will not connect. |
1047 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET | 1062 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET |
1048 }; | 1063 }; |
1049 | 1064 |
1050 client_socket_factory_.set_client_socket_types(case_types, 2); | 1065 client_socket_factory_.set_client_socket_types(case_types, 2); |
1051 client_socket_factory_.set_delay_ms(5000); | 1066 client_socket_factory_.set_delay_ms(5000); |
1052 | 1067 |
1053 EXPECT_EQ(0, pool_.IdleSocketCount()); | 1068 EXPECT_EQ(0, pool_.IdleSocketCount()); |
1054 | 1069 |
1055 TestOldCompletionCallback callback; | 1070 TestCompletionCallback callback; |
1056 ClientSocketHandle handle; | 1071 ClientSocketHandle handle; |
1057 int rv = handle.Init("b", low_params_, LOW, &callback, &pool_, BoundNetLog()); | 1072 int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_, |
1073 BoundNetLog()); | |
1058 EXPECT_EQ(ERR_IO_PENDING, rv); | 1074 EXPECT_EQ(ERR_IO_PENDING, rv); |
1059 EXPECT_FALSE(handle.is_initialized()); | 1075 EXPECT_FALSE(handle.is_initialized()); |
1060 EXPECT_FALSE(handle.socket()); | 1076 EXPECT_FALSE(handle.socket()); |
1061 | 1077 |
1062 // Create the first socket, set the timer. | 1078 // Create the first socket, set the timer. |
1063 MessageLoop::current()->RunAllPending(); | 1079 MessageLoop::current()->RunAllPending(); |
1064 | 1080 |
1065 // Wait for the backup socket timer to fire. | 1081 // Wait for the backup socket timer to fire. |
1066 base::PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs); | 1082 base::PlatformThread::Sleep(ClientSocketPool::kMaxConnectRetryIntervalMs); |
1067 | 1083 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1099 // This is the IPv4 socket. | 1115 // This is the IPv4 socket. |
1100 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET | 1116 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET |
1101 }; | 1117 }; |
1102 | 1118 |
1103 client_socket_factory_.set_client_socket_types(case_types, 2); | 1119 client_socket_factory_.set_client_socket_types(case_types, 2); |
1104 | 1120 |
1105 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. | 1121 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. |
1106 host_resolver_->rules()->AddIPLiteralRule( | 1122 host_resolver_->rules()->AddIPLiteralRule( |
1107 "*", "2:abcd::3:4:ff,2.2.2.2", ""); | 1123 "*", "2:abcd::3:4:ff,2.2.2.2", ""); |
1108 | 1124 |
1109 TestOldCompletionCallback callback; | 1125 TestCompletionCallback callback; |
1110 ClientSocketHandle handle; | 1126 ClientSocketHandle handle; |
1111 int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog()); | 1127 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, |
1128 BoundNetLog()); | |
1112 EXPECT_EQ(ERR_IO_PENDING, rv); | 1129 EXPECT_EQ(ERR_IO_PENDING, rv); |
1113 EXPECT_FALSE(handle.is_initialized()); | 1130 EXPECT_FALSE(handle.is_initialized()); |
1114 EXPECT_FALSE(handle.socket()); | 1131 EXPECT_FALSE(handle.socket()); |
1115 | 1132 |
1116 EXPECT_EQ(OK, callback.WaitForResult()); | 1133 EXPECT_EQ(OK, callback.WaitForResult()); |
1117 EXPECT_TRUE(handle.is_initialized()); | 1134 EXPECT_TRUE(handle.is_initialized()); |
1118 EXPECT_TRUE(handle.socket()); | 1135 EXPECT_TRUE(handle.socket()); |
1119 IPEndPoint endpoint; | 1136 IPEndPoint endpoint; |
1120 handle.socket()->GetLocalAddress(&endpoint); | 1137 handle.socket()->GetLocalAddress(&endpoint); |
1121 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); | 1138 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); |
(...skipping 21 matching lines...) Expand all Loading... | |
1143 }; | 1160 }; |
1144 | 1161 |
1145 client_socket_factory_.set_client_socket_types(case_types, 2); | 1162 client_socket_factory_.set_client_socket_types(case_types, 2); |
1146 client_socket_factory_.set_delay_ms( | 1163 client_socket_factory_.set_delay_ms( |
1147 TransportConnectJob::kIPv6FallbackTimerInMs + 50); | 1164 TransportConnectJob::kIPv6FallbackTimerInMs + 50); |
1148 | 1165 |
1149 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. | 1166 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. |
1150 host_resolver_->rules()->AddIPLiteralRule( | 1167 host_resolver_->rules()->AddIPLiteralRule( |
1151 "*", "2:abcd::3:4:ff,2.2.2.2", ""); | 1168 "*", "2:abcd::3:4:ff,2.2.2.2", ""); |
1152 | 1169 |
1153 TestOldCompletionCallback callback; | 1170 TestCompletionCallback callback; |
1154 ClientSocketHandle handle; | 1171 ClientSocketHandle handle; |
1155 int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog()); | 1172 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, |
1173 BoundNetLog()); | |
1156 EXPECT_EQ(ERR_IO_PENDING, rv); | 1174 EXPECT_EQ(ERR_IO_PENDING, rv); |
1157 EXPECT_FALSE(handle.is_initialized()); | 1175 EXPECT_FALSE(handle.is_initialized()); |
1158 EXPECT_FALSE(handle.socket()); | 1176 EXPECT_FALSE(handle.socket()); |
1159 | 1177 |
1160 EXPECT_EQ(OK, callback.WaitForResult()); | 1178 EXPECT_EQ(OK, callback.WaitForResult()); |
1161 EXPECT_TRUE(handle.is_initialized()); | 1179 EXPECT_TRUE(handle.is_initialized()); |
1162 EXPECT_TRUE(handle.socket()); | 1180 EXPECT_TRUE(handle.socket()); |
1163 IPEndPoint endpoint; | 1181 IPEndPoint endpoint; |
1164 handle.socket()->GetLocalAddress(&endpoint); | 1182 handle.socket()->GetLocalAddress(&endpoint); |
1165 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); | 1183 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); |
(...skipping 10 matching lines...) Expand all Loading... | |
1176 &client_socket_factory_, | 1194 &client_socket_factory_, |
1177 NULL); | 1195 NULL); |
1178 | 1196 |
1179 client_socket_factory_.set_client_socket_type( | 1197 client_socket_factory_.set_client_socket_type( |
1180 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); | 1198 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); |
1181 | 1199 |
1182 // Resolve an AddressList with only IPv6 addresses. | 1200 // Resolve an AddressList with only IPv6 addresses. |
1183 host_resolver_->rules()->AddIPLiteralRule( | 1201 host_resolver_->rules()->AddIPLiteralRule( |
1184 "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", ""); | 1202 "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", ""); |
1185 | 1203 |
1186 TestOldCompletionCallback callback; | 1204 TestCompletionCallback callback; |
1187 ClientSocketHandle handle; | 1205 ClientSocketHandle handle; |
1188 int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog()); | 1206 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, |
1207 BoundNetLog()); | |
1189 EXPECT_EQ(ERR_IO_PENDING, rv); | 1208 EXPECT_EQ(ERR_IO_PENDING, rv); |
1190 EXPECT_FALSE(handle.is_initialized()); | 1209 EXPECT_FALSE(handle.is_initialized()); |
1191 EXPECT_FALSE(handle.socket()); | 1210 EXPECT_FALSE(handle.socket()); |
1192 | 1211 |
1193 EXPECT_EQ(OK, callback.WaitForResult()); | 1212 EXPECT_EQ(OK, callback.WaitForResult()); |
1194 EXPECT_TRUE(handle.is_initialized()); | 1213 EXPECT_TRUE(handle.is_initialized()); |
1195 EXPECT_TRUE(handle.socket()); | 1214 EXPECT_TRUE(handle.socket()); |
1196 IPEndPoint endpoint; | 1215 IPEndPoint endpoint; |
1197 handle.socket()->GetLocalAddress(&endpoint); | 1216 handle.socket()->GetLocalAddress(&endpoint); |
1198 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); | 1217 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); |
(...skipping 10 matching lines...) Expand all Loading... | |
1209 &client_socket_factory_, | 1228 &client_socket_factory_, |
1210 NULL); | 1229 NULL); |
1211 | 1230 |
1212 client_socket_factory_.set_client_socket_type( | 1231 client_socket_factory_.set_client_socket_type( |
1213 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); | 1232 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); |
1214 | 1233 |
1215 // Resolve an AddressList with only IPv4 addresses. | 1234 // Resolve an AddressList with only IPv4 addresses. |
1216 host_resolver_->rules()->AddIPLiteralRule( | 1235 host_resolver_->rules()->AddIPLiteralRule( |
1217 "*", "1.1.1.1", ""); | 1236 "*", "1.1.1.1", ""); |
1218 | 1237 |
1219 TestOldCompletionCallback callback; | 1238 TestCompletionCallback callback; |
1220 ClientSocketHandle handle; | 1239 ClientSocketHandle handle; |
1221 int rv = handle.Init("a", low_params_, LOW, &callback, &pool, BoundNetLog()); | 1240 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, |
1241 BoundNetLog()); | |
1222 EXPECT_EQ(ERR_IO_PENDING, rv); | 1242 EXPECT_EQ(ERR_IO_PENDING, rv); |
1223 EXPECT_FALSE(handle.is_initialized()); | 1243 EXPECT_FALSE(handle.is_initialized()); |
1224 EXPECT_FALSE(handle.socket()); | 1244 EXPECT_FALSE(handle.socket()); |
1225 | 1245 |
1226 EXPECT_EQ(OK, callback.WaitForResult()); | 1246 EXPECT_EQ(OK, callback.WaitForResult()); |
1227 EXPECT_TRUE(handle.is_initialized()); | 1247 EXPECT_TRUE(handle.is_initialized()); |
1228 EXPECT_TRUE(handle.socket()); | 1248 EXPECT_TRUE(handle.socket()); |
1229 IPEndPoint endpoint; | 1249 IPEndPoint endpoint; |
1230 handle.socket()->GetLocalAddress(&endpoint); | 1250 handle.socket()->GetLocalAddress(&endpoint); |
1231 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); | 1251 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); |
1232 EXPECT_EQ(1, client_socket_factory_.allocation_count()); | 1252 EXPECT_EQ(1, client_socket_factory_.allocation_count()); |
1233 } | 1253 } |
1234 | 1254 |
1235 } // namespace | 1255 } // namespace |
1236 | 1256 |
1237 } // namespace net | 1257 } // namespace net |
OLD | NEW |