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_session.h" | 5 #include "net/quic/chromium/quic_chromium_client_session.h" |
6 | 6 |
7 #include "base/base64.h" | 7 #include "base/base64.h" |
8 #include "base/files/file_path.h" | 8 #include "base/files/file_path.h" |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
10 #include "base/rand_util.h" | 10 #include "base/rand_util.h" |
(...skipping 19 matching lines...) Expand all Loading... |
30 #include "net/quic/chromium/quic_test_packet_maker.h" | 30 #include "net/quic/chromium/quic_test_packet_maker.h" |
31 #include "net/quic/core/crypto/aes_128_gcm_12_encrypter.h" | 31 #include "net/quic/core/crypto/aes_128_gcm_12_encrypter.h" |
32 #include "net/quic/core/crypto/crypto_protocol.h" | 32 #include "net/quic/core/crypto/crypto_protocol.h" |
33 #include "net/quic/core/crypto/quic_decrypter.h" | 33 #include "net/quic/core/crypto/quic_decrypter.h" |
34 #include "net/quic/core/crypto/quic_encrypter.h" | 34 #include "net/quic/core/crypto/quic_encrypter.h" |
35 #include "net/quic/core/quic_client_promised_info.h" | 35 #include "net/quic/core/quic_client_promised_info.h" |
36 #include "net/quic/core/quic_packet_writer.h" | 36 #include "net/quic/core/quic_packet_writer.h" |
37 #include "net/quic/platform/api/quic_flags.h" | 37 #include "net/quic/platform/api/quic_flags.h" |
38 #include "net/quic/test_tools/crypto_test_utils.h" | 38 #include "net/quic/test_tools/crypto_test_utils.h" |
39 #include "net/quic/test_tools/quic_client_promised_info_peer.h" | 39 #include "net/quic/test_tools/quic_client_promised_info_peer.h" |
40 #include "net/quic/test_tools/quic_spdy_session_peer.h" | |
41 #include "net/quic/test_tools/quic_test_utils.h" | 40 #include "net/quic/test_tools/quic_test_utils.h" |
42 #include "net/quic/test_tools/simple_quic_framer.h" | 41 #include "net/quic/test_tools/simple_quic_framer.h" |
43 #include "net/socket/datagram_client_socket.h" | 42 #include "net/socket/datagram_client_socket.h" |
44 #include "net/socket/socket_test_util.h" | 43 #include "net/socket/socket_test_util.h" |
45 #include "net/spdy/core/spdy_test_utils.h" | 44 #include "net/spdy/core/spdy_test_utils.h" |
46 #include "net/test/cert_test_util.h" | 45 #include "net/test/cert_test_util.h" |
47 #include "net/test/gtest_util.h" | 46 #include "net/test/gtest_util.h" |
48 #include "net/test/test_data_directory.h" | 47 #include "net/test/test_data_directory.h" |
49 #include "testing/gmock/include/gmock/gmock.h" | 48 #include "testing/gmock/include/gmock/gmock.h" |
50 | 49 |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
149 | 148 |
150 QuicChromiumPacketWriter* CreateQuicChromiumPacketWriter( | 149 QuicChromiumPacketWriter* CreateQuicChromiumPacketWriter( |
151 DatagramClientSocket* socket, | 150 DatagramClientSocket* socket, |
152 QuicChromiumClientSession* session) const { | 151 QuicChromiumClientSession* session) const { |
153 std::unique_ptr<QuicChromiumPacketWriter> writer( | 152 std::unique_ptr<QuicChromiumPacketWriter> writer( |
154 new QuicChromiumPacketWriter(socket)); | 153 new QuicChromiumPacketWriter(socket)); |
155 writer->set_delegate(session); | 154 writer->set_delegate(session); |
156 return writer.release(); | 155 return writer.release(); |
157 } | 156 } |
158 | 157 |
| 158 QuicStreamId GetNthClientInitiatedStreamId(int n) { |
| 159 return test::GetNthClientInitiatedStreamId(GetParam(), n); |
| 160 } |
| 161 |
| 162 QuicStreamId GetNthServerInitiatedStreamId(int n) { |
| 163 return test::GetNthServerInitiatedStreamId(GetParam(), n); |
| 164 } |
| 165 |
159 QuicCryptoClientConfig crypto_config_; | 166 QuicCryptoClientConfig crypto_config_; |
160 TestNetLog net_log_; | 167 TestNetLog net_log_; |
161 BoundTestNetLog bound_test_net_log_; | 168 BoundTestNetLog bound_test_net_log_; |
162 MockClientSocketFactory socket_factory_; | 169 MockClientSocketFactory socket_factory_; |
163 std::unique_ptr<MockRead> default_read_; | 170 std::unique_ptr<MockRead> default_read_; |
164 std::unique_ptr<SequencedSocketData> socket_data_; | 171 std::unique_ptr<SequencedSocketData> socket_data_; |
165 MockClock clock_; | 172 MockClock clock_; |
166 MockRandom random_; | 173 MockRandom random_; |
167 QuicChromiumConnectionHelper helper_; | 174 QuicChromiumConnectionHelper helper_; |
168 MockAlarmFactory alarm_factory_; | 175 MockAlarmFactory alarm_factory_; |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
260 EXPECT_TRUE(stream_request->ReleaseStream() != nullptr); | 267 EXPECT_TRUE(stream_request->ReleaseStream() != nullptr); |
261 | 268 |
262 quic_data.Resume(); | 269 quic_data.Resume(); |
263 EXPECT_TRUE(quic_data.AllReadDataConsumed()); | 270 EXPECT_TRUE(quic_data.AllReadDataConsumed()); |
264 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); | 271 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); |
265 } | 272 } |
266 | 273 |
267 TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) { | 274 TEST_P(QuicChromiumClientSessionTest, CancelStreamRequestBeforeRelease) { |
268 MockQuicData quic_data; | 275 MockQuicData quic_data; |
269 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 276 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
270 quic_data.AddWrite(client_maker_.MakeRstPacket(2, true, kClientDataStreamId1, | 277 quic_data.AddWrite(client_maker_.MakeRstPacket( |
271 QUIC_STREAM_CANCELLED)); | 278 2, true, GetNthClientInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
272 quic_data.AddRead(ASYNC, ERR_IO_PENDING); | 279 quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
273 quic_data.AddRead(ASYNC, OK); // EOF | 280 quic_data.AddRead(ASYNC, OK); // EOF |
274 quic_data.AddSocketDataToFactory(&socket_factory_); | 281 quic_data.AddSocketDataToFactory(&socket_factory_); |
275 | 282 |
276 Initialize(); | 283 Initialize(); |
277 CompleteCryptoHandshake(); | 284 CompleteCryptoHandshake(); |
278 | 285 |
279 // Request a stream and cancel it without releasing the stream. | 286 // Request a stream and cancel it without releasing the stream. |
280 std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request = | 287 std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request = |
281 session_->CreateStreamRequest(/*requires_confirmation=*/false); | 288 session_->CreateStreamRequest(/*requires_confirmation=*/false); |
282 TestCompletionCallback callback; | 289 TestCompletionCallback callback; |
283 ASSERT_EQ(OK, stream_request->StartRequest(callback.callback())); | 290 ASSERT_EQ(OK, stream_request->StartRequest(callback.callback())); |
284 stream_request.reset(); | 291 stream_request.reset(); |
285 | 292 |
286 quic_data.Resume(); | 293 quic_data.Resume(); |
287 EXPECT_TRUE(quic_data.AllReadDataConsumed()); | 294 EXPECT_TRUE(quic_data.AllReadDataConsumed()); |
288 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); | 295 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); |
289 } | 296 } |
290 | 297 |
291 TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) { | 298 TEST_P(QuicChromiumClientSessionTest, AsyncStreamRequest) { |
292 MockQuicData quic_data; | 299 MockQuicData quic_data; |
293 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 300 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
294 quic_data.AddWrite(client_maker_.MakeRstPacket(2, true, kClientDataStreamId1, | 301 quic_data.AddWrite(client_maker_.MakeRstPacket( |
295 QUIC_RST_ACKNOWLEDGEMENT)); | 302 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
296 quic_data.AddRead(ASYNC, ERR_IO_PENDING); | 303 quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
297 quic_data.AddRead(ASYNC, OK); // EOF | 304 quic_data.AddRead(ASYNC, OK); // EOF |
298 quic_data.AddSocketDataToFactory(&socket_factory_); | 305 quic_data.AddSocketDataToFactory(&socket_factory_); |
299 | 306 |
300 Initialize(); | 307 Initialize(); |
301 CompleteCryptoHandshake(); | 308 CompleteCryptoHandshake(); |
302 | 309 |
303 // Open the maximum number of streams so that a subsequent request | 310 // Open the maximum number of streams so that a subsequent request |
304 // can not proceed immediately. | 311 // can not proceed immediately. |
305 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); | 312 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); |
306 for (size_t i = 0; i < kMaxOpenStreams; i++) { | 313 for (size_t i = 0; i < kMaxOpenStreams; i++) { |
307 session_->CreateOutgoingDynamicStream(kDefaultPriority); | 314 session_->CreateOutgoingDynamicStream(kDefaultPriority); |
308 } | 315 } |
309 EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams()); | 316 EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams()); |
310 | 317 |
311 // Request a stream and verify that it's pending. | 318 // Request a stream and verify that it's pending. |
312 std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request = | 319 std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request = |
313 session_->CreateStreamRequest(/*requires_confirmation=*/false); | 320 session_->CreateStreamRequest(/*requires_confirmation=*/false); |
314 TestCompletionCallback callback; | 321 TestCompletionCallback callback; |
315 ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback())); | 322 ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback())); |
316 | 323 |
317 // Close a stream and ensure the stream request completes. | 324 // Close a stream and ensure the stream request completes. |
318 QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_CANCELLED, 0); | 325 QuicRstStreamFrame rst(GetNthClientInitiatedStreamId(0), |
| 326 QUIC_STREAM_CANCELLED, 0); |
319 session_->OnRstStream(rst); | 327 session_->OnRstStream(rst); |
320 ASSERT_TRUE(callback.have_result()); | 328 ASSERT_TRUE(callback.have_result()); |
321 EXPECT_THAT(callback.WaitForResult(), IsOk()); | 329 EXPECT_THAT(callback.WaitForResult(), IsOk()); |
322 EXPECT_TRUE(stream_request->ReleaseStream() != nullptr); | 330 EXPECT_TRUE(stream_request->ReleaseStream() != nullptr); |
323 | 331 |
324 quic_data.Resume(); | 332 quic_data.Resume(); |
325 EXPECT_TRUE(quic_data.AllReadDataConsumed()); | 333 EXPECT_TRUE(quic_data.AllReadDataConsumed()); |
326 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); | 334 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); |
327 } | 335 } |
328 | 336 |
329 TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) { | 337 TEST_P(QuicChromiumClientSessionTest, CancelPendingStreamRequest) { |
330 MockQuicData quic_data; | 338 MockQuicData quic_data; |
331 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 339 quic_data.AddWrite(client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
332 quic_data.AddWrite(client_maker_.MakeRstPacket(2, true, kClientDataStreamId1, | 340 quic_data.AddWrite(client_maker_.MakeRstPacket( |
333 QUIC_RST_ACKNOWLEDGEMENT)); | 341 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
334 quic_data.AddRead(ASYNC, ERR_IO_PENDING); | 342 quic_data.AddRead(ASYNC, ERR_IO_PENDING); |
335 quic_data.AddRead(ASYNC, OK); // EOF | 343 quic_data.AddRead(ASYNC, OK); // EOF |
336 quic_data.AddSocketDataToFactory(&socket_factory_); | 344 quic_data.AddSocketDataToFactory(&socket_factory_); |
337 | 345 |
338 Initialize(); | 346 Initialize(); |
339 CompleteCryptoHandshake(); | 347 CompleteCryptoHandshake(); |
340 | 348 |
341 // Open the maximum number of streams so that a subsequent request | 349 // Open the maximum number of streams so that a subsequent request |
342 // can not proceed immediately. | 350 // can not proceed immediately. |
343 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); | 351 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); |
344 for (size_t i = 0; i < kMaxOpenStreams; i++) { | 352 for (size_t i = 0; i < kMaxOpenStreams; i++) { |
345 session_->CreateOutgoingDynamicStream(kDefaultPriority); | 353 session_->CreateOutgoingDynamicStream(kDefaultPriority); |
346 } | 354 } |
347 EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams()); | 355 EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams()); |
348 | 356 |
349 // Request a stream and verify that it's pending. | 357 // Request a stream and verify that it's pending. |
350 std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request = | 358 std::unique_ptr<QuicChromiumClientSession::StreamRequest> stream_request = |
351 session_->CreateStreamRequest(/*requires_confirmation=*/false); | 359 session_->CreateStreamRequest(/*requires_confirmation=*/false); |
352 TestCompletionCallback callback; | 360 TestCompletionCallback callback; |
353 ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback())); | 361 ASSERT_EQ(ERR_IO_PENDING, stream_request->StartRequest(callback.callback())); |
354 | 362 |
355 // Cancel the pending stream request. | 363 // Cancel the pending stream request. |
356 stream_request.reset(); | 364 stream_request.reset(); |
357 | 365 |
358 // Close a stream and ensure that no new stream is created. | 366 // Close a stream and ensure that no new stream is created. |
359 QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_STREAM_CANCELLED, 0); | 367 QuicRstStreamFrame rst(GetNthClientInitiatedStreamId(0), |
| 368 QUIC_STREAM_CANCELLED, 0); |
360 session_->OnRstStream(rst); | 369 session_->OnRstStream(rst); |
361 EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams()); | 370 EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams()); |
362 | 371 |
363 quic_data.Resume(); | 372 quic_data.Resume(); |
364 EXPECT_TRUE(quic_data.AllReadDataConsumed()); | 373 EXPECT_TRUE(quic_data.AllReadDataConsumed()); |
365 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); | 374 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); |
366 } | 375 } |
367 | 376 |
368 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeStreamRequest) { | 377 TEST_P(QuicChromiumClientSessionTest, ConnectionCloseBeforeStreamRequest) { |
369 MockQuicData quic_data; | 378 MockQuicData quic_data; |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
446 | 455 |
447 EXPECT_TRUE(quic_data.AllReadDataConsumed()); | 456 EXPECT_TRUE(quic_data.AllReadDataConsumed()); |
448 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); | 457 EXPECT_TRUE(quic_data.AllWriteDataConsumed()); |
449 } | 458 } |
450 | 459 |
451 TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) { | 460 TEST_P(QuicChromiumClientSessionTest, MaxNumStreams) { |
452 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 461 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
453 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 462 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
454 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 463 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
455 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 464 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
456 2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT)); | 465 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
457 MockWrite writes[] = { | 466 MockWrite writes[] = { |
458 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 467 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
459 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 468 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
460 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 469 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
461 arraysize(writes))); | 470 arraysize(writes))); |
462 | 471 |
463 Initialize(); | 472 Initialize(); |
464 CompleteCryptoHandshake(); | 473 CompleteCryptoHandshake(); |
465 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); | 474 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); |
466 | 475 |
(...skipping 18 matching lines...) Expand all Loading... |
485 EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams()); | 494 EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams()); |
486 EXPECT_TRUE(session_->CreateOutgoingDynamicStream(kDefaultPriority)); | 495 EXPECT_TRUE(session_->CreateOutgoingDynamicStream(kDefaultPriority)); |
487 } | 496 } |
488 | 497 |
489 TEST_P(QuicChromiumClientSessionTest, PushStreamTimedOutNoResponse) { | 498 TEST_P(QuicChromiumClientSessionTest, PushStreamTimedOutNoResponse) { |
490 base::HistogramTester histogram_tester; | 499 base::HistogramTester histogram_tester; |
491 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 500 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
492 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 501 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
493 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 502 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
494 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 503 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
495 2, true, kServerDataStreamId1, QUIC_PUSH_STREAM_TIMED_OUT)); | 504 2, true, GetNthServerInitiatedStreamId(0), QUIC_PUSH_STREAM_TIMED_OUT)); |
496 MockWrite writes[] = { | 505 MockWrite writes[] = { |
497 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 506 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
498 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 507 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
499 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 508 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
500 arraysize(writes))); | 509 arraysize(writes))); |
501 Initialize(); | 510 Initialize(); |
502 | 511 |
503 ProofVerifyDetailsChromium details; | 512 ProofVerifyDetailsChromium details; |
504 details.cert_verify_result.verified_cert = | 513 details.cert_verify_result.verified_cert = |
505 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 514 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
506 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); | 515 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); |
507 | 516 |
508 CompleteCryptoHandshake(); | 517 CompleteCryptoHandshake(); |
509 session_->OnProofVerifyDetailsAvailable(details); | 518 session_->OnProofVerifyDetailsAvailable(details); |
510 | 519 |
511 QuicChromiumClientStream* stream = | 520 QuicChromiumClientStream* stream = |
512 session_->CreateOutgoingDynamicStream(kDefaultPriority); | 521 session_->CreateOutgoingDynamicStream(kDefaultPriority); |
513 EXPECT_TRUE(stream); | 522 EXPECT_TRUE(stream); |
514 | 523 |
515 SpdyHeaderBlock promise_headers; | 524 SpdyHeaderBlock promise_headers; |
516 promise_headers[":method"] = "GET"; | 525 promise_headers[":method"] = "GET"; |
517 promise_headers[":authority"] = "www.example.org"; | 526 promise_headers[":authority"] = "www.example.org"; |
518 promise_headers[":scheme"] = "https"; | 527 promise_headers[":scheme"] = "https"; |
519 promise_headers[":path"] = "/pushed.jpg"; | 528 promise_headers[":path"] = "/pushed.jpg"; |
520 | 529 |
521 // Receive a PUSH PROMISE from the server. | 530 // Receive a PUSH PROMISE from the server. |
522 EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1, | 531 EXPECT_TRUE(session_->HandlePromised( |
523 promise_headers)); | 532 stream->id(), GetNthServerInitiatedStreamId(0), promise_headers)); |
524 | 533 |
525 QuicClientPromisedInfo* promised = | 534 QuicClientPromisedInfo* promised = |
526 session_->GetPromisedById(kServerDataStreamId1); | 535 session_->GetPromisedById(GetNthServerInitiatedStreamId(0)); |
527 EXPECT_TRUE(promised); | 536 EXPECT_TRUE(promised); |
528 // Fire alarm to time out the push stream. | 537 // Fire alarm to time out the push stream. |
529 alarm_factory_.FireAlarm(QuicClientPromisedInfoPeer::GetAlarm(promised)); | 538 alarm_factory_.FireAlarm(QuicClientPromisedInfoPeer::GetAlarm(promised)); |
530 EXPECT_FALSE( | 539 EXPECT_FALSE( |
531 session_->GetPromisedByUrl("https://www.example.org/pushed.jpg")); | 540 session_->GetPromisedByUrl("https://www.example.org/pushed.jpg")); |
532 EXPECT_EQ(0u, | 541 EXPECT_EQ(0u, |
533 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); | 542 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); |
534 EXPECT_EQ(0u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( | 543 EXPECT_EQ(0u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( |
535 session_.get())); | 544 session_.get())); |
536 } | 545 } |
537 | 546 |
538 TEST_P(QuicChromiumClientSessionTest, PushStreamTimedOutWithResponse) { | 547 TEST_P(QuicChromiumClientSessionTest, PushStreamTimedOutWithResponse) { |
539 base::HistogramTester histogram_tester; | 548 base::HistogramTester histogram_tester; |
540 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 549 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
541 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 550 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
542 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 551 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
543 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 552 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
544 2, true, kServerDataStreamId1, QUIC_PUSH_STREAM_TIMED_OUT)); | 553 2, true, GetNthServerInitiatedStreamId(0), QUIC_PUSH_STREAM_TIMED_OUT)); |
545 MockWrite writes[] = { | 554 MockWrite writes[] = { |
546 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 555 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
547 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 556 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
548 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 557 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
549 arraysize(writes))); | 558 arraysize(writes))); |
550 Initialize(); | 559 Initialize(); |
551 | 560 |
552 ProofVerifyDetailsChromium details; | 561 ProofVerifyDetailsChromium details; |
553 details.cert_verify_result.verified_cert = | 562 details.cert_verify_result.verified_cert = |
554 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 563 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
555 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); | 564 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); |
556 | 565 |
557 CompleteCryptoHandshake(); | 566 CompleteCryptoHandshake(); |
558 session_->OnProofVerifyDetailsAvailable(details); | 567 session_->OnProofVerifyDetailsAvailable(details); |
559 | 568 |
560 QuicChromiumClientStream* stream = | 569 QuicChromiumClientStream* stream = |
561 session_->CreateOutgoingDynamicStream(kDefaultPriority); | 570 session_->CreateOutgoingDynamicStream(kDefaultPriority); |
562 EXPECT_TRUE(stream); | 571 EXPECT_TRUE(stream); |
563 | 572 |
564 SpdyHeaderBlock promise_headers; | 573 SpdyHeaderBlock promise_headers; |
565 promise_headers[":method"] = "GET"; | 574 promise_headers[":method"] = "GET"; |
566 promise_headers[":authority"] = "www.example.org"; | 575 promise_headers[":authority"] = "www.example.org"; |
567 promise_headers[":scheme"] = "https"; | 576 promise_headers[":scheme"] = "https"; |
568 promise_headers[":path"] = "/pushed.jpg"; | 577 promise_headers[":path"] = "/pushed.jpg"; |
569 | 578 |
570 session_->GetOrCreateStream(kServerDataStreamId1); | 579 session_->GetOrCreateStream(GetNthServerInitiatedStreamId(0)); |
571 // Receive a PUSH PROMISE from the server. | 580 // Receive a PUSH PROMISE from the server. |
572 EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1, | 581 EXPECT_TRUE(session_->HandlePromised( |
573 promise_headers)); | 582 stream->id(), GetNthServerInitiatedStreamId(0), promise_headers)); |
574 session_->OnInitialHeadersComplete(kServerDataStreamId1, SpdyHeaderBlock()); | 583 session_->OnInitialHeadersComplete(GetNthServerInitiatedStreamId(0), |
| 584 SpdyHeaderBlock()); |
575 // Read data on the pushed stream. | 585 // Read data on the pushed stream. |
576 QuicStreamFrame data(kServerDataStreamId1, false, 0, QuicStringPiece("SP")); | 586 QuicStreamFrame data(GetNthServerInitiatedStreamId(0), false, 0, |
| 587 QuicStringPiece("SP")); |
577 session_->OnStreamFrame(data); | 588 session_->OnStreamFrame(data); |
578 | 589 |
579 QuicClientPromisedInfo* promised = | 590 QuicClientPromisedInfo* promised = |
580 session_->GetPromisedById(kServerDataStreamId1); | 591 session_->GetPromisedById(GetNthServerInitiatedStreamId(0)); |
581 EXPECT_TRUE(promised); | 592 EXPECT_TRUE(promised); |
582 // Fire alarm to time out the push stream. | 593 // Fire alarm to time out the push stream. |
583 alarm_factory_.FireAlarm(QuicClientPromisedInfoPeer::GetAlarm(promised)); | 594 alarm_factory_.FireAlarm(QuicClientPromisedInfoPeer::GetAlarm(promised)); |
584 EXPECT_EQ(2u, | 595 EXPECT_EQ(2u, |
585 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); | 596 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); |
586 EXPECT_EQ(2u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( | 597 EXPECT_EQ(2u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( |
587 session_.get())); | 598 session_.get())); |
588 } | 599 } |
589 | 600 |
590 TEST_P(QuicChromiumClientSessionTest, CancelPushWhenPendingValidation) { | 601 TEST_P(QuicChromiumClientSessionTest, CancelPushWhenPendingValidation) { |
591 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 602 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
592 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 603 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
593 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 604 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
594 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 605 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
595 2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT)); | 606 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
596 | 607 |
597 MockWrite writes[] = { | 608 MockWrite writes[] = { |
598 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 609 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
599 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 610 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
600 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 611 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
601 arraysize(writes))); | 612 arraysize(writes))); |
602 Initialize(); | 613 Initialize(); |
603 | 614 |
604 ProofVerifyDetailsChromium details; | 615 ProofVerifyDetailsChromium details; |
605 details.cert_verify_result.verified_cert = | 616 details.cert_verify_result.verified_cert = |
606 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 617 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
607 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); | 618 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); |
608 | 619 |
609 CompleteCryptoHandshake(); | 620 CompleteCryptoHandshake(); |
610 session_->OnProofVerifyDetailsAvailable(details); | 621 session_->OnProofVerifyDetailsAvailable(details); |
611 | 622 |
612 QuicChromiumClientStream* stream = | 623 QuicChromiumClientStream* stream = |
613 session_->CreateOutgoingDynamicStream(kDefaultPriority); | 624 session_->CreateOutgoingDynamicStream(kDefaultPriority); |
614 EXPECT_TRUE(stream); | 625 EXPECT_TRUE(stream); |
615 | 626 |
616 SpdyHeaderBlock promise_headers; | 627 SpdyHeaderBlock promise_headers; |
617 promise_headers[":method"] = "GET"; | 628 promise_headers[":method"] = "GET"; |
618 promise_headers[":authority"] = "www.example.org"; | 629 promise_headers[":authority"] = "www.example.org"; |
619 promise_headers[":scheme"] = "https"; | 630 promise_headers[":scheme"] = "https"; |
620 promise_headers[":path"] = "/pushed.jpg"; | 631 promise_headers[":path"] = "/pushed.jpg"; |
621 | 632 |
622 // Receive a PUSH PROMISE from the server. | 633 // Receive a PUSH PROMISE from the server. |
623 EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1, | 634 EXPECT_TRUE(session_->HandlePromised( |
624 promise_headers)); | 635 stream->id(), GetNthServerInitiatedStreamId(0), promise_headers)); |
625 | 636 |
626 QuicClientPromisedInfo* promised = | 637 QuicClientPromisedInfo* promised = |
627 session_->GetPromisedById(kServerDataStreamId1); | 638 session_->GetPromisedById(GetNthServerInitiatedStreamId(0)); |
628 EXPECT_TRUE(promised); | 639 EXPECT_TRUE(promised); |
629 | 640 |
630 // Initiate rendezvous. | 641 // Initiate rendezvous. |
631 SpdyHeaderBlock client_request = promise_headers.Clone(); | 642 SpdyHeaderBlock client_request = promise_headers.Clone(); |
632 TestPushPromiseDelegate delegate(/*match=*/true); | 643 TestPushPromiseDelegate delegate(/*match=*/true); |
633 promised->HandleClientRequest(client_request, &delegate); | 644 promised->HandleClientRequest(client_request, &delegate); |
634 | 645 |
635 // Cancel the push before receiving the response to the pushed request. | 646 // Cancel the push before receiving the response to the pushed request. |
636 GURL pushed_url("https://www.example.org/pushed.jpg"); | 647 GURL pushed_url("https://www.example.org/pushed.jpg"); |
637 test_push_delegate_.CancelPush(pushed_url); | 648 test_push_delegate_.CancelPush(pushed_url); |
638 EXPECT_TRUE(session_->GetPromisedByUrl(pushed_url.spec())); | 649 EXPECT_TRUE(session_->GetPromisedByUrl(pushed_url.spec())); |
639 | 650 |
640 // Reset the stream now before tear down. | 651 // Reset the stream now before tear down. |
641 session_->CloseStream(kClientDataStreamId1); | 652 session_->CloseStream(GetNthClientInitiatedStreamId(0)); |
642 } | 653 } |
643 | 654 |
644 TEST_P(QuicChromiumClientSessionTest, CancelPushBeforeReceivingResponse) { | 655 TEST_P(QuicChromiumClientSessionTest, CancelPushBeforeReceivingResponse) { |
645 base::HistogramTester histogram_tester; | 656 base::HistogramTester histogram_tester; |
646 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 657 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
647 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 658 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
648 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 659 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
649 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 660 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
650 2, true, kServerDataStreamId1, QUIC_STREAM_CANCELLED)); | 661 2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
651 MockWrite writes[] = { | 662 MockWrite writes[] = { |
652 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 663 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
653 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 664 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
654 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 665 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
655 arraysize(writes))); | 666 arraysize(writes))); |
656 Initialize(); | 667 Initialize(); |
657 | 668 |
658 ProofVerifyDetailsChromium details; | 669 ProofVerifyDetailsChromium details; |
659 details.cert_verify_result.verified_cert = | 670 details.cert_verify_result.verified_cert = |
660 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 671 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
661 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); | 672 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); |
662 | 673 |
663 CompleteCryptoHandshake(); | 674 CompleteCryptoHandshake(); |
664 session_->OnProofVerifyDetailsAvailable(details); | 675 session_->OnProofVerifyDetailsAvailable(details); |
665 | 676 |
666 QuicChromiumClientStream* stream = | 677 QuicChromiumClientStream* stream = |
667 session_->CreateOutgoingDynamicStream(kDefaultPriority); | 678 session_->CreateOutgoingDynamicStream(kDefaultPriority); |
668 EXPECT_TRUE(stream); | 679 EXPECT_TRUE(stream); |
669 | 680 |
670 SpdyHeaderBlock promise_headers; | 681 SpdyHeaderBlock promise_headers; |
671 promise_headers[":method"] = "GET"; | 682 promise_headers[":method"] = "GET"; |
672 promise_headers[":authority"] = "www.example.org"; | 683 promise_headers[":authority"] = "www.example.org"; |
673 promise_headers[":scheme"] = "https"; | 684 promise_headers[":scheme"] = "https"; |
674 promise_headers[":path"] = "/pushed.jpg"; | 685 promise_headers[":path"] = "/pushed.jpg"; |
675 | 686 |
676 // Receive a PUSH PROMISE from the server. | 687 // Receive a PUSH PROMISE from the server. |
677 EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1, | 688 EXPECT_TRUE(session_->HandlePromised( |
678 promise_headers)); | 689 stream->id(), GetNthServerInitiatedStreamId(0), promise_headers)); |
679 | 690 |
680 QuicClientPromisedInfo* promised = | 691 QuicClientPromisedInfo* promised = |
681 session_->GetPromisedById(kServerDataStreamId1); | 692 session_->GetPromisedById(GetNthServerInitiatedStreamId(0)); |
682 EXPECT_TRUE(promised); | 693 EXPECT_TRUE(promised); |
683 // Cancel the push before receiving the response to the pushed request. | 694 // Cancel the push before receiving the response to the pushed request. |
684 GURL pushed_url("https://www.example.org/pushed.jpg"); | 695 GURL pushed_url("https://www.example.org/pushed.jpg"); |
685 test_push_delegate_.CancelPush(pushed_url); | 696 test_push_delegate_.CancelPush(pushed_url); |
686 | 697 |
687 EXPECT_FALSE(session_->GetPromisedByUrl(pushed_url.spec())); | 698 EXPECT_FALSE(session_->GetPromisedByUrl(pushed_url.spec())); |
688 EXPECT_EQ(0u, | 699 EXPECT_EQ(0u, |
689 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); | 700 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); |
690 EXPECT_EQ(0u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( | 701 EXPECT_EQ(0u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( |
691 session_.get())); | 702 session_.get())); |
692 } | 703 } |
693 | 704 |
694 TEST_P(QuicChromiumClientSessionTest, CancelPushAfterReceivingResponse) { | 705 TEST_P(QuicChromiumClientSessionTest, CancelPushAfterReceivingResponse) { |
695 base::HistogramTester histogram_tester; | 706 base::HistogramTester histogram_tester; |
696 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 707 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
697 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 708 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
698 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 709 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
699 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 710 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
700 2, true, kServerDataStreamId1, QUIC_STREAM_CANCELLED)); | 711 2, true, GetNthServerInitiatedStreamId(0), QUIC_STREAM_CANCELLED)); |
701 MockWrite writes[] = { | 712 MockWrite writes[] = { |
702 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 713 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
703 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 714 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
704 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 715 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
705 arraysize(writes))); | 716 arraysize(writes))); |
706 Initialize(); | 717 Initialize(); |
707 | 718 |
708 ProofVerifyDetailsChromium details; | 719 ProofVerifyDetailsChromium details; |
709 details.cert_verify_result.verified_cert = | 720 details.cert_verify_result.verified_cert = |
710 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 721 ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
711 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); | 722 ASSERT_TRUE(details.cert_verify_result.verified_cert.get()); |
712 | 723 |
713 CompleteCryptoHandshake(); | 724 CompleteCryptoHandshake(); |
714 session_->OnProofVerifyDetailsAvailable(details); | 725 session_->OnProofVerifyDetailsAvailable(details); |
715 | 726 |
716 QuicChromiumClientStream* stream = | 727 QuicChromiumClientStream* stream = |
717 session_->CreateOutgoingDynamicStream(kDefaultPriority); | 728 session_->CreateOutgoingDynamicStream(kDefaultPriority); |
718 EXPECT_TRUE(stream); | 729 EXPECT_TRUE(stream); |
719 | 730 |
720 SpdyHeaderBlock promise_headers; | 731 SpdyHeaderBlock promise_headers; |
721 promise_headers[":method"] = "GET"; | 732 promise_headers[":method"] = "GET"; |
722 promise_headers[":authority"] = "www.example.org"; | 733 promise_headers[":authority"] = "www.example.org"; |
723 promise_headers[":scheme"] = "https"; | 734 promise_headers[":scheme"] = "https"; |
724 promise_headers[":path"] = "/pushed.jpg"; | 735 promise_headers[":path"] = "/pushed.jpg"; |
725 | 736 |
726 session_->GetOrCreateStream(kServerDataStreamId1); | 737 session_->GetOrCreateStream(GetNthServerInitiatedStreamId(0)); |
727 // Receive a PUSH PROMISE from the server. | 738 // Receive a PUSH PROMISE from the server. |
728 EXPECT_TRUE(session_->HandlePromised(stream->id(), kServerDataStreamId1, | 739 EXPECT_TRUE(session_->HandlePromised( |
729 promise_headers)); | 740 stream->id(), GetNthServerInitiatedStreamId(0), promise_headers)); |
730 session_->OnInitialHeadersComplete(kServerDataStreamId1, SpdyHeaderBlock()); | 741 session_->OnInitialHeadersComplete(GetNthServerInitiatedStreamId(0), |
| 742 SpdyHeaderBlock()); |
731 // Read data on the pushed stream. | 743 // Read data on the pushed stream. |
732 QuicStreamFrame data(kServerDataStreamId1, false, 0, QuicStringPiece("SP")); | 744 QuicStreamFrame data(GetNthServerInitiatedStreamId(0), false, 0, |
| 745 QuicStringPiece("SP")); |
733 session_->OnStreamFrame(data); | 746 session_->OnStreamFrame(data); |
734 | 747 |
735 QuicClientPromisedInfo* promised = | 748 QuicClientPromisedInfo* promised = |
736 session_->GetPromisedById(kServerDataStreamId1); | 749 session_->GetPromisedById(GetNthServerInitiatedStreamId(0)); |
737 EXPECT_TRUE(promised); | 750 EXPECT_TRUE(promised); |
738 // Cancel the push after receiving data on the push stream. | 751 // Cancel the push after receiving data on the push stream. |
739 GURL pushed_url("https://www.example.org/pushed.jpg"); | 752 GURL pushed_url("https://www.example.org/pushed.jpg"); |
740 test_push_delegate_.CancelPush(pushed_url); | 753 test_push_delegate_.CancelPush(pushed_url); |
741 | 754 |
742 EXPECT_FALSE(session_->GetPromisedByUrl(pushed_url.spec())); | 755 EXPECT_FALSE(session_->GetPromisedByUrl(pushed_url.spec())); |
743 EXPECT_EQ(2u, | 756 EXPECT_EQ(2u, |
744 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); | 757 QuicChromiumClientSessionPeer::GetPushedBytesCount(session_.get())); |
745 EXPECT_EQ(2u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( | 758 EXPECT_EQ(2u, QuicChromiumClientSessionPeer::GetPushedAndUnclaimedBytesCount( |
746 session_.get())); | 759 session_.get())); |
747 } | 760 } |
748 | 761 |
749 TEST_P(QuicChromiumClientSessionTest, Priority) { | 762 TEST_P(QuicChromiumClientSessionTest, Priority) { |
750 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 763 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
751 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 764 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
752 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 765 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
753 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 766 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
754 2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT)); | 767 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
755 MockWrite writes[] = { | 768 MockWrite writes[] = { |
756 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 769 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
757 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 770 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
758 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 771 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
759 arraysize(writes))); | 772 arraysize(writes))); |
760 | 773 |
761 Initialize(); | 774 Initialize(); |
762 CompleteCryptoHandshake(); | 775 CompleteCryptoHandshake(); |
763 | 776 |
764 for (SpdyPriority priority : {kV3HighestPriority, kV3LowestPriority}) { | 777 for (SpdyPriority priority : {kV3HighestPriority, kV3LowestPriority}) { |
765 QuicChromiumClientStream* stream = | 778 QuicChromiumClientStream* stream = |
766 session_->CreateOutgoingDynamicStream(priority); | 779 session_->CreateOutgoingDynamicStream(priority); |
767 EXPECT_EQ(kV3HighestPriority, stream->priority()); | 780 EXPECT_EQ(kV3HighestPriority, stream->priority()); |
768 | 781 |
769 SpdyHeaderBlock headers; | 782 SpdyHeaderBlock headers; |
770 stream->WriteHeaders(std::move(headers), /*fin*/ true, | 783 stream->WriteHeaders(std::move(headers), /*fin*/ true, |
771 /*ack_listener*/ nullptr); | 784 /*ack_listener*/ nullptr); |
772 | 785 |
773 EXPECT_EQ(priority, stream->priority()); | 786 EXPECT_EQ(priority, stream->priority()); |
774 } | 787 } |
775 } | 788 } |
776 | 789 |
777 TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) { | 790 TEST_P(QuicChromiumClientSessionTest, MaxNumStreamsViaRequest) { |
778 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; | 791 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; |
779 std::unique_ptr<QuicEncryptedPacket> settings_packet( | 792 std::unique_ptr<QuicEncryptedPacket> settings_packet( |
780 client_maker_.MakeInitialSettingsPacket(1, nullptr)); | 793 client_maker_.MakeInitialSettingsPacket(1, nullptr)); |
781 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( | 794 std::unique_ptr<QuicEncryptedPacket> client_rst(client_maker_.MakeRstPacket( |
782 2, true, kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT)); | 795 2, true, GetNthClientInitiatedStreamId(0), QUIC_RST_ACKNOWLEDGEMENT)); |
783 MockWrite writes[] = { | 796 MockWrite writes[] = { |
784 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), | 797 MockWrite(ASYNC, settings_packet->data(), settings_packet->length(), 1), |
785 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; | 798 MockWrite(ASYNC, client_rst->data(), client_rst->length(), 2)}; |
786 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, | 799 socket_data_.reset(new SequencedSocketData(reads, arraysize(reads), writes, |
787 arraysize(writes))); | 800 arraysize(writes))); |
788 | 801 |
789 Initialize(); | 802 Initialize(); |
790 CompleteCryptoHandshake(); | 803 CompleteCryptoHandshake(); |
791 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); | 804 const size_t kMaxOpenStreams = session_->max_open_outgoing_streams(); |
792 | 805 |
(...skipping 350 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1143 | 1156 |
1144 EXPECT_TRUE(socket_data_->AllReadDataConsumed()); | 1157 EXPECT_TRUE(socket_data_->AllReadDataConsumed()); |
1145 EXPECT_TRUE(socket_data_->AllWriteDataConsumed()); | 1158 EXPECT_TRUE(socket_data_->AllWriteDataConsumed()); |
1146 EXPECT_TRUE(new_socket_data.AllReadDataConsumed()); | 1159 EXPECT_TRUE(new_socket_data.AllReadDataConsumed()); |
1147 EXPECT_TRUE(new_socket_data.AllWriteDataConsumed()); | 1160 EXPECT_TRUE(new_socket_data.AllWriteDataConsumed()); |
1148 } | 1161 } |
1149 | 1162 |
1150 } // namespace | 1163 } // namespace |
1151 } // namespace test | 1164 } // namespace test |
1152 } // namespace net | 1165 } // namespace net |
OLD | NEW |