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

net/quic/quic_stream_factory.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 <set>
 
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 13 matching lines @@
 #include "net/quic/crypto/quic_server_info.h"
 #include "net/quic/port_suggester.h"
 #include "net/quic/quic_client_session.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/quic_crypto_client_stream_factory.h"
 #include "net/quic/quic_default_packet_writer.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/quic_session_key.h"
 #include "net/socket/client_socket_factory.h"
 
 using std::string;
 using std::vector;
 
 namespace net {
 
 namespace {
 
 const uint64 kBrokenAlternateProtocolDelaySecs = 300;
@@ skipping 348 matching lines @@
     active_requests_[request] = job;
     job_requests_map_[job].insert(request);
     return ERR_IO_PENDING;
   }
 
   QuicServerInfo* quic_server_info = NULL;
   if (quic_server_info_factory_) {
     QuicCryptoClientConfig* crypto_config =
         GetOrCreateCryptoConfig(session_key);
     QuicCryptoClientConfig::CachedState* cached =
-        crypto_config->LookupOrCreate(session_key.host_port_pair().host());
+        crypto_config->LookupOrCreate(session_key);
     DCHECK(cached);
     if (cached->IsEmpty()) {
-      quic_server_info =
-          quic_server_info_factory_->GetForHost(host_port_pair.host());
+      quic_server_info = quic_server_info_factory_->GetForServer(session_key);
     }
   }
   scoped_ptr<Job> job(new Job(this, host_resolver_, host_port_pair,
                               is_https, method, cert_verifier,
                               quic_server_info, net_log));
   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
                                base::Unretained(this), job.get()));
 
   if (rv == ERR_IO_PENDING) {
     active_requests_[request] = job.get();
@@ skipping 14 matching lines @@
   for (size_t i = 0; i < address_list.size(); ++i) {
     const IPEndPoint& address = address_list[i];
     const IpAliasKey ip_alias_key(address, session_key.is_https());
     if (!ContainsKey(ip_aliases_, ip_alias_key))
       continue;
 
     const SessionSet& sessions = ip_aliases_[ip_alias_key];
     for (SessionSet::const_iterator i = sessions.begin();
          i != sessions.end(); ++i) {
       QuicClientSession* session = *i;
-      if (!session->CanPool(session_key.host_port_pair().host()))
+      if (!session->CanPool(session_key.host()))
         continue;
       active_sessions_[session_key] = session;
       session_aliases_[session].insert(session_key);
       return true;
     }
   }
   return false;
 }
 
 void QuicStreamFactory::OnJobComplete(Job* job, int rv) {
@@ skipping 256 matching lines @@
     const HttpServerProperties::NetworkStats* stats =
         http_server_properties_->GetServerNetworkStats(host_port_pair);
     if (stats != NULL) {
       config.set_initial_round_trip_time_us(stats->rtt.InMicroseconds(),
                                             stats->rtt.InMicroseconds());
     }
   }
 
   *session = new QuicClientSession(
       connection, socket.Pass(), writer.Pass(), this, server_info.Pass(),
-      quic_crypto_client_stream_factory_, host_port_pair.host(),
-      config, crypto_config, net_log.net_log());
+      quic_crypto_client_stream_factory_, session_key, config, crypto_config,
+      net_log.net_log());
   all_sessions_.insert(*session);  // owning pointer
   if (is_https) {
     crypto_config->SetProofVerifier(
         new ProofVerifierChromium(cert_verifier, net_log));
   }
   return OK;
 }
 
 bool QuicStreamFactory::HasActiveJob(const QuicSessionKey& key) const {
   return ContainsKey(active_jobs_, key);
@@ skipping 25 matching lines @@
     crypto_config->SetDefaults();
     all_crypto_configs_[session_key] = crypto_config;
     PopulateFromCanonicalConfig(session_key, crypto_config);
   }
   return crypto_config;
 }
 
 void QuicStreamFactory::PopulateFromCanonicalConfig(
     const QuicSessionKey& session_key,
     QuicCryptoClientConfig* crypto_config) {
-  const string server_hostname = session_key.host_port_pair().host();
-  const uint16 server_port = session_key.host_port_pair().port();
+  const string server_hostname = session_key.host();
   unsigned i = 0;
   for (; i < canoncial_suffixes_.size(); ++i) {
     if (EndsWith(server_hostname, canoncial_suffixes_[i], false)) {
       break;
     }
   }
   if (i == canoncial_suffixes_.size())
     return;
 
-  HostPortPair suffix_host_port_pair(canoncial_suffixes_[i], server_port);
+  HostPortPair suffix_host_port_pair(canoncial_suffixes_[i],
+                                     session_key.port());
   QuicSessionKey suffix_session_key(suffix_host_port_pair,
                                     session_key.is_https());
   if (!ContainsKey(canonical_hostname_to_origin_map_, suffix_session_key)) {
     // This is the first host we've seen which matches the suffix, so make it
     // canonical.
     canonical_hostname_to_origin_map_[suffix_session_key] = session_key;
     return;
   }
 
   const QuicSessionKey& canonical_session_key =
       canonical_hostname_to_origin_map_[suffix_session_key];
   QuicCryptoClientConfig* canonical_crypto_config =
       all_crypto_configs_[canonical_session_key];
   DCHECK(canonical_crypto_config);
-  const HostPortPair& canonical_host_port_pair =
-      canonical_session_key.host_port_pair();
 
   // Copy the CachedState for the canonical server from canonical_crypto_config
   // as the initial CachedState for the server_hostname in crypto_config.
-  crypto_config->InitializeFrom(server_hostname,
-                                canonical_host_port_pair.host(),
+  crypto_config->InitializeFrom(session_key, canonical_session_key,
                                 canonical_crypto_config);
   // Update canonical version to point at the "most recent" crypto_config.
   canonical_hostname_to_origin_map_[suffix_session_key] =
       canonical_session_key;
 }
 
 void QuicStreamFactory::ExpireBrokenAlternateProtocolMappings() {
   base::TimeTicks now = base::TimeTicks::Now();
   while (!broken_alternate_protocol_list_.empty()) {
     BrokenAlternateProtocolEntry entry =
@@ skipping 16 matching lines @@
   base::TimeTicks when = broken_alternate_protocol_list_.front().when;
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&QuicStreamFactory::ExpireBrokenAlternateProtocolMappings,
                  weak_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net