Remove now unused Balsa code.

net/tools/quic/spdy_balsa_utils.cc

Index: net/tools/quic/spdy_balsa_utils.cc
diff --git a/net/tools/quic/spdy_balsa_utils.cc b/net/tools/quic/spdy_balsa_utils.cc
deleted file mode 100644
index b84e96fb0870cea2aab610ea0424e5adaf1fd783..0000000000000000000000000000000000000000
--- a/net/tools/quic/spdy_balsa_utils.cc
+++ /dev/null
@@ -1,318 +0,0 @@
-// 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/spdy_balsa_utils.h"
-
-#include <memory>
-#include <string>
-
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_split.h"
-#include "base/strings/string_util.h"
-#include "net/base/linked_hash_map.h"
-#include "net/quic/core/quic_flags.h"
-#include "net/quic/core/spdy_utils.h"
-#include "net/spdy/spdy_frame_builder.h"
-#include "net/spdy/spdy_framer.h"
-#include "net/spdy/spdy_protocol.h"
-#include "net/tools/balsa/balsa_headers.h"
-#include "url/gurl.h"
-
-using base::StringPiece;
-using base::StringPieceHash;
-using std::make_pair;
-using std::pair;
-using std::string;
-
-namespace net {
-namespace {
-
-const char kV4Host[] = ":authority";
-
-const char kV3Host[] = ":host";
-const char kV3Path[] = ":path";
-const char kV3Scheme[] = ":scheme";
-const char kV3Method[] = ":method";
-const char kV3Status[] = ":status";
-const char kV3Version[] = ":version";
-
-void PopulateSpdyHeaderBlock(const BalsaHeaders& headers,
-                             SpdyHeaderBlock* block,
-                             bool allow_empty_values) {
-  using HeaderValuesMap =
-      linked_hash_map<StringPiece, std::vector<StringPiece>, StringPieceHash>;
-  std::deque<string> names;
-  HeaderValuesMap header_values_map;
-  // First, gather references to all values for each name.
-  for (BalsaHeaders::const_header_lines_iterator hi =
-           headers.header_lines_begin();
-       hi != headers.header_lines_end(); ++hi) {
-    if ((hi->second.length() == 0) && !allow_empty_values) {
-      DVLOG(1) << "Dropping empty header " << hi->first.as_string()
-               << " from headers";
-      continue;
-    }
-    const string name = base::ToLowerASCII(hi->first.as_string());
-    names.push_back(name);
-    header_values_map[name].push_back(hi->second);
-  }
-  // Then, write joined representations to the header block.
-  for (const auto& header : header_values_map) {
-    if (header.second.size() == 1) {
-      // Avoid string allocation for the single value case.
-      (*block)[header.first] = header.second[0];
-    } else {
-      StringPiece separator("\0", 1);
-      auto it = header.second.begin();
-      string value = it->as_string();
-      ++it;
-      for (; it != header.second.end(); ++it) {
-        separator.AppendToString(&value);
-        value.append(it->data(), it->size());
-      }
-      (*block)[header.first] = value;
-    }
-  }
-}
-
-void PopulateHttp2RequestHeaderBlock(const BalsaHeaders& headers,
-                                     const string& scheme,
-                                     const string& host_and_port,
-                                     const string& path,
-                                     SpdyHeaderBlock* block) {
-  PopulateSpdyHeaderBlock(headers, block, true);
-  StringPiece host_header = headers.GetHeader("Host");
-  if (!host_header.empty()) {
-    DCHECK(host_and_port.empty() || host_header == host_and_port);
-    block->insert(make_pair(kV4Host, host_header));
-    // PopulateSpdyHeaderBlock already added the "host" header,
-    // which is invalid for HTTP2.
-    block->erase("host");
-  } else {
-    block->insert(make_pair(kV4Host, host_and_port));
-  }
-  block->insert(make_pair(kV3Path, path));
-  block->insert(make_pair(kV3Scheme, scheme));
-
-  if (!headers.request_method().empty()) {
-    block->insert(make_pair(kV3Method, headers.request_method()));
-  }
-}
-
-void PopulateSpdyResponseHeaderBlock(SpdyMajorVersion version,
-                                     const BalsaHeaders& headers,
-                                     SpdyHeaderBlock* block) {
-  if (version <= SPDY3) {
-    string status = headers.response_code().as_string();
-    status.append(" ");
-    status.append(headers.response_reason_phrase().as_string());
-    (*block)[kV3Status] = status;
-    (*block)[kV3Version] = headers.response_version();
-  } else {
-    (*block)[kV3Status] = headers.response_code();
-  }
-
-  PopulateSpdyHeaderBlock(headers, block, true);
-}
-
-bool IsSpecialSpdyHeader(SpdyHeaderBlock::const_iterator header,
-                         BalsaHeaders* headers) {
-  return header->first.empty() || /* header->second.empty() || */
-         header->first[0] == ':';
-}
-
-// The reason phrase should match regexp [\d\d\d [^\r\n]+].  If not, we will
-// fail to parse it.
-bool ParseReasonAndStatus(StringPiece status_and_reason,
-                          BalsaHeaders* headers) {
-  int status;
-  if (!base::StringToInt(status_and_reason, &status)) {
-    return false;
-  }
-  headers->SetResponseCode(status_and_reason);
-  headers->SetResponseCode(status_and_reason);
-  headers->set_parsed_response_code(status);
-  return true;
-}
-
-// static
-void SpdyHeadersToResponseHeaders(const SpdyHeaderBlock& header_block,
-                                  BalsaHeaders* request_headers) {
-  typedef SpdyHeaderBlock::const_iterator BlockIt;
-
-  BlockIt status_it = header_block.find(kV3Status);
-  BlockIt end_it = header_block.end();
-  if (status_it == end_it) {
-    return;
-  }
-
-  if (!ParseReasonAndStatus(status_it->second, request_headers)) {
-    return;
-  }
-
-  for (BlockIt it = header_block.begin(); it != header_block.end(); ++it) {
-    if (!IsSpecialSpdyHeader(it, request_headers)) {
-      if (it->second.empty()) {
-        request_headers->AppendHeader(it->first, it->second);
-      } else {
-        DVLOG(2) << "Splitting value: [" << it->second << "]"
-                 << " for key: " << it->first;
-        for (string value :
-             base::SplitString(it->second, base::StringPiece("\0", 1),
-                               base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-          DVLOG(2) << "AppendHeader(" << it->first << ", " << value << ")";
-          request_headers->AppendHeader(it->first, StringPiece(value));
-        }
-      }
-    }
-  }
-}
-
-// static
-void SpdyHeadersToRequestHeaders(const SpdyHeaderBlock& header_block,
-                                 BalsaHeaders* request_headers) {
-  typedef SpdyHeaderBlock::const_iterator BlockIt;
-
-  BlockIt authority_it = header_block.find(kV4Host);
-  BlockIt host_it = header_block.find(kV3Host);
-  BlockIt method_it = header_block.find(kV3Method);
-  BlockIt path_it = header_block.find(kV3Path);
-  BlockIt scheme_it = header_block.find(kV3Scheme);
-  BlockIt end_it = header_block.end();
-
-  string method;
-  if (method_it == end_it) {
-    method = "GET";
-  } else {
-    method = method_it->second.as_string();
-  }
-  string uri;
-  if (scheme_it == end_it) {
-    uri += "https";
-  } else {
-    uri += scheme_it->second.as_string();
-  }
-  uri += "://";
-
-  if (authority_it != end_it) {
-    uri += authority_it->second.as_string();
-    request_headers->AppendHeader("host", authority_it->second);
-  } else if (host_it != end_it) {
-    uri += host_it->second.as_string();
-    request_headers->AppendHeader("host", host_it->second);
-  }
-
-  if (path_it == end_it) {
-    uri += "/";
-  } else {
-    uri += path_it->second.as_string();
-  }
-  request_headers->SetRequestFirstlineFromStringPieces(
-      method, uri, net::kHttp2VersionString);
-
-  for (BlockIt it = header_block.begin(); it != header_block.end(); ++it) {
-    if (!IsSpecialSpdyHeader(it, request_headers)) {
-      if (it->second.empty()) {
-        request_headers->AppendHeader(it->first, it->second);
-      } else {
-        DVLOG(2) << "Splitting value: [" << it->second << "]"
-                 << " for key: " << it->first;
-        for (string value :
-             base::SplitString(it->second, base::StringPiece("\0", 1),
-                               base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-          DVLOG(2) << "AppendHeader(" << it->first << ", " << value << ")";
-          request_headers->AppendHeader(it->first, StringPiece(value));
-        }
-      }
-    }
-  }
-}
-
-// static
-void SpdyHeadersToBalsaHeaders(const SpdyHeaderBlock& block,
-                               BalsaHeaders* headers,
-                               bool isResponse) {
-  if (isResponse) {
-    SpdyHeadersToResponseHeaders(block, headers);
-    return;
-  }
-  SpdyHeadersToRequestHeaders(block, headers);
-}
-
-}  // namespace
-
-// static
-SpdyHeaderBlock SpdyBalsaUtils::RequestHeadersToSpdyHeaders(
-    const BalsaHeaders& request_headers) {
-  string scheme;
-  string host_and_port;
-  string path;
-
-  string url = request_headers.request_uri().as_string();
-  if (url.empty() || url[0] == '/') {
-    path = url;
-  } else {
-    std::unique_ptr<GURL> request_uri(new GURL(url));
-    if (request_headers.request_method() == "CONNECT") {
-      path = url;
-    } else {
-      path = request_uri->path();
-      if (!request_uri->query().empty()) {
-        path = path + "?" + request_uri->query();
-      }
-      host_and_port = request_uri->host();
-      scheme = request_uri->scheme();
-    }
-  }
-
-  if (scheme.empty()) {
-    if (request_headers.HasHeader("Scheme")) {
-      request_headers.GetAllOfHeaderAsString("Scheme", &scheme);
-    } else {
-      // Requests must contain a :scheme header, and unless another scheme is
-      // detected, https is assumed.
-      scheme = "https";
-    }
-  }
-
-  SpdyHeaderBlock block;
-  PopulateHttp2RequestHeaderBlock(request_headers, scheme, host_and_port, path,
-                                  &block);
-
-  // If a "Scheme" header existed in request_headers, it would have been
-  // propagated to |block|.
-  block.erase("scheme");
-  return block;
-}
-
-// static
-SpdyHeaderBlock SpdyBalsaUtils::ResponseHeadersToSpdyHeaders(
-    const BalsaHeaders& response_headers) {
-  SpdyHeaderBlock block;
-  PopulateSpdyResponseHeaderBlock(HTTP2, response_headers, &block);
-  return block;
-}
-
-// static
-string SpdyBalsaUtils::SerializeResponseHeaders(
-    const BalsaHeaders& response_headers) {
-  SpdyHeaderBlock block = ResponseHeadersToSpdyHeaders(response_headers);
-
-  return net::SpdyUtils::SerializeUncompressedHeaders(block);
-}
-
-// static
-void SpdyBalsaUtils::SpdyHeadersToResponseHeaders(const SpdyHeaderBlock& block,
-                                                  BalsaHeaders* headers) {
-  SpdyHeadersToBalsaHeaders(block, headers, true);
-}
-
-// static
-void SpdyBalsaUtils::SpdyHeadersToRequestHeaders(const SpdyHeaderBlock& block,
-                                                 BalsaHeaders* headers) {
-  SpdyHeadersToBalsaHeaders(block, headers, false);
-}
-
-}  // namespace net