OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 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/quic/chromium/quic_http_stream.h" | 5 #include "net/quic/chromium/quic_http_stream.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
42 #include "net/quic/core/crypto/quic_decrypter.h" | 42 #include "net/quic/core/crypto/quic_decrypter.h" |
43 #include "net/quic/core/crypto/quic_encrypter.h" | 43 #include "net/quic/core/crypto/quic_encrypter.h" |
44 #include "net/quic/core/quic_connection.h" | 44 #include "net/quic/core/quic_connection.h" |
45 #include "net/quic/core/quic_write_blocked_list.h" | 45 #include "net/quic/core/quic_write_blocked_list.h" |
46 #include "net/quic/core/spdy_utils.h" | 46 #include "net/quic/core/spdy_utils.h" |
47 #include "net/quic/platform/api/quic_string_piece.h" | 47 #include "net/quic/platform/api/quic_string_piece.h" |
48 #include "net/quic/test_tools/crypto_test_utils.h" | 48 #include "net/quic/test_tools/crypto_test_utils.h" |
49 #include "net/quic/test_tools/mock_clock.h" | 49 #include "net/quic/test_tools/mock_clock.h" |
50 #include "net/quic/test_tools/mock_random.h" | 50 #include "net/quic/test_tools/mock_random.h" |
51 #include "net/quic/test_tools/quic_connection_peer.h" | 51 #include "net/quic/test_tools/quic_connection_peer.h" |
| 52 #include "net/quic/test_tools/quic_spdy_session_peer.h" |
52 #include "net/quic/test_tools/quic_test_utils.h" | 53 #include "net/quic/test_tools/quic_test_utils.h" |
53 #include "net/socket/socket_performance_watcher.h" | 54 #include "net/socket/socket_performance_watcher.h" |
54 #include "net/socket/socket_test_util.h" | 55 #include "net/socket/socket_test_util.h" |
55 #include "net/spdy/chromium/spdy_http_utils.h" | 56 #include "net/spdy/chromium/spdy_http_utils.h" |
56 #include "net/spdy/core/spdy_frame_builder.h" | 57 #include "net/spdy/core/spdy_frame_builder.h" |
57 #include "net/spdy/core/spdy_framer.h" | 58 #include "net/spdy/core/spdy_framer.h" |
58 #include "net/spdy/core/spdy_protocol.h" | 59 #include "net/spdy/core/spdy_protocol.h" |
59 #include "net/test/cert_test_util.h" | 60 #include "net/test/cert_test_util.h" |
60 #include "net/test/gtest_util.h" | 61 #include "net/test/gtest_util.h" |
61 #include "net/test/test_data_directory.h" | 62 #include "net/test/test_data_directory.h" |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
192 PacketToWrite(IoMode mode, int rv) : mode(mode), packet(nullptr), rv(rv) {} | 193 PacketToWrite(IoMode mode, int rv) : mode(mode), packet(nullptr), rv(rv) {} |
193 IoMode mode; | 194 IoMode mode; |
194 QuicReceivedPacket* packet; | 195 QuicReceivedPacket* packet; |
195 int rv; | 196 int rv; |
196 }; | 197 }; |
197 | 198 |
198 QuicHttpStreamTest() | 199 QuicHttpStreamTest() |
199 : use_closing_stream_(false), | 200 : use_closing_stream_(false), |
200 crypto_config_(crypto_test_utils::ProofVerifierForTesting()), | 201 crypto_config_(crypto_test_utils::ProofVerifierForTesting()), |
201 read_buffer_(new IOBufferWithSize(4096)), | 202 read_buffer_(new IOBufferWithSize(4096)), |
202 promise_id_(kServerDataStreamId1), | 203 promise_id_(GetNthServerInitiatedStreamId(0)), |
203 stream_id_(kClientDataStreamId1), | 204 stream_id_(GetNthClientInitiatedStreamId(0)), |
204 connection_id_(2), | 205 connection_id_(2), |
205 client_maker_(GetParam(), | 206 client_maker_(GetParam(), |
206 connection_id_, | 207 connection_id_, |
207 &clock_, | 208 &clock_, |
208 kDefaultServerHostName, | 209 kDefaultServerHostName, |
209 Perspective::IS_CLIENT), | 210 Perspective::IS_CLIENT), |
210 server_maker_(GetParam(), | 211 server_maker_(GetParam(), |
211 connection_id_, | 212 connection_id_, |
212 &clock_, | 213 &clock_, |
213 kDefaultServerHostName, | 214 kDefaultServerHostName, |
(...skipping 327 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
541 if (session_reused) { | 542 if (session_reused) { |
542 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); | 543 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); |
543 } else { | 544 } else { |
544 ExpectConnectTimingHasTimes( | 545 ExpectConnectTimingHasTimes( |
545 load_timing_info.connect_timing, | 546 load_timing_info.connect_timing, |
546 CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES); | 547 CONNECT_TIMING_HAS_SSL_TIMES | CONNECT_TIMING_HAS_DNS_TIMES); |
547 } | 548 } |
548 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); | 549 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); |
549 } | 550 } |
550 | 551 |
| 552 QuicStreamId GetNthClientInitiatedStreamId(int n) { |
| 553 return test::GetNthClientInitiatedStreamId(GetParam(), n); |
| 554 } |
| 555 |
| 556 QuicStreamId GetNthServerInitiatedStreamId(int n) { |
| 557 return test::GetNthServerInitiatedStreamId(GetParam(), n); |
| 558 } |
| 559 |
551 BoundTestNetLog net_log_; | 560 BoundTestNetLog net_log_; |
552 bool use_closing_stream_; | 561 bool use_closing_stream_; |
553 MockSendAlgorithm* send_algorithm_; | 562 MockSendAlgorithm* send_algorithm_; |
554 scoped_refptr<TestTaskRunner> runner_; | 563 scoped_refptr<TestTaskRunner> runner_; |
555 std::unique_ptr<MockWrite[]> mock_writes_; | 564 std::unique_ptr<MockWrite[]> mock_writes_; |
556 MockClock clock_; | 565 MockClock clock_; |
557 HttpServerPropertiesImpl http_server_properties_; | 566 HttpServerPropertiesImpl http_server_properties_; |
558 TestQuicConnection* connection_; | 567 TestQuicConnection* connection_; |
559 std::unique_ptr<QuicChromiumConnectionHelper> helper_; | 568 std::unique_ptr<QuicChromiumConnectionHelper> helper_; |
560 std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_; | 569 std::unique_ptr<QuicChromiumAlarmFactory> alarm_factory_; |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
620 QuicHttpStreamPeer::GetQuicChromiumClientStream(stream_.get()); | 629 QuicHttpStreamPeer::GetQuicChromiumClientStream(stream_.get()); |
621 EXPECT_FALSE(client_stream->can_migrate()); | 630 EXPECT_FALSE(client_stream->can_migrate()); |
622 } | 631 } |
623 | 632 |
624 TEST_P(QuicHttpStreamTest, GetRequest) { | 633 TEST_P(QuicHttpStreamTest, GetRequest) { |
625 SetRequest("GET", "/", DEFAULT_PRIORITY); | 634 SetRequest("GET", "/", DEFAULT_PRIORITY); |
626 size_t spdy_request_header_frame_length; | 635 size_t spdy_request_header_frame_length; |
627 QuicStreamOffset header_stream_offset = 0; | 636 QuicStreamOffset header_stream_offset = 0; |
628 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 637 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
629 AddWrite(InnerConstructRequestHeadersPacket( | 638 AddWrite(InnerConstructRequestHeadersPacket( |
630 2, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 639 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
631 &spdy_request_header_frame_length, &header_stream_offset)); | 640 DEFAULT_PRIORITY, &spdy_request_header_frame_length, |
| 641 &header_stream_offset)); |
632 | 642 |
633 Initialize(); | 643 Initialize(); |
634 | 644 |
635 request_.method = "GET"; | 645 request_.method = "GET"; |
636 request_.url = GURL("https://www.example.org/"); | 646 request_.url = GURL("https://www.example.org/"); |
637 | 647 |
638 // Make sure getting load timing from the stream early does not crash. | 648 // Make sure getting load timing from the stream early does not crash. |
639 LoadTimingInfo load_timing_info; | 649 LoadTimingInfo load_timing_info; |
640 EXPECT_TRUE(stream_->GetLoadTimingInfo(&load_timing_info)); | 650 EXPECT_TRUE(stream_->GetLoadTimingInfo(&load_timing_info)); |
641 | 651 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
682 stream_->GetTotalReceivedBytes()); | 692 stream_->GetTotalReceivedBytes()); |
683 } | 693 } |
684 | 694 |
685 TEST_P(QuicHttpStreamTest, LoadTimingTwoRequests) { | 695 TEST_P(QuicHttpStreamTest, LoadTimingTwoRequests) { |
686 SetRequest("GET", "/", DEFAULT_PRIORITY); | 696 SetRequest("GET", "/", DEFAULT_PRIORITY); |
687 size_t spdy_request_header_frame_length; | 697 size_t spdy_request_header_frame_length; |
688 | 698 |
689 QuicStreamOffset offset = 0; | 699 QuicStreamOffset offset = 0; |
690 AddWrite(ConstructInitialSettingsPacket(&offset)); | 700 AddWrite(ConstructInitialSettingsPacket(&offset)); |
691 AddWrite(InnerConstructRequestHeadersPacket( | 701 AddWrite(InnerConstructRequestHeadersPacket( |
692 2, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 702 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
693 &spdy_request_header_frame_length, &offset)); | 703 DEFAULT_PRIORITY, &spdy_request_header_frame_length, &offset)); |
694 | 704 |
695 // SetRequest() again for second request as |request_headers_| was moved. | 705 // SetRequest() again for second request as |request_headers_| was moved. |
696 SetRequest("GET", "/", DEFAULT_PRIORITY); | 706 SetRequest("GET", "/", DEFAULT_PRIORITY); |
697 AddWrite(InnerConstructRequestHeadersPacket( | 707 AddWrite(InnerConstructRequestHeadersPacket( |
698 3, kClientDataStreamId2, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 708 3, GetNthClientInitiatedStreamId(1), kIncludeVersion, kFin, |
699 &spdy_request_header_frame_length, &offset)); | 709 DEFAULT_PRIORITY, &spdy_request_header_frame_length, &offset)); |
700 AddWrite(ConstructClientAckPacket(4, 3, 1, 1)); // Ack the responses. | 710 AddWrite(ConstructClientAckPacket(4, 3, 1, 1)); // Ack the responses. |
701 | 711 |
702 Initialize(); | 712 Initialize(); |
703 | 713 |
704 request_.method = "GET"; | 714 request_.method = "GET"; |
705 request_.url = GURL("https://www.example.org/"); | 715 request_.url = GURL("https://www.example.org/"); |
706 // Start first request. | 716 // Start first request. |
707 EXPECT_EQ(OK, | 717 EXPECT_EQ(OK, |
708 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 718 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
709 net_log_.bound(), callback_.callback())); | 719 net_log_.bound(), callback_.callback())); |
(...skipping 10 matching lines...) Expand all Loading... |
720 stream2.SendRequest(headers_, &response_, callback2.callback())); | 730 stream2.SendRequest(headers_, &response_, callback2.callback())); |
721 | 731 |
722 // Ack both requests. | 732 // Ack both requests. |
723 ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0)); | 733 ProcessPacket(ConstructServerAckPacket(1, 0, 0, 0)); |
724 | 734 |
725 EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()), | 735 EXPECT_THAT(stream_->ReadResponseHeaders(callback_.callback()), |
726 IsError(ERR_IO_PENDING)); | 736 IsError(ERR_IO_PENDING)); |
727 size_t spdy_response_header_frame_length; | 737 size_t spdy_response_header_frame_length; |
728 SetResponse("200 OK", string()); | 738 SetResponse("200 OK", string()); |
729 ProcessPacket(InnerConstructResponseHeadersPacket( | 739 ProcessPacket(InnerConstructResponseHeadersPacket( |
730 2, kClientDataStreamId1, kFin, &spdy_response_header_frame_length)); | 740 2, GetNthClientInitiatedStreamId(0), kFin, |
| 741 &spdy_response_header_frame_length)); |
731 | 742 |
732 // Now that the headers have been processed, the callback will return. | 743 // Now that the headers have been processed, the callback will return. |
733 EXPECT_THAT(callback_.WaitForResult(), IsOk()); | 744 EXPECT_THAT(callback_.WaitForResult(), IsOk()); |
734 EXPECT_EQ(200, response_.headers->response_code()); | 745 EXPECT_EQ(200, response_.headers->response_code()); |
735 | 746 |
736 // There is no body, so this should return immediately. | 747 // There is no body, so this should return immediately. |
737 EXPECT_EQ(0, | 748 EXPECT_EQ(0, |
738 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), | 749 stream_->ReadResponseBody(read_buffer_.get(), read_buffer_->size(), |
739 callback_.callback())); | 750 callback_.callback())); |
740 EXPECT_TRUE(stream_->IsResponseBodyComplete()); | 751 EXPECT_TRUE(stream_->IsResponseBodyComplete()); |
741 | 752 |
742 LoadTimingInfo load_timing_info; | 753 LoadTimingInfo load_timing_info; |
743 EXPECT_TRUE(stream_->GetLoadTimingInfo(&load_timing_info)); | 754 EXPECT_TRUE(stream_->GetLoadTimingInfo(&load_timing_info)); |
744 ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false); | 755 ExpectLoadTimingValid(load_timing_info, /*session_reused=*/false); |
745 | 756 |
746 // SetResponse() again for second request as |response_headers_| was moved. | 757 // SetResponse() again for second request as |response_headers_| was moved. |
747 SetResponse("200 OK", string()); | 758 SetResponse("200 OK", string()); |
748 EXPECT_THAT(stream2.ReadResponseHeaders(callback2.callback()), | 759 EXPECT_THAT(stream2.ReadResponseHeaders(callback2.callback()), |
749 IsError(ERR_IO_PENDING)); | 760 IsError(ERR_IO_PENDING)); |
750 | 761 |
751 ProcessPacket(InnerConstructResponseHeadersPacket( | 762 ProcessPacket(InnerConstructResponseHeadersPacket( |
752 3, kClientDataStreamId2, kFin, &spdy_response_header_frame_length)); | 763 3, GetNthClientInitiatedStreamId(1), kFin, |
| 764 &spdy_response_header_frame_length)); |
753 | 765 |
754 EXPECT_THAT(callback2.WaitForResult(), IsOk()); | 766 EXPECT_THAT(callback2.WaitForResult(), IsOk()); |
755 | 767 |
756 // There is no body, so this should return immediately. | 768 // There is no body, so this should return immediately. |
757 EXPECT_EQ(0, | 769 EXPECT_EQ(0, |
758 stream2.ReadResponseBody(read_buffer_.get(), read_buffer_->size(), | 770 stream2.ReadResponseBody(read_buffer_.get(), read_buffer_->size(), |
759 callback2.callback())); | 771 callback2.callback())); |
760 EXPECT_TRUE(stream2.IsResponseBodyComplete()); | 772 EXPECT_TRUE(stream2.IsResponseBodyComplete()); |
761 | 773 |
762 LoadTimingInfo load_timing_info2; | 774 LoadTimingInfo load_timing_info2; |
763 EXPECT_TRUE(stream2.GetLoadTimingInfo(&load_timing_info2)); | 775 EXPECT_TRUE(stream2.GetLoadTimingInfo(&load_timing_info2)); |
764 ExpectLoadTimingValid(load_timing_info2, /*session_reused=*/true); | 776 ExpectLoadTimingValid(load_timing_info2, /*session_reused=*/true); |
765 } | 777 } |
766 | 778 |
767 // QuicHttpStream does not currently support trailers. It should ignore | 779 // QuicHttpStream does not currently support trailers. It should ignore |
768 // trailers upon receiving them. | 780 // trailers upon receiving them. |
769 TEST_P(QuicHttpStreamTest, GetRequestWithTrailers) { | 781 TEST_P(QuicHttpStreamTest, GetRequestWithTrailers) { |
770 SetRequest("GET", "/", DEFAULT_PRIORITY); | 782 SetRequest("GET", "/", DEFAULT_PRIORITY); |
771 size_t spdy_request_header_frame_length; | 783 size_t spdy_request_header_frame_length; |
772 QuicStreamOffset header_stream_offset = 0; | 784 QuicStreamOffset header_stream_offset = 0; |
773 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 785 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
774 AddWrite(InnerConstructRequestHeadersPacket( | 786 AddWrite(InnerConstructRequestHeadersPacket( |
775 2, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 787 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
776 &spdy_request_header_frame_length, &header_stream_offset)); | 788 DEFAULT_PRIORITY, &spdy_request_header_frame_length, |
| 789 &header_stream_offset)); |
777 AddWrite(ConstructClientAckPacket(3, 3, 1, 1)); // Ack the data packet. | 790 AddWrite(ConstructClientAckPacket(3, 3, 1, 1)); // Ack the data packet. |
778 | 791 |
779 Initialize(); | 792 Initialize(); |
780 | 793 |
781 request_.method = "GET"; | 794 request_.method = "GET"; |
782 request_.url = GURL("https://www.example.org/"); | 795 request_.url = GURL("https://www.example.org/"); |
783 | 796 |
784 EXPECT_EQ(OK, | 797 EXPECT_EQ(OK, |
785 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 798 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
786 net_log_.bound(), callback_.callback())); | 799 net_log_.bound(), callback_.callback())); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
859 NetLogEventPhase::NONE); | 872 NetLogEventPhase::NONE); |
860 } | 873 } |
861 | 874 |
862 // Regression test for http://crbug.com/288128 | 875 // Regression test for http://crbug.com/288128 |
863 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) { | 876 TEST_P(QuicHttpStreamTest, GetRequestLargeResponse) { |
864 SetRequest("GET", "/", DEFAULT_PRIORITY); | 877 SetRequest("GET", "/", DEFAULT_PRIORITY); |
865 size_t spdy_request_headers_frame_length; | 878 size_t spdy_request_headers_frame_length; |
866 QuicStreamOffset header_stream_offset = 0; | 879 QuicStreamOffset header_stream_offset = 0; |
867 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 880 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
868 AddWrite(InnerConstructRequestHeadersPacket( | 881 AddWrite(InnerConstructRequestHeadersPacket( |
869 2, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 882 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
870 &spdy_request_headers_frame_length, &header_stream_offset)); | 883 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 884 &header_stream_offset)); |
871 Initialize(); | 885 Initialize(); |
872 | 886 |
873 request_.method = "GET"; | 887 request_.method = "GET"; |
874 request_.url = GURL("https://www.example.org/"); | 888 request_.url = GURL("https://www.example.org/"); |
875 | 889 |
876 EXPECT_EQ(OK, | 890 EXPECT_EQ(OK, |
877 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 891 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
878 net_log_.bound(), callback_.callback())); | 892 net_log_.bound(), callback_.callback())); |
879 EXPECT_EQ(OK, | 893 EXPECT_EQ(OK, |
880 stream_->SendRequest(headers_, &response_, callback_.callback())); | 894 stream_->SendRequest(headers_, &response_, callback_.callback())); |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
986 EXPECT_EQ(AlternativeService(kProtoQUIC, "www.example.org", 443), | 1000 EXPECT_EQ(AlternativeService(kProtoQUIC, "www.example.org", 443), |
987 alternative_service2); | 1001 alternative_service2); |
988 } | 1002 } |
989 | 1003 |
990 TEST_P(QuicHttpStreamTest, LogGranularQuicConnectionError) { | 1004 TEST_P(QuicHttpStreamTest, LogGranularQuicConnectionError) { |
991 SetRequest("GET", "/", DEFAULT_PRIORITY); | 1005 SetRequest("GET", "/", DEFAULT_PRIORITY); |
992 size_t spdy_request_headers_frame_length; | 1006 size_t spdy_request_headers_frame_length; |
993 QuicStreamOffset header_stream_offset = 0; | 1007 QuicStreamOffset header_stream_offset = 0; |
994 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1008 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
995 AddWrite(InnerConstructRequestHeadersPacket( | 1009 AddWrite(InnerConstructRequestHeadersPacket( |
996 2, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 1010 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
997 &spdy_request_headers_frame_length, &header_stream_offset)); | 1011 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1012 &header_stream_offset)); |
998 AddWrite(ConstructAckAndRstStreamPacket(3)); | 1013 AddWrite(ConstructAckAndRstStreamPacket(3)); |
999 use_closing_stream_ = true; | 1014 use_closing_stream_ = true; |
1000 Initialize(); | 1015 Initialize(); |
1001 | 1016 |
1002 request_.method = "GET"; | 1017 request_.method = "GET"; |
1003 request_.url = GURL("https://www.example.org/"); | 1018 request_.url = GURL("https://www.example.org/"); |
1004 | 1019 |
1005 EXPECT_EQ(OK, | 1020 EXPECT_EQ(OK, |
1006 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 1021 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
1007 net_log_.bound(), callback_.callback())); | 1022 net_log_.bound(), callback_.callback())); |
(...skipping 19 matching lines...) Expand all Loading... |
1027 // By default the test setup defaults handshake to be confirmed. Manually set | 1042 // By default the test setup defaults handshake to be confirmed. Manually set |
1028 // it to be not confirmed. | 1043 // it to be not confirmed. |
1029 // Granular errors shouldn't be reported if handshake not confirmed. | 1044 // Granular errors shouldn't be reported if handshake not confirmed. |
1030 crypto_client_stream_factory_.set_handshake_mode( | 1045 crypto_client_stream_factory_.set_handshake_mode( |
1031 MockCryptoClientStream::ZERO_RTT); | 1046 MockCryptoClientStream::ZERO_RTT); |
1032 | 1047 |
1033 SetRequest("GET", "/", DEFAULT_PRIORITY); | 1048 SetRequest("GET", "/", DEFAULT_PRIORITY); |
1034 size_t spdy_request_headers_frame_length; | 1049 size_t spdy_request_headers_frame_length; |
1035 QuicStreamOffset header_stream_offset = 0; | 1050 QuicStreamOffset header_stream_offset = 0; |
1036 AddWrite(InnerConstructRequestHeadersPacket( | 1051 AddWrite(InnerConstructRequestHeadersPacket( |
1037 1, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 1052 1, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
1038 &spdy_request_headers_frame_length, &header_stream_offset)); | 1053 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1054 &header_stream_offset)); |
1039 use_closing_stream_ = true; | 1055 use_closing_stream_ = true; |
1040 Initialize(); | 1056 Initialize(); |
1041 | 1057 |
1042 request_.method = "GET"; | 1058 request_.method = "GET"; |
1043 request_.url = GURL("https://www.example.org/"); | 1059 request_.url = GURL("https://www.example.org/"); |
1044 | 1060 |
1045 EXPECT_EQ(OK, | 1061 EXPECT_EQ(OK, |
1046 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 1062 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
1047 net_log_.bound(), callback_.callback())); | 1063 net_log_.bound(), callback_.callback())); |
1048 EXPECT_EQ(OK, | 1064 EXPECT_EQ(OK, |
(...skipping 14 matching lines...) Expand all Loading... |
1063 EXPECT_EQ(QUIC_NO_ERROR, details.quic_connection_error); | 1079 EXPECT_EQ(QUIC_NO_ERROR, details.quic_connection_error); |
1064 } | 1080 } |
1065 | 1081 |
1066 // Regression test for http://crbug.com/409871 | 1082 // Regression test for http://crbug.com/409871 |
1067 TEST_P(QuicHttpStreamTest, SessionClosedBeforeReadResponseHeaders) { | 1083 TEST_P(QuicHttpStreamTest, SessionClosedBeforeReadResponseHeaders) { |
1068 SetRequest("GET", "/", DEFAULT_PRIORITY); | 1084 SetRequest("GET", "/", DEFAULT_PRIORITY); |
1069 size_t spdy_request_headers_frame_length; | 1085 size_t spdy_request_headers_frame_length; |
1070 QuicStreamOffset header_stream_offset = 0; | 1086 QuicStreamOffset header_stream_offset = 0; |
1071 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1087 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1072 AddWrite(InnerConstructRequestHeadersPacket( | 1088 AddWrite(InnerConstructRequestHeadersPacket( |
1073 2, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 1089 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
1074 &spdy_request_headers_frame_length, &header_stream_offset)); | 1090 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1091 &header_stream_offset)); |
1075 Initialize(); | 1092 Initialize(); |
1076 | 1093 |
1077 request_.method = "GET"; | 1094 request_.method = "GET"; |
1078 request_.url = GURL("https://www.example.org/"); | 1095 request_.url = GURL("https://www.example.org/"); |
1079 | 1096 |
1080 EXPECT_EQ(OK, | 1097 EXPECT_EQ(OK, |
1081 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 1098 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
1082 net_log_.bound(), callback_.callback())); | 1099 net_log_.bound(), callback_.callback())); |
1083 | 1100 |
1084 EXPECT_EQ(OK, | 1101 EXPECT_EQ(OK, |
(...skipping 10 matching lines...) Expand all Loading... |
1095 stream_->GetTotalSentBytes()); | 1112 stream_->GetTotalSentBytes()); |
1096 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 1113 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
1097 } | 1114 } |
1098 | 1115 |
1099 TEST_P(QuicHttpStreamTest, SendPostRequest) { | 1116 TEST_P(QuicHttpStreamTest, SendPostRequest) { |
1100 SetRequest("POST", "/", DEFAULT_PRIORITY); | 1117 SetRequest("POST", "/", DEFAULT_PRIORITY); |
1101 size_t spdy_request_headers_frame_length; | 1118 size_t spdy_request_headers_frame_length; |
1102 QuicStreamOffset header_stream_offset = 0; | 1119 QuicStreamOffset header_stream_offset = 0; |
1103 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1120 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1104 AddWrite(InnerConstructRequestHeadersPacket( | 1121 AddWrite(InnerConstructRequestHeadersPacket( |
1105 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 1122 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
1106 &spdy_request_headers_frame_length, &header_stream_offset)); | 1123 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1124 &header_stream_offset)); |
1107 AddWrite(ConstructClientDataPacket(3, kIncludeVersion, kFin, 0, kUploadData)); | 1125 AddWrite(ConstructClientDataPacket(3, kIncludeVersion, kFin, 0, kUploadData)); |
1108 AddWrite(ConstructClientAckPacket(4, 3, 1, 1)); | 1126 AddWrite(ConstructClientAckPacket(4, 3, 1, 1)); |
1109 | 1127 |
1110 Initialize(); | 1128 Initialize(); |
1111 | 1129 |
1112 std::vector<std::unique_ptr<UploadElementReader>> element_readers; | 1130 std::vector<std::unique_ptr<UploadElementReader>> element_readers; |
1113 element_readers.push_back(base::MakeUnique<UploadBytesElementReader>( | 1131 element_readers.push_back(base::MakeUnique<UploadBytesElementReader>( |
1114 kUploadData, strlen(kUploadData))); | 1132 kUploadData, strlen(kUploadData))); |
1115 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); | 1133 ElementsUploadDataStream upload_data_stream(std::move(element_readers), 0); |
1116 request_.method = "POST"; | 1134 request_.method = "POST"; |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1164 stream_->GetTotalReceivedBytes()); | 1182 stream_->GetTotalReceivedBytes()); |
1165 } | 1183 } |
1166 | 1184 |
1167 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) { | 1185 TEST_P(QuicHttpStreamTest, SendChunkedPostRequest) { |
1168 SetRequest("POST", "/", DEFAULT_PRIORITY); | 1186 SetRequest("POST", "/", DEFAULT_PRIORITY); |
1169 size_t chunk_size = strlen(kUploadData); | 1187 size_t chunk_size = strlen(kUploadData); |
1170 size_t spdy_request_headers_frame_length; | 1188 size_t spdy_request_headers_frame_length; |
1171 QuicStreamOffset header_stream_offset = 0; | 1189 QuicStreamOffset header_stream_offset = 0; |
1172 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1190 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1173 AddWrite(InnerConstructRequestHeadersPacket( | 1191 AddWrite(InnerConstructRequestHeadersPacket( |
1174 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 1192 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
1175 &spdy_request_headers_frame_length, &header_stream_offset)); | 1193 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1194 &header_stream_offset)); |
1176 AddWrite( | 1195 AddWrite( |
1177 ConstructClientDataPacket(3, kIncludeVersion, !kFin, 0, kUploadData)); | 1196 ConstructClientDataPacket(3, kIncludeVersion, !kFin, 0, kUploadData)); |
1178 AddWrite(ConstructClientDataPacket(4, kIncludeVersion, kFin, chunk_size, | 1197 AddWrite(ConstructClientDataPacket(4, kIncludeVersion, kFin, chunk_size, |
1179 kUploadData)); | 1198 kUploadData)); |
1180 AddWrite(ConstructClientAckPacket(5, 3, 1, 1)); | 1199 AddWrite(ConstructClientAckPacket(5, 3, 1, 1)); |
1181 Initialize(); | 1200 Initialize(); |
1182 | 1201 |
1183 ChunkedUploadDataStream upload_data_stream(0); | 1202 ChunkedUploadDataStream upload_data_stream(0); |
1184 upload_data_stream.AppendData(kUploadData, chunk_size, false); | 1203 upload_data_stream.AppendData(kUploadData, chunk_size, false); |
1185 | 1204 |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1238 stream_->GetTotalReceivedBytes()); | 1257 stream_->GetTotalReceivedBytes()); |
1239 } | 1258 } |
1240 | 1259 |
1241 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) { | 1260 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithFinalEmptyDataPacket) { |
1242 SetRequest("POST", "/", DEFAULT_PRIORITY); | 1261 SetRequest("POST", "/", DEFAULT_PRIORITY); |
1243 size_t chunk_size = strlen(kUploadData); | 1262 size_t chunk_size = strlen(kUploadData); |
1244 size_t spdy_request_headers_frame_length; | 1263 size_t spdy_request_headers_frame_length; |
1245 QuicStreamOffset header_stream_offset = 0; | 1264 QuicStreamOffset header_stream_offset = 0; |
1246 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1265 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1247 AddWrite(InnerConstructRequestHeadersPacket( | 1266 AddWrite(InnerConstructRequestHeadersPacket( |
1248 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 1267 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
1249 &spdy_request_headers_frame_length, &header_stream_offset)); | 1268 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1269 &header_stream_offset)); |
1250 AddWrite( | 1270 AddWrite( |
1251 ConstructClientDataPacket(3, kIncludeVersion, !kFin, 0, kUploadData)); | 1271 ConstructClientDataPacket(3, kIncludeVersion, !kFin, 0, kUploadData)); |
1252 AddWrite(ConstructClientDataPacket(4, kIncludeVersion, kFin, chunk_size, "")); | 1272 AddWrite(ConstructClientDataPacket(4, kIncludeVersion, kFin, chunk_size, "")); |
1253 AddWrite(ConstructClientAckPacket(5, 3, 1, 1)); | 1273 AddWrite(ConstructClientAckPacket(5, 3, 1, 1)); |
1254 Initialize(); | 1274 Initialize(); |
1255 | 1275 |
1256 ChunkedUploadDataStream upload_data_stream(0); | 1276 ChunkedUploadDataStream upload_data_stream(0); |
1257 upload_data_stream.AppendData(kUploadData, chunk_size, false); | 1277 upload_data_stream.AppendData(kUploadData, chunk_size, false); |
1258 | 1278 |
1259 request_.method = "POST"; | 1279 request_.method = "POST"; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1308 strlen(kResponseBody)), | 1328 strlen(kResponseBody)), |
1309 stream_->GetTotalReceivedBytes()); | 1329 stream_->GetTotalReceivedBytes()); |
1310 } | 1330 } |
1311 | 1331 |
1312 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithOneEmptyDataPacket) { | 1332 TEST_P(QuicHttpStreamTest, SendChunkedPostRequestWithOneEmptyDataPacket) { |
1313 SetRequest("POST", "/", DEFAULT_PRIORITY); | 1333 SetRequest("POST", "/", DEFAULT_PRIORITY); |
1314 size_t spdy_request_headers_frame_length; | 1334 size_t spdy_request_headers_frame_length; |
1315 QuicStreamOffset header_stream_offset = 0; | 1335 QuicStreamOffset header_stream_offset = 0; |
1316 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1336 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1317 AddWrite(InnerConstructRequestHeadersPacket( | 1337 AddWrite(InnerConstructRequestHeadersPacket( |
1318 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 1338 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
1319 &spdy_request_headers_frame_length, &header_stream_offset)); | 1339 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1340 &header_stream_offset)); |
1320 AddWrite(ConstructClientDataPacket(3, kIncludeVersion, kFin, 0, "")); | 1341 AddWrite(ConstructClientDataPacket(3, kIncludeVersion, kFin, 0, "")); |
1321 AddWrite(ConstructClientAckPacket(4, 3, 1, 1)); | 1342 AddWrite(ConstructClientAckPacket(4, 3, 1, 1)); |
1322 Initialize(); | 1343 Initialize(); |
1323 | 1344 |
1324 ChunkedUploadDataStream upload_data_stream(0); | 1345 ChunkedUploadDataStream upload_data_stream(0); |
1325 | 1346 |
1326 request_.method = "POST"; | 1347 request_.method = "POST"; |
1327 request_.url = GURL("https://www.example.org/"); | 1348 request_.url = GURL("https://www.example.org/"); |
1328 request_.upload_data_stream = &upload_data_stream; | 1349 request_.upload_data_stream = &upload_data_stream; |
1329 ASSERT_EQ(OK, request_.upload_data_stream->Init( | 1350 ASSERT_EQ(OK, request_.upload_data_stream->Init( |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1375 strlen(kResponseBody)), | 1396 strlen(kResponseBody)), |
1376 stream_->GetTotalReceivedBytes()); | 1397 stream_->GetTotalReceivedBytes()); |
1377 } | 1398 } |
1378 | 1399 |
1379 TEST_P(QuicHttpStreamTest, DestroyedEarly) { | 1400 TEST_P(QuicHttpStreamTest, DestroyedEarly) { |
1380 SetRequest("GET", "/", DEFAULT_PRIORITY); | 1401 SetRequest("GET", "/", DEFAULT_PRIORITY); |
1381 size_t spdy_request_headers_frame_length; | 1402 size_t spdy_request_headers_frame_length; |
1382 QuicStreamOffset header_stream_offset = 0; | 1403 QuicStreamOffset header_stream_offset = 0; |
1383 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1404 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1384 AddWrite(InnerConstructRequestHeadersPacket( | 1405 AddWrite(InnerConstructRequestHeadersPacket( |
1385 2, kClientDataStreamId1, kIncludeVersion, kFin, DEFAULT_PRIORITY, | 1406 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, |
1386 &spdy_request_headers_frame_length, &header_stream_offset)); | 1407 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1408 &header_stream_offset)); |
1387 AddWrite(ConstructAckAndRstStreamPacket(3)); | 1409 AddWrite(ConstructAckAndRstStreamPacket(3)); |
1388 use_closing_stream_ = true; | 1410 use_closing_stream_ = true; |
1389 Initialize(); | 1411 Initialize(); |
1390 | 1412 |
1391 request_.method = "GET"; | 1413 request_.method = "GET"; |
1392 request_.url = GURL("https://www.example.org/"); | 1414 request_.url = GURL("https://www.example.org/"); |
1393 | 1415 |
1394 EXPECT_EQ(OK, | 1416 EXPECT_EQ(OK, |
1395 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, | 1417 stream_->InitializeStream(&request_, DEFAULT_PRIORITY, |
1396 net_log_.bound(), callback_.callback())); | 1418 net_log_.bound(), callback_.callback())); |
(...skipping 21 matching lines...) Expand all Loading... |
1418 // Zero since the stream is closed before processing the headers. | 1440 // Zero since the stream is closed before processing the headers. |
1419 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 1441 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
1420 } | 1442 } |
1421 | 1443 |
1422 TEST_P(QuicHttpStreamTest, Priority) { | 1444 TEST_P(QuicHttpStreamTest, Priority) { |
1423 SetRequest("GET", "/", MEDIUM); | 1445 SetRequest("GET", "/", MEDIUM); |
1424 size_t spdy_request_headers_frame_length; | 1446 size_t spdy_request_headers_frame_length; |
1425 QuicStreamOffset header_stream_offset = 0; | 1447 QuicStreamOffset header_stream_offset = 0; |
1426 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1448 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1427 AddWrite(InnerConstructRequestHeadersPacket( | 1449 AddWrite(InnerConstructRequestHeadersPacket( |
1428 2, kClientDataStreamId1, kIncludeVersion, kFin, MEDIUM, | 1450 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, kFin, MEDIUM, |
1429 &spdy_request_headers_frame_length, &header_stream_offset)); | 1451 &spdy_request_headers_frame_length, &header_stream_offset)); |
1430 AddWrite(ConstructAckAndRstStreamPacket(3)); | 1452 AddWrite(ConstructAckAndRstStreamPacket(3)); |
1431 use_closing_stream_ = true; | 1453 use_closing_stream_ = true; |
1432 Initialize(); | 1454 Initialize(); |
1433 | 1455 |
1434 request_.method = "GET"; | 1456 request_.method = "GET"; |
1435 request_.url = GURL("https://www.example.org/"); | 1457 request_.url = GURL("https://www.example.org/"); |
1436 | 1458 |
1437 EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, net_log_.bound(), | 1459 EXPECT_EQ(OK, stream_->InitializeStream(&request_, MEDIUM, net_log_.bound(), |
1438 callback_.callback())); | 1460 callback_.callback())); |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1505 EXPECT_EQ(0, stream_->GetTotalSentBytes()); | 1527 EXPECT_EQ(0, stream_->GetTotalSentBytes()); |
1506 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 1528 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
1507 } | 1529 } |
1508 | 1530 |
1509 TEST_P(QuicHttpStreamTest, SessionClosedDuringDoLoop) { | 1531 TEST_P(QuicHttpStreamTest, SessionClosedDuringDoLoop) { |
1510 SetRequest("POST", "/", DEFAULT_PRIORITY); | 1532 SetRequest("POST", "/", DEFAULT_PRIORITY); |
1511 size_t spdy_request_headers_frame_length; | 1533 size_t spdy_request_headers_frame_length; |
1512 QuicStreamOffset header_stream_offset = 0; | 1534 QuicStreamOffset header_stream_offset = 0; |
1513 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1535 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1514 AddWrite(InnerConstructRequestHeadersPacket( | 1536 AddWrite(InnerConstructRequestHeadersPacket( |
1515 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 1537 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
1516 &spdy_request_headers_frame_length, &header_stream_offset)); | 1538 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1539 &header_stream_offset)); |
1517 AddWrite( | 1540 AddWrite( |
1518 ConstructClientDataPacket(3, kIncludeVersion, !kFin, 0, kUploadData)); | 1541 ConstructClientDataPacket(3, kIncludeVersion, !kFin, 0, kUploadData)); |
1519 // Second data write will result in a synchronous failure which will close | 1542 // Second data write will result in a synchronous failure which will close |
1520 // the session. | 1543 // the session. |
1521 AddWrite(SYNCHRONOUS, ERR_FAILED); | 1544 AddWrite(SYNCHRONOUS, ERR_FAILED); |
1522 Initialize(); | 1545 Initialize(); |
1523 | 1546 |
1524 ChunkedUploadDataStream upload_data_stream(0); | 1547 ChunkedUploadDataStream upload_data_stream(0); |
1525 | 1548 |
1526 request_.method = "POST"; | 1549 request_.method = "POST"; |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1565 ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, | 1588 ASSERT_EQ(ERR_QUIC_PROTOCOL_ERROR, |
1566 stream_->SendRequest(headers_, &response_, callback_.callback())); | 1589 stream_->SendRequest(headers_, &response_, callback_.callback())); |
1567 } | 1590 } |
1568 | 1591 |
1569 TEST_P(QuicHttpStreamTest, SessionClosedBeforeSendBodyComplete) { | 1592 TEST_P(QuicHttpStreamTest, SessionClosedBeforeSendBodyComplete) { |
1570 SetRequest("POST", "/", DEFAULT_PRIORITY); | 1593 SetRequest("POST", "/", DEFAULT_PRIORITY); |
1571 size_t spdy_request_headers_frame_length; | 1594 size_t spdy_request_headers_frame_length; |
1572 QuicStreamOffset header_stream_offset = 0; | 1595 QuicStreamOffset header_stream_offset = 0; |
1573 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 1596 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
1574 AddWrite(InnerConstructRequestHeadersPacket( | 1597 AddWrite(InnerConstructRequestHeadersPacket( |
1575 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 1598 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
1576 &spdy_request_headers_frame_length, &header_stream_offset)); | 1599 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 1600 &header_stream_offset)); |
1577 AddWrite(SYNCHRONOUS, ERR_FAILED); | 1601 AddWrite(SYNCHRONOUS, ERR_FAILED); |
1578 Initialize(); | 1602 Initialize(); |
1579 | 1603 |
1580 ChunkedUploadDataStream upload_data_stream(0); | 1604 ChunkedUploadDataStream upload_data_stream(0); |
1581 size_t chunk_size = strlen(kUploadData); | 1605 size_t chunk_size = strlen(kUploadData); |
1582 upload_data_stream.AppendData(kUploadData, chunk_size, false); | 1606 upload_data_stream.AppendData(kUploadData, chunk_size, false); |
1583 | 1607 |
1584 request_.method = "POST"; | 1608 request_.method = "POST"; |
1585 request_.url = GURL("https://www.example.org/"); | 1609 request_.url = GURL("https://www.example.org/"); |
1586 request_.upload_data_stream = &upload_data_stream; | 1610 request_.upload_data_stream = &upload_data_stream; |
(...skipping 482 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2069 EXPECT_EQ(static_cast<int64_t>(spdy_response_header_frame_length), | 2093 EXPECT_EQ(static_cast<int64_t>(spdy_response_header_frame_length), |
2070 promised_stream_->GetTotalReceivedBytes()); | 2094 promised_stream_->GetTotalReceivedBytes()); |
2071 } | 2095 } |
2072 | 2096 |
2073 TEST_P(QuicHttpStreamTest, DataReadErrorSynchronous) { | 2097 TEST_P(QuicHttpStreamTest, DataReadErrorSynchronous) { |
2074 SetRequest("POST", "/", DEFAULT_PRIORITY); | 2098 SetRequest("POST", "/", DEFAULT_PRIORITY); |
2075 size_t spdy_request_headers_frame_length; | 2099 size_t spdy_request_headers_frame_length; |
2076 QuicStreamOffset header_stream_offset = 0; | 2100 QuicStreamOffset header_stream_offset = 0; |
2077 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 2101 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
2078 AddWrite(InnerConstructRequestHeadersPacket( | 2102 AddWrite(InnerConstructRequestHeadersPacket( |
2079 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 2103 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
2080 &spdy_request_headers_frame_length, &header_stream_offset)); | 2104 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 2105 &header_stream_offset)); |
2081 AddWrite(ConstructClientRstStreamErrorPacket(3, kIncludeVersion)); | 2106 AddWrite(ConstructClientRstStreamErrorPacket(3, kIncludeVersion)); |
2082 | 2107 |
2083 Initialize(); | 2108 Initialize(); |
2084 | 2109 |
2085 ReadErrorUploadDataStream upload_data_stream( | 2110 ReadErrorUploadDataStream upload_data_stream( |
2086 ReadErrorUploadDataStream::FailureMode::SYNC); | 2111 ReadErrorUploadDataStream::FailureMode::SYNC); |
2087 request_.method = "POST"; | 2112 request_.method = "POST"; |
2088 request_.url = GURL("https://www.example.org/"); | 2113 request_.url = GURL("https://www.example.org/"); |
2089 request_.upload_data_stream = &upload_data_stream; | 2114 request_.upload_data_stream = &upload_data_stream; |
2090 ASSERT_EQ(OK, request_.upload_data_stream->Init( | 2115 ASSERT_EQ(OK, request_.upload_data_stream->Init( |
(...skipping 13 matching lines...) Expand all Loading... |
2104 stream_->GetTotalSentBytes()); | 2129 stream_->GetTotalSentBytes()); |
2105 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 2130 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
2106 } | 2131 } |
2107 | 2132 |
2108 TEST_P(QuicHttpStreamTest, DataReadErrorAsynchronous) { | 2133 TEST_P(QuicHttpStreamTest, DataReadErrorAsynchronous) { |
2109 SetRequest("POST", "/", DEFAULT_PRIORITY); | 2134 SetRequest("POST", "/", DEFAULT_PRIORITY); |
2110 size_t spdy_request_headers_frame_length; | 2135 size_t spdy_request_headers_frame_length; |
2111 QuicStreamOffset header_stream_offset = 0; | 2136 QuicStreamOffset header_stream_offset = 0; |
2112 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); | 2137 AddWrite(ConstructInitialSettingsPacket(&header_stream_offset)); |
2113 AddWrite(InnerConstructRequestHeadersPacket( | 2138 AddWrite(InnerConstructRequestHeadersPacket( |
2114 2, kClientDataStreamId1, kIncludeVersion, !kFin, DEFAULT_PRIORITY, | 2139 2, GetNthClientInitiatedStreamId(0), kIncludeVersion, !kFin, |
2115 &spdy_request_headers_frame_length, &header_stream_offset)); | 2140 DEFAULT_PRIORITY, &spdy_request_headers_frame_length, |
| 2141 &header_stream_offset)); |
2116 AddWrite(ConstructClientRstStreamErrorPacket(3, !kIncludeVersion)); | 2142 AddWrite(ConstructClientRstStreamErrorPacket(3, !kIncludeVersion)); |
2117 | 2143 |
2118 Initialize(); | 2144 Initialize(); |
2119 | 2145 |
2120 ReadErrorUploadDataStream upload_data_stream( | 2146 ReadErrorUploadDataStream upload_data_stream( |
2121 ReadErrorUploadDataStream::FailureMode::ASYNC); | 2147 ReadErrorUploadDataStream::FailureMode::ASYNC); |
2122 request_.method = "POST"; | 2148 request_.method = "POST"; |
2123 request_.url = GURL("https://www.example.org/"); | 2149 request_.url = GURL("https://www.example.org/"); |
2124 request_.upload_data_stream = &upload_data_stream; | 2150 request_.upload_data_stream = &upload_data_stream; |
2125 ASSERT_EQ(OK, request_.upload_data_stream->Init( | 2151 ASSERT_EQ(OK, request_.upload_data_stream->Init( |
(...skipping 14 matching lines...) Expand all Loading... |
2140 EXPECT_TRUE(AtEof()); | 2166 EXPECT_TRUE(AtEof()); |
2141 | 2167 |
2142 // QuicHttpStream::GetTotalSent/ReceivedBytes includes only headers. | 2168 // QuicHttpStream::GetTotalSent/ReceivedBytes includes only headers. |
2143 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length), | 2169 EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length), |
2144 stream_->GetTotalSentBytes()); | 2170 stream_->GetTotalSentBytes()); |
2145 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); | 2171 EXPECT_EQ(0, stream_->GetTotalReceivedBytes()); |
2146 } | 2172 } |
2147 | 2173 |
2148 } // namespace test | 2174 } // namespace test |
2149 } // namespace net | 2175 } // namespace net |
OLD | NEW |