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_util.h"
  16 #include "net/http/transport_security_state.h"
  17 #include "net/quic/crypto/crypto_handshake.h"
  18 #include "net/quic/crypto/proof_verifier_chromium.h"
  19 #include "net/quic/crypto/quic_decrypter.h"
  20 #include "net/quic/crypto/quic_encrypter.h"
  21 #include "net/quic/crypto/quic_server_info.h"
  22 #include "net/quic/quic_http_stream.h"
  23 #include "net/quic/quic_server_id.h"
  24 #include "net/quic/test_tools/mock_clock.h"
  25 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
  26 #include "net/quic/test_tools/mock_random.h"
  27 #include "net/quic/test_tools/quic_test_packet_maker.h"
  28 #include "net/quic/test_tools/quic_test_utils.h"
  29 #include "net/quic/test_tools/test_task_runner.h"
  30 #include "net/socket/socket_test_util.h"
  31 #include "net/spdy/spdy_test_utils.h"
  32 #include "net/ssl/channel_id_service.h"
  33 #include "net/ssl/default_channel_id_store.h"
  34 #include "net/test/cert_test_util.h"
  35 #include "testing/gtest/include/gtest/gtest.h"
  36
  37 using base::StringPiece;
  38 using std::ostream;
  39 using std::string;
  40 using std::vector;
  41
  42 namespace net {
  43 namespace test {
  44
  45 namespace {
  46 const char kDefaultServerHostName[] = "www.google.com";
  47 const int kDefaultServerPort = 443;
  48
  49 // Run all tests with all the combinations of versions and
  50 // enable_connection_racing.
  51 struct TestParams {
  52   TestParams(const QuicVersion version, bool enable_connection_racing)
  53       : version(version), enable_connection_racing(enable_connection_racing) {}
  54
  55   friend ostream& operator<<(ostream& os, const TestParams& p) {
  56     os << "{ version: " << QuicVersionToString(p.version);
  57     os << " enable_connection_racing: " << p.enable_connection_racing << " }";
  58     return os;
  59   }
  60
  61   QuicVersion version;
  62   bool enable_connection_racing;
  63 };
  64
  65 // Constructs various test permutations.
  66 vector<TestParams> GetTestParams() {
  67   vector<TestParams> params;
  68   QuicVersionVector all_supported_versions = QuicSupportedVersions();
  69   for (const QuicVersion version : all_supported_versions) {
  70     params.push_back(TestParams(version, false));
  71     params.push_back(TestParams(version, true));
  72   }
  73   return params;
  74 }
  75
  76 }  // namespace anonymous
  77
  78 class QuicStreamFactoryPeer {
  79  public:
  80   static QuicCryptoClientConfig* GetCryptoConfig(QuicStreamFactory* factory) {
  81     return &factory->crypto_config_;
  82   }
  83
  84   static bool HasActiveSession(QuicStreamFactory* factory,
  85                                const HostPortPair& host_port_pair,
  86                                bool is_https) {
  87     QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
  88     return factory->HasActiveSession(server_id);
  89   }
  90
  91   static QuicClientSession* GetActiveSession(
  92       QuicStreamFactory* factory,
  93       const HostPortPair& host_port_pair,
  94       bool is_https) {
  95     QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
  96     DCHECK(factory->HasActiveSession(server_id));
  97     return factory->active_sessions_[server_id];
  98   }
  99
 100   static scoped_ptr<QuicHttpStream> CreateFromSession(
 101       QuicStreamFactory* factory,
 102       QuicClientSession* session) {
 103     return factory->CreateFromSession(session);
 104   }
 105
 106   static bool IsLiveSession(QuicStreamFactory* factory,
 107                             QuicClientSession* session) {
 108     for (QuicStreamFactory::SessionIdMap::iterator it =
 109              factory->all_sessions_.begin();
 110          it != factory->all_sessions_.end(); ++it) {
 111       if (it->first == session)
 112         return true;
 113     }
 114     return false;
 115   }
 116
 117   static void DisableConnectionPooling(QuicStreamFactory* factory) {
 118     factory->disable_connection_pooling_ = true;
 119   }
 120
 121   static void SetTaskRunner(QuicStreamFactory* factory,
 122                             base::TaskRunner* task_runner) {
 123     factory->task_runner_ = task_runner;
 124   }
 125
 126   static void SetEnableConnectionRacing(QuicStreamFactory* factory,
 127                                         bool enable_connection_racing) {
 128     factory->enable_connection_racing_ = enable_connection_racing;
 129   }
 130
 131   static void SetDisableDiskCache(QuicStreamFactory* factory,
 132                                   bool disable_disk_cache) {
 133     factory->disable_disk_cache_ = disable_disk_cache;
 134   }
 135
 136   static void SetMaxNumberOfLossyConnections(
 137       QuicStreamFactory* factory,
 138       int max_number_of_lossy_connections) {
 139     factory->max_number_of_lossy_connections_ = max_number_of_lossy_connections;
 140   }
 141
 142   static int GetNumberOfLossyConnections(QuicStreamFactory* factory,
 143                                          uint16 port) {
 144     return factory->number_of_lossy_connections_[port];
 145   }
 146
 147   static bool IsQuicDisabled(QuicStreamFactory* factory, uint16 port) {
 148     return factory->IsQuicDisabled(port);
 149   }
 150
 151   static size_t GetNumberOfActiveJobs(QuicStreamFactory* factory,
 152                                       const QuicServerId& server_id) {
 153     return (factory->active_jobs_[server_id]).size();
 154   }
 155 };
 156
 157 class MockQuicServerInfo : public QuicServerInfo {
 158  public:
 159   MockQuicServerInfo(const QuicServerId& server_id)
 160       : QuicServerInfo(server_id) {}
 161   ~MockQuicServerInfo() override {}
 162
 163   void Start() override {}
 164
 165   int WaitForDataReady(const CompletionCallback& callback) override {
 166     return ERR_IO_PENDING;
 167   }
 168
 169   void ResetWaitForDataReadyCallback() override {}
 170
 171   void CancelWaitForDataReadyCallback() override {}
 172
 173   bool IsDataReady() override { return false; }
 174
 175   bool IsReadyToPersist() override { return false; }
 176
 177   void Persist() override {}
 178
 179   void OnExternalCacheHit() override {}
 180 };
 181
 182 class MockQuicServerInfoFactory : public QuicServerInfoFactory {
 183  public:
 184   MockQuicServerInfoFactory() {}
 185   ~MockQuicServerInfoFactory() override {}
 186
 187   QuicServerInfo* GetForServer(const QuicServerId& server_id) override {
 188     return new MockQuicServerInfo(server_id);
 189   }
 190 };
 191
 192 class QuicStreamFactoryTest : public ::testing::TestWithParam<TestParams> {
 193  protected:
 194   QuicStreamFactoryTest()
 195       : random_generator_(0),
 196         clock_(new MockClock()),
 197         runner_(new TestTaskRunner(clock_)),
 198         maker_(GetParam().version, 0, clock_, kDefaultServerHostName),
 199         cert_verifier_(CertVerifier::CreateDefault()),
 200         channel_id_service_(
 201             new ChannelIDService(new DefaultChannelIDStore(nullptr),
 202                                  base::ThreadTaskRunnerHandle::Get())),
 203         factory_(&host_resolver_,
 204                  &socket_factory_,
 205                  base::WeakPtr<HttpServerProperties>(),
 206                  cert_verifier_.get(),
 207                  channel_id_service_.get(),
 208                  &transport_security_state_,
 209                  &crypto_client_stream_factory_,
 210                  &random_generator_,
 211                  clock_,
 212                  kDefaultMaxPacketSize,
 213                  std::string(),
 214                  SupportedVersions(GetParam().version),
 215                  /*enable_port_selection=*/true,
 216                  /*always_require_handshake_confirmation=*/false,
 217                  /*disable_connection_pooling=*/false,
 218                  /*load_server_info_timeout_srtt_multiplier=*/0.0f,
 219                  /*enable_connection_racing=*/false,
 220                  /*enable_non_blocking_io=*/true,
 221                  /*disable_disk_cache=*/false,
 222                  /*prefer_aes=*/false,
 223                  /*max_number_of_lossy_connections=*/0,
 224                  /*packet_loss_threshold=*/1.0f,
 225                  /*receive_buffer_size=*/0,
 226                  QuicTagVector()),
 227         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
 228         is_https_(false),
 229         privacy_mode_(PRIVACY_MODE_DISABLED) {
 230     factory_.set_require_confirmation(false);
 231     clock_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
 232     QuicStreamFactoryPeer::SetEnableConnectionRacing(
 233         &factory_, GetParam().enable_connection_racing);
 234   }
 235
 236   bool HasActiveSession(const HostPortPair& host_port_pair) {
 237     return QuicStreamFactoryPeer::HasActiveSession(&factory_, host_port_pair,
 238                                                    /*is_https_=*/false);
 239   }
 240
 241   scoped_ptr<QuicHttpStream> CreateFromSession(
 242       const HostPortPair& host_port_pair) {
 243     QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
 244         &factory_, host_port_pair, /*is_https=*/false);
 245     return QuicStreamFactoryPeer::CreateFromSession(&factory_, session);
 246   }
 247
 248   int GetSourcePortForNewSession(const HostPortPair& destination) {
 249     return GetSourcePortForNewSessionInner(destination, false);
 250   }
 251
 252   int GetSourcePortForNewSessionAndGoAway(
 253       const HostPortPair& destination) {
 254     return GetSourcePortForNewSessionInner(destination, true);
 255   }
 256
 257   int GetSourcePortForNewSessionInner(const HostPortPair& destination,
 258                                       bool goaway_received) {
 259     // Should only be called if there is no active session for this destination.
 260     EXPECT_FALSE(HasActiveSession(destination));
 261     size_t socket_count = socket_factory_.udp_client_sockets().size();
 262
 263     MockRead reads[] = {
 264       MockRead(ASYNC, OK, 0)  // EOF
 265     };
 266     DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 267     socket_data.StopAfter(1);
 268     socket_factory_.AddSocketDataProvider(&socket_data);
 269
 270     QuicStreamRequest request(&factory_);
 271     EXPECT_EQ(ERR_IO_PENDING,
 272               request.Request(destination, is_https_, privacy_mode_,
 273                               destination.host(), "GET", net_log_,
 274                               callback_.callback()));
 275
 276     EXPECT_EQ(OK, callback_.WaitForResult());
 277     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 278     EXPECT_TRUE(stream.get());
 279     stream.reset();
 280
 281     QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
 282         &factory_, destination, is_https_);
 283
 284     if (socket_count + 1 != socket_factory_.udp_client_sockets().size()) {
 285       EXPECT_TRUE(false);
 286       return 0;
 287     }
 288
 289     IPEndPoint endpoint;
 290     socket_factory_.
 291         udp_client_sockets()[socket_count]->GetLocalAddress(&endpoint);
 292     int port = endpoint.port();
 293     if (goaway_received) {
 294       QuicGoAwayFrame goaway(QUIC_NO_ERROR, 1, "");
 295       session->OnGoAway(goaway);
 296     }
 297
 298     factory_.OnSessionClosed(session);
 299     EXPECT_FALSE(HasActiveSession(destination));
 300     EXPECT_TRUE(socket_data.AllReadDataConsumed());
 301     EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 302     return port;
 303   }
 304
 305   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
 306     QuicStreamId stream_id = kClientDataStreamId1;
 307     return maker_.MakeRstPacket(
 308         1, true, stream_id,
 309         AdjustErrorForVersion(QUIC_RST_ACKNOWLEDGEMENT, GetParam().version));
 310   }
 311
 312   static ProofVerifyDetailsChromium DefaultProofVerifyDetails() {
 313     // Load a certificate that is valid for www.example.org, mail.example.org,
 314     // and mail.example.com.
 315     scoped_refptr<X509Certificate> test_cert(
 316         ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"));
 317     EXPECT_TRUE(test_cert.get());
 318     ProofVerifyDetailsChromium verify_details;
 319     verify_details.cert_verify_result.verified_cert = test_cert;
 320     verify_details.cert_verify_result.is_issued_by_known_root = true;
 321     return verify_details;
 322   }
 323
 324   MockQuicServerInfoFactory quic_server_info_factory_;
 325   MockHostResolver host_resolver_;
 326   DeterministicMockClientSocketFactory socket_factory_;
 327   MockCryptoClientStreamFactory crypto_client_stream_factory_;
 328   MockRandom random_generator_;
 329   MockClock* clock_;  // Owned by factory_.
 330   scoped_refptr<TestTaskRunner> runner_;
 331   QuicTestPacketMaker maker_;
 332   scoped_ptr<CertVerifier> cert_verifier_;
 333   scoped_ptr<ChannelIDService> channel_id_service_;
 334   TransportSecurityState transport_security_state_;
 335   QuicStreamFactory factory_;
 336   HostPortPair host_port_pair_;
 337   bool is_https_;
 338   PrivacyMode privacy_mode_;
 339   BoundNetLog net_log_;
 340   TestCompletionCallback callback_;
 341 };
 342
 343 INSTANTIATE_TEST_CASE_P(Version,
 344                         QuicStreamFactoryTest,
 345                         ::testing::ValuesIn(GetTestParams()));
 346
 347 TEST_P(QuicStreamFactoryTest, Create) {
 348   MockRead reads[] = {
 349     MockRead(ASYNC, OK, 0)  // EOF
 350   };
 351   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 352   socket_factory_.AddSocketDataProvider(&socket_data);
 353   socket_data.StopAfter(1);
 354
 355   QuicStreamRequest request(&factory_);
 356   EXPECT_EQ(ERR_IO_PENDING,
 357             request.Request(host_port_pair_, is_https_, privacy_mode_,
 358                             host_port_pair_.host(), "GET", net_log_,
 359                             callback_.callback()));
 360
 361   EXPECT_EQ(OK, callback_.WaitForResult());
 362   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 363   EXPECT_TRUE(stream.get());
 364
 365   // Will reset stream 3.
 366   stream = CreateFromSession(host_port_pair_);
 367   EXPECT_TRUE(stream.get());
 368
 369   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
 370   // in streams on different sessions.
 371   QuicStreamRequest request2(&factory_);
 372   EXPECT_EQ(OK, request2.Request(host_port_pair_, is_https_, privacy_mode_,
 373                                  host_port_pair_.host(), "GET", net_log_,
 374                                  callback_.callback()));
 375   stream = request2.ReleaseStream();  // Will reset stream 5.
 376   stream.reset();  // Will reset stream 7.
 377
 378   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 379   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 380 }
 381
 382 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
 383   MockRead reads[] = {
 384     MockRead(ASYNC, OK, 0)  // EOF
 385   };
 386   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 387   socket_factory_.AddSocketDataProvider(&socket_data);
 388   socket_data.StopAfter(1);
 389
 390   crypto_client_stream_factory_.set_handshake_mode(
 391       MockCryptoClientStream::ZERO_RTT);
 392   host_resolver_.set_synchronous_mode(true);
 393   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 394                                            "192.168.0.1", "");
 395
 396   QuicStreamRequest request(&factory_);
 397   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 398                                 host_port_pair_.host(), "GET", net_log_,
 399                                 callback_.callback()));
 400
 401   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 402   EXPECT_TRUE(stream.get());
 403   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 404   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 405 }
 406
 407 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
 408   MockRead reads[] = {
 409     MockRead(ASYNC, OK, 0)  // EOF
 410   };
 411   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 412   socket_factory_.AddSocketDataProvider(&socket_data);
 413   socket_data.StopAfter(1);
 414
 415   crypto_client_stream_factory_.set_handshake_mode(
 416       MockCryptoClientStream::ZERO_RTT);
 417   host_resolver_.set_synchronous_mode(true);
 418   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 419                                            "192.168.0.1", "");
 420
 421   QuicStreamRequest request(&factory_);
 422   // Posts require handshake confirmation, so this will return asynchronously.
 423   EXPECT_EQ(ERR_IO_PENDING,
 424             request.Request(host_port_pair_, is_https_, privacy_mode_,
 425                             host_port_pair_.host(), "POST", net_log_,
 426                             callback_.callback()));
 427
 428   // Confirm the handshake and verify that the stream is created.
 429   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
 430       QuicSession::HANDSHAKE_CONFIRMED);
 431
 432   EXPECT_EQ(OK, callback_.WaitForResult());
 433   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 434   EXPECT_TRUE(stream.get());
 435   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 436   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 437 }
 438
 439 TEST_P(QuicStreamFactoryTest, NoZeroRttForDifferentHost) {
 440   MockRead reads[] = {
 441       MockRead(ASYNC, OK, 0),
 442   };
 443   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 444   socket_factory_.AddSocketDataProvider(&socket_data);
 445   socket_data.StopAfter(1);
 446
 447   crypto_client_stream_factory_.set_handshake_mode(
 448       MockCryptoClientStream::ZERO_RTT);
 449   host_resolver_.set_synchronous_mode(true);
 450   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 451                                            "192.168.0.1", "");
 452
 453   QuicStreamRequest request(&factory_);
 454   int rv = request.Request(host_port_pair_, is_https_, privacy_mode_,
 455                            "different.host.example.com", "GET", net_log_,
 456                            callback_.callback());
 457   // If server and origin have different hostnames, then handshake confirmation
 458   // should be required, so Request will return asynchronously.
 459   EXPECT_EQ(ERR_IO_PENDING, rv);
 460   // Confirm handshake.
 461   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
 462       QuicSession::HANDSHAKE_CONFIRMED);
 463   EXPECT_EQ(OK, callback_.WaitForResult());
 464
 465   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 466   EXPECT_TRUE(stream.get());
 467   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 468   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 469 }
 470
 471 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
 472   MockRead reads[] = {
 473     MockRead(ASYNC, OK, 0)  // EOF
 474   };
 475   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 476   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 477   socket_factory_.AddSocketDataProvider(&socket_data1);
 478   socket_factory_.AddSocketDataProvider(&socket_data2);
 479   socket_data1.StopAfter(1);
 480   socket_data2.StopAfter(1);
 481
 482   QuicStreamRequest request(&factory_);
 483   EXPECT_EQ(ERR_IO_PENDING,
 484             request.Request(host_port_pair_, is_https_, privacy_mode_,
 485                             host_port_pair_.host(), "GET", net_log_,
 486                             callback_.callback()));
 487
 488   EXPECT_EQ(OK, callback_.WaitForResult());
 489   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 490   EXPECT_TRUE(stream.get());
 491
 492   QuicStreamRequest request2(&factory_);
 493   EXPECT_EQ(ERR_IO_PENDING,
 494             request2.Request(host_port_pair_, !is_https_, privacy_mode_,
 495                              host_port_pair_.host(), "GET", net_log_,
 496                              callback_.callback()));
 497   EXPECT_EQ(OK, callback_.WaitForResult());
 498   stream = request2.ReleaseStream();
 499   EXPECT_TRUE(stream.get());
 500   stream.reset();
 501
 502   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 503                 &factory_, host_port_pair_, is_https_),
 504             QuicStreamFactoryPeer::GetActiveSession(
 505                 &factory_, host_port_pair_, !is_https_));
 506
 507   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 508   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 509   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 510   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 511 }
 512
 513 TEST_P(QuicStreamFactoryTest, Pooling) {
 514   MockRead reads[] = {
 515     MockRead(ASYNC, OK, 0)  // EOF
 516   };
 517   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 518   socket_factory_.AddSocketDataProvider(&socket_data);
 519   socket_data.StopAfter(1);
 520
 521   HostPortPair server2("mail.google.com", kDefaultServerPort);
 522   host_resolver_.set_synchronous_mode(true);
 523   host_resolver_.rules()->AddIPLiteralRule(
 524       kDefaultServerHostName, "192.168.0.1", "");
 525   host_resolver_.rules()->AddIPLiteralRule(
 526       "mail.google.com", "192.168.0.1", "");
 527
 528   QuicStreamRequest request(&factory_);
 529   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 530                                 host_port_pair_.host(), "GET", net_log_,
 531                                 callback_.callback()));
 532   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 533   EXPECT_TRUE(stream.get());
 534
 535   TestCompletionCallback callback;
 536   QuicStreamRequest request2(&factory_);
 537   EXPECT_EQ(OK,
 538             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 539                              "GET", net_log_, callback.callback()));
 540   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 541   EXPECT_TRUE(stream2.get());
 542
 543   EXPECT_EQ(
 544       QuicStreamFactoryPeer::GetActiveSession(
 545           &factory_, host_port_pair_, is_https_),
 546       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 547
 548   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 549   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 550 }
 551
 552 TEST_P(QuicStreamFactoryTest, NoPoolingIfDisabled) {
 553   MockRead reads[] = {
 554     MockRead(ASYNC, OK, 0)  // EOF
 555   };
 556   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 557   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 558   socket_factory_.AddSocketDataProvider(&socket_data1);
 559   socket_factory_.AddSocketDataProvider(&socket_data2);
 560   socket_data1.StopAfter(1);
 561   socket_data2.StopAfter(1);
 562
 563   HostPortPair server2("mail.google.com", kDefaultServerPort);
 564   host_resolver_.set_synchronous_mode(true);
 565   host_resolver_.rules()->AddIPLiteralRule(
 566       kDefaultServerHostName, "192.168.0.1", "");
 567   host_resolver_.rules()->AddIPLiteralRule(
 568       "mail.google.com", "192.168.0.1", "");
 569
 570   // Disable connection pooling.
 571   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 572
 573   QuicStreamRequest request(&factory_);
 574   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 575                                 host_port_pair_.host(), "GET", net_log_,
 576                                 callback_.callback()));
 577   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 578   EXPECT_TRUE(stream.get());
 579
 580   TestCompletionCallback callback;
 581   QuicStreamRequest request2(&factory_);
 582   EXPECT_EQ(OK,
 583             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 584                              "GET", net_log_, callback.callback()));
 585   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 586   EXPECT_TRUE(stream2.get());
 587
 588   EXPECT_NE(
 589       QuicStreamFactoryPeer::GetActiveSession(
 590           &factory_, host_port_pair_, is_https_),
 591       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 592
 593   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 594   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 595   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 596   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 597 }
 598
 599 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 600   MockRead reads[] = {
 601     MockRead(ASYNC, OK, 0)  // EOF
 602   };
 603   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 604   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 605   socket_factory_.AddSocketDataProvider(&socket_data1);
 606   socket_factory_.AddSocketDataProvider(&socket_data2);
 607   socket_data1.StopAfter(1);
 608   socket_data2.StopAfter(1);
 609
 610   HostPortPair server2("mail.google.com", kDefaultServerPort);
 611   host_resolver_.set_synchronous_mode(true);
 612   host_resolver_.rules()->AddIPLiteralRule(
 613       kDefaultServerHostName, "192.168.0.1", "");
 614   host_resolver_.rules()->AddIPLiteralRule(
 615       "mail.google.com", "192.168.0.1", "");
 616
 617   QuicStreamRequest request(&factory_);
 618   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
 619                                 host_port_pair_.host(), "GET", net_log_,
 620                                 callback_.callback()));
 621   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 622   EXPECT_TRUE(stream.get());
 623
 624   TestCompletionCallback callback;
 625   QuicStreamRequest request2(&factory_);
 626   EXPECT_EQ(OK,
 627             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 628                              "GET", net_log_, callback.callback()));
 629   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 630   EXPECT_TRUE(stream2.get());
 631
 632   factory_.OnSessionGoingAway(QuicStreamFactoryPeer::GetActiveSession(
 633       &factory_, host_port_pair_, is_https_));
 634   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
 635       &factory_, host_port_pair_, is_https_));
 636   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
 637       &factory_, server2, is_https_));
 638
 639   TestCompletionCallback callback3;
 640   QuicStreamRequest request3(&factory_);
 641   EXPECT_EQ(OK,
 642             request3.Request(server2, is_https_, privacy_mode_, server2.host(),
 643                              "GET", net_log_, callback3.callback()));
 644   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
 645   EXPECT_TRUE(stream3.get());
 646
 647   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
 648       &factory_, server2, is_https_));
 649
 650   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 651   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 652   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 653   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 654 }
 655
 656 TEST_P(QuicStreamFactoryTest, HttpsPooling) {
 657   MockRead reads[] = {
 658     MockRead(ASYNC, OK, 0)  // EOF
 659   };
 660   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 661   socket_factory_.AddSocketDataProvider(&socket_data);
 662   socket_data.StopAfter(1);
 663
 664   HostPortPair server1("www.example.org", 443);
 665   HostPortPair server2("mail.example.org", 443);
 666
 667   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 668   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 669
 670   host_resolver_.set_synchronous_mode(true);
 671   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 672   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 673
 674   QuicStreamRequest request(&factory_);
 675   is_https_ = true;
 676   EXPECT_EQ(OK,
 677             request.Request(server1, is_https_, privacy_mode_, server1.host(),
 678                             "GET", net_log_, callback_.callback()));
 679   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 680   EXPECT_TRUE(stream.get());
 681
 682   TestCompletionCallback callback;
 683   QuicStreamRequest request2(&factory_);
 684   EXPECT_EQ(OK,
 685             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 686                              "GET", net_log_, callback_.callback()));
 687   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 688   EXPECT_TRUE(stream2.get());
 689
 690   EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
 691                 &factory_, server1, is_https_),
 692             QuicStreamFactoryPeer::GetActiveSession(
 693                 &factory_, server2, is_https_));
 694
 695   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 696   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 697 }
 698
 699 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingIfDisabled) {
 700   MockRead reads[] = {
 701     MockRead(ASYNC, OK, 0)  // EOF
 702   };
 703   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 704   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 705   socket_factory_.AddSocketDataProvider(&socket_data1);
 706   socket_factory_.AddSocketDataProvider(&socket_data2);
 707   socket_data1.StopAfter(1);
 708   socket_data2.StopAfter(1);
 709
 710   HostPortPair server1("www.example.org", 443);
 711   HostPortPair server2("mail.example.org", 443);
 712
 713   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 714   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 715
 716   host_resolver_.set_synchronous_mode(true);
 717   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 718   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 719
 720   // Disable connection pooling.
 721   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 722
 723   QuicStreamRequest request(&factory_);
 724   is_https_ = true;
 725   EXPECT_EQ(OK,
 726             request.Request(server1, is_https_, privacy_mode_, server1.host(),
 727                             "GET", net_log_, callback_.callback()));
 728   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 729   EXPECT_TRUE(stream.get());
 730
 731   TestCompletionCallback callback;
 732   QuicStreamRequest request2(&factory_);
 733   EXPECT_EQ(OK,
 734             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 735                              "GET", net_log_, callback_.callback()));
 736   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 737   EXPECT_TRUE(stream2.get());
 738
 739   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 740                 &factory_, server1, is_https_),
 741             QuicStreamFactoryPeer::GetActiveSession(
 742                 &factory_, server2, is_https_));
 743
 744   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 745   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 746   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 747   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 748 }
 749
 750 class QuicAlternativeServiceCertificateValidationPooling
 751     : public QuicStreamFactoryTest {
 752  public:
 753   void Run(bool valid) {
 754     MockRead reads[] = {
 755         MockRead(ASYNC, OK, 0)  // EOF
 756     };
 757     DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 758     socket_factory_.AddSocketDataProvider(&socket_data1);
 759     socket_data1.StopAfter(1);
 760
 761     HostPortPair server1("www.example.org", 443);
 762     HostPortPair server2("mail.example.org", 443);
 763
 764     std::string origin_host(valid ? "mail.example.org" : "invalid.example.org");
 765     HostPortPair alternative("www.example.org", 443);
 766
 767     ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 768     bool common_name_fallback_used;
 769     EXPECT_EQ(valid,
 770               verify_details.cert_verify_result.verified_cert->VerifyNameMatch(
 771                   origin_host, &common_name_fallback_used));
 772     EXPECT_TRUE(
 773         verify_details.cert_verify_result.verified_cert->VerifyNameMatch(
 774             alternative.host(), &common_name_fallback_used));
 775     crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 776
 777     host_resolver_.set_synchronous_mode(true);
 778     host_resolver_.rules()->AddIPLiteralRule(alternative.host(), "192.168.0.1",
 779                                              "");
 780
 781     // Open first stream to alternative.
 782     QuicStreamRequest request1(&factory_);
 783     is_https_ = true;
 784     EXPECT_EQ(OK, request1.Request(alternative, is_https_, privacy_mode_,
 785                                    alternative.host(), "GET", net_log_,
 786                                    callback_.callback()));
 787     scoped_ptr<QuicHttpStream> stream1 = request1.ReleaseStream();
 788     EXPECT_TRUE(stream1.get());
 789
 790     QuicStreamRequest request2(&factory_);
 791     int rv =
 792         request2.Request(alternative, is_https_, privacy_mode_, origin_host,
 793                          "GET", net_log_, callback_.callback());
 794     if (valid) {
 795       // Alternative service of origin to |alternative| should pool to session
 796       // of |stream1| even if origin is different.  Since only one
 797       // SocketDataProvider is set up, the second request succeeding means that
 798       // it pooled to the session opened by the first one.
 799       EXPECT_EQ(OK, rv);
 800       scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 801       EXPECT_TRUE(stream2.get());
 802     } else {
 803       EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv);
 804     }
 805
 806     EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 807     EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 808   }
 809 };
 810
 811 INSTANTIATE_TEST_CASE_P(Version,
 812                         QuicAlternativeServiceCertificateValidationPooling,
 813                         ::testing::ValuesIn(GetTestParams()));
 814
 815 TEST_P(QuicAlternativeServiceCertificateValidationPooling, Valid) {
 816   Run(true);
 817 }
 818
 819 TEST_P(QuicAlternativeServiceCertificateValidationPooling, Invalid) {
 820   Run(false);
 821 }
 822
 823 TEST_P(QuicStreamFactoryTest, HttpsPoolingWithMatchingPins) {
 824   MockRead reads[] = {
 825     MockRead(ASYNC, OK, 0)  // EOF
 826   };
 827   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 828   socket_factory_.AddSocketDataProvider(&socket_data);
 829   socket_data.StopAfter(1);
 830
 831   HostPortPair server1("www.example.org", 443);
 832   HostPortPair server2("mail.example.org", 443);
 833   uint8 primary_pin = 1;
 834   uint8 backup_pin = 2;
 835   test::AddPin(&transport_security_state_, "mail.example.org", primary_pin,
 836                backup_pin);
 837
 838   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 839   verify_details.cert_verify_result.public_key_hashes.push_back(
 840       test::GetTestHashValue(primary_pin));
 841   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 842
 843   host_resolver_.set_synchronous_mode(true);
 844   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 845   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 846
 847   QuicStreamRequest request(&factory_);
 848   is_https_ = true;
 849   EXPECT_EQ(OK,
 850             request.Request(server1, is_https_, privacy_mode_, server1.host(),
 851                             "GET", net_log_, callback_.callback()));
 852   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 853   EXPECT_TRUE(stream.get());
 854
 855   TestCompletionCallback callback;
 856   QuicStreamRequest request2(&factory_);
 857   EXPECT_EQ(OK,
 858             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 859                              "GET", net_log_, callback_.callback()));
 860   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 861   EXPECT_TRUE(stream2.get());
 862
 863   EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
 864                 &factory_, server1, is_https_),
 865             QuicStreamFactoryPeer::GetActiveSession(
 866                 &factory_, server2, is_https_));
 867
 868   EXPECT_TRUE(socket_data.AllReadDataConsumed());
 869   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 870 }
 871
 872 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithMatchingPinsIfDisabled) {
 873   MockRead reads[] = {
 874     MockRead(ASYNC, OK, 0)  // EOF
 875   };
 876   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 877   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 878   socket_factory_.AddSocketDataProvider(&socket_data1);
 879   socket_factory_.AddSocketDataProvider(&socket_data2);
 880   socket_data1.StopAfter(1);
 881   socket_data2.StopAfter(1);
 882
 883   HostPortPair server1("www.example.org", 443);
 884   HostPortPair server2("mail.example.org", 443);
 885   uint8 primary_pin = 1;
 886   uint8 backup_pin = 2;
 887   test::AddPin(&transport_security_state_, "mail.example.org", primary_pin,
 888                backup_pin);
 889
 890   ProofVerifyDetailsChromium verify_details = DefaultProofVerifyDetails();
 891   verify_details.cert_verify_result.public_key_hashes.push_back(
 892       test::GetTestHashValue(primary_pin));
 893   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details);
 894
 895   host_resolver_.set_synchronous_mode(true);
 896   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 897   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 898
 899   // Disable connection pooling.
 900   QuicStreamFactoryPeer::DisableConnectionPooling(&factory_);
 901
 902   QuicStreamRequest request(&factory_);
 903   is_https_ = true;
 904   EXPECT_EQ(OK,
 905             request.Request(server1, is_https_, privacy_mode_, server1.host(),
 906                             "GET", net_log_, callback_.callback()));
 907   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 908   EXPECT_TRUE(stream.get());
 909
 910   TestCompletionCallback callback;
 911   QuicStreamRequest request2(&factory_);
 912   EXPECT_EQ(OK,
 913             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 914                              "GET", net_log_, callback_.callback()));
 915   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 916   EXPECT_TRUE(stream2.get());
 917
 918   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 919                 &factory_, server1, is_https_),
 920             QuicStreamFactoryPeer::GetActiveSession(
 921                 &factory_, server2, is_https_));
 922
 923   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 924   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 925   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 926   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 927 }
 928
 929 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithDifferentPins) {
 930   MockRead reads[] = {
 931     MockRead(ASYNC, OK, 0)  // EOF
 932   };
 933   DeterministicSocketData socket_data1(reads, arraysize(reads), nullptr, 0);
 934   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 935   socket_factory_.AddSocketDataProvider(&socket_data1);
 936   socket_factory_.AddSocketDataProvider(&socket_data2);
 937   socket_data1.StopAfter(1);
 938   socket_data2.StopAfter(1);
 939
 940   HostPortPair server1("www.example.org", 443);
 941   HostPortPair server2("mail.example.org", 443);
 942   uint8 primary_pin = 1;
 943   uint8 backup_pin = 2;
 944   uint8 bad_pin = 3;
 945   test::AddPin(&transport_security_state_, "mail.example.org", primary_pin,
 946                backup_pin);
 947
 948   ProofVerifyDetailsChromium verify_details1 = DefaultProofVerifyDetails();
 949   verify_details1.cert_verify_result.public_key_hashes.push_back(
 950       test::GetTestHashValue(bad_pin));
 951   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details1);
 952
 953   ProofVerifyDetailsChromium verify_details2 = DefaultProofVerifyDetails();
 954   verify_details2.cert_verify_result.public_key_hashes.push_back(
 955       test::GetTestHashValue(primary_pin));
 956   crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details2);
 957
 958   host_resolver_.set_synchronous_mode(true);
 959   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 960   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 961
 962   QuicStreamRequest request(&factory_);
 963   is_https_ = true;
 964   EXPECT_EQ(OK,
 965             request.Request(server1, is_https_, privacy_mode_, server1.host(),
 966                             "GET", net_log_, callback_.callback()));
 967   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 968   EXPECT_TRUE(stream.get());
 969
 970   TestCompletionCallback callback;
 971   QuicStreamRequest request2(&factory_);
 972   EXPECT_EQ(OK,
 973             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
 974                              "GET", net_log_, callback_.callback()));
 975   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 976   EXPECT_TRUE(stream2.get());
 977
 978   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 979                 &factory_, server1, is_https_),
 980             QuicStreamFactoryPeer::GetActiveSession(
 981                 &factory_, server2, is_https_));
 982
 983   EXPECT_TRUE(socket_data1.AllReadDataConsumed());
 984   EXPECT_TRUE(socket_data1.AllWriteDataConsumed());
 985   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
 986   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
 987 }
 988
 989 TEST_P(QuicStreamFactoryTest, Goaway) {
 990   MockRead reads[] = {
 991     MockRead(ASYNC, OK, 0)  // EOF
 992   };
 993   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
 994   socket_data.StopAfter(1);
 995   socket_factory_.AddSocketDataProvider(&socket_data);
 996   DeterministicSocketData socket_data2(reads, arraysize(reads), nullptr, 0);
 997   socket_data2.StopAfter(1);
 998   socket_factory_.AddSocketDataProvider(&socket_data2);
 999
1000   QuicStreamRequest request(&factory_);
1001   EXPECT_EQ(ERR_IO_PENDING,
1002             request.Request(host_port_pair_, is_https_, privacy_mode_,
1003                             host_port_pair_.host(), "GET", net_log_,
1004                             callback_.callback()));
1005
1006   EXPECT_EQ(OK, callback_.WaitForResult());
1007   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1008   EXPECT_TRUE(stream.get());
1009
1010   // Mark the session as going away.  Ensure that while it is still alive
1011   // that it is no longer active.
1012   QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
1013       &factory_, host_port_pair_, is_https_);
1014   factory_.OnSessionGoingAway(session);
1015   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
1016   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
1017       &factory_, host_port_pair_, is_https_));
1018   EXPECT_FALSE(HasActiveSession(host_port_pair_));
1019
1020   // Create a new request for the same destination and verify that a
1021   // new session is created.
1022   QuicStreamRequest request2(&factory_);
1023   EXPECT_EQ(ERR_IO_PENDING,
1024             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1025                              host_port_pair_.host(), "GET", net_log_,
1026                              callback_.callback()));
1027   EXPECT_EQ(OK, callback_.WaitForResult());
1028   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1029   EXPECT_TRUE(stream2.get());
1030
1031   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_,
1032                                                       host_port_pair_,
1033                                                       is_https_));
1034   EXPECT_NE(session,
1035             QuicStreamFactoryPeer::GetActiveSession(
1036                 &factory_, host_port_pair_, is_https_));
1037   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
1038
1039   stream2.reset();
1040   stream.reset();
1041
1042   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1043   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1044   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1045   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1046 }
1047
1048 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
1049   MockRead reads[] = {
1050     MockRead(ASYNC, OK, 0)  // EOF
1051   };
1052   QuicStreamId stream_id = kClientDataStreamId1;
1053   scoped_ptr<QuicEncryptedPacket> rst(
1054       maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED));
1055   MockWrite writes[] = {
1056     MockWrite(ASYNC, rst->data(), rst->length(), 1),
1057   };
1058   DeterministicSocketData socket_data(reads, arraysize(reads),
1059                                       writes, arraysize(writes));
1060   socket_factory_.AddSocketDataProvider(&socket_data);
1061   socket_data.StopAfter(1);
1062
1063   HttpRequestInfo request_info;
1064   std::vector<QuicHttpStream*> streams;
1065   // The MockCryptoClientStream sets max_open_streams to be
1066   // kDefaultMaxStreamsPerConnection / 2.
1067   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection / 2; i++) {
1068     QuicStreamRequest request(&factory_);
1069     int rv = request.Request(host_port_pair_, is_https_, privacy_mode_,
1070                              host_port_pair_.host(), "GET", net_log_,
1071                              callback_.callback());
1072     if (i == 0) {
1073       EXPECT_EQ(ERR_IO_PENDING, rv);
1074       EXPECT_EQ(OK, callback_.WaitForResult());
1075     } else {
1076       EXPECT_EQ(OK, rv);
1077     }
1078     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1079     EXPECT_TRUE(stream);
1080     EXPECT_EQ(OK, stream->InitializeStream(
1081         &request_info, DEFAULT_PRIORITY, net_log_, CompletionCallback()));
1082     streams.push_back(stream.release());
1083   }
1084
1085   QuicStreamRequest request(&factory_);
1086   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1087                                 host_port_pair_.host(), "GET", net_log_,
1088                                 CompletionCallback()));
1089   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1090   EXPECT_TRUE(stream);
1091   EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream(
1092         &request_info, DEFAULT_PRIORITY, net_log_, callback_.callback()));
1093
1094   // Close the first stream.
1095   streams.front()->Close(false);
1096
1097   ASSERT_TRUE(callback_.have_result());
1098
1099   EXPECT_EQ(OK, callback_.WaitForResult());
1100
1101   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1102   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1103   STLDeleteElements(&streams);
1104 }
1105
1106 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
1107   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
1108   socket_factory_.AddSocketDataProvider(&socket_data);
1109
1110   host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
1111
1112   QuicStreamRequest request(&factory_);
1113   EXPECT_EQ(ERR_IO_PENDING,
1114             request.Request(host_port_pair_, is_https_, privacy_mode_,
1115                             host_port_pair_.host(), "GET", net_log_,
1116                             callback_.callback()));
1117
1118   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
1119
1120   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1121   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1122 }
1123
1124 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
1125   MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
1126   DeterministicSocketData socket_data(nullptr, 0, nullptr, 0);
1127   socket_data.set_connect_data(connect);
1128   socket_factory_.AddSocketDataProvider(&socket_data);
1129   socket_data.StopAfter(1);
1130
1131   QuicStreamRequest request(&factory_);
1132   EXPECT_EQ(ERR_IO_PENDING,
1133             request.Request(host_port_pair_, is_https_, privacy_mode_,
1134                             host_port_pair_.host(), "GET", net_log_,
1135                             callback_.callback()));
1136
1137   EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult());
1138
1139   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1140   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1141 }
1142
1143 TEST_P(QuicStreamFactoryTest, CancelCreate) {
1144   MockRead reads[] = {
1145     MockRead(ASYNC, OK, 0)  // EOF
1146   };
1147   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1148   socket_factory_.AddSocketDataProvider(&socket_data);
1149   {
1150     QuicStreamRequest request(&factory_);
1151     EXPECT_EQ(ERR_IO_PENDING,
1152               request.Request(host_port_pair_, is_https_, privacy_mode_,
1153                               host_port_pair_.host(), "GET", net_log_,
1154                               callback_.callback()));
1155   }
1156
1157   socket_data.StopAfter(1);
1158   base::RunLoop run_loop;
1159   run_loop.RunUntilIdle();
1160
1161   scoped_ptr<QuicHttpStream> stream(CreateFromSession(host_port_pair_));
1162   EXPECT_TRUE(stream.get());
1163   stream.reset();
1164
1165   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1166   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1167 }
1168
1169 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
1170   // Sequentially connect to the default host, then another host, and then the
1171   // default host.  Verify that the default host gets a consistent ephemeral
1172   // port, that is different from the other host's connection.
1173
1174   std::string other_server_name = "other.google.com";
1175   EXPECT_NE(kDefaultServerHostName, other_server_name);
1176   HostPortPair host_port_pair2(other_server_name, kDefaultServerPort);
1177
1178   int original_port = GetSourcePortForNewSession(host_port_pair_);
1179   EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair2));
1180   EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_));
1181 }
1182
1183 TEST_P(QuicStreamFactoryTest, GoAwayDisablesConsistentEphemeralPort) {
1184   // Get a session to the host using the port suggester.
1185   int original_port =
1186       GetSourcePortForNewSessionAndGoAway(host_port_pair_);
1187   // Verify that the port is different after the goaway.
1188   EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair_));
1189   // Since the previous session did not goaway we should see the original port.
1190   EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_));
1191 }
1192
1193 TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
1194   MockRead reads[] = {
1195     MockRead(ASYNC, 0, 0)  // EOF
1196   };
1197   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1198   std::vector<MockWrite> writes;
1199   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1200   DeterministicSocketData socket_data(reads, arraysize(reads),
1201                                       writes.empty() ? nullptr  : &writes[0],
1202                                       writes.size());
1203   socket_factory_.AddSocketDataProvider(&socket_data);
1204   socket_data.StopAfter(1);
1205
1206   MockRead reads2[] = {
1207     MockRead(ASYNC, 0, 0)  // EOF
1208   };
1209   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1210   socket_factory_.AddSocketDataProvider(&socket_data2);
1211   socket_data2.StopAfter(1);
1212
1213   QuicStreamRequest request(&factory_);
1214   EXPECT_EQ(ERR_IO_PENDING,
1215             request.Request(host_port_pair_, is_https_, privacy_mode_,
1216                             host_port_pair_.host(), "GET", net_log_,
1217                             callback_.callback()));
1218
1219   EXPECT_EQ(OK, callback_.WaitForResult());
1220   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1221   HttpRequestInfo request_info;
1222   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1223                                          DEFAULT_PRIORITY,
1224                                          net_log_, CompletionCallback()));
1225
1226   // Close the session and verify that stream saw the error.
1227   factory_.CloseAllSessions(ERR_INTERNET_DISCONNECTED);
1228   EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
1229             stream->ReadResponseHeaders(callback_.callback()));
1230
1231   // Now attempting to request a stream to the same origin should create
1232   // a new session.
1233
1234   QuicStreamRequest request2(&factory_);
1235   EXPECT_EQ(ERR_IO_PENDING,
1236             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1237                              host_port_pair_.host(), "GET", net_log_,
1238                              callback_.callback()));
1239
1240   EXPECT_EQ(OK, callback_.WaitForResult());
1241   stream = request2.ReleaseStream();
1242   stream.reset();  // Will reset stream 3.
1243
1244   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1245   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1246   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1247   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1248 }
1249
1250 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
1251   MockRead reads[] = {
1252     MockRead(ASYNC, 0, 0)  // EOF
1253   };
1254   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1255   std::vector<MockWrite> writes;
1256   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1257   DeterministicSocketData socket_data(reads, arraysize(reads),
1258                                       writes.empty() ? nullptr  : &writes[0],
1259                                       writes.size());
1260   socket_factory_.AddSocketDataProvider(&socket_data);
1261   socket_data.StopAfter(1);
1262
1263   MockRead reads2[] = {
1264     MockRead(ASYNC, 0, 0)  // EOF
1265   };
1266   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1267   socket_factory_.AddSocketDataProvider(&socket_data2);
1268   socket_data2.StopAfter(1);
1269
1270   QuicStreamRequest request(&factory_);
1271   EXPECT_EQ(ERR_IO_PENDING,
1272             request.Request(host_port_pair_, is_https_, privacy_mode_,
1273                             host_port_pair_.host(), "GET", net_log_,
1274                             callback_.callback()));
1275
1276   EXPECT_EQ(OK, callback_.WaitForResult());
1277   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1278   HttpRequestInfo request_info;
1279   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1280                                          DEFAULT_PRIORITY,
1281                                          net_log_, CompletionCallback()));
1282
1283   // Change the IP address and verify that stream saw the error.
1284   factory_.OnIPAddressChanged();
1285   EXPECT_EQ(ERR_NETWORK_CHANGED,
1286             stream->ReadResponseHeaders(callback_.callback()));
1287   EXPECT_TRUE(factory_.require_confirmation());
1288
1289   // Now attempting to request a stream to the same origin should create
1290   // a new session.
1291
1292   QuicStreamRequest request2(&factory_);
1293   EXPECT_EQ(ERR_IO_PENDING,
1294             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1295                              host_port_pair_.host(), "GET", net_log_,
1296                              callback_.callback()));
1297
1298   EXPECT_EQ(OK, callback_.WaitForResult());
1299   stream = request2.ReleaseStream();
1300   stream.reset();  // Will reset stream 3.
1301
1302   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1303   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1304   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1305   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1306 }
1307
1308 TEST_P(QuicStreamFactoryTest, OnCertAdded) {
1309   MockRead reads[] = {
1310     MockRead(ASYNC, 0, 0)  // EOF
1311   };
1312   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1313   std::vector<MockWrite> writes;
1314   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1315   DeterministicSocketData socket_data(reads, arraysize(reads),
1316                                       writes.empty() ? nullptr  : &writes[0],
1317                                       writes.size());
1318   socket_factory_.AddSocketDataProvider(&socket_data);
1319   socket_data.StopAfter(1);
1320
1321   MockRead reads2[] = {
1322     MockRead(ASYNC, 0, 0)  // EOF
1323   };
1324   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1325   socket_factory_.AddSocketDataProvider(&socket_data2);
1326   socket_data2.StopAfter(1);
1327
1328   QuicStreamRequest request(&factory_);
1329   EXPECT_EQ(ERR_IO_PENDING,
1330             request.Request(host_port_pair_, is_https_, privacy_mode_,
1331                             host_port_pair_.host(), "GET", net_log_,
1332                             callback_.callback()));
1333
1334   EXPECT_EQ(OK, callback_.WaitForResult());
1335   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1336   HttpRequestInfo request_info;
1337   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1338                                          DEFAULT_PRIORITY,
1339                                          net_log_, CompletionCallback()));
1340
1341   // Add a cert and verify that stream saw the event.
1342   factory_.OnCertAdded(nullptr);
1343   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
1344             stream->ReadResponseHeaders(callback_.callback()));
1345   EXPECT_FALSE(factory_.require_confirmation());
1346
1347   // Now attempting to request a stream to the same origin should create
1348   // a new session.
1349
1350   QuicStreamRequest request2(&factory_);
1351   EXPECT_EQ(ERR_IO_PENDING,
1352             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1353                              host_port_pair_.host(), "GET", net_log_,
1354                              callback_.callback()));
1355
1356   EXPECT_EQ(OK, callback_.WaitForResult());
1357   stream = request2.ReleaseStream();
1358   stream.reset();  // Will reset stream 3.
1359
1360   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1361   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1362   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1363   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1364 }
1365
1366 TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
1367   MockRead reads[] = {
1368     MockRead(ASYNC, 0, 0)  // EOF
1369   };
1370   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1371   std::vector<MockWrite> writes;
1372   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1373   DeterministicSocketData socket_data(reads, arraysize(reads),
1374                                       writes.empty() ? nullptr  : &writes[0],
1375                                       writes.size());
1376   socket_factory_.AddSocketDataProvider(&socket_data);
1377   socket_data.StopAfter(1);
1378
1379   MockRead reads2[] = {
1380     MockRead(ASYNC, 0, 0)  // EOF
1381   };
1382   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1383   socket_factory_.AddSocketDataProvider(&socket_data2);
1384   socket_data2.StopAfter(1);
1385
1386   QuicStreamRequest request(&factory_);
1387   EXPECT_EQ(ERR_IO_PENDING,
1388             request.Request(host_port_pair_, is_https_, privacy_mode_,
1389                             host_port_pair_.host(), "GET", net_log_,
1390                             callback_.callback()));
1391
1392   EXPECT_EQ(OK, callback_.WaitForResult());
1393   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1394   HttpRequestInfo request_info;
1395   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1396                                          DEFAULT_PRIORITY,
1397                                          net_log_, CompletionCallback()));
1398
1399   // Change the CA cert and verify that stream saw the event.
1400   factory_.OnCACertChanged(nullptr);
1401   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
1402             stream->ReadResponseHeaders(callback_.callback()));
1403   EXPECT_FALSE(factory_.require_confirmation());
1404
1405   // Now attempting to request a stream to the same origin should create
1406   // a new session.
1407
1408   QuicStreamRequest request2(&factory_);
1409   EXPECT_EQ(ERR_IO_PENDING,
1410             request2.Request(host_port_pair_, is_https_, privacy_mode_,
1411                              host_port_pair_.host(), "GET", net_log_,
1412                              callback_.callback()));
1413
1414   EXPECT_EQ(OK, callback_.WaitForResult());
1415   stream = request2.ReleaseStream();
1416   stream.reset();  // Will reset stream 3.
1417
1418   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1419   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1420   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1421   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1422 }
1423
1424 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
1425   vector<string> cannoncial_suffixes;
1426   cannoncial_suffixes.push_back(string(".c.youtube.com"));
1427   cannoncial_suffixes.push_back(string(".googlevideo.com"));
1428
1429   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
1430     string r1_host_name("r1");
1431     string r2_host_name("r2");
1432     r1_host_name.append(cannoncial_suffixes[i]);
1433     r2_host_name.append(cannoncial_suffixes[i]);
1434
1435     HostPortPair host_port_pair1(r1_host_name, 80);
1436     QuicCryptoClientConfig* crypto_config =
1437         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
1438     QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_);
1439     QuicCryptoClientConfig::CachedState* cached1 =
1440         crypto_config->LookupOrCreate(server_id1);
1441     EXPECT_FALSE(cached1->proof_valid());
1442     EXPECT_TRUE(cached1->source_address_token().empty());
1443
1444     // Mutate the cached1 to have different data.
1445     // TODO(rtenneti): mutate other members of CachedState.
1446     cached1->set_source_address_token(r1_host_name);
1447     cached1->SetProofValid();
1448
1449     HostPortPair host_port_pair2(r2_host_name, 80);
1450     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
1451     QuicCryptoClientConfig::CachedState* cached2 =
1452         crypto_config->LookupOrCreate(server_id2);
1453     EXPECT_EQ(cached1->source_address_token(), cached2->source_address_token());
1454     EXPECT_TRUE(cached2->proof_valid());
1455   }
1456 }
1457
1458 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
1459   vector<string> cannoncial_suffixes;
1460   cannoncial_suffixes.push_back(string(".c.youtube.com"));
1461   cannoncial_suffixes.push_back(string(".googlevideo.com"));
1462
1463   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
1464     string r3_host_name("r3");
1465     string r4_host_name("r4");
1466     r3_host_name.append(cannoncial_suffixes[i]);
1467     r4_host_name.append(cannoncial_suffixes[i]);
1468
1469     HostPortPair host_port_pair1(r3_host_name, 80);
1470     QuicCryptoClientConfig* crypto_config =
1471         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
1472     QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_);
1473     QuicCryptoClientConfig::CachedState* cached1 =
1474         crypto_config->LookupOrCreate(server_id1);
1475     EXPECT_FALSE(cached1->proof_valid());
1476     EXPECT_TRUE(cached1->source_address_token().empty());
1477
1478     // Mutate the cached1 to have different data.
1479     // TODO(rtenneti): mutate other members of CachedState.
1480     cached1->set_source_address_token(r3_host_name);
1481     cached1->SetProofInvalid();
1482
1483     HostPortPair host_port_pair2(r4_host_name, 80);
1484     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
1485     QuicCryptoClientConfig::CachedState* cached2 =
1486         crypto_config->LookupOrCreate(server_id2);
1487     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
1488     EXPECT_TRUE(cached2->source_address_token().empty());
1489     EXPECT_FALSE(cached2->proof_valid());
1490   }
1491 }
1492
1493 TEST_P(QuicStreamFactoryTest, RacingConnections) {
1494   if (!GetParam().enable_connection_racing)
1495     return;
1496   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1497   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1498   MockRead reads[] = {
1499       MockRead(ASYNC, OK, 0)  // EOF
1500   };
1501   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1502   socket_factory_.AddSocketDataProvider(&socket_data);
1503   socket_data.StopAfter(1);
1504
1505   MockRead reads2[] = {
1506       MockRead(ASYNC, 0, 0)  // EOF
1507   };
1508   DeterministicSocketData socket_data2(reads2, arraysize(reads2), nullptr, 0);
1509   socket_factory_.AddSocketDataProvider(&socket_data2);
1510   socket_data2.StopAfter(1);
1511
1512   crypto_client_stream_factory_.set_handshake_mode(
1513       MockCryptoClientStream::ZERO_RTT);
1514   host_resolver_.set_synchronous_mode(true);
1515   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1516                                            "192.168.0.1", "");
1517
1518   QuicStreamRequest request(&factory_);
1519   QuicServerId server_id(host_port_pair_, is_https_, privacy_mode_);
1520   EXPECT_EQ(ERR_IO_PENDING,
1521             request.Request(host_port_pair_, is_https_, privacy_mode_,
1522                             host_port_pair_.host(), "GET", net_log_,
1523                             callback_.callback()));
1524   EXPECT_EQ(2u,
1525             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
1526
1527   runner_->RunNextTask();
1528
1529   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1530   EXPECT_TRUE(stream.get());
1531   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1532   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1533   EXPECT_EQ(0u,
1534             QuicStreamFactoryPeer::GetNumberOfActiveJobs(&factory_, server_id));
1535 }
1536
1537 TEST_P(QuicStreamFactoryTest, EnableNotLoadFromDiskCache) {
1538   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1539   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1540   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1541
1542   MockRead reads[] = {
1543       MockRead(ASYNC, OK, 0)  // EOF
1544   };
1545   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1546   socket_factory_.AddSocketDataProvider(&socket_data);
1547   socket_data.StopAfter(1);
1548
1549   crypto_client_stream_factory_.set_handshake_mode(
1550       MockCryptoClientStream::ZERO_RTT);
1551   host_resolver_.set_synchronous_mode(true);
1552   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1553                                            "192.168.0.1", "");
1554
1555   QuicStreamRequest request(&factory_);
1556   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1557                                 host_port_pair_.host(), "GET", net_log_,
1558                                 callback_.callback()));
1559
1560   // If we are waiting for disk cache, we would have posted a task. Verify that
1561   // the CancelWaitForDataReady task hasn't been posted.
1562   ASSERT_EQ(0u, runner_->GetPostedTasks().size());
1563
1564   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1565   EXPECT_TRUE(stream.get());
1566   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1567   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1568 }
1569
1570 TEST_P(QuicStreamFactoryTest, BadPacketLoss) {
1571   factory_.set_quic_server_info_factory(&quic_server_info_factory_);
1572   QuicStreamFactoryPeer::SetTaskRunner(&factory_, runner_.get());
1573   QuicStreamFactoryPeer::SetDisableDiskCache(&factory_, true);
1574   QuicStreamFactoryPeer::SetMaxNumberOfLossyConnections(&factory_, 2);
1575   EXPECT_FALSE(
1576       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1577   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1578                    &factory_, host_port_pair_.port()));
1579
1580   MockRead reads[] = {
1581       MockRead(ASYNC, OK, 0)  // EOF
1582   };
1583   DeterministicSocketData socket_data(reads, arraysize(reads), nullptr, 0);
1584   socket_factory_.AddSocketDataProvider(&socket_data);
1585   socket_data.StopAfter(1);
1586
1587   DeterministicSocketData socket_data2(nullptr, 0, nullptr, 0);
1588   socket_factory_.AddSocketDataProvider(&socket_data2);
1589   socket_data2.StopAfter(1);
1590
1591   DeterministicSocketData socket_data3(nullptr, 0, nullptr, 0);
1592   socket_factory_.AddSocketDataProvider(&socket_data3);
1593   socket_data3.StopAfter(1);
1594
1595   DeterministicSocketData socket_data4(nullptr, 0, nullptr, 0);
1596   socket_factory_.AddSocketDataProvider(&socket_data4);
1597   socket_data4.StopAfter(1);
1598
1599   HostPortPair server2("mail.example.org", kDefaultServerPort);
1600   HostPortPair server3("docs.example.org", kDefaultServerPort);
1601   HostPortPair server4("images.example.org", kDefaultServerPort);
1602
1603   crypto_client_stream_factory_.set_handshake_mode(
1604       MockCryptoClientStream::ZERO_RTT);
1605   host_resolver_.set_synchronous_mode(true);
1606   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
1607                                            "192.168.0.1", "");
1608   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
1609   host_resolver_.rules()->AddIPLiteralRule(server3.host(), "192.168.0.1", "");
1610   host_resolver_.rules()->AddIPLiteralRule(server4.host(), "192.168.0.1", "");
1611
1612   QuicStreamRequest request(&factory_);
1613   EXPECT_EQ(OK, request.Request(host_port_pair_, is_https_, privacy_mode_,
1614                                 host_port_pair_.host(), "GET", net_log_,
1615                                 callback_.callback()));
1616
1617   QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
1618       &factory_, host_port_pair_, is_https_);
1619
1620   DVLOG(1) << "Create 1st session and test packet loss";
1621
1622   // Set packet_loss_rate to a lower value than packet_loss_threshold.
1623   EXPECT_FALSE(
1624       factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/0.9f));
1625   EXPECT_TRUE(session->connection()->connected());
1626   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
1627       &factory_, host_port_pair_, is_https_));
1628   EXPECT_FALSE(
1629       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1630   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1631                    &factory_, host_port_pair_.port()));
1632
1633   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
1634   // and that shouldn't close the session and it shouldn't disable QUIC.
1635   EXPECT_FALSE(
1636       factory_.OnHandshakeConfirmed(session, /*packet_loss_rate=*/1.0f));
1637   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1638                    &factory_, host_port_pair_.port()));
1639   EXPECT_TRUE(session->connection()->connected());
1640   EXPECT_FALSE(
1641       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, host_port_pair_.port()));
1642   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
1643       &factory_, host_port_pair_, is_https_));
1644
1645   // Test N-in-a-row high packet loss connections.
1646
1647   DVLOG(1) << "Create 2nd session and test packet loss";
1648
1649   TestCompletionCallback callback2;
1650   QuicStreamRequest request2(&factory_);
1651   EXPECT_EQ(OK,
1652             request2.Request(server2, is_https_, privacy_mode_, server2.host(),
1653                              "GET", net_log_, callback2.callback()));
1654   QuicClientSession* session2 =
1655       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_);
1656
1657   // If there is no packet loss during handshake confirmation, number of lossy
1658   // connections for the port should be 0.
1659   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1660                    &factory_, server2.port()));
1661   EXPECT_FALSE(
1662       factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/0.9f));
1663   EXPECT_EQ(0, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1664                    &factory_, server2.port()));
1665   EXPECT_FALSE(
1666       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
1667
1668   // Set packet_loss_rate to a higher value than packet_loss_threshold only once
1669   // and that shouldn't close the session and it shouldn't disable QUIC.
1670   EXPECT_FALSE(
1671       factory_.OnHandshakeConfirmed(session2, /*packet_loss_rate=*/1.0f));
1672   EXPECT_EQ(1, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1673                    &factory_, server2.port()));
1674   EXPECT_TRUE(session2->connection()->connected());
1675   EXPECT_FALSE(
1676       QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server2.port()));
1677   EXPECT_TRUE(
1678       QuicStreamFactoryPeer::HasActiveSession(&factory_, server2, is_https_));
1679
1680   DVLOG(1) << "Create 3rd session which also has packet loss";
1681
1682   TestCompletionCallback callback3;
1683   QuicStreamRequest request3(&factory_);
1684   EXPECT_EQ(OK,
1685             request3.Request(server3, is_https_, privacy_mode_, server3.host(),
1686                              "GET", net_log_, callback3.callback()));
1687   QuicClientSession* session3 =
1688       QuicStreamFactoryPeer::GetActiveSession(&factory_, server3, is_https_);
1689
1690   DVLOG(1) << "Create 4th session with packet loss and test IsQuicDisabled()";
1691   TestCompletionCallback callback4;
1692   QuicStreamRequest request4(&factory_);
1693   EXPECT_EQ(OK,
1694             request4.Request(server4, is_https_, privacy_mode_, server4.host(),
1695                              "GET", net_log_, callback4.callback()));
1696   QuicClientSession* session4 =
1697       QuicStreamFactoryPeer::GetActiveSession(&factory_, server4, is_https_);
1698
1699   // Set packet_loss_rate to higher value than packet_loss_threshold 2nd time in
1700   // a row and that should close the session and disable QUIC.
1701   EXPECT_TRUE(
1702       factory_.OnHandshakeConfirmed(session3, /*packet_loss_rate=*/1.0f));
1703   EXPECT_EQ(2, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1704                    &factory_, server3.port()));
1705   EXPECT_FALSE(session3->connection()->connected());
1706   EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server3.port()));
1707   EXPECT_FALSE(
1708       QuicStreamFactoryPeer::HasActiveSession(&factory_, server3, is_https_));
1709   EXPECT_FALSE(HasActiveSession(server3));
1710
1711   // Set packet_loss_rate to higher value than packet_loss_threshold 3rd time in
1712   // a row and IsQuicDisabled() should close the session.
1713   EXPECT_TRUE(
1714       factory_.OnHandshakeConfirmed(session4, /*packet_loss_rate=*/1.0f));
1715   EXPECT_EQ(3, QuicStreamFactoryPeer::GetNumberOfLossyConnections(
1716                    &factory_, server4.port()));
1717   EXPECT_FALSE(session4->connection()->connected());
1718   EXPECT_TRUE(QuicStreamFactoryPeer::IsQuicDisabled(&factory_, server4.port()));
1719   EXPECT_FALSE(
1720       QuicStreamFactoryPeer::HasActiveSession(&factory_, server4, is_https_));
1721   EXPECT_FALSE(HasActiveSession(server4));
1722
1723   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1724   EXPECT_TRUE(stream.get());
1725   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
1726   EXPECT_TRUE(stream2.get());
1727   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
1728   EXPECT_TRUE(stream3.get());
1729   scoped_ptr<QuicHttpStream> stream4 = request4.ReleaseStream();
1730   EXPECT_TRUE(stream4.get());
1731   EXPECT_TRUE(socket_data.AllReadDataConsumed());
1732   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
1733   EXPECT_TRUE(socket_data2.AllReadDataConsumed());
1734   EXPECT_TRUE(socket_data2.AllWriteDataConsumed());
1735   EXPECT_TRUE(socket_data3.AllReadDataConsumed());
1736   EXPECT_TRUE(socket_data3.AllWriteDataConsumed());
1737   EXPECT_TRUE(socket_data4.AllReadDataConsumed());
1738   EXPECT_TRUE(socket_data4.AllWriteDataConsumed());
1739 }
1740
1741 }  // namespace test
1742 }  // namespace net