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