Include the scheme in the key for QUIC the session map.

net/quic/quic_stream_factory_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "net/base/test_data_directory.h"
 #include "net/cert/cert_verifier.h"
@@ skipping 23 matching lines @@
 
 namespace {
 const char kDefaultServerHostName[] = "www.google.com";
 const int kDefaultServerPort = 443;
 }  // namespace anonymous
 
 class QuicStreamFactoryPeer {
  public:
   static QuicCryptoClientConfig* GetOrCreateCryptoConfig(
       QuicStreamFactory* factory,
-      const HostPortProxyPair& host_port_proxy_pair) {
-    return factory->GetOrCreateCryptoConfig(host_port_proxy_pair);
+      const HostPortProxyPair& host_port_proxy_pair,
+      bool is_https) {
+    QuicStreamFactory::SessionKey session_key(host_port_proxy_pair, is_https);
+    return factory->GetOrCreateCryptoConfig(session_key);
   }
 
   static bool HasActiveSession(QuicStreamFactory* factory,
-                               const HostPortProxyPair& host_port_proxy_pair) {
-    return factory->HasActiveSession(host_port_proxy_pair);
+                               const HostPortProxyPair& host_port_proxy_pair,
+                               bool is_https) {
+    QuicStreamFactory::SessionKey session_key(host_port_proxy_pair, is_https);
+    return factory->HasActiveSession(session_key);
   }
 
   static QuicClientSession* GetActiveSession(
       QuicStreamFactory* factory,
-      const HostPortProxyPair& host_port_proxy_pair) {
-    DCHECK(factory->HasActiveSession(host_port_proxy_pair));
-    return factory->active_sessions_[host_port_proxy_pair];
+      const HostPortProxyPair& host_port_proxy_pair,
+      bool is_https) {
+    QuicStreamFactory::SessionKey session_key(host_port_proxy_pair, is_https);
+    DCHECK(factory->HasActiveSession(session_key));
+    return factory->active_sessions_[session_key];
+  }
+
+  static scoped_ptr<QuicHttpStream> CreateIfSessionExists(
+      QuicStreamFactory* factory,
+      const HostPortProxyPair& host_port_proxy_pair,
+      bool is_https,
+      const BoundNetLog& net_log) {
+    QuicStreamFactory::SessionKey session_key(host_port_proxy_pair, is_https);
+    return factory->CreateIfSessionExists(session_key, net_log);
   }
 
   static bool IsLiveSession(QuicStreamFactory* factory,
                             QuicClientSession* session) {
     for (QuicStreamFactory::SessionSet::iterator it =
              factory->all_sessions_.begin();
          it != factory->all_sessions_.end(); ++it) {
       if (*it == session)
         return true;
     }
@@ skipping 13 matching lines @@
                  &random_generator_, clock_, kDefaultMaxPacketSize,
                  SupportedVersions(GetParam()), true, true),
         host_port_proxy_pair_(HostPortPair(kDefaultServerHostName,
                                            kDefaultServerPort),
                               ProxyServer::Direct()),
         is_https_(false),
         cert_verifier_(CertVerifier::CreateDefault()) {
     factory_.set_require_confirmation(false);
   }
 
+  scoped_ptr<QuicHttpStream> CreateIfSessionExists(
+      const HostPortProxyPair& host_port_proxy_pair,
+      const BoundNetLog& net_log) {
+    return QuicStreamFactoryPeer::CreateIfSessionExists(
+        &factory_, host_port_proxy_pair, false, net_log_);
+  }
 
   int GetSourcePortForNewSession(const HostPortProxyPair& destination) {
     return GetSourcePortForNewSessionInner(destination, false);
   }
 
   int GetSourcePortForNewSessionAndGoAway(
       const HostPortProxyPair& destination) {
     return GetSourcePortForNewSessionInner(destination, true);
   }
 
   int GetSourcePortForNewSessionInner(const HostPortProxyPair& destination,
                                       bool goaway_received) {
     // Should only be called if there is no active session for this destination.
-    EXPECT_EQ(NULL, factory_.CreateIfSessionExists(destination,
-                                                   net_log_).get());
+    EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get());
     size_t socket_count = socket_factory_.udp_client_sockets().size();
 
     MockRead reads[] = {
       MockRead(ASYNC, OK, 0)  // EOF
     };
     DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
     socket_data.StopAfter(1);
     socket_factory_.AddSocketDataProvider(&socket_data);
 
     QuicStreamRequest request(&factory_);
     EXPECT_EQ(ERR_IO_PENDING,
               request.Request(destination,
                               is_https_,
                               "GET",
                               cert_verifier_.get(),
                               net_log_,
                               callback_.callback()));
 
     EXPECT_EQ(OK, callback_.WaitForResult());
     scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
     EXPECT_TRUE(stream.get());
     stream.reset();
 
     QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
-        &factory_, destination);
+        &factory_, destination, is_https_);
 
     if (socket_count + 1 != socket_factory_.udp_client_sockets().size()) {
       EXPECT_TRUE(false);
       return 0;
     }
 
     IPEndPoint endpoint;
     socket_factory_.
         udp_client_sockets()[socket_count]->GetLocalAddress(&endpoint);
     int port = endpoint.port();
     if (goaway_received) {
       QuicGoAwayFrame goaway(QUIC_NO_ERROR, 1, "");
       session->OnGoAway(goaway);
     }
 
     factory_.OnSessionClosed(session);
