Create an interface for explicit notification of Dispatcher about

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 guids 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/quic/quic_blocked_writer_interface.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_epoll_clock.h"
 
 namespace net {
 namespace tools {
 
 class GuidCleanUpAlarm;
+class QuicServerSessionVisitor;
 
 namespace test {
 class QuicTimeWaitListManagerPeer;
 }  // namespace test
 
 // Maintains a list of all guids that have been recently closed. A guid lives in
 // this state for kTimeWaitPeriod. All packets received for guids 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 guid in time wait state.  After the guid expires its time wait
 // period, a new connection/session will be created if a packet is received
 // for this guid.
 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);
   virtual ~QuicTimeWaitListManager();
 
   // Adds the given guid to time wait state for kTimeWaitPeriod. Henceforth,
   // any packet bearing this guid should not be processed while the guid remains
   // in this list. If a non-NULL |close_packet| is provided, it is sent again
   // when packets are received for added guids. If NULL, a public reset packet
   // is sent with the specified |version|. DCHECKs that guid is not already on
   // the list.
@@ skipping 76 matching lines @@
 
   // Maintains a list of GuidAddTime elements which it owns, in the
   // order they should be deleted.
   std::deque<GuidAddTime*> time_ordered_guid_list_;
 
   // 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 guids which have been in the list for
-  // too long. Owned by the dispatcher.
+  // too long.
   EpollServer* epoll_server_;
 
   // Time period for which guids should remain in time wait state.
   const QuicTime::Delta kTimeWaitPeriod_;
 
   // Alarm registered with the epoll server to clean up guids that have out
   // lived their duration in time wait state.
   scoped_ptr<GuidCleanUpAlarm> guid_clean_up_alarm_;
 
   // Clock to efficiently measure approximate time from the epoll server.
   QuicEpollClock clock_;
 
-  // Interface that writes given buffer to the socket. Owned by the dispatcher.
+  // 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_