Update from https://crrev.com/304418

net/quic/quic_time_wait_list_manager.cc

 // Copyright 2014 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/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_connection_helper.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_server_session.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 
 namespace net {
 
 namespace {
 
-// Time period for which a given connection_id should live in the time-wait
-// state.
-int64 FLAGS_quic_time_wait_list_seconds = 5;
+// Time period for which the connection_id should live in time wait state.
+const int kTimeWaitSeconds = 5;
 
 }  // namespace
 
 // 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 QuicAlarm::Delegate {
  public:
   explicit ConnectionIdCleanUpAlarm(
       QuicTimeWaitListManager* time_wait_list_manager)
-      : time_wait_list_manager_(time_wait_list_manager) {}
+      : time_wait_list_manager_(time_wait_list_manager) {
+  }
 
   QuicTime OnAlarm() override {
     time_wait_list_manager_->CleanUpOldConnectionIds();
     // Let the time wait manager register the alarm at appropriate time.
     return QuicTime::Zero();
   }
 
  private:
   // Not owned.
   QuicTimeWaitListManager* time_wait_list_manager_;
 };
 
 // This class stores pending public reset packets to be sent to clients.
 // server_address - server address on which a packet what was received for
 //                  a connection_id in time wait state.
 // client_address - address of the client that sent that packet. Needed to send
 //                  the public reset packet back to the client.
 // packet - the pending public reset packet that is to be sent to the client.
 //          created instance takes the ownership of this packet.
 class QuicTimeWaitListManager::QueuedPacket {
  public:
   QueuedPacket(const IPEndPoint& server_address,
                const IPEndPoint& client_address,
                QuicEncryptedPacket* packet)
       : server_address_(server_address),
         client_address_(client_address),
-        packet_(packet) {}
+        packet_(packet) {
+  }
 
   const IPEndPoint& server_address() const { return server_address_; }
   const IPEndPoint& client_address() const { return client_address_; }
   QuicEncryptedPacket* packet() { return packet_.get(); }
 
  private:
   const IPEndPoint server_address_;
   const IPEndPoint client_address_;
   scoped_ptr<QuicEncryptedPacket> packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QueuedPacket);
 };
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
     QuicServerSessionVisitor* visitor,
     QuicConnectionHelperInterface* helper,
     const QuicVersionVector& supported_versions)
     : helper_(helper),
-      kTimeWaitPeriod_(
-          QuicTime::Delta::FromSeconds(FLAGS_quic_time_wait_list_seconds)),
+      kTimeWaitPeriod_(QuicTime::Delta::FromSeconds(kTimeWaitSeconds)),
       connection_id_clean_up_alarm_(
           helper_->CreateAlarm(new ConnectionIdCleanUpAlarm(this))),
       writer_(writer),
       visitor_(visitor) {
   SetConnectionIdCleanUpAlarm();
 }
 
 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
   connection_id_clean_up_alarm_->Cancel();
   STLDeleteElements(&pending_packets_queue_);
@@ skipping 167 matching lines @@
 
 void QuicTimeWaitListManager::CleanUpOldConnectionIds() {
   QuicTime now = helper_->GetClock()->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;
     }
     // This connection_id has lived its age, retire it now.
-    DVLOG(1) << "Retiring " << it->first << " from the time-wait state.";
     delete it->second.close_packet;
     connection_id_map_.erase(it);
   }
   SetConnectionIdCleanUpAlarm();
 }
 
 }  // namespace net