Allow trailing headers with duplicate keys. Protected by FLAGS_quic_reloadable_flag_quic_allow_dupl…

net/quic/core/spdy_utils_test.cc

 // Copyright 2016 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/quic/core/spdy_utils.h"
 
 #include <memory>
 
 #include "base/macros.h"
+#include "net/quic/platform/api/quic_flag_utils.h"
+#include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/test/gtest_util.h"
 
 using std::string;
 using testing::UnorderedElementsAre;
 using testing::Pair;
 
 namespace net {
 namespace test {
@@ skipping 220 matching lines @@
   // Pseudo headers are illegal in trailers.
   auto trailers =
       FromList({{":pseudo_key", "value"}, {kFinalOffsetHeaderKey, "1234"}});
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
   EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
                                                   &block));
 }
 
 TEST(CopyAndValidateTrailers, DuplicateTrailers) {
-  // Duplicate trailers are not allowed.
+  // Duplicate trailers are allowed, and their values are concatenated into a
+  // single string delimted with '\0'. Some of the duplicate headers
+  // deliberately have an empty value.
+  FLAGS_quic_reloadable_flag_quic_handle_duplicate_trailers = true;
   auto trailers = FromList({{"key", "value0"},
                             {"key", "value1"},
                             {"key", ""},
                             {"key", ""},
                             {"key", "value2"},
                             {"key", ""},
                             {kFinalOffsetHeaderKey, "1234"},
                             {"other_key", "value"},
                             {"key", "non_contiguous_duplicate"}});
   size_t final_byte_offset = 0;
   SpdyHeaderBlock block;
-  EXPECT_FALSE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
-                                                  &block));
+  EXPECT_TRUE(SpdyUtils::CopyAndValidateTrailers(*trailers, &final_byte_offset,
+                                                 &block));
+  EXPECT_THAT(
+      block,
+      UnorderedElementsAre(
+          Pair("key",
+               QuicStringPiece(
+                   "value0\0value1\0\0\0value2\0\0non_contiguous_duplicate",
+                   48)),
+          Pair("other_key", "value")));
+}
+
+TEST(CopyAndValidateTrailers, DuplicateCookies) {
+  // Duplicate cookie headers in trailers should be concatenated into a single
+  //  "; " delimted string.
+  FLAGS_quic_reloadable_flag_quic_handle_duplicate_trailers = true;
+  auto headers = FromList({{"cookie", " part 1"},
+                           {"cookie", "part 2 "},
+                           {"cookie", "part3"},
+                           {"key", "value"},
+                           {kFinalOffsetHeaderKey, "1234"},
+                           {"cookie", " non_contiguous_cookie!"}});
+
+  size_t final_byte_offset = 0;
+  SpdyHeaderBlock block;
+  EXPECT_TRUE(
+      SpdyUtils::CopyAndValidateTrailers(*headers, &final_byte_offset, &block));
+  EXPECT_THAT(
+      block,
+      UnorderedElementsAre(
+          Pair("cookie", " part 1; part 2 ; part3;  non_contiguous_cookie!"),
+          Pair("key", "value")));
 }
 
 TEST(GetUrlFromHeaderBlock, Basic) {
   SpdyHeaderBlock headers;
   EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers), "");
   headers[":scheme"] = "https";
   EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers), "");
   headers[":authority"] = "www.google.com";
   EXPECT_EQ(SpdyUtils::GetUrlFromHeaderBlock(headers), "");
   headers[":path"] = "/index.html";
@@ skipping 46 matching lines @@
 TEST(PopulateHeaderBlockFromUrl, Failure) {
   SpdyHeaderBlock headers;
   EXPECT_FALSE(SpdyUtils::PopulateHeaderBlockFromUrl("/", &headers));
   EXPECT_FALSE(SpdyUtils::PopulateHeaderBlockFromUrl("/index.html", &headers));
   EXPECT_FALSE(
       SpdyUtils::PopulateHeaderBlockFromUrl("www.google.com/", &headers));
 }
 
 }  // namespace test
 }  // namespace net