Update from https://crrev.com/312398

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/containers/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_clock.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_server_session.h"
 
 using base::StringPiece;
 using std::make_pair;
 
 namespace net {
 namespace tools {
 
-namespace {
-
-// Time period for which a given connection_id should live in the time-wait
-// state.
-int64 FLAGS_quic_time_wait_list_seconds = 5;
-
-}  // namespace
+// TODO(rtenneti): Remove the duplicated code in this file. Share code with
+// "net/quic/quic_time_wait_list_manager.cc"
 
 // A very simple alarm that just informs the QuicTimeWaitListManager to clean
 // up old connection_ids. This alarm should be unregistered and deleted before
 // the QuicTimeWaitListManager is deleted.
 class ConnectionIdCleanUpAlarm : public EpollAlarm {
  public:
   explicit ConnectionIdCleanUpAlarm(
       QuicTimeWaitListManager* time_wait_list_manager)
       : time_wait_list_manager_(time_wait_list_manager) {
   }
@@ skipping 69 matching lines @@
     QuicVersion version,
     QuicEncryptedPacket* close_packet) {
   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();
+  if (FLAGS_quic_limit_time_wait_list_size) {
+    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_id_map_.insert(make_pair(connection_id, data));
   if (new_connection_id) {
     visitor_->OnConnectionAddedToTimeWaitList(connection_id);
   }
 }
 
@@ skipping 136 matching lines @@
     }
   } else {
     // No connection_ids added so none will expire before kTimeWaitPeriod_.
     next_alarm_interval = kTimeWaitPeriod_.ToMicroseconds();
   }
 
   epoll_server_->RegisterAlarmApproximateDelta(
       next_alarm_interval, connection_id_clean_up_alarm_.get());
 }
 
+bool QuicTimeWaitListManager::MaybeExpireOldestConnection(
+    QuicTime expiration_time) {
+  if (connection_id_map_.empty()) {
+    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;
+  connection_id_map_.erase(it);
+  visitor_->OnConnectionRemovedFromTimeWaitList(connection_id);
+  return true;
+}
+
 void QuicTimeWaitListManager::CleanUpOldConnectionIds() {
   QuicTime now = clock_.ApproximateNow();
-  while (!connection_id_map_.empty()) {
-    ConnectionIdMap::iterator it = connection_id_map_.begin();
-    QuicTime oldest_connection_id = it->second.time_added;
-    if (now.Subtract(oldest_connection_id) < kTimeWaitPeriod_) {
-      break;
+  QuicTime expiration = now.Subtract(kTimeWaitPeriod_);
+  if (FLAGS_quic_limit_time_wait_list_size) {
+    while (MaybeExpireOldestConnection(expiration)) {
     }
-    const QuicConnectionId connection_id = it->first;
-    // This connection_id has lived its age, retire it now.
-    delete it->second.close_packet;
-    connection_id_map_.erase(it);
-    visitor_->OnConnectionRemovedFromTimeWaitList(connection_id);
+  } else {
+    while (!connection_id_map_.empty()) {
+      ConnectionIdMap::iterator it = connection_id_map_.begin();
+      QuicTime oldest_connection_id = it->second.time_added;
+      if (now.Subtract(oldest_connection_id) < kTimeWaitPeriod_) {
+        break;
+      }
+      const QuicConnectionId connection_id = it->first;
+      // This connection_id has lived its age, retire it now.
+      delete it->second.close_packet;
+      connection_id_map_.erase(it);
+      visitor_->OnConnectionRemovedFromTimeWaitList(connection_id);
+    }
   }
+
   SetConnectionIdCleanUpAlarm();
 }
 
+void QuicTimeWaitListManager::TrimTimeWaitListIfNeeded() {
+  if (FLAGS_quic_limit_time_wait_list_size) {
+    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());
+    }
+  }
+}
+
 }  // namespace tools
 }  // namespace net