QuicServer: Use Chrome's header parsing rather than Balsa

net/spdy/spdy_http_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/spdy/spdy_http_utils.h"
 
 #include <string>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
-#include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 
 namespace net {
 
+namespace {
+
+void AddSpdyHeader(SpdyHeaderBlock* headers,

[wtc, 2014/06/25 22:22:25]

Nit: |headers| is an output parameter, so it should be listed after the inputs.

[dmziegler, 2014/06/26 01:23:30]

It's really an in-out parameter that is modified -- should that actually be
listed at the end?

[wtc, 2014/06/26 21:23:16]

Yes, I would list an in-out parameter after pure-input parameters.

+                   const std::string& name,
+                   const std::string& value) {
+  if (headers->find(name) == headers->end()) {
+    (*headers)[name] = value;
+  } else {
+    (*headers)[name] += '\0' + value;

[wtc, 2014/06/25 22:22:25]

IMPORTANT: Is the use of '\0' correct? Are you using this form of operator+?

  string operator+ (char c, const string& str)

[dmziegler, 2014/06/26 01:23:29]

Yes. I intentionally used '\0' and not "\0".

+  }
+}
+
+} // namespace
+
 bool SpdyHeadersToHttpResponse(const SpdyHeaderBlock& headers,
                                SpdyMajorVersion protocol_version,
                                HttpResponseInfo* response) {
   std::string status_key = (protocol_version >= SPDY3) ? ":status" : "status";
   std::string version_key =
       (protocol_version >= SPDY3) ? ":version" : "version";
   std::string version;
   std::string status;
 
   // The "status" header is required. "version" is required below SPDY4.
@@ skipping 43 matching lines @@
       raw_headers.push_back('\0');
       start = end + 1;
     } while (end != value.npos);
   }
 
   response->headers = new HttpResponseHeaders(raw_headers);
   response->was_fetched_via_spdy = true;
   return true;
 }
 
+void CreateSpdyHeadersFromHttpResponse(
+    scoped_refptr<HttpResponseHeaders> response_headers,
+    SpdyMajorVersion protocol_version,
+    SpdyHeaderBlock* headers) {
+  std::string status_key = (protocol_version >= SPDY3) ? ":status" : "status";
+  std::string version_key =
+      (protocol_version >= SPDY3) ? ":version" : "version";
+
+  std::string status_line = response_headers->GetStatusLine();
+  std::string::iterator after_version =

[wtc, 2014/06/25 22:22:25]

Use a const_iterator.

[dmziegler, 2014/06/26 01:23:30]

Done.

+      std::find(status_line.begin(), status_line.end(), ' ');
+  if (protocol_version < SPDY4) {

[wtc, 2014/06/25 23:17:32]

The internal version tests version <= SPDY3. I think these two tests are
equivalent because there is no major version between SPDY3 and SPDY4.

[dmziegler, 2014/06/26 01:23:30]

Okay. I am simply inverting SpdyHeadersToHttpResponse:
if (protocol_version >= SPDY4) {
  version = "HTTP/1.1";
} else {
  it = headers.find(version_key);
  if (it == headers.end())
    return false;
  version = it->second;
}

+    (*headers)[version_key] = std::string(status_line.begin(), after_version);
+  }
+  (*headers)[status_key] = std::string(after_version + 1, status_line.end());
+
+  void* iter = NULL;
+  std::string raw_name, value;
+  while (response_headers->EnumerateHeaderLines(&iter, &raw_name, &value)) {
+    std::string name = StringToLowerASCII(raw_name);
+    AddSpdyHeader(headers, name, value);
+  }
+}
+
 void CreateSpdyHeadersFromHttpRequest(const HttpRequestInfo& info,
                                       const HttpRequestHeaders& request_headers,
-                                      SpdyHeaderBlock* headers,
                                       SpdyMajorVersion protocol_version,
-                                      bool direct) {
+                                      bool direct,
+                                      SpdyHeaderBlock* headers) {
 
   HttpRequestHeaders::Iterator it(request_headers);
   while (it.GetNext()) {
     std::string name = StringToLowerASCII(it.name());
     if (name == "connection" || name == "proxy-connection" ||
         name == "transfer-encoding" || name == "host") {
       continue;
     }
-    if (headers->find(name) == headers->end()) {
-      (*headers)[name] = it.value();
-    } else {
-      std::string new_value = (*headers)[name];
-      new_value.append(1, '\0');  // +=() doesn't append 0's
-      new_value += it.value();
-      (*headers)[name] = new_value;
-    }
+    AddSpdyHeader(headers, name, it.value());
   }
   static const char kHttpProtocolVersion[] = "HTTP/1.1";
 
   if (protocol_version < SPDY3) {
     (*headers)["version"] = kHttpProtocolVersion;
     (*headers)["method"] = info.method;
     (*headers)["host"] = GetHostAndOptionalPort(info.url);
     (*headers)["scheme"] = info.url.scheme();
     if (direct)
       (*headers)["url"] = HttpUtil::PathForRequest(info.url);
@@ skipping 76 matching lines @@
   if (it != headers.end())
     path = it->second;
 
   std::string url = (scheme.empty() || host_port.empty() || path.empty())
                         ? std::string()
                         : scheme + "://" + host_port + path;
   return GURL(url);
 }
 
 }  // namespace net