Create an interface for explicit notification of Dispatcher about

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"
 #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_framer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
+#include "net/tools/quic/quic_server_session.h"
 
 using base::StringPiece;
 using std::make_pair;
 
 namespace net {
 namespace tools {
 
 namespace {
 
 // Time period for which the guid should live in time wait state..
@@ skipping 56 matching lines @@
  private:
   const IPEndPoint server_address_;
   const IPEndPoint client_address_;
   scoped_ptr<QuicEncryptedPacket> packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QueuedPacket);
 };
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
+    QuicServerSessionVisitor* visitor,
     EpollServer* epoll_server,
     const QuicVersionVector& supported_versions)
     : epoll_server_(epoll_server),
       kTimeWaitPeriod_(QuicTime::Delta::FromSeconds(kTimeWaitSeconds)),
       guid_clean_up_alarm_(new GuidCleanUpAlarm(this)),
       clock_(epoll_server_),
-      writer_(writer) {
+      writer_(writer),
+      visitor_(visitor) {
   SetGuidCleanUpAlarm();
 }
 
 QuicTimeWaitListManager::~QuicTimeWaitListManager() {
   guid_clean_up_alarm_->UnregisterIfRegistered();
   STLDeleteElements(&time_ordered_guid_list_);
   STLDeleteElements(&pending_packets_queue_);
   for (GuidMapIterator it = guid_map_.begin(); it != guid_map_.end(); ++it) {
     delete it->second.close_packet;
   }
@@ skipping 95 matching lines @@
   if (WriteToWire(packet)) {
     delete packet;
   } else {
     // pending_packets_queue takes the ownership of the queued packet.
     pending_packets_queue_.push_back(packet);
   }
 }
 
 bool QuicTimeWaitListManager::WriteToWire(QueuedPacket* queued_packet) {
   if (writer_->IsWriteBlocked()) {
+    visitor_->OnWriteBlocked(this);
     return false;
   }
   WriteResult result = writer_->WritePacket(
       queued_packet->packet()->data(),
       queued_packet->packet()->length(),
       queued_packet->server_address().address(),
       queued_packet->client_address(),
       this);
   if (result.status == WRITE_STATUS_BLOCKED) {
     // If blocked and unbuffered, return false to retry sending.
     DCHECK(writer_->IsWriteBlocked());
+    visitor_->OnWriteBlocked(this);
     return writer_->IsWriteBlockedDataBuffered();
   } else if (result.status == WRITE_STATUS_ERROR) {
     LOG(WARNING) << "Received unknown error while sending reset packet to "
                  << queued_packet->client_address().ToString() << ": "
                  << strerror(result.error_code);
   }
   return true;
 }
 
 void QuicTimeWaitListManager::SetGuidCleanUpAlarm() {
@@ skipping 30 matching lines @@
     delete it->second.close_packet;
     guid_map_.erase(oldest_guid->guid);
     time_ordered_guid_list_.pop_front();
     delete oldest_guid;
   }
   SetGuidCleanUpAlarm();
 }
 
 }  // namespace tools
 }  // namespace net