-    EXPECT_EQ(NULL, factory_.CreateIfSessionExists(destination,
-                                                   net_log_).get());
+    EXPECT_EQ(NULL, CreateIfSessionExists(destination, net_log_).get());

[eroman, 2014/03/08 01:04:25]

BTW I seem to remember having issues with this pattern (where on some platforms
NULL is not understood to be a pointer type and the template magic fails...

If so, try EXPECT_FALSE() instead

     EXPECT_TRUE(socket_data.at_read_eof());
     EXPECT_TRUE(socket_data.at_write_eof());
     return port;
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket() {
     QuicStreamId stream_id = 5;
     return maker_.MakeRstPacket(1, true, stream_id, QUIC_STREAM_NO_ERROR);
   }
 
   MockHostResolver host_resolver_;
   DeterministicMockClientSocketFactory socket_factory_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
   QuicTestPacketMaker maker_;
   MockClock* clock_;  // Owned by factory_.
   QuicStreamFactory factory_;
   HostPortProxyPair host_port_proxy_pair_;
   bool is_https_;
   scoped_ptr<CertVerifier> cert_verifier_;
   BoundNetLog net_log_;
   TestCompletionCallback callback_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version, QuicStreamFactoryTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicStreamFactoryTest, CreateIfSessionExists) {
-  EXPECT_EQ(NULL, factory_.CreateIfSessionExists(host_port_proxy_pair_,
-                                                 net_log_).get());
+  EXPECT_EQ(NULL, CreateIfSessionExists(host_port_proxy_pair_, net_log_).get());
 }
 
 TEST_P(QuicStreamFactoryTest, Create) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   QuicStreamRequest request(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
             request.Request(host_port_proxy_pair_,
                             is_https_,
                             "GET",
                             cert_verifier_.get(),
                             net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   // Will reset stream 3.
-  stream = factory_.CreateIfSessionExists(host_port_proxy_pair_, net_log_);
+  stream = CreateIfSessionExists(host_port_proxy_pair_, net_log_);
   EXPECT_TRUE(stream.get());
 
   // TODO(rtenneti): We should probably have a tests that HTTP and HTTPS result
   // in streams on different sessions.
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(OK,
             request2.Request(host_port_proxy_pair_,
                              is_https_,
                              "GET",
                              cert_verifier_.get(),
                              net_log_,
                              callback_.callback()));
   stream = request2.ReleaseStream();  // Will reset stream 5.
   stream.reset();  // Will reset stream 7.
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
+TEST_P(QuicStreamFactoryTest, CreateHttpVsHttps) {
+  MockRead reads[] = {
+    MockRead(ASYNC, OK, 0)  // EOF
+  };
+  DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
+  DeterministicSocketData socket_data2(reads, arraysize(reads), NULL, 0);
+  socket_factory_.AddSocketDataProvider(&socket_data1);
+  socket_factory_.AddSocketDataProvider(&socket_data2);
+  socket_data1.StopAfter(1);
+  socket_data2.StopAfter(1);
+
+  QuicStreamRequest request(&factory_);
+  EXPECT_EQ(ERR_IO_PENDING,
+            request.Request(host_port_proxy_pair_,
+                            is_https_,
+                            "GET",
+                            cert_verifier_.get(),
+                            net_log_,
+                            callback_.callback()));
+
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
+  EXPECT_TRUE(stream.get());
+
+  QuicStreamRequest request2(&factory_);
+  EXPECT_EQ(ERR_IO_PENDING,
+            request2.Request(host_port_proxy_pair_,
+                             !is_https_,
+                             "GET",
+                             cert_verifier_.get(),
+                             net_log_,
+                             callback_.callback()));
+  EXPECT_EQ(OK, callback_.WaitForResult());
+  stream = request2.ReleaseStream();
+  EXPECT_TRUE(stream.get());
+  stream.reset();
+
+  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
+                &factory_, host_port_proxy_pair_, is_https_),
+            QuicStreamFactoryPeer::GetActiveSession(
+                &factory_, host_port_proxy_pair_, !is_https_));
+
+  EXPECT_TRUE(socket_data1.at_read_eof());
+  EXPECT_TRUE(socket_data1.at_write_eof());
+  EXPECT_TRUE(socket_data2.at_read_eof());
+  EXPECT_TRUE(socket_data2.at_write_eof());
+}
+
 TEST_P(QuicStreamFactoryTest, Pooling) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data(reads, arraysize(reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
   socket_data.StopAfter(1);
 
   HostPortProxyPair server2 = HostPortProxyPair(
       HostPortPair("mail.google.com", kDefaultServerPort),
@@ skipping 22 matching lines @@
             request2.Request(server2,
                              is_https_,
                              "GET",
                              cert_verifier_.get(),
                              net_log_,
                              callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_EQ(
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, host_port_proxy_pair_),
-      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+      QuicStreamFactoryPeer::GetActiveSession(
+          &factory_, host_port_proxy_pair_, is_https_),
+      QuicStreamFactoryPeer::GetActiveSession(&factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 TEST_P(QuicStreamFactoryTest, NoPoolingAfterGoAway) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
@@ skipping 29 matching lines @@
   EXPECT_EQ(OK,
             request2.Request(server2,
                              is_https_,
                              "GET",
                              cert_verifier_.get(),
                              net_log_,
                              callback.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  factory_.OnSessionGoingAway(
-      QuicStreamFactoryPeer::GetActiveSession(&factory_,
-                                              host_port_proxy_pair_));
-  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(&factory_,
-                                                       host_port_proxy_pair_));
-  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(&factory_, server2));
+  factory_.OnSessionGoingAway(QuicStreamFactoryPeer::GetActiveSession(
+      &factory_, host_port_proxy_pair_, is_https_));
+  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
+      &factory_, host_port_proxy_pair_, is_https_));
+  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
+      &factory_, server2, is_https_));
 
   TestCompletionCallback callback3;
   QuicStreamRequest request3(&factory_);
   EXPECT_EQ(OK,
             request3.Request(server2,
                              is_https_,
                              "GET",
                              cert_verifier_.get(),
                              net_log_,
                              callback3.callback()));
   scoped_ptr<QuicHttpStream> stream3 = request3.ReleaseStream();
   EXPECT_TRUE(stream3.get());
 
-  EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_, server2));
+  EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(
+      &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.at_read_eof());
   EXPECT_TRUE(socket_data1.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
   EXPECT_TRUE(socket_data2.at_write_eof());
 }
 
 TEST_P(QuicStreamFactoryTest, HttpsPooling) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
