Deprecate FLAGS_quic_reloadable_flag_enable_async_get_proof

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/macros.h"
 #include "net/quic/core/crypto/quic_random.h"
@@ skipping 258 matching lines @@
     return false;
   }
 
   if (FLAGS_quic_reloadable_flag_quic_buffer_packets_after_chlo &&
       buffered_packets_.HasChloForConnection(connection_id)) {
     BufferEarlyPacket(connection_id);
     return false;
   }
 
   // Check if we are buffering packets for this connection ID
-  if (FLAGS_quic_reloadable_flag_enable_async_get_proof &&
-      (temporarily_buffered_connections_.find(connection_id) !=
-       temporarily_buffered_connections_.end())) {
+  if (temporarily_buffered_connections_.find(connection_id) !=
+      temporarily_buffered_connections_.end()) {
     // This packet was received while the a CHLO for the same connection ID was
     // being processed.  Buffer it.
     BufferEarlyPacket(connection_id);
     return false;
   }
 
   if (!OnUnauthenticatedUnknownPublicHeader(header)) {
     return false;
   }
 
@@ skipping 87 matching lines @@
                         << "to time-wait list.";
         time_wait_list_manager_->AddConnectionIdToTimeWait(
             connection_id, framer_.version(),
             /*connection_rejected_statelessly=*/false, nullptr);
       }
       DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
       time_wait_list_manager_->ProcessPacket(
           current_server_address_, current_client_address_, connection_id,
           packet_number, *current_packet_);
 
-      if (FLAGS_quic_reloadable_flag_enable_async_get_proof) {
-        // Any packets which were buffered while the stateless rejector logic
-        // was running should be discarded.  Do not inform the time wait list
-        // manager, which should already have a made a decision about sending a
-        // reject based on the CHLO alone.
-        buffered_packets_.DiscardPackets(connection_id);
-      }
-
+      // Any packets which were buffered while the stateless rejector logic was
+      // running should be discarded.  Do not inform the time wait list manager,
+      // which should already have a made a decision about sending a reject
+      // based on the CHLO alone.
+      buffered_packets_.DiscardPackets(connection_id);
       break;
     case kFateBuffer:
       // This packet is a non-CHLO packet which has arrived before the
       // corresponding CHLO, *or* this packet was received while the
       // corresponding CHLO was being processed.  Buffer it.
       BufferEarlyPacket(connection_id);
       break;
     case kFateDrop:
       // Do nothing with the packet.
       break;
@@ skipping 474 matching lines @@
 
   // If we were able to make a decision about this CHLO based purely on the
   // information available in OnChlo, just invoke the done callback immediately.
   if (rejector->state() != StatelessRejector::UNKNOWN) {
     ProcessStatelessRejectorState(std::move(rejector), header.packet_number,
                                   header.public_header.versions.front());
     return;
   }
 
   // Insert into set of connection IDs to buffer
-  if (FLAGS_quic_reloadable_flag_enable_async_get_proof) {
-    const bool ok =
-        temporarily_buffered_connections_.insert(connection_id).second;
-    QUIC_BUG_IF(!ok)
-        << "Processing multiple stateless rejections for connection ID "
-        << connection_id;
-  }
+  const bool ok =
+      temporarily_buffered_connections_.insert(connection_id).second;
+  QUIC_BUG_IF(!ok)
+      << "Processing multiple stateless rejections for connection ID "
+      << connection_id;
 
   // Continue stateless rejector processing
   std::unique_ptr<StatelessRejectorProcessDoneCallback> cb(
       new StatelessRejectorProcessDoneCallback(
           this, header.packet_number, header.public_header.versions.front()));
   StatelessRejector::Process(std::move(rejector), std::move(cb));
 }
 
 void QuicDispatcher::OnStatelessRejectorProcessDone(
     std::unique_ptr<StatelessRejector> rejector,
     const QuicSocketAddress& current_client_address,
     const QuicSocketAddress& current_server_address,
     std::unique_ptr<QuicReceivedPacket> current_packet,
     QuicPacketNumber packet_number,
     QuicVersion first_version) {
-  if (FLAGS_quic_reloadable_flag_enable_async_get_proof) {
-    // Stop buffering packets on this connection
-    const auto num_erased =
-        temporarily_buffered_connections_.erase(rejector->connection_id());
-    QUIC_BUG_IF(num_erased != 1) << "Completing stateless rejection logic for "
-                                    "non-buffered connection ID "
-                                 << rejector->connection_id();
+  // Stop buffering packets on this connection
+  const auto num_erased =
+      temporarily_buffered_connections_.erase(rejector->connection_id());
+  QUIC_BUG_IF(num_erased != 1) << "Completing stateless rejection logic for "
+                                  "non-buffered connection ID "
+                               << rejector->connection_id();
 
-    // If this connection has gone into time-wait during the async processing,
-    // don't proceed.
-    if (time_wait_list_manager_->IsConnectionIdInTimeWait(
-            rejector->connection_id())) {
-      time_wait_list_manager_->ProcessPacket(
-          current_server_address, current_client_address,
-          rejector->connection_id(), packet_number, *current_packet);
-      return;
-    }
+  // If this connection has gone into time-wait during the async processing,
+  // don't proceed.
+  if (time_wait_list_manager_->IsConnectionIdInTimeWait(
+          rejector->connection_id())) {
+    time_wait_list_manager_->ProcessPacket(
+        current_server_address, current_client_address,
+        rejector->connection_id(), packet_number, *current_packet);
+    return;
   }
 
   // Reset current_* to correspond to the packet which initiated the stateless
   // reject logic.
   current_client_address_ = current_client_address;
   current_server_address_ = current_server_address;
   current_packet_ = current_packet.get();
   current_connection_id_ = rejector->connection_id();
 
   ProcessStatelessRejectorState(std::move(rejector), packet_number,
@@ skipping 54 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