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