Improve tests. Correct things clang_tidy complains about. Make

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"
@@ skipping 68 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(QueuedPacket);
 };
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
     QuicServerSessionVisitor* visitor,
     EpollServer* epoll_server,
     const QuicVersionVector& supported_versions)
     : epoll_server_(epoll_server),
-      kTimeWaitPeriod_(
+      time_wait_period_(
           QuicTime::Delta::FromSeconds(FLAGS_quic_time_wait_list_seconds)),
       connection_id_clean_up_alarm_(new ConnectionIdCleanUpAlarm(this)),
       clock_(epoll_server_),
       writer_(writer),
       visitor_(visitor) {
   SetConnectionIdCleanUpAlarm();
 }
 
 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
   connection_id_clean_up_alarm_->UnregisterIfRegistered();
@@ skipping 152 matching lines @@
   return true;
 }
 
 void QuicTimeWaitListManager::SetConnectionIdCleanUpAlarm() {
   connection_id_clean_up_alarm_->UnregisterIfRegistered();
   int64 next_alarm_interval;
   if (!connection_id_map_.empty()) {
     QuicTime oldest_connection_id =
         connection_id_map_.begin()->second.time_added;
     QuicTime now = clock_.ApproximateNow();
-    if (now.Subtract(oldest_connection_id) < kTimeWaitPeriod_) {
-      next_alarm_interval = oldest_connection_id.Add(kTimeWaitPeriod_)
-                                                .Subtract(now)
-                                                .ToMicroseconds();
+    if (now.Subtract(oldest_connection_id) < time_wait_period_) {
+      next_alarm_interval = oldest_connection_id.Add(time_wait_period_)
+                                .Subtract(now)
+                                .ToMicroseconds();
     } else {
-      LOG(ERROR) << "ConnectionId lingered for longer than kTimeWaitPeriod";
+      LOG(ERROR) << "ConnectionId lingered for longer than time_wait_period_";
       next_alarm_interval = 0;
     }
   } else {
-    // No connection_ids added so none will expire before kTimeWaitPeriod_.
-    next_alarm_interval = kTimeWaitPeriod_.ToMicroseconds();
+    // No connection_ids added so none will expire before time_wait_period_.
+    next_alarm_interval = time_wait_period_.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();
-  QuicTime expiration = now.Subtract(kTimeWaitPeriod_);
+  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());
   }
 }
 
 }  // namespace tools
 }  // namespace net