Make TimeWaitListManager use PacketWriter's socket writability state.

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 81 matching lines @@
 };
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
     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),
-      is_write_blocked_(false) {
+      writer_(writer) {
   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 16 matching lines @@
   return guid_map_.find(guid) != guid_map_.end();
 }
 
 QuicVersion QuicTimeWaitListManager::GetQuicVersionFromGuid(QuicGuid guid) {
   GuidMapIterator it = guid_map_.find(guid);
   DCHECK(it != guid_map_.end());
   return (it->second).version;
 }
 
 bool QuicTimeWaitListManager::OnCanWrite() {
-  is_write_blocked_ = false;
-  while (!is_write_blocked_ && !pending_packets_queue_.empty()) {
+  while (!pending_packets_queue_.empty()) {
     QueuedPacket* queued_packet = pending_packets_queue_.front();
-    WriteToWire(queued_packet);
-    if (!is_write_blocked_) {
+    if (WriteToWire(queued_packet)) {
       pending_packets_queue_.pop_front();
       delete queued_packet;
+    } else {
+      break;
     }
   }
 
-  return !is_write_blocked_;
+  return !writer_->IsWriteBlocked();
 }
 
 void QuicTimeWaitListManager::ProcessPacket(
     const IPEndPoint& server_address,
     const IPEndPoint& client_address,
     QuicGuid guid,
     QuicPacketSequenceNumber sequence_number) {
   DCHECK(IsGuidInTimeWait(guid));
   // TODO(satyamshekhar): Think about handling packets from different client
   // addresses.
@@ skipping 38 matching lines @@
       server_address,
       client_address,
       QuicFramer::BuildPublicResetPacket(packet));
   // Takes ownership of the packet.
   SendOrQueuePacket(queued_packet);
 }
 
 // Either sends the packet and deletes it or makes pending queue the
 // owner of the packet.
 void QuicTimeWaitListManager::SendOrQueuePacket(QueuedPacket* packet) {
-  if (!is_write_blocked_) {
-    // TODO(satyamshekhar): Handle packets that fail due to error other than
-    // EAGAIN or EWOULDBLOCK.
-    WriteToWire(packet);
-  }
-
-  if (is_write_blocked_) {
+  if (WriteToWire(packet)) {
+    delete packet;
+  } else {
     // pending_packets_queue takes the ownership of the queued packet.
     pending_packets_queue_.push_back(packet);
-  } else {
-    delete packet;
   }
 }
 
-void QuicTimeWaitListManager::WriteToWire(QueuedPacket* queued_packet) {
-  DCHECK(!is_write_blocked_);
+bool QuicTimeWaitListManager::WriteToWire(QueuedPacket* queued_packet) {
+  if (writer_->IsWriteBlocked()) {
+    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) {
-    is_write_blocked_ = true;
+    // If blocked and unbuffered, return false to retry sending.
+    DCHECK(writer_->IsWriteBlocked());
+    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() {
   guid_clean_up_alarm_->UnregisterIfRegistered();
   int64 next_alarm_interval;
   if (!time_ordered_guid_list_.empty()) {
     GuidAddTime* oldest_guid = time_ordered_guid_list_.front();
     QuicTime now = clock_.ApproximateNow();
     DCHECK(now.Subtract(oldest_guid->time_added) < kTimeWaitPeriod_);
     next_alarm_interval = oldest_guid->time_added
@@ skipping 23 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