src/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 "net/base/test_data_directory.h"
  10 #include "net/cert/cert_verifier.h"
  11 #include "net/dns/mock_host_resolver.h"
  12 #include "net/http/http_response_headers.h"
  13 #include "net/http/http_response_info.h"
  14 #include "net/http/http_util.h"
  15 #include "net/http/transport_security_state.h"
  16 #include "net/quic/crypto/crypto_handshake.h"
  17 #include "net/quic/crypto/proof_verifier_chromium.h"
  18 #include "net/quic/crypto/quic_decrypter.h"
  19 #include "net/quic/crypto/quic_encrypter.h"
  20 #include "net/quic/quic_http_stream.h"
  21 #include "net/quic/quic_server_id.h"
  22 #include "net/quic/test_tools/mock_clock.h"
  23 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
  24 #include "net/quic/test_tools/mock_random.h"
  25 #include "net/quic/test_tools/quic_test_packet_maker.h"
  26 #include "net/quic/test_tools/quic_test_utils.h"
  27 #include "net/socket/socket_test_util.h"
  28 #include "net/test/cert_test_util.h"
  29 #include "testing/gtest/include/gtest/gtest.h"
  30
  31 using base::StringPiece;
  32 using std::string;
  33 using std::vector;
  34
  35 namespace net {
  36 namespace test {
  37
  38 namespace {
  39 const char kDefaultServerHostName[] = "www.google.com";
  40 const int kDefaultServerPort = 443;
  41 }  // namespace anonymous
  42
  43 class QuicStreamFactoryPeer {
  44  public:
  45   static QuicCryptoClientConfig* GetCryptoConfig(QuicStreamFactory* factory) {
  46     return &factory->crypto_config_;
  47   }
  48
  49   static bool HasActiveSession(QuicStreamFactory* factory,
  50                                const HostPortPair& host_port_pair,
  51                                bool is_https) {
  52     QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
  53     return factory->HasActiveSession(server_id);
  54   }
  55
  56   static QuicClientSession* GetActiveSession(
  57       QuicStreamFactory* factory,
  58       const HostPortPair& host_port_pair,
  59       bool is_https) {
  60     QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
  61     DCHECK(factory->HasActiveSession(server_id));
  62     return factory->active_sessions_[server_id];
  63   }
  64
  65   static scoped_ptr<QuicHttpStream> CreateIfSessionExists(
  66       QuicStreamFactory* factory,
  67       const HostPortPair& host_port_pair,
  68       bool is_https,
  69       const BoundNetLog& net_log) {
  70     QuicServerId server_id(host_port_pair, is_https, PRIVACY_MODE_DISABLED);
  71     return factory->CreateIfSessionExists(server_id, net_log);
  72   }
  73
  74   static bool IsLiveSession(QuicStreamFactory* factory,
  75                             QuicClientSession* session) {
  76     for (QuicStreamFactory::SessionIdMap::iterator it =
  77              factory->all_sessions_.begin();
  78          it != factory->all_sessions_.end(); ++it) {
  79       if (it->first == session)
  80         return true;
  81     }
  82     return false;
  83   }
  84 };
  85
  86 class QuicStreamFactoryTest : public ::testing::TestWithParam<QuicVersion> {
  87  protected:
  88   QuicStreamFactoryTest()
  89       : random_generator_(0),
  90         maker_(GetParam(), 0),
  91         clock_(new MockClock()),
  92         cert_verifier_(CertVerifier::CreateDefault()),
  93         factory_(&host_resolver_, &socket_factory_,
  94                  base::WeakPtr<HttpServerProperties>(), cert_verifier_.get(),
  95                  &transport_security_state_,
  96                  &crypto_client_stream_factory_, &random_generator_, clock_,
  97                  kDefaultMaxPacketSize, std::string(),
  98                  SupportedVersions(GetParam()), true, true, true),
  99         host_port_pair_(kDefaultServerHostName, kDefaultServerPort),
 100         is_https_(false),
 101         privacy_mode_(PRIVACY_MODE_DISABLED) {
 102     factory_.set_require_confirmation(false);
 103   }
 104
 105   scoped_ptr<QuicHttpStream> CreateIfSessionExists(
 106       const HostPortPair& host_port_pair,
 107       const BoundNetLog& net_log) {
 108     return QuicStreamFactoryPeer::CreateIfSessionExists(
 109         &factory_, host_port_pair, false, net_log_);
 110   }
 111
 112   int GetSourcePortForNewSession(const HostPortPair& destination) {
 113     return GetSourcePortForNewSessionInner(destination, false);
 114   }
 115
 116   int GetSourcePortForNewSessionAndGoAway(
 117       const HostPortPair& destination) {
 118     return GetSourcePortForNewSessionInner(destination, true);
 119   }
 120
 121   int GetSourcePortForNewSessionInner(const HostPortPair& destination,
 122                                       bool goaway_received) {
 123     // Should only be called if there is no active session for this destination.
 124     EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get());
 125     size_t socket_count = socket_factory_.udp_client_sockets().size();
 126
 127     MockRead reads[] = {
 128       MockRead(ASYNC, OK, 0)  // EOF
 129     };
 130     DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 131     socket_data.StopAfter(1);
 132     socket_factory_.AddSocketDataProvider(&socket_data);
 133
 134     QuicStreamRequest request(&factory_);
 135     EXPECT_EQ(ERR_IO_PENDING,
 136               request.Request(destination,
 137                               is_https_,
 138                               privacy_mode_,
 139                               "GET",
 140                               net_log_,
 141                               callback_.callback()));
 142
 143     EXPECT_EQ(OK, callback_.WaitForResult());
 144     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 145     EXPECT_TRUE(stream.get());
 146     stream.reset();
 147
 148     QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
 149         &factory_, destination, is_https_);
 150
 151     if (socket_count + 1 != socket_factory_.udp_client_sockets().size()) {
 152       EXPECT_TRUE(false);
 153       return 0;
 154     }
 155
 156     IPEndPoint endpoint;
 157     socket_factory_.
 158         udp_client_sockets()[socket_count]->GetLocalAddress(&endpoint);
 159     int port = endpoint.port();
 160     if (goaway_received) {
 161       QuicGoAwayFrame goaway(QUIC_NO_ERROR, 1, "");
 162       session->OnGoAway(goaway);
 163     }
 164
 165     factory_.OnSessionClosed(session);
 166     EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get());
 167     EXPECT_TRUE(socket_data.at_read_eof());
 168     EXPECT_TRUE(socket_data.at_write_eof());
 169     return port;
 170   }
 171
 172   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
 173     QuicStreamId stream_id = kClientDataStreamId1;
 174     return maker_.MakeRstPacket(
 175         1, true, stream_id,
 176         AdjustErrorForVersion(QUIC_RST_FLOW_CONTROL_ACCOUNTING, GetParam()));
 177   }
 178
 179   MockHostResolver host_resolver_;
 180   DeterministicMockClientSocketFactory socket_factory_;
 181   MockCryptoClientStreamFactory crypto_client_stream_factory_;
 182   MockRandom random_generator_;
 183   QuicTestPacketMaker maker_;
 184   MockClock* clock_;  // Owned by factory_.
 185   scoped_ptr<CertVerifier> cert_verifier_;
 186   TransportSecurityState transport_security_state_;
 187   QuicStreamFactory factory_;
 188   HostPortPair host_port_pair_;
 189   bool is_https_;
 190   PrivacyMode privacy_mode_;
 191   BoundNetLog net_log_;
 192   TestCompletionCallback callback_;
 193 };
 194
 195 INSTANTIATE_TEST_CASE_P(Version, QuicStreamFactoryTest,
 196                         ::testing::ValuesIn(QuicSupportedVersions()));
 197
 198 TEST_P(QuicStreamFactoryTest, CreateIfSessionExists) {
 199   EXPECT_EQ(NULL, CreateIfSessionExists(host_port_pair_, net_log_).get());
 200 }
 201
 202 TEST_P(QuicStreamFactoryTest, Create) {
 203   MockRead reads[] = {
 204     MockRead(ASYNC, OK, 0)  // EOF
 205   };
 206   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 207   socket_factory_.AddSocketDataProvider(&socket_data);
 208   socket_data.StopAfter(1);
 209
 210   QuicStreamRequest request(&factory_);
 211   EXPECT_EQ(ERR_IO_PENDING,
 212             request.Request(host_port_pair_,
 213                             is_https_,
 214                             privacy_mode_,
 215                             "GET",
 216                             net_log_,
 217                             callback_.callback()));
 218
 219   EXPECT_EQ(OK, callback_.WaitForResult());
 220   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 221   EXPECT_TRUE(stream.get());
 222
 223   // Will reset stream 3.
 224   stream = CreateIfSessionExists(host_port_pair_, net_log_);
 225   EXPECT_TRUE(stream.get());
 226
 227   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
 228   // in streams on different sessions.
 229   QuicStreamRequest request2(&factory_);
 230   EXPECT_EQ(OK,
 231             request2.Request(host_port_pair_,
 232                              is_https_,
 233                              privacy_mode_,
 234                              "GET",
 235                              net_log_,
 236                              callback_.callback()));
 237   stream = request2.ReleaseStream();  // Will reset stream 5.
 238   stream.reset();  // Will reset stream 7.
 239
 240   EXPECT_TRUE(socket_data.at_read_eof());
 241   EXPECT_TRUE(socket_data.at_write_eof());
 242 }
 243
 244 TEST_P(QuicStreamFactoryTest, CreateZeroRtt) {
 245   MockRead reads[] = {
 246     MockRead(ASYNC, OK, 0)  // EOF
 247   };
 248   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 249   socket_factory_.AddSocketDataProvider(&socket_data);
 250   socket_data.StopAfter(1);
 251
 252   crypto_client_stream_factory_.set_handshake_mode(
 253       MockCryptoClientStream::ZERO_RTT);
 254   host_resolver_.set_synchronous_mode(true);
 255   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 256                                            "192.168.0.1", "");
 257
 258   QuicStreamRequest request(&factory_);
 259   EXPECT_EQ(OK,
 260             request.Request(host_port_pair_,
 261                             is_https_,
 262                             privacy_mode_,
 263                             "GET",
 264                             net_log_,
 265                             callback_.callback()));
 266
 267   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 268   EXPECT_TRUE(stream.get());
 269   EXPECT_TRUE(socket_data.at_read_eof());
 270   EXPECT_TRUE(socket_data.at_write_eof());
 271 }
 272
 273 TEST_P(QuicStreamFactoryTest, CreateZeroRttPost) {
 274   MockRead reads[] = {
 275     MockRead(ASYNC, OK, 0)  // EOF
 276   };
 277   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 278   socket_factory_.AddSocketDataProvider(&socket_data);
 279   socket_data.StopAfter(1);
 280
 281   crypto_client_stream_factory_.set_handshake_mode(
 282       MockCryptoClientStream::ZERO_RTT);
 283   host_resolver_.set_synchronous_mode(true);
 284   host_resolver_.rules()->AddIPLiteralRule(host_port_pair_.host(),
 285                                            "192.168.0.1", "");
 286
 287   QuicStreamRequest request(&factory_);
 288   // Posts require handshake confirmation, so this will return asynchronously.
 289   EXPECT_EQ(ERR_IO_PENDING,
 290             request.Request(host_port_pair_,
 291                             is_https_,
 292                             privacy_mode_,
 293                             "POST",
 294                             net_log_,
 295                             callback_.callback()));
 296
 297   // Confirm the handshake and verify that the stream is created.
 298   crypto_client_stream_factory_.last_stream()->SendOnCryptoHandshakeEvent(
 299       QuicSession::HANDSHAKE_CONFIRMED);
 300
 301   EXPECT_EQ(OK, callback_.WaitForResult());
 302   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 303   EXPECT_TRUE(stream.get());
 304   EXPECT_TRUE(socket_data.at_read_eof());
 305   EXPECT_TRUE(socket_data.at_write_eof());
 306 }
 307
 308 TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
 309   MockRead reads[] = {
 310     MockRead(ASYNC, OK, 0)  // EOF
 311   };
 312   DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
 313   DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
 314   socket_factory_.AddSocketDataProvider(&socket_data1);
 315   socket_factory_.AddSocketDataProvider(&socket_data2);
 316   socket_data1.StopAfter(1);
 317   socket_data2.StopAfter(1);
 318
 319   QuicStreamRequest request(&factory_);
 320   EXPECT_EQ(ERR_IO_PENDING,
 321             request.Request(host_port_pair_,
 322                             is_https_,
 323                             privacy_mode_,
 324                             "GET",
 325                             net_log_,
 326                             callback_.callback()));
 327
 328   EXPECT_EQ(OK, callback_.WaitForResult());
 329   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 330   EXPECT_TRUE(stream.get());
 331
 332   QuicStreamRequest request2(&factory_);
 333   EXPECT_EQ(ERR_IO_PENDING,
 334             request2.Request(host_port_pair_,
 335                              !is_https_,
 336                              privacy_mode_,
 337                              "GET",
 338                              net_log_,
 339                              callback_.callback()));
 340   EXPECT_EQ(OK, callback_.WaitForResult());
 341   stream = request2.ReleaseStream();
 342   EXPECT_TRUE(stream.get());
 343   stream.reset();
 344
 345   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 346                 &factory_, host_port_pair_, is_https_),
 347             QuicStreamFactoryPeer::GetActiveSession(
 348                 &factory_, host_port_pair_, !is_https_));
 349
 350   EXPECT_TRUE(socket_data1.at_read_eof());
 351   EXPECT_TRUE(socket_data1.at_write_eof());
 352   EXPECT_TRUE(socket_data2.at_read_eof());
 353   EXPECT_TRUE(socket_data2.at_write_eof());
 354 }
 355
 356 // TODO(rch): re-enable this.
 357 TEST_P(QuicStreamFactoryTest, DISABLED_Pooling) {
 358   MockRead reads[] = {
 359     MockRead(ASYNC, OK, 0)  // EOF
 360   };
 361   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 362   socket_factory_.AddSocketDataProvider(&socket_data);
 363   socket_data.StopAfter(1);
 364
 365   HostPortPair server2("mail.google.com", kDefaultServerPort);
 366   host_resolver_.set_synchronous_mode(true);
 367   host_resolver_.rules()->AddIPLiteralRule(
 368       kDefaultServerHostName, "192.168.0.1", "");
 369   host_resolver_.rules()->AddIPLiteralRule(
 370       "mail.google.com", "192.168.0.1", "");
 371
 372   QuicStreamRequest request(&factory_);
 373   EXPECT_EQ(OK,
 374             request.Request(host_port_pair_,
 375                             is_https_,
 376                             privacy_mode_,
 377                             "GET",
 378                             net_log_,
 379                             callback_.callback()));
 380   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 381   EXPECT_TRUE(stream.get());
 382
 383   TestCompletionCallback callback;
 384   QuicStreamRequest request2(&factory_);
 385   EXPECT_EQ(OK,
 386             request2.Request(server2,
 387                              is_https_,
 388                              privacy_mode_,
 389                              "GET",
 390                              net_log_,
 391                              callback.callback()));
 392   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 393   EXPECT_TRUE(stream2.get());
 394
 395   EXPECT_EQ(
 396       QuicStreamFactoryPeer::GetActiveSession(
 397           &factory_, host_port_pair_, is_https_),
 398       QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 399
 400   EXPECT_TRUE(socket_data.at_read_eof());
 401   EXPECT_TRUE(socket_data.at_write_eof());
 402 }
 403
 404 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
 405   MockRead reads[] = {
 406     MockRead(ASYNC, OK, 0)  // EOF
 407   };
 408   DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
 409   DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
 410   socket_factory_.AddSocketDataProvider(&socket_data1);
 411   socket_factory_.AddSocketDataProvider(&socket_data2);
 412   socket_data1.StopAfter(1);
 413   socket_data2.StopAfter(1);
 414
 415   HostPortPair server2("mail.google.com", kDefaultServerPort);
 416   host_resolver_.set_synchronous_mode(true);
 417   host_resolver_.rules()->AddIPLiteralRule(
 418       kDefaultServerHostName, "192.168.0.1", "");
 419   host_resolver_.rules()->AddIPLiteralRule(
 420       "mail.google.com", "192.168.0.1", "");
 421
 422   QuicStreamRequest request(&factory_);
 423   EXPECT_EQ(OK,
 424             request.Request(host_port_pair_,
 425                             is_https_,
 426                             privacy_mode_,
 427                             "GET",
 428                             net_log_,
 429                             callback_.callback()));
 430   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 431   EXPECT_TRUE(stream.get());
 432
 433   TestCompletionCallback callback;
 434   QuicStreamRequest request2(&factory_);
 435   EXPECT_EQ(OK,
 436             request2.Request(server2,
 437                              is_https_,
 438                              privacy_mode_,
 439                              "GET",
 440                              net_log_,
 441                              callback.callback()));
 442   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 443   EXPECT_TRUE(stream2.get());
 444
 445   factory_.OnSessionGoingAway(QuicStreamFactoryPeer::GetActiveSession(
 446       &factory_, host_port_pair_, is_https_));
 447   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
 448       &factory_, host_port_pair_, is_https_));
 449   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
 450       &factory_, server2, is_https_));
 451
 452   TestCompletionCallback callback3;
 453   QuicStreamRequest request3(&factory_);
 454   EXPECT_EQ(OK,
 455             request3.Request(server2,
 456                              is_https_,
 457                              privacy_mode_,
 458                              "GET",
 459                              net_log_,
 460                              callback3.callback()));
 461   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
 462   EXPECT_TRUE(stream3.get());
 463
 464   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
 465       &factory_, server2, is_https_));
 466
 467   EXPECT_TRUE(socket_data1.at_read_eof());
 468   EXPECT_TRUE(socket_data1.at_write_eof());
 469   EXPECT_TRUE(socket_data2.at_read_eof());
 470   EXPECT_TRUE(socket_data2.at_write_eof());
 471 }
 472
 473 // TODO(rch): re-enable this.
 474 TEST_P(QuicStreamFactoryTest, DISABLED_HttpsPooling) {
 475   MockRead reads[] = {
 476     MockRead(ASYNC, OK, 0)  // EOF
 477   };
 478   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 479   socket_factory_.AddSocketDataProvider(&socket_data);
 480   socket_data.StopAfter(1);
 481
 482   HostPortPair server1("www.example.org", 443);
 483   HostPortPair server2("mail.example.org", 443);
 484
 485   // Load a cert that is valid for:
 486   //   www.example.org (server1)
 487   //   mail.example.org (server2)
 488   //   www.example.com
 489   base::FilePath certs_dir = GetTestCertsDirectory();
 490   scoped_refptr<X509Certificate> test_cert(
 491       ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
 492   ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert);
 493   ProofVerifyDetailsChromium verify_details;
 494   verify_details.cert_verify_result.verified_cert = test_cert;
 495   crypto_client_stream_factory_.set_proof_verify_details(&verify_details);
 496
 497   host_resolver_.set_synchronous_mode(true);
 498   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 499   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 500
 501   QuicStreamRequest request(&factory_);
 502   is_https_ = true;
 503   EXPECT_EQ(OK,
 504             request.Request(server1,
 505                             is_https_,
 506                             privacy_mode_,
 507                             "GET",
 508                             net_log_,
 509                             callback_.callback()));
 510   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 511   EXPECT_TRUE(stream.get());
 512
 513   TestCompletionCallback callback;
 514   QuicStreamRequest request2(&factory_);
 515   EXPECT_EQ(OK,
 516             request2.Request(server2,
 517                              is_https_,
 518                              privacy_mode_,
 519                              "GET",
 520                              net_log_,
 521                              callback_.callback()));
 522   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 523   EXPECT_TRUE(stream2.get());
 524
 525   EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
 526                 &factory_, server1, is_https_),
 527             QuicStreamFactoryPeer::GetActiveSession(
 528                 &factory_, server2, is_https_));
 529
 530   EXPECT_TRUE(socket_data.at_read_eof());
 531   EXPECT_TRUE(socket_data.at_write_eof());
 532 }
 533
 534 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) {
 535   MockRead reads[] = {
 536     MockRead(ASYNC, OK, 0)  // EOF
 537   };
 538   DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
 539   DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
 540   socket_factory_.AddSocketDataProvider(&socket_data1);
 541   socket_factory_.AddSocketDataProvider(&socket_data2);
 542   socket_data1.StopAfter(1);
 543   socket_data2.StopAfter(1);
 544
 545   HostPortPair server1("www.example.org", 443);
 546   HostPortPair server2("mail.google.com", 443);
 547
 548   // Load a cert that is valid for:
 549   //   www.example.org (server1)
 550   //   mail.example.org
 551   //   www.example.com
 552   // But is not valid for mail.google.com (server2).
 553   base::FilePath certs_dir = GetTestCertsDirectory();
 554   scoped_refptr<X509Certificate> test_cert(
 555       ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
 556   ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert);
 557   ProofVerifyDetailsChromium verify_details;
 558   verify_details.cert_verify_result.verified_cert = test_cert;
 559   crypto_client_stream_factory_.set_proof_verify_details(&verify_details);
 560
 561
 562   host_resolver_.set_synchronous_mode(true);
 563   host_resolver_.rules()->AddIPLiteralRule(server1.host(), "192.168.0.1", "");
 564   host_resolver_.rules()->AddIPLiteralRule(server2.host(), "192.168.0.1", "");
 565
 566   QuicStreamRequest request(&factory_);
 567   is_https_ = true;
 568   EXPECT_EQ(OK,
 569             request.Request(server1,
 570                             is_https_,
 571                             privacy_mode_,
 572                             "GET",
 573                             net_log_,
 574                             callback_.callback()));
 575   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 576   EXPECT_TRUE(stream.get());
 577
 578   TestCompletionCallback callback;
 579   QuicStreamRequest request2(&factory_);
 580   EXPECT_EQ(OK,
 581             request2.Request(server2,
 582                              is_https_,
 583                              privacy_mode_,
 584                              "GET",
 585                              net_log_,
 586                              callback_.callback()));
 587   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 588   EXPECT_TRUE(stream2.get());
 589
 590   EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
 591                 &factory_, server1, is_https_),
 592             QuicStreamFactoryPeer::GetActiveSession(
 593                 &factory_, server2, is_https_));
 594
 595   EXPECT_TRUE(socket_data1.at_read_eof());
 596   EXPECT_TRUE(socket_data1.at_write_eof());
 597   EXPECT_TRUE(socket_data2.at_read_eof());
 598   EXPECT_TRUE(socket_data2.at_write_eof());
 599 }
 600
 601 TEST_P(QuicStreamFactoryTest, Goaway) {
 602   MockRead reads[] = {
 603     MockRead(ASYNC, OK, 0)  // EOF
 604   };
 605   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 606   socket_data.StopAfter(1);
 607   socket_factory_.AddSocketDataProvider(&socket_data);
 608   DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
 609   socket_data2.StopAfter(1);
 610   socket_factory_.AddSocketDataProvider(&socket_data2);
 611
 612   QuicStreamRequest request(&factory_);
 613   EXPECT_EQ(ERR_IO_PENDING,
 614             request.Request(host_port_pair_,
 615                             is_https_,
 616                             privacy_mode_,
 617                             "GET",
 618                             net_log_,
 619                             callback_.callback()));
 620
 621   EXPECT_EQ(OK, callback_.WaitForResult());
 622   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 623   EXPECT_TRUE(stream.get());
 624
 625   // Mark the session as going away.  Ensure that while it is still alive
 626   // that it is no longer active.
 627   QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
 628       &factory_, host_port_pair_, is_https_);
 629   factory_.OnSessionGoingAway(session);
 630   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
 631   EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
 632       &factory_, host_port_pair_, is_https_));
 633   EXPECT_EQ(NULL, CreateIfSessionExists(host_port_pair_, net_log_).get());
 634
 635   // Create a new request for the same destination and verify that a
 636   // new session is created.
 637   QuicStreamRequest request2(&factory_);
 638   EXPECT_EQ(ERR_IO_PENDING,
 639             request2.Request(host_port_pair_,
 640                              is_https_,
 641                              privacy_mode_,
 642                              "GET",
 643                              net_log_,
 644                              callback_.callback()));
 645   EXPECT_EQ(OK, callback_.WaitForResult());
 646   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
 647   EXPECT_TRUE(stream2.get());
 648
 649   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_,
 650                                                       host_port_pair_,
 651                                                       is_https_));
 652   EXPECT_NE(session,
 653             QuicStreamFactoryPeer::GetActiveSession(
 654                 &factory_, host_port_pair_, is_https_));
 655   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
 656
 657   stream2.reset();
 658   stream.reset();
 659
 660   EXPECT_TRUE(socket_data.at_read_eof());
 661   EXPECT_TRUE(socket_data.at_write_eof());
 662   EXPECT_TRUE(socket_data2.at_read_eof());
 663   EXPECT_TRUE(socket_data2.at_write_eof());
 664 }
 665
 666 TEST_P(QuicStreamFactoryTest, MaxOpenStream) {
 667   MockRead reads[] = {
 668     MockRead(ASYNC, OK, 0)  // EOF
 669   };
 670   QuicStreamId stream_id = kClientDataStreamId1;
 671   scoped_ptr<QuicEncryptedPacket> rst(
 672       maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_CANCELLED));
 673   MockWrite writes[] = {
 674     MockWrite(ASYNC, rst->data(), rst->length(), 1),
 675   };
 676   DeterministicSocketData socket_data(reads, arraysize(reads),
 677                                       writes, arraysize(writes));
 678   socket_factory_.AddSocketDataProvider(&socket_data);
 679   socket_data.StopAfter(1);
 680
 681   HttpRequestInfo request_info;
 682   std::vector<QuicHttpStream*> streams;
 683   // The MockCryptoClientStream sets max_open_streams to be
 684   // 2 * kDefaultMaxStreamsPerConnection.
 685   for (size_t i = 0; i < 2 * kDefaultMaxStreamsPerConnection; i++) {
 686     QuicStreamRequest request(&factory_);
 687     int rv = request.Request(host_port_pair_,
 688                              is_https_,
 689                              privacy_mode_,
 690                              "GET",
 691                              net_log_,
 692                              callback_.callback());
 693     if (i == 0) {
 694       EXPECT_EQ(ERR_IO_PENDING, rv);
 695       EXPECT_EQ(OK, callback_.WaitForResult());
 696     } else {
 697       EXPECT_EQ(OK, rv);
 698     }
 699     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 700     EXPECT_TRUE(stream);
 701     EXPECT_EQ(OK, stream->InitializeStream(
 702         &request_info, DEFAULT_PRIORITY, net_log_, CompletionCallback()));
 703     streams.push_back(stream.release());
 704   }
 705
 706   QuicStreamRequest request(&factory_);
 707   EXPECT_EQ(OK,
 708             request.Request(host_port_pair_,
 709                             is_https_,
 710                             privacy_mode_,
 711                             "GET",
 712                             net_log_,
 713                             CompletionCallback()));
 714   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 715   EXPECT_TRUE(stream);
 716   EXPECT_EQ(ERR_IO_PENDING, stream->InitializeStream(
 717         &request_info, DEFAULT_PRIORITY, net_log_, callback_.callback()));
 718
 719   // Close the first stream.
 720   streams.front()->Close(false);
 721
 722   ASSERT_TRUE(callback_.have_result());
 723
 724   EXPECT_EQ(OK, callback_.WaitForResult());
 725
 726   EXPECT_TRUE(socket_data.at_read_eof());
 727   EXPECT_TRUE(socket_data.at_write_eof());
 728   STLDeleteElements(&streams);
 729 }
 730
 731 TEST_P(QuicStreamFactoryTest, ResolutionErrorInCreate) {
 732   DeterministicSocketData socket_data(NULL, 0, NULL, 0);
 733   socket_factory_.AddSocketDataProvider(&socket_data);
 734
 735   host_resolver_.rules()->AddSimulatedFailure(kDefaultServerHostName);
 736
 737   QuicStreamRequest request(&factory_);
 738   EXPECT_EQ(ERR_IO_PENDING,
 739             request.Request(host_port_pair_,
 740                             is_https_,
 741                             privacy_mode_,
 742                             "GET",
 743                             net_log_,
 744                             callback_.callback()));
 745
 746   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
 747
 748   EXPECT_TRUE(socket_data.at_read_eof());
 749   EXPECT_TRUE(socket_data.at_write_eof());
 750 }
 751
 752 TEST_P(QuicStreamFactoryTest, ConnectErrorInCreate) {
 753   MockConnect connect(SYNCHRONOUS, ERR_ADDRESS_IN_USE);
 754   DeterministicSocketData socket_data(NULL, 0, NULL, 0);
 755   socket_data.set_connect_data(connect);
 756   socket_factory_.AddSocketDataProvider(&socket_data);
 757   socket_data.StopAfter(1);
 758
 759   QuicStreamRequest request(&factory_);
 760   EXPECT_EQ(ERR_IO_PENDING,
 761             request.Request(host_port_pair_,
 762                             is_https_,
 763                             privacy_mode_,
 764                             "GET",
 765                             net_log_,
 766                             callback_.callback()));
 767
 768   EXPECT_EQ(ERR_ADDRESS_IN_USE, callback_.WaitForResult());
 769
 770   EXPECT_TRUE(socket_data.at_read_eof());
 771   EXPECT_TRUE(socket_data.at_write_eof());
 772 }
 773
 774 TEST_P(QuicStreamFactoryTest, CancelCreate) {
 775   MockRead reads[] = {
 776     MockRead(ASYNC, OK, 0)  // EOF
 777   };
 778   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
 779   socket_factory_.AddSocketDataProvider(&socket_data);
 780   {
 781     QuicStreamRequest request(&factory_);
 782     EXPECT_EQ(ERR_IO_PENDING,
 783               request.Request(host_port_pair_,
 784                               is_https_,
 785                               privacy_mode_,
 786                               "GET",
 787                               net_log_,
 788                               callback_.callback()));
 789   }
 790
 791   socket_data.StopAfter(1);
 792   base::RunLoop run_loop;
 793   run_loop.RunUntilIdle();
 794
 795   scoped_ptr<QuicHttpStream> stream(
 796       CreateIfSessionExists(host_port_pair_, net_log_));
 797   EXPECT_TRUE(stream.get());
 798   stream.reset();
 799
 800   EXPECT_TRUE(socket_data.at_read_eof());
 801   EXPECT_TRUE(socket_data.at_write_eof());
 802 }
 803
 804 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
 805   // Sequentially connect to the default host, then another host, and then the
 806   // default host.  Verify that the default host gets a consistent ephemeral
 807   // port, that is different from the other host's connection.
 808
 809   std::string other_server_name = "other.google.com";
 810   EXPECT_NE(kDefaultServerHostName, other_server_name);
 811   HostPortPair host_port_pair2(other_server_name, kDefaultServerPort);
 812
 813   int original_port = GetSourcePortForNewSession(host_port_pair_);
 814   EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair2));
 815   EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_));
 816 }
 817
 818 TEST_P(QuicStreamFactoryTest, GoAwayDisablesConsistentEphemeralPort) {
 819   // Get a session to the host using the port suggester.
 820   int original_port =
 821       GetSourcePortForNewSessionAndGoAway(host_port_pair_);
 822   // Verify that the port is different after the goaway.
 823   EXPECT_NE(original_port, GetSourcePortForNewSession(host_port_pair_));
 824   // Since the previous session did not goaway we should see the original port.
 825   EXPECT_EQ(original_port, GetSourcePortForNewSession(host_port_pair_));
 826 }
 827
 828 TEST_P(QuicStreamFactoryTest, CloseAllSessions) {
 829   MockRead reads[] = {
 830     MockRead(ASYNC, 0, 0)  // EOF
 831   };
 832   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
 833   std::vector<MockWrite> writes;
 834   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
 835   DeterministicSocketData socket_data(reads, arraysize(reads),
 836                                       writes.empty() ? NULL  : &writes[0],
 837                                       writes.size());
 838   socket_factory_.AddSocketDataProvider(&socket_data);
 839   socket_data.StopAfter(1);
 840
 841   MockRead reads2[] = {
 842     MockRead(ASYNC, 0, 0)  // EOF
 843   };
 844   DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
 845   socket_factory_.AddSocketDataProvider(&socket_data2);
 846   socket_data2.StopAfter(1);
 847
 848   QuicStreamRequest request(&factory_);
 849   EXPECT_EQ(ERR_IO_PENDING,
 850             request.Request(host_port_pair_,
 851                             is_https_,
 852                             privacy_mode_,
 853                             "GET",
 854                             net_log_,
 855                             callback_.callback()));
 856
 857   EXPECT_EQ(OK, callback_.WaitForResult());
 858   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 859   HttpRequestInfo request_info;
 860   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
 861                                          DEFAULT_PRIORITY,
 862                                          net_log_, CompletionCallback()));
 863
 864   // Close the session and verify that stream saw the error.
 865   factory_.CloseAllSessions(ERR_INTERNET_DISCONNECTED);
 866   EXPECT_EQ(ERR_INTERNET_DISCONNECTED,
 867             stream->ReadResponseHeaders(callback_.callback()));
 868
 869   // Now attempting to request a stream to the same origin should create
 870   // a new session.
 871
 872   QuicStreamRequest request2(&factory_);
 873   EXPECT_EQ(ERR_IO_PENDING,
 874             request2.Request(host_port_pair_,
 875                              is_https_,
 876                              privacy_mode_,
 877                              "GET",
 878                              net_log_,
 879                              callback_.callback()));
 880
 881   EXPECT_EQ(OK, callback_.WaitForResult());
 882   stream = request2.ReleaseStream();
 883   stream.reset();  // Will reset stream 3.
 884
 885   EXPECT_TRUE(socket_data.at_read_eof());
 886   EXPECT_TRUE(socket_data.at_write_eof());
 887   EXPECT_TRUE(socket_data2.at_read_eof());
 888   EXPECT_TRUE(socket_data2.at_write_eof());
 889 }
 890
 891 TEST_P(QuicStreamFactoryTest, OnIPAddressChanged) {
 892   MockRead reads[] = {
 893     MockRead(ASYNC, 0, 0)  // EOF
 894   };
 895   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
 896   std::vector<MockWrite> writes;
 897   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
 898   DeterministicSocketData socket_data(reads, arraysize(reads),
 899                                       writes.empty() ? NULL  : &writes[0],
 900                                       writes.size());
 901   socket_factory_.AddSocketDataProvider(&socket_data);
 902   socket_data.StopAfter(1);
 903
 904   MockRead reads2[] = {
 905     MockRead(ASYNC, 0, 0)  // EOF
 906   };
 907   DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
 908   socket_factory_.AddSocketDataProvider(&socket_data2);
 909   socket_data2.StopAfter(1);
 910
 911   QuicStreamRequest request(&factory_);
 912   EXPECT_EQ(ERR_IO_PENDING,
 913             request.Request(host_port_pair_,
 914                             is_https_,
 915                             privacy_mode_,
 916                             "GET",
 917                             net_log_,
 918                             callback_.callback()));
 919
 920   EXPECT_EQ(OK, callback_.WaitForResult());
 921   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 922   HttpRequestInfo request_info;
 923   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
 924                                          DEFAULT_PRIORITY,
 925                                          net_log_, CompletionCallback()));
 926
 927   // Change the IP address and verify that stream saw the error.
 928   factory_.OnIPAddressChanged();
 929   EXPECT_EQ(ERR_NETWORK_CHANGED,
 930             stream->ReadResponseHeaders(callback_.callback()));
 931   EXPECT_TRUE(factory_.require_confirmation());
 932
 933   // Now attempting to request a stream to the same origin should create
 934   // a new session.
 935
 936   QuicStreamRequest request2(&factory_);
 937   EXPECT_EQ(ERR_IO_PENDING,
 938             request2.Request(host_port_pair_,
 939                              is_https_,
 940                              privacy_mode_,
 941                              "GET",
 942                              net_log_,
 943                              callback_.callback()));
 944
 945   EXPECT_EQ(OK, callback_.WaitForResult());
 946   stream = request2.ReleaseStream();
 947   stream.reset();  // Will reset stream 3.
 948
 949   EXPECT_TRUE(socket_data.at_read_eof());
 950   EXPECT_TRUE(socket_data.at_write_eof());
 951   EXPECT_TRUE(socket_data2.at_read_eof());
 952   EXPECT_TRUE(socket_data2.at_write_eof());
 953 }
 954
 955 TEST_P(QuicStreamFactoryTest, OnCertAdded) {
 956   MockRead reads[] = {
 957     MockRead(ASYNC, 0, 0)  // EOF
 958   };
 959   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
 960   std::vector<MockWrite> writes;
 961   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
 962   DeterministicSocketData socket_data(reads, arraysize(reads),
 963                                       writes.empty() ? NULL  : &writes[0],
 964                                       writes.size());
 965   socket_factory_.AddSocketDataProvider(&socket_data);
 966   socket_data.StopAfter(1);
 967
 968   MockRead reads2[] = {
 969     MockRead(ASYNC, 0, 0)  // EOF
 970   };
 971   DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
 972   socket_factory_.AddSocketDataProvider(&socket_data2);
 973   socket_data2.StopAfter(1);
 974
 975   QuicStreamRequest request(&factory_);
 976   EXPECT_EQ(ERR_IO_PENDING,
 977             request.Request(host_port_pair_,
 978                             is_https_,
 979                             privacy_mode_,
 980                             "GET",
 981                             net_log_,
 982                             callback_.callback()));
 983
 984   EXPECT_EQ(OK, callback_.WaitForResult());
 985   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
 986   HttpRequestInfo request_info;
 987   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
 988                                          DEFAULT_PRIORITY,
 989                                          net_log_, CompletionCallback()));
 990
 991   // Add a cert and verify that stream saw the event.
 992   factory_.OnCertAdded(NULL);
 993   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
 994             stream->ReadResponseHeaders(callback_.callback()));
 995   EXPECT_FALSE(factory_.require_confirmation());
 996
 997   // Now attempting to request a stream to the same origin should create
 998   // a new session.
 999
