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"
 #include "net/cert/x509_certificate.h"
 #include "net/quic/crypto/proof_verifier.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_test_utils.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::test::QuicConnectionPeer;
 using std::string;
 using std::vector;
 
 namespace {
 
@@ skipping 66 matching lines @@
   return headers;
 }
 
 // A quic client which allows mocking out writes.
 class MockableQuicClient : public QuicClient {
  public:
   MockableQuicClient(IPEndPoint server_address,
                      const string& server_hostname,
                      const QuicVersionVector& supported_versions)
       : QuicClient(server_address, server_hostname, supported_versions, false),
-        override_guid_(0),
+        override_connection_id_(0),
         test_writer_(NULL) {}
 
   MockableQuicClient(IPEndPoint server_address,
                      const string& server_hostname,
                      const QuicConfig& config,
                      const QuicVersionVector& supported_versions)
       : QuicClient(server_address, server_hostname, config, supported_versions),
-        override_guid_(0),
+        override_connection_id_(0),
         test_writer_(NULL) {}
 
   virtual ~MockableQuicClient() {
     if (connected()) {
       Disconnect();
     }
   }
 
   virtual QuicPacketWriter* CreateQuicPacketWriter() OVERRIDE {
     QuicPacketWriter* writer = QuicClient::CreateQuicPacketWriter();
     if (!test_writer_) {
       return writer;
     }
     test_writer_->set_writer(writer);
     return test_writer_;
   }
 
-  virtual QuicGuid GenerateGuid() OVERRIDE {
-    return override_guid_ ? override_guid_ : QuicClient::GenerateGuid();
+  virtual QuicConnectionId GenerateConnectionId() OVERRIDE {
+    return override_connection_id_ ? override_connection_id_
+                                   : QuicClient::GenerateConnectionId();
   }
 
   // Takes ownership of writer.
   void UseWriter(QuicPacketWriterWrapper* writer) { test_writer_ = writer; }
 
-  void UseGuid(QuicGuid guid) { override_guid_ = guid; }
+  void UseConnectionId(QuicConnectionId connection_id) {
+    override_connection_id_ = connection_id;
+  }
 
  private:
-  QuicGuid override_guid_;  // GUID to use, if nonzero
+  QuicConnectionId override_connection_id_;  // ConnectionId to use, if nonzero
   QuicPacketWriterWrapper* test_writer_;
 };
 
 QuicTestClient::QuicTestClient(IPEndPoint address, const string& hostname,
                                const QuicVersionVector& supported_versions)
     : client_(new MockableQuicClient(address, hostname, supported_versions)) {
   Initialize(address, hostname, true);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
@@ skipping 286 matching lines @@
       stream_->stream_bytes_written() + stream_->header_bytes_written();
   response_header_size_ = headers_.GetSizeForWriteBuffer();
   response_body_size_ = stream_->data().size();
   stream_ = NULL;
 }
 
 void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) {
   client_->UseWriter(writer);
 }
 
-void QuicTestClient::UseGuid(QuicGuid guid) {
+void QuicTestClient::UseConnectionId(QuicConnectionId connection_id) {
   DCHECK(!connected());
-  client_->UseGuid(guid);
+  client_->UseConnectionId(connection_id);
 }
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net