Landing Recent QUIC changes until: Fri Oct 30 22:23:58 2015 +0000

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 79 matching lines @@
       visitor_(visitor) {
   SetConnectionIdCleanUpAlarm();
 }
 
 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
   connection_id_clean_up_alarm_->Cancel();
   STLDeleteElements(&pending_packets_queue_);
   for (ConnectionIdMap::iterator it = connection_id_map_.begin();
        it != connection_id_map_.end();
        ++it) {
-    delete it->second.close_packet;
+    STLDeleteElements(&it->second.termination_packets);
   }
 }
 
 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;
+    std::vector<QuicEncryptedPacket*>* termination_packets) {
+  if (connection_rejected_statelessly) {
+    DCHECK(termination_packets != nullptr && !termination_packets->empty())
+        << "Connections that were rejected statelessly must "
+        << "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;
+    STLDeleteElements(&it->second.termination_packets);
     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, connection_rejected_statelessly);
+                        connection_rejected_statelessly);
+  if (termination_packets != nullptr) {
+    data.termination_packets.swap(*termination_packets);
+  }
   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 29 matching lines @@
   ConnectionIdMap::iterator it = connection_id_map_.find(connection_id);
   DCHECK(it != connection_id_map_.end());
   // Increment the received packet count.
   ConnectionIdData* connection_data = &it->second;
   ++(connection_data->num_packets);
 
   if (!ShouldSendResponse(connection_data->num_packets)) {
     return;
   }
 
-  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);
+  if (!connection_data->termination_packets.empty()) {
+    if (connection_data->connection_rejected_statelessly) {
+      DVLOG(3) << "Time wait list sending previous stateless reject response "
+               << "for connection " << connection_id;
+    }
+    for (QuicEncryptedPacket* packet : connection_data->termination_packets) {
+      QueuedPacket* queued_packet =
+          new QueuedPacket(server_address, client_address, packet->Clone());
+      // Takes ownership of the packet.
+      SendOrQueuePacket(queued_packet);
+    }
     return;
   }
 
-  if (connection_data->connection_rejected_statelessly) {
-    DVLOG(3) << "Time wait list not sending response for connection "
-             << connection_id << " due to previous stateless reject.";
-    return;
-  }
-
   SendPublicReset(server_address, client_address, connection_id, packet_number);
 }
 
 // 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 85 matching lines @@
     return false;
   }
   ConnectionIdMap::iterator it = connection_id_map_.begin();
   QuicTime oldest_connection_id_time = it->second.time_added;
   if (oldest_connection_id_time > expiration_time) {
     // Too recent, don't retire.
     return false;
   }
   // This connection_id has lived its age, retire it now.
   const QuicConnectionId connection_id = it->first;
-  delete it->second.close_packet;
+  STLDeleteElements(&it->second.termination_packets);
   connection_id_map_.erase(it);
   visitor_->OnConnectionRemovedFromTimeWaitList(connection_id);
   return true;
 }
 
 void QuicTimeWaitListManager::CleanUpOldConnectionIds() {
   QuicTime now = clock_->ApproximateNow();
   QuicTime expiration = now.Subtract(time_wait_period_);
 
   while (MaybeExpireOldestConnection(expiration)) {
   }
 
   SetConnectionIdCleanUpAlarm();
 }
 
 void QuicTimeWaitListManager::TrimTimeWaitListIfNeeded() {
   if (FLAGS_quic_time_wait_list_max_connections < 0) {
     return;
   }
   while (num_connections() >=
          static_cast<size_t>(FLAGS_quic_time_wait_list_max_connections)) {
     MaybeExpireOldestConnection(QuicTime::Infinite());
   }
 }
 
+QuicTimeWaitListManager::ConnectionIdData::ConnectionIdData(
+    int num_packets_,
+    QuicVersion version_,
+    QuicTime time_added_,
+    bool connection_rejected_statelessly)
+    : num_packets(num_packets_),
+      version(version_),
+      time_added(time_added_),
+      connection_rejected_statelessly(connection_rejected_statelessly) {}
+
+QuicTimeWaitListManager::ConnectionIdData::~ConnectionIdData() {}
+
 }  // namespace tools
 }  // namespace net