Land Recent QUIC 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"
@@ skipping 83 matching lines @@
   return headers;
 }
 
 // A quic client which allows mocking out writes.
 class QuicEpollClient : public QuicClient {
  public:
   typedef QuicClient Super;
 
   QuicEpollClient(IPEndPoint server_address,
              const string& server_hostname,
-             const QuicVersion version)
-      : Super(server_address, server_hostname, version, false),
+             const QuicVersionVector& supported_versions)
+      : Super(server_address, server_hostname, supported_versions, false),
         override_guid_(0), test_writer_(NULL) {
   }
 
   QuicEpollClient(IPEndPoint server_address,
              const string& server_hostname,
              const QuicConfig& config,
-             const QuicVersion version)
-      : Super(server_address, server_hostname, config, version),
+             const QuicVersionVector& supported_versions)
+      : Super(server_address, server_hostname, config, supported_versions),
         override_guid_(0), test_writer_(NULL) {
   }
 
   virtual ~QuicEpollClient() {
     if (connected()) {
       Disconnect();
     }
   }
 
   virtual QuicPacketWriter* CreateQuicPacketWriter() OVERRIDE {
@@ skipping 15 matching lines @@
   void UseGuid(QuicGuid guid) {
     override_guid_ = guid;
   }
 
  private:
   QuicGuid override_guid_;  // GUID to use, if nonzero
   QuicTestWriter* test_writer_;
 };
 
 QuicTestClient::QuicTestClient(IPEndPoint address, const string& hostname,
-                               const QuicVersion version)
-    : client_(new QuicEpollClient(address, hostname, version)) {
+                               const QuicVersionVector& supported_versions)
+    : client_(new QuicEpollClient(address, hostname, supported_versions)) {
   Initialize(address, hostname, true);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
                                const string& hostname,
                                bool secure,
-                               const QuicVersion version)
-    : client_(new QuicEpollClient(address, hostname, version)) {
+                               const QuicVersionVector& supported_versions)
+    : client_(new QuicEpollClient(address, hostname, supported_versions)) {
   Initialize(address, hostname, secure);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
                                const string& hostname,
                                bool secure,
                                const QuicConfig& config,
-                               const QuicVersion version)
-    : client_(new QuicEpollClient(address, hostname, config, version)) {
+                               const QuicVersionVector& supported_versions)
+    : client_(new QuicEpollClient(address, hostname, config,
+                                  supported_versions)) {
   Initialize(address, hostname, secure);
 }
 
 void QuicTestClient::Initialize(IPEndPoint address,
                                 const string& hostname,
                                 bool secure) {
   server_address_ = address;
   stream_ = NULL;
   stream_error_ = QUIC_STREAM_NO_ERROR;
   priority_ = 3;
@@ skipping 118 matching lines @@
   client_->Connect();
   connect_attempted_ = true;
 }
 
 void QuicTestClient::ResetConnection() {
   Disconnect();
   Connect();
 }
 
 void QuicTestClient::Disconnect() {
-  client_->Disconnect();
+  if (client_->connected()) {
+    client_->Disconnect();
+  }
   connect_attempted_ = false;
 }
 
 IPEndPoint QuicTestClient::LocalSocketAddress() const {
   return client_->client_address();
 }
 
 void QuicTestClient::ClearPerRequestState() {
   stream_error_ = QUIC_STREAM_NO_ERROR;
   stream_ = NULL;
@@ skipping 79 matching lines @@
 }
 
 void QuicTestClient::UseGuid(QuicGuid guid) {
   DCHECK(!connected());
   reinterpret_cast<QuicEpollClient*>(client_.get())->UseGuid(guid);
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net