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

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 "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/x509_certificate.h"
 #include "net/quic/core/crypto/proof_verifier.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_server_id.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/tools/balsa/balsa_headers.h"

[Zhongyi Shi, 2016/09/26 21:12:55]

nit: remove the include?

[Ryan Hamilton, 2016/09/26 21:52:56]

Alas, the QuicTestClient is still using BalsaHeaders. I can't remove this ...
yet.

 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_packet_writer_wrapper.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "net/tools/quic/spdy_balsa_utils.h"
 #include "net/tools/quic/test_tools/http_message.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "url/gurl.h"
 
 using base::StringPiece;
 using net::QuicServerId;
@@ skipping 278 matching lines @@
     bool fin,
     QuicAckListenerInterface* delegate) {
   if (headers) {
     QuicClientPushPromiseIndex::TryHandle* handle;
     QuicAsyncStatus rv = client()->push_promise_index()->Try(
         SpdyBalsaUtils::RequestHeadersToSpdyHeaders(*headers), this, &handle);
     if (rv == QUIC_SUCCESS)
       return 1;
     if (rv == QUIC_PENDING) {
       // May need to retry request if asynchronous rendezvous fails.
-      auto* new_headers = new BalsaHeaders;
-      new_headers->CopyFrom(*headers);
-      push_promise_data_to_resend_.reset(
-          new TestClientDataToResend(new_headers, body, fin, this, delegate));
+      std::unique_ptr<SpdyHeaderBlock> new_headers(new SpdyHeaderBlock(
+          SpdyBalsaUtils::RequestHeadersToSpdyHeaders(*headers)));
+      push_promise_data_to_resend_.reset(new TestClientDataToResend(
+          std::move(new_headers), body, fin, this, delegate));
       return 1;
     }
   }
 
   // Maybe it's better just to overload this.  it's just that we need
   // for the GetOrCreateStream function to call something else...which
   // is icky and complicated, but maybe not worse than this.
   QuicSpdyClientStream* stream = GetOrCreateStream();
   if (stream == nullptr) {
     return 0;
@@ skipping 14 matching lines @@
       // HTTP/2 requests should include the :authority pseudo hader.
       spdy_headers[":authority"] = client_->server_id().host();
     }
     ret = stream->SendRequest(std::move(spdy_headers), body, fin);
     ++num_requests_;
   } else {
     stream->WriteOrBufferBody(body.as_string(), fin, delegate);
     ret = body.length();
   }
   if (FLAGS_enable_quic_stateless_reject_support) {
-    BalsaHeaders* new_headers = nullptr;
+    std::unique_ptr<SpdyHeaderBlock> new_headers;
     if (headers) {
-      new_headers = new BalsaHeaders;
-      new_headers->CopyFrom(*headers);
+      new_headers.reset(new SpdyHeaderBlock(
+          SpdyBalsaUtils::RequestHeadersToSpdyHeaders(*headers)));
     }
-    std::unique_ptr<QuicClient::QuicDataToResend> data_to_resend(
-        new TestClientDataToResend(new_headers, body, fin, this, delegate));
+    std::unique_ptr<QuicClientBase::QuicDataToResend> data_to_resend(
+        new TestClientDataToResend(std::move(new_headers), body, fin, this,
+                                   delegate));
     client()->MaybeAddQuicDataToResend(std::move(data_to_resend));
   }
   return ret;
 }
 
 ssize_t QuicTestClient::SendMessage(const HTTPMessage& message) {
   stream_ = nullptr;  // Always force creation of a stream for SendMessage.
   // Any response we might have received for a previous request would no longer
   // be valid.  TODO(jeffpiazza): There's probably additional client state that
   // should be reset here, too, if we were being more careful.
@@ skipping 350 matching lines @@
   return 0;
 }
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 void QuicTestClient::TestClientDataToResend::Resend() {
-  test_client_->GetOrCreateStreamAndSendRequest(headers_, body_, fin_,
+  BalsaHeaders balsa_headers;
+  SpdyBalsaUtils::SpdyHeadersToRequestHeaders(*headers_, &balsa_headers);
+  test_client_->GetOrCreateStreamAndSendRequest(&balsa_headers, body_, fin_,
                                                 delegate_);
-  if (headers_ != nullptr) {
-    delete headers_;
-    headers_ = nullptr;
-  }
+  headers_.reset();
 }
 
 // static
 void QuicTestClient::FillInRequest(const string& uri, HTTPMessage* message) {
   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