Add a --quic_allow_chlo_buffering flag. Default value is true, no behavior change.

net/tools/quic/quic_dispatcher.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/quic_dispatcher.h"
 
 #include <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 701 matching lines @@
     ShouldCreateOrBufferPacketForConnection(connection_id);
   }
 }
 
 void QuicDispatcher::ProcessChlo() {
   if (FLAGS_quic_create_session_after_insertion &&
       !buffered_packets_.HasBufferedPackets(current_connection_id_) &&
       !ShouldCreateOrBufferPacketForConnection(current_connection_id_)) {
     return;
   }
-
-  if (FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
+  if (FLAGS_quic_allow_chlo_buffering &&
+      FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
       new_sessions_allowed_per_event_loop_ <= 0) {
     // Can't create new session any more. Wait till next event loop.
     if (!buffered_packets_.HasChloForConnection(current_connection_id_)) {
       // Only buffer one CHLO per connection. Remove this condition check when
       // --gfe2_reloadable_flag_quic_buffer_packets_after_chlo
       // is deprecated because after that retransmitted CHLO should be buffered
       // earlier in OnUnauthenticatedPublicHeader().
       bool is_new_connection =
           !buffered_packets_.HasBufferedPackets(current_connection_id_);
       EnqueuePacketResult rs = buffered_packets_.EnqueuePacket(
@@ skipping 87 matching lines @@
   IPEndPoint current_client_address_;
   IPEndPoint current_server_address_;
   std::unique_ptr<QuicReceivedPacket> current_packet_;
   QuicPacketNumber packet_number_;
   QuicVersion first_version_;
 };
 
 void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
                                             const QuicPacketHeader& header) {
   // TODO(rch): This logic should probably live completely inside the rejector.
-  if (!FLAGS_quic_use_cheap_stateless_rejects ||
+  if (!FLAGS_quic_allow_chlo_buffering ||
+      !FLAGS_quic_use_cheap_stateless_rejects ||
       !FLAGS_enable_quic_stateless_reject_support ||
       !ShouldAttemptCheapStatelessRejection()) {
     // Not use cheap stateless reject.
-    if (!ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
+    if (FLAGS_quic_allow_chlo_buffering &&
+        !ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
                                 nullptr)) {
       // Buffer non-CHLO packets.
       ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id,
                                        header.packet_number);
       return;
     }
     ProcessUnauthenticatedHeaderFate(kFateProcess, connection_id,
                                      header.packet_number);
     return;
   }
@@ skipping 139 matching lines @@
 void QuicDispatcher::DeliverPacketsToSession(
     const std::list<BufferedPacket>& packets,
     QuicSession* session) {
   for (const BufferedPacket& packet : packets) {
     session->ProcessUdpPacket(packet.server_address, packet.client_address,
                               *(packet.packet));
   }
 }
 
 }  // namespace net