relnote: Create QUIC connection after it is successfully inserted to the global map. If a connectio…

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 627 matching lines @@
     DVLOG(1) << "Created new session for " << connection_id;
     session_map_.insert(std::make_pair(connection_id, session));
     DeliverPacketsToSession(packets, session);
   }
 }
 
 bool QuicDispatcher::HasChlosBuffered() const {
   return buffered_packets_.HasChlosBuffered();
 }
 
-void QuicDispatcher::OnNewConnectionAdded(QuicConnectionId connection_id) {
+bool QuicDispatcher::ShouldCreateOrBufferPacketForConnection(
+    QuicConnectionId connection_id) {
   VLOG(1) << "Received packet from new connection " << connection_id;
+  return true;
 }
 
 // Return true if there is any packet buffered in the store.
 bool QuicDispatcher::HasBufferedPackets(QuicConnectionId connection_id) {
   return buffered_packets_.HasBufferedPackets(connection_id);
 }
 
 void QuicDispatcher::OnBufferPacketFailure(EnqueuePacketResult result,
                                            QuicConnectionId connection_id) {
   DVLOG(1) << "Fail to buffer packet on connection " << connection_id
            << " because of " << result;
 }
 
 void QuicDispatcher::OnConnectionRejectedStatelessly() {}
 
 void QuicDispatcher::OnConnectionClosedStatelessly(QuicErrorCode error) {}
 
 bool QuicDispatcher::ShouldAttemptCheapStatelessRejection() {
   return true;
 }
 
 QuicTimeWaitListManager* QuicDispatcher::CreateQuicTimeWaitListManager() {
   return new QuicTimeWaitListManager(writer_.get(), this, helper_.get(),
                                      alarm_factory_.get());
 }
 
 void QuicDispatcher::BufferEarlyPacket(QuicConnectionId connection_id) {
   bool is_new_connection = !buffered_packets_.HasBufferedPackets(connection_id);
+  if (FLAGS_quic_create_session_after_insertion && is_new_connection &&
+      !ShouldCreateOrBufferPacketForConnection(connection_id)) {
+    return;
+  }
   EnqueuePacketResult rs = buffered_packets_.EnqueuePacket(
       connection_id, *current_packet_, current_server_address_,
       current_client_address_, /*is_chlo=*/false);
   if (rs != EnqueuePacketResult::SUCCESS) {
     OnBufferPacketFailure(rs, connection_id);
-  } else if (is_new_connection) {
-    OnNewConnectionAdded(connection_id);
+  } else if (FLAGS_quic_create_session_after_insertion && is_new_connection) {
+    ShouldCreateOrBufferPacketForConnection(connection_id);
   }
 }
 
 void QuicDispatcher::ProcessChlo() {
   QUIC_BUG_IF(!FLAGS_quic_buffer_packet_till_chlo &&
               FLAGS_quic_limit_num_new_sessions_per_epoll_loop)
       << "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_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 &&
       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. 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_);
+      } else if (!FLAGS_quic_create_session_after_insertion &&
+                 is_new_connection) {
+        ShouldCreateOrBufferPacketForConnection(current_connection_id_);
       }
     }
     return;
   }
-
   // Creates a new session and process all buffered packets for this connection.
   QuicServerSessionBase* session =
       CreateQuicSession(current_connection_id_, current_client_address_);
   DVLOG(1) << "Created new session for " << current_connection_id_;
   session_map_.insert(std::make_pair(current_connection_id_, session));
   std::list<BufferedPacket> packets =
       buffered_packets_.DeliverPackets(current_connection_id_);
   // Check if CHLO is the first packet arrived on this connection.
-  if (FLAGS_quic_buffer_packet_till_chlo && packets.empty()) {
-    OnNewConnectionAdded(current_connection_id_);
+  if (!FLAGS_quic_create_session_after_insertion &&
+      FLAGS_quic_buffer_packet_till_chlo && packets.empty()) {
+    ShouldCreateOrBufferPacketForConnection(current_connection_id_);
   }
   // Process CHLO at first.
   session->ProcessUdpPacket(current_server_address_, current_client_address_,
                             *current_packet_);
-
   // Deliver queued-up packets in the same order as they arrived.
   // Do this even when flag is off because there might be still some packets
   // buffered in the store before flag is turned off.
   DeliverPacketsToSession(packets, session);
   if (FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
       FLAGS_quic_buffer_packet_till_chlo) {
     --new_sessions_allowed_per_event_loop_;
   }
 }
 
@@ skipping 166 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