@@ skipping 42 matching lines @@
   EXPECT_EQ(OK,
             request2.Request(server2,
                              is_https_,
                              "GET",
                              cert_verifier_.get(),
                              net_log_,
                              callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(&factory_, server1),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_EQ(QuicStreamFactoryPeer::GetActiveSession(
+                &factory_, server1, is_https_),
+            QuicStreamFactoryPeer::GetActiveSession(
+                &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 TEST_P(QuicStreamFactoryTest, NoHttpsPoolingWithCertMismatch) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
   };
   DeterministicSocketData socket_data1(reads, arraysize(reads), NULL, 0);
@@ skipping 44 matching lines @@
   EXPECT_EQ(OK,
             request2.Request(server2,
                              is_https_,
                              "GET",
                              cert_verifier_.get(),
                              net_log_,
                              callback_.callback()));
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
-  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(&factory_, server1),
-            QuicStreamFactoryPeer::GetActiveSession(&factory_, server2));
+  EXPECT_NE(QuicStreamFactoryPeer::GetActiveSession(
+                &factory_, server1, is_https_),
+            QuicStreamFactoryPeer::GetActiveSession(
+                &factory_, server2, is_https_));
 
   EXPECT_TRUE(socket_data1.at_read_eof());
   EXPECT_TRUE(socket_data1.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
   EXPECT_TRUE(socket_data2.at_write_eof());
 }
 
 TEST_P(QuicStreamFactoryTest, Goaway) {
   MockRead reads[] = {
     MockRead(ASYNC, OK, 0)  // EOF
@@ skipping 14 matching lines @@
                             net_log_,
                             callback_.callback()));
 
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
 
   // Mark the session as going away.  Ensure that while it is still alive
   // that it is no longer active.
   QuicClientSession* session = QuicStreamFactoryPeer::GetActiveSession(
-      &factory_, host_port_proxy_pair_);
+      &factory_, host_port_proxy_pair_, is_https_);
   factory_.OnSessionGoingAway(session);
   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
-  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(&factory_,
-                                                       host_port_proxy_pair_));
-  EXPECT_EQ(NULL, factory_.CreateIfSessionExists(host_port_proxy_pair_,
-                                                 net_log_).get());
+  EXPECT_FALSE(QuicStreamFactoryPeer::HasActiveSession(
+      &factory_, host_port_proxy_pair_, is_https_));
+  EXPECT_EQ(NULL, CreateIfSessionExists(host_port_proxy_pair_, net_log_).get());
 
   // Create a new request for the same destination and verify that a
   // new session is created.
   QuicStreamRequest request2(&factory_);
   EXPECT_EQ(ERR_IO_PENDING,
             request2.Request(host_port_proxy_pair_,
                              is_https_,
                              "GET",
                              cert_verifier_.get(),
                              net_log_,
                              callback_.callback()));
   EXPECT_EQ(OK, callback_.WaitForResult());
   scoped_ptr<QuicHttpStream> stream2 = request2.ReleaseStream();
   EXPECT_TRUE(stream2.get());
 
   EXPECT_TRUE(QuicStreamFactoryPeer::HasActiveSession(&factory_,
-                                                      host_port_proxy_pair_));
+                                                      host_port_proxy_pair_,
+                                                      is_https_));
   EXPECT_NE(session,
             QuicStreamFactoryPeer::GetActiveSession(
-                &factory_, host_port_proxy_pair_));
+                &factory_, host_port_proxy_pair_, is_https_));
   EXPECT_EQ(true, QuicStreamFactoryPeer::IsLiveSession(&factory_, session));
 
   stream2.reset();
   stream.reset();
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
   EXPECT_TRUE(socket_data2.at_read_eof());
   EXPECT_TRUE(socket_data2.at_write_eof());
 }
