Remove unused packet_number parameter from multiple functions in QUIC.

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 320 matching lines @@
 }
 
 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, header.packet_number,
-        *current_packet_);
+        header.public_header.connection_id, *current_packet_);
     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);
+    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;
 }
 
 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:
       // MaybeRejectStatelessly or OnExpiredPackets might have already added the
       // connection to time wait, in which case it should not be added again.
       if (!FLAGS_quic_reloadable_flag_quic_use_cheap_stateless_rejects ||
           !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,
-          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,
       // 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 313 matching lines @@
       connection_id, *current_packet_, current_server_address_,
       current_client_address_, /*is_chlo=*/false);
   if (rs != EnqueuePacketResult::SUCCESS) {
     OnBufferPacketFailure(rs, connection_id);
   } else if (!FLAGS_quic_reloadable_flag_quic_create_session_after_insertion &&
              is_new_connection) {
     ShouldCreateOrBufferPacketForConnection(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(
         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(), packet_number, current_packet());
+        current_connection_id(), current_packet());
     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 67 matching lines @@
 
 bool QuicDispatcher::OnUnauthenticatedUnknownPublicHeader(
     const QuicPacketPublicHeader& header) {
   return true;
 }
 
 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:
   QuicDispatcher* dispatcher_;
   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 ||
       !FLAGS_quic_reloadable_flag_enable_quic_stateless_reject_support ||
       !ShouldAttemptCheapStatelessRejection()) {
     // Not use cheap stateless reject.
     if (FLAGS_quic_allow_chlo_buffering &&
         !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;
   }
 
   if (!validator.can_accept()) {
     // This CHLO is prohibited by policy.
     StatelessConnectionTerminator terminator(connection_id, &framer_, helper(),
                                              time_wait_list_manager_.get());
     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;
   }
 
   // Insert into set of connection IDs to buffer
   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()));
+      new StatelessRejectorProcessDoneCallback(this, version));
   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) {
   // 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);
+        rejector->connection_id(), *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,
-                                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()) {
     case StatelessRejector::FAILED: {
       // There was an error processing the client hello.
       StatelessConnectionTerminator terminator(rejector->connection_id(),
                                                &framer_, helper(),
                                                time_wait_list_manager_.get());
       terminator.CloseConnection(rejector->error(), rejector->error_details());
       fate = kFateTimeWait;
@@ skipping 21 matching lines @@
       OnConnectionRejectedStatelessly();
       fate = kFateTimeWait;
       break;
     }
 
     default:
       QUIC_BUG << "Rejector has invalid state " << rejector->state();
       fate = kFateDrop;
       break;
   }
-  ProcessUnauthenticatedHeaderFate(fate, rejector->connection_id(),
-                                   packet_number);
+  ProcessUnauthenticatedHeaderFate(fate, rejector->connection_id());
 }
 
 const QuicVersionVector& QuicDispatcher::GetSupportedVersions() {
   return version_manager_->GetSupportedVersions();
 }
 
 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