Remove FLAGS_quic_session_map_threshold_for_stateless_rejects, and instead always use stateless rej…

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"
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 #include "net/tools/quic/quic_per_connection_packet_writer.h"
 #include "net/tools/quic/quic_time_wait_list_manager.h"
 
 namespace net {
 
 namespace tools {
 
 using std::make_pair;
 using base::StringPiece;
 
-// The threshold size for the session map, over which the dispatcher will start
-// sending stateless rejects (SREJ), rather than stateful rejects (REJ) to
-// clients who support them.  If -1, stateless rejects will not be sent.  If 0,
-// the server will only send stateless rejects to clients who support them.
-int32 FLAGS_quic_session_map_threshold_for_stateless_rejects = -1;
-
 namespace {
 
 // An alarm that informs the QuicDispatcher to delete old sessions.
 class DeleteSessionsAlarm : public QuicAlarm::Delegate {
  public:
   explicit DeleteSessionsAlarm(QuicDispatcher* dispatcher)
       : dispatcher_(dispatcher) {
   }
 
   QuicTime OnAlarm() override {
@@ skipping 251 matching lines @@
   }
 
   // Packet's connection ID is unknown.
   // Apply the validity checks.
   QuicPacketFate fate = ValidityChecks(header);
   switch (fate) {
     case kFateProcess: {
       // Create a session and process the packet.
       QuicServerSession* session =
           CreateQuicSession(connection_id, current_client_address_);
+      if (FLAGS_enable_quic_stateless_reject_support) {
+        session->set_use_stateless_rejects_if_peer_supported(true);
+      }
       DVLOG(1) << "Created new session for " << connection_id;
       session_map_.insert(std::make_pair(connection_id, session));
       session->connection()->ProcessUdpPacket(
           current_server_address_, current_client_address_, *current_packet_);
       break;
     }
     case kFateTimeWait:
       // Add this connection_id to the time-wait state, to safely reject
       // future packets.
       DVLOG(1) << "Adding connection ID " << connection_id
@@ skipping 144 matching lines @@
     QuicConnectionId connection_id,
     const IPEndPoint& client_address) {
   // The QuicServerSession takes ownership of |connection| below.
   QuicConnection* connection = new QuicConnection(
       connection_id, client_address, helper_.get(), connection_writer_factory_,
       /* owns_writer= */ true, Perspective::IS_SERVER, supported_versions_);
 
   QuicServerSession* session =
       new QuicServerSession(config_, connection, this, crypto_config_);
   session->Initialize();
-  if (FLAGS_quic_session_map_threshold_for_stateless_rejects != -1 &&
-      session_map_.size() >=
-          static_cast<size_t>(
-              FLAGS_quic_session_map_threshold_for_stateless_rejects)) {
-    session->set_use_stateless_rejects_if_peer_supported(true);
-  }
   return session;
 }
 
 QuicTimeWaitListManager* QuicDispatcher::CreateQuicTimeWaitListManager() {
   // TODO(rjshade): The QuicTimeWaitListManager should take ownership of the
   // per-connection packet writer.
   time_wait_list_writer_.reset(
       packet_writer_factory_->Create(writer_.get(), nullptr));
   return new QuicTimeWaitListManager(time_wait_list_writer_.get(), this,
                                      helper_.get());
@@ skipping 15 matching lines @@
   // send it to the time wait manager in OnUnathenticatedHeader.
   return true;
 }
 
 void QuicDispatcher::SetLastError(QuicErrorCode error) {
   last_error_ = error;
 }
 
 }  // namespace tools
 }  // namespace net