QUIC - use QuicSessionKey tuple (host, port, is_https) instead of server_hostname

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 26 matching lines @@
 const char kDefaultServerHostName[] = "www.google.com";
 const int kDefaultServerPort = 443;
 }  // namespace anonymous
 
 class QuicStreamFactoryPeer {
  public:
   static QuicCryptoClientConfig* GetOrCreateCryptoConfig(
       QuicStreamFactory* factory,
       const HostPortPair& host_port_pair,
       bool is_https) {
-    QuicSessionKey session_key(host_port_pair, is_https);
-    return factory->GetOrCreateCryptoConfig(session_key);
+    QuicSessionKey server_key(host_port_pair, is_https);
+    return factory->GetOrCreateCryptoConfig(server_key);
   }
 
   static bool HasActiveSession(QuicStreamFactory* factory,
                                const HostPortPair& host_port_pair,
                                bool is_https) {
-    QuicSessionKey session_key(host_port_pair, is_https);
-    return factory->HasActiveSession(session_key);
+    QuicSessionKey server_key(host_port_pair, is_https);
+    return factory->HasActiveSession(server_key);
   }
 
   static QuicClientSession* GetActiveSession(
       QuicStreamFactory* factory,
       const HostPortPair& host_port_pair,
       bool is_https) {
-    QuicSessionKey session_key(host_port_pair, is_https);
-    DCHECK(factory->HasActiveSession(session_key));
-    return factory->active_sessions_[session_key];
+    QuicSessionKey server_key(host_port_pair, is_https);
+    DCHECK(factory->HasActiveSession(server_key));
+    return factory->active_sessions_[server_key];
   }
 
   static scoped_ptr<QuicHttpStream> CreateIfSessionExists(
       QuicStreamFactory* factory,
       const HostPortPair& host_port_pair,
       bool is_https,
       const BoundNetLog& net_log) {
-    QuicSessionKey session_key(host_port_pair, is_https);
-    return factory->CreateIfSessionExists(session_key, net_log);
+    QuicSessionKey server_key(host_port_pair, is_https);
+    return factory->CreateIfSessionExists(server_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 938 matching lines @@
     string r1_host_name("r1");
     string r2_host_name("r2");
     r1_host_name.append(cannoncial_suffixes[i]);
     r2_host_name.append(cannoncial_suffixes[i]);
 
     HostPortPair host_port_pair1(r1_host_name, 80);
     QuicCryptoClientConfig* crypto_config1 =
         QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
             &factory_, host_port_pair1, is_https_);
     DCHECK(crypto_config1);
+    QuicSessionKey server_key1(host_port_pair1, is_https_);
     QuicCryptoClientConfig::CachedState* cached1 =
-        crypto_config1->LookupOrCreate(host_port_pair1.host());
+        crypto_config1->LookupOrCreate(server_key1);
     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();
 
     HostPortPair host_port_pair2(r2_host_name, 80);
     QuicCryptoClientConfig* crypto_config2 =
         QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
             &factory_, host_port_pair2, is_https_);
     DCHECK(crypto_config2);
+    QuicSessionKey server_key2(host_port_pair2, is_https_);
     QuicCryptoClientConfig::CachedState* cached2 =
-        crypto_config2->LookupOrCreate(host_port_pair2.host());
+        crypto_config2->LookupOrCreate(server_key2);
     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]);
 
     HostPortPair host_port_pair1(r3_host_name, 80);
     QuicCryptoClientConfig* crypto_config1 =
         QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
             &factory_, host_port_pair1, is_https_);
     DCHECK(crypto_config1);
+    QuicSessionKey server_key1(host_port_pair1, is_https_);
     QuicCryptoClientConfig::CachedState* cached1 =
-        crypto_config1->LookupOrCreate(host_port_pair1.host());
+        crypto_config1->LookupOrCreate(server_key1);
     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();
 
     HostPortPair host_port_pair2(r4_host_name, 80);
     QuicCryptoClientConfig* crypto_config2 =
         QuicStreamFactoryPeer::GetOrCreateCryptoConfig(
             &factory_, host_port_pair2, is_https_);
     DCHECK(crypto_config2);
+    QuicSessionKey server_key2(host_port_pair2, is_https_);
     QuicCryptoClientConfig::CachedState* cached2 =
-        crypto_config2->LookupOrCreate(host_port_pair2.host());
+        crypto_config2->LookupOrCreate(server_key2);
     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