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/quic_client_peer.h"
 #include "url/gurl.h"
 
 using base::StringPiece;
 using net::test::QuicConnectionPeer;
-using net::test::QuicTestWriter;
 using std::string;
 using std::vector;
 
 namespace {
 
 // RecordingProofVerifier accepts any certificate chain and records the common
 // name of the leaf.
 class RecordingProofVerifier : public net::ProofVerifier {
  public:
   // ProofVerifier interface.
@@ skipping 55 matching lines @@
     // If we have a relative URL, set some defaults.
     string full_uri = secure ? "https://www.google.com" :
                                "http://www.google.com";
     full_uri.append(uri.as_string());
     headers->SetRequestUri(full_uri);
   }
   return headers;
 }
 
 // A quic client which allows mocking out writes.
-class QuicEpollClient : public QuicClient {
+class MockableQuicClient : public QuicClient {
  public:
-  typedef QuicClient Super;
+  MockableQuicClient(IPEndPoint server_address,
+                     const string& server_hostname,
+                     const QuicVersionVector& supported_versions)
+      : QuicClient(server_address, server_hostname, supported_versions, false),
+        override_guid_(0),
+        test_writer_(NULL) {}
 
-  QuicEpollClient(IPEndPoint server_address,
-             const string& server_hostname,
-             const QuicVersionVector& supported_versions)
-      : Super(server_address, server_hostname, supported_versions, false),
-        override_guid_(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),
+        test_writer_(NULL) {}
 
-  QuicEpollClient(IPEndPoint server_address,
-             const string& server_hostname,
-             const QuicConfig& config,
-             const QuicVersionVector& supported_versions)
-      : Super(server_address, server_hostname, config, supported_versions),
-        override_guid_(0), test_writer_(NULL) {
-  }
-
-  virtual ~QuicEpollClient() {
+  virtual ~MockableQuicClient() {
     if (connected()) {
       Disconnect();
     }
   }
 
   virtual QuicPacketWriter* CreateQuicPacketWriter() OVERRIDE {
-    QuicPacketWriter* writer = Super::CreateQuicPacketWriter();
+    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_ : Super::GenerateGuid();
+    return override_guid_ ? override_guid_ : QuicClient::GenerateGuid();
   }
 
   // Takes ownership of writer.
-  void UseWriter(QuicTestWriter* writer) { test_writer_ = writer; }
+  void UseWriter(QuicPacketWriterWrapper* writer) { test_writer_ = writer; }
 
-  void UseGuid(QuicGuid guid) {
-    override_guid_ = guid;
-  }
+  void UseGuid(QuicGuid guid) { override_guid_ = guid; }
 
  private:
   QuicGuid override_guid_;  // GUID to use, if nonzero
-  QuicTestWriter* test_writer_;
+  QuicPacketWriterWrapper* test_writer_;
 };
 
 QuicTestClient::QuicTestClient(IPEndPoint address, const string& hostname,
                                const QuicVersionVector& supported_versions)
-    : client_(new QuicEpollClient(address, hostname, supported_versions)) {
+    : client_(new MockableQuicClient(address, hostname, supported_versions)) {
   Initialize(address, hostname, true);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
                                const string& hostname,
                                bool secure,
                                const QuicVersionVector& supported_versions)
-    : client_(new QuicEpollClient(address, hostname, supported_versions)) {
+    : client_(new MockableQuicClient(address, hostname, supported_versions)) {
   Initialize(address, hostname, secure);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint address,
                                const string& hostname,
                                bool secure,
                                const QuicConfig& config,
                                const QuicVersionVector& supported_versions)
-    : client_(new QuicEpollClient(address, hostname, config,
-                                  supported_versions)) {
+    : client_(new MockableQuicClient(
+        address, hostname, config, supported_versions)) {
   Initialize(address, hostname, secure);
 }
 
 void QuicTestClient::Initialize(IPEndPoint address,
                                 const string& hostname,
                                 bool secure) {
   server_address_ = address;
   priority_ = 3;
   connect_attempted_ = false;
   secure_ = secure;
@@ skipping 50 matching lines @@
 }
 
 ssize_t QuicTestClient::SendData(string data, bool last_data) {
   QuicSpdyClientStream* stream = GetOrCreateStream();
   if (!stream) { return 0; }
   GetOrCreateStream()->SendBody(data, last_data);
   WaitForWriteToFlush();
   return data.length();
 }
 
+QuicPacketCreator::Options* QuicTestClient::options() {
+  return client_->options();
+}
+
 string QuicTestClient::SendCustomSynchronousRequest(
     const HTTPMessage& message) {
   SendMessage(message);
   WaitForResponse();
   return response_;
 }
 
 string QuicTestClient::SendSynchronousRequest(const string& uri) {
   if (SendRequest(uri) == 0) {
     DLOG(ERROR) << "Failed the request for uri:" << uri;
@@ skipping 17 matching lines @@
     if (stream_ == NULL) {
       return NULL;
     }
     stream_->set_visitor(this);
     reinterpret_cast<QuicSpdyClientStream*>(stream_)->set_priority(priority_);
   }
 
   return stream_;
 }
 
+QuicErrorCode QuicTestClient::connection_error() {
+  return client()->session()->error();
+}
+
+QuicClient* QuicTestClient::client() { return client_.get(); }
+
 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());
@@ skipping 141 matching lines @@
   headers_.CopyFrom(stream_->headers());
   stream_error_ = stream_->stream_error();
   bytes_read_ = stream_->stream_bytes_read() + stream_->header_bytes_read();
   bytes_written_ =
       stream_->stream_bytes_written() + stream_->header_bytes_written();
   response_header_size_ = headers_.GetSizeForWriteBuffer();
   response_body_size_ = stream_->data().size();
   stream_ = NULL;
 }
 
-void QuicTestClient::UseWriter(QuicTestWriter* writer) {
-  reinterpret_cast<QuicEpollClient*>(client_.get())->UseWriter(writer);
+void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) {
+  client_->UseWriter(writer);
 }
 
 void QuicTestClient::UseGuid(QuicGuid guid) {
   DCHECK(!connected());
-  reinterpret_cast<QuicEpollClient*>(client_.get())->UseGuid(guid);
+  client_->UseGuid(guid);
 }
 
 void QuicTestClient::WaitForWriteToFlush() {
-  while (connected() && client()->session()->HasQueuedData()) {
+  while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net