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

net/quic/crypto/quic_crypto_client_config.cc

 // Copyright 2013 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/crypto/quic_crypto_client_config.h"
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/cert_compressor.h"
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/curve25519_key_exchange.h"
 #include "net/quic/crypto/key_exchange.h"
 #include "net/quic/crypto/p256_key_exchange.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_server_info.h"
+#include "net/quic/quic_session_key.h"
 #include "net/quic/quic_utils.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using base::StringPiece;
+using std::make_pair;
 using std::map;
 using std::string;
 using std::vector;
 
 namespace net {
 
 QuicCryptoClientConfig::QuicCryptoClientConfig() {}
 
 QuicCryptoClientConfig::~QuicCryptoClientConfig() {
   STLDeleteValues(&cached_states_);
@@ skipping 188 matching lines @@
   DCHECK(!server_config_valid_);
   server_config_ = other.server_config_;
   source_address_token_ = other.source_address_token_;
   certs_ = other.certs_;
   server_config_sig_ = other.server_config_sig_;
   server_config_valid_ = other.server_config_valid_;
   ++generation_counter_;
 }
 
 // An issue to be solved: while we are loading the data from disk cache, it is
-// possible for another request for the same hostname update the CachedState
+// possible for another request for the same |server_key| update the CachedState
 // because that request has sent FillInchoateClientHello and got REJ message.
 // Loading of data from disk cache shouldn't blindly overwrite what is in
 // CachedState.
 bool QuicCryptoClientConfig::CachedState::LoadQuicServerInfo(QuicWallTime now) {
   DCHECK(server_config_.empty());
   DCHECK(quic_server_info_.get());
   DCHECK(quic_server_info_->IsDataReady());
 
   const QuicServerInfo::State& state(quic_server_info_->state());
   if (state.server_config.empty()) {
@@ skipping 43 matching lines @@
   kexs.resize(2);
   kexs[0] = kC255;
   kexs[1] = kP256;
 
   // Authenticated encryption algorithms.
   aead.resize(1);
   aead[0] = kAESG;
 }
 
 QuicCryptoClientConfig::CachedState* QuicCryptoClientConfig::Create(
-    const string& server_hostname,
+    const QuicSessionKey& server_key,
     QuicServerInfoFactory* quic_server_info_factory) {
-  DCHECK(cached_states_.find(server_hostname) == cached_states_.end());
+  DCHECK(cached_states_.find(server_key) == cached_states_.end());
   scoped_ptr<QuicServerInfo> quic_server_info;
   if (quic_server_info_factory) {
     quic_server_info.reset(
-        quic_server_info_factory->GetForHost(server_hostname));
+        quic_server_info_factory->GetForServer(server_key));
     quic_server_info->Start();
   }
 
   CachedState* cached = new CachedState(quic_server_info.Pass());
-  cached_states_.insert(make_pair(server_hostname, cached));
+  cached_states_.insert(make_pair(server_key, cached));
   return cached;
 }
 
 QuicCryptoClientConfig::CachedState* QuicCryptoClientConfig::LookupOrCreate(
-    const string& server_hostname) {
-  map<string, CachedState*>::const_iterator it =
-      cached_states_.find(server_hostname);
+    const QuicSessionKey& server_key) {
+  map<QuicSessionKey, CachedState*>::const_iterator it =
+      cached_states_.find(server_key);
   if (it != cached_states_.end()) {
     return it->second;
   }
-  return Create(server_hostname, NULL);
+  return Create(server_key, NULL);
 }
 
 void QuicCryptoClientConfig::FillInchoateClientHello(
     const string& server_hostname,
     const QuicVersion preferred_version,
     const CachedState* cached,
     QuicCryptoNegotiatedParameters* out_params,
     CryptoHandshakeMessage* out) const {
   out->set_tag(kCHLO);
   out->set_minimum_size(kClientHelloMinimumSize);
@@ skipping 383 matching lines @@
 
 ChannelIDSigner* QuicCryptoClientConfig::channel_id_signer() const {
   return channel_id_signer_.get();
 }
 
 void QuicCryptoClientConfig::SetChannelIDSigner(ChannelIDSigner* signer) {
   channel_id_signer_.reset(signer);
 }
 
 void QuicCryptoClientConfig::InitializeFrom(
-    const std::string& server_hostname,
-    const std::string& canonical_server_hostname,
+    const QuicSessionKey& server_key,
+    const QuicSessionKey& canonical_server_key,
     QuicCryptoClientConfig* canonical_crypto_config) {
   CachedState* canonical_cached =
-      canonical_crypto_config->LookupOrCreate(canonical_server_hostname);
+      canonical_crypto_config->LookupOrCreate(canonical_server_key);
   if (!canonical_cached->proof_valid()) {
     return;
   }
-  CachedState* cached = LookupOrCreate(server_hostname);
+  CachedState* cached = LookupOrCreate(server_key);
   cached->InitializeFrom(*canonical_cached);
 }
 
 }  // namespace net