@@ skipping 121 matching lines @@
                               cert_verifier_.get(),
                               net_log_,
                               callback_.callback()));
   }
 
   socket_data.StopAfter(1);
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
   scoped_ptr<QuicHttpStream> stream(
-      factory_.CreateIfSessionExists(host_port_proxy_pair_, net_log_));
+      CreateIfSessionExists(host_port_proxy_pair_, net_log_));
   EXPECT_TRUE(stream.get());
   stream.reset();
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 TEST_P(QuicStreamFactoryTest, CreateConsistentEphemeralPort) {
   // Sequentially connect to the default host, then another host, and then the
   // default host.  Verify that the default host gets a consistent ephemeral
@@ skipping 287 matching lines @@
   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
     string r1_host_name("r1");
     string r2_host_name("r2");
     r1_host_name.append(cannoncial_suffixes[i]);
     r2_host_name.append(cannoncial_suffixes[i]);
 
     HostPortProxyPair host_port_proxy_pair1(HostPortPair(r1_host_name, 80),
                                             ProxyServer::Direct());
 
     QuicCryptoClientConfig* crypto_config1 =
-        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(&factory_,
-                                                       host_port_proxy_pair1);
+        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
+            &factory_, host_port_proxy_pair1, is_https_);
     DCHECK(crypto_config1);
     QuicCryptoClientConfig::CachedState* cached1 =
         crypto_config1->LookupOrCreate(host_port_proxy_pair1.first.host());
     EXPECT_FALSE(cached1->proof_valid());
     EXPECT_TRUE(cached1->source_address_token().empty());
 
     // Mutate the cached1 to have different data.
     // TODO(rtenneti): mutate other members of CachedState.
     cached1->set_source_address_token(r1_host_name);
     cached1->SetProofValid();
 
     HostPortProxyPair host_port_proxy_pair2(HostPortPair(r2_host_name, 80),
                                             ProxyServer::Direct());
     QuicCryptoClientConfig* crypto_config2 =
