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

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

Issue 1114353005: Revert of Add AllReadDataConsumed and AllWriteDataConsumed methods to SocketDataProvider (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 7 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
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 "net/base/test_data_directory.h" 9 #include "net/base/test_data_directory.h"
10 #include "net/cert/cert_verifier.h" 10 #include "net/cert/cert_verifier.h"
(...skipping 278 matching lines...) Expand 10 before | Expand all | Expand 10 after
289 socket_factory_. 289 socket_factory_.
290 udp_client_sockets()[socket_count]->GetLocalAddress(&endpoint); 290 udp_client_sockets()[socket_count]->GetLocalAddress(&endpoint);
291 int port = endpoint.port(); 291 int port = endpoint.port();
292 if (goaway_received) { 292 if (goaway_received) {
293 QuicGoAwayFrame goaway(QUIC_NO_ERROR, 1, ""); 293 QuicGoAwayFrame goaway(QUIC_NO_ERROR, 1, "");
294 session->OnGoAway(goaway); 294 session->OnGoAway(goaway);
295 } 295 }
296 296
297 factory_.OnSessionClosed(session); 297 factory_.OnSessionClosed(session);
298 EXPECT_EQ(nullptr, CreateIfSessionExists(destination, net_log_).get()); 298 EXPECT_EQ(nullptr, CreateIfSessionExists(destination, net_log_).get());
299 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 299 EXPECT_TRUE(socket_data.at_read_eof());
300 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 300 EXPECT_TRUE(socket_data.at_write_eof());
301 return port; 301 return port;
302 } 302 }
303 303
304 scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() { 304 scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
305 QuicStreamId stream_id = kClientDataStreamId1; 305 QuicStreamId stream_id = kClientDataStreamId1;
306 return maker_.MakeRstPacket( 306 return maker_.MakeRstPacket(
307 1, true, stream_id, 307 1, true, stream_id,
308 AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam().version)); 308 AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam().version));
309 } 309 }
310 310
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
366 EXPECT_EQ(OK, 366 EXPECT_EQ(OK,
367 request2.Request(host_port_pair_, 367 request2.Request(host_port_pair_,
368 is_https_, 368 is_https_,
369 privacy_mode_, 369 privacy_mode_,
370 "GET", 370 "GET",
371 net_log_, 371 net_log_,
372 callback_.callback())); 372 callback_.callback()));
373 stream = request2.ReleaseStream(); // Will reset stream 5. 373 stream = request2.ReleaseStream(); // Will reset stream 5.
374 stream.reset(); // Will reset stream 7. 374 stream.reset(); // Will reset stream 7.
375 375
376 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 376 EXPECT_TRUE(socket_data.at_read_eof());
377 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 377 EXPECT_TRUE(socket_data.at_write_eof());
378 } 378 }
379 379
380 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) { 380 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
381 MockRead reads[] = { 381 MockRead reads[] = {
382 MockRead(ASYNC, OK, 0) // EOF 382 MockRead(ASYNC, OK, 0) // EOF
383 }; 383 };
384 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0); 384 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
385 socket_factory_.AddSocketDataProvider(&socket_data); 385 socket_factory_.AddSocketDataProvider(&socket_data);
386 socket_data.StopAfter(1); 386 socket_data.StopAfter(1);
387 387
388 crypto_client_stream_factory_.set_handshake_mode( 388 crypto_client_stream_factory_.set_handshake_mode(
389 MockCryptoClientStream::ZERO_RTT); 389 MockCryptoClientStream::ZERO_RTT);
390 host_resolver_.set_synchronous_mode(true); 390 host_resolver_.set_synchronous_mode(true);
391 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(), 391 host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
392 "192.168.0.1", ""); 392 "192.168.0.1", "");
393 393
394 QuicStreamRequest request(&factory_); 394 QuicStreamRequest request(&factory_);
395 EXPECT_EQ(OK, 395 EXPECT_EQ(OK,
396 request.Request(host_port_pair_, 396 request.Request(host_port_pair_,
397 is_https_, 397 is_https_,
398 privacy_mode_, 398 privacy_mode_,
399 "GET", 399 "GET",
400 net_log_, 400 net_log_,
401 callback_.callback())); 401 callback_.callback()));
402 402
403 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 403 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
404 EXPECT_TRUE(stream.get()); 404 EXPECT_TRUE(stream.get());
405 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 405 EXPECT_TRUE(socket_data.at_read_eof());
406 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 406 EXPECT_TRUE(socket_data.at_write_eof());
407 } 407 }
408 408
409 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) { 409 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
410 MockRead reads[] = { 410 MockRead reads[] = {
411 MockRead(ASYNC, OK, 0) // EOF 411 MockRead(ASYNC, OK, 0) // EOF
412 }; 412 };
413 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0); 413 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
414 socket_factory_.AddSocketDataProvider(&socket_data); 414 socket_factory_.AddSocketDataProvider(&socket_data);
415 socket_data.StopAfter(1); 415 socket_data.StopAfter(1);
416 416
(...skipping 13 matching lines...) Expand all
430 net_log_, 430 net_log_,
431 callback_.callback())); 431 callback_.callback()));
432 432
433 // Confirm the handshake and verify that the stream is created. 433 // Confirm the handshake and verify that the stream is created.
434 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent( 434 crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
435 QuicSession::HANDSHAKE_CONFIRMED); 435 QuicSession::HANDSHAKE_CONFIRMED);
436 436
437 EXPECT_EQ(OK, callback_.WaitForResult()); 437 EXPECT_EQ(OK, callback_.WaitForResult());
438 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 438 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
439 EXPECT_TRUE(stream.get()); 439 EXPECT_TRUE(stream.get());
440 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 440 EXPECT_TRUE(socket_data.at_read_eof());
441 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 441 EXPECT_TRUE(socket_data.at_write_eof());
442 } 442 }
443 443
444 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) { 444 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
445 MockRead reads[] = { 445 MockRead reads[] = {
446 MockRead(ASYNC, OK, 0) // EOF 446 MockRead(ASYNC, OK, 0) // EOF
447 }; 447 };
448 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0); 448 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
449 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 449 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
450 socket_factory_.AddSocketDataProvider(&socket_data1); 450 socket_factory_.AddSocketDataProvider(&socket_data1);
451 socket_factory_.AddSocketDataProvider(&socket_data2); 451 socket_factory_.AddSocketDataProvider(&socket_data2);
(...skipping 24 matching lines...) Expand all
476 EXPECT_EQ(OK, callback_.WaitForResult()); 476 EXPECT_EQ(OK, callback_.WaitForResult());
477 stream = request2.ReleaseStream(); 477 stream = request2.ReleaseStream();
478 EXPECT_TRUE(stream.get()); 478 EXPECT_TRUE(stream.get());
479 stream.reset(); 479 stream.reset();
480 480
481 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession( 481 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
482 &factory_, host_port_pair_, is_https_), 482 &factory_, host_port_pair_, is_https_),
483 QuicStreamFactoryPeer::GetActiveSession( 483 QuicStreamFactoryPeer::GetActiveSession(
484 &factory_, host_port_pair_, !is_https_)); 484 &factory_, host_port_pair_, !is_https_));
485 485
486 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 486 EXPECT_TRUE(socket_data1.at_read_eof());
487 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 487 EXPECT_TRUE(socket_data1.at_write_eof());
488 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 488 EXPECT_TRUE(socket_data2.at_read_eof());
489 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 489 EXPECT_TRUE(socket_data2.at_write_eof());
490 } 490 }
491 491
492 TEST_P(QuicStreamFactoryTest, Pooling) { 492 TEST_P(QuicStreamFactoryTest, Pooling) {
493 MockRead reads[] = { 493 MockRead reads[] = {
494 MockRead(ASYNC, OK, 0) // EOF 494 MockRead(ASYNC, OK, 0) // EOF
495 }; 495 };
496 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0); 496 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
497 socket_factory_.AddSocketDataProvider(&socket_data); 497 socket_factory_.AddSocketDataProvider(&socket_data);
498 socket_data.StopAfter(1); 498 socket_data.StopAfter(1);
499 499
(...skipping 25 matching lines...) Expand all
525 net_log_, 525 net_log_,
526 callback.callback())); 526 callback.callback()));
527 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 527 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
528 EXPECT_TRUE(stream2.get()); 528 EXPECT_TRUE(stream2.get());
529 529
530 EXPECT_EQ( 530 EXPECT_EQ(
531 QuicStreamFactoryPeer::GetActiveSession( 531 QuicStreamFactoryPeer::GetActiveSession(
532 &factory_, host_port_pair_, is_https_), 532 &factory_, host_port_pair_, is_https_),
533 QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_)); 533 QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
534 534
535 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 535 EXPECT_TRUE(socket_data.at_read_eof());
536 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 536 EXPECT_TRUE(socket_data.at_write_eof());
537 } 537 }
538 538
539 TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) { 539 TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
540 MockRead reads[] = { 540 MockRead reads[] = {
541 MockRead(ASYNC, OK, 0) // EOF 541 MockRead(ASYNC, OK, 0) // EOF
542 }; 542 };
543 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0); 543 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
544 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 544 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
545 socket_factory_.AddSocketDataProvider(&socket_data1); 545 socket_factory_.AddSocketDataProvider(&socket_data1);
546 socket_factory_.AddSocketDataProvider(&socket_data2); 546 socket_factory_.AddSocketDataProvider(&socket_data2);
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
578 net_log_, 578 net_log_,
579 callback.callback())); 579 callback.callback()));
580 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 580 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
581 EXPECT_TRUE(stream2.get()); 581 EXPECT_TRUE(stream2.get());
582 582
583 EXPECT_NE( 583 EXPECT_NE(
584 QuicStreamFactoryPeer::GetActiveSession( 584 QuicStreamFactoryPeer::GetActiveSession(
585 &factory_, host_port_pair_, is_https_), 585 &factory_, host_port_pair_, is_https_),
586 QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_)); 586 QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
587 587
588 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 588 EXPECT_TRUE(socket_data1.at_read_eof());
589 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 589 EXPECT_TRUE(socket_data1.at_write_eof());
590 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 590 EXPECT_TRUE(socket_data2.at_read_eof());
591 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 591 EXPECT_TRUE(socket_data2.at_write_eof());
592 } 592 }
593 593
594 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) { 594 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
595 MockRead reads[] = { 595 MockRead reads[] = {
596 MockRead(ASYNC, OK, 0) // EOF 596 MockRead(ASYNC, OK, 0) // EOF
597 }; 597 };
598 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0); 598 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
599 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 599 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
600 socket_factory_.AddSocketDataProvider(&socket_data1); 600 socket_factory_.AddSocketDataProvider(&socket_data1);
601 socket_factory_.AddSocketDataProvider(&socket_data2); 601 socket_factory_.AddSocketDataProvider(&socket_data2);
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
647 privacy_mode_, 647 privacy_mode_,
648 "GET", 648 "GET",
649 net_log_, 649 net_log_,
650 callback3.callback())); 650 callback3.callback()));
651 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 651 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
652 EXPECT_TRUE(stream3.get()); 652 EXPECT_TRUE(stream3.get());
653 653
654 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession( 654 EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
655 &factory_, server2, is_https_)); 655 &factory_, server2, is_https_));
656 656
657 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 657 EXPECT_TRUE(socket_data1.at_read_eof());
658 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 658 EXPECT_TRUE(socket_data1.at_write_eof());
659 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 659 EXPECT_TRUE(socket_data2.at_read_eof());
660 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 660 EXPECT_TRUE(socket_data2.at_write_eof());
661 } 661 }
662 662
663 TEST_P(QuicStreamFactoryTest, HttpsPooling) { 663 TEST_P(QuicStreamFactoryTest, HttpsPooling) {
664 MockRead reads[] = { 664 MockRead reads[] = {
665 MockRead(ASYNC, OK, 0) // EOF 665 MockRead(ASYNC, OK, 0) // EOF
666 }; 666 };
667 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0); 667 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
668 socket_factory_.AddSocketDataProvider(&socket_data); 668 socket_factory_.AddSocketDataProvider(&socket_data);
669 socket_data.StopAfter(1); 669 socket_data.StopAfter(1);
670 670
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
710 net_log_, 710 net_log_,
711 callback_.callback())); 711 callback_.callback()));
712 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 712 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
713 EXPECT_TRUE(stream2.get()); 713 EXPECT_TRUE(stream2.get());
714 714
715 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession( 715 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
716 &factory_, server1, is_https_), 716 &factory_, server1, is_https_),
717 QuicStreamFactoryPeer::GetActiveSession( 717 QuicStreamFactoryPeer::GetActiveSession(
718 &factory_, server2, is_https_)); 718 &factory_, server2, is_https_));
719 719
720 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 720 EXPECT_TRUE(socket_data.at_read_eof());
721 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 721 EXPECT_TRUE(socket_data.at_write_eof());
722 } 722 }
723 723
724 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) { 724 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
725 MockRead reads[] = { 725 MockRead reads[] = {
726 MockRead(ASYNC, OK, 0) // EOF 726 MockRead(ASYNC, OK, 0) // EOF
727 }; 727 };
728 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0); 728 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
729 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 729 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
730 socket_factory_.AddSocketDataProvider(&socket_data1); 730 socket_factory_.AddSocketDataProvider(&socket_data1);
731 socket_factory_.AddSocketDataProvider(&socket_data2); 731 socket_factory_.AddSocketDataProvider(&socket_data2);
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
777 net_log_, 777 net_log_,
778 callback_.callback())); 778 callback_.callback()));
779 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 779 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
780 EXPECT_TRUE(stream2.get()); 780 EXPECT_TRUE(stream2.get());
781 781
782 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession( 782 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
783 &factory_, server1, is_https_), 783 &factory_, server1, is_https_),
784 QuicStreamFactoryPeer::GetActiveSession( 784 QuicStreamFactoryPeer::GetActiveSession(
785 &factory_, server2, is_https_)); 785 &factory_, server2, is_https_));
786 786
787 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 787 EXPECT_TRUE(socket_data1.at_read_eof());
788 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 788 EXPECT_TRUE(socket_data1.at_write_eof());
789 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 789 EXPECT_TRUE(socket_data2.at_read_eof());
790 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 790 EXPECT_TRUE(socket_data2.at_write_eof());
791 } 791 }
792 792
793 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) { 793 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) {
794 MockRead reads[] = { 794 MockRead reads[] = {
795 MockRead(ASYNC, OK, 0) // EOF 795 MockRead(ASYNC, OK, 0) // EOF
796 }; 796 };
797 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0); 797 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
798 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 798 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
799 socket_factory_.AddSocketDataProvider(&socket_data1); 799 socket_factory_.AddSocketDataProvider(&socket_data1);
800 socket_factory_.AddSocketDataProvider(&socket_data2); 800 socket_factory_.AddSocketDataProvider(&socket_data2);
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
844 net_log_, 844 net_log_,
845 callback_.callback())); 845 callback_.callback()));
846 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 846 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
847 EXPECT_TRUE(stream2.get()); 847 EXPECT_TRUE(stream2.get());
848 848
849 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession( 849 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
850 &factory_, server1, is_https_), 850 &factory_, server1, is_https_),
851 QuicStreamFactoryPeer::GetActiveSession( 851 QuicStreamFactoryPeer::GetActiveSession(
852 &factory_, server2, is_https_)); 852 &factory_, server2, is_https_));
853 853
854 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 854 EXPECT_TRUE(socket_data1.at_read_eof());
855 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 855 EXPECT_TRUE(socket_data1.at_write_eof());
856 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 856 EXPECT_TRUE(socket_data2.at_read_eof());
857 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 857 EXPECT_TRUE(socket_data2.at_write_eof());
858 } 858 }
859 859
860 TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) { 860 TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
861 MockRead reads[] = { 861 MockRead reads[] = {
862 MockRead(ASYNC, OK, 0) // EOF 862 MockRead(ASYNC, OK, 0) // EOF
863 }; 863 };
864 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0); 864 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
865 socket_factory_.AddSocketDataProvider(&socket_data); 865 socket_factory_.AddSocketDataProvider(&socket_data);
866 socket_data.StopAfter(1); 866 socket_data.StopAfter(1);
867 867
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
913 net_log_, 913 net_log_,
914 callback_.callback())); 914 callback_.callback()));
915 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 915 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
916 EXPECT_TRUE(stream2.get()); 916 EXPECT_TRUE(stream2.get());
917 917
918 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession( 918 EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
919 &factory_, server1, is_https_), 919 &factory_, server1, is_https_),
920 QuicStreamFactoryPeer::GetActiveSession( 920 QuicStreamFactoryPeer::GetActiveSession(
921 &factory_, server2, is_https_)); 921 &factory_, server2, is_https_));
922 922
923 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 923 EXPECT_TRUE(socket_data.at_read_eof());
924 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 924 EXPECT_TRUE(socket_data.at_write_eof());
925 } 925 }
926 926
927 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) { 927 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
928 MockRead reads[] = { 928 MockRead reads[] = {
929 MockRead(ASYNC, OK, 0) // EOF 929 MockRead(ASYNC, OK, 0) // EOF
930 }; 930 };
931 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0); 931 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
932 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 932 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
933 socket_factory_.AddSocketDataProvider(&socket_data1); 933 socket_factory_.AddSocketDataProvider(&socket_data1);
934 socket_factory_.AddSocketDataProvider(&socket_data2); 934 socket_factory_.AddSocketDataProvider(&socket_data2);
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after
986 net_log_, 986 net_log_,
987 callback_.callback())); 987 callback_.callback()));
988 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 988 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
989 EXPECT_TRUE(stream2.get()); 989 EXPECT_TRUE(stream2.get());
990 990
991 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession( 991 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
992 &factory_, server1, is_https_), 992 &factory_, server1, is_https_),
993 QuicStreamFactoryPeer::GetActiveSession( 993 QuicStreamFactoryPeer::GetActiveSession(
994 &factory_, server2, is_https_)); 994 &factory_, server2, is_https_));
995 995
996 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 996 EXPECT_TRUE(socket_data1.at_read_eof());
997 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 997 EXPECT_TRUE(socket_data1.at_write_eof());
998 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 998 EXPECT_TRUE(socket_data2.at_read_eof());
999 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 999 EXPECT_TRUE(socket_data2.at_write_eof());
1000 } 1000 }
1001 1001
1002 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) { 1002 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
1003 MockRead reads[] = { 1003 MockRead reads[] = {
1004 MockRead(ASYNC, OK, 0) // EOF 1004 MockRead(ASYNC, OK, 0) // EOF
1005 }; 1005 };
1006 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0); 1006 DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
1007 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 1007 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
1008 socket_factory_.AddSocketDataProvider(&socket_data1); 1008 socket_factory_.AddSocketDataProvider(&socket_data1);
1009 socket_factory_.AddSocketDataProvider(&socket_data2); 1009 socket_factory_.AddSocketDataProvider(&socket_data2);
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after
1059 net_log_, 1059 net_log_,
1060 callback_.callback())); 1060 callback_.callback()));
1061 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 1061 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1062 EXPECT_TRUE(stream2.get()); 1062 EXPECT_TRUE(stream2.get());
1063 1063
1064 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession( 1064 EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
1065 &factory_, server1, is_https_), 1065 &factory_, server1, is_https_),
1066 QuicStreamFactoryPeer::GetActiveSession( 1066 QuicStreamFactoryPeer::GetActiveSession(
1067 &factory_, server2, is_https_)); 1067 &factory_, server2, is_https_));
1068 1068
1069 EXPECT_TRUE(socket_data1.AllReadDataConsumed()); 1069 EXPECT_TRUE(socket_data1.at_read_eof());
1070 EXPECT_TRUE(socket_data1.AllWriteDataConsumed()); 1070 EXPECT_TRUE(socket_data1.at_write_eof());
1071 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1071 EXPECT_TRUE(socket_data2.at_read_eof());
1072 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1072 EXPECT_TRUE(socket_data2.at_write_eof());
1073 } 1073 }
1074 1074
1075 TEST_P(QuicStreamFactoryTest, Goaway) { 1075 TEST_P(QuicStreamFactoryTest, Goaway) {
1076 MockRead reads[] = { 1076 MockRead reads[] = {
1077 MockRead(ASYNC, OK, 0) // EOF 1077 MockRead(ASYNC, OK, 0) // EOF
1078 }; 1078 };
1079 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0); 1079 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1080 socket_data.StopAfter(1); 1080 socket_data.StopAfter(1);
1081 socket_factory_.AddSocketDataProvider(&socket_data); 1081 socket_factory_.AddSocketDataProvider(&socket_data);
1082 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0); 1082 DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
1124 host_port_pair_, 1124 host_port_pair_,
1125 is_https_)); 1125 is_https_));
1126 EXPECT_NE(session, 1126 EXPECT_NE(session,
1127 QuicStreamFactoryPeer::GetActiveSession( 1127 QuicStreamFactoryPeer::GetActiveSession(
1128 &factory_, host_port_pair_, is_https_)); 1128 &factory_, host_port_pair_, is_https_));
1129 EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session)); 1129 EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
1130 1130
1131 stream2.reset(); 1131 stream2.reset();
1132 stream.reset(); 1132 stream.reset();
1133 1133
1134 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1134 EXPECT_TRUE(socket_data.at_read_eof());
1135 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1135 EXPECT_TRUE(socket_data.at_write_eof());
1136 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1136 EXPECT_TRUE(socket_data2.at_read_eof());
1137 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1137 EXPECT_TRUE(socket_data2.at_write_eof());
1138 } 1138 }
1139 1139
1140 TEST_P(QuicStreamFactoryTest, MaxOpenStream) { 1140 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
1141 MockRead reads[] = { 1141 MockRead reads[] = {
1142 MockRead(ASYNC, OK, 0) // EOF 1142 MockRead(ASYNC, OK, 0) // EOF
1143 }; 1143 };
1144 QuicStreamId stream_id = kClientDataStreamId1; 1144 QuicStreamId stream_id = kClientDataStreamId1;
1145 scoped_ptr<QuicEncryptedPacket> rst( 1145 scoped_ptr<QuicEncryptedPacket> rst(
1146 maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED)); 1146 maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED));
1147 MockWrite writes[] = { 1147 MockWrite writes[] = {
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
1190 EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream( 1190 EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream(
1191 &request_info, DEFAULT_PRIORITY, net_log_, callback_.callback())); 1191 &request_info, DEFAULT_PRIORITY, net_log_, callback_.callback()));
1192 1192
1193 // Close the first stream. 1193 // Close the first stream.
1194 streams.front()->Close(false); 1194 streams.front()->Close(false);
1195 1195
1196 ASSERT_TRUE(callback_.have_result()); 1196 ASSERT_TRUE(callback_.have_result());
1197 1197
1198 EXPECT_EQ(OK, callback_.WaitForResult()); 1198 EXPECT_EQ(OK, callback_.WaitForResult());
1199 1199
1200 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1200 EXPECT_TRUE(socket_data.at_read_eof());
1201 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1201 EXPECT_TRUE(socket_data.at_write_eof());
1202 STLDeleteElements(&streams); 1202 STLDeleteElements(&streams);
1203 } 1203 }
1204 1204
1205 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) { 1205 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
1206 DeterministicSocketData socket_data(nullptr, 0, nullptr, 0); 1206 DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
1207 socket_factory_.AddSocketDataProvider(&socket_data); 1207 socket_factory_.AddSocketDataProvider(&socket_data);
1208 1208
1209 host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName); 1209 host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
1210 1210
1211 QuicStreamRequest request(&factory_); 1211 QuicStreamRequest request(&factory_);
1212 EXPECT_EQ(ERR_IO_PENDING, 1212 EXPECT_EQ(ERR_IO_PENDING,
1213 request.Request(host_port_pair_, 1213 request.Request(host_port_pair_,
1214 is_https_, 1214 is_https_,
1215 privacy_mode_, 1215 privacy_mode_,
1216 "GET", 1216 "GET",
1217 net_log_, 1217 net_log_,
1218 callback_.callback())); 1218 callback_.callback()));
1219 1219
1220 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult()); 1220 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
1221 1221
1222 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1222 EXPECT_TRUE(socket_data.at_read_eof());
1223 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1223 EXPECT_TRUE(socket_data.at_write_eof());
1224 } 1224 }
1225 1225
1226 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) { 1226 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
1227 MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE); 1227 MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
1228 DeterministicSocketData socket_data(nullptr, 0, nullptr, 0); 1228 DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
1229 socket_data.set_connect_data(connect); 1229 socket_data.set_connect_data(connect);
1230 socket_factory_.AddSocketDataProvider(&socket_data); 1230 socket_factory_.AddSocketDataProvider(&socket_data);
1231 socket_data.StopAfter(1); 1231 socket_data.StopAfter(1);
1232 1232
1233 QuicStreamRequest request(&factory_); 1233 QuicStreamRequest request(&factory_);
1234 EXPECT_EQ(ERR_IO_PENDING, 1234 EXPECT_EQ(ERR_IO_PENDING,
1235 request.Request(host_port_pair_, 1235 request.Request(host_port_pair_,
1236 is_https_, 1236 is_https_,
1237 privacy_mode_, 1237 privacy_mode_,
1238 "GET", 1238 "GET",
1239 net_log_, 1239 net_log_,
1240 callback_.callback())); 1240 callback_.callback()));
1241 1241
1242 EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult()); 1242 EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult());
1243 1243
1244 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1244 EXPECT_TRUE(socket_data.at_read_eof());
1245 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1245 EXPECT_TRUE(socket_data.at_write_eof());
1246 } 1246 }
1247 1247
1248 TEST_P(QuicStreamFactoryTest, CancelCreate) { 1248 TEST_P(QuicStreamFactoryTest, CancelCreate) {
1249 MockRead reads[] = { 1249 MockRead reads[] = {
1250 MockRead(ASYNC, OK, 0) // EOF 1250 MockRead(ASYNC, OK, 0) // EOF
1251 }; 1251 };
1252 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0); 1252 DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1253 socket_factory_.AddSocketDataProvider(&socket_data); 1253 socket_factory_.AddSocketDataProvider(&socket_data);
1254 { 1254 {
1255 QuicStreamRequest request(&factory_); 1255 QuicStreamRequest request(&factory_);
1256 EXPECT_EQ(ERR_IO_PENDING, 1256 EXPECT_EQ(ERR_IO_PENDING,
1257 request.Request(host_port_pair_, 1257 request.Request(host_port_pair_,
1258 is_https_, 1258 is_https_,
1259 privacy_mode_, 1259 privacy_mode_,
1260 "GET", 1260 "GET",
1261 net_log_, 1261 net_log_,
1262 callback_.callback())); 1262 callback_.callback()));
1263 } 1263 }
1264 1264
1265 socket_data.StopAfter(1); 1265 socket_data.StopAfter(1);
1266 base::RunLoop run_loop; 1266 base::RunLoop run_loop;
1267 run_loop.RunUntilIdle(); 1267 run_loop.RunUntilIdle();
1268 1268
1269 scoped_ptr<QuicHttpStream> stream( 1269 scoped_ptr<QuicHttpStream> stream(
1270 CreateIfSessionExists(host_port_pair_, net_log_)); 1270 CreateIfSessionExists(host_port_pair_, net_log_));
1271 EXPECT_TRUE(stream.get()); 1271 EXPECT_TRUE(stream.get());
1272 stream.reset(); 1272 stream.reset();
1273 1273
1274 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1274 EXPECT_TRUE(socket_data.at_read_eof());
1275 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1275 EXPECT_TRUE(socket_data.at_write_eof());
1276 } 1276 }
1277 1277
1278 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) { 1278 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
1279 // Sequentially connect to the default host, then another host, and then the 1279 // Sequentially connect to the default host, then another host, and then the
1280 // default host. Verify that the default host gets a consistent ephemeral 1280 // default host. Verify that the default host gets a consistent ephemeral
1281 // port, that is different from the other host's connection. 1281 // port, that is different from the other host's connection.
1282 1282
1283 std::string other_server_name = "other.google.com"; 1283 std::string other_server_name = "other.google.com";
1284 EXPECT_NE(kDefaultServerHostName, other_server_name); 1284 EXPECT_NE(kDefaultServerHostName, other_server_name);
1285 HostPortPair host_port_pair2(other_server_name, kDefaultServerPort); 1285 HostPortPair host_port_pair2(other_server_name, kDefaultServerPort);
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after
1349 is_https_, 1349 is_https_,
1350 privacy_mode_, 1350 privacy_mode_,
1351 "GET", 1351 "GET",
1352 net_log_, 1352 net_log_,
1353 callback_.callback())); 1353 callback_.callback()));
1354 1354
1355 EXPECT_EQ(OK, callback_.WaitForResult()); 1355 EXPECT_EQ(OK, callback_.WaitForResult());
1356 stream = request2.ReleaseStream(); 1356 stream = request2.ReleaseStream();
1357 stream.reset(); // Will reset stream 3. 1357 stream.reset(); // Will reset stream 3.
1358 1358
1359 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1359 EXPECT_TRUE(socket_data.at_read_eof());
1360 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1360 EXPECT_TRUE(socket_data.at_write_eof());
1361 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1361 EXPECT_TRUE(socket_data2.at_read_eof());
1362 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1362 EXPECT_TRUE(socket_data2.at_write_eof());
1363 } 1363 }
1364 1364
1365 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) { 1365 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
1366 MockRead reads[] = { 1366 MockRead reads[] = {
1367 MockRead(ASYNC, 0, 0) // EOF 1367 MockRead(ASYNC, 0, 0) // EOF
1368 }; 1368 };
1369 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket()); 1369 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1370 std::vector<MockWrite> writes; 1370 std::vector<MockWrite> writes;
1371 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1)); 1371 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1372 DeterministicSocketData socket_data(reads, arraysize(reads), 1372 DeterministicSocketData socket_data(reads, arraysize(reads),
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
1413 is_https_, 1413 is_https_,
1414 privacy_mode_, 1414 privacy_mode_,
1415 "GET", 1415 "GET",
1416 net_log_, 1416 net_log_,
1417 callback_.callback())); 1417 callback_.callback()));
1418 1418
1419 EXPECT_EQ(OK, callback_.WaitForResult()); 1419 EXPECT_EQ(OK, callback_.WaitForResult());
1420 stream = request2.ReleaseStream(); 1420 stream = request2.ReleaseStream();
1421 stream.reset(); // Will reset stream 3. 1421 stream.reset(); // Will reset stream 3.
1422 1422
1423 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1423 EXPECT_TRUE(socket_data.at_read_eof());
1424 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1424 EXPECT_TRUE(socket_data.at_write_eof());
1425 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1425 EXPECT_TRUE(socket_data2.at_read_eof());
1426 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1426 EXPECT_TRUE(socket_data2.at_write_eof());
1427 } 1427 }
1428 1428
1429 TEST_P(QuicStreamFactoryTest, OnCertAdded) { 1429 TEST_P(QuicStreamFactoryTest, OnCertAdded) {
1430 MockRead reads[] = { 1430 MockRead reads[] = {
1431 MockRead(ASYNC, 0, 0) // EOF 1431 MockRead(ASYNC, 0, 0) // EOF
1432 }; 1432 };
1433 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket()); 1433 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1434 std::vector<MockWrite> writes; 1434 std::vector<MockWrite> writes;
1435 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1)); 1435 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1436 DeterministicSocketData socket_data(reads, arraysize(reads), 1436 DeterministicSocketData socket_data(reads, arraysize(reads),
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
1477 is_https_, 1477 is_https_,
1478 privacy_mode_, 1478 privacy_mode_,
1479 "GET", 1479 "GET",
1480 net_log_, 1480 net_log_,
1481 callback_.callback())); 1481 callback_.callback()));
1482 1482
1483 EXPECT_EQ(OK, callback_.WaitForResult()); 1483 EXPECT_EQ(OK, callback_.WaitForResult());
1484 stream = request2.ReleaseStream(); 1484 stream = request2.ReleaseStream();
1485 stream.reset(); // Will reset stream 3. 1485 stream.reset(); // Will reset stream 3.
1486 1486
1487 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1487 EXPECT_TRUE(socket_data.at_read_eof());
1488 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1488 EXPECT_TRUE(socket_data.at_write_eof());
1489 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1489 EXPECT_TRUE(socket_data2.at_read_eof());
1490 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1490 EXPECT_TRUE(socket_data2.at_write_eof());
1491 } 1491 }
1492 1492
1493 TEST_P(QuicStreamFactoryTest, OnCACertChanged) { 1493 TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
1494 MockRead reads[] = { 1494 MockRead reads[] = {
1495 MockRead(ASYNC, 0, 0) // EOF 1495 MockRead(ASYNC, 0, 0) // EOF
1496 }; 1496 };
1497 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket()); 1497 scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1498 std::vector<MockWrite> writes; 1498 std::vector<MockWrite> writes;
1499 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1)); 1499 writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1500 DeterministicSocketData socket_data(reads, arraysize(reads), 1500 DeterministicSocketData socket_data(reads, arraysize(reads),
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
1541 is_https_, 1541 is_https_,
1542 privacy_mode_, 1542 privacy_mode_,
1543 "GET", 1543 "GET",
1544 net_log_, 1544 net_log_,
1545 callback_.callback())); 1545 callback_.callback()));
1546 1546
1547 EXPECT_EQ(OK, callback_.WaitForResult()); 1547 EXPECT_EQ(OK, callback_.WaitForResult());
1548 stream = request2.ReleaseStream(); 1548 stream = request2.ReleaseStream();
1549 stream.reset(); // Will reset stream 3. 1549 stream.reset(); // Will reset stream 3.
1550 1550
1551 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1551 EXPECT_TRUE(socket_data.at_read_eof());
1552 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1552 EXPECT_TRUE(socket_data.at_write_eof());
1553 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1553 EXPECT_TRUE(socket_data2.at_read_eof());
1554 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1554 EXPECT_TRUE(socket_data2.at_write_eof());
1555 } 1555 }
1556 1556
1557 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) { 1557 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
1558 vector<string> cannoncial_suffixes; 1558 vector<string> cannoncial_suffixes;
1559 cannoncial_suffixes.push_back(string(".c.youtube.com")); 1559 cannoncial_suffixes.push_back(string(".c.youtube.com"));
1560 cannoncial_suffixes.push_back(string(".googlevideo.com")); 1560 cannoncial_suffixes.push_back(string(".googlevideo.com"));
1561 1561
1562 for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) { 1562 for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
1563 string r1_host_name("r1"); 1563 string r1_host_name("r1");
1564 string r2_host_name("r2"); 1564 string r2_host_name("r2");
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
1653 EXPECT_EQ(ERR_IO_PENDING, 1653 EXPECT_EQ(ERR_IO_PENDING,
1654 request.Request(host_port_pair_, is_https_, privacy_mode_, "GET", 1654 request.Request(host_port_pair_, is_https_, privacy_mode_, "GET",
1655 net_log_, callback_.callback())); 1655 net_log_, callback_.callback()));
1656 EXPECT_EQ(2u, 1656 EXPECT_EQ(2u,
1657 QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id)); 1657 QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
1658 1658
1659 runner_->RunNextTask(); 1659 runner_->RunNextTask();
1660 1660
1661 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1661 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1662 EXPECT_TRUE(stream.get()); 1662 EXPECT_TRUE(stream.get());
1663 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1663 EXPECT_TRUE(socket_data.at_read_eof());
1664 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1664 EXPECT_TRUE(socket_data.at_write_eof());
1665 EXPECT_EQ(0u, 1665 EXPECT_EQ(0u,
1666 QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id)); 1666 QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
1667 } 1667 }
1668 1668
1669 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) { 1669 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
1670 factory_.set_quic_server_info_factory(&quic_server_info_factory_); 1670 factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1671 QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get()); 1671 QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1672 QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true); 1672 QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1673 1673
1674 MockRead reads[] = { 1674 MockRead reads[] = {
(...skipping 12 matching lines...) Expand all
1687 QuicStreamRequest request(&factory_); 1687 QuicStreamRequest request(&factory_);
1688 EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_, 1688 EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1689 "GET", net_log_, callback_.callback())); 1689 "GET", net_log_, callback_.callback()));
1690 1690
1691 // If we are waiting for disk cache, we would have posted a task. Verify that 1691 // If we are waiting for disk cache, we would have posted a task. Verify that
1692 // the CancelWaitForDataReady task hasn't been posted. 1692 // the CancelWaitForDataReady task hasn't been posted.
1693 ASSERT_EQ(0u, runner_->GetPostedTasks().size()); 1693 ASSERT_EQ(0u, runner_->GetPostedTasks().size());
1694 1694
1695 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1695 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1696 EXPECT_TRUE(stream.get()); 1696 EXPECT_TRUE(stream.get());
1697 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1697 EXPECT_TRUE(socket_data.at_read_eof());
1698 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1698 EXPECT_TRUE(socket_data.at_write_eof());
1699 } 1699 }
1700 1700
1701 TEST_P(QuicStreamFactoryTest, BadPacketLoss) { 1701 TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
1702 factory_.set_quic_server_info_factory(&quic_server_info_factory_); 1702 factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1703 QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get()); 1703 QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1704 QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true); 1704 QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1705 QuicStreamFactoryPeer::SetMaxNumberOfLossyConnections(&factory_, 2); 1705 QuicStreamFactoryPeer::SetMaxNumberOfLossyConnections(&factory_, 2);
1706 EXPECT_FALSE( 1706 EXPECT_FALSE(
1707 QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port())); 1707 QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1708 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections( 1708 EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
(...skipping 112 matching lines...) Expand 10 before | Expand all | Expand 10 after
1821 EXPECT_FALSE( 1821 EXPECT_FALSE(
1822 QuicStreamFactoryPeer::HasActiveSession(&factory_, server3, is_https_)); 1822 QuicStreamFactoryPeer::HasActiveSession(&factory_, server3, is_https_));
1823 EXPECT_EQ(nullptr, CreateIfSessionExists(server3, net_log_).get()); 1823 EXPECT_EQ(nullptr, CreateIfSessionExists(server3, net_log_).get());
1824 1824
1825 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream(); 1825 scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1826 EXPECT_TRUE(stream.get()); 1826 EXPECT_TRUE(stream.get());
1827 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream(); 1827 scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1828 EXPECT_TRUE(stream2.get()); 1828 EXPECT_TRUE(stream2.get());
1829 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream(); 1829 scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
1830 EXPECT_TRUE(stream3.get()); 1830 EXPECT_TRUE(stream3.get());
1831 EXPECT_TRUE(socket_data.AllReadDataConsumed()); 1831 EXPECT_TRUE(socket_data.at_read_eof());
1832 EXPECT_TRUE(socket_data.AllWriteDataConsumed()); 1832 EXPECT_TRUE(socket_data.at_write_eof());
1833 EXPECT_TRUE(socket_data2.AllReadDataConsumed()); 1833 EXPECT_TRUE(socket_data2.at_read_eof());
1834 EXPECT_TRUE(socket_data2.AllWriteDataConsumed()); 1834 EXPECT_TRUE(socket_data2.at_write_eof());
1835 EXPECT_TRUE(socket_data3.AllReadDataConsumed()); 1835 EXPECT_TRUE(socket_data3.at_read_eof());
1836 EXPECT_TRUE(socket_data3.AllWriteDataConsumed()); 1836 EXPECT_TRUE(socket_data3.at_write_eof());
1837 } 1837 }
1838 1838
1839 } // namespace test 1839 } // namespace test
1840 } // namespace net 1840 } // namespace net
OLDNEW
« no previous file with comments | « net/quic/quic_network_transaction_unittest.cc ('k') | net/socket/sequenced_socket_data_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698