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_chromium_client_stream.h" | 5 #include "net/quic/chromium/quic_chromium_client_stream.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
10 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
(...skipping 26 matching lines...) Expand all Loading... |
37 namespace { | 37 namespace { |
38 | 38 |
39 const QuicStreamId kTestStreamId = 5u; | 39 const QuicStreamId kTestStreamId = 5u; |
40 | 40 |
41 class MockDelegate : public QuicChromiumClientStream::Delegate { | 41 class MockDelegate : public QuicChromiumClientStream::Delegate { |
42 public: | 42 public: |
43 MockDelegate() {} | 43 MockDelegate() {} |
44 | 44 |
45 MOCK_METHOD0(OnSendData, int()); | 45 MOCK_METHOD0(OnSendData, int()); |
46 MOCK_METHOD2(OnSendDataComplete, int(int, bool*)); | 46 MOCK_METHOD2(OnSendDataComplete, int(int, bool*)); |
47 void OnInitialHeadersAvailable(const SpdyHeaderBlock& headers, | |
48 size_t frame_len) override { | |
49 headers_ = headers.Clone(); | |
50 OnInitialHeadersAvailableMock(headers, frame_len); | |
51 } | |
52 MOCK_METHOD2(OnInitialHeadersAvailableMock, | |
53 void(const SpdyHeaderBlock& headers, size_t frame_len)); | |
54 void OnTrailingHeadersAvailable(const SpdyHeaderBlock& headers, | 47 void OnTrailingHeadersAvailable(const SpdyHeaderBlock& headers, |
55 size_t frame_len) override { | 48 size_t frame_len) override { |
56 trailers_ = headers.Clone(); | 49 trailers_ = headers.Clone(); |
57 OnTrailingHeadersAvailableMock(headers, frame_len); | 50 OnTrailingHeadersAvailableMock(headers, frame_len); |
58 } | 51 } |
59 MOCK_METHOD2(OnTrailingHeadersAvailableMock, | 52 MOCK_METHOD2(OnTrailingHeadersAvailableMock, |
60 void(const SpdyHeaderBlock& headers, size_t frame_len)); | 53 void(const SpdyHeaderBlock& headers, size_t frame_len)); |
61 MOCK_METHOD0(OnDataAvailable, void()); | 54 MOCK_METHOD0(OnDataAvailable, void()); |
62 MOCK_METHOD0(OnClose, void()); | 55 MOCK_METHOD0(OnClose, void()); |
63 MOCK_METHOD1(OnError, void(int)); | 56 MOCK_METHOD1(OnError, void(int)); |
(...skipping 182 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
246 } | 239 } |
247 | 240 |
248 QuicHeaderList ProcessTrailers(const SpdyHeaderBlock& headers) { | 241 QuicHeaderList ProcessTrailers(const SpdyHeaderBlock& headers) { |
249 QuicHeaderList h = AsHeaderList(headers); | 242 QuicHeaderList h = AsHeaderList(headers); |
250 stream_->OnStreamHeaderList(true, h.uncompressed_header_bytes(), h); | 243 stream_->OnStreamHeaderList(true, h.uncompressed_header_bytes(), h); |
251 return h; | 244 return h; |
252 } | 245 } |
253 | 246 |
254 QuicHeaderList ProcessHeadersFull(const SpdyHeaderBlock& headers) { | 247 QuicHeaderList ProcessHeadersFull(const SpdyHeaderBlock& headers) { |
255 QuicHeaderList h = ProcessHeaders(headers); | 248 QuicHeaderList h = ProcessHeaders(headers); |
256 EXPECT_CALL(delegate_, OnInitialHeadersAvailableMock( | 249 TestCompletionCallback callback; |
257 _, h.uncompressed_header_bytes())); | 250 EXPECT_EQ( |
258 base::RunLoop().RunUntilIdle(); | 251 static_cast<int>(h.uncompressed_header_bytes()), |
| 252 handle_->ReadInitialHeaders(&delegate_.headers_, callback.callback())); |
259 EXPECT_EQ(headers, delegate_.headers_); | 253 EXPECT_EQ(headers, delegate_.headers_); |
260 EXPECT_TRUE(stream_->header_list().empty()); | 254 EXPECT_TRUE(stream_->header_list().empty()); |
261 return h; | 255 return h; |
262 } | 256 } |
263 | 257 |
264 QuicStreamId GetNthClientInitiatedStreamId(int n) { | 258 QuicStreamId GetNthClientInitiatedStreamId(int n) { |
265 return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n); | 259 return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n); |
266 } | 260 } |
267 | 261 |
268 QuicStreamId GetNthServerInitiatedStreamId(int n) { | 262 QuicStreamId GetNthServerInitiatedStreamId(int n) { |
(...skipping 455 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
724 | 718 |
725 InitializeHeaders(); | 719 InitializeHeaders(); |
726 | 720 |
727 // Receive the headers before the delegate is set. | 721 // Receive the headers before the delegate is set. |
728 QuicHeaderList header_list = AsHeaderList(headers_); | 722 QuicHeaderList header_list = AsHeaderList(headers_); |
729 stream2->OnStreamHeaderList(true, header_list.uncompressed_header_bytes(), | 723 stream2->OnStreamHeaderList(true, header_list.uncompressed_header_bytes(), |
730 header_list); | 724 header_list); |
731 EXPECT_TRUE(delegate2_.headers_.empty()); | 725 EXPECT_TRUE(delegate2_.headers_.empty()); |
732 | 726 |
733 // Now set the delegate and verify that the headers are delivered. | 727 // Now set the delegate and verify that the headers are delivered. |
734 EXPECT_CALL(delegate2_, OnInitialHeadersAvailableMock( | |
735 _, header_list.uncompressed_header_bytes())); | |
736 handle2_ = stream2->CreateHandle(&delegate2_); | 728 handle2_ = stream2->CreateHandle(&delegate2_); |
737 base::RunLoop().RunUntilIdle(); | 729 TestCompletionCallback callback; |
| 730 EXPECT_EQ( |
| 731 static_cast<int>(header_list.uncompressed_header_bytes()), |
| 732 handle2_->ReadInitialHeaders(&delegate2_.headers_, callback.callback())); |
738 EXPECT_EQ(headers_, delegate2_.headers_); | 733 EXPECT_EQ(headers_, delegate2_.headers_); |
739 | 734 |
740 // Both delegates should be notified that theirs streams are closed. | 735 // Both delegates should be notified that theirs streams are closed. |
741 EXPECT_CALL(delegate2_, OnClose()); | 736 EXPECT_CALL(delegate2_, OnClose()); |
742 EXPECT_CALL(delegate_, OnClose()); | 737 EXPECT_CALL(delegate_, OnClose()); |
743 } | 738 } |
744 | 739 |
745 TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeDelegate) { | 740 TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeDelegate) { |
746 // We don't use stream_ because we want an incoming server push | 741 // We don't use stream_ because we want an incoming server push |
747 // stream. | 742 // stream. |
748 QuicStreamId stream_id = GetNthServerInitiatedStreamId(0); | 743 QuicStreamId stream_id = GetNthServerInitiatedStreamId(0); |
749 QuicChromiumClientStream* stream2 = | 744 QuicChromiumClientStream* stream2 = |
750 new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource()); | 745 new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource()); |
751 session_.ActivateStream(base::WrapUnique(stream2)); | 746 session_.ActivateStream(base::WrapUnique(stream2)); |
752 | 747 |
753 InitializeHeaders(); | 748 InitializeHeaders(); |
754 | 749 |
755 // Receive the headers and data before the delegate is set. | 750 // Receive the headers and data before the delegate is set. |
756 QuicHeaderList header_list = AsHeaderList(headers_); | 751 QuicHeaderList header_list = AsHeaderList(headers_); |
757 stream2->OnStreamHeaderList(false, header_list.uncompressed_header_bytes(), | 752 stream2->OnStreamHeaderList(false, header_list.uncompressed_header_bytes(), |
758 header_list); | 753 header_list); |
759 EXPECT_TRUE(delegate2_.headers_.empty()); | 754 EXPECT_TRUE(delegate2_.headers_.empty()); |
760 const char data[] = "hello world!"; | 755 const char data[] = "hello world!"; |
761 stream2->OnStreamFrame(QuicStreamFrame(stream_id, /*fin=*/false, | 756 stream2->OnStreamFrame(QuicStreamFrame(stream_id, /*fin=*/false, |
762 /*offset=*/0, data)); | 757 /*offset=*/0, data)); |
763 | 758 |
764 // Now set the delegate and verify that the headers are delivered, but | 759 // Now set the delegate and verify that the headers are delivered, but |
765 // not the data, which needs to be read explicitly. | 760 // not the data, which needs to be read explicitly. |
766 EXPECT_CALL(delegate2_, OnInitialHeadersAvailableMock( | |
767 _, header_list.uncompressed_header_bytes())); | |
768 handle2_ = stream2->CreateHandle(&delegate2_); | 761 handle2_ = stream2->CreateHandle(&delegate2_); |
769 base::RunLoop().RunUntilIdle(); | 762 TestCompletionCallback callback; |
| 763 EXPECT_EQ( |
| 764 static_cast<int>(header_list.uncompressed_header_bytes()), |
| 765 handle2_->ReadInitialHeaders(&delegate2_.headers_, callback.callback())); |
770 EXPECT_EQ(headers_, delegate2_.headers_); | 766 EXPECT_EQ(headers_, delegate2_.headers_); |
771 base::RunLoop().RunUntilIdle(); | 767 base::RunLoop().RunUntilIdle(); |
772 | 768 |
773 // Now explicitly read the data. | 769 // Now explicitly read the data. |
774 int data_len = arraysize(data) - 1; | 770 int data_len = arraysize(data) - 1; |
775 scoped_refptr<IOBuffer> buffer(new IOBuffer(data_len + 1)); | 771 scoped_refptr<IOBuffer> buffer(new IOBuffer(data_len + 1)); |
776 ASSERT_EQ(data_len, stream2->Read(buffer.get(), data_len + 1)); | 772 ASSERT_EQ(data_len, stream2->Read(buffer.get(), data_len + 1)); |
777 EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len)); | 773 EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len)); |
778 | 774 |
779 // Both delegates should be notified that theirs streams are closed. | 775 // Both delegates should be notified that theirs streams are closed. |
780 EXPECT_CALL(delegate2_, OnClose()); | 776 EXPECT_CALL(delegate2_, OnClose()); |
781 EXPECT_CALL(delegate_, OnClose()); | 777 EXPECT_CALL(delegate_, OnClose()); |
782 } | 778 } |
783 | 779 |
784 } // namespace | 780 } // namespace |
785 } // namespace test | 781 } // namespace test |
786 } // namespace net | 782 } // namespace net |
OLD | NEW |