1000   QuicStreamRequest request2(&factory_);
1001   EXPECT_EQ(ERR_IO_PENDING,
1002             request2.Request(host_port_pair_,
1003                              is_https_,
1004                              privacy_mode_,
1005                              "GET",
1006                              net_log_,
1007                              callback_.callback()));
1008
1009   EXPECT_EQ(OK, callback_.WaitForResult());
1010   stream = request2.ReleaseStream();
1011   stream.reset();  // Will reset stream 3.
1012
1013   EXPECT_TRUE(socket_data.at_read_eof());
1014   EXPECT_TRUE(socket_data.at_write_eof());
1015   EXPECT_TRUE(socket_data2.at_read_eof());
1016   EXPECT_TRUE(socket_data2.at_write_eof());
1017 }
1018
1019 TEST_P(QuicStreamFactoryTest, OnCACertChanged) {
1020   MockRead reads[] = {
1021     MockRead(ASYNC, 0, 0)  // EOF
1022   };
1023   scoped_ptr<QuicEncryptedPacket> rst(ConstructRstPacket());
1024   std::vector<MockWrite> writes;
1025   writes.push_back(MockWrite(ASYNC, rst->data(), rst->length(), 1));
1026   DeterministicSocketData socket_data(reads, arraysize(reads),
1027                                       writes.empty() ? NULL  : &writes[0],
1028                                       writes.size());
1029   socket_factory_.AddSocketDataProvider(&socket_data);
1030   socket_data.StopAfter(1);
1031
1032   MockRead reads2[] = {
1033     MockRead(ASYNC, 0, 0)  // EOF
1034   };
1035   DeterministicSocketData socket_data2(reads2, arraysize(reads2), NULL, 0);
1036   socket_factory_.AddSocketDataProvider(&socket_data2);
1037   socket_data2.StopAfter(1);
1038
1039   QuicStreamRequest request(&factory_);
1040   EXPECT_EQ(ERR_IO_PENDING,
1041             request.Request(host_port_pair_,
1042                             is_https_,
1043                             privacy_mode_,
1044                             "GET",
1045                             net_log_,
1046                             callback_.callback()));
1047
1048   EXPECT_EQ(OK, callback_.WaitForResult());
1049   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
1050   HttpRequestInfo request_info;
1051   EXPECT_EQ(OK, stream->InitializeStream(&request_info,
1052                                          DEFAULT_PRIORITY,
1053                                          net_log_, CompletionCallback()));
1054
1055   // Change the CA cert and verify that stream saw the event.
1056   factory_.OnCACertChanged(NULL);
1057   EXPECT_EQ(ERR_CERT_DATABASE_CHANGED,
1058             stream->ReadResponseHeaders(callback_.callback()));
1059   EXPECT_FALSE(factory_.require_confirmation());
1060
1061   // Now attempting to request a stream to the same origin should create
1062   // a new session.
1063
1064   QuicStreamRequest request2(&factory_);
1065   EXPECT_EQ(ERR_IO_PENDING,
1066             request2.Request(host_port_pair_,
1067                              is_https_,
1068                              privacy_mode_,
1069                              "GET",
1070                              net_log_,
1071                              callback_.callback()));
1072
1073   EXPECT_EQ(OK, callback_.WaitForResult());
1074   stream = request2.ReleaseStream();
1075   stream.reset();  // Will reset stream 3.
1076
1077   EXPECT_TRUE(socket_data.at_read_eof());
1078   EXPECT_TRUE(socket_data.at_write_eof());
1079   EXPECT_TRUE(socket_data2.at_read_eof());
1080   EXPECT_TRUE(socket_data2.at_write_eof());
1081 }
1082
1083 TEST_P(QuicStreamFactoryTest, SharedCryptoConfig) {
1084   vector<string> cannoncial_suffixes;
1085   cannoncial_suffixes.push_back(string(".c.youtube.com"));
1086   cannoncial_suffixes.push_back(string(".googlevideo.com"));
1087
1088   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
1089     string r1_host_name("r1");
1090     string r2_host_name("r2");
1091     r1_host_name.append(cannoncial_suffixes[i]);
1092     r2_host_name.append(cannoncial_suffixes[i]);
1093
1094     HostPortPair host_port_pair1(r1_host_name, 80);
1095     QuicCryptoClientConfig* crypto_config =
1096         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
1097     QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_);
1098     QuicCryptoClientConfig::CachedState* cached1 =
1099         crypto_config->LookupOrCreate(server_id1);
1100     EXPECT_FALSE(cached1->proof_valid());
1101     EXPECT_TRUE(cached1->source_address_token().empty());
1102
1103     // Mutate the cached1 to have different data.
1104     // TODO(rtenneti): mutate other members of CachedState.
1105     cached1->set_source_address_token(r1_host_name);
1106     cached1->SetProofValid();
1107
1108     HostPortPair host_port_pair2(r2_host_name, 80);
1109     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
1110     QuicCryptoClientConfig::CachedState* cached2 =
1111         crypto_config->LookupOrCreate(server_id2);
1112     EXPECT_EQ(cached1->source_address_token(), cached2->source_address_token());
1113     EXPECT_TRUE(cached2->proof_valid());
1114   }
1115 }
1116
1117 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
1118   vector<string> cannoncial_suffixes;
1119   cannoncial_suffixes.push_back(string(".c.youtube.com"));
1120   cannoncial_suffixes.push_back(string(".googlevideo.com"));
1121
1122   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
1123     string r3_host_name("r3");
1124     string r4_host_name("r4");
1125     r3_host_name.append(cannoncial_suffixes[i]);
1126     r4_host_name.append(cannoncial_suffixes[i]);
1127
1128     HostPortPair host_port_pair1(r3_host_name, 80);
1129     QuicCryptoClientConfig* crypto_config =
1130         QuicStreamFactoryPeer::GetCryptoConfig(&factory_);
1131     QuicServerId server_id1(host_port_pair1, is_https_, privacy_mode_);
1132     QuicCryptoClientConfig::CachedState* cached1 =
1133         crypto_config->LookupOrCreate(server_id1);
1134     EXPECT_FALSE(cached1->proof_valid());
1135     EXPECT_TRUE(cached1->source_address_token().empty());
1136
1137     // Mutate the cached1 to have different data.
1138     // TODO(rtenneti): mutate other members of CachedState.
1139     cached1->set_source_address_token(r3_host_name);
1140     cached1->SetProofInvalid();
1141
1142     HostPortPair host_port_pair2(r4_host_name, 80);
1143     QuicServerId server_id2(host_port_pair2, is_https_, privacy_mode_);
1144     QuicCryptoClientConfig::CachedState* cached2 =
1145         crypto_config->LookupOrCreate(server_id2);
1146     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
1147     EXPECT_TRUE(cached2->source_address_token().empty());
1148     EXPECT_FALSE(cached2->proof_valid());
1149   }
1150 }
1151
1152 }  // namespace test
1153 }  // namespace net