Sync various changes to QuicTestClient.

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 24 matching lines @@
 
 // RecordingProofVerifier accepts any certificate chain and records the common
 // name of the leaf.
 class RecordingProofVerifier : public ProofVerifier {
  public:
   // ProofVerifier interface.
   virtual Status VerifyProof(const string& hostname,
                              const string& server_config,
                              const vector<string>& certs,
                              const string& signature,
-                             const net::ProofVerifyContext* context,
+                             const ProofVerifyContext* context,
                              string* error_details,
                              scoped_ptr<ProofVerifyDetails>* details,
                              ProofVerifierCallback* callback) OVERRIDE {
     common_name_.clear();
     if (certs.empty()) {
       return FAILURE;
     }
 
     // Convert certs to X509Certificate.
     vector<StringPiece> cert_pieces(certs.size());
@@ skipping 33 matching lines @@
       !uri.starts_with("http://")) {
     // 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 MockableQuicClient : public QuicClient {
- public:
-  MockableQuicClient(IPEndPoint server_address,
-                     const QuicServerId& server_id,
-                     const QuicVersionVector& supported_versions,
-                     uint32 initial_flow_control_window)
-      : QuicClient(server_address,
-                   server_id,
-                   supported_versions,
-                   false,
-                   initial_flow_control_window),
-        override_connection_id_(0),
-        test_writer_(NULL) {}
+MockableQuicClient::MockableQuicClient(
+    IPEndPoint server_address,
+    const QuicServerId& server_id,
+    const QuicVersionVector& supported_versions,
+    uint32 initial_flow_control_window)
+    : QuicClient(server_address,
+                 server_id,
+                 supported_versions,
+                 false,
+                 initial_flow_control_window),
+      override_connection_id_(0),
+      test_writer_(NULL) {}
 
-  MockableQuicClient(IPEndPoint server_address,
-                     const QuicServerId& server_id,
-                     const QuicConfig& config,
-                     const QuicVersionVector& supported_versions,
-                     uint32 initial_flow_control_window)
-      : QuicClient(server_address,
-                   server_id,
-                   config,
-                   supported_versions,
-                   initial_flow_control_window),
-        override_connection_id_(0),
-        test_writer_(NULL) {}
+MockableQuicClient::MockableQuicClient(
+    IPEndPoint server_address,
+    const QuicServerId& server_id,
+    const QuicConfig& config,
+    const QuicVersionVector& supported_versions,
+    uint32 initial_flow_control_window)
+    : QuicClient(server_address,
+                 server_id,
+                 config,
+                 supported_versions,
+                 initial_flow_control_window),
+      override_connection_id_(0),
+      test_writer_(NULL) {}
 
-  virtual ~MockableQuicClient() {
-    if (connected()) {
-      Disconnect();
-    }
+MockableQuicClient::~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_;
+QuicPacketWriter* MockableQuicClient::CreateQuicPacketWriter() {
+  QuicPacketWriter* writer = QuicClient::CreateQuicPacketWriter();
+  if (!test_writer_) {
+    return writer;
   }
+  test_writer_->set_writer(writer);
+  return test_writer_;
+}
 
-  virtual QuicConnectionId GenerateConnectionId() OVERRIDE {
-    return override_connection_id_ ? override_connection_id_
-                                   : QuicClient::GenerateConnectionId();
-  }
+QuicConnectionId MockableQuicClient::GenerateConnectionId() {
+  return override_connection_id_ ? override_connection_id_
+      : QuicClient::GenerateConnectionId();
+}
 
-  // Takes ownership of writer.
-  void UseWriter(QuicPacketWriterWrapper* writer) {
-    CHECK(test_writer_ == NULL);
-    test_writer_ = writer;
-  }
+// Takes ownership of writer.
+void MockableQuicClient::UseWriter(QuicPacketWriterWrapper* writer) {
+  CHECK(test_writer_ == NULL);
+  test_writer_ = writer;
+}
 
-  void UseConnectionId(QuicConnectionId connection_id) {
-    override_connection_id_ = connection_id;
-  }
-
-  virtual int ReadPacket(char* buffer,
-                         int buffer_len,
-                         IPEndPoint* server_address,
-                         IPAddressNumber* client_ip) OVERRIDE {
-    return QuicClient::ReadPacket(
-        buffer, buffer_len, server_address, client_ip);
-  }
-
- private:
-  QuicConnectionId override_connection_id_;  // ConnectionId to use, if nonzero
-  QuicPacketWriterWrapper* test_writer_;
-};
+void MockableQuicClient::UseConnectionId(QuicConnectionId connection_id) {
+  override_connection_id_ = connection_id;
+}
 
 QuicTestClient::QuicTestClient(IPEndPoint server_address,
                                const string& server_hostname,
                                const QuicVersionVector& supported_versions)
     : client_(new MockableQuicClient(server_address,
                                      QuicServerId(server_hostname,
                                                   server_address.port(),
                                                   false,
                                                   PRIVACY_MODE_DISABLED),
                                      supported_versions,
                                      kInitialFlowControlWindowForTest)) {
-  Initialize(server_address, server_hostname, true);
+  Initialize(true);
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint server_address,
                                const string& server_hostname,
                                bool secure,
                                const QuicVersionVector& supported_versions)
     : client_(new MockableQuicClient(server_address,
                                      QuicServerId(server_hostname,
                                                   server_address.port(),
                                                   secure,
                                                   PRIVACY_MODE_DISABLED),
                                      supported_versions,
                                      kInitialFlowControlWindowForTest)) {
-  Initialize(server_address, server_hostname, secure);
+  Initialize(secure);
 }
 
 QuicTestClient::QuicTestClient(
     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(server_address,
-                               QuicServerId(server_hostname,
-                                            server_address.port(),
-                                            secure,
-                                            PRIVACY_MODE_DISABLED),
-                               config,
-                               supported_versions,
-                               client_initial_flow_control_receive_window)) {
-  Initialize(server_address, server_hostname, secure);
+          new MockableQuicClient(server_address,
+                                 QuicServerId(server_hostname,
+                                              server_address.port(),
+                                              secure,
+                                              PRIVACY_MODE_DISABLED),
+                                 config,
+                                 supported_versions,
+                                 client_initial_flow_control_receive_window)) {
+  Initialize(secure);
 }
 
-void QuicTestClient::Initialize(IPEndPoint address,
-                                const string& hostname,
-                                bool secure) {
-  server_address_ = address;
+QuicTestClient::QuicTestClient() {
+}
+
+void QuicTestClient::Initialize(bool secure) {
   priority_ = 3;
   connect_attempted_ = false;
   secure_ = secure;
   auto_reconnect_ = false;
   buffer_body_ = true;
   proof_verifier_ = NULL;
   ClearPerRequestState();
   ExpectCertificates(secure_);
 }
 
 QuicTestClient::~QuicTestClient() {
   if (stream_) {
     stream_->set_visitor(NULL);
   }
 }
 
 void QuicTestClient::ExpectCertificates(bool on) {
   if (on) {
     proof_verifier_ = new RecordingProofVerifier;
     client_->SetProofVerifier(proof_verifier_);
   } else {
     proof_verifier_ = NULL;
     client_->SetProofVerifier(NULL);
   }
 }
 
 ssize_t QuicTestClient::SendRequest(const string& uri) {
-  HTTPMessage message(HttpConstants::HTTP_1_1, HttpConstants::GET, uri);
+  HTTPMessage message(HttpConstants::HTTP_1_1,
+                      HttpConstants::GET,
+                      uri);
   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_id(
-          QuicServerId(url.host(), url.EffectiveIntPort(),
-                       url.SchemeIs("https"), PRIVACY_MODE_DISABLED));
+          QuicServerId(url.host(),
+                       url.EffectiveIntPort(),
+                       url.SchemeIs("https"),
+                       PRIVACY_MODE_DISABLED));
     }
   }
 
   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(),
       message.body(),
       message.has_complete_message());
   WaitForWriteToFlush();
   return ret;
 }
 
 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();
 }
 
