Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(269)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: net/quic/quic_stream_factory_test.cc

Issue 1744693002: Implement QUIC-based net::BidirectionalStream (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@basecl
Patch Set: Fix compile due to merge Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/quic/quic_stream_factory.cc ('k') | net/quic/test_tools/quic_test_packet_maker.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/quic/quic_stream_factory.h" 5 #include "net/quic/quic_stream_factory.h"
6 6
7 #include "base/run_loop.h" 7 #include "base/run_loop.h"
8 #include "base/strings/string_util.h" 8 #include "base/strings/string_util.h"
9 #include "base/thread_task_runner_handle.h" 9 #include "base/thread_task_runner_handle.h"
10 #include "net/base/test_data_directory.h" 10 #include "net/base/test_data_directory.h"
(...skipping 294 matching lines...) Expand 10 before | Expand all | Expand 10 after
305 socket_factory_.AddSocketDataProvider(&socket_data); 305 socket_factory_.AddSocketDataProvider(&socket_data);
306 306
307 QuicStreamRequest request(factory_.get()); 307 QuicStreamRequest request(factory_.get());
308 GURL url("https://" + destination.host() + "/"); 308 GURL url("https://" + destination.host() + "/");
309 EXPECT_EQ(ERR_IO_PENDING, 309 EXPECT_EQ(ERR_IO_PENDING,
310 request.Request(destination, privacy_mode_, 310 request.Request(destination, privacy_mode_,
311 /*cert_verify_flags=*/0, url, "GET", net_log_, 311 /*cert_verify_flags=*/0, url, "GET", net_log_,
312 callback_.callback())); 312 callback_.callback()));
313 313
314 EXPECT_EQ(OK, callback_.WaitForResult()); 314 EXPECT_EQ(OK, callback_.WaitForResult());
315 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 315 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
316 EXPECT_TRUE(stream.get()); 316 EXPECT_TRUE(stream.get());
317 stream.reset(); 317 stream.reset();
318 318
319 QuicChromiumClientSession* session = 319 QuicChromiumClientSession* session =
320 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), destination); 320 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), destination);
321 321
322 if (socket_count + 1 != socket_factory_.udp_client_socket_ports().size()) { 322 if (socket_count + 1 != socket_factory_.udp_client_socket_ports().size()) {
323 ADD_FAILURE(); 323 ADD_FAILURE();
324 return 0; 324 return 0;
325 } 325 }
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after
453 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0); 453 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0);
454 socket_factory_.AddSocketDataProvider(&socket_data); 454 socket_factory_.AddSocketDataProvider(&socket_data);
455 455
456 QuicStreamRequest request(factory_.get()); 456 QuicStreamRequest request(factory_.get());
457 EXPECT_EQ(ERR_IO_PENDING, 457 EXPECT_EQ(ERR_IO_PENDING,
458 request.Request(host_port_pair_, privacy_mode_, 458 request.Request(host_port_pair_, privacy_mode_,
459 /*cert_verify_flags=*/0, url_, "GET", net_log_, 459 /*cert_verify_flags=*/0, url_, "GET", net_log_,
460 callback_.callback())); 460 callback_.callback()));
461 461
462 EXPECT_EQ(OK, callback_.WaitForResult()); 462 EXPECT_EQ(OK, callback_.WaitForResult());
463 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 463 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
464 EXPECT_TRUE(stream.get()); 464 EXPECT_TRUE(stream.get());
465 465
466 // Will reset stream 3. 466 // Will reset stream 3.
467 stream = CreateFromSession(host_port_pair_); 467 stream = CreateFromSession(host_port_pair_);
468 EXPECT_TRUE(stream.get()); 468 EXPECT_TRUE(stream.get());
469 469
470 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result 470 // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
471 // in streams on different sessions. 471 // in streams on different sessions.
472 QuicStreamRequest request2(factory_.get()); 472 QuicStreamRequest request2(factory_.get());
473 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_, 473 EXPECT_EQ(OK, request2.Request(host_port_pair_, privacy_mode_,
474 /*cert_verify_flags=*/0, url_, "GET", net_log_, 474 /*cert_verify_flags=*/0, url_, "GET", net_log_,
475 callback_.callback())); 475 callback_.callback()));
476 stream = request2.ReleaseStream(); // Will reset stream 5. 476 stream = request2.CreateStream(); // Will reset stream 5.
477 stream.reset(); // Will reset stream 7. 477 stream.reset(); // Will reset stream 7.
478 478
479 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 479 EXPECT_TRUE(socket_data.AllReadDataConsumed());
480 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 480 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
481 } 481 }
482 482
483 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) { 483 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
484 Initialize(); 484 Initialize();
485 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 485 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
486 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 486 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
487 487
488 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; 488 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
489 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0); 489 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0);
490 socket_factory_.AddSocketDataProvider(&socket_data); 490 socket_factory_.AddSocketDataProvider(&socket_data);
491 491
492 crypto_client_stream_factory_.set_handshake_mode( 492 crypto_client_stream_factory_.set_handshake_mode(
493 MockCryptoClientStream::ZERO_RTT); 493 MockCryptoClientStream::ZERO_RTT);
494 host_resolver_.set_synchronous_mode(true); 494 host_resolver_.set_synchronous_mode(true);
495 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), 495 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
496 "192.168.0.1", ""); 496 "192.168.0.1", "");
497 497
498 QuicStreamRequest request(factory_.get()); 498 QuicStreamRequest request(factory_.get());
499 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 499 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
500 /*cert_verify_flags=*/0, url_, "GET", net_log_, 500 /*cert_verify_flags=*/0, url_, "GET", net_log_,
501 callback_.callback())); 501 callback_.callback()));
502 502
503 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 503 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
504 EXPECT_TRUE(stream.get()); 504 EXPECT_TRUE(stream.get());
505 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 505 EXPECT_TRUE(socket_data.AllReadDataConsumed());
506 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 506 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
507 } 507 }
508 508
509 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) { 509 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
510 Initialize(); 510 Initialize();
511 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 511 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
512 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 512 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
513 513
(...skipping 12 matching lines...) Expand all
526 EXPECT_EQ(ERR_IO_PENDING, 526 EXPECT_EQ(ERR_IO_PENDING,
527 request.Request(host_port_pair_, privacy_mode_, 527 request.Request(host_port_pair_, privacy_mode_,
528 /*cert_verify_flags=*/0, url_, "POST", net_log_, 528 /*cert_verify_flags=*/0, url_, "POST", net_log_,
529 callback_.callback())); 529 callback_.callback()));
530 530
531 // Confirm the handshake and verify that the stream is created. 531 // Confirm the handshake and verify that the stream is created.
532 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( 532 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
533 QuicSession::HANDSHAKE_CONFIRMED); 533 QuicSession::HANDSHAKE_CONFIRMED);
534 534
535 EXPECT_EQ(OK, callback_.WaitForResult()); 535 EXPECT_EQ(OK, callback_.WaitForResult());
536 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 536 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
537 EXPECT_TRUE(stream.get()); 537 EXPECT_TRUE(stream.get());
538 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 538 EXPECT_TRUE(socket_data.AllReadDataConsumed());
539 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 539 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
540 } 540 }
541 541
542 TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) { 542 TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) {
543 Initialize(); 543 Initialize();
544 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 544 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
545 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 545 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
546 546
(...skipping 12 matching lines...) Expand all
559 /*cert_verify_flags=*/0, url2_, "GET", net_log_, 559 /*cert_verify_flags=*/0, url2_, "GET", net_log_,
560 callback_.callback()); 560 callback_.callback());
561 // If server and origin have different hostnames, then handshake confirmation 561 // If server and origin have different hostnames, then handshake confirmation
562 // should be required, so Request will return asynchronously. 562 // should be required, so Request will return asynchronously.
563 EXPECT_EQ(ERR_IO_PENDING, rv); 563 EXPECT_EQ(ERR_IO_PENDING, rv);
564 // Confirm handshake. 564 // Confirm handshake.
565 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( 565 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
566 QuicSession::HANDSHAKE_CONFIRMED); 566 QuicSession::HANDSHAKE_CONFIRMED);
567 EXPECT_EQ(OK, callback_.WaitForResult()); 567 EXPECT_EQ(OK, callback_.WaitForResult());
568 568
569 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 569 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
570 EXPECT_TRUE(stream.get()); 570 EXPECT_TRUE(stream.get());
571 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 571 EXPECT_TRUE(socket_data.AllReadDataConsumed());
572 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 572 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
573 } 573 }
574 574
575 TEST_P(QuicStreamFactoryTest, GoAway) { 575 TEST_P(QuicStreamFactoryTest, GoAway) {
576 Initialize(); 576 Initialize();
577 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 577 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
578 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 578 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
579 579
580 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; 580 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
581 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0); 581 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0);
582 socket_factory_.AddSocketDataProvider(&socket_data); 582 socket_factory_.AddSocketDataProvider(&socket_data);
583 583
584 QuicStreamRequest request(factory_.get()); 584 QuicStreamRequest request(factory_.get());
585 EXPECT_EQ(ERR_IO_PENDING, 585 EXPECT_EQ(ERR_IO_PENDING,
586 request.Request(host_port_pair_, privacy_mode_, 586 request.Request(host_port_pair_, privacy_mode_,
587 /*cert_verify_flags=*/0, url_, "GET", net_log_, 587 /*cert_verify_flags=*/0, url_, "GET", net_log_,
588 callback_.callback())); 588 callback_.callback()));
589 589
590 EXPECT_EQ(OK, callback_.WaitForResult()); 590 EXPECT_EQ(OK, callback_.WaitForResult());
591 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 591 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
592 EXPECT_TRUE(stream.get()); 592 EXPECT_TRUE(stream.get());
593 593
594 QuicChromiumClientSession* session = 594 QuicChromiumClientSession* session =
595 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 595 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
596 596
597 session->OnGoAway(QuicGoAwayFrame()); 597 session->OnGoAway(QuicGoAwayFrame());
598 598
599 EXPECT_FALSE( 599 EXPECT_FALSE(
600 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_)); 600 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
601 601
(...skipping 10 matching lines...) Expand all
612 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0); 612 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0);
613 socket_factory_.AddSocketDataProvider(&socket_data); 613 socket_factory_.AddSocketDataProvider(&socket_data);
614 614
615 QuicStreamRequest request(factory_.get()); 615 QuicStreamRequest request(factory_.get());
616 EXPECT_EQ(ERR_IO_PENDING, 616 EXPECT_EQ(ERR_IO_PENDING,
617 request.Request(host_port_pair_, privacy_mode_, 617 request.Request(host_port_pair_, privacy_mode_,
618 /*cert_verify_flags=*/0, url_, "GET", net_log_, 618 /*cert_verify_flags=*/0, url_, "GET", net_log_,
619 callback_.callback())); 619 callback_.callback()));
620 620
621 EXPECT_EQ(OK, callback_.WaitForResult()); 621 EXPECT_EQ(OK, callback_.WaitForResult());
622 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 622 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
623 EXPECT_TRUE(stream.get()); 623 EXPECT_TRUE(stream.get());
624 624
625 QuicChromiumClientSession* session = 625 QuicChromiumClientSession* session =
626 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 626 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
627 627
628 session->OnGoAway( 628 session->OnGoAway(
629 QuicGoAwayFrame(QUIC_ERROR_MIGRATING_PORT, 0, 629 QuicGoAwayFrame(QUIC_ERROR_MIGRATING_PORT, 0,
630 "peer connection migration due to port change only")); 630 "peer connection migration due to port change only"));
631 NetErrorDetails details; 631 NetErrorDetails details;
632 EXPECT_FALSE(details.quic_port_migration_detected); 632 EXPECT_FALSE(details.quic_port_migration_detected);
(...skipping 22 matching lines...) Expand all
655 HostPortPair server2(kServer2HostName, kDefaultServerPort); 655 HostPortPair server2(kServer2HostName, kDefaultServerPort);
656 host_resolver_.set_synchronous_mode(true); 656 host_resolver_.set_synchronous_mode(true);
657 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), 657 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
658 "192.168.0.1", ""); 658 "192.168.0.1", "");
659 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 659 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
660 660
661 QuicStreamRequest request(factory_.get()); 661 QuicStreamRequest request(factory_.get());
662 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 662 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
663 /*cert_verify_flags=*/0, url_, "GET", net_log_, 663 /*cert_verify_flags=*/0, url_, "GET", net_log_,
664 callback_.callback())); 664 callback_.callback()));
665 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 665 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
666 EXPECT_TRUE(stream.get()); 666 EXPECT_TRUE(stream.get());
667 667
668 TestCompletionCallback callback; 668 TestCompletionCallback callback;
669 QuicStreamRequest request2(factory_.get()); 669 QuicStreamRequest request2(factory_.get());
670 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 670 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
671 /*cert_verify_flags=*/0, url2_, "GET", 671 /*cert_verify_flags=*/0, url2_, "GET",
672 net_log_, callback.callback())); 672 net_log_, callback.callback()));
673 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 673 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
674 EXPECT_TRUE(stream2.get()); 674 EXPECT_TRUE(stream2.get());
675 675
676 EXPECT_EQ( 676 EXPECT_EQ(
677 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_), 677 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_),
678 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2)); 678 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
679 679
680 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 680 EXPECT_TRUE(socket_data.AllReadDataConsumed());
681 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 681 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
682 } 682 }
683 683
(...skipping 13 matching lines...) Expand all
697 HostPortPair server2(kServer2HostName, kDefaultServerPort); 697 HostPortPair server2(kServer2HostName, kDefaultServerPort);
698 host_resolver_.set_synchronous_mode(true); 698 host_resolver_.set_synchronous_mode(true);
699 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), 699 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
700 "192.168.0.1", ""); 700 "192.168.0.1", "");
701 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 701 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
702 702
703 QuicStreamRequest request(factory_.get()); 703 QuicStreamRequest request(factory_.get());
704 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 704 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
705 /*cert_verify_flags=*/0, url_, "GET", net_log_, 705 /*cert_verify_flags=*/0, url_, "GET", net_log_,
706 callback_.callback())); 706 callback_.callback()));
707 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 707 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
708 EXPECT_TRUE(stream.get()); 708 EXPECT_TRUE(stream.get());
709 709
710 TestCompletionCallback callback; 710 TestCompletionCallback callback;
711 QuicStreamRequest request2(factory_.get()); 711 QuicStreamRequest request2(factory_.get());
712 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 712 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
713 /*cert_verify_flags=*/0, url2_, "GET", 713 /*cert_verify_flags=*/0, url2_, "GET",
714 net_log_, callback.callback())); 714 net_log_, callback.callback()));
715 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 715 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
716 EXPECT_TRUE(stream2.get()); 716 EXPECT_TRUE(stream2.get());
717 717
718 EXPECT_NE( 718 EXPECT_NE(
719 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_), 719 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_),
720 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2)); 720 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
721 721
722 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 722 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
723 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 723 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
724 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 724 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
725 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 725 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
(...skipping 14 matching lines...) Expand all
740 HostPortPair server2(kServer2HostName, kDefaultServerPort); 740 HostPortPair server2(kServer2HostName, kDefaultServerPort);
741 host_resolver_.set_synchronous_mode(true); 741 host_resolver_.set_synchronous_mode(true);
742 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), 742 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
743 "192.168.0.1", ""); 743 "192.168.0.1", "");
744 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 744 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
745 745
746 QuicStreamRequest request(factory_.get()); 746 QuicStreamRequest request(factory_.get());
747 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 747 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
748 /*cert_verify_flags=*/0, url_, "GET", net_log_, 748 /*cert_verify_flags=*/0, url_, "GET", net_log_,
749 callback_.callback())); 749 callback_.callback()));
750 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 750 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
751 EXPECT_TRUE(stream.get()); 751 EXPECT_TRUE(stream.get());
752 752
753 TestCompletionCallback callback; 753 TestCompletionCallback callback;
754 QuicStreamRequest request2(factory_.get()); 754 QuicStreamRequest request2(factory_.get());
755 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 755 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
756 /*cert_verify_flags=*/0, url2_, "GET", 756 /*cert_verify_flags=*/0, url2_, "GET",
757 net_log_, callback.callback())); 757 net_log_, callback.callback()));
758 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 758 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
759 EXPECT_TRUE(stream2.get()); 759 EXPECT_TRUE(stream2.get());
760 760
761 factory_->OnSessionGoingAway( 761 factory_->OnSessionGoingAway(
762 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_)); 762 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_));
763 EXPECT_FALSE( 763 EXPECT_FALSE(
764 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_)); 764 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
765 EXPECT_FALSE( 765 EXPECT_FALSE(
766 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2)); 766 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2));
767 767
768 TestCompletionCallback callback3; 768 TestCompletionCallback callback3;
769 QuicStreamRequest request3(factory_.get()); 769 QuicStreamRequest request3(factory_.get());
770 EXPECT_EQ(OK, request3.Request(server2, privacy_mode_, 770 EXPECT_EQ(OK, request3.Request(server2, privacy_mode_,
771 /*cert_verify_flags=*/0, url2_, "GET", 771 /*cert_verify_flags=*/0, url2_, "GET",
772 net_log_, callback3.callback())); 772 net_log_, callback3.callback()));
773 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 773 scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
774 EXPECT_TRUE(stream3.get()); 774 EXPECT_TRUE(stream3.get());
775 775
776 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2)); 776 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server2));
777 777
778 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 778 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
779 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 779 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
780 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 780 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
781 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 781 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
782 } 782 }
783 783
(...skipping 11 matching lines...) Expand all
795 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 795 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
796 796
797 host_resolver_.set_synchronous_mode(true); 797 host_resolver_.set_synchronous_mode(true);
798 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); 798 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
799 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 799 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
800 800
801 QuicStreamRequest request(factory_.get()); 801 QuicStreamRequest request(factory_.get());
802 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, 802 EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
803 /*cert_verify_flags=*/0, url_, "GET", net_log_, 803 /*cert_verify_flags=*/0, url_, "GET", net_log_,
804 callback_.callback())); 804 callback_.callback()));
805 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 805 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
806 EXPECT_TRUE(stream.get()); 806 EXPECT_TRUE(stream.get());
807 807
808 TestCompletionCallback callback; 808 TestCompletionCallback callback;
809 QuicStreamRequest request2(factory_.get()); 809 QuicStreamRequest request2(factory_.get());
810 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 810 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
811 /*cert_verify_flags=*/0, url2_, "GET", 811 /*cert_verify_flags=*/0, url2_, "GET",
812 net_log_, callback_.callback())); 812 net_log_, callback_.callback()));
813 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 813 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
814 EXPECT_TRUE(stream2.get()); 814 EXPECT_TRUE(stream2.get());
815 815
816 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1), 816 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
817 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2)); 817 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
818 818
819 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 819 EXPECT_TRUE(socket_data.AllReadDataConsumed());
820 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 820 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
821 } 821 }
822 822
823 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) { 823 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
(...skipping 14 matching lines...) Expand all
838 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 838 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
839 839
840 host_resolver_.set_synchronous_mode(true); 840 host_resolver_.set_synchronous_mode(true);
841 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); 841 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
842 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 842 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
843 843
844 QuicStreamRequest request(factory_.get()); 844 QuicStreamRequest request(factory_.get());
845 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, 845 EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
846 /*cert_verify_flags=*/0, url_, "GET", net_log_, 846 /*cert_verify_flags=*/0, url_, "GET", net_log_,
847 callback_.callback())); 847 callback_.callback()));
848 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 848 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
849 EXPECT_TRUE(stream.get()); 849 EXPECT_TRUE(stream.get());
850 850
851 TestCompletionCallback callback; 851 TestCompletionCallback callback;
852 QuicStreamRequest request2(factory_.get()); 852 QuicStreamRequest request2(factory_.get());
853 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 853 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
854 /*cert_verify_flags=*/0, url2_, "GET", 854 /*cert_verify_flags=*/0, url2_, "GET",
855 net_log_, callback_.callback())); 855 net_log_, callback_.callback()));
856 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 856 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
857 EXPECT_TRUE(stream2.get()); 857 EXPECT_TRUE(stream2.get());
858 858
859 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1), 859 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
860 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2)); 860 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
861 861
862 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 862 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
863 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 863 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
864 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 864 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
865 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 865 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
866 } 866 }
(...skipping 24 matching lines...) Expand all
891 891
892 host_resolver_.set_synchronous_mode(true); 892 host_resolver_.set_synchronous_mode(true);
893 host_resolver_.rules()->AddIPLiteralRule(alternative.host(), "192.168.0.1", 893 host_resolver_.rules()->AddIPLiteralRule(alternative.host(), "192.168.0.1",
894 ""); 894 "");
895 895
896 // Open first stream to alternative. 896 // Open first stream to alternative.
897 QuicStreamRequest request1(factory_.get()); 897 QuicStreamRequest request1(factory_.get());
898 EXPECT_EQ(OK, request1.Request(alternative, privacy_mode_, 898 EXPECT_EQ(OK, request1.Request(alternative, privacy_mode_,
899 /*cert_verify_flags=*/0, url_, "GET", 899 /*cert_verify_flags=*/0, url_, "GET",
900 net_log_, callback_.callback())); 900 net_log_, callback_.callback()));
901 scoped_ptr<QuicHttpStream> stream1 = request1.ReleaseStream(); 901 scoped_ptr<QuicHttpStream> stream1 = request1.CreateStream();
902 EXPECT_TRUE(stream1.get()); 902 EXPECT_TRUE(stream1.get());
903 903
904 QuicStreamRequest request2(factory_.get()); 904 QuicStreamRequest request2(factory_.get());
905 int rv = request2.Request(alternative, privacy_mode_, 905 int rv = request2.Request(alternative, privacy_mode_,
906 /*cert_verify_flags=*/0, url, "GET", net_log_, 906 /*cert_verify_flags=*/0, url, "GET", net_log_,
907 callback_.callback()); 907 callback_.callback());
908 if (valid) { 908 if (valid) {
909 // Alternative service of origin to |alternative| should pool to session 909 // Alternative service of origin to |alternative| should pool to session
910 // of |stream1| even if origin is different. Since only one 910 // of |stream1| even if origin is different. Since only one
911 // SocketDataProvider is set up, the second request succeeding means that 911 // SocketDataProvider is set up, the second request succeeding means that
912 // it pooled to the session opened by the first one. 912 // it pooled to the session opened by the first one.
913 EXPECT_EQ(OK, rv); 913 EXPECT_EQ(OK, rv);
914 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 914 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
915 EXPECT_TRUE(stream2.get()); 915 EXPECT_TRUE(stream2.get());
916 } else { 916 } else {
917 EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv); 917 EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv);
918 } 918 }
919 919
920 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 920 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
921 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 921 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
922 } 922 }
923 }; 923 };
924 924
(...skipping 30 matching lines...) Expand all
955 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 955 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
956 956
957 host_resolver_.set_synchronous_mode(true); 957 host_resolver_.set_synchronous_mode(true);
958 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); 958 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
959 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 959 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
960 960
961 QuicStreamRequest request(factory_.get()); 961 QuicStreamRequest request(factory_.get());
962 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, 962 EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
963 /*cert_verify_flags=*/0, url_, "GET", net_log_, 963 /*cert_verify_flags=*/0, url_, "GET", net_log_,
964 callback_.callback())); 964 callback_.callback()));
965 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 965 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
966 EXPECT_TRUE(stream.get()); 966 EXPECT_TRUE(stream.get());
967 967
968 TestCompletionCallback callback; 968 TestCompletionCallback callback;
969 QuicStreamRequest request2(factory_.get()); 969 QuicStreamRequest request2(factory_.get());
970 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 970 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
971 /*cert_verify_flags=*/0, url2_, "GET", 971 /*cert_verify_flags=*/0, url2_, "GET",
972 net_log_, callback_.callback())); 972 net_log_, callback_.callback()));
973 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 973 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
974 EXPECT_TRUE(stream2.get()); 974 EXPECT_TRUE(stream2.get());
975 975
976 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1), 976 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
977 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2)); 977 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
978 978
979 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 979 EXPECT_TRUE(socket_data.AllReadDataConsumed());
980 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 980 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
981 } 981 }
982 982
983 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) { 983 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
(...skipping 20 matching lines...) Expand all
1004 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 1004 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
1005 1005
1006 host_resolver_.set_synchronous_mode(true); 1006 host_resolver_.set_synchronous_mode(true);
1007 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); 1007 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
1008 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 1008 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1009 1009
1010 QuicStreamRequest request(factory_.get()); 1010 QuicStreamRequest request(factory_.get());
1011 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, 1011 EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
1012 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1012 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1013 callback_.callback())); 1013 callback_.callback()));
1014 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1014 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1015 EXPECT_TRUE(stream.get()); 1015 EXPECT_TRUE(stream.get());
1016 1016
1017 TestCompletionCallback callback; 1017 TestCompletionCallback callback;
1018 QuicStreamRequest request2(factory_.get()); 1018 QuicStreamRequest request2(factory_.get());
1019 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 1019 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
1020 /*cert_verify_flags=*/0, url2_, "GET", 1020 /*cert_verify_flags=*/0, url2_, "GET",
1021 net_log_, callback_.callback())); 1021 net_log_, callback_.callback()));
1022 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 1022 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
1023 EXPECT_TRUE(stream2.get()); 1023 EXPECT_TRUE(stream2.get());
1024 1024
1025 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1), 1025 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
1026 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2)); 1026 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
1027 1027
1028 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 1028 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
1029 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 1029 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
1030 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1030 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1031 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1031 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1032 } 1032 }
(...skipping 25 matching lines...) Expand all
1058 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2); 1058 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
1059 1059
1060 host_resolver_.set_synchronous_mode(true); 1060 host_resolver_.set_synchronous_mode(true);
1061 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", ""); 1061 host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
1062 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 1062 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1063 1063
1064 QuicStreamRequest request(factory_.get()); 1064 QuicStreamRequest request(factory_.get());
1065 EXPECT_EQ(OK, request.Request(server1, privacy_mode_, 1065 EXPECT_EQ(OK, request.Request(server1, privacy_mode_,
1066 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1066 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1067 callback_.callback())); 1067 callback_.callback()));
1068 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1068 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1069 EXPECT_TRUE(stream.get()); 1069 EXPECT_TRUE(stream.get());
1070 1070
1071 TestCompletionCallback callback; 1071 TestCompletionCallback callback;
1072 QuicStreamRequest request2(factory_.get()); 1072 QuicStreamRequest request2(factory_.get());
1073 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 1073 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
1074 /*cert_verify_flags=*/0, url2_, "GET", 1074 /*cert_verify_flags=*/0, url2_, "GET",
1075 net_log_, callback_.callback())); 1075 net_log_, callback_.callback()));
1076 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 1076 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
1077 EXPECT_TRUE(stream2.get()); 1077 EXPECT_TRUE(stream2.get());
1078 1078
1079 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1), 1079 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server1),
1080 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2)); 1080 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2));
1081 1081
1082 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 1082 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
1083 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 1083 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
1084 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1084 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1085 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1085 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1086 } 1086 }
(...skipping 10 matching lines...) Expand all
1097 SequencedSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 1097 SequencedSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
1098 socket_factory_.AddSocketDataProvider(&socket_data2); 1098 socket_factory_.AddSocketDataProvider(&socket_data2);
1099 1099
1100 QuicStreamRequest request(factory_.get()); 1100 QuicStreamRequest request(factory_.get());
1101 EXPECT_EQ(ERR_IO_PENDING, 1101 EXPECT_EQ(ERR_IO_PENDING,
1102 request.Request(host_port_pair_, privacy_mode_, 1102 request.Request(host_port_pair_, privacy_mode_,
1103 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1103 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1104 callback_.callback())); 1104 callback_.callback()));
1105 1105
1106 EXPECT_EQ(OK, callback_.WaitForResult()); 1106 EXPECT_EQ(OK, callback_.WaitForResult());
1107 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1107 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1108 EXPECT_TRUE(stream.get()); 1108 EXPECT_TRUE(stream.get());
1109 1109
1110 // Mark the session as going away. Ensure that while it is still alive 1110 // Mark the session as going away. Ensure that while it is still alive
1111 // that it is no longer active. 1111 // that it is no longer active.
1112 QuicChromiumClientSession* session = 1112 QuicChromiumClientSession* session =
1113 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 1113 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
1114 factory_->OnSessionGoingAway(session); 1114 factory_->OnSessionGoingAway(session);
1115 EXPECT_EQ(true, 1115 EXPECT_EQ(true,
1116 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); 1116 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
1117 EXPECT_FALSE( 1117 EXPECT_FALSE(
1118 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_)); 1118 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
1119 EXPECT_FALSE(HasActiveSession(host_port_pair_)); 1119 EXPECT_FALSE(HasActiveSession(host_port_pair_));
1120 1120
1121 // Create a new request for the same destination and verify that a 1121 // Create a new request for the same destination and verify that a
1122 // new session is created. 1122 // new session is created.
1123 QuicStreamRequest request2(factory_.get()); 1123 QuicStreamRequest request2(factory_.get());
1124 EXPECT_EQ(ERR_IO_PENDING, 1124 EXPECT_EQ(ERR_IO_PENDING,
1125 request2.Request(host_port_pair_, privacy_mode_, 1125 request2.Request(host_port_pair_, privacy_mode_,
1126 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1126 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1127 callback_.callback())); 1127 callback_.callback()));
1128 EXPECT_EQ(OK, callback_.WaitForResult()); 1128 EXPECT_EQ(OK, callback_.WaitForResult());
1129 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 1129 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
1130 EXPECT_TRUE(stream2.get()); 1130 EXPECT_TRUE(stream2.get());
1131 1131
1132 EXPECT_TRUE( 1132 EXPECT_TRUE(
1133 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_)); 1133 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
1134 EXPECT_NE(session, QuicStreamFactoryPeer::GetActiveSession(factory_.get(), 1134 EXPECT_NE(session, QuicStreamFactoryPeer::GetActiveSession(factory_.get(),
1135 host_port_pair_)); 1135 host_port_pair_));
1136 EXPECT_EQ(true, 1136 EXPECT_EQ(true,
1137 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); 1137 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
1138 1138
1139 stream2.reset(); 1139 stream2.reset();
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
1173 QuicStreamRequest request(factory_.get()); 1173 QuicStreamRequest request(factory_.get());
1174 int rv = request.Request(host_port_pair_, privacy_mode_, 1174 int rv = request.Request(host_port_pair_, privacy_mode_,
1175 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1175 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1176 callback_.callback()); 1176 callback_.callback());
1177 if (i == 0) { 1177 if (i == 0) {
1178 EXPECT_EQ(ERR_IO_PENDING, rv); 1178 EXPECT_EQ(ERR_IO_PENDING, rv);
1179 EXPECT_EQ(OK, callback_.WaitForResult()); 1179 EXPECT_EQ(OK, callback_.WaitForResult());
1180 } else { 1180 } else {
1181 EXPECT_EQ(OK, rv); 1181 EXPECT_EQ(OK, rv);
1182 } 1182 }
1183 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1183 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1184 EXPECT_TRUE(stream); 1184 EXPECT_TRUE(stream);
1185 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1185 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1186 net_log_, CompletionCallback())); 1186 net_log_, CompletionCallback()));
1187 streams.push_back(stream.release()); 1187 streams.push_back(stream.release());
1188 } 1188 }
1189 1189
1190 QuicStreamRequest request(factory_.get()); 1190 QuicStreamRequest request(factory_.get());
1191 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 1191 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
1192 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1192 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1193 CompletionCallback())); 1193 CompletionCallback()));
1194 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1194 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1195 EXPECT_TRUE(stream); 1195 EXPECT_TRUE(stream);
1196 EXPECT_EQ(ERR_IO_PENDING, 1196 EXPECT_EQ(ERR_IO_PENDING,
1197 stream->InitializeStream(&request_info, DEFAULT_PRIORITY, net_log_, 1197 stream->InitializeStream(&request_info, DEFAULT_PRIORITY, net_log_,
1198 callback_.callback())); 1198 callback_.callback()));
1199 1199
1200 // Close the first stream. 1200 // Close the first stream.
1201 streams.front()->Close(false); 1201 streams.front()->Close(false);
1202 // Trigger exchange of RSTs that in turn allow progress for the last 1202 // Trigger exchange of RSTs that in turn allow progress for the last
1203 // stream. 1203 // stream.
1204 EXPECT_EQ(OK, callback_.WaitForResult()); 1204 EXPECT_EQ(OK, callback_.WaitForResult());
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after
1332 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 1332 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1333 socket_factory_.AddSocketDataProvider(&socket_data2); 1333 socket_factory_.AddSocketDataProvider(&socket_data2);
1334 1334
1335 QuicStreamRequest request(factory_.get()); 1335 QuicStreamRequest request(factory_.get());
1336 EXPECT_EQ(ERR_IO_PENDING, 1336 EXPECT_EQ(ERR_IO_PENDING,
1337 request.Request(host_port_pair_, privacy_mode_, 1337 request.Request(host_port_pair_, privacy_mode_,
1338 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1338 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1339 callback_.callback())); 1339 callback_.callback()));
1340 1340
1341 EXPECT_EQ(OK, callback_.WaitForResult()); 1341 EXPECT_EQ(OK, callback_.WaitForResult());
1342 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1342 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1343 HttpRequestInfo request_info; 1343 HttpRequestInfo request_info;
1344 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1344 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1345 net_log_, CompletionCallback())); 1345 net_log_, CompletionCallback()));
1346 1346
1347 // Close the session and verify that stream saw the error. 1347 // Close the session and verify that stream saw the error.
1348 factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED, QUIC_INTERNAL_ERROR); 1348 factory_->CloseAllSessions(ERR_INTERNET_DISCONNECTED, QUIC_INTERNAL_ERROR);
1349 EXPECT_EQ(ERR_INTERNET_DISCONNECTED, 1349 EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
1350 stream->ReadResponseHeaders(callback_.callback())); 1350 stream->ReadResponseHeaders(callback_.callback()));
1351 1351
1352 // Now attempting to request a stream to the same origin should create 1352 // Now attempting to request a stream to the same origin should create
1353 // a new session. 1353 // a new session.
1354 1354
1355 QuicStreamRequest request2(factory_.get()); 1355 QuicStreamRequest request2(factory_.get());
1356 EXPECT_EQ(ERR_IO_PENDING, 1356 EXPECT_EQ(ERR_IO_PENDING,
1357 request2.Request(host_port_pair_, privacy_mode_, 1357 request2.Request(host_port_pair_, privacy_mode_,
1358 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1358 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1359 callback_.callback())); 1359 callback_.callback()));
1360 1360
1361 EXPECT_EQ(OK, callback_.WaitForResult()); 1361 EXPECT_EQ(OK, callback_.WaitForResult());
1362 stream = request2.ReleaseStream(); 1362 stream = request2.CreateStream();
1363 stream.reset(); // Will reset stream 3. 1363 stream.reset(); // Will reset stream 3.
1364 1364
1365 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1365 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1366 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1366 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1367 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1367 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1368 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1368 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1369 } 1369 }
1370 1370
1371 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) { 1371 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
1372 close_sessions_on_ip_change_ = true; 1372 close_sessions_on_ip_change_ = true;
(...skipping 15 matching lines...) Expand all
1388 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 1388 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1389 socket_factory_.AddSocketDataProvider(&socket_data2); 1389 socket_factory_.AddSocketDataProvider(&socket_data2);
1390 1390
1391 QuicStreamRequest request(factory_.get()); 1391 QuicStreamRequest request(factory_.get());
1392 EXPECT_EQ(ERR_IO_PENDING, 1392 EXPECT_EQ(ERR_IO_PENDING,
1393 request.Request(host_port_pair_, privacy_mode_, 1393 request.Request(host_port_pair_, privacy_mode_,
1394 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1394 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1395 callback_.callback())); 1395 callback_.callback()));
1396 1396
1397 EXPECT_EQ(OK, callback_.WaitForResult()); 1397 EXPECT_EQ(OK, callback_.WaitForResult());
1398 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1398 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1399 HttpRequestInfo request_info; 1399 HttpRequestInfo request_info;
1400 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1400 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1401 net_log_, CompletionCallback())); 1401 net_log_, CompletionCallback()));
1402 1402
1403 // Change the IP address and verify that stream saw the error. 1403 // Change the IP address and verify that stream saw the error.
1404 NotifyIPAddressChanged(); 1404 NotifyIPAddressChanged();
1405 EXPECT_EQ(ERR_NETWORK_CHANGED, 1405 EXPECT_EQ(ERR_NETWORK_CHANGED,
1406 stream->ReadResponseHeaders(callback_.callback())); 1406 stream->ReadResponseHeaders(callback_.callback()));
1407 EXPECT_TRUE(factory_->require_confirmation()); 1407 EXPECT_TRUE(factory_->require_confirmation());
1408 1408
1409 // Now attempting to request a stream to the same origin should create 1409 // Now attempting to request a stream to the same origin should create
1410 // a new session. 1410 // a new session.
1411 1411
1412 QuicStreamRequest request2(factory_.get()); 1412 QuicStreamRequest request2(factory_.get());
1413 EXPECT_EQ(ERR_IO_PENDING, 1413 EXPECT_EQ(ERR_IO_PENDING,
1414 request2.Request(host_port_pair_, privacy_mode_, 1414 request2.Request(host_port_pair_, privacy_mode_,
1415 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1415 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1416 callback_.callback())); 1416 callback_.callback()));
1417 1417
1418 EXPECT_EQ(OK, callback_.WaitForResult()); 1418 EXPECT_EQ(OK, callback_.WaitForResult());
1419 stream = request2.ReleaseStream(); 1419 stream = request2.CreateStream();
1420 stream.reset(); // Will reset stream 3. 1420 stream.reset(); // Will reset stream 3.
1421 1421
1422 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1422 EXPECT_TRUE(socket_data.AllReadDataConsumed());
1423 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1423 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1424 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1424 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1425 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1425 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1426 } 1426 }
1427 1427
1428 TEST_P(QuicStreamFactoryTest, OnNetworkChangeSoonToDisconnect) { 1428 TEST_P(QuicStreamFactoryTest, OnNetworkChangeSoonToDisconnect) {
1429 InitializeConnectionMigrationTest( 1429 InitializeConnectionMigrationTest(
(...skipping 11 matching lines...) Expand all
1441 arraysize(writes)); 1441 arraysize(writes));
1442 socket_factory_.AddSocketDataProvider(&socket_data); 1442 socket_factory_.AddSocketDataProvider(&socket_data);
1443 1443
1444 // Create request and QuicHttpStream. 1444 // Create request and QuicHttpStream.
1445 QuicStreamRequest request(factory_.get()); 1445 QuicStreamRequest request(factory_.get());
1446 EXPECT_EQ(ERR_IO_PENDING, 1446 EXPECT_EQ(ERR_IO_PENDING,
1447 request.Request(host_port_pair_, privacy_mode_, 1447 request.Request(host_port_pair_, privacy_mode_,
1448 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1448 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1449 callback_.callback())); 1449 callback_.callback()));
1450 EXPECT_EQ(OK, callback_.WaitForResult()); 1450 EXPECT_EQ(OK, callback_.WaitForResult());
1451 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1451 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1452 EXPECT_TRUE(stream.get()); 1452 EXPECT_TRUE(stream.get());
1453 1453
1454 // Cause QUIC stream to be created. 1454 // Cause QUIC stream to be created.
1455 HttpRequestInfo request_info; 1455 HttpRequestInfo request_info;
1456 request_info.method = "GET"; 1456 request_info.method = "GET";
1457 request_info.url = GURL("https://www.example.org/"); 1457 request_info.url = GURL("https://www.example.org/");
1458 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1458 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1459 net_log_, CompletionCallback())); 1459 net_log_, CompletionCallback()));
1460 1460
1461 // Ensure that session is alive and active. 1461 // Ensure that session is alive and active.
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
1506 MockRead reads2[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; 1506 MockRead reads2[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
1507 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 1507 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1508 socket_factory_.AddSocketDataProvider(&socket_data2); 1508 socket_factory_.AddSocketDataProvider(&socket_data2);
1509 1509
1510 QuicStreamRequest request2(factory_.get()); 1510 QuicStreamRequest request2(factory_.get());
1511 EXPECT_EQ(ERR_IO_PENDING, 1511 EXPECT_EQ(ERR_IO_PENDING,
1512 request2.Request(host_port_pair_, privacy_mode_, 1512 request2.Request(host_port_pair_, privacy_mode_,
1513 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1513 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1514 callback_.callback())); 1514 callback_.callback()));
1515 EXPECT_EQ(OK, callback_.WaitForResult()); 1515 EXPECT_EQ(OK, callback_.WaitForResult());
1516 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 1516 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
1517 EXPECT_TRUE(stream2.get()); 1517 EXPECT_TRUE(stream2.get());
1518 1518
1519 EXPECT_TRUE( 1519 EXPECT_TRUE(
1520 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_)); 1520 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
1521 QuicChromiumClientSession* new_session = 1521 QuicChromiumClientSession* new_session =
1522 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 1522 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
1523 EXPECT_NE(session, new_session); 1523 EXPECT_NE(session, new_session);
1524 1524
1525 // On a DISCONNECTED notification, nothing happens to the migrated 1525 // On a DISCONNECTED notification, nothing happens to the migrated
1526 // session, but the new session is closed since it has no open 1526 // session, but the new session is closed since it has no open
(...skipping 29 matching lines...) Expand all
1556 arraysize(writes)); 1556 arraysize(writes));
1557 socket_factory_.AddSocketDataProvider(&socket_data); 1557 socket_factory_.AddSocketDataProvider(&socket_data);
1558 1558
1559 // Create request and QuicHttpStream. 1559 // Create request and QuicHttpStream.
1560 QuicStreamRequest request(factory_.get()); 1560 QuicStreamRequest request(factory_.get());
1561 EXPECT_EQ(ERR_IO_PENDING, 1561 EXPECT_EQ(ERR_IO_PENDING,
1562 request.Request(host_port_pair_, privacy_mode_, 1562 request.Request(host_port_pair_, privacy_mode_,
1563 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1563 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1564 callback_.callback())); 1564 callback_.callback()));
1565 EXPECT_EQ(OK, callback_.WaitForResult()); 1565 EXPECT_EQ(OK, callback_.WaitForResult());
1566 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1566 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1567 EXPECT_TRUE(stream.get()); 1567 EXPECT_TRUE(stream.get());
1568 1568
1569 // Cause QUIC stream to be created. 1569 // Cause QUIC stream to be created.
1570 HttpRequestInfo request_info; 1570 HttpRequestInfo request_info;
1571 request_info.method = "GET"; 1571 request_info.method = "GET";
1572 request_info.url = GURL("https://www.example.org/"); 1572 request_info.url = GURL("https://www.example.org/");
1573 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1573 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1574 net_log_, CompletionCallback())); 1574 net_log_, CompletionCallback()));
1575 1575
1576 // Ensure that session is alive and active. 1576 // Ensure that session is alive and active.
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
1617 MockRead reads2[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; 1617 MockRead reads2[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
1618 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 1618 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1619 socket_factory_.AddSocketDataProvider(&socket_data2); 1619 socket_factory_.AddSocketDataProvider(&socket_data2);
1620 1620
1621 QuicStreamRequest request2(factory_.get()); 1621 QuicStreamRequest request2(factory_.get());
1622 EXPECT_EQ(ERR_IO_PENDING, 1622 EXPECT_EQ(ERR_IO_PENDING,
1623 request2.Request(host_port_pair_, privacy_mode_, 1623 request2.Request(host_port_pair_, privacy_mode_,
1624 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1624 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1625 callback_.callback())); 1625 callback_.callback()));
1626 EXPECT_EQ(OK, callback_.WaitForResult()); 1626 EXPECT_EQ(OK, callback_.WaitForResult());
1627 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 1627 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
1628 EXPECT_TRUE(stream2.get()); 1628 EXPECT_TRUE(stream2.get());
1629 1629
1630 EXPECT_TRUE( 1630 EXPECT_TRUE(
1631 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_)); 1631 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
1632 EXPECT_NE(session, QuicStreamFactoryPeer::GetActiveSession(factory_.get(), 1632 EXPECT_NE(session, QuicStreamFactoryPeer::GetActiveSession(factory_.get(),
1633 host_port_pair_)); 1633 host_port_pair_));
1634 EXPECT_EQ(true, 1634 EXPECT_EQ(true,
1635 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); 1635 QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
1636 1636
1637 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1637 EXPECT_TRUE(socket_data.AllReadDataConsumed());
(...skipping 20 matching lines...) Expand all
1658 arraysize(writes)); 1658 arraysize(writes));
1659 socket_factory_.AddSocketDataProvider(&socket_data); 1659 socket_factory_.AddSocketDataProvider(&socket_data);
1660 1660
1661 // Create request and QuicHttpStream. 1661 // Create request and QuicHttpStream.
1662 QuicStreamRequest request(factory_.get()); 1662 QuicStreamRequest request(factory_.get());
1663 EXPECT_EQ(ERR_IO_PENDING, 1663 EXPECT_EQ(ERR_IO_PENDING,
1664 request.Request(host_port_pair_, privacy_mode_, 1664 request.Request(host_port_pair_, privacy_mode_,
1665 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1665 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1666 callback_.callback())); 1666 callback_.callback()));
1667 EXPECT_EQ(OK, callback_.WaitForResult()); 1667 EXPECT_EQ(OK, callback_.WaitForResult());
1668 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1668 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1669 EXPECT_TRUE(stream.get()); 1669 EXPECT_TRUE(stream.get());
1670 1670
1671 // Cause QUIC stream to be created. 1671 // Cause QUIC stream to be created.
1672 HttpRequestInfo request_info; 1672 HttpRequestInfo request_info;
1673 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1673 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1674 net_log_, CompletionCallback())); 1674 net_log_, CompletionCallback()));
1675 1675
1676 // Ensure that session is alive and active. 1676 // Ensure that session is alive and active.
1677 QuicChromiumClientSession* session = 1677 QuicChromiumClientSession* session =
1678 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 1678 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
1712 arraysize(writes)); 1712 arraysize(writes));
1713 socket_factory_.AddSocketDataProvider(&socket_data); 1713 socket_factory_.AddSocketDataProvider(&socket_data);
1714 1714
1715 // Create request and QuicHttpStream. 1715 // Create request and QuicHttpStream.
1716 QuicStreamRequest request(factory_.get()); 1716 QuicStreamRequest request(factory_.get());
1717 EXPECT_EQ(ERR_IO_PENDING, 1717 EXPECT_EQ(ERR_IO_PENDING,
1718 request.Request(host_port_pair_, privacy_mode_, 1718 request.Request(host_port_pair_, privacy_mode_,
1719 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1719 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1720 callback_.callback())); 1720 callback_.callback()));
1721 EXPECT_EQ(OK, callback_.WaitForResult()); 1721 EXPECT_EQ(OK, callback_.WaitForResult());
1722 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1722 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1723 EXPECT_TRUE(stream.get()); 1723 EXPECT_TRUE(stream.get());
1724 1724
1725 // Cause QUIC stream to be created. 1725 // Cause QUIC stream to be created.
1726 HttpRequestInfo request_info; 1726 HttpRequestInfo request_info;
1727 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1727 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1728 net_log_, CompletionCallback())); 1728 net_log_, CompletionCallback()));
1729 1729
1730 // Ensure that session is alive and active. 1730 // Ensure that session is alive and active.
1731 QuicChromiumClientSession* session = 1731 QuicChromiumClientSession* session =
1732 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 1732 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
(...skipping 28 matching lines...) Expand all
1761 arraysize(writes)); 1761 arraysize(writes));
1762 socket_factory_.AddSocketDataProvider(&socket_data); 1762 socket_factory_.AddSocketDataProvider(&socket_data);
1763 1763
1764 // Create request and QuicHttpStream. 1764 // Create request and QuicHttpStream.
1765 QuicStreamRequest request(factory_.get()); 1765 QuicStreamRequest request(factory_.get());
1766 EXPECT_EQ(ERR_IO_PENDING, 1766 EXPECT_EQ(ERR_IO_PENDING,
1767 request.Request(host_port_pair_, privacy_mode_, 1767 request.Request(host_port_pair_, privacy_mode_,
1768 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1768 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1769 callback_.callback())); 1769 callback_.callback()));
1770 EXPECT_EQ(OK, callback_.WaitForResult()); 1770 EXPECT_EQ(OK, callback_.WaitForResult());
1771 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1771 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1772 EXPECT_TRUE(stream.get()); 1772 EXPECT_TRUE(stream.get());
1773 1773
1774 // Cause QUIC stream to be created. 1774 // Cause QUIC stream to be created.
1775 HttpRequestInfo request_info; 1775 HttpRequestInfo request_info;
1776 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1776 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1777 net_log_, CompletionCallback())); 1777 net_log_, CompletionCallback()));
1778 1778
1779 // Ensure that session is alive and active. 1779 // Ensure that session is alive and active.
1780 QuicChromiumClientSession* session = 1780 QuicChromiumClientSession* session =
1781 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 1781 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
1813 arraysize(writes)); 1813 arraysize(writes));
1814 socket_factory_.AddSocketDataProvider(&socket_data); 1814 socket_factory_.AddSocketDataProvider(&socket_data);
1815 1815
1816 // Create request and QuicHttpStream. 1816 // Create request and QuicHttpStream.
1817 QuicStreamRequest request(factory_.get()); 1817 QuicStreamRequest request(factory_.get());
1818 EXPECT_EQ(ERR_IO_PENDING, 1818 EXPECT_EQ(ERR_IO_PENDING,
1819 request.Request(host_port_pair_, privacy_mode_, 1819 request.Request(host_port_pair_, privacy_mode_,
1820 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1820 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1821 callback_.callback())); 1821 callback_.callback()));
1822 EXPECT_EQ(OK, callback_.WaitForResult()); 1822 EXPECT_EQ(OK, callback_.WaitForResult());
1823 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1823 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1824 EXPECT_TRUE(stream.get()); 1824 EXPECT_TRUE(stream.get());
1825 1825
1826 // Cause QUIC stream to be created. 1826 // Cause QUIC stream to be created.
1827 HttpRequestInfo request_info; 1827 HttpRequestInfo request_info;
1828 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1828 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1829 net_log_, CompletionCallback())); 1829 net_log_, CompletionCallback()));
1830 1830
1831 // Ensure that session is alive and active. 1831 // Ensure that session is alive and active.
1832 QuicChromiumClientSession* session = 1832 QuicChromiumClientSession* session =
1833 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 1833 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
(...skipping 30 matching lines...) Expand all
1864 arraysize(writes)); 1864 arraysize(writes));
1865 socket_factory_.AddSocketDataProvider(&socket_data); 1865 socket_factory_.AddSocketDataProvider(&socket_data);
1866 1866
1867 // Create request and QuicHttpStream. 1867 // Create request and QuicHttpStream.
1868 QuicStreamRequest request(factory_.get()); 1868 QuicStreamRequest request(factory_.get());
1869 EXPECT_EQ(ERR_IO_PENDING, 1869 EXPECT_EQ(ERR_IO_PENDING,
1870 request.Request(host_port_pair_, privacy_mode_, 1870 request.Request(host_port_pair_, privacy_mode_,
1871 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1871 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1872 callback_.callback())); 1872 callback_.callback()));
1873 EXPECT_EQ(OK, callback_.WaitForResult()); 1873 EXPECT_EQ(OK, callback_.WaitForResult());
1874 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1874 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1875 EXPECT_TRUE(stream.get()); 1875 EXPECT_TRUE(stream.get());
1876 1876
1877 // Cause QUIC stream to be created, but marked as non-migratable. 1877 // Cause QUIC stream to be created, but marked as non-migratable.
1878 HttpRequestInfo request_info; 1878 HttpRequestInfo request_info;
1879 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; 1879 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION;
1880 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1880 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1881 net_log_, CompletionCallback())); 1881 net_log_, CompletionCallback()));
1882 1882
1883 // Ensure that session is alive and active. 1883 // Ensure that session is alive and active.
1884 QuicChromiumClientSession* session = 1884 QuicChromiumClientSession* session =
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
1917 arraysize(writes)); 1917 arraysize(writes));
1918 socket_factory_.AddSocketDataProvider(&socket_data); 1918 socket_factory_.AddSocketDataProvider(&socket_data);
1919 1919
1920 // Create request and QuicHttpStream. 1920 // Create request and QuicHttpStream.
1921 QuicStreamRequest request(factory_.get()); 1921 QuicStreamRequest request(factory_.get());
1922 EXPECT_EQ(ERR_IO_PENDING, 1922 EXPECT_EQ(ERR_IO_PENDING,
1923 request.Request(host_port_pair_, privacy_mode_, 1923 request.Request(host_port_pair_, privacy_mode_,
1924 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1924 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1925 callback_.callback())); 1925 callback_.callback()));
1926 EXPECT_EQ(OK, callback_.WaitForResult()); 1926 EXPECT_EQ(OK, callback_.WaitForResult());
1927 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1927 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1928 EXPECT_TRUE(stream.get()); 1928 EXPECT_TRUE(stream.get());
1929 1929
1930 // Cause QUIC stream to be created, but marked as non-migratable. 1930 // Cause QUIC stream to be created, but marked as non-migratable.
1931 HttpRequestInfo request_info; 1931 HttpRequestInfo request_info;
1932 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; 1932 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION;
1933 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 1933 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1934 net_log_, CompletionCallback())); 1934 net_log_, CompletionCallback()));
1935 1935
1936 // Ensure that session is alive and active. 1936 // Ensure that session is alive and active.
1937 QuicChromiumClientSession* session = 1937 QuicChromiumClientSession* session =
(...skipping 24 matching lines...) Expand all
1962 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0u); 1962 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0u);
1963 socket_factory_.AddSocketDataProvider(&socket_data); 1963 socket_factory_.AddSocketDataProvider(&socket_data);
1964 1964
1965 // Create request and QuicHttpStream. 1965 // Create request and QuicHttpStream.
1966 QuicStreamRequest request(factory_.get()); 1966 QuicStreamRequest request(factory_.get());
1967 EXPECT_EQ(ERR_IO_PENDING, 1967 EXPECT_EQ(ERR_IO_PENDING,
1968 request.Request(host_port_pair_, privacy_mode_, 1968 request.Request(host_port_pair_, privacy_mode_,
1969 /*cert_verify_flags=*/0, url_, "GET", net_log_, 1969 /*cert_verify_flags=*/0, url_, "GET", net_log_,
1970 callback_.callback())); 1970 callback_.callback()));
1971 EXPECT_EQ(OK, callback_.WaitForResult()); 1971 EXPECT_EQ(OK, callback_.WaitForResult());
1972 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1972 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
1973 EXPECT_TRUE(stream.get()); 1973 EXPECT_TRUE(stream.get());
1974 1974
1975 // Ensure that session is alive and active. 1975 // Ensure that session is alive and active.
1976 QuicChromiumClientSession* session = 1976 QuicChromiumClientSession* session =
1977 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 1977 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
1978 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); 1978 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
1979 EXPECT_TRUE(HasActiveSession(host_port_pair_)); 1979 EXPECT_TRUE(HasActiveSession(host_port_pair_));
1980 1980
1981 // Trigger connection migration. Since there are no active streams, 1981 // Trigger connection migration. Since there are no active streams,
1982 // the session will be closed. 1982 // the session will be closed.
(...skipping 17 matching lines...) Expand all
2000 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0u); 2000 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0u);
2001 socket_factory_.AddSocketDataProvider(&socket_data); 2001 socket_factory_.AddSocketDataProvider(&socket_data);
2002 2002
2003 // Create request and QuicHttpStream. 2003 // Create request and QuicHttpStream.
2004 QuicStreamRequest request(factory_.get()); 2004 QuicStreamRequest request(factory_.get());
2005 EXPECT_EQ(ERR_IO_PENDING, 2005 EXPECT_EQ(ERR_IO_PENDING,
2006 request.Request(host_port_pair_, privacy_mode_, 2006 request.Request(host_port_pair_, privacy_mode_,
2007 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2007 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2008 callback_.callback())); 2008 callback_.callback()));
2009 EXPECT_EQ(OK, callback_.WaitForResult()); 2009 EXPECT_EQ(OK, callback_.WaitForResult());
2010 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2010 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2011 EXPECT_TRUE(stream.get()); 2011 EXPECT_TRUE(stream.get());
2012 2012
2013 // Ensure that session is alive and active. 2013 // Ensure that session is alive and active.
2014 QuicChromiumClientSession* session = 2014 QuicChromiumClientSession* session =
2015 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 2015 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
2016 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session)); 2016 EXPECT_TRUE(QuicStreamFactoryPeer::IsLiveSession(factory_.get(), session));
2017 EXPECT_TRUE(HasActiveSession(host_port_pair_)); 2017 EXPECT_TRUE(HasActiveSession(host_port_pair_));
2018 2018
2019 // Trigger connection migration. Since there are no active streams, 2019 // Trigger connection migration. Since there are no active streams,
2020 // the session will be closed. 2020 // the session will be closed.
(...skipping 23 matching lines...) Expand all
2044 arraysize(writes)); 2044 arraysize(writes));
2045 socket_factory_.AddSocketDataProvider(&socket_data); 2045 socket_factory_.AddSocketDataProvider(&socket_data);
2046 2046
2047 // Create request and QuicHttpStream. 2047 // Create request and QuicHttpStream.
2048 QuicStreamRequest request(factory_.get()); 2048 QuicStreamRequest request(factory_.get());
2049 EXPECT_EQ(ERR_IO_PENDING, 2049 EXPECT_EQ(ERR_IO_PENDING,
2050 request.Request(host_port_pair_, privacy_mode_, 2050 request.Request(host_port_pair_, privacy_mode_,
2051 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2051 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2052 callback_.callback())); 2052 callback_.callback()));
2053 EXPECT_EQ(OK, callback_.WaitForResult()); 2053 EXPECT_EQ(OK, callback_.WaitForResult());
2054 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2054 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2055 EXPECT_TRUE(stream.get()); 2055 EXPECT_TRUE(stream.get());
2056 2056
2057 // Cause QUIC stream to be created. 2057 // Cause QUIC stream to be created.
2058 HttpRequestInfo request_info; 2058 HttpRequestInfo request_info;
2059 request_info.method = "GET"; 2059 request_info.method = "GET";
2060 request_info.url = GURL("https://www.example.org/"); 2060 request_info.url = GURL("https://www.example.org/");
2061 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 2061 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2062 net_log_, CompletionCallback())); 2062 net_log_, CompletionCallback()));
2063 2063
2064 // Ensure that session is alive and active. 2064 // Ensure that session is alive and active.
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after
2112 MockRead reads2[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; 2112 MockRead reads2[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
2113 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 2113 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
2114 socket_factory_.AddSocketDataProvider(&socket_data2); 2114 socket_factory_.AddSocketDataProvider(&socket_data2);
2115 2115
2116 QuicStreamRequest request2(factory_.get()); 2116 QuicStreamRequest request2(factory_.get());
2117 EXPECT_EQ(ERR_IO_PENDING, 2117 EXPECT_EQ(ERR_IO_PENDING,
2118 request2.Request(host_port_pair_, privacy_mode_, 2118 request2.Request(host_port_pair_, privacy_mode_,
2119 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2119 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2120 callback_.callback())); 2120 callback_.callback()));
2121 EXPECT_EQ(OK, callback_.WaitForResult()); 2121 EXPECT_EQ(OK, callback_.WaitForResult());
2122 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 2122 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
2123 EXPECT_TRUE(stream2.get()); 2123 EXPECT_TRUE(stream2.get());
2124 2124
2125 EXPECT_TRUE( 2125 EXPECT_TRUE(
2126 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_)); 2126 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), host_port_pair_));
2127 QuicChromiumClientSession* new_session = 2127 QuicChromiumClientSession* new_session =
2128 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 2128 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
2129 EXPECT_NE(session, new_session); 2129 EXPECT_NE(session, new_session);
2130 2130
2131 // On a SOON_TO_DISCONNECT notification, nothing happens to the 2131 // On a SOON_TO_DISCONNECT notification, nothing happens to the
2132 // migrated session, but the new session is closed since it has no 2132 // migrated session, but the new session is closed since it has no
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
2167 arraysize(writes)); 2167 arraysize(writes));
2168 socket_factory_.AddSocketDataProvider(&socket_data); 2168 socket_factory_.AddSocketDataProvider(&socket_data);
2169 2169
2170 // Create request and QuicHttpStream. 2170 // Create request and QuicHttpStream.
2171 QuicStreamRequest request(factory_.get()); 2171 QuicStreamRequest request(factory_.get());
2172 EXPECT_EQ(ERR_IO_PENDING, 2172 EXPECT_EQ(ERR_IO_PENDING,
2173 request.Request(host_port_pair_, privacy_mode_, 2173 request.Request(host_port_pair_, privacy_mode_,
2174 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2174 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2175 callback_.callback())); 2175 callback_.callback()));
2176 EXPECT_EQ(OK, callback_.WaitForResult()); 2176 EXPECT_EQ(OK, callback_.WaitForResult());
2177 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2177 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2178 EXPECT_TRUE(stream.get()); 2178 EXPECT_TRUE(stream.get());
2179 2179
2180 // Cause QUIC stream to be created. 2180 // Cause QUIC stream to be created.
2181 HttpRequestInfo request_info; 2181 HttpRequestInfo request_info;
2182 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 2182 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2183 net_log_, CompletionCallback())); 2183 net_log_, CompletionCallback()));
2184 2184
2185 // Ensure that session is alive and active. 2185 // Ensure that session is alive and active.
2186 QuicChromiumClientSession* session = 2186 QuicChromiumClientSession* session =
2187 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 2187 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
2223 arraysize(writes)); 2223 arraysize(writes));
2224 socket_factory_.AddSocketDataProvider(&socket_data); 2224 socket_factory_.AddSocketDataProvider(&socket_data);
2225 2225
2226 // Create request and QuicHttpStream. 2226 // Create request and QuicHttpStream.
2227 QuicStreamRequest request(factory_.get()); 2227 QuicStreamRequest request(factory_.get());
2228 EXPECT_EQ(ERR_IO_PENDING, 2228 EXPECT_EQ(ERR_IO_PENDING,
2229 request.Request(host_port_pair_, privacy_mode_, 2229 request.Request(host_port_pair_, privacy_mode_,
2230 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2230 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2231 callback_.callback())); 2231 callback_.callback()));
2232 EXPECT_EQ(OK, callback_.WaitForResult()); 2232 EXPECT_EQ(OK, callback_.WaitForResult());
2233 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2233 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2234 EXPECT_TRUE(stream.get()); 2234 EXPECT_TRUE(stream.get());
2235 2235
2236 // Cause QUIC stream to be created, but marked as non-migratable. 2236 // Cause QUIC stream to be created, but marked as non-migratable.
2237 HttpRequestInfo request_info; 2237 HttpRequestInfo request_info;
2238 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION; 2238 request_info.load_flags |= LOAD_DISABLE_CONNECTION_MIGRATION;
2239 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 2239 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2240 net_log_, CompletionCallback())); 2240 net_log_, CompletionCallback()));
2241 2241
2242 // Ensure that session is alive and active. 2242 // Ensure that session is alive and active.
2243 QuicChromiumClientSession* session = 2243 QuicChromiumClientSession* session =
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after
2282 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 2282 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
2283 socket_factory_.AddSocketDataProvider(&socket_data2); 2283 socket_factory_.AddSocketDataProvider(&socket_data2);
2284 2284
2285 QuicStreamRequest request(factory_.get()); 2285 QuicStreamRequest request(factory_.get());
2286 EXPECT_EQ(ERR_IO_PENDING, 2286 EXPECT_EQ(ERR_IO_PENDING,
2287 request.Request(host_port_pair_, privacy_mode_, 2287 request.Request(host_port_pair_, privacy_mode_,
2288 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2288 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2289 callback_.callback())); 2289 callback_.callback()));
2290 2290
2291 EXPECT_EQ(OK, callback_.WaitForResult()); 2291 EXPECT_EQ(OK, callback_.WaitForResult());
2292 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2292 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2293 HttpRequestInfo request_info; 2293 HttpRequestInfo request_info;
2294 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 2294 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2295 net_log_, CompletionCallback())); 2295 net_log_, CompletionCallback()));
2296 2296
2297 factory_->OnSSLConfigChanged(); 2297 factory_->OnSSLConfigChanged();
2298 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, 2298 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
2299 stream->ReadResponseHeaders(callback_.callback())); 2299 stream->ReadResponseHeaders(callback_.callback()));
2300 EXPECT_FALSE(factory_->require_confirmation()); 2300 EXPECT_FALSE(factory_->require_confirmation());
2301 2301
2302 // Now attempting to request a stream to the same origin should create 2302 // Now attempting to request a stream to the same origin should create
2303 // a new session. 2303 // a new session.
2304 2304
2305 QuicStreamRequest request2(factory_.get()); 2305 QuicStreamRequest request2(factory_.get());
2306 EXPECT_EQ(ERR_IO_PENDING, 2306 EXPECT_EQ(ERR_IO_PENDING,
2307 request2.Request(host_port_pair_, privacy_mode_, 2307 request2.Request(host_port_pair_, privacy_mode_,
2308 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2308 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2309 callback_.callback())); 2309 callback_.callback()));
2310 2310
2311 EXPECT_EQ(OK, callback_.WaitForResult()); 2311 EXPECT_EQ(OK, callback_.WaitForResult());
2312 stream = request2.ReleaseStream(); 2312 stream = request2.CreateStream();
2313 stream.reset(); // Will reset stream 3. 2313 stream.reset(); // Will reset stream 3.
2314 2314
2315 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 2315 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2316 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 2316 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2317 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 2317 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2318 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 2318 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2319 } 2319 }
2320 2320
2321 TEST_P(QuicStreamFactoryTest, OnCertAdded) { 2321 TEST_P(QuicStreamFactoryTest, OnCertAdded) {
2322 Initialize(); 2322 Initialize();
(...skipping 14 matching lines...) Expand all
2337 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 2337 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
2338 socket_factory_.AddSocketDataProvider(&socket_data2); 2338 socket_factory_.AddSocketDataProvider(&socket_data2);
2339 2339
2340 QuicStreamRequest request(factory_.get()); 2340 QuicStreamRequest request(factory_.get());
2341 EXPECT_EQ(ERR_IO_PENDING, 2341 EXPECT_EQ(ERR_IO_PENDING,
2342 request.Request(host_port_pair_, privacy_mode_, 2342 request.Request(host_port_pair_, privacy_mode_,
2343 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2343 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2344 callback_.callback())); 2344 callback_.callback()));
2345 2345
2346 EXPECT_EQ(OK, callback_.WaitForResult()); 2346 EXPECT_EQ(OK, callback_.WaitForResult());
2347 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2347 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2348 HttpRequestInfo request_info; 2348 HttpRequestInfo request_info;
2349 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 2349 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2350 net_log_, CompletionCallback())); 2350 net_log_, CompletionCallback()));
2351 2351
2352 // Add a cert and verify that stream saw the event. 2352 // Add a cert and verify that stream saw the event.
2353 factory_->OnCertAdded(nullptr); 2353 factory_->OnCertAdded(nullptr);
2354 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, 2354 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
2355 stream->ReadResponseHeaders(callback_.callback())); 2355 stream->ReadResponseHeaders(callback_.callback()));
2356 EXPECT_FALSE(factory_->require_confirmation()); 2356 EXPECT_FALSE(factory_->require_confirmation());
2357 2357
2358 // Now attempting to request a stream to the same origin should create 2358 // Now attempting to request a stream to the same origin should create
2359 // a new session. 2359 // a new session.
2360 2360
2361 QuicStreamRequest request2(factory_.get()); 2361 QuicStreamRequest request2(factory_.get());
2362 EXPECT_EQ(ERR_IO_PENDING, 2362 EXPECT_EQ(ERR_IO_PENDING,
2363 request2.Request(host_port_pair_, privacy_mode_, 2363 request2.Request(host_port_pair_, privacy_mode_,
2364 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2364 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2365 callback_.callback())); 2365 callback_.callback()));
2366 2366
2367 EXPECT_EQ(OK, callback_.WaitForResult()); 2367 EXPECT_EQ(OK, callback_.WaitForResult());
2368 stream = request2.ReleaseStream(); 2368 stream = request2.CreateStream();
2369 stream.reset(); // Will reset stream 3. 2369 stream.reset(); // Will reset stream 3.
2370 2370
2371 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 2371 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2372 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 2372 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2373 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 2373 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2374 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 2374 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2375 } 2375 }
2376 2376
2377 TEST_P(QuicStreamFactoryTest, OnCACertChanged) { 2377 TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
2378 Initialize(); 2378 Initialize();
(...skipping 14 matching lines...) Expand all
2393 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0); 2393 SequencedSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
2394 socket_factory_.AddSocketDataProvider(&socket_data2); 2394 socket_factory_.AddSocketDataProvider(&socket_data2);
2395 2395
2396 QuicStreamRequest request(factory_.get()); 2396 QuicStreamRequest request(factory_.get());
2397 EXPECT_EQ(ERR_IO_PENDING, 2397 EXPECT_EQ(ERR_IO_PENDING,
2398 request.Request(host_port_pair_, privacy_mode_, 2398 request.Request(host_port_pair_, privacy_mode_,
2399 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2399 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2400 callback_.callback())); 2400 callback_.callback()));
2401 2401
2402 EXPECT_EQ(OK, callback_.WaitForResult()); 2402 EXPECT_EQ(OK, callback_.WaitForResult());
2403 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2403 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2404 HttpRequestInfo request_info; 2404 HttpRequestInfo request_info;
2405 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 2405 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2406 net_log_, CompletionCallback())); 2406 net_log_, CompletionCallback()));
2407 2407
2408 // Change the CA cert and verify that stream saw the event. 2408 // Change the CA cert and verify that stream saw the event.
2409 factory_->OnCACertChanged(nullptr); 2409 factory_->OnCACertChanged(nullptr);
2410 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED, 2410 EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
2411 stream->ReadResponseHeaders(callback_.callback())); 2411 stream->ReadResponseHeaders(callback_.callback()));
2412 EXPECT_FALSE(factory_->require_confirmation()); 2412 EXPECT_FALSE(factory_->require_confirmation());
2413 2413
2414 // Now attempting to request a stream to the same origin should create 2414 // Now attempting to request a stream to the same origin should create
2415 // a new session. 2415 // a new session.
2416 2416
2417 QuicStreamRequest request2(factory_.get()); 2417 QuicStreamRequest request2(factory_.get());
2418 EXPECT_EQ(ERR_IO_PENDING, 2418 EXPECT_EQ(ERR_IO_PENDING,
2419 request2.Request(host_port_pair_, privacy_mode_, 2419 request2.Request(host_port_pair_, privacy_mode_,
2420 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2420 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2421 callback_.callback())); 2421 callback_.callback()));
2422 2422
2423 EXPECT_EQ(OK, callback_.WaitForResult()); 2423 EXPECT_EQ(OK, callback_.WaitForResult());
2424 stream = request2.ReleaseStream(); 2424 stream = request2.CreateStream();
2425 stream.reset(); // Will reset stream 3. 2425 stream.reset(); // Will reset stream 3.
2426 2426
2427 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 2427 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2428 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 2428 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2429 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 2429 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2430 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 2430 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2431 } 2431 }
2432 2432
2433 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) { 2433 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
2434 Initialize(); 2434 Initialize();
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after
2541 QuicServerId server_id(host_port_pair_, privacy_mode_); 2541 QuicServerId server_id(host_port_pair_, privacy_mode_);
2542 EXPECT_EQ(ERR_IO_PENDING, 2542 EXPECT_EQ(ERR_IO_PENDING,
2543 request.Request(host_port_pair_, privacy_mode_, 2543 request.Request(host_port_pair_, privacy_mode_,
2544 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2544 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2545 callback_.callback())); 2545 callback_.callback()));
2546 EXPECT_EQ(2u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(), 2546 EXPECT_EQ(2u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(),
2547 server_id)); 2547 server_id));
2548 2548
2549 runner_->RunNextTask(); 2549 runner_->RunNextTask();
2550 2550
2551 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2551 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2552 EXPECT_TRUE(stream.get()); 2552 EXPECT_TRUE(stream.get());
2553 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 2553 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2554 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 2554 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2555 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(), 2555 EXPECT_EQ(0u, QuicStreamFactoryPeer::GetNumberOfActiveJobs(factory_.get(),
2556 server_id)); 2556 server_id));
2557 } 2557 }
2558 2558
2559 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) { 2559 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
2560 disable_disk_cache_ = true; 2560 disable_disk_cache_ = true;
2561 Initialize(); 2561 Initialize();
(...skipping 14 matching lines...) Expand all
2576 2576
2577 QuicStreamRequest request(factory_.get()); 2577 QuicStreamRequest request(factory_.get());
2578 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 2578 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
2579 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2579 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2580 callback_.callback())); 2580 callback_.callback()));
2581 2581
2582 // If we are waiting for disk cache, we would have posted a task. Verify that 2582 // If we are waiting for disk cache, we would have posted a task. Verify that
2583 // the CancelWaitForDataReady task hasn't been posted. 2583 // the CancelWaitForDataReady task hasn't been posted.
2584 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); 2584 ASSERT_EQ(0u, runner_->GetPostedTasks().size());
2585 2585
2586 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2586 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2587 EXPECT_TRUE(stream.get()); 2587 EXPECT_TRUE(stream.get());
2588 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 2588 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2589 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 2589 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2590 } 2590 }
2591 2591
2592 TEST_P(QuicStreamFactoryTest, BadPacketLoss) { 2592 TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
2593 disable_disk_cache_ = false; 2593 disable_disk_cache_ = false;
2594 max_number_of_lossy_connections_ = 2; 2594 max_number_of_lossy_connections_ = 2;
2595 Initialize(); 2595 Initialize();
2596 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 2596 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
(...skipping 140 matching lines...) Expand 10 before | Expand all | Expand 10 after
2737 factory_->OnHandshakeConfirmed(session4, /*packet_loss_rate=*/1.0f)); 2737 factory_->OnHandshakeConfirmed(session4, /*packet_loss_rate=*/1.0f));
2738 EXPECT_EQ(3, QuicStreamFactoryPeer::GetNumberOfLossyConnections( 2738 EXPECT_EQ(3, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
2739 factory_.get(), server4.port())); 2739 factory_.get(), server4.port()));
2740 EXPECT_FALSE(session4->connection()->connected()); 2740 EXPECT_FALSE(session4->connection()->connected());
2741 EXPECT_TRUE( 2741 EXPECT_TRUE(
2742 QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), server4.port())); 2742 QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), server4.port()));
2743 EXPECT_FALSE( 2743 EXPECT_FALSE(
2744 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server4)); 2744 QuicStreamFactoryPeer::HasActiveSession(factory_.get(), server4));
2745 EXPECT_FALSE(HasActiveSession(server4)); 2745 EXPECT_FALSE(HasActiveSession(server4));
2746 2746
2747 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2747 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2748 EXPECT_TRUE(stream.get()); 2748 EXPECT_TRUE(stream.get());
2749 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 2749 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
2750 EXPECT_TRUE(stream2.get()); 2750 EXPECT_TRUE(stream2.get());
2751 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 2751 scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
2752 EXPECT_TRUE(stream3.get()); 2752 EXPECT_TRUE(stream3.get());
2753 scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream(); 2753 scoped_ptr<QuicHttpStream> stream4 = request4.CreateStream();
2754 EXPECT_TRUE(stream4.get()); 2754 EXPECT_TRUE(stream4.get());
2755 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 2755 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2756 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 2756 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2757 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 2757 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2758 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 2758 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2759 EXPECT_TRUE(socket_data3.AllReadDataConsumed()); 2759 EXPECT_TRUE(socket_data3.AllReadDataConsumed());
2760 EXPECT_TRUE(socket_data3.AllWriteDataConsumed()); 2760 EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
2761 EXPECT_TRUE(socket_data4.AllReadDataConsumed()); 2761 EXPECT_TRUE(socket_data4.AllReadDataConsumed());
2762 EXPECT_TRUE(socket_data4.AllWriteDataConsumed()); 2762 EXPECT_TRUE(socket_data4.AllWriteDataConsumed());
2763 } 2763 }
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after
2830 base::RunLoop run_loop2; 2830 base::RunLoop run_loop2;
2831 run_loop2.RunUntilIdle(); 2831 run_loop2.RunUntilIdle();
2832 EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake( 2832 EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
2833 factory_.get())); 2833 factory_.get()));
2834 EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), 2834 EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
2835 host_port_pair_.port())); 2835 host_port_pair_.port()));
2836 EXPECT_EQ( 2836 EXPECT_EQ(
2837 QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE, 2837 QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
2838 factory_->QuicDisabledReason(host_port_pair_.port())); 2838 factory_->QuicDisabledReason(host_port_pair_.port()));
2839 2839
2840 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2840 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2841 EXPECT_TRUE(stream.get()); 2841 EXPECT_FALSE(stream.get()); // Session is already closed.
2842 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 2842 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
2843 EXPECT_TRUE(stream2.get()); 2843 EXPECT_FALSE(stream2.get()); // Session is already closed.
2844 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 2844 EXPECT_TRUE(socket_data.AllReadDataConsumed());
2845 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 2845 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2846 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 2846 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2847 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 2847 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2848 } 2848 }
2849 2849
2850 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) { 2850 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) {
2851 disable_disk_cache_ = true; 2851 disable_disk_cache_ = true;
2852 threshold_timeouts_with_open_streams_ = 2; 2852 threshold_timeouts_with_open_streams_ = 2;
2853 Initialize(); 2853 Initialize();
(...skipping 24 matching lines...) Expand all
2878 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", ""); 2878 host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
2879 2879
2880 QuicStreamRequest request(factory_.get()); 2880 QuicStreamRequest request(factory_.get());
2881 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 2881 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
2882 /*cert_verify_flags=*/0, url_, "GET", net_log_, 2882 /*cert_verify_flags=*/0, url_, "GET", net_log_,
2883 callback_.callback())); 2883 callback_.callback()));
2884 2884
2885 QuicChromiumClientSession* session = 2885 QuicChromiumClientSession* session =
2886 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 2886 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
2887 2887
2888 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 2888 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
2889 EXPECT_TRUE(stream.get()); 2889 EXPECT_TRUE(stream.get());
2890 HttpRequestInfo request_info; 2890 HttpRequestInfo request_info;
2891 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 2891 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2892 net_log_, CompletionCallback())); 2892 net_log_, CompletionCallback()));
2893 2893
2894 DVLOG(1) 2894 DVLOG(1)
2895 << "Created 1st session and initialized a stream. Now trigger timeout"; 2895 << "Created 1st session and initialized a stream. Now trigger timeout";
2896 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, 2896 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
2897 ConnectionCloseSource::FROM_SELF); 2897 ConnectionCloseSource::FROM_SELF);
2898 // Need to spin the loop now to ensure that 2898 // Need to spin the loop now to ensure that
2899 // QuicStreamFactory::OnSessionClosed() runs. 2899 // QuicStreamFactory::OnSessionClosed() runs.
2900 base::RunLoop run_loop; 2900 base::RunLoop run_loop;
2901 run_loop.RunUntilIdle(); 2901 run_loop.RunUntilIdle();
2902 2902
2903 EXPECT_EQ( 2903 EXPECT_EQ(
2904 1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get())); 2904 1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
2905 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), 2905 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
2906 host_port_pair_.port())); 2906 host_port_pair_.port()));
2907 2907
2908 // Test two-in-a-row timeouts with open streams. 2908 // Test two-in-a-row timeouts with open streams.
2909 DVLOG(1) << "Create 2nd session and timeout with open stream"; 2909 DVLOG(1) << "Create 2nd session and timeout with open stream";
2910 TestCompletionCallback callback2; 2910 TestCompletionCallback callback2;
2911 QuicStreamRequest request2(factory_.get()); 2911 QuicStreamRequest request2(factory_.get());
2912 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_, 2912 EXPECT_EQ(OK, request2.Request(server2, privacy_mode_,
2913 /*cert_verify_flags=*/0, url2_, "GET", 2913 /*cert_verify_flags=*/0, url2_, "GET",
2914 net_log_, callback2.callback())); 2914 net_log_, callback2.callback()));
2915 QuicChromiumClientSession* session2 = 2915 QuicChromiumClientSession* session2 =
2916 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2); 2916 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server2);
2917 2917
2918 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 2918 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
2919 EXPECT_TRUE(stream2.get()); 2919 EXPECT_TRUE(stream2.get());
2920 EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY, 2920 EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY,
2921 net_log_, CompletionCallback())); 2921 net_log_, CompletionCallback()));
2922 2922
2923 session2->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, 2923 session2->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
2924 ConnectionCloseSource::FROM_SELF); 2924 ConnectionCloseSource::FROM_SELF);
2925 // Need to spin the loop now to ensure that 2925 // Need to spin the loop now to ensure that
2926 // QuicStreamFactory::OnSessionClosed() runs. 2926 // QuicStreamFactory::OnSessionClosed() runs.
2927 base::RunLoop run_loop2; 2927 base::RunLoop run_loop2;
2928 run_loop2.RunUntilIdle(); 2928 run_loop2.RunUntilIdle();
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after
3040 base::RunLoop run_loop3; 3040 base::RunLoop run_loop3;
3041 run_loop3.RunUntilIdle(); 3041 run_loop3.RunUntilIdle();
3042 EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake( 3042 EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
3043 factory_.get())); 3043 factory_.get()));
3044 EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), 3044 EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
3045 host_port_pair_.port())); 3045 host_port_pair_.port()));
3046 EXPECT_EQ( 3046 EXPECT_EQ(
3047 QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE, 3047 QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
3048 factory_->QuicDisabledReason(host_port_pair_.port())); 3048 factory_->QuicDisabledReason(host_port_pair_.port()));
3049 3049
3050 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3050 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3051 EXPECT_TRUE(stream.get()); 3051 EXPECT_FALSE(stream.get()); // Session is already closed.
3052 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 3052 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
3053 EXPECT_TRUE(stream2.get()); 3053 EXPECT_FALSE(stream2.get()); // Session is already closed.
3054 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 3054 scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
3055 EXPECT_TRUE(stream3.get()); 3055 EXPECT_FALSE(stream3.get()); // Session is already closed.
3056 3056
3057 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 3057 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3058 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 3058 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3059 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 3059 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
3060 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 3060 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
3061 EXPECT_TRUE(socket_data3.AllReadDataConsumed()); 3061 EXPECT_TRUE(socket_data3.AllReadDataConsumed());
3062 EXPECT_TRUE(socket_data3.AllWriteDataConsumed()); 3062 EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
3063 } 3063 }
3064 3064
3065 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) { 3065 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) {
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after
3101 3101
3102 // Test first and third out of three timeouts with open streams. 3102 // Test first and third out of three timeouts with open streams.
3103 QuicStreamRequest request(factory_.get()); 3103 QuicStreamRequest request(factory_.get());
3104 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 3104 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
3105 /*cert_verify_flags=*/0, url_, "GET", net_log_, 3105 /*cert_verify_flags=*/0, url_, "GET", net_log_,
3106 callback_.callback())); 3106 callback_.callback()));
3107 3107
3108 QuicChromiumClientSession* session = 3108 QuicChromiumClientSession* session =
3109 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 3109 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
3110 3110
3111 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3111 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3112 EXPECT_TRUE(stream.get()); 3112 EXPECT_TRUE(stream.get());
3113 HttpRequestInfo request_info; 3113 HttpRequestInfo request_info;
3114 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 3114 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
3115 net_log_, CompletionCallback())); 3115 net_log_, CompletionCallback()));
3116 3116
3117 DVLOG(1) 3117 DVLOG(1)
3118 << "Created 1st session and initialized a stream. Now trigger timeout"; 3118 << "Created 1st session and initialized a stream. Now trigger timeout";
3119 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, 3119 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
3120 ConnectionCloseSource::FROM_SELF); 3120 ConnectionCloseSource::FROM_SELF);
3121 // Need to spin the loop now to ensure that 3121 // Need to spin the loop now to ensure that
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
3153 << " will disable QUIC"; 3153 << " will disable QUIC";
3154 3154
3155 TestCompletionCallback callback3; 3155 TestCompletionCallback callback3;
3156 QuicStreamRequest request3(factory_.get()); 3156 QuicStreamRequest request3(factory_.get());
3157 EXPECT_EQ(OK, request3.Request(server3, privacy_mode_, 3157 EXPECT_EQ(OK, request3.Request(server3, privacy_mode_,
3158 /*cert_verify_flags=*/0, url3_, "GET", 3158 /*cert_verify_flags=*/0, url3_, "GET",
3159 net_log_, callback3.callback())); 3159 net_log_, callback3.callback()));
3160 QuicChromiumClientSession* session3 = 3160 QuicChromiumClientSession* session3 =
3161 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3); 3161 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server3);
3162 3162
3163 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 3163 scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
3164 EXPECT_TRUE(stream3.get()); 3164 EXPECT_TRUE(stream3.get());
3165 EXPECT_EQ(OK, stream3->InitializeStream(&request_info, DEFAULT_PRIORITY, 3165 EXPECT_EQ(OK, stream3->InitializeStream(&request_info, DEFAULT_PRIORITY,
3166 net_log_, CompletionCallback())); 3166 net_log_, CompletionCallback()));
3167 session3->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, 3167 session3->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
3168 ConnectionCloseSource::FROM_SELF); 3168 ConnectionCloseSource::FROM_SELF);
3169 // Need to spin the loop now to ensure that 3169 // Need to spin the loop now to ensure that
3170 // QuicStreamFactory::OnSessionClosed() runs. 3170 // QuicStreamFactory::OnSessionClosed() runs.
3171 base::RunLoop run_loop3; 3171 base::RunLoop run_loop3;
3172 run_loop3.RunUntilIdle(); 3172 run_loop3.RunUntilIdle();
3173 EXPECT_EQ( 3173 EXPECT_EQ(
3174 2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get())); 3174 2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
3175 EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), 3175 EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
3176 host_port_pair_.port())); 3176 host_port_pair_.port()));
3177 EXPECT_EQ(QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS, 3177 EXPECT_EQ(QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS,
3178 factory_->QuicDisabledReason(host_port_pair_.port())); 3178 factory_->QuicDisabledReason(host_port_pair_.port()));
3179 3179
3180 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 3180 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
3181 EXPECT_TRUE(stream2.get()); 3181 EXPECT_FALSE(stream2.get()); // Session is already closed.
3182 3182
3183 // Verify that QUIC is un-disabled after a network change. 3183 // Verify that QUIC is un-disabled after a network change.
3184 factory_->OnIPAddressChanged(); 3184 factory_->OnIPAddressChanged();
3185 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), 3185 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
3186 host_port_pair_.port())); 3186 host_port_pair_.port()));
3187 EXPECT_EQ( 3187 EXPECT_EQ(
3188 0, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get())); 3188 0, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
3189 3189
3190 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 3190 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3191 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 3191 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
(...skipping 28 matching lines...) Expand all
3220 3220
3221 // Test first timeouts with open streams will disable QUIC. 3221 // Test first timeouts with open streams will disable QUIC.
3222 QuicStreamRequest request(factory_.get()); 3222 QuicStreamRequest request(factory_.get());
3223 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 3223 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
3224 /*cert_verify_flags=*/0, url_, "GET", net_log_, 3224 /*cert_verify_flags=*/0, url_, "GET", net_log_,
3225 callback_.callback())); 3225 callback_.callback()));
3226 3226
3227 QuicChromiumClientSession* session = 3227 QuicChromiumClientSession* session =
3228 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 3228 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
3229 3229
3230 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3230 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3231 EXPECT_TRUE(stream.get()); 3231 EXPECT_TRUE(stream.get());
3232 HttpRequestInfo request_info; 3232 HttpRequestInfo request_info;
3233 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 3233 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
3234 net_log_, CompletionCallback())); 3234 net_log_, CompletionCallback()));
3235 3235
3236 DVLOG(1) 3236 DVLOG(1)
3237 << "Created 1st session and initialized a stream. Now trigger timeout." 3237 << "Created 1st session and initialized a stream. Now trigger timeout."
3238 << "Will disable QUIC."; 3238 << "Will disable QUIC.";
3239 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, 3239 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
3240 ConnectionCloseSource::FROM_SELF); 3240 ConnectionCloseSource::FROM_SELF);
(...skipping 141 matching lines...) Expand 10 before | Expand all | Expand 10 after
3382 ConnectionCloseSource::FROM_PEER); 3382 ConnectionCloseSource::FROM_PEER);
3383 // Need to spin the loop now to ensure that 3383 // Need to spin the loop now to ensure that
3384 // QuicStreamFactory::OnSessionClosed() runs. 3384 // QuicStreamFactory::OnSessionClosed() runs.
3385 base::RunLoop run_loop4; 3385 base::RunLoop run_loop4;
3386 run_loop4.RunUntilIdle(); 3386 run_loop4.RunUntilIdle();
3387 EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake( 3387 EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(
3388 factory_.get())); 3388 factory_.get()));
3389 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), 3389 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
3390 host_port_pair_.port())); 3390 host_port_pair_.port()));
3391 3391
3392 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3392 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3393 EXPECT_TRUE(stream.get()); 3393 EXPECT_FALSE(stream.get()); // Session is already closed.
3394 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 3394 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
3395 EXPECT_TRUE(stream2.get()); 3395 EXPECT_FALSE(stream2.get()); // Session is already closed.
3396 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 3396 scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
3397 EXPECT_TRUE(stream3.get()); 3397 EXPECT_FALSE(stream3.get()); // Session is already closed.
3398 scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream(); 3398 scoped_ptr<QuicHttpStream> stream4 = request4.CreateStream();
3399 EXPECT_TRUE(stream4.get()); 3399 EXPECT_FALSE(stream4.get()); // Session is already closed.
3400 3400
3401 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 3401 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3402 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 3402 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3403 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 3403 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
3404 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 3404 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
3405 EXPECT_TRUE(socket_data3.AllReadDataConsumed()); 3405 EXPECT_TRUE(socket_data3.AllReadDataConsumed());
3406 EXPECT_TRUE(socket_data3.AllWriteDataConsumed()); 3406 EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
3407 EXPECT_TRUE(socket_data4.AllReadDataConsumed()); 3407 EXPECT_TRUE(socket_data4.AllReadDataConsumed());
3408 EXPECT_TRUE(socket_data4.AllWriteDataConsumed()); 3408 EXPECT_TRUE(socket_data4.AllWriteDataConsumed());
3409 } 3409 }
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
3453 3453
3454 // Test first and fourth out of three timeouts with open streams. 3454 // Test first and fourth out of three timeouts with open streams.
3455 QuicStreamRequest request(factory_.get()); 3455 QuicStreamRequest request(factory_.get());
3456 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_, 3456 EXPECT_EQ(OK, request.Request(host_port_pair_, privacy_mode_,
3457 /*cert_verify_flags=*/0, url_, "GET", net_log_, 3457 /*cert_verify_flags=*/0, url_, "GET", net_log_,
3458 callback_.callback())); 3458 callback_.callback()));
3459 3459
3460 QuicChromiumClientSession* session = 3460 QuicChromiumClientSession* session =
3461 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 3461 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
3462 3462
3463 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3463 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3464 EXPECT_TRUE(stream.get()); 3464 EXPECT_TRUE(stream.get());
3465 HttpRequestInfo request_info; 3465 HttpRequestInfo request_info;
3466 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY, 3466 EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
3467 net_log_, CompletionCallback())); 3467 net_log_, CompletionCallback()));
3468 3468
3469 DVLOG(1) 3469 DVLOG(1)
3470 << "Created 1st session and initialized a stream. Now trigger timeout"; 3470 << "Created 1st session and initialized a stream. Now trigger timeout";
3471 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, 3471 session->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
3472 ConnectionCloseSource::FROM_SELF); 3472 ConnectionCloseSource::FROM_SELF);
3473 // Need to spin the loop now to ensure that 3473 // Need to spin the loop now to ensure that
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
3523 << " will not disable QUIC"; 3523 << " will not disable QUIC";
3524 3524
3525 TestCompletionCallback callback4; 3525 TestCompletionCallback callback4;
3526 QuicStreamRequest request4(factory_.get()); 3526 QuicStreamRequest request4(factory_.get());
3527 EXPECT_EQ(OK, request4.Request(server4, privacy_mode_, 3527 EXPECT_EQ(OK, request4.Request(server4, privacy_mode_,
3528 /*cert_verify_flags=*/0, url4_, "GET", 3528 /*cert_verify_flags=*/0, url4_, "GET",
3529 net_log_, callback4.callback())); 3529 net_log_, callback4.callback()));
3530 QuicChromiumClientSession* session4 = 3530 QuicChromiumClientSession* session4 =
3531 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server4); 3531 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), server4);
3532 3532
3533 scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream(); 3533 scoped_ptr<QuicHttpStream> stream4 = request4.CreateStream();
3534 EXPECT_TRUE(stream4.get()); 3534 EXPECT_TRUE(stream4.get());
3535 EXPECT_EQ(OK, stream4->InitializeStream(&request_info, DEFAULT_PRIORITY, 3535 EXPECT_EQ(OK, stream4->InitializeStream(&request_info, DEFAULT_PRIORITY,
3536 net_log_, CompletionCallback())); 3536 net_log_, CompletionCallback()));
3537 session4->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT, 3537 session4->connection()->CloseConnection(QUIC_NETWORK_IDLE_TIMEOUT,
3538 ConnectionCloseSource::FROM_SELF); 3538 ConnectionCloseSource::FROM_SELF);
3539 // Need to spin the loop now to ensure that 3539 // Need to spin the loop now to ensure that
3540 // QuicStreamFactory::OnSessionClosed() runs. 3540 // QuicStreamFactory::OnSessionClosed() runs.
3541 base::RunLoop run_loop4; 3541 base::RunLoop run_loop4;
3542 run_loop4.RunUntilIdle(); 3542 run_loop4.RunUntilIdle();
3543 EXPECT_EQ( 3543 EXPECT_EQ(
3544 1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get())); 3544 1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(factory_.get()));
3545 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(), 3545 EXPECT_FALSE(QuicStreamFactoryPeer::IsQuicDisabled(factory_.get(),
3546 host_port_pair_.port())); 3546 host_port_pair_.port()));
3547 3547
3548 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 3548 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
3549 EXPECT_TRUE(stream2.get()); 3549 EXPECT_FALSE(stream2.get()); // Session is already closed.
3550 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 3550 scoped_ptr<QuicHttpStream> stream3 = request3.CreateStream();
3551 EXPECT_TRUE(stream3.get()); 3551 EXPECT_FALSE(stream3.get()); // Session is already closed.
3552 3552
3553 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 3553 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3554 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 3554 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3555 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 3555 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
3556 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 3556 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
3557 EXPECT_TRUE(socket_data3.AllReadDataConsumed()); 3557 EXPECT_TRUE(socket_data3.AllReadDataConsumed());
3558 EXPECT_TRUE(socket_data3.AllWriteDataConsumed()); 3558 EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
3559 EXPECT_TRUE(socket_data4.AllReadDataConsumed()); 3559 EXPECT_TRUE(socket_data4.AllReadDataConsumed());
3560 EXPECT_TRUE(socket_data4.AllWriteDataConsumed()); 3560 EXPECT_TRUE(socket_data4.AllWriteDataConsumed());
3561 } 3561 }
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after
3596 EXPECT_TRUE(factory_->delay_tcp_race()); 3596 EXPECT_TRUE(factory_->delay_tcp_race());
3597 EXPECT_EQ(base::TimeDelta::FromMicroseconds(15), 3597 EXPECT_EQ(base::TimeDelta::FromMicroseconds(15),
3598 request.GetTimeDelayForWaitingJob()); 3598 request.GetTimeDelayForWaitingJob());
3599 3599
3600 // Confirm the handshake and verify that the stream is created. 3600 // Confirm the handshake and verify that the stream is created.
3601 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( 3601 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
3602 QuicSession::HANDSHAKE_CONFIRMED); 3602 QuicSession::HANDSHAKE_CONFIRMED);
3603 3603
3604 EXPECT_EQ(OK, callback_.WaitForResult()); 3604 EXPECT_EQ(OK, callback_.WaitForResult());
3605 3605
3606 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3606 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3607 EXPECT_TRUE(stream.get()); 3607 EXPECT_TRUE(stream.get());
3608 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 3608 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3609 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 3609 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3610 QuicStreamFactoryPeer::SetDelayTcpRace(factory_.get(), delay_tcp_race); 3610 QuicStreamFactoryPeer::SetDelayTcpRace(factory_.get(), delay_tcp_race);
3611 } 3611 }
3612 3612
3613 TEST_P(QuicStreamFactoryTest, MaybeInitialize) { 3613 TEST_P(QuicStreamFactoryTest, MaybeInitialize) {
3614 idle_connection_timeout_seconds_ = 500; 3614 idle_connection_timeout_seconds_ = 500;
3615 Initialize(); 3615 Initialize();
3616 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 3616 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after
3741 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets 3741 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
3742 // called. 3742 // called.
3743 base::RunLoop run_loop; 3743 base::RunLoop run_loop;
3744 run_loop.RunUntilIdle(); 3744 run_loop.RunUntilIdle();
3745 3745
3746 // Verify task that the observer's executed_count is 1, which indicates 3746 // Verify task that the observer's executed_count is 1, which indicates
3747 // QuicChromiumPacketReader::StartReading() has posted only one task and 3747 // QuicChromiumPacketReader::StartReading() has posted only one task and
3748 // yielded the read. 3748 // yielded the read.
3749 EXPECT_EQ(1u, observer.executed_count()); 3749 EXPECT_EQ(1u, observer.executed_count());
3750 3750
3751 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3751 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3752 EXPECT_TRUE(stream.get()); 3752 EXPECT_FALSE(stream.get()); // Session is already closed.
3753 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 3753 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3754 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 3754 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3755 } 3755 }
3756 3756
3757 TEST_P(QuicStreamFactoryTest, YieldAfterDuration) { 3757 TEST_P(QuicStreamFactoryTest, YieldAfterDuration) {
3758 Initialize(); 3758 Initialize();
3759 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 3759 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3760 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 3760 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3761 QuicStreamFactoryPeer::SetYieldAfterDuration( 3761 QuicStreamFactoryPeer::SetYieldAfterDuration(
3762 factory_.get(), QuicTime::Delta::FromMilliseconds(-1)); 3762 factory_.get(), QuicTime::Delta::FromMilliseconds(-1));
(...skipping 27 matching lines...) Expand all
3790 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets 3790 // Call run_loop so that QuicChromiumPacketReader::OnReadComplete() gets
3791 // called. 3791 // called.
3792 base::RunLoop run_loop; 3792 base::RunLoop run_loop;
3793 run_loop.RunUntilIdle(); 3793 run_loop.RunUntilIdle();
3794 3794
3795 // Verify task that the observer's executed_count is 1, which indicates 3795 // Verify task that the observer's executed_count is 1, which indicates
3796 // QuicChromiumPacketReader::StartReading() has posted only one task and 3796 // QuicChromiumPacketReader::StartReading() has posted only one task and
3797 // yielded the read. 3797 // yielded the read.
3798 EXPECT_EQ(1u, observer.executed_count()); 3798 EXPECT_EQ(1u, observer.executed_count());
3799 3799
3800 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3800 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3801 EXPECT_TRUE(stream.get()); 3801 EXPECT_FALSE(stream.get()); // Session is already closed.
3802 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 3802 EXPECT_TRUE(socket_data.AllReadDataConsumed());
3803 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 3803 EXPECT_TRUE(socket_data.AllWriteDataConsumed());
3804 } 3804 }
3805 3805
3806 TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) { 3806 TEST_P(QuicStreamFactoryTest, ServerPushSessionAffinity) {
3807 Initialize(); 3807 Initialize();
3808 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails(); 3808 ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
3809 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details); 3809 crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
3810 3810
3811 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)}; 3811 MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
3812 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0); 3812 SequencedSocketData socket_data(reads, arraysize(reads), nullptr, 0);
3813 socket_factory_.AddSocketDataProvider(&socket_data); 3813 socket_factory_.AddSocketDataProvider(&socket_data);
3814 3814
3815 QuicStreamRequest request(factory_.get()); 3815 QuicStreamRequest request(factory_.get());
3816 EXPECT_EQ(ERR_IO_PENDING, 3816 EXPECT_EQ(ERR_IO_PENDING,
3817 request.Request(host_port_pair_, privacy_mode_, 3817 request.Request(host_port_pair_, privacy_mode_,
3818 /*cert_verify_flags=*/0, url_, "GET", net_log_, 3818 /*cert_verify_flags=*/0, url_, "GET", net_log_,
3819 callback_.callback())); 3819 callback_.callback()));
3820 3820
3821 EXPECT_EQ(OK, callback_.WaitForResult()); 3821 EXPECT_EQ(OK, callback_.WaitForResult());
3822 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3822 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3823 EXPECT_TRUE(stream.get()); 3823 EXPECT_TRUE(stream.get());
3824 3824
3825 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); 3825 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
3826 3826
3827 std::string url = "https://www.example.org/"; 3827 std::string url = "https://www.example.org/";
3828 3828
3829 QuicChromiumClientSession* session = 3829 QuicChromiumClientSession* session =
3830 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 3830 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
3831 3831
3832 QuicClientPromisedInfo promised(session, kServerDataStreamId1, url); 3832 QuicClientPromisedInfo promised(session, kServerDataStreamId1, url);
(...skipping 29 matching lines...) Expand all
3862 socket_factory_.AddSocketDataProvider(&socket_data1); 3862 socket_factory_.AddSocketDataProvider(&socket_data1);
3863 socket_factory_.AddSocketDataProvider(&socket_data2); 3863 socket_factory_.AddSocketDataProvider(&socket_data2);
3864 3864
3865 QuicStreamRequest request(factory_.get()); 3865 QuicStreamRequest request(factory_.get());
3866 EXPECT_EQ(ERR_IO_PENDING, 3866 EXPECT_EQ(ERR_IO_PENDING,
3867 request.Request(host_port_pair_, privacy_mode_, 3867 request.Request(host_port_pair_, privacy_mode_,
3868 /*cert_verify_flags=*/0, url_, "GET", net_log_, 3868 /*cert_verify_flags=*/0, url_, "GET", net_log_,
3869 callback_.callback())); 3869 callback_.callback()));
3870 3870
3871 EXPECT_EQ(OK, callback_.WaitForResult()); 3871 EXPECT_EQ(OK, callback_.WaitForResult());
3872 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 3872 scoped_ptr<QuicHttpStream> stream = request.CreateStream();
3873 EXPECT_TRUE(stream.get()); 3873 EXPECT_TRUE(stream.get());
3874 3874
3875 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); 3875 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
3876 3876
3877 std::string url = "https://www.example.org/"; 3877 std::string url = "https://www.example.org/";
3878 QuicChromiumClientSession* session = 3878 QuicChromiumClientSession* session =
3879 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_); 3879 QuicStreamFactoryPeer::GetActiveSession(factory_.get(), host_port_pair_);
3880 3880
3881 QuicClientPromisedInfo promised(session, kServerDataStreamId1, url); 3881 QuicClientPromisedInfo promised(session, kServerDataStreamId1, url);
3882 3882
3883 QuicClientPushPromiseIndex* index = 3883 QuicClientPushPromiseIndex* index =
3884 QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get()); 3884 QuicStreamFactoryPeer::GetPushPromiseIndex(factory_.get());
3885 3885
3886 (*index->promised_by_url())[url] = &promised; 3886 (*index->promised_by_url())[url] = &promised;
3887 EXPECT_EQ(index->GetPromised(url), &promised); 3887 EXPECT_EQ(index->GetPromised(url), &promised);
3888 3888
3889 // Doing the request should not use the push stream, but rather 3889 // Doing the request should not use the push stream, but rather
3890 // cancel it because the privacy modes do not match. 3890 // cancel it because the privacy modes do not match.
3891 QuicStreamRequest request2(factory_.get()); 3891 QuicStreamRequest request2(factory_.get());
3892 EXPECT_EQ(ERR_IO_PENDING, 3892 EXPECT_EQ(ERR_IO_PENDING,
3893 request2.Request(host_port_pair_, PRIVACY_MODE_ENABLED, 3893 request2.Request(host_port_pair_, PRIVACY_MODE_ENABLED,
3894 /*cert_verify_flags=*/0, GURL(url), "GET", 3894 /*cert_verify_flags=*/0, GURL(url), "GET",
3895 net_log_, callback_.callback())); 3895 net_log_, callback_.callback()));
3896 3896
3897 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get())); 3897 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumPushStreamsCreated(factory_.get()));
3898 EXPECT_EQ(index->GetPromised(url), nullptr); 3898 EXPECT_EQ(index->GetPromised(url), nullptr);
3899 3899
3900 EXPECT_EQ(OK, callback_.WaitForResult()); 3900 EXPECT_EQ(OK, callback_.WaitForResult());
3901 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 3901 scoped_ptr<QuicHttpStream> stream2 = request2.CreateStream();
3902 EXPECT_TRUE(stream2.get()); 3902 EXPECT_TRUE(stream2.get());
3903 3903
3904 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 3904 EXPECT_TRUE(socket_data1.AllReadDataConsumed());
3905 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 3905 EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
3906 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 3906 EXPECT_TRUE(socket_data2.AllReadDataConsumed());
3907 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 3907 EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
3908 } 3908 }
3909 3909
3910 } // namespace test 3910 } // namespace test
3911 } // namespace net 3911 } // namespace net
OLDNEW
« no previous file with comments | « net/quic/quic_stream_factory.cc ('k') | net/quic/test_tools/quic_test_packet_maker.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698