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 "base/metrics/histogram.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/crypto_protocol.h"
@@ skipping 49 matching lines @@
   // The ProofVerifier owns this object and will delete it when this method
   // returns.
 }
 
 void QuicCryptoClientStream::ProofVerifierCallbackImpl::Cancel() {
   stream_ = NULL;
 }
 
 
 QuicCryptoClientStream::QuicCryptoClientStream(
-    const string& server_hostname,
+    const QuicSessionKey& session_key,

[wtc, 2014/03/13 22:22:03]

Nit: this parameter probably should be named |server_key| to be more
descriptive.

[ramant (doing other things), 2014/03/13 23:46:36]

Done.

     QuicSession* session,
     QuicCryptoClientConfig* crypto_config)
     : QuicCryptoStream(session),
       next_state_(STATE_IDLE),
       num_client_hellos_(0),
       crypto_config_(crypto_config),
-      server_hostname_(server_hostname),
+      session_key_(session_key),
       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(session_key_);
 
   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 10 matching lines @@
         // Send the client hello in plaintext.
         session()->connection()->SetDefaultEncryptionLevel(ENCRYPTION_NONE);
         if (num_client_hellos_ > kMaxClientHellos) {
           CloseConnection(QUIC_CRYPTO_TOO_MANY_REJECTS);
           return;
         }
         num_client_hellos_++;
 
         if (!cached->IsComplete(session()->connection()->clock()->WallNow())) {
           crypto_config_->FillInchoateClientHello(
-              server_hostname_,
+              session_key_.host_port_pair().host(),
               session()->connection()->supported_versions().front(),
               cached, &crypto_negotiated_params_, &out);
           // Pad the inchoate client hello to fill up a packet.
           const size_t kFramingOverhead = 50;  // A rough estimate.
           const size_t max_packet_size =
               session()->connection()->options()->max_packet_length;
           if (max_packet_size <= kFramingOverhead) {
             DLOG(DFATAL) << "max_packet_length (" << max_packet_size
                          << ") has no room for framing overhead.";
             CloseConnection(QUIC_INTERNAL_ERROR);
             return;
           }
           if (kClientHelloMinimumSize > max_packet_size - kFramingOverhead) {
             DLOG(DFATAL) << "Client hello won't fit in a single packet.";
             CloseConnection(QUIC_INTERNAL_ERROR);
             return;
           }
           out.set_minimum_size(max_packet_size - kFramingOverhead);
           next_state_ = STATE_RECV_REJ;
           DVLOG(1) << "Client: Sending " << out.DebugString();
           SendHandshakeMessage(out);
           return;
         }
         session()->config()->ToHandshakeMessage(&out);
         error = crypto_config_->FillClientHello(
-            server_hostname_,
+            session_key_.host_port_pair().host(),
             session()->connection()->connection_id(),
             session()->connection()->supported_versions().front(),
             cached,
             session()->connection()->clock()->WallNow(),
             session()->connection()->random_generator(),
             &crypto_negotiated_params_,
             &out,
             &error_details);
         if (error != QUIC_NO_ERROR) {
           // Flush the cached config so that, if it's bad, the server has a
@@ skipping 66 matching lines @@
         DCHECK(verifier);
         next_state_ = STATE_VERIFY_PROOF_COMPLETE;
         generation_counter_ = cached->generation_counter();
 
         ProofVerifierCallbackImpl* proof_verify_callback =
             new ProofVerifierCallbackImpl(this);
 
         verify_ok_ = false;
 
         ProofVerifier::Status status = verifier->VerifyProof(
-            server_hostname_,
+            session_key_.host_port_pair().host(),
             cached->server_config(),
             cached->certs(),
             cached->signature(),
             &verify_error_details_,
             &verify_details_,
             proof_verify_callback);
 
         switch (status) {
           case ProofVerifier::PENDING:
             proof_verify_callback_ = proof_verify_callback;
@@ skipping 169 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