short circuit QUIC packets to packet buffer if there is already a CHLO on same connection buffered …

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 255 matching lines @@
   // immediately.
   QuicConnectionId connection_id = header.connection_id;
   SessionMap::iterator it = session_map_.find(connection_id);
   if (it != session_map_.end()) {
     DCHECK(!buffered_packets_.HasBufferedPackets(connection_id));
     it->second->ProcessUdpPacket(current_server_address_,
                                  current_client_address_, *current_packet_);
     return false;
   }
 
+  if (FLAGS_quic_buffer_packets_after_chlo &&
+      buffered_packets_.HasChloForConnection(connection_id)) {
+    BufferEarlyPacket(connection_id);
+    return false;
+  }
+
   if (!OnUnauthenticatedUnknownPublicHeader(header)) {
     return false;
   }
 
   // If the packet is a public reset for a connection ID that is not active,
   // there is nothing we must do or can do.
   if (header.reset_flag) {
     return false;
   }
 
@@ skipping 399 matching lines @@
       << "Try to limit connection creation per epoll event while not "
          "supporting packet buffer. "
          "--quic_limit_num_new_sessions_per_epoll_loop = true "
          "--quic_buffer_packet_till_chlo = false";
 
   if (FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
       FLAGS_quic_buffer_packet_till_chlo &&
       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.
+      // 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(
           current_connection_id_, *current_packet_, current_server_address_,
           current_client_address_, /*is_chlo=*/true);
       if (rs != EnqueuePacketResult::SUCCESS) {
         OnBufferPacketFailure(rs, current_connection_id_);
       } else if (is_new_connection) {
         OnNewConnectionAdded(current_connection_id_);
       }
@@ skipping 200 matching lines @@
 void QuicDispatcher::DeliverPacketsToSession(
     const std::list<BufferedPacket>& packets,
     QuicServerSessionBase* session) {
   for (const BufferedPacket& packet : packets) {
     session->ProcessUdpPacket(packet.server_address, packet.client_address,
                               *(packet.packet));
   }
 }
 
 }  // namespace net