Land Recent QUIC Changes

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_
 
 #include <deque>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/strings/string_piece.h"
 #include "net/base/linked_hash_map.h"
 #include "net/quic/quic_blocked_writer_interface.h"
+#include "net/quic/quic_connection.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
-#include "net/tools/quic/quic_epoll_clock.h"
 
 namespace net {
 
-class EpollServer;
-
 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)
+  // helper - used to run clean up alarms. (Owned by the dispatcher)
   QuicTimeWaitListManager(QuicPacketWriter* writer,
                           QuicServerSessionVisitor* visitor,
-                          EpollServer* epoll_server,
+                          QuicConnectionHelperInterface* helper,
                           const QuicVersionVector& supported_versions);
   ~QuicTimeWaitListManager() override;
 
-  // Adds the given connection_id to time wait state for kTimeWaitPeriod.
-  // 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.
+  // 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, 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 47 matching lines @@
   // Either sends the packet and deletes it or makes pending_packets_queue_ the
   // owner of the packet.
   void SendOrQueuePacket(QueuedPacket* packet);
 
   // Sends the packet out. Returns true if the packet was successfully consumed.
   // If the writer got blocked and did not buffer the packet, we'll need to keep
   // the packet and retry sending. In case of all other errors we drop the
   // packet.
   bool WriteToWire(QueuedPacket* packet);
 
-  // Register the alarm with the epoll server to wake up at appropriate time.
+  // Register the alarm server to wake up at appropriate time.
   void SetConnectionIdCleanUpAlarm();
 
   // Removes the oldest connection from the time-wait list if it was added prior
   // to "expiration_time".  To unconditionally remove the oldest connection, use
   // a QuicTime::Delta:Infinity().  This function modifies the
   // connection_id_map_.  If you plan to call this function in a loop, any
   // iterators that you hold before the call to this function may be invalid
   // afterward.  Returns true if the oldest connection was expired.  Returns
   // false if the map is empty or the oldest connection has not expired.
   bool MaybeExpireOldestConnection(QuicTime expiration_time);
@@ skipping 17 matching lines @@
   };
 
   // linked_hash_map allows lookup by ConnectionId and traversal in add order.
   typedef linked_hash_map<QuicConnectionId, ConnectionIdData> ConnectionIdMap;
   ConnectionIdMap connection_id_map_;
 
   // 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 time_wait_period_;
 
-  // Time period for which connection_ids should remain in time wait state.
-  const QuicTime::Delta kTimeWaitPeriod_;
+  // Alarm to clean up connection_ids that have out lived their duration in
+  // time wait state.
+  scoped_ptr<QuicAlarm> connection_id_clean_up_alarm_;
 
-  // 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_;
+  // Clock to efficiently measure approximate time.
+  const QuicClock* 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_