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