OLD | NEW |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2013 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/tools/quic/quic_simple_server_stream.h" | 5 #include "net/tools/quic/quic_simple_server_stream.h" |
6 | 6 |
7 #include "base/strings/string_number_conversions.h" | 7 #include "base/strings/string_number_conversions.h" |
8 #include "base/strings/string_piece.h" | 8 #include "base/strings/string_piece.h" |
9 #include "net/quic/quic_connection.h" | 9 #include "net/quic/quic_connection.h" |
10 #include "net/quic/quic_flags.h" | 10 #include "net/quic/quic_flags.h" |
(...skipping 24 matching lines...) Expand all Loading... |
35 using std::string; | 35 using std::string; |
36 using testing::_; | 36 using testing::_; |
37 using testing::AnyNumber; | 37 using testing::AnyNumber; |
38 using testing::Invoke; | 38 using testing::Invoke; |
39 using testing::InvokeArgument; | 39 using testing::InvokeArgument; |
40 using testing::InSequence; | 40 using testing::InSequence; |
41 using testing::Return; | 41 using testing::Return; |
42 using testing::StrictMock; | 42 using testing::StrictMock; |
43 using testing::WithArgs; | 43 using testing::WithArgs; |
44 | 44 |
45 DECLARE_bool(quic_always_log_bugs_for_tests); | |
46 | |
47 namespace net { | 45 namespace net { |
48 namespace test { | 46 namespace test { |
49 | 47 |
50 class QuicSimpleServerStreamPeer : public QuicSimpleServerStream { | 48 class QuicSimpleServerStreamPeer : public QuicSimpleServerStream { |
51 public: | 49 public: |
52 QuicSimpleServerStreamPeer(QuicStreamId stream_id, QuicSpdySession* session) | 50 QuicSimpleServerStreamPeer(QuicStreamId stream_id, QuicSpdySession* session) |
53 : QuicSimpleServerStream(stream_id, session) {} | 51 : QuicSimpleServerStream(stream_id, session) {} |
54 | 52 |
55 ~QuicSimpleServerStreamPeer() override{}; | 53 ~QuicSimpleServerStreamPeer() override{}; |
56 | 54 |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
89 MockQuicServerSessionVisitor* owner, | 87 MockQuicServerSessionVisitor* owner, |
90 QuicCryptoServerConfig* crypto_config, | 88 QuicCryptoServerConfig* crypto_config, |
91 QuicCompressedCertsCache* compressed_certs_cache) | 89 QuicCompressedCertsCache* compressed_certs_cache) |
92 : QuicSimpleServerSession(DefaultQuicConfig(), | 90 : QuicSimpleServerSession(DefaultQuicConfig(), |
93 connection, | 91 connection, |
94 owner, | 92 owner, |
95 crypto_config, | 93 crypto_config, |
96 compressed_certs_cache) { | 94 compressed_certs_cache) { |
97 set_max_open_incoming_streams(kMaxStreamsForTest); | 95 set_max_open_incoming_streams(kMaxStreamsForTest); |
98 set_max_open_outgoing_streams(kMaxStreamsForTest); | 96 set_max_open_outgoing_streams(kMaxStreamsForTest); |
99 ON_CALL(*this, WritevData(_, _, _, _, _)) | 97 ON_CALL(*this, WritevData(_, _, _, _, _, _)) |
100 .WillByDefault(testing::Return(QuicConsumedData(0, false))); | 98 .WillByDefault(testing::Return(QuicConsumedData(0, false))); |
101 } | 99 } |
102 | 100 |
103 ~MockQuicSimpleServerSession() override {} | 101 ~MockQuicSimpleServerSession() override {} |
104 | 102 |
105 MOCK_METHOD3(OnConnectionClosed, | 103 MOCK_METHOD3(OnConnectionClosed, |
106 void(QuicErrorCode error, | 104 void(QuicErrorCode error, |
107 const string& error_details, | 105 const string& error_details, |
108 ConnectionCloseSource source)); | 106 ConnectionCloseSource source)); |
109 MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id)); | 107 MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id)); |
110 MOCK_METHOD5(WritevData, | 108 MOCK_METHOD6(WritevData, |
111 QuicConsumedData(QuicStreamId id, | 109 QuicConsumedData(ReliableQuicStream* stream, |
| 110 QuicStreamId id, |
112 QuicIOVector data, | 111 QuicIOVector data, |
113 QuicStreamOffset offset, | 112 QuicStreamOffset offset, |
114 bool fin, | 113 bool fin, |
115 QuicAckListenerInterface*)); | 114 QuicAckListenerInterface*)); |
116 MOCK_METHOD2(OnStreamHeaders, | 115 MOCK_METHOD2(OnStreamHeaders, |
117 void(QuicStreamId stream_id, StringPiece headers_data)); | 116 void(QuicStreamId stream_id, StringPiece headers_data)); |
118 MOCK_METHOD2(OnStreamHeadersPriority, | 117 MOCK_METHOD2(OnStreamHeadersPriority, |
119 void(QuicStreamId stream_id, SpdyPriority priority)); | 118 void(QuicStreamId stream_id, SpdyPriority priority)); |
120 MOCK_METHOD3(OnStreamHeadersComplete, | 119 MOCK_METHOD3(OnStreamHeadersComplete, |
121 void(QuicStreamId stream_id, bool fin, size_t frame_len)); | 120 void(QuicStreamId stream_id, bool fin, size_t frame_len)); |
122 MOCK_METHOD5(WriteHeaders, | 121 MOCK_METHOD5(WriteHeaders, |
123 size_t(QuicStreamId id, | 122 size_t(QuicStreamId id, |
124 const SpdyHeaderBlock& headers, | 123 const SpdyHeaderBlock& headers, |
125 bool fin, | 124 bool fin, |
126 SpdyPriority priority, | 125 SpdyPriority priority, |
127 QuicAckListenerInterface* ack_notifier_delegate)); | 126 QuicAckListenerInterface* ack_notifier_delegate)); |
128 MOCK_METHOD3(SendRstStream, | 127 MOCK_METHOD3(SendRstStream, |
129 void(QuicStreamId stream_id, | 128 void(QuicStreamId stream_id, |
130 QuicRstStreamErrorCode error, | 129 QuicRstStreamErrorCode error, |
131 QuicStreamOffset bytes_written)); | 130 QuicStreamOffset bytes_written)); |
132 MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta)); | 131 MOCK_METHOD1(OnHeadersHeadOfLineBlocking, void(QuicTime::Delta delta)); |
133 MOCK_METHOD4(PromisePushResources, | 132 MOCK_METHOD4(PromisePushResources, |
134 void(const string&, | 133 void(const string&, |
135 const list<QuicInMemoryCache::ServerPushInfo>&, | 134 const std::list<QuicInMemoryCache::ServerPushInfo>&, |
136 QuicStreamId, | 135 QuicStreamId, |
137 const SpdyHeaderBlock&)); | 136 const SpdyHeaderBlock&)); |
138 | 137 |
139 using QuicSession::ActivateStream; | 138 using QuicSession::ActivateStream; |
140 | 139 |
141 private: | 140 private: |
142 DISALLOW_COPY_AND_ASSIGN(MockQuicSimpleServerSession); | 141 DISALLOW_COPY_AND_ASSIGN(MockQuicSimpleServerSession); |
143 }; | 142 }; |
144 | 143 |
145 namespace { | 144 namespace { |
146 | 145 |
147 class QuicSimpleServerStreamTest | 146 class QuicSimpleServerStreamTest |
148 : public ::testing::TestWithParam<QuicVersion> { | 147 : public ::testing::TestWithParam<QuicVersion> { |
149 public: | 148 public: |
150 QuicSimpleServerStreamTest() | 149 QuicSimpleServerStreamTest() |
151 : connection_( | 150 : connection_( |
152 new StrictMock<MockQuicConnection>(&helper_, | 151 new StrictMock<MockQuicConnection>(&helper_, |
153 &alarm_factory_, | 152 &alarm_factory_, |
154 Perspective::IS_SERVER, | 153 Perspective::IS_SERVER, |
155 SupportedVersions(GetParam()))), | 154 SupportedVersions(GetParam()))), |
156 session_owner_(new StrictMock<MockQuicServerSessionVisitor>()), | |
157 crypto_config_(new QuicCryptoServerConfig( | 155 crypto_config_(new QuicCryptoServerConfig( |
158 QuicCryptoServerConfig::TESTING, | 156 QuicCryptoServerConfig::TESTING, |
159 QuicRandom::GetInstance(), | 157 QuicRandom::GetInstance(), |
160 ::net::test::CryptoTestUtils::ProofSourceForTesting())), | 158 ::net::test::CryptoTestUtils::ProofSourceForTesting())), |
161 compressed_certs_cache_( | 159 compressed_certs_cache_( |
162 QuicCompressedCertsCache::kQuicCompressedCertsCacheSize), | 160 QuicCompressedCertsCache::kQuicCompressedCertsCacheSize), |
163 session_(connection_, | 161 session_(connection_, |
164 session_owner_, | 162 &session_owner_, |
165 crypto_config_.get(), | 163 crypto_config_.get(), |
166 &compressed_certs_cache_), | 164 &compressed_certs_cache_), |
167 body_("hello world") { | 165 body_("hello world") { |
168 FLAGS_quic_always_log_bugs_for_tests = true; | 166 FLAGS_quic_always_log_bugs_for_tests = true; |
169 SpdyHeaderBlock request_headers; | 167 SpdyHeaderBlock request_headers; |
170 request_headers[":host"] = ""; | 168 request_headers[":host"] = ""; |
171 request_headers[":authority"] = "www.google.com"; | 169 request_headers[":authority"] = "www.google.com"; |
172 request_headers[":path"] = "/"; | 170 request_headers[":path"] = "/"; |
173 request_headers[":method"] = "POST"; | 171 request_headers[":method"] = "POST"; |
174 request_headers[":version"] = "HTTP/1.1"; | 172 request_headers[":version"] = "HTTP/1.1"; |
(...skipping 25 matching lines...) Expand all Loading... |
200 } | 198 } |
201 | 199 |
202 StringPiece StreamHeadersValue(const string& key) { | 200 StringPiece StreamHeadersValue(const string& key) { |
203 return (*stream_->mutable_headers())[key]; | 201 return (*stream_->mutable_headers())[key]; |
204 } | 202 } |
205 | 203 |
206 SpdyHeaderBlock response_headers_; | 204 SpdyHeaderBlock response_headers_; |
207 MockQuicConnectionHelper helper_; | 205 MockQuicConnectionHelper helper_; |
208 MockAlarmFactory alarm_factory_; | 206 MockAlarmFactory alarm_factory_; |
209 StrictMock<MockQuicConnection>* connection_; | 207 StrictMock<MockQuicConnection>* connection_; |
210 StrictMock<MockQuicServerSessionVisitor>* session_owner_; | 208 StrictMock<MockQuicServerSessionVisitor> session_owner_; |
211 std::unique_ptr<QuicCryptoServerConfig> crypto_config_; | 209 std::unique_ptr<QuicCryptoServerConfig> crypto_config_; |
212 QuicCompressedCertsCache compressed_certs_cache_; | 210 QuicCompressedCertsCache compressed_certs_cache_; |
213 StrictMock<MockQuicSimpleServerSession> session_; | 211 StrictMock<MockQuicSimpleServerSession> session_; |
214 QuicSimpleServerStreamPeer* stream_; // Owned by session_. | 212 QuicSimpleServerStreamPeer* stream_; // Owned by session_. |
215 string headers_string_; | 213 string headers_string_; |
216 string body_; | 214 string body_; |
217 }; | 215 }; |
218 | 216 |
219 INSTANTIATE_TEST_CASE_P(Tests, | 217 INSTANTIATE_TEST_CASE_P(Tests, |
220 QuicSimpleServerStreamTest, | 218 QuicSimpleServerStreamTest, |
221 ::testing::ValuesIn(QuicSupportedVersions())); | 219 ::testing::ValuesIn(QuicSupportedVersions())); |
222 | 220 |
223 TEST_P(QuicSimpleServerStreamTest, TestFraming) { | 221 TEST_P(QuicSimpleServerStreamTest, TestFraming) { |
224 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 222 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
225 .Times(AnyNumber()) | 223 .Times(AnyNumber()) |
226 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | 224 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); |
227 stream_->OnStreamHeaders(headers_string_); | 225 stream_->OnStreamHeaders(headers_string_); |
228 stream_->OnStreamHeadersComplete(false, headers_string_.size()); | 226 stream_->OnStreamHeadersComplete(false, headers_string_.size()); |
229 stream_->OnStreamFrame( | 227 stream_->OnStreamFrame( |
230 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); | 228 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); |
231 EXPECT_EQ("11", StreamHeadersValue("content-length")); | 229 EXPECT_EQ("11", StreamHeadersValue("content-length")); |
232 EXPECT_EQ("/", StreamHeadersValue(":path")); | 230 EXPECT_EQ("/", StreamHeadersValue(":path")); |
233 EXPECT_EQ("POST", StreamHeadersValue(":method")); | 231 EXPECT_EQ("POST", StreamHeadersValue(":method")); |
234 EXPECT_EQ(body_, StreamBody()); | 232 EXPECT_EQ(body_, StreamBody()); |
235 } | 233 } |
236 | 234 |
237 TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) { | 235 TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) { |
238 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 236 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
239 .Times(AnyNumber()) | 237 .Times(AnyNumber()) |
240 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | 238 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); |
241 | 239 |
242 stream_->OnStreamHeaders(headers_string_); | 240 stream_->OnStreamHeaders(headers_string_); |
243 stream_->OnStreamHeadersComplete(false, headers_string_.size()); | 241 stream_->OnStreamHeadersComplete(false, headers_string_.size()); |
244 stream_->OnStreamFrame( | 242 stream_->OnStreamFrame( |
245 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); | 243 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); |
246 EXPECT_EQ("11", StreamHeadersValue("content-length")); | 244 EXPECT_EQ("11", StreamHeadersValue("content-length")); |
247 EXPECT_EQ("/", StreamHeadersValue(":path")); | 245 EXPECT_EQ("/", StreamHeadersValue(":path")); |
248 EXPECT_EQ("POST", StreamHeadersValue(":method")); | 246 EXPECT_EQ("POST", StreamHeadersValue(":method")); |
249 EXPECT_EQ(body_, StreamBody()); | 247 EXPECT_EQ(body_, StreamBody()); |
250 } | 248 } |
251 | 249 |
252 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) { | 250 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) { |
253 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 251 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
254 .Times(AnyNumber()) | 252 .Times(AnyNumber()) |
255 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | 253 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); |
256 | 254 |
257 EXPECT_FALSE(stream_->fin_received()); | 255 EXPECT_FALSE(stream_->fin_received()); |
258 EXPECT_FALSE(stream_->rst_received()); | 256 EXPECT_FALSE(stream_->rst_received()); |
259 | 257 |
260 stream_->set_fin_sent(true); | 258 stream_->set_fin_sent(true); |
261 stream_->CloseWriteSide(); | 259 stream_->CloseWriteSide(); |
262 | 260 |
263 if (GetParam() > QUIC_VERSION_28) { | 261 if (GetParam() > QUIC_VERSION_28) { |
264 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1); | 262 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1); |
265 } else { | 263 } else { |
266 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); | 264 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); |
267 } | 265 } |
268 stream_->StopReading(); | 266 stream_->StopReading(); |
269 } | 267 } |
270 | 268 |
271 TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) { | 269 TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) { |
272 string large_body = "hello world!!!!!!"; | 270 string large_body = "hello world!!!!!!"; |
273 | 271 |
274 // We'll automatically write out an error (headers + body) | 272 // We'll automatically write out an error (headers + body) |
275 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); | 273 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); |
276 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 274 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
277 .WillOnce(Invoke(MockQuicSession::ConsumeAllData)); | 275 .WillOnce(Invoke(MockQuicSession::ConsumeAllData)); |
278 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); | 276 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); |
279 | 277 |
280 stream_->OnStreamHeaders(headers_string_); | 278 stream_->OnStreamHeaders(headers_string_); |
281 stream_->OnStreamHeadersComplete(false, headers_string_.size()); | 279 stream_->OnStreamHeadersComplete(false, headers_string_.size()); |
282 stream_->OnStreamFrame( | 280 stream_->OnStreamFrame( |
283 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); | 281 QuicStreamFrame(stream_->id(), /*fin=*/false, /*offset=*/0, body_)); |
284 // Content length is still 11. This will register as an error and we won't | 282 // Content length is still 11. This will register as an error and we won't |
285 // accept the bytes. | 283 // accept the bytes. |
286 stream_->OnStreamFrame( | 284 stream_->OnStreamFrame( |
(...skipping 16 matching lines...) Expand all Loading... |
303 response_headers_[":status"] = "200 OK"; | 301 response_headers_[":status"] = "200 OK"; |
304 response_headers_["content-length"] = "5"; | 302 response_headers_["content-length"] = "5"; |
305 string body = "Yummm"; | 303 string body = "Yummm"; |
306 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", | 304 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", |
307 response_headers_, body); | 305 response_headers_, body); |
308 | 306 |
309 stream_->set_fin_received(true); | 307 stream_->set_fin_received(true); |
310 | 308 |
311 InSequence s; | 309 InSequence s; |
312 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); | 310 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); |
313 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 311 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
314 .Times(1) | 312 .Times(1) |
315 .WillOnce(Return(QuicConsumedData( | 313 .WillOnce(Return(QuicConsumedData( |
316 strlen(QuicSimpleServerStream::kErrorResponseBody), true))); | 314 strlen(QuicSimpleServerStream::kErrorResponseBody), true))); |
317 | 315 |
318 QuicSimpleServerStreamPeer::SendResponse(stream_); | 316 QuicSimpleServerStreamPeer::SendResponse(stream_); |
319 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); | 317 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); |
320 EXPECT_TRUE(stream_->reading_stopped()); | 318 EXPECT_TRUE(stream_->reading_stopped()); |
321 EXPECT_TRUE(stream_->write_side_closed()); | 319 EXPECT_TRUE(stream_->write_side_closed()); |
322 } | 320 } |
323 | 321 |
(...skipping 10 matching lines...) Expand all Loading... |
334 response_headers_[":status"] = "+200"; | 332 response_headers_[":status"] = "+200"; |
335 response_headers_["content-length"] = "5"; | 333 response_headers_["content-length"] = "5"; |
336 string body = "Yummm"; | 334 string body = "Yummm"; |
337 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", | 335 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", |
338 response_headers_, body); | 336 response_headers_, body); |
339 | 337 |
340 stream_->set_fin_received(true); | 338 stream_->set_fin_received(true); |
341 | 339 |
342 InSequence s; | 340 InSequence s; |
343 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); | 341 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); |
344 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 342 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
345 .Times(1) | 343 .Times(1) |
346 .WillOnce(Return(QuicConsumedData( | 344 .WillOnce(Return(QuicConsumedData( |
347 strlen(QuicSimpleServerStream::kErrorResponseBody), true))); | 345 strlen(QuicSimpleServerStream::kErrorResponseBody), true))); |
348 | 346 |
349 QuicSimpleServerStreamPeer::SendResponse(stream_); | 347 QuicSimpleServerStreamPeer::SendResponse(stream_); |
350 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); | 348 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); |
351 EXPECT_TRUE(stream_->reading_stopped()); | 349 EXPECT_TRUE(stream_->reading_stopped()); |
352 EXPECT_TRUE(stream_->write_side_closed()); | 350 EXPECT_TRUE(stream_->write_side_closed()); |
353 } | 351 } |
354 | 352 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
391 response_headers_[":version"] = "HTTP/1.1"; | 389 response_headers_[":version"] = "HTTP/1.1"; |
392 response_headers_[":status"] = "200"; | 390 response_headers_[":status"] = "200"; |
393 response_headers_["content-length"] = "5"; | 391 response_headers_["content-length"] = "5"; |
394 string body = "Yummm"; | 392 string body = "Yummm"; |
395 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", | 393 QuicInMemoryCache::GetInstance()->AddResponse("www.google.com", "/bar", |
396 response_headers_, body); | 394 response_headers_, body); |
397 stream_->set_fin_received(true); | 395 stream_->set_fin_received(true); |
398 | 396 |
399 InSequence s; | 397 InSequence s; |
400 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); | 398 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); |
401 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 399 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
402 .Times(1) | 400 .Times(1) |
403 .WillOnce(Return(QuicConsumedData(body.length(), true))); | 401 .WillOnce(Return(QuicConsumedData(body.length(), true))); |
404 | 402 |
405 QuicSimpleServerStreamPeer::SendResponse(stream_); | 403 QuicSimpleServerStreamPeer::SendResponse(stream_); |
406 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); | 404 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); |
407 EXPECT_TRUE(stream_->reading_stopped()); | 405 EXPECT_TRUE(stream_->reading_stopped()); |
408 EXPECT_TRUE(stream_->write_side_closed()); | 406 EXPECT_TRUE(stream_->write_side_closed()); |
409 } | 407 } |
410 | 408 |
411 TEST_P(QuicSimpleServerStreamTest, SendReponseWithPushResources) { | 409 TEST_P(QuicSimpleServerStreamTest, SendReponseWithPushResources) { |
412 // Tests that if a reponse has push resources to be send, SendResponse() will | 410 // Tests that if a reponse has push resources to be send, SendResponse() will |
413 // call PromisePushResources() to handle these resources. | 411 // call PromisePushResources() to handle these resources. |
414 | 412 |
415 // Add a request and response with valid headers into cache. | 413 // Add a request and response with valid headers into cache. |
416 string host = "www.google.com"; | 414 string host = "www.google.com"; |
417 string request_path = "/foo"; | 415 string request_path = "/foo"; |
418 string body = "Yummm"; | 416 string body = "Yummm"; |
419 SpdyHeaderBlock response_headers; | 417 SpdyHeaderBlock response_headers; |
420 string url = host + "/bar"; | 418 string url = host + "/bar"; |
421 QuicInMemoryCache::ServerPushInfo push_info(GURL(url), response_headers, | 419 QuicInMemoryCache::ServerPushInfo push_info(GURL(url), response_headers, |
422 kDefaultPriority, "Push body"); | 420 kDefaultPriority, "Push body"); |
423 list<QuicInMemoryCache::ServerPushInfo> push_resources; | 421 std::list<QuicInMemoryCache::ServerPushInfo> push_resources; |
424 push_resources.push_back(push_info); | 422 push_resources.push_back(push_info); |
425 QuicInMemoryCache::GetInstance()->AddSimpleResponseWithServerPushResources( | 423 QuicInMemoryCache::GetInstance()->AddSimpleResponseWithServerPushResources( |
426 host, request_path, 200, body, push_resources); | 424 host, request_path, 200, body, push_resources); |
427 | 425 |
428 SpdyHeaderBlock* request_headers = stream_->mutable_headers(); | 426 SpdyHeaderBlock* request_headers = stream_->mutable_headers(); |
429 (*request_headers)[":path"] = request_path; | 427 (*request_headers)[":path"] = request_path; |
430 (*request_headers)[":authority"] = host; | 428 (*request_headers)[":authority"] = host; |
431 (*request_headers)[":version"] = "HTTP/1.1"; | 429 (*request_headers)[":version"] = "HTTP/1.1"; |
432 (*request_headers)[":method"] = "GET"; | 430 (*request_headers)[":method"] = "GET"; |
433 | 431 |
434 stream_->set_fin_received(true); | 432 stream_->set_fin_received(true); |
435 InSequence s; | 433 InSequence s; |
436 EXPECT_CALL(session_, PromisePushResources(host + request_path, _, | 434 EXPECT_CALL(session_, PromisePushResources(host + request_path, _, |
437 ::net::test::kClientDataStreamId1, | 435 ::net::test::kClientDataStreamId1, |
438 *request_headers)); | 436 *request_headers)); |
439 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); | 437 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, false, _, nullptr)); |
440 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 438 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
441 .Times(1) | 439 .Times(1) |
442 .WillOnce(Return(QuicConsumedData(body.length(), true))); | 440 .WillOnce(Return(QuicConsumedData(body.length(), true))); |
443 QuicSimpleServerStreamPeer::SendResponse(stream_); | 441 QuicSimpleServerStreamPeer::SendResponse(stream_); |
444 } | 442 } |
445 | 443 |
446 TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) { | 444 TEST_P(QuicSimpleServerStreamTest, PushResponseOnClientInitiatedStream) { |
447 // Calling PushResponse() on a client initialted stream is never supposed to | 445 // Calling PushResponse() on a client initialted stream is never supposed to |
448 // happen. | 446 // happen. |
449 SpdyHeaderBlock headers; | 447 SpdyHeaderBlock headers; |
450 EXPECT_DFATAL(stream_->PushResponse(headers), | 448 EXPECT_DFATAL(stream_->PushResponse(headers), |
(...skipping 25 matching lines...) Expand all Loading... |
476 response_headers_["content-length"] = "5"; | 474 response_headers_["content-length"] = "5"; |
477 const string kBody = "Hello"; | 475 const string kBody = "Hello"; |
478 QuicInMemoryCache::GetInstance()->AddResponse(kHost, kPath, response_headers_, | 476 QuicInMemoryCache::GetInstance()->AddResponse(kHost, kPath, response_headers_, |
479 kBody); | 477 kBody); |
480 | 478 |
481 // Call PushResponse() should trigger stream to fetch response from cache | 479 // Call PushResponse() should trigger stream to fetch response from cache |
482 // and send it back. | 480 // and send it back. |
483 EXPECT_CALL(session_, | 481 EXPECT_CALL(session_, |
484 WriteHeaders(kServerInitiatedStreamId, _, false, | 482 WriteHeaders(kServerInitiatedStreamId, _, false, |
485 server_initiated_stream->priority(), nullptr)); | 483 server_initiated_stream->priority(), nullptr)); |
486 EXPECT_CALL(session_, WritevData(kServerInitiatedStreamId, _, _, _, _)) | 484 EXPECT_CALL(session_, WritevData(_, kServerInitiatedStreamId, _, _, _, _)) |
487 .Times(1) | 485 .Times(1) |
488 .WillOnce(Return(QuicConsumedData(kBody.size(), true))); | 486 .WillOnce(Return(QuicConsumedData(kBody.size(), true))); |
489 server_initiated_stream->PushResponse(headers); | 487 server_initiated_stream->PushResponse(headers); |
490 EXPECT_EQ(kPath, QuicSimpleServerStreamPeer::headers( | 488 EXPECT_EQ(kPath, QuicSimpleServerStreamPeer::headers( |
491 server_initiated_stream)[":path"] | 489 server_initiated_stream)[":path"] |
492 .as_string()); | 490 .as_string()); |
493 EXPECT_EQ("GET", QuicSimpleServerStreamPeer::headers( | 491 EXPECT_EQ("GET", QuicSimpleServerStreamPeer::headers( |
494 server_initiated_stream)[":method"] | 492 server_initiated_stream)[":method"] |
495 .as_string()); | 493 .as_string()); |
496 } | 494 } |
497 | 495 |
498 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) { | 496 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) { |
499 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); | 497 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); |
500 | 498 |
501 response_headers_[":version"] = "HTTP/1.1"; | 499 response_headers_[":version"] = "HTTP/1.1"; |
502 response_headers_[":status"] = "500 Server Error"; | 500 response_headers_[":status"] = "500 Server Error"; |
503 response_headers_["content-length"] = "3"; | 501 response_headers_["content-length"] = "3"; |
504 stream_->set_fin_received(true); | 502 stream_->set_fin_received(true); |
505 | 503 |
506 InSequence s; | 504 InSequence s; |
507 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); | 505 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); |
508 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 506 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
509 .Times(1) | 507 .Times(1) |
510 .WillOnce(Return(QuicConsumedData(3, true))); | 508 .WillOnce(Return(QuicConsumedData(3, true))); |
511 | 509 |
512 QuicSimpleServerStreamPeer::SendErrorResponse(stream_); | 510 QuicSimpleServerStreamPeer::SendErrorResponse(stream_); |
513 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); | 511 EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_)); |
514 EXPECT_TRUE(stream_->reading_stopped()); | 512 EXPECT_TRUE(stream_->reading_stopped()); |
515 EXPECT_TRUE(stream_->write_side_closed()); | 513 EXPECT_TRUE(stream_->write_side_closed()); |
516 } | 514 } |
517 | 515 |
518 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) { | 516 TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) { |
519 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); | 517 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); |
520 | 518 |
521 SpdyHeaderBlock request_headers; | 519 SpdyHeaderBlock request_headers; |
522 // \000 is a way to write the null byte when followed by a literal digit. | 520 // \000 is a way to write the null byte when followed by a literal digit. |
523 request_headers["content-length"] = StringPiece("11\00012", 5); | 521 request_headers["content-length"] = StringPiece("11\00012", 5); |
524 | 522 |
525 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers); | 523 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers); |
526 | 524 |
527 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); | 525 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); |
528 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 526 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
529 .Times(AnyNumber()) | 527 .Times(AnyNumber()) |
530 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | 528 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); |
531 stream_->OnStreamHeaders(headers_string_); | 529 stream_->OnStreamHeaders(headers_string_); |
532 stream_->OnStreamHeadersComplete(true, headers_string_.size()); | 530 stream_->OnStreamHeadersComplete(true, headers_string_.size()); |
533 | 531 |
534 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_)); | 532 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_)); |
535 EXPECT_TRUE(stream_->reading_stopped()); | 533 EXPECT_TRUE(stream_->reading_stopped()); |
536 EXPECT_TRUE(stream_->write_side_closed()); | 534 EXPECT_TRUE(stream_->write_side_closed()); |
537 } | 535 } |
538 | 536 |
539 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) { | 537 TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) { |
540 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); | 538 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); |
541 | 539 |
542 SpdyHeaderBlock request_headers; | 540 SpdyHeaderBlock request_headers; |
543 // \000 is a way to write the null byte when followed by a literal digit. | 541 // \000 is a way to write the null byte when followed by a literal digit. |
544 request_headers["content-length"] = StringPiece("\00012", 3); | 542 request_headers["content-length"] = StringPiece("\00012", 3); |
545 | 543 |
546 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers); | 544 headers_string_ = SpdyUtils::SerializeUncompressedHeaders(request_headers); |
547 | 545 |
548 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); | 546 EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _)); |
549 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 547 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
550 .Times(AnyNumber()) | 548 .Times(AnyNumber()) |
551 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | 549 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); |
552 stream_->OnStreamHeaders(headers_string_); | 550 stream_->OnStreamHeaders(headers_string_); |
553 stream_->OnStreamHeadersComplete(true, headers_string_.size()); | 551 stream_->OnStreamHeadersComplete(true, headers_string_.size()); |
554 | 552 |
555 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_)); | 553 EXPECT_TRUE(ReliableQuicStreamPeer::read_side_closed(stream_)); |
556 EXPECT_TRUE(stream_->reading_stopped()); | 554 EXPECT_TRUE(stream_->reading_stopped()); |
557 EXPECT_TRUE(stream_->write_side_closed()); | 555 EXPECT_TRUE(stream_->write_side_closed()); |
558 } | 556 } |
559 | 557 |
(...skipping 13 matching lines...) Expand all Loading... |
573 EXPECT_FALSE(stream_->write_side_closed()); | 571 EXPECT_FALSE(stream_->write_side_closed()); |
574 } | 572 } |
575 | 573 |
576 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) { | 574 TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) { |
577 response_headers_[":version"] = "HTTP/1.1"; | 575 response_headers_[":version"] = "HTTP/1.1"; |
578 response_headers_[":status"] = "500 Server Error"; | 576 response_headers_[":status"] = "500 Server Error"; |
579 response_headers_["content-length"] = "3"; | 577 response_headers_["content-length"] = "3"; |
580 | 578 |
581 InSequence s; | 579 InSequence s; |
582 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, _, _, _)); | 580 EXPECT_CALL(session_, WriteHeaders(stream_->id(), _, _, _, _)); |
583 EXPECT_CALL(session_, WritevData(_, _, _, _, _)) | 581 EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)) |
584 .Times(1) | 582 .Times(1) |
585 .WillOnce(Return(QuicConsumedData(3, true))); | 583 .WillOnce(Return(QuicConsumedData(3, true))); |
586 if (GetParam() > QUIC_VERSION_28) { | 584 if (GetParam() > QUIC_VERSION_28) { |
587 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1); | 585 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(1); |
588 } else { | 586 } else { |
589 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); | 587 EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0); |
590 } | 588 } |
591 EXPECT_FALSE(stream_->fin_received()); | 589 EXPECT_FALSE(stream_->fin_received()); |
592 QuicSimpleServerStreamPeer::SendErrorResponse(stream_); | 590 QuicSimpleServerStreamPeer::SendErrorResponse(stream_); |
593 EXPECT_TRUE(stream_->reading_stopped()); | 591 EXPECT_TRUE(stream_->reading_stopped()); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
638 }; | 636 }; |
639 StringPiece data(arr, arraysize(arr)); | 637 StringPiece data(arr, arraysize(arr)); |
640 QuicStreamFrame frame(stream_->id(), true, 0, data); | 638 QuicStreamFrame frame(stream_->id(), true, 0, data); |
641 // Verify that we don't crash when we get a invalid headers in stream frame. | 639 // Verify that we don't crash when we get a invalid headers in stream frame. |
642 stream_->OnStreamFrame(frame); | 640 stream_->OnStreamFrame(frame); |
643 } | 641 } |
644 | 642 |
645 } // namespace | 643 } // namespace |
646 } // namespace test | 644 } // namespace test |
647 } // namespace net | 645 } // namespace net |
OLD | NEW |