Added support for stateless time-wait entries. Will be used in a

net/tools/quic/quic_time_wait_list_manager.h

 // 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.
 //
 // Handles packets for connection_ids in time wait state by discarding the
 // packet and sending the clients a public reset packet with exponential
 // backoff.
 
 #ifndef NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_
 #define NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_
@@ skipping 37 matching lines @@
                           const QuicVersionVector& supported_versions);
   ~QuicTimeWaitListManager() override;
 
   // Adds the given connection_id to time wait state for time_wait_period_.
   // Henceforth, any packet bearing this connection_id should not be processed
   // while the connection_id remains in this list. If a non-nullptr
   // |close_packet| is provided, the TimeWaitListManager takes ownership of it
   // and sends it again when packets are received for added connection_ids. If
   // nullptr, a public reset packet is sent with the specified |version|.
   // DCHECKs that connection_id is not already on the list. "virtual" to
-  // override in tests.
+  // override in tests.  If "connection_rejected_statelessly" is true, it means
+  // that the connection was closed due to a stateless reject, and no close
+  // packet is expected.  Any packets that are received for connection_id will
+  // be black-holed.
+  // TODO(jokulik): In the future, we plan send (redundant) SREJ packets back to
+  // the client in response to stray data-packets that arrive after the first
+  // SREJ.  This requires some new plumbing, so we black-hole for now.
   virtual void AddConnectionIdToTimeWait(QuicConnectionId connection_id,
                                          QuicVersion version,
+                                         bool connection_rejected_statelessly,
                                          QuicEncryptedPacket* close_packet);
 
   // Returns true if the connection_id is in time wait state, false otherwise.
   // Packets received for this connection_id should not lead to creation of new
   // QuicSessions.
   bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) const;
 
   // Called when a packet is received for a connection_id that is in time wait
   // state. Sends a public reset packet to the client which sent this
   // connection_id. Sending of the public reset packet is throttled by using
@@ skipping 67 matching lines @@
   // false if the map is empty or the oldest connection has not expired.
   bool MaybeExpireOldestConnection(QuicTime expiration_time);
 
   // A map from a recently closed connection_id to the number of packets
   // received after the termination of the connection bound to the
   // connection_id.
   struct ConnectionIdData {
     ConnectionIdData(int num_packets_,
                      QuicVersion version_,
                      QuicTime time_added_,
-                     QuicEncryptedPacket* close_packet)
+                     QuicEncryptedPacket* close_packet,
+                     bool connection_rejected_statelessly)
         : num_packets(num_packets_),
           version(version_),
           time_added(time_added_),
-          close_packet(close_packet) {}
+          close_packet(close_packet),
+          connection_rejected_statelessly(connection_rejected_statelessly) {}
     int num_packets;
     QuicVersion version;
     QuicTime time_added;
     QuicEncryptedPacket* close_packet;
+    bool connection_rejected_statelessly;
   };
 
   // linked_hash_map allows lookup by ConnectionId and traversal in add order.
   typedef linked_hash_map<QuicConnectionId, ConnectionIdData> ConnectionIdMap;
   ConnectionIdMap connection_id_map_;
 
   // Pending public reset packets that need to be sent out to the client
   // when we are given a chance to write by the dispatcher.
   std::deque<QueuedPacket*> pending_packets_queue_;
 
@@ skipping 13 matching lines @@
   // Interface that manages blocked writers.
   QuicServerSessionVisitor* visitor_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicTimeWaitListManager);
 };
 
 }  // namespace tools
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_