Remove usage of BalsaHeaders from QuicClient. Also move QuicDataToResend from QuicClient to QuicCli…

net/tools/quic/quic_simple_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/quic_simple_client.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/run_loop.h"
@@ skipping 10 matching lines @@
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/quic/core/quic_server_id.h"
 #include "net/quic/core/spdy_utils.h"
 #include "net/spdy/spdy_header_block.h"
 #include "net/spdy/spdy_http_utils.h"
 #include "net/udp/udp_client_socket.h"
 
 using std::string;
 using std::vector;
+using base::StringPiece;
 
 namespace net {
 
 void QuicSimpleClient::ClientQuicDataToResend::Resend() {
   client_->SendRequest(*headers_, body_, fin_);
-  delete headers_;
   headers_ = nullptr;
 }
 
 QuicSimpleClient::QuicSimpleClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicVersionVector& supported_versions,
     std::unique_ptr<ProofVerifier> proof_verifier)
     : QuicClientBase(server_id,
                      supported_versions,
@@ skipping 39 matching lines @@
   QuicClientBase::Initialize();
 
   if (!CreateUDPSocket()) {
     return false;
   }
 
   initialized_ = true;
   return true;
 }
 
-QuicSimpleClient::QuicDataToResend::QuicDataToResend(HttpRequestInfo* headers,
-                                                     base::StringPiece body,
-                                                     bool fin)
-    : headers_(headers), body_(body), fin_(fin) {}
-
-QuicSimpleClient::QuicDataToResend::~QuicDataToResend() {
-  if (headers_) {
-    delete headers_;
-  }
-}
-
 bool QuicSimpleClient::CreateUDPSocket() {
   std::unique_ptr<UDPClientSocket> socket(
       new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
                           &net_log_, NetLog::Source()));
 
   int address_family = server_address_.GetSockAddrFamily();
   if (bind_to_address_.size() != 0) {
     client_address_ = IPEndPoint(bind_to_address_, local_port_);
   } else if (address_family == AF_INET) {
     client_address_ = IPEndPoint(IPAddress::IPv4AllZeros(), local_port_);
@@ skipping 120 matching lines @@
   }
   data_to_resend_on_connect_.clear();
 
   reset_writer();
   packet_reader_.reset();
   packet_reader_started_ = false;
 
   initialized_ = false;
 }
 
-void QuicSimpleClient::SendRequest(const HttpRequestInfo& headers,
-                                   base::StringPiece body,
+void QuicSimpleClient::SendRequest(const SpdyHeaderBlock& headers,
+                                   StringPiece body,
                                    bool fin) {
   QuicSpdyClientStream* stream = CreateReliableClientStream();
   if (stream == nullptr) {
     LOG(DFATAL) << "stream creation failed!";
     return;
   }
-  SpdyHeaderBlock header_block;
-  CreateSpdyHeadersFromHttpRequest(headers, headers.extra_headers, true,
-                                   &header_block);
   stream->set_visitor(this);
-  stream->SendRequest(std::move(header_block), body, fin);
+  stream->SendRequest(headers.Clone(), body, fin);
   if (FLAGS_enable_quic_stateless_reject_support) {
     // Record this in case we need to resend.
-    auto* new_headers = new HttpRequestInfo;
-    *new_headers = headers;
-    auto* data_to_resend =
-        new ClientQuicDataToResend(new_headers, body, fin, this);
+    std::unique_ptr<SpdyHeaderBlock> new_headers(
+        new SpdyHeaderBlock(headers.Clone()));
+    auto data_to_resend =
+        new ClientQuicDataToResend(std::move(new_headers), body, fin, this);
     MaybeAddQuicDataToResend(std::unique_ptr<QuicDataToResend>(data_to_resend));
   }
 }
 
 void QuicSimpleClient::MaybeAddQuicDataToResend(
     std::unique_ptr<QuicDataToResend> data_to_resend) {
   DCHECK(FLAGS_enable_quic_stateless_reject_support);
   if (session()->IsCryptoHandshakeConfirmed()) {
     // The handshake is confirmed.  No need to continue saving requests to
     // resend.
     data_to_resend_on_connect_.clear();
     return;
   }
 
   // The handshake is not confirmed.  Push the data onto the queue of data to
   // resend if statelessly rejected.
   data_to_resend_on_connect_.push_back(std::move(data_to_resend));
 }
 
 void QuicSimpleClient::SendRequestAndWaitForResponse(
-    const HttpRequestInfo& request,
+    const SpdyHeaderBlock& headers,
     base::StringPiece body,
     bool fin) {
-  SendRequest(request, body, fin);
+  SendRequest(headers, body, fin);
   while (WaitForEvents()) {
   }
 }
 
 void QuicSimpleClient::SendRequestsAndWaitForResponse(
     const base::CommandLine::StringVector& url_list) {
   for (size_t i = 0; i < url_list.size(); ++i) {
-    HttpRequestInfo request;
-    request.method = "GET";
-    request.url = GURL(url_list[i]);
-    SendRequest(request, "", true);
+    string url = GURL(url_list[i]).spec();
+    SpdyHeaderBlock headers;
+    if (!SpdyUtils::PopulateHeaderBlockFromUrl(url, &headers)) {
+      QUIC_BUG << "Unable to create request";
+      continue;
+    }
+    SendRequest(headers, "", true);
   }
 
   while (WaitForEvents()) {
   }
 }
 
 bool QuicSimpleClient::WaitForEvents() {
   DCHECK(connected());
 
   base::RunLoop().RunUntilIdle();
@@ skipping 92 matching lines @@
   session()->connection()->ProcessUdpPacket(local_address, peer_address,
                                             packet);
   if (!session()->connection()->connected()) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace net