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 28 matching lines @@
 
 class QuicStreamFactoryPeer {
  public:
   static QuicCryptoClientConfig* GetOrCreateCryptoConfig(
       QuicStreamFactory* factory,
       const HostPortProxyPair& host_port_proxy_pair) {
     return factory->GetOrCreateCryptoConfig(host_port_proxy_pair);
   }
 
   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());
     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_));

[ramant (doing other things), 2014/03/07 23:42:56]

nit: 4 spaces indentation on line# 382

[Ryan Hamilton, 2014/03/08 00:58:34]

Done.

+  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 357 matching lines @@
     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