Improve tests. Correct things clang_tidy complains about. Make

net/tools/quic/quic_time_wait_list_manager.h

 // 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.
 //
 // Handles packets for connection_ids in time wait state by discarding the
 // packet and sending the clients a public reset packet with exponential
 // backoff.
 
 #ifndef NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_
 #define NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_
@@ skipping 17 matching lines @@
 namespace tools {
 
 class ConnectionIdCleanUpAlarm;
 class QuicServerSessionVisitor;
 
 namespace test {
 class QuicTimeWaitListManagerPeer;
 }  // namespace test
 
 // Maintains a list of all connection_ids that have been recently closed. A
-// connection_id lives in this state for kTimeWaitPeriod. All packets received
+// connection_id lives in this state for time_wait_period_. All packets received
 // for connection_ids in this state are handed over to the
 // QuicTimeWaitListManager by the QuicDispatcher.  Decides whether to send a
 // public reset packet, a copy of the previously sent connection close packet,
 // or nothing to the client which sent a packet with the connection_id in time
 // wait state.  After the connection_id expires its time wait period, a new
 // connection/session will be created if a packet is received for this
 // connection_id.
 class QuicTimeWaitListManager : public QuicBlockedWriterInterface {
  public:
   // writer - the entity that writes to the socket. (Owned by the dispatcher)
   // visitor - the entity that manages blocked writers. (The dispatcher)
   // epoll_server - used to run clean up alarms. (Owned by the dispatcher)
   QuicTimeWaitListManager(QuicPacketWriter* writer,
                           QuicServerSessionVisitor* visitor,
                           EpollServer* epoll_server,
                           const QuicVersionVector& supported_versions);
   ~QuicTimeWaitListManager() override;
 
-  // Adds the given connection_id to time wait state for kTimeWaitPeriod.
+  // Adds the given connection_id to time wait state for time_wait_period_.
   // Henceforth, any packet bearing this connection_id should not be processed
   // while the connection_id remains in this list. If a non-nullptr
-  // |close_packet| is provided, it is sent again when packets are received for
-  // added connection_ids. If nullptr, a public reset packet is sent with the
-  // specified |version|. DCHECKs that connection_id is not already on the list.
-  void AddConnectionIdToTimeWait(QuicConnectionId connection_id,
-                                 QuicVersion version,
-                                 QuicEncryptedPacket* close_packet);  // Owned.
+  // |close_packet| is provided, the TimeWaitListManager takes ownership of it
+  // and sends it again when packets are received for added connection_ids. If
+  // nullptr, a public reset packet is sent with the specified |version|.
+  // DCHECKs that connection_id is not already on the list. "virtual" to
+  // override in tests.
+  virtual void AddConnectionIdToTimeWait(QuicConnectionId connection_id,
+                                         QuicVersion version,
+                                         QuicEncryptedPacket* close_packet);
 
   // Returns true if the connection_id is in time wait state, false otherwise.
   // Packets received for this connection_id should not lead to creation of new
   // QuicSessions.
   bool IsConnectionIdInTimeWait(QuicConnectionId connection_id) const;
 
   // Called when a packet is received for a connection_id that is in time wait
   // state. Sends a public reset packet to the client which sent this
   // connection_id. Sending of the public reset packet is throttled by using
   // exponential back off. DCHECKs for the connection_id to be in time wait
@@ skipping 90 matching lines @@
 
   // Pending public reset packets that need to be sent out to the client
   // when we are given a chance to write by the dispatcher.
   std::deque<QueuedPacket*> pending_packets_queue_;
 
   // Used to schedule alarms to delete old connection_ids which have been in the
   // list for too long.
   EpollServer* epoll_server_;
 
   // Time period for which connection_ids should remain in time wait state.
-  const QuicTime::Delta kTimeWaitPeriod_;
+  const QuicTime::Delta time_wait_period_;
 
   // Alarm registered with the epoll server to clean up connection_ids that have
   // out lived their duration in time wait state.
   scoped_ptr<ConnectionIdCleanUpAlarm> connection_id_clean_up_alarm_;
 
   // Clock to efficiently measure approximate time from the epoll server.
   QuicEpollClock clock_;
 
   // Interface that writes given buffer to the socket.
   QuicPacketWriter* writer_;
 
   // Interface that manages blocked writers.
   QuicServerSessionVisitor* visitor_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicTimeWaitListManager);
 };
 
 }  // namespace tools
 }  // namespace net
 
 #endif  // NET_TOOLS_QUIC_QUIC_TIME_WAIT_LIST_MANAGER_H_