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_METHOD2(OnDataReceived, int(const char*, int)); | 54 MOCK_METHOD2(OnDataReceived, int(const char*, int)); |
62 MOCK_METHOD0(OnDataAvailable, void()); | 55 MOCK_METHOD0(OnDataAvailable, void()); |
63 MOCK_METHOD0(OnClose, void()); | 56 MOCK_METHOD0(OnClose, void()); |
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
254 } | 247 } |
255 | 248 |
256 QuicHeaderList ProcessTrailers(const SpdyHeaderBlock& headers) { | 249 QuicHeaderList ProcessTrailers(const SpdyHeaderBlock& headers) { |
257 QuicHeaderList h = AsHeaderList(headers); | 250 QuicHeaderList h = AsHeaderList(headers); |
258 stream_->OnStreamHeaderList(true, h.uncompressed_header_bytes(), h); | 251 stream_->OnStreamHeaderList(true, h.uncompressed_header_bytes(), h); |
259 return h; | 252 return h; |
260 } | 253 } |
261 | 254 |
262 QuicHeaderList ProcessHeadersFull(const SpdyHeaderBlock& headers) { | 255 QuicHeaderList ProcessHeadersFull(const SpdyHeaderBlock& headers) { |
263 QuicHeaderList h = ProcessHeaders(headers); | 256 QuicHeaderList h = ProcessHeaders(headers); |
264 EXPECT_CALL(delegate_, OnInitialHeadersAvailableMock( | 257 TestCompletionCallback callback; |
265 _, h.uncompressed_header_bytes())); | 258 EXPECT_EQ( |
266 base::RunLoop().RunUntilIdle(); | 259 static_cast<int>(h.uncompressed_header_bytes()), |
| 260 handle_->ReadInitialHeaders(&delegate_.headers_, callback.callback())); |
267 EXPECT_EQ(headers, delegate_.headers_); | 261 EXPECT_EQ(headers, delegate_.headers_); |
268 EXPECT_TRUE(stream_->header_list().empty()); | 262 EXPECT_TRUE(stream_->header_list().empty()); |
269 return h; | 263 return h; |
270 } | 264 } |
271 | 265 |
272 QuicStreamId GetNthClientInitiatedStreamId(int n) { | 266 QuicStreamId GetNthClientInitiatedStreamId(int n) { |
273 return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n); | 267 return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n); |
274 } | 268 } |
275 | 269 |
276 QuicStreamId GetNthServerInitiatedStreamId(int n) { | 270 QuicStreamId GetNthServerInitiatedStreamId(int n) { |
(...skipping 455 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
732 | 726 |
733 InitializeHeaders(); | 727 InitializeHeaders(); |
734 | 728 |
735 // Receive the headers before the delegate is set. | 729 // Receive the headers before the delegate is set. |
736 QuicHeaderList header_list = AsHeaderList(headers_); | 730 QuicHeaderList header_list = AsHeaderList(headers_); |
737 stream2->OnStreamHeaderList(true, header_list.uncompressed_header_bytes(), | 731 stream2->OnStreamHeaderList(true, header_list.uncompressed_header_bytes(), |
738 header_list); | 732 header_list); |
739 EXPECT_TRUE(delegate2_.headers_.empty()); | 733 EXPECT_TRUE(delegate2_.headers_.empty()); |
740 | 734 |
741 // Now set the delegate and verify that the headers are delivered. | 735 // Now set the delegate and verify that the headers are delivered. |
742 EXPECT_CALL(delegate2_, OnInitialHeadersAvailableMock( | |
743 _, header_list.uncompressed_header_bytes())); | |
744 handle2_ = stream2->CreateHandle(&delegate2_); | 736 handle2_ = stream2->CreateHandle(&delegate2_); |
745 base::RunLoop().RunUntilIdle(); | 737 TestCompletionCallback callback; |
| 738 EXPECT_EQ( |
| 739 static_cast<int>(header_list.uncompressed_header_bytes()), |
| 740 handle2_->ReadInitialHeaders(&delegate2_.headers_, callback.callback())); |
746 EXPECT_EQ(headers_, delegate2_.headers_); | 741 EXPECT_EQ(headers_, delegate2_.headers_); |
747 | 742 |
748 // Both delegates should be notified that theirs streams are closed. | 743 // Both delegates should be notified that theirs streams are closed. |
749 EXPECT_CALL(delegate2_, OnClose()); | 744 EXPECT_CALL(delegate2_, OnClose()); |
750 EXPECT_CALL(delegate_, OnClose()); | 745 EXPECT_CALL(delegate_, OnClose()); |
751 } | 746 } |
752 | 747 |
753 TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeDelegate) { | 748 TEST_P(QuicChromiumClientStreamTest, HeadersAndDataBeforeDelegate) { |
754 // We don't use stream_ because we want an incoming server push | 749 // We don't use stream_ because we want an incoming server push |
755 // stream. | 750 // stream. |
756 QuicStreamId stream_id = GetNthServerInitiatedStreamId(0); | 751 QuicStreamId stream_id = GetNthServerInitiatedStreamId(0); |
757 QuicChromiumClientStream* stream2 = | 752 QuicChromiumClientStream* stream2 = |
758 new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource()); | 753 new QuicChromiumClientStream(stream_id, &session_, NetLogWithSource()); |
759 session_.ActivateStream(base::WrapUnique(stream2)); | 754 session_.ActivateStream(base::WrapUnique(stream2)); |
760 | 755 |
761 InitializeHeaders(); | 756 InitializeHeaders(); |
762 | 757 |
763 // Receive the headers and data before the delegate is set. | 758 // Receive the headers and data before the delegate is set. |
764 QuicHeaderList header_list = AsHeaderList(headers_); | 759 QuicHeaderList header_list = AsHeaderList(headers_); |
765 stream2->OnStreamHeaderList(false, header_list.uncompressed_header_bytes(), | 760 stream2->OnStreamHeaderList(false, header_list.uncompressed_header_bytes(), |
766 header_list); | 761 header_list); |
767 EXPECT_TRUE(delegate2_.headers_.empty()); | 762 EXPECT_TRUE(delegate2_.headers_.empty()); |
768 const char data[] = "hello world!"; | 763 const char data[] = "hello world!"; |
769 stream2->OnStreamFrame(QuicStreamFrame(stream_id, /*fin=*/false, | 764 stream2->OnStreamFrame(QuicStreamFrame(stream_id, /*fin=*/false, |
770 /*offset=*/0, data)); | 765 /*offset=*/0, data)); |
771 | 766 |
772 // Now set the delegate and verify that the headers are delivered, but | 767 // Now set the delegate and verify that the headers are delivered, but |
773 // not the data, which needs to be read explicitly. | 768 // not the data, which needs to be read explicitly. |
774 EXPECT_CALL(delegate2_, OnInitialHeadersAvailableMock( | |
775 _, header_list.uncompressed_header_bytes())); | |
776 handle2_ = stream2->CreateHandle(&delegate2_); | 769 handle2_ = stream2->CreateHandle(&delegate2_); |
777 base::RunLoop().RunUntilIdle(); | 770 TestCompletionCallback callback; |
| 771 EXPECT_EQ( |
| 772 static_cast<int>(header_list.uncompressed_header_bytes()), |
| 773 handle2_->ReadInitialHeaders(&delegate2_.headers_, callback.callback())); |
778 EXPECT_EQ(headers_, delegate2_.headers_); | 774 EXPECT_EQ(headers_, delegate2_.headers_); |
779 base::RunLoop().RunUntilIdle(); | 775 base::RunLoop().RunUntilIdle(); |
780 | 776 |
781 // Now explicitly read the data. | 777 // Now explicitly read the data. |
782 int data_len = arraysize(data) - 1; | 778 int data_len = arraysize(data) - 1; |
783 scoped_refptr<IOBuffer> buffer(new IOBuffer(data_len + 1)); | 779 scoped_refptr<IOBuffer> buffer(new IOBuffer(data_len + 1)); |
784 ASSERT_EQ(data_len, stream2->Read(buffer.get(), data_len + 1)); | 780 ASSERT_EQ(data_len, stream2->Read(buffer.get(), data_len + 1)); |
785 EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len)); | 781 EXPECT_EQ(QuicStringPiece(data), QuicStringPiece(buffer->data(), data_len)); |
786 | 782 |
787 // Both delegates should be notified that theirs streams are closed. | 783 // Both delegates should be notified that theirs streams are closed. |
788 EXPECT_CALL(delegate2_, OnClose()); | 784 EXPECT_CALL(delegate2_, OnClose()); |
789 EXPECT_CALL(delegate_, OnClose()); | 785 EXPECT_CALL(delegate_, OnClose()); |
790 } | 786 } |
791 | 787 |
792 } // namespace | 788 } // namespace |
793 } // namespace test | 789 } // namespace test |
794 } // namespace net | 790 } // namespace net |
OLD | NEW |