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

net/quic/quic_crypto_client_stream.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_crypto_client_stream.h"
 
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
@@ skipping 49 matching lines @@
   // returns.
 }
 
 void QuicCryptoClientStream::ProofVerifierCallbackImpl::Cancel() {
   stream_ = NULL;
 }
 
 
 QuicCryptoClientStream::QuicCryptoClientStream(
     const string& server_hostname,
+    uint16 server_port,
     QuicSession* session,
     QuicCryptoClientConfig* crypto_config)
     : QuicCryptoStream(session),
       next_state_(STATE_IDLE),
       num_client_hellos_(0),
       crypto_config_(crypto_config),
       server_hostname_(server_hostname),
+      server_port_(server_port),
       generation_counter_(0),
       proof_verify_callback_(NULL),
       disk_cache_load_result_(ERR_UNEXPECTED),
       weak_factory_(this) {
 }
 
 QuicCryptoClientStream::~QuicCryptoClientStream() {
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
   }
@@ skipping 58 matching lines @@
 //   * One failure due the server's certificate chain being unavailible and the
 //     server being unwilling to send it without a valid source-address token.
 static const int kMaxClientHellos = 3;
 
 void QuicCryptoClientStream::DoHandshakeLoop(
     const CryptoHandshakeMessage* in) {
   CryptoHandshakeMessage out;
   QuicErrorCode error;
   string error_details;
   QuicCryptoClientConfig::CachedState* cached =
-      crypto_config_->LookupOrCreate(server_hostname_);
+      crypto_config_->LookupOrCreate(server_hostname_, server_port_);
 
   if (in != NULL) {
     DVLOG(1) << "Client: Received " << in->DebugString();
   }
 
   for (;;) {
     const State state = next_state_;
     next_state_ = STATE_IDLE;
     switch (state) {
       case STATE_LOAD_QUIC_SERVER_INFO: {
@@ skipping 259 matching lines @@
   generation_counter_ = cached->generation_counter();
   next_state_ = STATE_LOAD_QUIC_SERVER_INFO_COMPLETE;
 
   // TODO(rtenneti): If multiple tabs load the same URL, all requests except for
   // the first request send InchoateClientHello. Fix the code to handle multiple
   // requests. A possible solution is to wait for the first request to finish
   // and use the data from the disk cache for all requests.
   // We may need to call quic_server_info->Persist later.
   // quic_server_info->Persist requires quic_server_info to be ready, so we
   // always call WaitForDataReady, even though we might have initialized
-  // |cached| config from the cached state for a canonical hostname.
+  // |cached| config from the cached state for a canonical hostname and port.
   int rv = quic_server_info->WaitForDataReady(
       base::Bind(&QuicCryptoClientStream::OnIOComplete,
                  weak_factory_.GetWeakPtr()));
 
   if (rv != ERR_IO_PENDING) {
     disk_cache_load_result_ = rv;
   }
   return rv;
 }
 
@@ skipping 27 matching lines @@
   ProofVerifier* verifier = crypto_config_->proof_verifier();
   if (!verifier) {
     // If no verifier is set then we don't check the certificates.
     cached->SetProofValid();
   } else if (!cached->signature().empty()) {
     next_state_ = STATE_VERIFY_PROOF;
   }
 }
 
 }  // namespace net