-        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(&factory_,
-                                                       host_port_proxy_pair2);
+        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
+            &factory_, host_port_proxy_pair2, is_https_);
     DCHECK(crypto_config2);
     QuicCryptoClientConfig::CachedState* cached2 =
         crypto_config2->LookupOrCreate(host_port_proxy_pair2.first.host());
     EXPECT_EQ(cached1->source_address_token(), cached2->source_address_token());
     EXPECT_TRUE(cached2->proof_valid());
   }
 }
 
 TEST_P(QuicStreamFactoryTest, CryptoConfigWhenProofIsInvalid) {
   vector<string> cannoncial_suffixes;
   cannoncial_suffixes.push_back(string(".c.youtube.com"));
   cannoncial_suffixes.push_back(string(".googlevideo.com"));
 
   for (unsigned i = 0; i < cannoncial_suffixes.size(); ++i) {
     string r3_host_name("r3");
     string r4_host_name("r4");
     r3_host_name.append(cannoncial_suffixes[i]);
     r4_host_name.append(cannoncial_suffixes[i]);
 
     HostPortProxyPair host_port_proxy_pair1(HostPortPair(r3_host_name, 80),
                                             ProxyServer::Direct());
 
     QuicCryptoClientConfig* crypto_config1 =
-        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(&factory_,
-                                                       host_port_proxy_pair1);
+        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
+            &factory_, host_port_proxy_pair1, is_https_);
     DCHECK(crypto_config1);
     QuicCryptoClientConfig::CachedState* cached1 =
         crypto_config1->LookupOrCreate(host_port_proxy_pair1.first.host());
     EXPECT_FALSE(cached1->proof_valid());
     EXPECT_TRUE(cached1->source_address_token().empty());
 
     // Mutate the cached1 to have different data.
     // TODO(rtenneti): mutate other members of CachedState.
     cached1->set_source_address_token(r3_host_name);
     cached1->SetProofInvalid();
 
     HostPortProxyPair host_port_proxy_pair2(HostPortPair(r4_host_name, 80),
                                             ProxyServer::Direct());
     QuicCryptoClientConfig* crypto_config2 =
-        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(&factory_,
-                                                       host_port_proxy_pair2);
+        QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
+            &factory_, host_port_proxy_pair2, is_https_);
     DCHECK(crypto_config2);
     QuicCryptoClientConfig::CachedState* cached2 =
         crypto_config2->LookupOrCreate(host_port_proxy_pair2.first.host());
     EXPECT_NE(cached1->source_address_token(), cached2->source_address_token());
     EXPECT_TRUE(cached2->source_address_token().empty());
     EXPECT_FALSE(cached2->proof_valid());
   }
 }
 
 }  // namespace test
 }  // namespace net