Remove unused packet parameter from QuicTimeWaitListManager::ProcessPacket.

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 318 matching lines @@
   framer_.set_version(version);
   return true;
 }
 
 bool QuicDispatcher::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
   QuicConnectionId connection_id = header.public_header.connection_id;
 
   if (time_wait_list_manager_->IsConnectionIdInTimeWait(
           header.public_header.connection_id)) {
     // This connection ID is already in time-wait state.
-    time_wait_list_manager_->ProcessPacket(
-        current_server_address_, current_client_address_,
-        header.public_header.connection_id, *current_packet_);
+    time_wait_list_manager_->ProcessPacket(current_server_address_,
+                                           current_client_address_,
+                                           header.public_header.connection_id);
     return false;
   }
 
   // Packet's connection ID is unknown.  Apply the validity checks.
   QuicPacketFate fate = ValidityChecks(header);
   if (fate == kFateProcess) {
     // Execute stateless rejection logic to determine the packet fate, then
     // invoke ProcessUnauthenticatedHeaderFate.
     MaybeRejectStatelessly(connection_id,
                            header.public_header.versions.front());
@@ skipping 21 matching lines @@
           !time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
         // Add this connection_id to the time-wait state, to safely reject
         // future packets.
         QUIC_DLOG(INFO) << "Adding connection ID " << connection_id
                         << "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, *current_packet_);
+      time_wait_list_manager_->ProcessPacket(
+          current_server_address_, current_client_address_, 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
@@ skipping 321 matching lines @@
 }
 
 void QuicDispatcher::ProcessChlo() {
   if (!accept_new_connections_) {
     // Don't any create new connection.
     time_wait_list_manager()->AddConnectionIdToTimeWait(
         current_connection_id(), framer()->version(),
         /*connection_rejected_statelessly=*/false,
         /*termination_packets=*/nullptr);
     // This will trigger sending Public Reset packet.
-    time_wait_list_manager()->ProcessPacket(
-        current_server_address(), current_client_address(),
-        current_connection_id(), current_packet());
+    time_wait_list_manager()->ProcessPacket(current_server_address(),
+                                            current_client_address(),
+                                            current_connection_id());
     return;
   }
   if (FLAGS_quic_reloadable_flag_quic_create_session_after_insertion &&
       !buffered_packets_.HasBufferedPackets(current_connection_id_) &&
       !ShouldCreateOrBufferPacketForConnection(current_connection_id_)) {
     QUIC_FLAG_COUNT_N(quic_reloadable_flag_quic_create_session_after_insertion,
                       2, 5);
     return;
   }
   if (FLAGS_quic_allow_chlo_buffering &&
@@ skipping 169 matching lines @@
   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(), *current_packet);
+    time_wait_list_manager_->ProcessPacket(current_server_address,
+                                           current_client_address,
+                                           rejector->connection_id());
     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();
 
@@ skipping 53 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