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

net/tools/quic/quic_time_wait_list_manager.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_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 88 matching lines @@
   for (ConnectionIdMap::iterator it = connection_id_map_.begin();
        it != connection_id_map_.end();
        ++it) {
     delete it->second.close_packet;
   }
 }
 
 void QuicTimeWaitListManager::AddConnectionIdToTimeWait(
     QuicConnectionId connection_id,
     QuicVersion version,
+    bool connection_rejected_statelessly,
     QuicEncryptedPacket* close_packet) {
+  DCHECK(!connection_rejected_statelessly || !close_packet)
+      << "Connections that were rejected statelessly should not "
+      << "have a close packet.  connection_id = " << connection_id;
   int num_packets = 0;
   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
   const bool new_connection_id = it == connection_id_map_.end();
   if (!new_connection_id) {  // Replace record if it is reinserted.
     num_packets = it->second.num_packets;
     delete it->second.close_packet;
     connection_id_map_.erase(it);
   }
   TrimTimeWaitListIfNeeded();
   DCHECK_LT(num_connections(),
             static_cast<size_t>(FLAGS_quic_time_wait_list_max_connections));
-  ConnectionIdData data(num_packets,
-                        version,
-                        clock_->ApproximateNow(),
-                        close_packet);
+  ConnectionIdData data(num_packets, version, clock_->ApproximateNow(),
+                        close_packet, connection_rejected_statelessly);
   connection_id_map_.insert(std::make_pair(connection_id, data));
   if (new_connection_id) {
     visitor_->OnConnectionAddedToTimeWaitList(connection_id);
   }
 }
 
 bool QuicTimeWaitListManager::IsConnectionIdInTimeWait(
     QuicConnectionId connection_id) const {
   return ContainsKey(connection_id_map_, connection_id);
 }
@@ skipping 22 matching lines @@
     QuicConnectionId connection_id,
     QuicPacketSequenceNumber sequence_number,
     const QuicEncryptedPacket& /*packet*/) {
   DCHECK(IsConnectionIdInTimeWait(connection_id));
   DVLOG(1) << "Processing " << connection_id << " in time wait state.";
   // TODO(satyamshekhar): Think about handling packets from different client
   // addresses.
   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
   DCHECK(it != connection_id_map_.end());
   // Increment the received packet count.
-  ++((it->second).num_packets);
-  if (!ShouldSendResponse((it->second).num_packets)) {
+  ConnectionIdData* connection_data = &it->second;
+  ++(connection_data->num_packets);
+  if (!ShouldSendResponse(connection_data->num_packets)) {
     return;
   }
-  if (it->second.close_packet) {
-    QueuedPacket* queued_packet =
-        new QueuedPacket(server_address,
-                         client_address,
-                         it->second.close_packet->Clone());
+  if (connection_data->close_packet) {
+    QueuedPacket* queued_packet = new QueuedPacket(
+        server_address, client_address, connection_data->close_packet->Clone());
     // Takes ownership of the packet.
     SendOrQueuePacket(queued_packet);
-  } else {
+  } else if (!connection_data->connection_rejected_statelessly) {
     SendPublicReset(server_address,
                     client_address,
                     connection_id,
                     sequence_number);
+  } else {
+    DVLOG(3) << "Time wait list not sending response for connection "
+             << connection_id << " due to previous stateless reject.";
   }
 }
 
 // Returns true if the number of packets received for this connection_id is a
 // power of 2 to throttle the number of public reset packets we send to a
 // client.
 bool QuicTimeWaitListManager::ShouldSendResponse(int received_packet_count) {
   return (received_packet_count & (received_packet_count - 1)) == 0;
 }
 
@@ skipping 113 matching lines @@
     return;
   }
   while (num_connections() >=
          static_cast<size_t>(FLAGS_quic_time_wait_list_max_connections)) {
     MaybeExpireOldestConnection(QuicTime::Infinite());
   }
 }
 
 }  // namespace tools
 }  // namespace net