+bool QuicTestClient::response_complete() const {
+  return response_complete_;
+}
+
+int QuicTestClient::response_header_size() const {
+  return response_header_size_;
+}
+
+int QuicTestClient::response_body_size() const {
+  return response_body_size_;
+}
+
+bool QuicTestClient::buffer_body() const {
+  return buffer_body_;
+}
+
+void QuicTestClient::set_buffer_body(bool buffer_body) {
+  buffer_body_ = buffer_body;
+}
+
+bool QuicTestClient::ServerInLameDuckMode() const {
+  return false;
+}
+
+const string& QuicTestClient::response_body() {
+  return response_;
+}
+
 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 29 matching lines @@
 }
 
 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 =
+  QuicCryptoClientConfig* config =
       QuicClientPeer::GetCryptoConfig(client_.get());
-  net::QuicCryptoClientConfig::CachedState* state =
+  QuicCryptoClientConfig::CachedState* state =
       config->LookupOrCreate(client_->server_id());
-  const net::CryptoHandshakeMessage* handshake_msg = state->GetServerConfig();
+  const 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();
 }
 
-void QuicTestClient::WaitForResponse() {
-  if (stream_ == NULL) {
-    // The client has likely disconnected.
-    return;
-  }
-  client_->WaitForStreamToClose(stream_->id());
-}
-
 void QuicTestClient::Connect() {
   DCHECK(!connected());
   if (!connect_attempted_) {
     client_->Initialize();
   }
   client_->Connect();
   connect_attempted_ = true;
 }
 
 void QuicTestClient::ResetConnection() {
@@ skipping 120 matching lines @@
 
 void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) {
   client_->UseWriter(writer);
 }
 
 void QuicTestClient::UseConnectionId(QuicConnectionId connection_id) {
   DCHECK(!connected());
   client_->UseConnectionId(connection_id);
 }
 
+ssize_t QuicTestClient::SendAndWaitForResponse(const void *buffer,
+                                               size_t size) {
+  LOG(DFATAL) << "Not implemented";
+  return 0;
+}
+void QuicTestClient::Bind(IPEndPoint* local_address) {
+  DLOG(WARNING) << "Bind will be done during connect";
+}
+string QuicTestClient::SerializeMessage(const HTTPMessage& message) {
+  LOG(DFATAL) << "Not implemented";
+  return "";
+}
+IPAddressNumber QuicTestClient::bind_to_address() const {
+  return client_->bind_to_address();
+}
+void QuicTestClient::set_bind_to_address(IPAddressNumber address) {
+  client_->set_bind_to_address(address);
+}
+const IPEndPoint& QuicTestClient::address() const {
+  LOG(DFATAL) << "Not implemented";
+  return client_->server_address();
+}
+size_t QuicTestClient::requests_sent() const {
+  LOG(DFATAL) << "Not implemented";
+  return 0;
+}
+
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net