net/quic/quic_stream_factory_test.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/quic_stream_factory.h"
   6
   7 #include "base/run_loop.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/thread_task_runner_handle.h"
  10 #include "net/base/test_data_directory.h"
  11 #include "net/cert/cert_verifier.h"
  12 #include "net/dns/mock_host_resolver.h"
  13 #include "net/http/http_response_headers.h"
  14 #include "net/http/http_response_info.h"
  15 #include "net/http/http_server_properties_impl.h"
  16 #include "net/http/http_util.h"
  17 #include "net/http/transport_security_state.h"
  18 #include "net/quic/crypto/crypto_handshake.h"
  19 #include "net/quic/crypto/proof_verifier_chromium.h"
  20 #include "net/quic/crypto/quic_decrypter.h"
  21 #include "net/quic/crypto/quic_encrypter.h"
  22 #include "net/quic/crypto/quic_server_info.h"
  23 #include "net/quic/quic_http_stream.h"
  24 #include "net/quic/quic_server_id.h"
  25 #include "net/quic/test_tools/mock_clock.h"
  26 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
  27 #include "net/quic/test_tools/mock_random.h"
  28 #include "net/quic/test_tools/quic_test_packet_maker.h"
  29 #include "net/quic/test_tools/quic_test_utils.h"
  30 #include "net/quic/test_tools/test_task_runner.h"
  31 #include "net/socket/socket_test_util.h"
  32 #include "net/spdy/spdy_test_utils.h"
  33 #include "net/ssl/channel_id_service.h"
  34 #include "net/ssl/default_channel_id_store.h"
  35 #include "net/test/cert_test_util.h"
  36 #include "testing/gtest/include/gtest/gtest.h"
  37
  38 using base::StringPiece;
  39 using std::ostream;
  40 using std::string;
  41 using std::vector;
  42
  43 namespace net {
  44 namespace test {
  45
  46 namespace {
  47 const char kDefaultServerHostName[] = "www.google.com";
  48 const int kDefaultServerPort = 443;
  49
  50 // Run all tests with all the combinations of versions and
  51 // enable_connection_racing.
  52 struct TestParams {
  53   TestParams(const QuicVersion version, bool enable_connection_racing)
  54       : version(version), enable_connection_racing(enable_connection_racing) {}
  55
  56   friend ostream& operator<<(ostream& os, const TestParams& p) {
  57     os << "{ version: " << QuicVersionToString(p.version);
  58     os << " enable_connection_racing: " << p.enable_connection_racing << " }";
  59     return os;
  60   }
  61
  62   QuicVersion version;
  63   bool enable_connection_racing;
  64 };
  65
  66 // Constructs various test permutations.
  67 vector<TestParams> GetTestParams() {
  68   vector<TestParams> params;
  69   QuicVersionVector all_supported_versions = QuicSupportedVersions();
  70   for (const QuicVersion version : all_supported_versions) {
  71     params.push_back(TestParams(version, false));
  72     params.push_back(TestParams(version, true));
  73   }
  74   return params;
  75 }
  76
  77 }  // namespace anonymous
  78
  79 class QuicStreamFactoryPeer {
  80  public:
  81   static QuicCryptoClientConfig* GetCryptoConfig(QuicStreamFactory* factory) {
  82     return &factory->crypto_config_;
  83   }
  84
  85   static bool HasActiveSession(QuicStreamFactory* factory,
  86                                const HostPortPair& host_port_pair,
  87                                bool is_https) {
  88     QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
  89     return factory->HasActiveSession(server_id);
  90   }
  91
  92   static QuicChromiumClientSession* GetActiveSession(
  93       QuicStreamFactory* factory,
  94       const HostPortPair& host_port_pair,
  95       bool is_https) {
  96     QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
  97     DCHECK(factory->HasActiveSession(server_id));
  98     return factory->active_sessions_[server_id];
  99   }
 100
 101   static scoped_ptr<QuicHttpStream> CreateFromSession(
 102       QuicStreamFactory* factory,
 103       QuicChromiumClientSession* session) {
 104     return factory->CreateFromSession(session);
 105   }
 106
 107   static bool IsLiveSession(QuicStreamFactory* factory,
 108                             QuicChromiumClientSession* session) {
 109     for (QuicStreamFactory::SessionIdMap::iterator it =
 110              factory->all_sessions_.begin();
 111          it != factory->all_sessions_.end(); ++it) {
 112       if (it->first == session)
 113         return true;
 114     }
 115     return false;
 116   }
 117
 118   static void DisableConnectionPooling(QuicStreamFactory* factory) {
 119     factory->disable_connection_pooling_ = true;
 120   }
 121
 122   static void SetTaskRunner(QuicStreamFactory* factory,
 123                             base::TaskRunner* task_runner) {
 124     factory->task_runner_ = task_runner;
 125   }
 126
 127   static void SetEnableConnectionRacing(QuicStreamFactory* factory,
 128                                         bool enable_connection_racing) {
 129     factory->enable_connection_racing_ = enable_connection_racing;
 130   }
 131
 132   static void SetDisableDiskCache(QuicStreamFactory* factory,
 133                                   bool disable_disk_cache) {
 134     factory->disable_disk_cache_ = disable_disk_cache;
 135   }
 136
 137   static void SetMaxNumberOfLossyConnections(
 138       QuicStreamFactory* factory,
 139       int max_number_of_lossy_connections) {
 140     factory->max_number_of_lossy_connections_ = max_number_of_lossy_connections;
 141   }
 142
 143   static int GetNumberOfLossyConnections(QuicStreamFactory* factory,
 144                                          uint16 port) {
 145     return factory->number_of_lossy_connections_[port];
 146   }
 147
 148   static bool IsQuicDisabled(QuicStreamFactory* factory, uint16 port) {
 149     return factory->IsQuicDisabled(port);
 150   }
 151
 152   static bool GetDelayTcpRace(QuicStreamFactory* factory) {
 153     return factory->delay_tcp_race_;
 154   }
 155
 156   static void SetDelayTcpRace(QuicStreamFactory* factory, bool delay_tcp_race) {
 157     factory->delay_tcp_race_ = delay_tcp_race;
 158   }
 159
 160   static void SetHttpServerProperties(
 161       QuicStreamFactory* factory,
 162       base::WeakPtr<HttpServerProperties> http_server_properties) {
 163     factory->http_server_properties_ = http_server_properties;
 164   }
 165
 166   static size_t GetNumberOfActiveJobs(QuicStreamFactory* factory,
 167                                       const QuicServerId& server_id) {
 168     return (factory->active_jobs_[server_id]).size();
 169   }
 170
 171   static void SetThresholdTimeoutsWithOpenStreams(
 172       QuicStreamFactory* factory,
 173       int threshold_timeouts_with_open_streams) {
 174     factory->threshold_timeouts_with_open_streams_ =
 175         threshold_timeouts_with_open_streams;
 176   }
 177
 178   static int GetNumTimeoutsWithOpenStreams(QuicStreamFactory* factory) {
 179     return factory->num_timeouts_with_open_streams_;
 180   }
 181
 182   static void SetThresholdPublicResetsPostHandshake(
 183       QuicStreamFactory* factory,
 184       int threshold_public_resets_post_handshake) {
 185     factory->threshold_public_resets_post_handshake_ =
 186         threshold_public_resets_post_handshake;
 187   }
 188
 189   static int GetNumPublicResetsPostHandshake(QuicStreamFactory* factory) {
 190     return factory->num_public_resets_post_handshake_;
 191   }
 192 };
 193
 194 class MockQuicServerInfo : public QuicServerInfo {
 195  public:
 196   MockQuicServerInfo(const QuicServerId& server_id)
 197       : QuicServerInfo(server_id) {}
 198   ~MockQuicServerInfo() override {}
 199
 200   void Start() override {}
 201
 202   int WaitForDataReady(const CompletionCallback& callback) override {
 203     return ERR_IO_PENDING;
 204   }
 205
 206   void ResetWaitForDataReadyCallback() override {}
 207
 208   void CancelWaitForDataReadyCallback() override {}
 209
 210   bool IsDataReady() override { return false; }
 211
 212   bool IsReadyToPersist() override { return false; }
 213
 214   void Persist() override {}
 215
 216   void OnExternalCacheHit() override {}
 217 };
 218
 219 class MockQuicServerInfoFactory : public QuicServerInfoFactory {
 220  public:
 221   MockQuicServerInfoFactory() {}
 222   ~MockQuicServerInfoFactory() override {}
 223
 224   QuicServerInfo* GetForServer(const QuicServerId& server_id) override {
 225     return new MockQuicServerInfo(server_id);
 226   }
 227 };
 228
 229 class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
 230  protected:
 231   QuicStreamFactoryTest()
 232       : random_generator_(0),
 233         clock_(new MockClock()),
 234         runner_(new TestTaskRunner(clock_)),
 235         maker_(GetParam().version, 0, clock_, kDefaultServerHostName),
 236         cert_verifier_(CertVerifier::CreateDefault()),
 237         channel_id_service_(
 238             new ChannelIDService(new DefaultChannelIDStore(nullptr),
 239                                  base::ThreadTaskRunnerHandle::Get())),
 240         factory_(&host_resolver_,
 241                  &socket_factory_,
 242                  base::WeakPtr<HttpServerProperties>(),
 243                  cert_verifier_.get(),
 244                  nullptr,
 245                  channel_id_service_.get(),
 246                  &transport_security_state_,
 247                  &crypto_client_stream_factory_,
 248                  &random_generator_,
 249                  clock_,
 250                  kDefaultMaxPacketSize,
 251                  std::string(),
 252                  SupportedVersions(GetParam().version),
 253                  /*enable_port_selection=*/true,
 254                  /*always_require_handshake_confirmation=*/false,
 255                  /*disable_connection_pooling=*/false,
 256                  /*load_server_info_timeout_srtt_multiplier=*/0.0f,
 257                  /*enable_connection_racing=*/false,
 258                  /*enable_non_blocking_io=*/true,
 259                  /*disable_disk_cache=*/false,
 260                  /*prefer_aes=*/false,
 261                  /*max_number_of_lossy_connections=*/0,
 262                  /*packet_loss_threshold=*/1.0f,
 263                  /*max_disabled_reasons=*/3,
 264                  /*threshold_timeouts_with_open_streams=*/2,
 265                  /*threshold_pulic_resets_post_handshake=*/2,
 266                  /*receive_buffer_size=*/0,
 267                  /*delay_tcp_race=*/false,
 268                  QuicTagVector()),
 269         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
 270         is_https_(false),
 271         privacy_mode_(PRIVACY_MODE_DISABLED) {
 272     factory_.set_require_confirmation(false);
 273     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
 274     QuicStreamFactoryPeer::SetEnableConnectionRacing(
 275         &factory_, GetParam().enable_connection_racing);
 276   }
 277
 278   bool HasActiveSession(const HostPortPair& host_port_pair) {
 279     return QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair,
 280                                                    /*is_https_=*/false);
 281   }
 282
 283   scoped_ptr<QuicHttpStream> CreateFromSession(
 284       const HostPortPair& host_port_pair) {
 285     QuicChromiumClientSession* session =
 286         QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_pair,
 287                                                 /*is_https=*/false);
 288     return QuicStreamFactoryPeer::CreateFromSession(&factory_, session);
 289   }
 290
 291   int GetSourcePortForNewSession(const HostPortPair& destination) {
 292     return GetSourcePortForNewSessionInner(destination, false);
 293   }
 294
 295   int GetSourcePortForNewSessionAndGoAway(
 296       const HostPortPair& destination) {
 297     return GetSourcePortForNewSessionInner(destination, true);
 298   }
 299
 300   int GetSourcePortForNewSessionInner(const HostPortPair& destination,
 301                                       bool goaway_received) {
 302     // Should only be called if there is no active session for this destination.
 303     EXPECT_FALSE(HasActiveSession(destination));
 304     size_t socket_count = socket_factory_.udp_client_sockets().size();
 305
 306     MockRead reads[] = {
 307       MockRead(ASYNC, OK, 0)  // EOF
 308     };
 309     DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 310     socket_data.StopAfter(1);
 311     socket_factory_.AddSocketDataProvider(&socket_data);
 312
 313     QuicStreamRequest request(&factory_);
 314     EXPECT_EQ(ERR_IO_PENDING,
 315               request.Request(destination, is_https_, privacy_mode_,
 316                               /*cert_verify_flags=*/0, destination.host(),
 317                               "GET", net_log_, callback_.callback()));
 318
 319     EXPECT_EQ(OK, callback_.WaitForResult());
 320     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 321     EXPECT_TRUE(stream.get());
 322     stream.reset();
 323
 324     QuicChromiumClientSession* session =
 325         QuicStreamFactoryPeer::GetActiveSession(&factory_, destination,
 326                                                 is_https_);
 327
 328     if (socket_count + 1 != socket_factory_.udp_client_sockets().size()) {
 329       EXPECT_TRUE(false);
 330       return 0;
 331     }
 332
 333     IPEndPoint endpoint;
 334     socket_factory_.
 335         udp_client_sockets()[socket_count]->GetLocalAddress(&endpoint);
 336     int port = endpoint.port();
 337     if (goaway_received) {
 338       QuicGoAwayFrame goaway(QUIC_NO_ERROR, 1, "");
 339       session->connection()->OnGoAwayFrame(goaway);
 340     }
 341
 342     factory_.OnSessionClosed(session);
 343     EXPECT_FALSE(HasActiveSession(destination));
 344     EXPECT_TRUE(socket_data.AllReadDataConsumed());
 345     EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 346     return port;
 347   }
 348
 349   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
 350     QuicStreamId stream_id = kClientDataStreamId1;
 351     return maker_.MakeRstPacket(
 352         1, true, stream_id,
 353         AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam().version));
 354   }
 355
 356   static ProofVerifyDetailsChromium DefaultProofVerifyDetails() {
 357     // Load a certificate that is valid for www.example.org, mail.example.org,
 358     // and mail.example.com.
 359     scoped_refptr<X509Certificate> test_cert(
 360         ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
 361     EXPECT_TRUE(test_cert.get());
 362     ProofVerifyDetailsChromium verify_details;
 363     verify_details.cert_verify_result.verified_cert = test_cert;
 364     verify_details.cert_verify_result.is_issued_by_known_root = true;
 365     return verify_details;
 366   }
 367
 368   MockQuicServerInfoFactory quic_server_info_factory_;
 369   MockHostResolver host_resolver_;
 370   DeterministicMockClientSocketFactory socket_factory_;
 371   MockCryptoClientStreamFactory crypto_client_stream_factory_;
 372   MockRandom random_generator_;
 373   MockClock* clock_;  // Owned by factory_.
 374   scoped_refptr<TestTaskRunner> runner_;
 375   QuicTestPacketMaker maker_;
 376   scoped_ptr<CertVerifier> cert_verifier_;
 377   scoped_ptr<ChannelIDService> channel_id_service_;
 378   TransportSecurityState transport_security_state_;
 379   QuicStreamFactory factory_;
 380   HostPortPair host_port_pair_;
 381   bool is_https_;
 382   PrivacyMode privacy_mode_;
 383   BoundNetLog net_log_;
 384   TestCompletionCallback callback_;
 385 };
 386
 387 INSTANTIATE_TEST_CASE_P(Version,
 388                         QuicStreamFactoryTest,
 389                         ::testing::ValuesIn(GetTestParams()));
 390
 391 TEST_P(QuicStreamFactoryTest, Create) {
 392   MockRead reads[] = {
 393     MockRead(ASYNC, OK, 0)  // EOF
 394   };
 395   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 396   socket_factory_.AddSocketDataProvider(&socket_data);
 397   socket_data.StopAfter(1);
 398
 399   QuicStreamRequest request(&factory_);
 400   EXPECT_EQ(ERR_IO_PENDING,
 401             request.Request(host_port_pair_, is_https_, privacy_mode_,
 402                             /*cert_verify_flags=*/0, host_port_pair_.host(),
 403                             "GET", net_log_, callback_.callback()));
 404
 405   EXPECT_EQ(OK, callback_.WaitForResult());
 406   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 407   EXPECT_TRUE(stream.get());
 408
 409   // Will reset stream 3.
 410   stream = CreateFromSession(host_port_pair_);
 411   EXPECT_TRUE(stream.get());
 412
 413   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
 414   // in streams on different sessions.
 415   QuicStreamRequest request2(&factory_);
 416   EXPECT_EQ(OK,
 417             request2.Request(host_port_pair_, is_https_, privacy_mode_,
 418                              /*cert_verify_flags=*/0, host_port_pair_.host(),
 419                              "GET", net_log_, callback_.callback()));
 420   stream = request2.ReleaseStream();  // Will reset stream 5.
 421   stream.reset();  // Will reset stream 7.
 422
 423   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 424   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 425 }
 426
 427 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
 428   MockRead reads[] = {
 429     MockRead(ASYNC, OK, 0)  // EOF
 430   };
 431   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 432   socket_factory_.AddSocketDataProvider(&socket_data);
 433   socket_data.StopAfter(1);
 434
 435   crypto_client_stream_factory_.set_handshake_mode(
 436       MockCryptoClientStream::ZERO_RTT);
 437   host_resolver_.set_synchronous_mode(true);
 438   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 439                                            "192.168.0.1", "");
 440
 441   QuicStreamRequest request(&factory_);
 442   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 443                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
 444                                 "GET", net_log_, callback_.callback()));
 445
 446   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 447   EXPECT_TRUE(stream.get());
 448   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 449   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 450 }
 451
 452 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
 453   MockRead reads[] = {
 454     MockRead(ASYNC, OK, 0)  // EOF
 455   };
 456   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 457   socket_factory_.AddSocketDataProvider(&socket_data);
 458   socket_data.StopAfter(1);
 459
 460   crypto_client_stream_factory_.set_handshake_mode(
 461       MockCryptoClientStream::ZERO_RTT);
 462   host_resolver_.set_synchronous_mode(true);
 463   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 464                                            "192.168.0.1", "");
 465
 466   QuicStreamRequest request(&factory_);
 467   // Posts require handshake confirmation, so this will return asynchronously.
 468   EXPECT_EQ(ERR_IO_PENDING,
 469             request.Request(host_port_pair_, is_https_, privacy_mode_,
 470                             /*cert_verify_flags=*/0, host_port_pair_.host(),
 471                             "POST", net_log_, callback_.callback()));
 472
 473   // Confirm the handshake and verify that the stream is created.
 474   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
 475       QuicSession::HANDSHAKE_CONFIRMED);
 476
 477   EXPECT_EQ(OK, callback_.WaitForResult());
 478   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 479   EXPECT_TRUE(stream.get());
 480   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 481   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 482 }
 483
 484 TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) {
 485   MockRead reads[] = {
 486       MockRead(ASYNC, OK, 0),
 487   };
 488   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 489   socket_factory_.AddSocketDataProvider(&socket_data);
 490   socket_data.StopAfter(1);
 491
 492   crypto_client_stream_factory_.set_handshake_mode(
 493       MockCryptoClientStream::ZERO_RTT);
 494   host_resolver_.set_synchronous_mode(true);
 495   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 496                                            "192.168.0.1", "");
 497
 498   QuicStreamRequest request(&factory_);
 499   int rv = request.Request(
 500       host_port_pair_, is_https_, privacy_mode_, /*cert_verify_flags=*/0,
 501       "different.host.example.com", "GET", net_log_, callback_.callback());
 502   // If server and origin have different hostnames, then handshake confirmation
 503   // should be required, so Request will return asynchronously.
 504   EXPECT_EQ(ERR_IO_PENDING, rv);
 505   // Confirm handshake.
 506   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
 507       QuicSession::HANDSHAKE_CONFIRMED);
 508   EXPECT_EQ(OK, callback_.WaitForResult());
 509
 510   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 511   EXPECT_TRUE(stream.get());
 512   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 513   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 514 }
 515
 516 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
 517   MockRead reads[] = {
 518     MockRead(ASYNC, OK, 0)  // EOF
 519   };
 520   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 521   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 522   socket_factory_.AddSocketDataProvider(&socket_data1);
 523   socket_factory_.AddSocketDataProvider(&socket_data2);
 524   socket_data1.StopAfter(1);
 525   socket_data2.StopAfter(1);
 526
 527   QuicStreamRequest request(&factory_);
 528   EXPECT_EQ(ERR_IO_PENDING,
 529             request.Request(host_port_pair_, is_https_, privacy_mode_,
 530                             /*cert_verify_flags=*/0, host_port_pair_.host(),
 531                             "GET", net_log_, callback_.callback()));
 532
 533   EXPECT_EQ(OK, callback_.WaitForResult());
 534   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 535   EXPECT_TRUE(stream.get());
 536
 537   QuicStreamRequest request2(&factory_);
 538   EXPECT_EQ(ERR_IO_PENDING,
 539             request2.Request(host_port_pair_, !is_https_, privacy_mode_,
 540                              /*cert_verify_flags=*/0, host_port_pair_.host(),
 541                              "GET", net_log_, callback_.callback()));
 542   EXPECT_EQ(OK, callback_.WaitForResult());
 543   stream = request2.ReleaseStream();
 544   EXPECT_TRUE(stream.get());
 545   stream.reset();
 546
 547   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 548                 &factory_, host_port_pair_, is_https_),
 549             QuicStreamFactoryPeer::GetActiveSession(
 550                 &factory_, host_port_pair_, !is_https_));
 551
 552   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 553   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 554   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 555   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 556 }
 557
 558 TEST_P(QuicStreamFactoryTest, Pooling) {
 559   MockRead reads[] = {
 560     MockRead(ASYNC, OK, 0)  // EOF
 561   };
 562   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 563   socket_factory_.AddSocketDataProvider(&socket_data);
 564   socket_data.StopAfter(1);
 565
 566   HostPortPair server2("mail.google.com", kDefaultServerPort);
 567   host_resolver_.set_synchronous_mode(true);
 568   host_resolver_.rules()->AddIPLiteralRule(
 569       kDefaultServerHostName, "192.168.0.1", "");
 570   host_resolver_.rules()->AddIPLiteralRule(
 571       "mail.google.com", "192.168.0.1", "");
 572
 573   QuicStreamRequest request(&factory_);
 574   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 575                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
 576                                 "GET", net_log_, callback_.callback()));
 577   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 578   EXPECT_TRUE(stream.get());
 579
 580   TestCompletionCallback callback;
 581   QuicStreamRequest request2(&factory_);
 582   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
 583                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 584                                  net_log_, callback.callback()));
 585   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 586   EXPECT_TRUE(stream2.get());
 587
 588   EXPECT_EQ(
 589       QuicStreamFactoryPeer::GetActiveSession(
 590           &factory_, host_port_pair_, is_https_),
 591       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 592
 593   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 594   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 595 }
 596
 597 TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
 598   MockRead reads[] = {
 599     MockRead(ASYNC, OK, 0)  // EOF
 600   };
 601   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 602   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 603   socket_factory_.AddSocketDataProvider(&socket_data1);
 604   socket_factory_.AddSocketDataProvider(&socket_data2);
 605   socket_data1.StopAfter(1);
 606   socket_data2.StopAfter(1);
 607
 608   HostPortPair server2("mail.google.com", kDefaultServerPort);
 609   host_resolver_.set_synchronous_mode(true);
 610   host_resolver_.rules()->AddIPLiteralRule(
 611       kDefaultServerHostName, "192.168.0.1", "");
 612   host_resolver_.rules()->AddIPLiteralRule(
 613       "mail.google.com", "192.168.0.1", "");
 614
 615   // Disable connection pooling.
 616   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 617
 618   QuicStreamRequest request(&factory_);
 619   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 620                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
 621                                 "GET", net_log_, callback_.callback()));
 622   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 623   EXPECT_TRUE(stream.get());
 624
 625   TestCompletionCallback callback;
 626   QuicStreamRequest request2(&factory_);
 627   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
 628                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 629                                  net_log_, callback.callback()));
 630   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 631   EXPECT_TRUE(stream2.get());
 632
 633   EXPECT_NE(
 634       QuicStreamFactoryPeer::GetActiveSession(
 635           &factory_, host_port_pair_, is_https_),
 636       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 637
 638   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 639   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 640   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 641   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 642 }
 643
 644 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 645   MockRead reads[] = {
 646     MockRead(ASYNC, OK, 0)  // EOF
 647   };
 648   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 649   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 650   socket_factory_.AddSocketDataProvider(&socket_data1);
 651   socket_factory_.AddSocketDataProvider(&socket_data2);
 652   socket_data1.StopAfter(1);
 653   socket_data2.StopAfter(1);
 654
 655   HostPortPair server2("mail.google.com", kDefaultServerPort);
 656   host_resolver_.set_synchronous_mode(true);
 657   host_resolver_.rules()->AddIPLiteralRule(
 658       kDefaultServerHostName, "192.168.0.1", "");
 659   host_resolver_.rules()->AddIPLiteralRule(
 660       "mail.google.com", "192.168.0.1", "");
 661
 662   QuicStreamRequest request(&factory_);
 663   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 664                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
 665                                 "GET", net_log_, callback_.callback()));
 666   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 667   EXPECT_TRUE(stream.get());
 668
 669   TestCompletionCallback callback;
 670   QuicStreamRequest request2(&factory_);
 671   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
 672                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 673                                  net_log_, callback.callback()));
 674   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 675   EXPECT_TRUE(stream2.get());
 676
 677   factory_.OnSessionGoingAway(QuicStreamFactoryPeer::GetActiveSession(
 678       &factory_, host_port_pair_, is_https_));
 679   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
 680       &factory_, host_port_pair_, is_https_));
 681   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
 682       &factory_, server2, is_https_));
 683
 684   TestCompletionCallback callback3;
 685   QuicStreamRequest request3(&factory_);
 686   EXPECT_EQ(OK, request3.Request(server2, is_https_, privacy_mode_,
 687                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 688                                  net_log_, callback3.callback()));
 689   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
 690   EXPECT_TRUE(stream3.get());
 691
 692   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
 693       &factory_, server2, is_https_));
 694
 695   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 696   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 697   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 698   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 699 }
 700
 701 TEST_P(QuicStreamFactoryTest, HttpsPooling) {
 702   MockRead reads[] = {
 703     MockRead(ASYNC, OK, 0)  // EOF
 704   };
 705   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 706   socket_factory_.AddSocketDataProvider(&socket_data);
 707   socket_data.StopAfter(1);
 708
 709   HostPortPair server1("www.example.org", 443);
 710   HostPortPair server2("mail.example.org", 443);
 711
 712   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 713   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 714
 715   host_resolver_.set_synchronous_mode(true);
 716   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 717   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 718
 719   QuicStreamRequest request(&factory_);
 720   is_https_ = true;
 721   EXPECT_EQ(OK, request.Request(server1, is_https_, privacy_mode_,
 722                                 /*cert_verify_flags=*/0, server1.host(), "GET",
 723                                 net_log_, callback_.callback()));
 724   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 725   EXPECT_TRUE(stream.get());
 726
 727   TestCompletionCallback callback;
 728   QuicStreamRequest request2(&factory_);
 729   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
 730                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 731                                  net_log_, callback_.callback()));
 732   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 733   EXPECT_TRUE(stream2.get());
 734
 735   EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
 736                 &factory_, server1, is_https_),
 737             QuicStreamFactoryPeer::GetActiveSession(
 738                 &factory_, server2, is_https_));
 739
 740   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 741   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 742 }
 743
 744 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
 745   MockRead reads[] = {
 746     MockRead(ASYNC, OK, 0)  // EOF
 747   };
 748   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 749   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 750   socket_factory_.AddSocketDataProvider(&socket_data1);
 751   socket_factory_.AddSocketDataProvider(&socket_data2);
 752   socket_data1.StopAfter(1);
 753   socket_data2.StopAfter(1);
 754
 755   HostPortPair server1("www.example.org", 443);
 756   HostPortPair server2("mail.example.org", 443);
 757
 758   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 759   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 760
 761   host_resolver_.set_synchronous_mode(true);
 762   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 763   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 764
 765   // Disable connection pooling.
 766   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 767
 768   QuicStreamRequest request(&factory_);
 769   is_https_ = true;
 770   EXPECT_EQ(OK, request.Request(server1, is_https_, privacy_mode_,
 771                                 /*cert_verify_flags=*/0, server1.host(), "GET",
 772                                 net_log_, callback_.callback()));
 773   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 774   EXPECT_TRUE(stream.get());
 775
 776   TestCompletionCallback callback;
 777   QuicStreamRequest request2(&factory_);
 778   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
 779                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 780                                  net_log_, callback_.callback()));
 781   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 782   EXPECT_TRUE(stream2.get());
 783
 784   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 785                 &factory_, server1, is_https_),
 786             QuicStreamFactoryPeer::GetActiveSession(
 787                 &factory_, server2, is_https_));
 788
 789   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 790   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 791   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 792   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 793 }
 794
 795 class QuicAlternativeServiceCertificateValidationPooling
 796     : public QuicStreamFactoryTest {
 797  public:
 798   void Run(bool valid) {
 799     MockRead reads[] = {
 800         MockRead(ASYNC, OK, 0)  // EOF
 801     };
 802     DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 803     socket_factory_.AddSocketDataProvider(&socket_data1);
 804     socket_data1.StopAfter(1);
 805
 806     HostPortPair server1("www.example.org", 443);
 807     HostPortPair server2("mail.example.org", 443);
 808
 809     std::string origin_host(valid ? "mail.example.org" : "invalid.example.org");
 810     HostPortPair alternative("www.example.org", 443);
 811
 812     ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 813     bool common_name_fallback_used;
 814     EXPECT_EQ(valid,
 815               verify_details.cert_verify_result.verified_cert->VerifyNameMatch(
 816                   origin_host, &common_name_fallback_used));
 817     EXPECT_TRUE(
 818         verify_details.cert_verify_result.verified_cert->VerifyNameMatch(
 819             alternative.host(), &common_name_fallback_used));
 820     crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 821
 822     host_resolver_.set_synchronous_mode(true);
 823     host_resolver_.rules()->AddIPLiteralRule(alternative.host(), "192.168.0.1",
 824                                              "");
 825
 826     // Open first stream to alternative.
 827     QuicStreamRequest request1(&factory_);
 828     is_https_ = true;
 829     EXPECT_EQ(OK, request1.Request(alternative, is_https_, privacy_mode_,
 830                                    /*cert_verify_flags=*/0, alternative.host(),
 831                                    "GET", net_log_, callback_.callback()));
 832     scoped_ptr<QuicHttpStream> stream1 = request1.ReleaseStream();
 833     EXPECT_TRUE(stream1.get());
 834
 835     QuicStreamRequest request2(&factory_);
 836     int rv = request2.Request(alternative, is_https_, privacy_mode_,
 837                               /*cert_verify_flags=*/0, origin_host, "GET",
 838                               net_log_, callback_.callback());
 839     if (valid) {
 840       // Alternative service of origin to |alternative| should pool to session
 841       // of |stream1| even if origin is different.  Since only one
 842       // SocketDataProvider is set up, the second request succeeding means that
 843       // it pooled to the session opened by the first one.
 844       EXPECT_EQ(OK, rv);
 845       scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 846       EXPECT_TRUE(stream2.get());
 847     } else {
 848       EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv);
 849     }
 850
 851     EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 852     EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 853   }
 854 };
 855
 856 INSTANTIATE_TEST_CASE_P(Version,
 857                         QuicAlternativeServiceCertificateValidationPooling,
 858                         ::testing::ValuesIn(GetTestParams()));
 859
 860 TEST_P(QuicAlternativeServiceCertificateValidationPooling, Valid) {
 861   Run(true);
 862 }
 863
 864 TEST_P(QuicAlternativeServiceCertificateValidationPooling, Invalid) {
 865   Run(false);
 866 }
 867
 868 TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
 869   MockRead reads[] = {
 870     MockRead(ASYNC, OK, 0)  // EOF
 871   };
 872   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 873   socket_factory_.AddSocketDataProvider(&socket_data);
 874   socket_data.StopAfter(1);
 875
 876   HostPortPair server1("www.example.org", 443);
 877   HostPortPair server2("mail.example.org", 443);
 878   uint8 primary_pin = 1;
 879   uint8 backup_pin = 2;
 880   test::AddPin(&transport_security_state_, "mail.example.org", primary_pin,
 881                backup_pin);
 882
 883   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 884   verify_details.cert_verify_result.public_key_hashes.push_back(
 885       test::GetTestHashValue(primary_pin));
 886   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 887
 888   host_resolver_.set_synchronous_mode(true);
 889   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 890   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 891
 892   QuicStreamRequest request(&factory_);
 893   is_https_ = true;
 894   EXPECT_EQ(OK, request.Request(server1, is_https_, privacy_mode_,
 895                                 /*cert_verify_flags=*/0, server1.host(), "GET",
 896                                 net_log_, callback_.callback()));
 897   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 898   EXPECT_TRUE(stream.get());
 899
 900   TestCompletionCallback callback;
 901   QuicStreamRequest request2(&factory_);
 902   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
 903                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 904                                  net_log_, callback_.callback()));
 905   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 906   EXPECT_TRUE(stream2.get());
 907
 908   EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
 909                 &factory_, server1, is_https_),
 910             QuicStreamFactoryPeer::GetActiveSession(
 911                 &factory_, server2, is_https_));
 912
 913   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 914   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 915 }
 916
 917 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
 918   MockRead reads[] = {
 919     MockRead(ASYNC, OK, 0)  // EOF
 920   };
 921   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 922   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 923   socket_factory_.AddSocketDataProvider(&socket_data1);
 924   socket_factory_.AddSocketDataProvider(&socket_data2);
 925   socket_data1.StopAfter(1);
 926   socket_data2.StopAfter(1);
 927
 928   HostPortPair server1("www.example.org", 443);
 929   HostPortPair server2("mail.example.org", 443);
 930   uint8 primary_pin = 1;
 931   uint8 backup_pin = 2;
 932   test::AddPin(&transport_security_state_, "mail.example.org", primary_pin,
 933                backup_pin);
 934
 935   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 936   verify_details.cert_verify_result.public_key_hashes.push_back(
 937       test::GetTestHashValue(primary_pin));
 938   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 939
 940   host_resolver_.set_synchronous_mode(true);
 941   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 942   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 943
 944   // Disable connection pooling.
 945   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 946
 947   QuicStreamRequest request(&factory_);
 948   is_https_ = true;
 949   EXPECT_EQ(OK, request.Request(server1, is_https_, privacy_mode_,
 950                                 /*cert_verify_flags=*/0, server1.host(), "GET",
 951                                 net_log_, callback_.callback()));
 952   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 953   EXPECT_TRUE(stream.get());
 954
 955   TestCompletionCallback callback;
 956   QuicStreamRequest request2(&factory_);
 957   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
 958                                  /*cert_verify_flags=*/0, server2.host(), "GET",
 959                                  net_log_, callback_.callback()));
 960   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 961   EXPECT_TRUE(stream2.get());
 962
 963   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 964                 &factory_, server1, is_https_),
 965             QuicStreamFactoryPeer::GetActiveSession(
 966                 &factory_, server2, is_https_));
 967
 968   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 969   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 970   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 971   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 972 }
 973
 974 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
 975   MockRead reads[] = {
 976     MockRead(ASYNC, OK, 0)  // EOF
 977   };
 978   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 979   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 980   socket_factory_.AddSocketDataProvider(&socket_data1);
 981   socket_factory_.AddSocketDataProvider(&socket_data2);
 982   socket_data1.StopAfter(1);
 983   socket_data2.StopAfter(1);
 984
 985   HostPortPair server1("www.example.org", 443);
 986   HostPortPair server2("mail.example.org", 443);
 987   uint8 primary_pin = 1;
 988   uint8 backup_pin = 2;
 989   uint8 bad_pin = 3;
 990   test::AddPin(&transport_security_state_, "mail.example.org", primary_pin,
 991                backup_pin);
 992
 993   ProofVerifyDetailsChromium verify_details1 = DefaultProofVerifyDetails();
 994   verify_details1.cert_verify_result.public_key_hashes.push_back(
 995       test::GetTestHashValue(bad_pin));
 996   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1);
 997
 998   ProofVerifyDetailsChromium verify_details2 = DefaultProofVerifyDetails();
 999   verify_details2.cert_verify_result.public_key_hashes.push_back(
1000       test::GetTestHashValue(primary_pin));
1001   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
1002
1003   host_resolver_.set_synchronous_mode(true);
1004   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
1005   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1006
1007   QuicStreamRequest request(&factory_);
1008   is_https_ = true;
1009   EXPECT_EQ(OK, request.Request(server1, is_https_, privacy_mode_,
1010                                 /*cert_verify_flags=*/0, server1.host(), "GET",
1011                                 net_log_, callback_.callback()));
1012   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1013   EXPECT_TRUE(stream.get());
1014
1015   TestCompletionCallback callback;
1016   QuicStreamRequest request2(&factory_);
1017   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
1018                                  /*cert_verify_flags=*/0, server2.host(), "GET",
1019                                  net_log_, callback_.callback()));
1020   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1021   EXPECT_TRUE(stream2.get());
1022
1023   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
1024                 &factory_, server1, is_https_),
1025             QuicStreamFactoryPeer::GetActiveSession(
1026                 &factory_, server2, is_https_));
1027
1028   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
1029   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
1030   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1031   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1032 }
1033
1034 TEST_P(QuicStreamFactoryTest, Goaway) {
1035   MockRead reads[] = {
1036     MockRead(ASYNC, OK, 0)  // EOF
1037   };
1038   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1039   socket_data.StopAfter(1);
1040   socket_factory_.AddSocketDataProvider(&socket_data);
1041   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
1042   socket_data2.StopAfter(1);
1043   socket_factory_.AddSocketDataProvider(&socket_data2);
1044
1045   QuicStreamRequest request(&factory_);
1046   EXPECT_EQ(ERR_IO_PENDING,
1047             request.Request(host_port_pair_, is_https_, privacy_mode_,
1048                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1049                             "GET", net_log_, callback_.callback()));
1050
1051   EXPECT_EQ(OK, callback_.WaitForResult());
1052   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1053   EXPECT_TRUE(stream.get());
1054
1055   // Mark the session as going away.  Ensure that while it is still alive
1056   // that it is no longer active.
1057   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
1058       &factory_, host_port_pair_, is_https_);
1059   factory_.OnSessionGoingAway(session);
1060   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
1061   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
1062       &factory_, host_port_pair_, is_https_));
1063   EXPECT_FALSE(HasActiveSession(host_port_pair_));
1064
1065   // Create a new request for the same destination and verify that a
1066   // new session is created.
1067   QuicStreamRequest request2(&factory_);
1068   EXPECT_EQ(ERR_IO_PENDING,
1069             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1070                              /*cert_verify_flags=*/0, host_port_pair_.host(),
1071                              "GET", net_log_, callback_.callback()));
1072   EXPECT_EQ(OK, callback_.WaitForResult());
1073   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1074   EXPECT_TRUE(stream2.get());
1075
1076   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_,
1077                                                       host_port_pair_,
1078                                                       is_https_));
1079   EXPECT_NE(session,
1080             QuicStreamFactoryPeer::GetActiveSession(
1081                 &factory_, host_port_pair_, is_https_));
1082   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
1083
1084   stream2.reset();
1085   stream.reset();
1086
1087   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1088   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1089   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1090   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1091 }
1092
1093 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
1094   MockRead reads[] = {
1095     MockRead(ASYNC, OK, 0)  // EOF
1096   };
1097   QuicStreamId stream_id = kClientDataStreamId1;
1098   scoped_ptr<QuicEncryptedPacket> rst(
1099       maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED));
1100   MockWrite writes[] = {
1101     MockWrite(ASYNC, rst->data(), rst->length(), 1),
1102   };
1103   DeterministicSocketData socket_data(reads, arraysize(reads),
1104                                       writes, arraysize(writes));
1105   socket_factory_.AddSocketDataProvider(&socket_data);
1106   socket_data.StopAfter(1);
1107
1108   HttpRequestInfo request_info;
1109   std::vector<QuicHttpStream*> streams;
1110   // The MockCryptoClientStream sets max_open_streams to be
1111   // kDefaultMaxStreamsPerConnection / 2.
1112   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) {
1113     QuicStreamRequest request(&factory_);
1114     int rv = request.Request(host_port_pair_, is_https_, privacy_mode_,
1115                              /*cert_verify_flags=*/0, host_port_pair_.host(),
1116                              "GET", net_log_, callback_.callback());
1117     if (i == 0) {
1118       EXPECT_EQ(ERR_IO_PENDING, rv);
1119       EXPECT_EQ(OK, callback_.WaitForResult());
1120     } else {
1121       EXPECT_EQ(OK, rv);
1122     }
1123     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1124     EXPECT_TRUE(stream);
1125     EXPECT_EQ(OK, stream->InitializeStream(
1126         &request_info, DEFAULT_PRIORITY, net_log_, CompletionCallback()));
1127     streams.push_back(stream.release());
1128   }
1129
1130   QuicStreamRequest request(&factory_);
1131   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1132                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
1133                                 "GET", net_log_, CompletionCallback()));
1134   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1135   EXPECT_TRUE(stream);
1136   EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream(
1137         &request_info, DEFAULT_PRIORITY, net_log_, callback_.callback()));
1138
1139   // Close the first stream.
1140   streams.front()->Close(false);
1141
1142   ASSERT_TRUE(callback_.have_result());
1143
1144   EXPECT_EQ(OK, callback_.WaitForResult());
1145
1146   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1147   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1148   STLDeleteElements(&streams);
1149 }
1150
1151 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
1152   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
1153   socket_factory_.AddSocketDataProvider(&socket_data);
1154
1155   host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
1156
1157   QuicStreamRequest request(&factory_);
1158   EXPECT_EQ(ERR_IO_PENDING,
1159             request.Request(host_port_pair_, is_https_, privacy_mode_,
1160                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1161                             "GET", net_log_, callback_.callback()));
1162
1163   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
1164
1165   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1166   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1167 }
1168
1169 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
1170   MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
1171   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
1172   socket_data.set_connect_data(connect);
1173   socket_factory_.AddSocketDataProvider(&socket_data);
1174   socket_data.StopAfter(1);
1175
1176   QuicStreamRequest request(&factory_);
1177   EXPECT_EQ(ERR_IO_PENDING,
1178             request.Request(host_port_pair_, is_https_, privacy_mode_,
1179                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1180                             "GET", net_log_, callback_.callback()));
1181
1182   EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult());
1183
1184   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1185   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1186 }
1187
1188 TEST_P(QuicStreamFactoryTest, CancelCreate) {
1189   MockRead reads[] = {
1190     MockRead(ASYNC, OK, 0)  // EOF
1191   };
1192   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1193   socket_factory_.AddSocketDataProvider(&socket_data);
1194   {
1195     QuicStreamRequest request(&factory_);
1196     EXPECT_EQ(ERR_IO_PENDING,
1197               request.Request(host_port_pair_, is_https_, privacy_mode_,
1198                               /*cert_verify_flags=*/0, host_port_pair_.host(),
1199                               "GET", net_log_, callback_.callback()));
1200   }
1201
1202   socket_data.StopAfter(1);
1203   base::RunLoop run_loop;
1204   run_loop.RunUntilIdle();
1205
1206   scoped_ptr<QuicHttpStream> stream(CreateFromSession(host_port_pair_));
1207   EXPECT_TRUE(stream.get());
1208   stream.reset();
1209
1210   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1211   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1212 }
1213
1214 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
1215   // Sequentially connect to the default host, then another host, and then the
1216   // default host.  Verify that the default host gets a consistent ephemeral
1217   // port, that is different from the other host's connection.
1218
1219   std::string other_server_name = "other.google.com";
1220   EXPECT_NE(kDefaultServerHostName, other_server_name);
1221   HostPortPair host_port_pair2(other_server_name, kDefaultServerPort);
1222
1223   int original_port = GetSourcePortForNewSession(host_port_pair_);
1224   EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair2));
1225   EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_));
1226 }
1227
1228 TEST_P(QuicStreamFactoryTest, GoAwayDisablesConsistentEphemeralPort) {
1229   // Get a session to the host using the port suggester.
1230   int original_port =
1231       GetSourcePortForNewSessionAndGoAway(host_port_pair_);
1232   // Verify that the port is different after the goaway.
1233   EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair_));
1234   // Since the previous session did not goaway we should see the original port.
1235   EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_));
1236 }
1237
1238 TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
1239   MockRead reads[] = {
1240     MockRead(ASYNC, 0, 0)  // EOF
1241   };
1242   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1243   std::vector<MockWrite> writes;
1244   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1245   DeterministicSocketData socket_data(reads, arraysize(reads),
1246                                       writes.empty() ? nullptr  : &writes[0],
1247                                       writes.size());
1248   socket_factory_.AddSocketDataProvider(&socket_data);
1249   socket_data.StopAfter(1);
1250
1251   MockRead reads2[] = {
1252     MockRead(ASYNC, 0, 0)  // EOF
1253   };
1254   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1255   socket_factory_.AddSocketDataProvider(&socket_data2);
1256   socket_data2.StopAfter(1);
1257
1258   QuicStreamRequest request(&factory_);
1259   EXPECT_EQ(ERR_IO_PENDING,
1260             request.Request(host_port_pair_, is_https_, privacy_mode_,
1261                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1262                             "GET", net_log_, callback_.callback()));
1263
1264   EXPECT_EQ(OK, callback_.WaitForResult());
1265   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1266   HttpRequestInfo request_info;
1267   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1268                                          DEFAULT_PRIORITY,
1269                                          net_log_, CompletionCallback()));
1270
1271   // Close the session and verify that stream saw the error.
1272   factory_.CloseAllSessions(ERR_INTERNET_DISCONNECTED);
1273   EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
1274             stream->ReadResponseHeaders(callback_.callback()));
1275
1276   // Now attempting to request a stream to the same origin should create
1277   // a new session.
1278
1279   QuicStreamRequest request2(&factory_);
1280   EXPECT_EQ(ERR_IO_PENDING,
1281             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1282                              /*cert_verify_flags=*/0, host_port_pair_.host(),
1283                              "GET", net_log_, callback_.callback()));
1284
1285   EXPECT_EQ(OK, callback_.WaitForResult());
1286   stream = request2.ReleaseStream();
1287   stream.reset();  // Will reset stream 3.
1288
1289   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1290   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1291   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1292   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1293 }
1294
1295 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
1296   MockRead reads[] = {
1297     MockRead(ASYNC, 0, 0)  // EOF
1298   };
1299   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1300   std::vector<MockWrite> writes;
1301   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1302   DeterministicSocketData socket_data(reads, arraysize(reads),
1303                                       writes.empty() ? nullptr  : &writes[0],
1304                                       writes.size());
1305   socket_factory_.AddSocketDataProvider(&socket_data);
1306   socket_data.StopAfter(1);
1307
1308   MockRead reads2[] = {
1309     MockRead(ASYNC, 0, 0)  // EOF
1310   };
1311   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1312   socket_factory_.AddSocketDataProvider(&socket_data2);
1313   socket_data2.StopAfter(1);
1314
1315   QuicStreamRequest request(&factory_);
1316   EXPECT_EQ(ERR_IO_PENDING,
1317             request.Request(host_port_pair_, is_https_, privacy_mode_,
1318                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1319                             "GET", net_log_, callback_.callback()));
1320
1321   EXPECT_EQ(OK, callback_.WaitForResult());
1322   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1323   HttpRequestInfo request_info;
1324   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1325                                          DEFAULT_PRIORITY,
1326                                          net_log_, CompletionCallback()));
1327
1328   // Change the IP address and verify that stream saw the error.
1329   factory_.OnIPAddressChanged();
1330   EXPECT_EQ(ERR_NETWORK_CHANGED,
1331             stream->ReadResponseHeaders(callback_.callback()));
1332   EXPECT_TRUE(factory_.require_confirmation());
1333
1334   // Now attempting to request a stream to the same origin should create
1335   // a new session.
1336
1337   QuicStreamRequest request2(&factory_);
1338   EXPECT_EQ(ERR_IO_PENDING,
1339             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1340                              /*cert_verify_flags=*/0, host_port_pair_.host(),
1341                              "GET", net_log_, callback_.callback()));
1342
1343   EXPECT_EQ(OK, callback_.WaitForResult());
1344   stream = request2.ReleaseStream();
1345   stream.reset();  // Will reset stream 3.
1346
1347   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1348   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1349   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1350   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1351 }
1352
1353 TEST_P(QuicStreamFactoryTest, OnSSLConfigChanged) {
1354   MockRead reads[] = {
1355       MockRead(ASYNC, 0, 0)  // EOF
1356   };
1357   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1358   std::vector<MockWrite> writes;
1359   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1360   DeterministicSocketData socket_data(reads, arraysize(reads),
1361                                       writes.empty() ? nullptr : &writes[0],
1362                                       writes.size());
1363   socket_factory_.AddSocketDataProvider(&socket_data);
1364   socket_data.StopAfter(1);
1365
1366   MockRead reads2[] = {
1367       MockRead(ASYNC, 0, 0)  // EOF
1368   };
1369   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1370   socket_factory_.AddSocketDataProvider(&socket_data2);
1371   socket_data2.StopAfter(1);
1372
1373   QuicStreamRequest request(&factory_);
1374   EXPECT_EQ(ERR_IO_PENDING,
1375             request.Request(host_port_pair_, is_https_, privacy_mode_,
1376                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1377                             "GET", net_log_, callback_.callback()));
1378
1379   EXPECT_EQ(OK, callback_.WaitForResult());
1380   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1381   HttpRequestInfo request_info;
1382   EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1383                                          net_log_, CompletionCallback()));
1384
1385   factory_.OnSSLConfigChanged();
1386   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
1387             stream->ReadResponseHeaders(callback_.callback()));
1388   EXPECT_FALSE(factory_.require_confirmation());
1389
1390   // Now attempting to request a stream to the same origin should create
1391   // a new session.
1392
1393   QuicStreamRequest request2(&factory_);
1394   EXPECT_EQ(ERR_IO_PENDING,
1395             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1396                              /*cert_verify_flags=*/0, host_port_pair_.host(),
1397                              "GET", net_log_, callback_.callback()));
1398
1399   EXPECT_EQ(OK, callback_.WaitForResult());
1400   stream = request2.ReleaseStream();
1401   stream.reset();  // Will reset stream 3.
1402
1403   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1404   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1405   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1406   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1407 }
1408
1409 TEST_P(QuicStreamFactoryTest, OnCertAdded) {
1410   MockRead reads[] = {
1411     MockRead(ASYNC, 0, 0)  // EOF
1412   };
1413   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1414   std::vector<MockWrite> writes;
1415   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1416   DeterministicSocketData socket_data(reads, arraysize(reads),
1417                                       writes.empty() ? nullptr  : &writes[0],
1418                                       writes.size());
1419   socket_factory_.AddSocketDataProvider(&socket_data);
1420   socket_data.StopAfter(1);
1421
1422   MockRead reads2[] = {
1423     MockRead(ASYNC, 0, 0)  // EOF
1424   };
1425   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1426   socket_factory_.AddSocketDataProvider(&socket_data2);
1427   socket_data2.StopAfter(1);
1428
1429   QuicStreamRequest request(&factory_);
1430   EXPECT_EQ(ERR_IO_PENDING,
1431             request.Request(host_port_pair_, is_https_, privacy_mode_,
1432                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1433                             "GET", net_log_, callback_.callback()));
1434
1435   EXPECT_EQ(OK, callback_.WaitForResult());
1436   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1437   HttpRequestInfo request_info;
1438   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1439                                          DEFAULT_PRIORITY,
1440                                          net_log_, CompletionCallback()));
1441
1442   // Add a cert and verify that stream saw the event.
1443   factory_.OnCertAdded(nullptr);
1444   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
1445             stream->ReadResponseHeaders(callback_.callback()));
1446   EXPECT_FALSE(factory_.require_confirmation());
1447
1448   // Now attempting to request a stream to the same origin should create
1449   // a new session.
1450
1451   QuicStreamRequest request2(&factory_);
1452   EXPECT_EQ(ERR_IO_PENDING,
1453             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1454                              /*cert_verify_flags=*/0, host_port_pair_.host(),
1455                              "GET", net_log_, callback_.callback()));
1456
1457   EXPECT_EQ(OK, callback_.WaitForResult());
1458   stream = request2.ReleaseStream();
1459   stream.reset();  // Will reset stream 3.
1460
1461   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1462   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1463   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1464   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1465 }
1466
1467 TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
1468   MockRead reads[] = {
1469     MockRead(ASYNC, 0, 0)  // EOF
1470   };
1471   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1472   std::vector<MockWrite> writes;
1473   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1474   DeterministicSocketData socket_data(reads, arraysize(reads),
1475                                       writes.empty() ? nullptr  : &writes[0],
1476                                       writes.size());
1477   socket_factory_.AddSocketDataProvider(&socket_data);
1478   socket_data.StopAfter(1);
1479
1480   MockRead reads2[] = {
1481     MockRead(ASYNC, 0, 0)  // EOF
1482   };
1483   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1484   socket_factory_.AddSocketDataProvider(&socket_data2);
1485   socket_data2.StopAfter(1);
1486
1487   QuicStreamRequest request(&factory_);
1488   EXPECT_EQ(ERR_IO_PENDING,
1489             request.Request(host_port_pair_, is_https_, privacy_mode_,
1490                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1491                             "GET", net_log_, callback_.callback()));
1492
1493   EXPECT_EQ(OK, callback_.WaitForResult());
1494   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1495   HttpRequestInfo request_info;
1496   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1497                                          DEFAULT_PRIORITY,
1498                                          net_log_, CompletionCallback()));
1499
1500   // Change the CA cert and verify that stream saw the event.
1501   factory_.OnCACertChanged(nullptr);
1502   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
1503             stream->ReadResponseHeaders(callback_.callback()));
1504   EXPECT_FALSE(factory_.require_confirmation());
1505
1506   // Now attempting to request a stream to the same origin should create
1507   // a new session.
1508
1509   QuicStreamRequest request2(&factory_);
1510   EXPECT_EQ(ERR_IO_PENDING,
1511             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1512                              /*cert_verify_flags=*/0, host_port_pair_.host(),
1513                              "GET", net_log_, callback_.callback()));
1514
1515   EXPECT_EQ(OK, callback_.WaitForResult());
1516   stream = request2.ReleaseStream();
1517   stream.reset();  // Will reset stream 3.
1518
1519   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1520   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1521   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1522   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1523 }
1524
1525 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
1526   vector<string> cannoncial_suffixes;
1527   cannoncial_suffixes.push_back(string(".c.youtube.com"));
1528   cannoncial_suffixes.push_back(string(".googlevideo.com"));
1529
1530   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
1531     string r1_host_name("r1");
1532     string r2_host_name("r2");
1533     r1_host_name.append(cannoncial_suffixes[i]);
1534     r2_host_name.append(cannoncial_suffixes[i]);
1535
1536     HostPortPair host_port_pair1(r1_host_name, 80);
1537     QuicCryptoClientConfig* crypto_config =
1538         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
1539     QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_);
1540     QuicCryptoClientConfig::CachedState* cached1 =
1541         crypto_config->LookupOrCreate(server_id1);
1542     EXPECT_FALSE(cached1->proof_valid());
1543     EXPECT_TRUE(cached1->source_address_token().empty());
1544
1545     // Mutate the cached1 to have different data.
1546     // TODO(rtenneti): mutate other members of CachedState.
1547     cached1->set_source_address_token(r1_host_name);
1548     cached1->SetProofValid();
1549
1550     HostPortPair host_port_pair2(r2_host_name, 80);
1551     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
1552     QuicCryptoClientConfig::CachedState* cached2 =
1553         crypto_config->LookupOrCreate(server_id2);
1554     EXPECT_EQ(cached1->source_address_token(), cached2->source_address_token());
1555     EXPECT_TRUE(cached2->proof_valid());
1556   }
1557 }
1558
1559 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
1560   vector<string> cannoncial_suffixes;
1561   cannoncial_suffixes.push_back(string(".c.youtube.com"));
1562   cannoncial_suffixes.push_back(string(".googlevideo.com"));
1563
1564   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
1565     string r3_host_name("r3");
1566     string r4_host_name("r4");
1567     r3_host_name.append(cannoncial_suffixes[i]);
1568     r4_host_name.append(cannoncial_suffixes[i]);
1569
1570     HostPortPair host_port_pair1(r3_host_name, 80);
1571     QuicCryptoClientConfig* crypto_config =
1572         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
1573     QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_);
1574     QuicCryptoClientConfig::CachedState* cached1 =
1575         crypto_config->LookupOrCreate(server_id1);
1576     EXPECT_FALSE(cached1->proof_valid());
1577     EXPECT_TRUE(cached1->source_address_token().empty());
1578
1579     // Mutate the cached1 to have different data.
1580     // TODO(rtenneti): mutate other members of CachedState.
1581     cached1->set_source_address_token(r3_host_name);
1582     cached1->SetProofInvalid();
1583
1584     HostPortPair host_port_pair2(r4_host_name, 80);
1585     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
1586     QuicCryptoClientConfig::CachedState* cached2 =
1587         crypto_config->LookupOrCreate(server_id2);
1588     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
1589     EXPECT_TRUE(cached2->source_address_token().empty());
1590     EXPECT_FALSE(cached2->proof_valid());
1591   }
1592 }
1593
1594 TEST_P(QuicStreamFactoryTest, RacingConnections) {
1595   if (!GetParam().enable_connection_racing)
1596     return;
1597   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1598   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1599   MockRead reads[] = {
1600       MockRead(ASYNC, OK, 0)  // EOF
1601   };
1602   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1603   socket_factory_.AddSocketDataProvider(&socket_data);
1604   socket_data.StopAfter(1);
1605
1606   MockRead reads2[] = {
1607       MockRead(ASYNC, 0, 0)  // EOF
1608   };
1609   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1610   socket_factory_.AddSocketDataProvider(&socket_data2);
1611   socket_data2.StopAfter(1);
1612
1613   crypto_client_stream_factory_.set_handshake_mode(
1614       MockCryptoClientStream::ZERO_RTT);
1615   host_resolver_.set_synchronous_mode(true);
1616   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1617                                            "192.168.0.1", "");
1618
1619   QuicStreamRequest request(&factory_);
1620   QuicServerId server_id(host_port_pair_, is_https_, privacy_mode_);
1621   EXPECT_EQ(ERR_IO_PENDING,
1622             request.Request(host_port_pair_, is_https_, privacy_mode_,
1623                             /*cert_verify_flags=*/0, host_port_pair_.host(),
1624                             "GET", net_log_, callback_.callback()));
1625   EXPECT_EQ(2u,
1626             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
1627
1628   runner_->RunNextTask();
1629
1630   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1631   EXPECT_TRUE(stream.get());
1632   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1633   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1634   EXPECT_EQ(0u,
1635             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
1636 }
1637
1638 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
1639   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1640   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1641   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1642
1643   MockRead reads[] = {
1644       MockRead(ASYNC, OK, 0)  // EOF
1645   };
1646   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1647   socket_factory_.AddSocketDataProvider(&socket_data);
1648   socket_data.StopAfter(1);
1649
1650   crypto_client_stream_factory_.set_handshake_mode(
1651       MockCryptoClientStream::ZERO_RTT);
1652   host_resolver_.set_synchronous_mode(true);
1653   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1654                                            "192.168.0.1", "");
1655
1656   QuicStreamRequest request(&factory_);
1657   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1658                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
1659                                 "GET", net_log_, callback_.callback()));
1660
1661   // If we are waiting for disk cache, we would have posted a task. Verify that
1662   // the CancelWaitForDataReady task hasn't been posted.
1663   ASSERT_EQ(0u, runner_->GetPostedTasks().size());
1664
1665   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1666   EXPECT_TRUE(stream.get());
1667   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1668   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1669 }
1670
1671 TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
1672   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1673   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1674   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1675   QuicStreamFactoryPeer::SetMaxNumberOfLossyConnections(&factory_, 2);
1676   EXPECT_FALSE(
1677       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1678   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1679                    &factory_, host_port_pair_.port()));
1680
1681   MockRead reads[] = {
1682       MockRead(ASYNC, OK, 0)  // EOF
1683   };
1684   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1685   socket_factory_.AddSocketDataProvider(&socket_data);
1686   socket_data.StopAfter(1);
1687
1688   DeterministicSocketData socket_data2(nullptr, 0, nullptr, 0);
1689   socket_factory_.AddSocketDataProvider(&socket_data2);
1690   socket_data2.StopAfter(1);
1691
1692   DeterministicSocketData socket_data3(nullptr, 0, nullptr, 0);
1693   socket_factory_.AddSocketDataProvider(&socket_data3);
1694   socket_data3.StopAfter(1);
1695
1696   DeterministicSocketData socket_data4(nullptr, 0, nullptr, 0);
1697   socket_factory_.AddSocketDataProvider(&socket_data4);
1698   socket_data4.StopAfter(1);
1699
1700   HostPortPair server2("mail.example.org", kDefaultServerPort);
1701   HostPortPair server3("docs.example.org", kDefaultServerPort);
1702   HostPortPair server4("images.example.org", kDefaultServerPort);
1703
1704   crypto_client_stream_factory_.set_handshake_mode(
1705       MockCryptoClientStream::ZERO_RTT);
1706   host_resolver_.set_synchronous_mode(true);
1707   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1708                                            "192.168.0.1", "");
1709   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1710   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
1711   host_resolver_.rules()->AddIPLiteralRule(server4.host(), "192.168.0.1", "");
1712
1713   QuicStreamRequest request(&factory_);
1714   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1715                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
1716                                 "GET", net_log_, callback_.callback()));
1717
1718   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
1719       &factory_, host_port_pair_, is_https_);
1720
1721   DVLOG(1) << "Create 1st session and test packet loss";
1722
1723   // Set packet_loss_rate to a lower value than packet_loss_threshold.
1724   EXPECT_FALSE(
1725       factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/0.9f));
1726   EXPECT_TRUE(session->connection()->connected());
1727   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
1728       &factory_, host_port_pair_, is_https_));
1729   EXPECT_FALSE(
1730       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1731   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1732                    &factory_, host_port_pair_.port()));
1733
1734   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
1735   // and that shouldn't close the session and it shouldn't disable QUIC.
1736   EXPECT_FALSE(
1737       factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/1.0f));
1738   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1739                    &factory_, host_port_pair_.port()));
1740   EXPECT_TRUE(session->connection()->connected());
1741   EXPECT_FALSE(
1742       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1743   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
1744       &factory_, host_port_pair_, is_https_));
1745
1746   // Test N-in-a-row high packet loss connections.
1747
1748   DVLOG(1) << "Create 2nd session and test packet loss";
1749
1750   TestCompletionCallback callback2;
1751   QuicStreamRequest request2(&factory_);
1752   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
1753                                  /*cert_verify_flags=*/0, server2.host(), "GET",
1754                                  net_log_, callback2.callback()));
1755   QuicChromiumClientSession* session2 =
1756       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
1757
1758   // If there is no packet loss during handshake confirmation, number of lossy
1759   // connections for the port should be 0.
1760   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1761                    &factory_, server2.port()));
1762   EXPECT_FALSE(
1763       factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/0.9f));
1764   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1765                    &factory_, server2.port()));
1766   EXPECT_FALSE(
1767       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
1768
1769   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
1770   // and that shouldn't close the session and it shouldn't disable QUIC.
1771   EXPECT_FALSE(
1772       factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/1.0f));
1773   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1774                    &factory_, server2.port()));
1775   EXPECT_TRUE(session2->connection()->connected());
1776   EXPECT_FALSE(
1777       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
1778   EXPECT_TRUE(
1779       QuicStreamFactoryPeer::HasActiveSession(&factory_, server2, is_https_));
1780
1781   DVLOG(1) << "Create 3rd session which also has packet loss";
1782
1783   TestCompletionCallback callback3;
1784   QuicStreamRequest request3(&factory_);
1785   EXPECT_EQ(OK, request3.Request(server3, is_https_, privacy_mode_,
1786                                  /*cert_verify_flags=*/0, server3.host(), "GET",
1787                                  net_log_, callback3.callback()));
1788   QuicChromiumClientSession* session3 =
1789       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
1790
1791   DVLOG(1) << "Create 4th session with packet loss and test IsQuicDisabled()";
1792   TestCompletionCallback callback4;
1793   QuicStreamRequest request4(&factory_);
1794   EXPECT_EQ(OK, request4.Request(server4, is_https_, privacy_mode_,
1795                                  /*cert_verify_flags=*/0, server4.host(), "GET",
1796                                  net_log_, callback4.callback()));
1797   QuicChromiumClientSession* session4 =
1798       QuicStreamFactoryPeer::GetActiveSession(&factory_, server4, is_https_);
1799
1800   // Set packet_loss_rate to higher value than packet_loss_threshold 2nd time in
1801   // a row and that should close the session and disable QUIC.
1802   EXPECT_TRUE(
1803       factory_.OnHandshakeConfirmed(session3, /*packet_loss_rate=*/1.0f));
1804   EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1805                    &factory_, server3.port()));
1806   EXPECT_FALSE(session3->connection()->connected());
1807   EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server3.port()));
1808   EXPECT_FALSE(
1809       QuicStreamFactoryPeer::HasActiveSession(&factory_, server3, is_https_));
1810   EXPECT_FALSE(HasActiveSession(server3));
1811
1812   // Set packet_loss_rate to higher value than packet_loss_threshold 3rd time in
1813   // a row and IsQuicDisabled() should close the session.
1814   EXPECT_TRUE(
1815       factory_.OnHandshakeConfirmed(session4, /*packet_loss_rate=*/1.0f));
1816   EXPECT_EQ(3, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1817                    &factory_, server4.port()));
1818   EXPECT_FALSE(session4->connection()->connected());
1819   EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server4.port()));
1820   EXPECT_FALSE(
1821       QuicStreamFactoryPeer::HasActiveSession(&factory_, server4, is_https_));
1822   EXPECT_FALSE(HasActiveSession(server4));
1823
1824   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1825   EXPECT_TRUE(stream.get());
1826   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1827   EXPECT_TRUE(stream2.get());
1828   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
1829   EXPECT_TRUE(stream3.get());
1830   scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream();
1831   EXPECT_TRUE(stream4.get());
1832   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1833   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1834   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1835   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1836   EXPECT_TRUE(socket_data3.AllReadDataConsumed());
1837   EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
1838   EXPECT_TRUE(socket_data4.AllReadDataConsumed());
1839   EXPECT_TRUE(socket_data4.AllWriteDataConsumed());
1840 }
1841
1842 TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfTwo) {
1843   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1844   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1845   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1846   QuicStreamFactoryPeer::SetThresholdPublicResetsPostHandshake(&factory_, 2);
1847   EXPECT_FALSE(
1848       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1849   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1850                    &factory_, host_port_pair_.port()));
1851
1852   MockRead reads[] = {
1853       MockRead(ASYNC, OK, 0)  // EOF
1854   };
1855   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1856   socket_factory_.AddSocketDataProvider(&socket_data);
1857   socket_data.StopAfter(1);
1858
1859   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
1860   socket_factory_.AddSocketDataProvider(&socket_data2);
1861   socket_data2.StopAfter(1);
1862
1863   HostPortPair server2("mail.example.org", kDefaultServerPort);
1864
1865   crypto_client_stream_factory_.set_handshake_mode(
1866       MockCryptoClientStream::CONFIRM_HANDSHAKE);
1867   host_resolver_.set_synchronous_mode(true);
1868   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1869                                            "192.168.0.1", "");
1870   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1871
1872   QuicStreamRequest request(&factory_);
1873   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1874                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
1875                                 "GET", net_log_, callback_.callback()));
1876
1877   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
1878       &factory_, host_port_pair_, is_https_);
1879
1880   DVLOG(1) << "Created 1st session. Now trigger public reset post handshake";
1881   session->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
1882   // Need to spin the loop now to ensure that
1883   // QuicStreamFactory::OnSessionClosed() runs.
1884   base::RunLoop run_loop;
1885   run_loop.RunUntilIdle();
1886
1887   EXPECT_EQ(1,
1888             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
1889   EXPECT_FALSE(
1890       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1891
1892   // Test two-in-a-row public reset post handshakes..
1893   DVLOG(1) << "Create 2nd session and trigger public reset post handshake";
1894   TestCompletionCallback callback2;
1895   QuicStreamRequest request2(&factory_);
1896   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
1897                                  /*cert_verify_flags=*/0, server2.host(), "GET",
1898                                  net_log_, callback2.callback()));
1899   QuicChromiumClientSession* session2 =
1900       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
1901
1902   session2->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
1903   // Need to spin the loop now to ensure that
1904   // QuicStreamFactory::OnSessionClosed() runs.
1905   base::RunLoop run_loop2;
1906   run_loop2.RunUntilIdle();
1907   EXPECT_EQ(2,
1908             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
1909   EXPECT_TRUE(
1910       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1911   EXPECT_EQ(
1912       QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
1913       factory_.QuicDisabledReason(host_port_pair_.port()));
1914
1915   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1916   EXPECT_TRUE(stream.get());
1917   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1918   EXPECT_TRUE(stream2.get());
1919   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1920   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1921   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1922   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1923 }
1924
1925 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfTwo) {
1926   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1927   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1928   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1929   QuicStreamFactoryPeer::SetThresholdTimeoutsWithOpenStreams(&factory_, 2);
1930   EXPECT_FALSE(
1931       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1932   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1933                    &factory_, host_port_pair_.port()));
1934
1935   MockRead reads[] = {
1936       MockRead(ASYNC, OK, 0)  // EOF
1937   };
1938   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1939   socket_factory_.AddSocketDataProvider(&socket_data);
1940   socket_data.StopAfter(1);
1941
1942   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
1943   socket_factory_.AddSocketDataProvider(&socket_data2);
1944   socket_data2.StopAfter(1);
1945
1946   HostPortPair server2("mail.example.org", kDefaultServerPort);
1947
1948   crypto_client_stream_factory_.set_handshake_mode(
1949       MockCryptoClientStream::CONFIRM_HANDSHAKE);
1950   host_resolver_.set_synchronous_mode(true);
1951   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1952                                            "192.168.0.1", "");
1953   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1954
1955   QuicStreamRequest request(&factory_);
1956   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1957                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
1958                                 "GET", net_log_, callback_.callback()));
1959
1960   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
1961       &factory_, host_port_pair_, is_https_);
1962
1963   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1964   EXPECT_TRUE(stream.get());
1965   HttpRequestInfo request_info;
1966   EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
1967                                          net_log_, CompletionCallback()));
1968
1969   DVLOG(1)
1970       << "Created 1st session and initialized a stream. Now trigger timeout";
1971   session->connection()->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
1972   // Need to spin the loop now to ensure that
1973   // QuicStreamFactory::OnSessionClosed() runs.
1974   base::RunLoop run_loop;
1975   run_loop.RunUntilIdle();
1976
1977   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
1978   EXPECT_FALSE(
1979       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1980
1981   // Test two-in-a-row timeouts with open streams.
1982   DVLOG(1) << "Create 2nd session and timeout with open stream";
1983   TestCompletionCallback callback2;
1984   QuicStreamRequest request2(&factory_);
1985   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
1986                                  /*cert_verify_flags=*/0, server2.host(), "GET",
1987                                  net_log_, callback2.callback()));
1988   QuicChromiumClientSession* session2 =
1989       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
1990
1991   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1992   EXPECT_TRUE(stream2.get());
1993   EXPECT_EQ(OK, stream2->InitializeStream(&request_info, DEFAULT_PRIORITY,
1994                                           net_log_, CompletionCallback()));
1995
1996   session2->connection()->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
1997   // Need to spin the loop now to ensure that
1998   // QuicStreamFactory::OnSessionClosed() runs.
1999   base::RunLoop run_loop2;
2000   run_loop2.RunUntilIdle();
2001   EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2002   EXPECT_TRUE(
2003       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2004   EXPECT_EQ(QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS,
2005             factory_.QuicDisabledReason(host_port_pair_.port()));
2006
2007   EXPECT_TRUE(socket_data.AllReadDataConsumed());
2008   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2009   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2010   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2011 }
2012
2013 TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfThree) {
2014   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
2015   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
2016   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
2017   QuicStreamFactoryPeer::SetThresholdPublicResetsPostHandshake(&factory_, 2);
2018   EXPECT_FALSE(
2019       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2020   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
2021                    &factory_, host_port_pair_.port()));
2022
2023   MockRead reads[] = {
2024       MockRead(ASYNC, OK, 0)  // EOF
2025   };
2026   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
2027   socket_factory_.AddSocketDataProvider(&socket_data);
2028   socket_data.StopAfter(1);
2029
2030   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
2031   socket_factory_.AddSocketDataProvider(&socket_data2);
2032   socket_data2.StopAfter(1);
2033
2034   DeterministicSocketData socket_data3(reads, arraysize(reads), nullptr, 0);
2035   socket_factory_.AddSocketDataProvider(&socket_data3);
2036   socket_data3.StopAfter(1);
2037
2038   HostPortPair server2("mail.example.org", kDefaultServerPort);
2039   HostPortPair server3("docs.example.org", kDefaultServerPort);
2040
2041   crypto_client_stream_factory_.set_handshake_mode(
2042       MockCryptoClientStream::CONFIRM_HANDSHAKE);
2043   host_resolver_.set_synchronous_mode(true);
2044   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
2045                                            "192.168.0.1", "");
2046   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
2047   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
2048
2049   // Test first and third out of three public reset post handshakes.
2050   QuicStreamRequest request(&factory_);
2051   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
2052                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
2053                                 "GET", net_log_, callback_.callback()));
2054
2055   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
2056       &factory_, host_port_pair_, is_https_);
2057
2058   DVLOG(1) << "Created 1st session. Now trigger public reset post handshake";
2059   session->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
2060   // Need to spin the loop now to ensure that
2061   // QuicStreamFactory::OnSessionClosed() runs.
2062   base::RunLoop run_loop;
2063   run_loop.RunUntilIdle();
2064
2065   EXPECT_EQ(1,
2066             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
2067   EXPECT_FALSE(
2068       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2069
2070   DVLOG(1) << "Create 2nd session without disable trigger";
2071   TestCompletionCallback callback2;
2072   QuicStreamRequest request2(&factory_);
2073   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
2074                                  /*cert_verify_flags=*/0, server2.host(), "GET",
2075                                  net_log_, callback2.callback()));
2076   QuicChromiumClientSession* session2 =
2077       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
2078
2079   session2->connection()->CloseConnection(QUIC_NO_ERROR, false);
2080   // Need to spin the loop now to ensure that
2081   // QuicStreamFactory::OnSessionClosed() runs.
2082   base::RunLoop run_loop2;
2083   run_loop2.RunUntilIdle();
2084   EXPECT_EQ(1,
2085             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
2086   EXPECT_FALSE(
2087       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2088
2089   DVLOG(1) << "Create 3rd session with public reset post handshake,"
2090            << " will disable QUIC";
2091   TestCompletionCallback callback3;
2092   QuicStreamRequest request3(&factory_);
2093   EXPECT_EQ(OK, request3.Request(server3, is_https_, privacy_mode_,
2094                                  /*cert_verify_flags=*/0, server3.host(), "GET",
2095                                  net_log_, callback3.callback()));
2096   QuicChromiumClientSession* session3 =
2097       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
2098
2099   session3->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
2100   // Need to spin the loop now to ensure that
2101   // QuicStreamFactory::OnSessionClosed() runs.
2102   base::RunLoop run_loop3;
2103   run_loop3.RunUntilIdle();
2104   EXPECT_EQ(2,
2105             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
2106   EXPECT_TRUE(
2107       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2108   EXPECT_EQ(
2109       QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE,
2110       factory_.QuicDisabledReason(host_port_pair_.port()));
2111
2112   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
2113   EXPECT_TRUE(stream.get());
2114   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
2115   EXPECT_TRUE(stream2.get());
2116   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
2117   EXPECT_TRUE(stream3.get());
2118
2119   EXPECT_TRUE(socket_data.AllReadDataConsumed());
2120   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2121   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2122   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2123   EXPECT_TRUE(socket_data3.AllReadDataConsumed());
2124   EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
2125 }
2126
2127 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfThree) {
2128   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
2129   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
2130   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
2131   QuicStreamFactoryPeer::SetThresholdTimeoutsWithOpenStreams(&factory_, 2);
2132   EXPECT_FALSE(
2133       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2134   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
2135                    &factory_, host_port_pair_.port()));
2136
2137   MockRead reads[] = {
2138       MockRead(ASYNC, OK, 0)  // EOF
2139   };
2140   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
2141   socket_factory_.AddSocketDataProvider(&socket_data);
2142   socket_data.StopAfter(1);
2143
2144   //  DeterministicSocketData socket_data2(nullptr, 0, nullptr, 0);
2145   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
2146   socket_factory_.AddSocketDataProvider(&socket_data2);
2147   socket_data2.StopAfter(1);
2148
2149   DeterministicSocketData socket_data3(reads, arraysize(reads), nullptr, 0);
2150   socket_factory_.AddSocketDataProvider(&socket_data3);
2151   socket_data3.StopAfter(1);
2152
2153   HostPortPair server2("mail.example.org", kDefaultServerPort);
2154   HostPortPair server3("docs.example.org", kDefaultServerPort);
2155
2156   crypto_client_stream_factory_.set_handshake_mode(
2157       MockCryptoClientStream::CONFIRM_HANDSHAKE);
2158   host_resolver_.set_synchronous_mode(true);
2159   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
2160                                            "192.168.0.1", "");
2161   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
2162   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
2163
2164   // Test first and third out of three timeouts with open streams.
2165   QuicStreamRequest request(&factory_);
2166   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
2167                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
2168                                 "GET", net_log_, callback_.callback()));
2169
2170   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
2171       &factory_, host_port_pair_, is_https_);
2172
2173   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
2174   EXPECT_TRUE(stream.get());
2175   HttpRequestInfo request_info;
2176   EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2177                                          net_log_, CompletionCallback()));
2178
2179   DVLOG(1)
2180       << "Created 1st session and initialized a stream. Now trigger timeout";
2181   session->connection()->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
2182   // Need to spin the loop now to ensure that
2183   // QuicStreamFactory::OnSessionClosed() runs.
2184   base::RunLoop run_loop;
2185   run_loop.RunUntilIdle();
2186
2187   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2188   EXPECT_FALSE(
2189       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2190
2191   // Test two-in-a-row timeouts with open streams.
2192   DVLOG(1) << "Create 2nd session without timeout";
2193   TestCompletionCallback callback2;
2194   QuicStreamRequest request2(&factory_);
2195   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
2196                                  /*cert_verify_flags=*/0, server2.host(), "GET",
2197                                  net_log_, callback2.callback()));
2198   QuicChromiumClientSession* session2 =
2199       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
2200
2201   session2->connection()->CloseConnection(QUIC_NO_ERROR, true);
2202   // Need to spin the loop now to ensure that
2203   // QuicStreamFactory::OnSessionClosed() runs.
2204   base::RunLoop run_loop2;
2205   run_loop2.RunUntilIdle();
2206   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2207   EXPECT_FALSE(
2208       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2209
2210   DVLOG(1) << "Create 3rd session with timeout with open streams,"
2211            << " will disable QUIC";
2212
2213   TestCompletionCallback callback3;
2214   QuicStreamRequest request3(&factory_);
2215   EXPECT_EQ(OK, request3.Request(server3, is_https_, privacy_mode_,
2216                                  /*cert_verify_flags=*/0, server3.host(), "GET",
2217                                  net_log_, callback3.callback()));
2218   QuicChromiumClientSession* session3 =
2219       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
2220
2221   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
2222   EXPECT_TRUE(stream3.get());
2223   EXPECT_EQ(OK, stream3->InitializeStream(&request_info, DEFAULT_PRIORITY,
2224                                           net_log_, CompletionCallback()));
2225   session3->connection()->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
2226   // Need to spin the loop now to ensure that
2227   // QuicStreamFactory::OnSessionClosed() runs.
2228   base::RunLoop run_loop3;
2229   run_loop3.RunUntilIdle();
2230   EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2231   EXPECT_TRUE(
2232       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2233   EXPECT_EQ(QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS,
2234             factory_.QuicDisabledReason(host_port_pair_.port()));
2235
2236   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
2237   EXPECT_TRUE(stream2.get());
2238   EXPECT_TRUE(socket_data.AllReadDataConsumed());
2239   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2240   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2241   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2242   EXPECT_TRUE(socket_data3.AllReadDataConsumed());
2243   EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
2244 }
2245
2246 TEST_P(QuicStreamFactoryTest, PublicResetPostHandshakeTwoOfFour) {
2247   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
2248   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
2249   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
2250   QuicStreamFactoryPeer::SetThresholdPublicResetsPostHandshake(&factory_, 2);
2251   EXPECT_FALSE(
2252       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2253   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
2254                    &factory_, host_port_pair_.port()));
2255
2256   MockRead reads[] = {
2257       MockRead(ASYNC, OK, 0)  // EOF
2258   };
2259   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
2260   socket_factory_.AddSocketDataProvider(&socket_data);
2261   socket_data.StopAfter(1);
2262
2263   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
2264   socket_factory_.AddSocketDataProvider(&socket_data2);
2265   socket_data2.StopAfter(1);
2266
2267   DeterministicSocketData socket_data3(reads, arraysize(reads), nullptr, 0);
2268   socket_factory_.AddSocketDataProvider(&socket_data3);
2269   socket_data3.StopAfter(1);
2270
2271   DeterministicSocketData socket_data4(reads, arraysize(reads), nullptr, 0);
2272   socket_factory_.AddSocketDataProvider(&socket_data4);
2273   socket_data4.StopAfter(1);
2274
2275   HostPortPair server2("mail.example.org", kDefaultServerPort);
2276   HostPortPair server3("docs.example.org", kDefaultServerPort);
2277   HostPortPair server4("images.example.org", kDefaultServerPort);
2278
2279   crypto_client_stream_factory_.set_handshake_mode(
2280       MockCryptoClientStream::CONFIRM_HANDSHAKE);
2281   host_resolver_.set_synchronous_mode(true);
2282   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
2283                                            "192.168.0.1", "");
2284   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
2285   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
2286   host_resolver_.rules()->AddIPLiteralRule(server4.host(), "192.168.0.1", "");
2287
2288   // Test first and fourth out of four public reset post handshakes.
2289   QuicStreamRequest request(&factory_);
2290   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
2291                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
2292                                 "GET", net_log_, callback_.callback()));
2293
2294   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
2295       &factory_, host_port_pair_, is_https_);
2296
2297   DVLOG(1) << "Created 1st session. Now trigger public reset post handshake";
2298   session->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
2299   // Need to spin the loop now to ensure that
2300   // QuicStreamFactory::OnSessionClosed() runs.
2301   base::RunLoop run_loop;
2302   run_loop.RunUntilIdle();
2303
2304   EXPECT_EQ(1,
2305             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
2306   EXPECT_FALSE(
2307       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2308
2309   DVLOG(1) << "Create 2nd and 3rd sessions without disable trigger";
2310   TestCompletionCallback callback2;
2311   QuicStreamRequest request2(&factory_);
2312   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
2313                                  /*cert_verify_flags=*/0, server2.host(), "GET",
2314                                  net_log_, callback2.callback()));
2315   QuicChromiumClientSession* session2 =
2316       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
2317
2318   session2->connection()->CloseConnection(QUIC_NO_ERROR, false);
2319   // Need to spin the loop now to ensure that
2320   // QuicStreamFactory::OnSessionClosed() runs.
2321   base::RunLoop run_loop2;
2322   run_loop2.RunUntilIdle();
2323   EXPECT_EQ(1,
2324             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
2325   EXPECT_FALSE(
2326       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2327
2328   TestCompletionCallback callback3;
2329   QuicStreamRequest request3(&factory_);
2330   EXPECT_EQ(OK, request3.Request(server3, is_https_, privacy_mode_,
2331                                  /*cert_verify_flags=*/0, server3.host(), "GET",
2332                                  net_log_, callback3.callback()));
2333   QuicChromiumClientSession* session3 =
2334       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
2335
2336   session3->connection()->CloseConnection(QUIC_NO_ERROR, false);
2337   // Need to spin the loop now to ensure that
2338   // QuicStreamFactory::OnSessionClosed() runs.
2339   base::RunLoop run_loop3;
2340   run_loop3.RunUntilIdle();
2341   EXPECT_EQ(1,
2342             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
2343   EXPECT_FALSE(
2344       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2345
2346   DVLOG(1) << "Create 4rd session with public reset post handshake,"
2347            << " will not disable QUIC";
2348   TestCompletionCallback callback4;
2349   QuicStreamRequest request4(&factory_);
2350   EXPECT_EQ(OK, request4.Request(server4, is_https_, privacy_mode_,
2351                                  /*cert_verify_flags=*/0, server4.host(), "GET",
2352                                  net_log_, callback4.callback()));
2353   QuicChromiumClientSession* session4 =
2354       QuicStreamFactoryPeer::GetActiveSession(&factory_, server4, is_https_);
2355
2356   session4->connection()->CloseConnection(QUIC_PUBLIC_RESET, true);
2357   // Need to spin the loop now to ensure that
2358   // QuicStreamFactory::OnSessionClosed() runs.
2359   base::RunLoop run_loop4;
2360   run_loop4.RunUntilIdle();
2361   EXPECT_EQ(1,
2362             QuicStreamFactoryPeer::GetNumPublicResetsPostHandshake(&factory_));
2363   EXPECT_FALSE(
2364       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2365
2366   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
2367   EXPECT_TRUE(stream.get());
2368   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
2369   EXPECT_TRUE(stream2.get());
2370   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
2371   EXPECT_TRUE(stream3.get());
2372   scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream();
2373   EXPECT_TRUE(stream4.get());
2374
2375   EXPECT_TRUE(socket_data.AllReadDataConsumed());
2376   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2377   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2378   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2379   EXPECT_TRUE(socket_data3.AllReadDataConsumed());
2380   EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
2381   EXPECT_TRUE(socket_data4.AllReadDataConsumed());
2382   EXPECT_TRUE(socket_data4.AllWriteDataConsumed());
2383 }
2384
2385 TEST_P(QuicStreamFactoryTest, TimeoutsWithOpenStreamsTwoOfFour) {
2386   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
2387   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
2388   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
2389   QuicStreamFactoryPeer::SetThresholdTimeoutsWithOpenStreams(&factory_, 2);
2390   EXPECT_FALSE(
2391       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2392   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
2393                    &factory_, host_port_pair_.port()));
2394
2395   MockRead reads[] = {
2396       MockRead(ASYNC, OK, 0)  // EOF
2397   };
2398   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
2399   socket_factory_.AddSocketDataProvider(&socket_data);
2400   socket_data.StopAfter(1);
2401
2402   //  DeterministicSocketData socket_data2(nullptr, 0, nullptr, 0);
2403   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
2404   socket_factory_.AddSocketDataProvider(&socket_data2);
2405   socket_data2.StopAfter(1);
2406
2407   DeterministicSocketData socket_data3(reads, arraysize(reads), nullptr, 0);
2408   socket_factory_.AddSocketDataProvider(&socket_data3);
2409   socket_data3.StopAfter(1);
2410
2411   DeterministicSocketData socket_data4(reads, arraysize(reads), nullptr, 0);
2412   socket_factory_.AddSocketDataProvider(&socket_data4);
2413   socket_data4.StopAfter(1);
2414
2415   HostPortPair server2("mail.example.org", kDefaultServerPort);
2416   HostPortPair server3("docs.example.org", kDefaultServerPort);
2417   HostPortPair server4("images.example.org", kDefaultServerPort);
2418
2419   crypto_client_stream_factory_.set_handshake_mode(
2420       MockCryptoClientStream::CONFIRM_HANDSHAKE);
2421   host_resolver_.set_synchronous_mode(true);
2422   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
2423                                            "192.168.0.1", "");
2424   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
2425   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
2426   host_resolver_.rules()->AddIPLiteralRule(server4.host(), "192.168.0.1", "");
2427
2428   // Test first and fourth out of three timeouts with open streams.
2429   QuicStreamRequest request(&factory_);
2430   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
2431                                 /*cert_verify_flags=*/0, host_port_pair_.host(),
2432                                 "GET", net_log_, callback_.callback()));
2433
2434   QuicChromiumClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
2435       &factory_, host_port_pair_, is_https_);
2436
2437   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
2438   EXPECT_TRUE(stream.get());
2439   HttpRequestInfo request_info;
2440   EXPECT_EQ(OK, stream->InitializeStream(&request_info, DEFAULT_PRIORITY,
2441                                          net_log_, CompletionCallback()));
2442
2443   DVLOG(1)
2444       << "Created 1st session and initialized a stream. Now trigger timeout";
2445   session->connection()->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
2446   // Need to spin the loop now to ensure that
2447   // QuicStreamFactory::OnSessionClosed() runs.
2448   base::RunLoop run_loop;
2449   run_loop.RunUntilIdle();
2450
2451   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2452   EXPECT_FALSE(
2453       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2454
2455   DVLOG(1) << "Create 2nd and 3rd sessions without timeout";
2456   TestCompletionCallback callback2;
2457   QuicStreamRequest request2(&factory_);
2458   EXPECT_EQ(OK, request2.Request(server2, is_https_, privacy_mode_,
2459                                  /*cert_verify_flags=*/0, server2.host(), "GET",
2460                                  net_log_, callback2.callback()));
2461   QuicChromiumClientSession* session2 =
2462       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
2463
2464   session2->connection()->CloseConnection(QUIC_NO_ERROR, true);
2465   // Need to spin the loop now to ensure that
2466   // QuicStreamFactory::OnSessionClosed() runs.
2467   base::RunLoop run_loop2;
2468   run_loop2.RunUntilIdle();
2469   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2470   EXPECT_FALSE(
2471       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2472
2473   TestCompletionCallback callback3;
2474   QuicStreamRequest request3(&factory_);
2475   EXPECT_EQ(OK, request3.Request(server3, is_https_, privacy_mode_,
2476                                  /*cert_verify_flags=*/0, server3.host(), "GET",
2477                                  net_log_, callback3.callback()));
2478   QuicChromiumClientSession* session3 =
2479       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
2480
2481   session3->connection()->CloseConnection(QUIC_NO_ERROR, true);
2482   // Need to spin the loop now to ensure that
2483   // QuicStreamFactory::OnSessionClosed() runs.
2484   base::RunLoop run_loop3;
2485   run_loop3.RunUntilIdle();
2486   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2487   EXPECT_FALSE(
2488       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2489
2490   DVLOG(1) << "Create 4th session with timeout with open streams,"
2491            << " will not disable QUIC";
2492
2493   TestCompletionCallback callback4;
2494   QuicStreamRequest request4(&factory_);
2495   EXPECT_EQ(OK, request4.Request(server4, is_https_, privacy_mode_,
2496                                  /*cert_verify_flags=*/0, server4.host(), "GET",
2497                                  net_log_, callback4.callback()));
2498   QuicChromiumClientSession* session4 =
2499       QuicStreamFactoryPeer::GetActiveSession(&factory_, server4, is_https_);
2500
2501   scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream();
2502   EXPECT_TRUE(stream4.get());
2503   EXPECT_EQ(OK, stream4->InitializeStream(&request_info, DEFAULT_PRIORITY,
2504                                           net_log_, CompletionCallback()));
2505   session4->connection()->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
2506   // Need to spin the loop now to ensure that
2507   // QuicStreamFactory::OnSessionClosed() runs.
2508   base::RunLoop run_loop4;
2509   run_loop4.RunUntilIdle();
2510   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumTimeoutsWithOpenStreams(&factory_));
2511   EXPECT_FALSE(
2512       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
2513
2514   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
2515   EXPECT_TRUE(stream2.get());
2516   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
2517   EXPECT_TRUE(stream3.get());
2518   EXPECT_TRUE(socket_data.AllReadDataConsumed());
2519   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2520   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
2521   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
2522   EXPECT_TRUE(socket_data3.AllReadDataConsumed());
2523   EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
2524   EXPECT_TRUE(socket_data4.AllReadDataConsumed());
2525   EXPECT_TRUE(socket_data4.AllWriteDataConsumed());
2526 }
2527
2528 TEST_P(QuicStreamFactoryTest, EnableDelayTcpRace) {
2529   bool delay_tcp_race = QuicStreamFactoryPeer::GetDelayTcpRace(&factory_);
2530   QuicStreamFactoryPeer::SetDelayTcpRace(&factory_, false);
2531   MockRead reads[] = {
2532       MockRead(ASYNC, OK, 0),
2533   };
2534   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
2535   socket_factory_.AddSocketDataProvider(&socket_data);
2536   socket_data.StopAfter(1);
2537
2538   // Set up data in HttpServerProperties.
2539   scoped_ptr<HttpServerProperties> http_server_properties(
2540       new HttpServerPropertiesImpl());
2541   QuicStreamFactoryPeer::SetHttpServerProperties(
2542       &factory_, http_server_properties->GetWeakPtr());
2543
2544   const AlternativeService alternative_service1(QUIC, host_port_pair_.host(),
2545                                                 host_port_pair_.port());
2546   AlternativeServiceInfoVector alternative_service_info_vector;
2547   base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
2548   alternative_service_info_vector.push_back(
2549       AlternativeServiceInfo(alternative_service1, 1.0, expiration));
2550
2551   http_server_properties->SetAlternativeServices(
2552       host_port_pair_, alternative_service_info_vector);
2553
2554   ServerNetworkStats stats1;
2555   stats1.srtt = base::TimeDelta::FromMicroseconds(10);
2556   http_server_properties->SetServerNetworkStats(host_port_pair_, stats1);
2557
2558   crypto_client_stream_factory_.set_handshake_mode(
2559       MockCryptoClientStream::ZERO_RTT);
2560   host_resolver_.set_synchronous_mode(true);
2561   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
2562                                            "192.168.0.1", "");
2563
2564   QuicStreamRequest request(&factory_);
2565   EXPECT_EQ(ERR_IO_PENDING,
2566             request.Request(host_port_pair_, is_https_, privacy_mode_,
2567                             /*cert_verify_flags=*/0, host_port_pair_.host(),
2568                             "POST", net_log_, callback_.callback()));
2569
2570   // If we don't delay TCP connection, then time delay should be 0.
2571   EXPECT_FALSE(factory_.delay_tcp_race());
2572   EXPECT_EQ(base::TimeDelta(), request.GetTimeDelayForWaitingJob());
2573
2574   // Enable |delay_tcp_race_| param and verify delay is one RTT and that
2575   // server supports QUIC.
2576   QuicStreamFactoryPeer::SetDelayTcpRace(&factory_, true);
2577   EXPECT_TRUE(factory_.delay_tcp_race());
2578   EXPECT_EQ(base::TimeDelta::FromMicroseconds(15),
2579             request.GetTimeDelayForWaitingJob());
2580
2581   // Confirm the handshake and verify that the stream is created.
2582   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
2583       QuicSession::HANDSHAKE_CONFIRMED);
2584
2585   EXPECT_EQ(OK, callback_.WaitForResult());
2586
2587   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
2588   EXPECT_TRUE(stream.get());
2589   EXPECT_TRUE(socket_data.AllReadDataConsumed());
2590   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
2591   QuicStreamFactoryPeer::SetDelayTcpRace(&factory_, delay_tcp_race);
2592 }
2593
2594 }  // namespace test
2595 }  // namespace net