Allow trailing headers with duplicate keys. Protected by FLAGS_quic_reloadable_flag_quic_allow_dupl…

net/quic/core/spdy_utils.cc

 // Copyright (c) 2013 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 <vector>
 
+#include "net/quic/platform/api/quic_flag_utils.h"
+#include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_map_util.h"
 #include "net/quic/platform/api/quic_string_piece.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/quic/platform/api/quic_url_utils.h"
 #include "net/spdy/chromium/spdy_flags.h"
 #include "net/spdy/core/spdy_frame_builder.h"
 #include "net/spdy/core/spdy_framer.h"
 #include "net/spdy/core/spdy_protocol.h"
 
@@ skipping 69 matching lines @@
     return false;
   }
 
   QUIC_DVLOG(1) << "Successfully parsed headers: " << headers->DebugString();
   return true;
 }
 
 bool SpdyUtils::CopyAndValidateTrailers(const QuicHeaderList& header_list,
                                         size_t* final_byte_offset,
                                         SpdyHeaderBlock* trailers) {
+  const bool handle_duplicate_trailers =
+      FLAGS_quic_reloadable_flag_quic_handle_duplicate_trailers;
   bool found_final_byte_offset = false;
   for (const auto& p : header_list) {
     const string& name = p.first;
 
     // Pull out the final offset pseudo header which indicates the number of
     // response body bytes expected.
     if (!found_final_byte_offset && name == kFinalOffsetHeaderKey &&
         QuicTextUtils::StringToSizeT(p.second, final_byte_offset)) {
       found_final_byte_offset = true;
       continue;
     }
 
     if (name.empty() || name[0] == ':') {
       QUIC_DLOG(ERROR)
           << "Trailers must not be empty, and must not contain pseudo-"
           << "headers. Found: '" << name << "'";
       return false;
     }
 
     if (QuicTextUtils::ContainsUpperCase(name)) {
       QUIC_DLOG(ERROR) << "Malformed header: Header name " << name
                        << " contains upper-case characters.";
       return false;
     }
 
-    if (trailers->find(name) != trailers->end()) {
-      QUIC_DLOG(ERROR) << "Duplicate header '" << name
-                       << "' found in trailers.";
-      return false;
+    if (handle_duplicate_trailers) {
+      QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_handle_duplicate_trailers, 1,
+                        3);
+      trailers->AppendValueOrAddHeader(name, p.second);
+    } else {
+      QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_handle_duplicate_trailers, 2,
+                        3);
+      if (trailers->find(name) != trailers->end()) {
+        QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_handle_duplicate_trailers,
+                          3, 3);
+        QUIC_DLOG(ERROR) << "Duplicate header '" << name
+                         << "' found in trailers.";
+        return false;
+      }
+      (*trailers)[name] = p.second;
     }
-
-    (*trailers)[name] = p.second;
   }
 
   if (!found_final_byte_offset) {
     QUIC_DLOG(ERROR) << "Required key '" << kFinalOffsetHeaderKey
                      << "' not present";
     return false;
   }
 
   // TODO(rjshade): Check for other forbidden keys, following the HTTP/2 spec.
 
@@ skipping 53 matching lines @@
     (*headers)[":authority"] = url.substr(start);
     (*headers)[":path"] = "/";
     return true;
   }
   (*headers)[":authority"] = url.substr(start, pos - start);
   (*headers)[":path"] = url.substr(pos);
   return true;
 }
 
 }  // namespace net