Remove unused packet_number parameter from multiple functions in QUIC.

net/tools/quic/quic_dispatcher.cc

Index: net/tools/quic/quic_dispatcher.cc
diff --git a/net/tools/quic/quic_dispatcher.cc b/net/tools/quic/quic_dispatcher.cc
index 6721c0729d1f42cb13764cf73cc737cc02d6b6d8..edd34d81c03fe9d561763cbeaa80c09c3de1f9a6 100644
--- a/net/tools/quic/quic_dispatcher.cc
+++ b/net/tools/quic/quic_dispatcher.cc
@@ -338,8 +338,7 @@ bool QuicDispatcher::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
     // 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, header.packet_number,
-        *current_packet_);
+        header.public_header.connection_id, *current_packet_);
     return false;
   }
 
@@ -348,11 +347,12 @@ bool QuicDispatcher::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
   if (fate == kFateProcess) {
     // Execute stateless rejection logic to determine the packet fate, then
     // invoke ProcessUnauthenticatedHeaderFate.
-    MaybeRejectStatelessly(connection_id, header);
+    MaybeRejectStatelessly(connection_id,
+                           header.public_header.versions.front());
   } else {
     // If the fate is already known, process it without executing stateless
     // rejection logic.
-    ProcessUnauthenticatedHeaderFate(fate, connection_id, header.packet_number);
+    ProcessUnauthenticatedHeaderFate(fate, connection_id);
   }
 
   return false;
