Updates quic_client_bin.cc to be more user friendly, and support more

net/tools/quic/spdy_utils.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/spdy_utils.h"
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.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 std::make_pair;
 using std::pair;
 using std::string;
 
 namespace net {
 namespace tools {
 
+const char* const kV4Host = ":authority";
+
 const char* const kV3Host = ":host";
 const char* const kV3Path = ":path";
 const char* const kV3Scheme = ":scheme";
 const char* const kV3Status = ":status";
 const char* const kV3Method = ":method";
 const char* const kV3Version = ":version";
 
 void PopulateSpdyHeaderBlock(const BalsaHeaders& headers,
                              SpdyHeaderBlock* block,
                              bool allow_empty_values) {
@@ skipping 40 matching lines @@
 
   if (!headers.request_method().empty()) {
     block->insert(make_pair(kV3Method, headers.request_method().as_string()));
   }
 
   if (!headers.request_version().empty()) {
     (*block)[kV3Version] = headers.request_version().as_string();
   }
 }
 
+void PopulateSpdy4RequestHeaderBlock(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.as_string()));
+    // PopulateSpdyHeaderBlock already added the "host" header,
+    // which is invalid for SPDY4.
+    block->erase("host");
+  } else {
+    block->insert(make_pair(kV4Host, host_and_port));

[ramant (doing other things), 2015/01/13 01:35:47]

rjshade: Is this right? Are we sending SPDY4 headers correctly?

[rjshade, 2015/01/13 15:22:36]

See my other comment reply, but we aren't actually *sending* anything that is
returned from this function. It's just being used to transform BalsaHeaders into
something that can be easily iterated over and printed to std::cout.

+  }
+  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().as_string()));
+  }
+}
+
 void PopulateSpdyResponseHeaderBlock(const BalsaHeaders& headers,
                                      SpdyHeaderBlock* block) {
   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().as_string();
 
   // Empty header values are only allowed because this is spdy3.
@@ skipping 31 matching lines @@
   SpdyHeaderBlock block;
   PopulateSpdy3RequestHeaderBlock(
       request_headers, scheme, host_and_port, path, &block);
   if (block.find("host") != block.end()) {
     block.erase(block.find("host"));
   }
   return block;
 }
 
 // static
+SpdyHeaderBlock SpdyUtils::RequestHeadersToSpdy4Headers(
+    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 {
+    GURL request_uri(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();
+    }
+  }
+
+  DCHECK(!scheme.empty());
+  DCHECK(!host_and_port.empty());
+  DCHECK(!path.empty());
+
+  SpdyHeaderBlock block;
+  PopulateSpdy4RequestHeaderBlock(request_headers, scheme, host_and_port, path,
+                                  &block);
+  if (block.find("host") != block.end()) {
+    block.erase(block.find("host"));
+  }
+  return block;
+}
+
+// static
 string SpdyUtils::SerializeRequestHeaders(const BalsaHeaders& request_headers) {
   SpdyHeaderBlock block = RequestHeadersToSpdyHeaders(request_headers);
   return SerializeUncompressedHeaders(block);
 }
 
 // static
 SpdyHeaderBlock SpdyUtils::ResponseHeadersToSpdyHeaders(
     const BalsaHeaders& response_headers) {
   SpdyHeaderBlock block;
   PopulateSpdyResponseHeaderBlock(response_headers, &block);
@@ skipping 110 matching lines @@
   for (BlockIt it = header_block.begin(); it != header_block.end(); ++it) {
    if (!IsSpecialSpdyHeader(it, request_headers)) {
      request_headers->AppendHeader(it->first, it->second);
    }
   }
   return true;
 }
 
 }  // namespace tools
 }  // namespace net