Make QuicTestClient::response_headers() return a SPDY header block, not BalsaHeaders.

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 <vector>
 
@@ skipping 403 matching lines @@
                                  bool last_data,
                                  QuicAckListenerInterface* delegate) {
   return GetOrCreateStreamAndSendRequest(nullptr, StringPiece(data), last_data,
                                          delegate);
 }
 
 bool QuicTestClient::response_complete() const {
   return response_complete_;
 }
 
-int QuicTestClient::response_header_size() const {
-  return response_header_size_;
-}
-
 int64_t QuicTestClient::response_body_size() const {
   return response_body_size_;
 }
 
 bool QuicTestClient::buffer_body() const {
   return buffer_body_;
 }
 
 void QuicTestClient::set_buffer_body(bool buffer_body) {
   buffer_body_ = buffer_body;
@@ skipping 107 matching lines @@
 IPEndPoint QuicTestClient::local_address() const {
   return client_->GetLatestClientAddress();
 }
 
 void QuicTestClient::ClearPerRequestState() {
   stream_error_ = QUIC_STREAM_NO_ERROR;
   stream_ = nullptr;
   response_ = "";
   response_complete_ = false;
   response_headers_complete_ = false;
-  response_headers_.Clear();
+  response_headers_.clear();
   bytes_read_ = 0;
   bytes_written_ = 0;
-  response_header_size_ = 0;
   response_body_size_ = 0;
 }
 
 bool QuicTestClient::HaveActiveStream() {
   return push_promise_data_to_resend_.get() ||
          (stream_ != nullptr &&
           !client_->session()->IsClosedStream(stream_->id()));
 }
 
 bool QuicTestClient::WaitUntil(int timeout_ms, std::function<bool()> trigger) {
@@ skipping 25 matching lines @@
   return SendData(string(static_cast<const char*>(buffer), size), false);
 }
 
 bool QuicTestClient::response_headers_complete() const {
   if (stream_ != nullptr) {
     return stream_->headers_decompressed();
   }
   return response_headers_complete_;
 }
 
-const BalsaHeaders* QuicTestClient::response_headers() const {
+const SpdyHeaderBlock* QuicTestClient::response_headers() const {
   if (stream_ != nullptr) {
-    SpdyBalsaUtils::SpdyHeadersToResponseHeaders(stream_->response_headers(),
-                                                 &response_headers_);
-    return &response_headers_;
-  } else {
-    return &response_headers_;
+    response_headers_ = stream_->response_headers().Clone();
   }
+  return &response_headers_;
 }
 
 const SpdyHeaderBlock& QuicTestClient::response_trailers() const {
   return response_trailers_;
 }
 
 int64_t QuicTestClient::response_size() const {
   return bytes_read();
 }
 
@@ skipping 26 matching lines @@
   }
   if (stream_ != stream) {
     return;
   }
   if (buffer_body()) {
     // TODO(fnk): The stream still buffers the whole thing. Fix that.
     response_ = stream_->data();
   }
   response_complete_ = true;
   response_headers_complete_ = stream_->headers_decompressed();
-  SpdyBalsaUtils::SpdyHeadersToResponseHeaders(stream_->response_headers(),
-                                               &response_headers_);
+  response_headers_ = stream_->response_headers().Clone();
   response_trailers_ = stream_->received_trailers().Clone();
   stream_error_ = stream_->stream_error();
   bytes_read_ = stream_->stream_bytes_read() + stream_->header_bytes_read();
   bytes_written_ =
       stream_->stream_bytes_written() + stream_->header_bytes_written();
-  response_header_size_ = response_headers_.GetSizeForWriteBuffer();
   response_body_size_ = stream_->data().size();
   stream_ = nullptr;
 }
 
 bool QuicTestClient::CheckVary(const SpdyHeaderBlock& client_request,
                                const SpdyHeaderBlock& promise_request,
                                const SpdyHeaderBlock& promise_response) {
   return true;
 }
 
@@ skipping 52 matching lines @@
   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