Remove Balsa from QuicSpdyClientStream.

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/socket.h>
 #include <unistd.h>
 
 #include "base/logging.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_server_id.h"
 #include "net/tools/balsa/balsa_headers.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
+#include "net/tools/quic/spdy_utils.h"
 
 #ifndef SO_RXQ_OVFL
 #define SO_RXQ_OVFL 40
 #endif
 
 using std::string;
 using std::vector;
 
 namespace net {
 namespace tools {
@@ skipping 208 matching lines @@
 }
 
 void QuicClient::SendRequest(const BalsaHeaders& headers,
                              StringPiece body,
                              bool fin) {
   QuicSpdyClientStream* stream = CreateReliableClientStream();
   if (stream == nullptr) {
     LOG(DFATAL) << "stream creation failed!";
     return;
   }
-  stream->SendRequest(headers, body, fin);
+  stream->SendRequest(
+      SpdyUtils::RequestHeadersToSpdyHeaders(headers), body, fin);
   stream->set_visitor(this);
 }
 
 void QuicClient::SendRequestAndWaitForResponse(
     const BalsaHeaders& headers,
     StringPiece body,
     bool fin) {
   SendRequest(headers, body, fin);
   while (WaitForEvents()) {}
 }
@@ skipping 51 matching lines @@
     session_->connection()->OnCanWrite();
   }
   if (event->in_events & NET_POLLERR) {
     DVLOG(1) << "NET_POLLERR";
   }
 }
 
 void QuicClient::OnClose(QuicDataStream* stream) {
   QuicSpdyClientStream* client_stream =
       static_cast<QuicSpdyClientStream*>(stream);
+  BalsaHeaders headers;
+  SpdyUtils::FillBalsaResponseHeaders(client_stream->headers(), &headers);
+
   if (response_listener_.get() != nullptr) {
     response_listener_->OnCompleteResponse(
-        stream->id(), client_stream->headers(), client_stream->data());
+        stream->id(), headers, client_stream->data());
   }
 
   // Store response headers and body.
   if (store_response_) {
-    latest_response_code_ = client_stream->headers().parsed_response_code();
-    client_stream->headers().DumpHeadersToString(&latest_response_headers_);
+    latest_response_code_ = headers.parsed_response_code();
+    headers.DumpHeadersToString(&latest_response_headers_);
     latest_response_body_ = client_stream->data();
   }
 }
 
 bool QuicClient::connected() const {
   return session_.get() && session_->connection() &&
       session_->connection()->connected();
 }
 
 bool QuicClient::goaway_received() const {
@@ skipping 54 matching lines @@
   QuicEncryptedPacket packet(buf, bytes_read, false);
 
   IPEndPoint client_address(client_ip, client_address_.port());
   session_->connection()->ProcessUdpPacket(
       client_address, server_address, packet);
   return true;
 }
 
 }  // namespace tools
 }  // namespace net