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

net/tools/quic/test_tools/quic_test_client.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/tools/quic/test_tools/quic_test_client.h"
 
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/x509_certificate.h"
 #include "net/quic/crypto/proof_verifier.h"
+#include "net/quic/quic_session_key.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/tools/balsa/balsa_headers.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/test_tools/http_message.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "url/gurl.h"
 
 using base::StringPiece;
@@ skipping 69 matching lines @@
     full_uri.append(uri.as_string());
     headers->SetRequestUri(full_uri);
   }
   return headers;
 }
 
 // A quic client which allows mocking out writes.
 class MockableQuicClient : public QuicClient {
  public:
   MockableQuicClient(IPEndPoint server_address,
-                     const string& server_hostname,
+                     const QuicSessionKey& session_key,
                      const QuicVersionVector& supported_versions)
-      : QuicClient(server_address, server_hostname, supported_versions, false),
+      : QuicClient(server_address, session_key, supported_versions, false),
         override_connection_id_(0),
         test_writer_(NULL) {}
 
   MockableQuicClient(IPEndPoint server_address,
-                     const string& server_hostname,
+                     const QuicSessionKey& session_key,
                      const QuicConfig& config,
                      const QuicVersionVector& supported_versions)
-      : QuicClient(server_address, server_hostname, config, supported_versions),
+      : QuicClient(server_address, session_key, config, supported_versions),
         override_connection_id_(0),
         test_writer_(NULL) {}
 
   virtual ~MockableQuicClient() {
     if (connected()) {
       Disconnect();
     }
   }
 
   virtual QuicPacketWriter* CreateQuicPacketWriter() OVERRIDE {
@@ skipping 15 matching lines @@
 
   void UseConnectionId(QuicConnectionId connection_id) {
     override_connection_id_ = connection_id;
   }
 
  private:
   QuicConnectionId override_connection_id_;  // ConnectionId to use, if nonzero
   QuicPacketWriterWrapper* test_writer_;
 };
 
-QuicTestClient::QuicTestClient(IPEndPoint address, const string& hostname,
+QuicTestClient::QuicTestClient(IPEndPoint address,
+                               const QuicSessionKey& session_key,
                                const QuicVersionVector& supported_versions)
-    : client_(new MockableQuicClient(address, hostname, supported_versions)) {
-  Initialize(address, hostname, true);
+    : client_(new MockableQuicClient(address, session_key,
+                                     supported_versions)) {
+  Initialize(address, session_key, true);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
-                               const string& hostname,
+                               const QuicSessionKey& session_key,
                                bool secure,
                                const QuicVersionVector& supported_versions)
-    : client_(new MockableQuicClient(address, hostname, supported_versions)) {
-  Initialize(address, hostname, secure);
+    : client_(new MockableQuicClient(address, session_key,
+                                     supported_versions)) {
+  Initialize(address, session_key, secure);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
-                               const string& hostname,
+                               const QuicSessionKey& session_key,
                                bool secure,
                                const QuicConfig& config,
                                const QuicVersionVector& supported_versions)
-    : client_(new MockableQuicClient(
-        address, hostname, config, supported_versions)) {
-  Initialize(address, hostname, secure);
+    : client_(new MockableQuicClient(address, session_key, config,
+                                     supported_versions)) {
+  Initialize(address, session_key, secure);
 }
 
 void QuicTestClient::Initialize(IPEndPoint address,
-                                const string& hostname,
+                                const QuicSessionKey& session_key,
                                 bool secure) {
   server_address_ = address;
+  session_key_ = session_key;
   priority_ = 3;
   connect_attempted_ = false;
   secure_ = secure;
   auto_reconnect_ = false;
   buffer_body_ = true;
   proof_verifier_ = NULL;
   ClearPerRequestState();
   ExpectCertificates(secure_);
 }
 
@@ skipping 18 matching lines @@
   return SendMessage(message);
 }
 
 ssize_t QuicTestClient::SendMessage(const HTTPMessage& message) {
   stream_ = NULL;  // Always force creation of a stream for SendMessage.
 
   // If we're not connected, try to find an sni hostname.
   if (!connected()) {
     GURL url(message.headers()->request_uri().as_string());
     if (!url.host().empty()) {
-      client_->set_server_hostname(url.host());
+      client_->set_session_key(
+          QuicSessionKey(url.host(), url.EffectiveIntPort(),
+                         url.SchemeIs("https") ? true : false));
     }
   }
 
   QuicSpdyClientStream* stream = GetOrCreateStream();
   if (!stream) { return 0; }
 
   scoped_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers(),
                                           secure_));
   ssize_t ret = GetOrCreateStream()->SendRequest(
       munged_headers.get() ? *munged_headers.get() : *message.headers(),
@@ skipping 60 matching lines @@
 
 const string& QuicTestClient::cert_common_name() const {
   return reinterpret_cast<RecordingProofVerifier*>(proof_verifier_)
       ->common_name();
 }
 
 QuicTagValueMap QuicTestClient::GetServerConfig() const {
   net::QuicCryptoClientConfig* config =
       QuicClientPeer::GetCryptoConfig(client_.get());
   net::QuicCryptoClientConfig::CachedState* state =
-      config->LookupOrCreate(client_->server_hostname());
+      config->LookupOrCreate(client_->session_key());
   const net::CryptoHandshakeMessage* handshake_msg = state->GetServerConfig();
   if (handshake_msg != NULL) {
     return handshake_msg->tag_value_map();
   } else {
     return QuicTagValueMap();
   }
 }
 
 bool QuicTestClient::connected() const {
   return client_->connected();
@@ skipping 149 matching lines @@
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net