@@ -360,11 +360,10 @@ bool QuicDispatcher::OnUnauthenticatedHeader(const QuicPacketHeader& header) {
 
 void QuicDispatcher::ProcessUnauthenticatedHeaderFate(
     QuicPacketFate fate,
-    QuicConnectionId connection_id,
-    QuicPacketNumber packet_number) {
+    QuicConnectionId connection_id) {
   switch (fate) {
     case kFateProcess: {
-      ProcessChlo(packet_number);
+      ProcessChlo();
       break;
     }
     case kFateTimeWait:
@@ -381,9 +380,9 @@ void QuicDispatcher::ProcessUnauthenticatedHeaderFate(
             /*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_);
+      time_wait_list_manager_->ProcessPacket(current_server_address_,
+                                             current_client_address_,
+                                             connection_id, *current_packet_);
 
       // Any packets which were buffered while the stateless rejector logic was
       // running should be discarded.  Do not inform the time wait list manager,
@@ -717,7 +716,7 @@ void QuicDispatcher::BufferEarlyPacket(QuicConnectionId connection_id) {
   }
 }
 
-void QuicDispatcher::ProcessChlo(QuicPacketNumber packet_number) {
+void QuicDispatcher::ProcessChlo() {
   if (!accept_new_connections_) {
     // Don't any create new connection.
     time_wait_list_manager()->AddConnectionIdToTimeWait(
@@ -727,7 +726,7 @@ void QuicDispatcher::ProcessChlo(QuicPacketNumber packet_number) {
     // This will trigger sending Public Reset packet.
     time_wait_list_manager()->ProcessPacket(
         current_server_address(), current_client_address(),
-        current_connection_id(), packet_number, current_packet());
+        current_connection_id(), current_packet());
     return;
   }
   if (FLAGS_quic_reloadable_flag_quic_create_session_after_insertion &&
@@ -815,20 +814,18 @@ class StatelessRejectorProcessDoneCallback
     : public StatelessRejector::ProcessDoneCallback {
  public:
   StatelessRejectorProcessDoneCallback(QuicDispatcher* dispatcher,
-                                       QuicPacketNumber packet_number,
                                        QuicVersion first_version)
       : dispatcher_(dispatcher),
         current_client_address_(dispatcher->current_client_address_),
         current_server_address_(dispatcher->current_server_address_),
         current_packet_(
             dispatcher->current_packet_->Clone()),  // Note: copies the packet
-        packet_number_(packet_number),
         first_version_(first_version) {}
 
   void Run(std::unique_ptr<StatelessRejector> rejector) override {
     dispatcher_->OnStatelessRejectorProcessDone(
         std::move(rejector), current_client_address_, current_server_address_,
-        std::move(current_packet_), packet_number_, first_version_);
+        std::move(current_packet_), first_version_);
   }
 
  private:
@@ -836,12 +833,11 @@ class StatelessRejectorProcessDoneCallback
   QuicSocketAddress current_client_address_;
   QuicSocketAddress current_server_address_;
   std::unique_ptr<QuicReceivedPacket> current_packet_;
-  QuicPacketNumber packet_number_;
   QuicVersion first_version_;
 };
 
 void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
-                                            const QuicPacketHeader& header) {
+                                            QuicVersion version) {
   // TODO(rch): This logic should probably live completely inside the rejector.
   if (!FLAGS_quic_allow_chlo_buffering ||
       !FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects ||
@@ -852,26 +848,23 @@ void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
         !ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
                                 nullptr)) {
       // Buffer non-CHLO packets.
-      ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id,
-                                       header.packet_number);
+      ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id);
       return;
     }
-    ProcessUnauthenticatedHeaderFate(kFateProcess, connection_id,
-                                     header.packet_number);
+    ProcessUnauthenticatedHeaderFate(kFateProcess, connection_id);
     return;
   }
 
   std::unique_ptr<StatelessRejector> rejector(new StatelessRejector(
-      header.public_header.versions.front(), GetSupportedVersions(),
-      crypto_config_, &compressed_certs_cache_, helper()->GetClock(),
-      helper()->GetRandomGenerator(), current_packet_->length(),
-      current_client_address_, current_server_address_));
+      version, GetSupportedVersions(), crypto_config_, &compressed_certs_cache_,
+      helper()->GetClock(), helper()->GetRandomGenerator(),
+      current_packet_->length(), current_client_address_,
+      current_server_address_));
   ChloValidator validator(session_helper_.get(), current_server_address_,
                           rejector.get());
   if (!ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
                               &validator)) {
-    ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id,
-                                     header.packet_number);
+    ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id);
     return;
   }
 
@@ -882,16 +875,14 @@ void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
     terminator.CloseConnection(QUIC_HANDSHAKE_FAILED,
                                validator.error_details());
     OnConnectionClosedStatelessly(QUIC_HANDSHAKE_FAILED);
-    ProcessUnauthenticatedHeaderFate(kFateTimeWait, connection_id,
-                                     header.packet_number);
+    ProcessUnauthenticatedHeaderFate(kFateTimeWait, connection_id);
     return;
   }
 
   // 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());
+    ProcessStatelessRejectorState(std::move(rejector), version);
     return;
   }
 
@@ -904,8 +895,7 @@ void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
 
   // Continue stateless rejector processing
   std::unique_ptr<StatelessRejectorProcessDoneCallback> cb(
-      new StatelessRejectorProcessDoneCallback(
-          this, header.packet_number, header.public_header.versions.front()));
+      new StatelessRejectorProcessDoneCallback(this, version));
   StatelessRejector::Process(std::move(rejector), std::move(cb));
 }
 
@@ -914,7 +904,6 @@ void QuicDispatcher::OnStatelessRejectorProcessDone(
     const QuicSocketAddress& current_client_address,
     const QuicSocketAddress& current_server_address,
     std::unique_ptr<QuicReceivedPacket> current_packet,
-    QuicPacketNumber packet_number,
     QuicVersion first_version) {
   // Stop buffering packets on this connection
   const auto num_erased =
@@ -929,7 +918,7 @@ void QuicDispatcher::OnStatelessRejectorProcessDone(
           rejector->connection_id())) {
     time_wait_list_manager_->ProcessPacket(
         current_server_address, current_client_address,
-        rejector->connection_id(), packet_number, *current_packet);
+        rejector->connection_id(), *current_packet);
     return;
   }
 
@@ -940,13 +929,11 @@ void QuicDispatcher::OnStatelessRejectorProcessDone(
   current_packet_ = current_packet.get();
   current_connection_id_ = rejector->connection_id();
 
-  ProcessStatelessRejectorState(std::move(rejector), packet_number,
-                                first_version);
+  ProcessStatelessRejectorState(std::move(rejector), first_version);
 }
 
 void QuicDispatcher::ProcessStatelessRejectorState(
     std::unique_ptr<StatelessRejector> rejector,
-    QuicPacketNumber packet_number,
     QuicVersion first_version) {
   QuicPacketFate fate;
   switch (rejector->state()) {
@@ -988,8 +975,7 @@ void QuicDispatcher::ProcessStatelessRejectorState(
       fate = kFateDrop;
       break;
   }
-  ProcessUnauthenticatedHeaderFate(fate, rejector->connection_id(),
-                                   packet_number);
+  ProcessUnauthenticatedHeaderFate(fate, rejector->connection_id());
 }
 
 const QuicVersionVector& QuicDispatcher::GetSupportedVersions() {