Remove any use of BalsaHeaders and HttpMessage from QuicTestClient.

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>
 
 #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/core/spdy_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"
 #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 76 matching lines @@
   const string& cert_sct() const { return cert_sct_; }
 
  private:
   std::unique_ptr<ProofVerifier> verifier_;
   string common_name_;
   string cert_sct_;
 };
 
 }  // anonymous namespace
 
-BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers) {
-  StringPiece uri = const_headers->request_uri();
-  if (uri.empty()) {
-    return nullptr;
-  }
-  if (const_headers->request_method() == "CONNECT") {
-    return nullptr;
-  }
-  BalsaHeaders* headers = new BalsaHeaders;
-  headers->CopyFrom(*const_headers);
-  if (!base::StartsWith(uri, "https://",
-                        base::CompareCase::INSENSITIVE_ASCII) &&
-      !base::StartsWith(uri, "http://", base::CompareCase::INSENSITIVE_ASCII)) {
-    // If we have a relative URL, set some defaults.
-    string full_uri = "https://test.example.com";
-    full_uri.append(uri.as_string());
-    headers->SetRequestUri(full_uri);
-  }
-  return headers;
-}
-
 MockableQuicClient::MockableQuicClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicVersionVector& supported_versions,
     EpollServer* epoll_server)
     : MockableQuicClient(server_address,
                          server_id,
                          QuicConfig(),
                          supported_versions,
                          epoll_server) {}
