Landing Recent QUIC changes until Sun May 8 00:39:29 2016 +0000

net/tools/quic/spdy_balsa_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_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/quic_flags.h"
 #include "net/quic/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"
 
@@ skipping 89 matching lines @@
     (*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() ||
+  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;
@@ skipping 14 matching lines @@
   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)) {
-      request_headers->AppendHeader(it->first, it->second);
+      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);
@@ skipping 24 matching lines @@
     request_headers->AppendHeader("Scheme", scheme_it->second);
   }
   if (authority_it != end_it) {
     request_headers->AppendHeader("host", authority_it->second);
   } else if (host_it != end_it) {
     request_headers->AppendHeader("host", host_it->second);
   }
 
   for (BlockIt it = header_block.begin(); it != header_block.end(); ++it) {
     if (!IsSpecialSpdyHeader(it, request_headers)) {
-      request_headers->AppendHeader(it->first, it->second);
+      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);
@@ skipping 60 matching lines @@
   SpdyHeadersToBalsaHeaders(block, headers, true);
 }
 
 // static
 void SpdyBalsaUtils::SpdyHeadersToRequestHeaders(const SpdyHeaderBlock& block,
                                                  BalsaHeaders* headers) {
   SpdyHeadersToBalsaHeaders(block, headers, false);
 }
 
 }  // namespace net