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

net/tools/quic/quic_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_client.h"
 
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/epoll.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include "base/logging.h"
 #include "base/run_loop.h"
+#include "base/strings/string_number_conversions.h"
 #include "net/base/sockaddr_storage.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_connection.h"
 #include "net/quic/core/quic_data_reader.h"
 #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/tools/quic/quic_epoll_alarm_factory.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/spdy_balsa_utils.h"
 
 #ifndef SO_RXQ_OVFL
 #define SO_RXQ_OVFL 40
 #endif
 
 // TODO(rtenneti): Add support for MMSG_MORE.
 #define MMSG_MORE 0
 
 using base::StringPiece;
+using base::StringToInt;
 using std::string;
 using std::vector;
 
 namespace net {
 
 const int kEpollFlags = EPOLLIN | EPOLLOUT | EPOLLET;
 
 void QuicClient::ClientQuicDataToResend::Resend() {
   client_->SendRequest(*headers_, body_, fin_);
-  delete headers_;
   headers_ = nullptr;
 }
 
 QuicClient::QuicClient(IPEndPoint server_address,
                        const QuicServerId& server_id,
                        const QuicVersionVector& supported_versions,
                        EpollServer* epoll_server,
                        std::unique_ptr<ProofVerifier> proof_verifier)
     : QuicClient(server_address,
                  server_id,
@@ skipping 60 matching lines @@
 
   if (!CreateUDPSocketAndBind()) {
     return false;
   }
 
   epoll_server_->RegisterFD(GetLatestFD(), this, kEpollFlags);
   initialized_ = true;
   return true;
 }
 
-QuicClient::QuicDataToResend::QuicDataToResend(BalsaHeaders* headers,
-                                               StringPiece body,
-                                               bool fin)
-    : headers_(headers), body_(body), fin_(fin) {}
-
-QuicClient::QuicDataToResend::~QuicDataToResend() {
-  if (headers_) {
-    delete headers_;
-  }
-}
-
 bool QuicClient::CreateUDPSocketAndBind() {
   int fd =
       QuicSocketUtils::CreateUDPSocket(server_address_, &overflow_supported_);
   if (fd < 0) {
     return false;
   }
 
   IPEndPoint client_address;
   if (bind_to_address_.size() != 0) {
     client_address = IPEndPoint(bind_to_address_, local_port_);
@@ skipping 119 matching lines @@
 }
 
 void QuicClient::CleanUpUDPSocketImpl(int fd) {
   if (fd > -1) {
     epoll_server_->UnregisterFD(fd);
     int rc = close(fd);
     DCHECK_EQ(0, rc);
   }
 }
 
-void QuicClient::SendRequest(const BalsaHeaders& headers,
+void QuicClient::SendRequest(const SpdyHeaderBlock& headers,
                              StringPiece body,
                              bool fin) {
   QuicClientPushPromiseIndex::TryHandle* handle;
-  QuicAsyncStatus rv = push_promise_index()->Try(
-      SpdyBalsaUtils::RequestHeadersToSpdyHeaders(headers), this, &handle);
+  QuicAsyncStatus rv = push_promise_index()->Try(headers, this, &handle);
   if (rv == QUIC_SUCCESS)
     return;
 
   if (rv == QUIC_PENDING) {
     // May need to retry request if asynchronous rendezvous fails.
-    auto* new_headers = new BalsaHeaders;
-    new_headers->CopyFrom(headers);
+    std::unique_ptr<SpdyHeaderBlock> new_headers(
+        new SpdyHeaderBlock(headers.Clone()));
     push_promise_data_to_resend_.reset(
-        new ClientQuicDataToResend(new_headers, body, fin, this));
+        new ClientQuicDataToResend(std::move(new_headers), body, fin, this));
     return;
   }
 
   QuicSpdyClientStream* stream = CreateReliableClientStream();
   if (stream == nullptr) {
     QUIC_BUG << "stream creation failed!";
     return;
   }
-  stream->SendRequest(SpdyBalsaUtils::RequestHeadersToSpdyHeaders(headers),
-                      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 BalsaHeaders;
-    new_headers->CopyFrom(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 QuicClient::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 QuicClient::SendRequestAndWaitForResponse(const BalsaHeaders& headers,
+void QuicClient::SendRequestAndWaitForResponse(const SpdyHeaderBlock& headers,
                                                StringPiece body,
                                                bool fin) {
   SendRequest(headers, body, fin);
   while (WaitForEvents()) {
   }
 }
 
 void QuicClient::SendRequestsAndWaitForResponse(
     const vector<string>& url_list) {
   for (size_t i = 0; i < url_list.size(); ++i) {
-    BalsaHeaders headers;
-    headers.SetRequestFirstlineFromStringPieces("GET", url_list[i], "HTTP/1.1");
+    SpdyHeaderBlock headers;
+    if (!SpdyUtils::PopulateHeaderBlockFromUrl(url_list[i], &headers)) {
+      QUIC_BUG << "Unable to create request";
+      continue;
+    }
     SendRequest(headers, "", true);
   }
   while (WaitForEvents()) {
   }
 }
 
 QuicSpdyClientStream* QuicClient::CreateReliableClientStream() {
   QuicSpdyClientStream* stream = QuicClientBase::CreateReliableClientStream();
   if (stream) {
     stream->set_visitor(this);
@@ skipping 59 matching lines @@
   }
   if (event->in_events & EPOLLERR) {
     DVLOG(1) << "Epollerr";
   }
 }
 
 void QuicClient::OnClose(QuicSpdyStream* stream) {
   DCHECK(stream != nullptr);
   QuicSpdyClientStream* client_stream =
       static_cast<QuicSpdyClientStream*>(stream);
-  BalsaHeaders response_headers;
-  SpdyBalsaUtils::SpdyHeadersToResponseHeaders(
-      client_stream->response_headers(), &response_headers);
 
+  const SpdyHeaderBlock& response_headers = client_stream->response_headers();
   if (response_listener_.get() != nullptr) {
     response_listener_->OnCompleteResponse(stream->id(), response_headers,
                                            client_stream->data());
   }
 
   // Store response headers and body.
   if (store_response_) {
-    latest_response_code_ = response_headers.parsed_response_code();
-    response_headers.DumpHeadersToString(&latest_response_headers_);
+    auto status = response_headers.find(":status");
+    if (status == response_headers.end() ||
+        !StringToInt(status->second, &latest_response_code_)) {
+      LOG(ERROR) << "Invalid response headers: no status code";
+    }
+    latest_response_headers_ = response_headers.DebugString();
+    latest_response_header_block_ = response_headers.Clone();
     latest_response_body_ = client_stream->data();
     latest_response_trailers_ =
         client_stream->received_trailers().DebugString();
   }
 }
 
 bool QuicClient::CheckVary(const SpdyHeaderBlock& client_request,
                            const SpdyHeaderBlock& promise_request,
                            const SpdyHeaderBlock& promise_response) {
   return true;
@@ skipping 13 matching lines @@
 size_t QuicClient::latest_response_code() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_code_;
 }
 
 const string& QuicClient::latest_response_headers() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_headers_;
 }
 
+const SpdyHeaderBlock& QuicClient::latest_response_header_block() const {
+  QUIC_BUG_IF(!store_response_) << "Response not stored!";
+  return latest_response_header_block_;
+}
+
 const string& QuicClient::latest_response_body() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_body_;
 }
 
 const string& QuicClient::latest_response_trailers() const {
   QUIC_BUG_IF(!store_response_) << "Response not stored!";
   return latest_response_trailers_;
 }
 
@@ skipping 17 matching lines @@
   return fd_address_map_.back().first;
 }
 
 void QuicClient::ProcessPacket(const IPEndPoint& self_address,
                                const IPEndPoint& peer_address,
                                const QuicReceivedPacket& packet) {
   session()->connection()->ProcessUdpPacket(self_address, peer_address, packet);
 }
 
 }  // namespace net