Merge internal change: 63891842 - QuicServerId changes

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/quic_server_id.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.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;
+using net::QuicServerId;
 using net::test::kInitialFlowControlWindowForTest;
 using net::test::QuicConnectionPeer;
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
 namespace test {
 namespace {
 
@@ skipping 59 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 QuicSessionKey& server_key,
+                     const QuicServerId& server_id,
                      const QuicVersionVector& supported_versions,
                      uint32 initial_flow_control_window)
       : QuicClient(server_address,
-                   server_key,
+                   server_id,
                    supported_versions,
                    false,
                    initial_flow_control_window),
         override_connection_id_(0),
         test_writer_(NULL) {}
 
   MockableQuicClient(IPEndPoint server_address,
-                     const QuicSessionKey& server_key,
+                     const QuicServerId& server_id,
                      const QuicConfig& config,
                      const QuicVersionVector& supported_versions,
                      uint32 initial_flow_control_window)
       : QuicClient(server_address,
-                   server_key,
+                   server_id,
                    config,
                    supported_versions,
                    initial_flow_control_window),
         override_connection_id_(0),
         test_writer_(NULL) {}
 
   virtual ~MockableQuicClient() {
     if (connected()) {
       Disconnect();
     }
@@ skipping 21 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 QuicSessionKey& server_key,
+QuicTestClient::QuicTestClient(IPEndPoint server_address,
+                               const string& server_hostname,
                                const QuicVersionVector& supported_versions)
-    : client_(new MockableQuicClient(address,
-                                     server_key,
+    : client_(new MockableQuicClient(server_address,
+                                     QuicServerId(server_hostname,
+                                                  server_address.port(),
+                                                  false,
+                                                  kPrivacyModeDisabled),
                                      supported_versions,
                                      kInitialFlowControlWindowForTest)) {
-  Initialize(address, server_key, true);
+  Initialize(server_address, server_hostname, true);
 }
 
-QuicTestClient::QuicTestClient(IPEndPoint address,
-                               const QuicSessionKey& server_key,
+QuicTestClient::QuicTestClient(IPEndPoint server_address,
+                               const string& server_hostname,
                                bool secure,
                                const QuicVersionVector& supported_versions)
-    : client_(new MockableQuicClient(address,
-                                     server_key,
+    : client_(new MockableQuicClient(server_address,
+                                     QuicServerId(server_hostname,
+                                                  server_address.port(),
+                                                  secure,
+                                                  kPrivacyModeDisabled),
                                      supported_versions,
                                      kInitialFlowControlWindowForTest)) {
-  Initialize(address, server_key, secure);
+  Initialize(server_address, server_hostname, secure);
 }
 
 QuicTestClient::QuicTestClient(
-    IPEndPoint address,
-    const QuicSessionKey& server_key,
+    IPEndPoint server_address,
+    const string& server_hostname,
     bool secure,
     const QuicConfig& config,
     const QuicVersionVector& supported_versions,
     uint32 client_initial_flow_control_receive_window)
     : client_(
-        new MockableQuicClient(address,
-                               server_key,
+        new MockableQuicClient(server_address,
+                               QuicServerId(server_hostname,
+                                            server_address.port(),
+                                            secure,
+                                            kPrivacyModeDisabled),
                                config,
                                supported_versions,
                                client_initial_flow_control_receive_window)) {
-  Initialize(address, server_key, secure);
+  Initialize(server_address, server_hostname, secure);
 }
 
 void QuicTestClient::Initialize(IPEndPoint address,
-                                const QuicSessionKey& server_key,
+                                const string& hostname,
                                 bool secure) {
   server_address_ = address;
-  server_key_ = server_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_key(
-          QuicSessionKey(url.host(), url.EffectiveIntPort(),
-                         url.SchemeIs("https"), kPrivacyModeDisabled));
+      client_->set_server_id(
+          QuicServerId(url.host(), url.EffectiveIntPort(),
+                       url.SchemeIs("https"), kPrivacyModeDisabled));
     }
   }
 
   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_key());
+      config->LookupOrCreate(client_->server_id());
   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