Make QuicTestClient no longer inherit from SimpleClient

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 <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 420 matching lines @@
 }
 
 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) {
   if (SendMessage(message) == 0) {
     DLOG(ERROR) << "Failed the request for uri:"
                 << message.headers()->request_uri();
     // Set the response_ explicitly.  Otherwise response_ will contain the
@@ skipping 236 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";
-}
-
 void QuicTestClient::MigrateSocket(const IPAddress& new_host) {
   client_->MigrateSocket(new_host);
 }
 
-string QuicTestClient::SerializeMessage(const HTTPMessage& message) {
-  LOG(DFATAL) << "Not implemented";
-  return "";
-}
-
 IPAddress QuicTestClient::bind_to_address() const {
   return client_->bind_to_address();
 }
 
-void QuicTestClient::set_bind_to_address(const IPAddress& address) {
+void QuicTestClient::set_bind_to_address(IPAddress address) {
   client_->set_bind_to_address(address);
 }
 
 const IPEndPoint& QuicTestClient::address() const {
   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();
   }
 }
 
 void QuicTestClient::TestClientDataToResend::Resend() {
   BalsaHeaders balsa_headers;
   SpdyBalsaUtils::SpdyHeadersToRequestHeaders(*headers_, &balsa_headers);
   test_client_->GetOrCreateStreamAndSendRequest(&balsa_headers, body_, fin_,
                                                 delegate_);
   headers_.reset();
 }
 
 // static
 void QuicTestClient::FillInRequest(const string& uri, HTTPMessage* message) {
   CHECK(message);
   message->headers()->SetRequestVersion(
       HTTPMessage::VersionToString(HttpConstants::HTTP_1_1));
   message->headers()->SetRequestMethod(
       HTTPMessage::MethodToString(HttpConstants::GET));
   message->headers()->SetRequestUri(uri);
 }
 
 }  // namespace test
 }  // namespace net