@@ skipping 132 matching lines @@
   if (!client_->config()->HasSetBytesForConnectionIdToSend()) {
     client_->config()->SetBytesForConnectionIdToSend(0);
   }
 }
 
 void QuicTestClient::SetUserAgentID(const string& user_agent_id) {
   client_->SetUserAgentID(user_agent_id);
 }
 
 ssize_t QuicTestClient::SendRequest(const string& uri) {
-  HTTPMessage message;
-  FillInRequest(uri, &message);
-  return SendMessage(message);
+  SpdyHeaderBlock headers;
+  if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
+    return 0;
+  }
+  return SendMessage(headers, "");
 }
 
 void QuicTestClient::SendRequestsAndWaitForResponses(
     const std::vector<string>& url_list) {
   for (const string& url : url_list) {
     SendRequest(url);
   }
   while (client()->WaitForEvents()) {
   }
   return;
 }
 
 ssize_t QuicTestClient::GetOrCreateStreamAndSendRequest(
-    const BalsaHeaders* headers,
+    const SpdyHeaderBlock* headers,
     StringPiece body,
     bool fin,
     QuicAckListenerInterface* delegate) {
   if (headers) {
     QuicClientPushPromiseIndex::TryHandle* handle;
-    QuicAsyncStatus rv = client()->push_promise_index()->Try(
-        SpdyBalsaUtils::RequestHeadersToSpdyHeaders(*headers), this, &handle);
+    QuicAsyncStatus rv =
+        client()->push_promise_index()->Try(*headers, this, &handle);
     if (rv == QUIC_SUCCESS)
       return 1;
     if (rv == QUIC_PENDING) {
       // May need to retry request if asynchronous rendezvous fails.
-      std::unique_ptr<SpdyHeaderBlock> new_headers(new SpdyHeaderBlock(
-          SpdyBalsaUtils::RequestHeadersToSpdyHeaders(*headers)));
+      std::unique_ptr<SpdyHeaderBlock> new_headers(
+          new SpdyHeaderBlock(headers->Clone()));
       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;
   }
 
   ssize_t ret = 0;
   if (headers != nullptr) {
-    SpdyHeaderBlock spdy_headers =
-        SpdyBalsaUtils::RequestHeadersToSpdyHeaders(*headers);
-    if (headers->HasHeader("transfer-encoding")) {
-      // We have tests which rely on sending a non-standards-compliant
-      // T-E header.
-      string encoding;
-      headers->GetAllOfHeaderAsString("transfer-encoding", &encoding);
-      spdy_headers.insert(std::make_pair("transfer-encoding", encoding));
-    }
-    auto authority = spdy_headers.find(":authority");
-    if (authority == spdy_headers.end() || authority->second.empty()) {
-      // HTTP/2 requests should include the :authority pseudo hader.
+    SpdyHeaderBlock spdy_headers(headers->Clone());
+    if (spdy_headers[":authority"].as_string().empty()) {
       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) {
     std::unique_ptr<SpdyHeaderBlock> new_headers;
     if (headers) {
-      new_headers.reset(new SpdyHeaderBlock(
-          SpdyBalsaUtils::RequestHeadersToSpdyHeaders(*headers)));
+      new_headers.reset(new SpdyHeaderBlock(headers->Clone()));
     }
     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) {
+ssize_t QuicTestClient::SendMessage(const SpdyHeaderBlock& headers,
+                                    StringPiece body) {
+  return SendMessage(headers, body, /*fin=*/true);
+}
+
+ssize_t QuicTestClient::SendMessage(const SpdyHeaderBlock& headers,
+                                    StringPiece body,
+                                    bool fin) {
   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.
   response_complete_ = false;
 
   // If we're not connected, try to find an sni hostname.
   if (!connected()) {
-    GURL url(message.headers()->request_uri());
+    GURL url(SpdyUtils::GetUrlFromHeaderBlock(headers));
     if (override_sni_set_) {
       client_->set_server_id(QuicServerId(override_sni_, url.EffectiveIntPort(),
                                           PRIVACY_MODE_DISABLED));
-    } else {
-      if (!url.host().empty()) {
-        client_->set_server_id(QuicServerId(url.host(), url.EffectiveIntPort(),
-                                            PRIVACY_MODE_DISABLED));
-      }
     }
   }
 
-  // TODO(rtenneti): Add support for HTTPMessage::body_chunks().
-  // CHECK(message.body_chunks().empty())
-  //      << "HTTPMessage::body_chunks not supported";
-
-  std::unique_ptr<BalsaHeaders> munged_headers(MungeHeaders(message.headers()));
-  ssize_t ret = GetOrCreateStreamAndSendRequest(
-      (munged_headers.get() ? munged_headers.get() : message.headers()),
-      message.body(), message.has_complete_message(), nullptr);
+  ssize_t ret = GetOrCreateStreamAndSendRequest(&headers, body, fin, nullptr);
   WaitForWriteToFlush();
   return ret;
 }
 
 ssize_t QuicTestClient::SendData(const string& data, bool last_data) {
   return SendData(data, last_data, nullptr);
 }
 
 ssize_t QuicTestClient::SendData(const string& data,
                                  bool last_data,
@@ skipping 16 matching lines @@
 
 void QuicTestClient::set_buffer_body(bool buffer_body) {
   buffer_body_ = buffer_body;
 }
 
 const string& QuicTestClient::response_body() {
   return response_;
 }
 
 string QuicTestClient::SendCustomSynchronousRequest(
-    const HTTPMessage& message) {
-  if (SendMessage(message) == 0) {
-    DLOG(ERROR) << "Failed the request for uri:"
-                << message.headers()->request_uri();
+    const SpdyHeaderBlock& headers,
+    const string& body) {
+  if (SendMessage(headers, body) == 0) {
+    DLOG(ERROR) << "Failed the request for: " << headers.DebugString();
     // Set the response_ explicitly.  Otherwise response_ will contain the
     // response from the previously successful request.
     response_ = "";
   } else {
     WaitForResponse();
   }
   return response_;
 }
 
 string QuicTestClient::SendSynchronousRequest(const string& uri) {
-  HTTPMessage message;
-  FillInRequest(uri, &message);
-  return SendCustomSynchronousRequest(message);
+  SpdyHeaderBlock headers;
+  if (!PopulateHeaderBlockFromUrl(uri, &headers)) {
+    return "";
+  }
+  return SendCustomSynchronousRequest(headers, "");
 }
 
 void QuicTestClient::SetStream(QuicSpdyClientStream* stream) {
   stream_ = stream;
   if (stream_ != nullptr) {
     response_complete_ = false;
     stream_->set_visitor(this);
   }
 }
 
@@ skipping 231 matching lines @@
   return client_->server_address();
 }
 
 void QuicTestClient::WaitForWriteToFlush() {
   while (connected() && client()->session()->HasDataToWrite()) {
     client_->WaitForEvents();
   }
 }
 
 void QuicTestClient::TestClientDataToResend::Resend() {
-  BalsaHeaders balsa_headers;
-  SpdyBalsaUtils::SpdyHeadersToRequestHeaders(*headers_, &balsa_headers);
-  test_client_->GetOrCreateStreamAndSendRequest(&balsa_headers, body_, fin_,
+  test_client_->GetOrCreateStreamAndSendRequest(headers_.get(), body_, fin_,
                                                 delegate_);
   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);
+bool QuicTestClient::PopulateHeaderBlockFromUrl(const string& uri,
+                                                SpdyHeaderBlock* headers) {
+  string url;
+  if (base::StartsWith(uri, "https://", base::CompareCase::INSENSITIVE_ASCII) ||
+      base::StartsWith(uri, "http://", base::CompareCase::INSENSITIVE_ASCII)) {
+    url = uri;
+  } else if (uri[0] == '/') {
+    url = "https://" + client_->server_id().host() + uri;
+  } else {
+    url = "https://" + uri;
+  }
+  return SpdyUtils::PopulateHeaderBlockFromUrl(url, headers);
 }
 
 }  // namespace test
 }  // namespace net