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/quic_reliable_client_stream.h" | 5 #include "net/quic/quic_reliable_client_stream.h" |
6 | 6 |
7 #include "net/base/net_errors.h" | 7 #include "net/base/net_errors.h" |
8 #include "net/base/test_completion_callback.h" | 8 #include "net/base/test_completion_callback.h" |
9 #include "net/quic/quic_chromium_client_session.h" | 9 #include "net/quic/quic_chromium_client_session.h" |
10 #include "net/quic/quic_utils.h" | 10 #include "net/quic/quic_utils.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 namespace { | 25 namespace { |
26 | 26 |
27 const QuicStreamId kTestStreamId = 5u; | 27 const QuicStreamId kTestStreamId = 5u; |
28 | 28 |
29 class MockDelegate : public QuicReliableClientStream::Delegate { | 29 class MockDelegate : public QuicReliableClientStream::Delegate { |
30 public: | 30 public: |
31 MockDelegate() {} | 31 MockDelegate() {} |
32 | 32 |
33 MOCK_METHOD0(OnSendData, int()); | 33 MOCK_METHOD0(OnSendData, int()); |
34 MOCK_METHOD2(OnSendDataComplete, int(int, bool*)); | 34 MOCK_METHOD2(OnSendDataComplete, int(int, bool*)); |
35 MOCK_METHOD1(OnHeadersAvailable, void(const SpdyHeaderBlock&)); | 35 MOCK_METHOD2(OnHeadersAvailable, void(const SpdyHeaderBlock&, size_t)); |
36 MOCK_METHOD2(OnDataReceived, int(const char*, int)); | 36 MOCK_METHOD2(OnDataReceived, int(const char*, int)); |
37 MOCK_METHOD0(OnDataAvailable, void()); | 37 MOCK_METHOD0(OnDataAvailable, void()); |
38 MOCK_METHOD1(OnClose, void(QuicErrorCode)); | 38 MOCK_METHOD1(OnClose, void(QuicErrorCode)); |
39 MOCK_METHOD1(OnError, void(int)); | 39 MOCK_METHOD1(OnError, void(int)); |
40 MOCK_METHOD0(HasSendHeadersComplete, bool()); | 40 MOCK_METHOD0(HasSendHeadersComplete, bool()); |
41 | 41 |
42 private: | 42 private: |
43 DISALLOW_COPY_AND_ASSIGN(MockDelegate); | 43 DISALLOW_COPY_AND_ASSIGN(MockDelegate); |
44 }; | 44 }; |
45 | 45 |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
104 ::testing::ValuesIn(QuicSupportedVersions())); | 104 ::testing::ValuesIn(QuicSupportedVersions())); |
105 | 105 |
106 TEST_P(QuicReliableClientStreamTest, OnFinRead) { | 106 TEST_P(QuicReliableClientStreamTest, OnFinRead) { |
107 InitializeHeaders(); | 107 InitializeHeaders(); |
108 std::string uncompressed_headers = | 108 std::string uncompressed_headers = |
109 SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam()); | 109 SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam()); |
110 QuicStreamOffset offset = 0; | 110 QuicStreamOffset offset = 0; |
111 stream_->OnStreamHeaders(uncompressed_headers); | 111 stream_->OnStreamHeaders(uncompressed_headers); |
112 stream_->OnStreamHeadersComplete(false, uncompressed_headers.length()); | 112 stream_->OnStreamHeadersComplete(false, uncompressed_headers.length()); |
113 | 113 |
114 EXPECT_CALL(delegate_, OnHeadersAvailable(headers_)); | 114 EXPECT_CALL(delegate_, |
| 115 OnHeadersAvailable(headers_, uncompressed_headers.length())); |
115 base::MessageLoop::current()->RunUntilIdle(); | 116 base::MessageLoop::current()->RunUntilIdle(); |
116 EXPECT_TRUE(stream_->decompressed_headers().empty()); | 117 EXPECT_TRUE(stream_->decompressed_headers().empty()); |
117 | 118 |
118 QuicStreamFrame frame2(kTestStreamId, true, offset, StringPiece()); | 119 QuicStreamFrame frame2(kTestStreamId, true, offset, StringPiece()); |
119 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | 120 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); |
120 stream_->OnStreamFrame(frame2); | 121 stream_->OnStreamFrame(frame2); |
121 } | 122 } |
122 | 123 |
123 TEST_P(QuicReliableClientStreamTest, OnDataAvailableBeforeHeaders) { | 124 TEST_P(QuicReliableClientStreamTest, OnDataAvailableBeforeHeaders) { |
124 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | 125 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); |
125 | 126 |
126 EXPECT_CALL(delegate_, OnDataAvailable()).Times(0); | 127 EXPECT_CALL(delegate_, OnDataAvailable()).Times(0); |
127 stream_->OnDataAvailable(); | 128 stream_->OnDataAvailable(); |
128 } | 129 } |
129 | 130 |
130 TEST_P(QuicReliableClientStreamTest, OnDataAvailable) { | 131 TEST_P(QuicReliableClientStreamTest, OnDataAvailable) { |
131 InitializeHeaders(); | 132 InitializeHeaders(); |
132 std::string uncompressed_headers = | 133 std::string uncompressed_headers = |
133 SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam()); | 134 SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam()); |
134 stream_->OnStreamHeaders(uncompressed_headers); | 135 stream_->OnStreamHeaders(uncompressed_headers); |
135 stream_->OnStreamHeadersComplete(false, uncompressed_headers.length()); | 136 stream_->OnStreamHeadersComplete(false, uncompressed_headers.length()); |
136 | 137 |
137 EXPECT_CALL(delegate_, OnHeadersAvailable(headers_)); | 138 EXPECT_CALL(delegate_, |
| 139 OnHeadersAvailable(headers_, uncompressed_headers.length())); |
138 base::MessageLoop::current()->RunUntilIdle(); | 140 base::MessageLoop::current()->RunUntilIdle(); |
139 EXPECT_TRUE(stream_->decompressed_headers().empty()); | 141 EXPECT_TRUE(stream_->decompressed_headers().empty()); |
140 | 142 |
141 const char data[] = "hello world!"; | 143 const char data[] = "hello world!"; |
142 stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false, | 144 stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false, |
143 /*offset=*/0, data)); | 145 /*offset=*/0, data)); |
144 | 146 |
145 EXPECT_CALL(delegate_, OnDataAvailable()) | 147 EXPECT_CALL(delegate_, OnDataAvailable()) |
146 .WillOnce(testing::Invoke( | 148 .WillOnce(testing::Invoke( |
147 CreateFunctor(this, &QuicReliableClientStreamTest::ReadData, | 149 CreateFunctor(this, &QuicReliableClientStreamTest::ReadData, |
(...skipping 15 matching lines...) Expand all Loading... |
163 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); | 165 EXPECT_CALL(delegate_, OnClose(QUIC_NO_ERROR)); |
164 } | 166 } |
165 | 167 |
166 TEST_P(QuicReliableClientStreamTest, OnDataAvailableWithError) { | 168 TEST_P(QuicReliableClientStreamTest, OnDataAvailableWithError) { |
167 InitializeHeaders(); | 169 InitializeHeaders(); |
168 std::string uncompressed_headers = | 170 std::string uncompressed_headers = |
169 SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam()); | 171 SpdyUtils::SerializeUncompressedHeaders(headers_, GetParam()); |
170 stream_->OnStreamHeaders(uncompressed_headers); | 172 stream_->OnStreamHeaders(uncompressed_headers); |
171 stream_->OnStreamHeadersComplete(false, uncompressed_headers.length()); | 173 stream_->OnStreamHeadersComplete(false, uncompressed_headers.length()); |
172 | 174 |
173 EXPECT_CALL(delegate_, OnHeadersAvailable(headers_)); | 175 EXPECT_CALL(delegate_, |
| 176 OnHeadersAvailable(headers_, uncompressed_headers.length())); |
174 base::MessageLoop::current()->RunUntilIdle(); | 177 base::MessageLoop::current()->RunUntilIdle(); |
175 EXPECT_TRUE(stream_->decompressed_headers().empty()); | 178 EXPECT_TRUE(stream_->decompressed_headers().empty()); |
176 | 179 |
177 const char data[] = "hello world!"; | 180 const char data[] = "hello world!"; |
178 stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false, | 181 stream_->OnStreamFrame(QuicStreamFrame(kTestStreamId, /*fin=*/false, |
179 /*offset=*/0, data)); | 182 /*offset=*/0, data)); |
180 EXPECT_CALL(delegate_, OnDataAvailable()) | 183 EXPECT_CALL(delegate_, OnDataAvailable()) |
181 .WillOnce(testing::Invoke(CreateFunctor( | 184 .WillOnce(testing::Invoke(CreateFunctor( |
182 stream_, &QuicReliableClientStream::Reset, QUIC_STREAM_CANCELLED))); | 185 stream_, &QuicReliableClientStream::Reset, QUIC_STREAM_CANCELLED))); |
183 base::MessageLoop::current()->RunUntilIdle(); | 186 base::MessageLoop::current()->RunUntilIdle(); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
226 EXPECT_CALL(session_, WritevData(stream_->id(), _, _, _, _, _)).WillOnce( | 229 EXPECT_CALL(session_, WritevData(stream_->id(), _, _, _, _, _)).WillOnce( |
227 Return(QuicConsumedData(kDataLen, true))); | 230 Return(QuicConsumedData(kDataLen, true))); |
228 stream_->OnCanWrite(); | 231 stream_->OnCanWrite(); |
229 ASSERT_TRUE(callback.have_result()); | 232 ASSERT_TRUE(callback.have_result()); |
230 EXPECT_EQ(OK, callback.WaitForResult()); | 233 EXPECT_EQ(OK, callback.WaitForResult()); |
231 } | 234 } |
232 | 235 |
233 } // namespace | 236 } // namespace |
234 } // namespace test | 237 } // namespace test |
235 } // namespace net | 238 } // namespace net |
OLD | NEW |