Remove any use of BalsaHeaders and HttpMessage from QuicTestClient.

net/tools/quic/test_tools/quic_test_client.h

 // 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.
 
 #ifndef NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 #define NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cstdint>
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/quic/core/quic_framer.h"
 #include "net/quic/core/quic_packet_creator.h"
 #include "net/quic/core/quic_protocol.h"
-#include "net/tools/balsa/balsa_frame.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::StringPiece;
 
 namespace net {
 
 class ProofVerifier;
 
@@ skipping 89 matching lines @@
                    QuicAckListenerInterface* delegate);
 
   // Clears any outstanding state and sends a simple GET of 'uri' to the
   // server.  Returns 0 if the request failed and no bytes were written.
   ssize_t SendRequest(const std::string& uri);
   // Sends requests for all the urls and waits for the responses.  To process
   // the individual responses as they are returned, the caller should use the
   // set the response_listener on the client().
   void SendRequestsAndWaitForResponses(
       const std::vector<std::string>& url_list);
-  ssize_t SendMessage(const HTTPMessage& message);
-  std::string SendCustomSynchronousRequest(const HTTPMessage& message);
+  // Sends a request containing |headers| and |body| and returns the number of
+  // bytes sent (the size of the serialized request headers and body).
+  ssize_t SendMessage(const SpdyHeaderBlock& headers, base::StringPiece body);
+  // Sends a request containing |headers| and |body| with the fin bit set to
+  // |fin| and returns the number of bytes sent (the size of the serialized
+  // request headers and body).
+  ssize_t SendMessage(const SpdyHeaderBlock& headers,
+                      base::StringPiece body,
+                      bool fin);
+  // Sends a request containing |headers| and |body|, waits for the response,
+  // and returns the response body.
+  std::string SendCustomSynchronousRequest(const SpdyHeaderBlock& headers,
+                                           const std::string& body);
+  // Sends a GET request for |uri|, waits for the response, and returns the
+  // response body.
   std::string SendSynchronousRequest(const std::string& uri);
   void Connect();
   void ResetConnection();
   void Disconnect();
   IPEndPoint local_address() const;
   void ClearPerRequestState();
   bool WaitUntil(int timeout_ms, std::function<bool()> trigger);
   ssize_t Send(const void* buffer, size_t size);
   bool response_complete() const;
   bool response_headers_complete() const;
@@ skipping 55 matching lines @@
   void UseConnectionId(QuicConnectionId connection_id);
 
   // Update internal stream_ pointer and perform accompanying housekeeping.
   void SetStream(QuicSpdyClientStream* stream);
   // Returns nullptr if the maximum number of streams have already been created.
   QuicSpdyClientStream* GetOrCreateStream();
 
   // Calls GetOrCreateStream(), sends the request on the stream, and
   // stores the request in case it needs to be resent.  If |headers| is
   // null, only the body will be sent on the stream.
-  ssize_t GetOrCreateStreamAndSendRequest(const BalsaHeaders* headers,
-                                          StringPiece body,
+  ssize_t GetOrCreateStreamAndSendRequest(const SpdyHeaderBlock* headers,
+                                          base::StringPiece body,
                                           bool fin,
                                           QuicAckListenerInterface* delegate);
 
   QuicRstStreamErrorCode stream_error() { return stream_error_; }
   QuicErrorCode connection_error();
 
   MockableQuicClient* client();
 
   // cert_common_name returns the common name value of the server's certificate,
   // or the empty string if no certificate was presented.
@@ skipping 56 matching lines @@
 
     ~TestClientDataToResend() override {}
 
     void Resend() override;
 
    protected:
     QuicTestClient* test_client_;
     QuicAckListenerInterface* delegate_;
   };
 
-  // Given a uri, creates a simple HTTPMessage request message for testing.
-  static void FillInRequest(const std::string& uri, HTTPMessage* message);
+  // Given |uri|, populates the fields in |headers| for a simple GET
+  // request. If |uri| is a relative URL, the QuicServerId will be
+  // use to specify the authority.
+  bool PopulateHeaderBlockFromUrl(const std::string& uri,
+                                  SpdyHeaderBlock* headers);
 
   bool HaveActiveStream();
 
   EpollServer epoll_server_;
   std::unique_ptr<MockableQuicClient> client_;  // The actual client
   QuicSpdyClientStream* stream_;
 
   QuicRstStreamErrorCode stream_error_;
 
   bool response_complete_;
@@ skipping 35 matching lines @@
   std::string override_sni_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicTestClient);
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_TEST_TOOLS_QUIC_TEST_CLIENT_H_