1 files changed, 87 insertions, 46 deletions

diff --git a/chromium/net/tools/quic/quic_time_wait_list_manager.cc b/chromium/net/tools/quic/quic_time_wait_list_manager.cc
index a2fc4f84cb6..df9e378e722 100644
--- a/chromium/net/tools/quic/quic_time_wait_list_manager.cc
+++ b/chromium/net/tools/quic/quic_time_wait_list_manager.cc
@@ -18,6 +18,7 @@
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 
+using base::StringPiece;
 using std::make_pair;
 
 namespace net {
@@ -92,8 +93,9 @@ class QuicTimeWaitListManager::QueuedPacket {
 
 QuicTimeWaitListManager::QuicTimeWaitListManager(
     QuicPacketWriter* writer,
-    EpollServer* epoll_server)
-    : framer_(QuicVersionMax(),
+    EpollServer* epoll_server,
+    const QuicVersionVector& supported_versions)
+    : framer_(supported_versions,
               QuicTime::Zero(),  // unused
               true),
       epoll_server_(epoll_server),
@@ -110,13 +112,18 @@ 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;
+  }
 }
 
-void QuicTimeWaitListManager::AddGuidToTimeWait(QuicGuid guid,
-                                                QuicVersion version) {
+void QuicTimeWaitListManager::AddGuidToTimeWait(
+    QuicGuid guid,
+    QuicVersion version,
+    QuicEncryptedPacket* close_packet) {
   DCHECK(!IsGuidInTimeWait(guid));
   // Initialize the guid with 0 packets received.
-  GuidData data(0, version);
+  GuidData data(0, version, close_packet);
   guid_map_.insert(make_pair(guid, data));
   time_ordered_guid_list_.push_back(new GuidAddTime(guid,
                                                     clock_.ApproximateNow()));
@@ -172,55 +179,89 @@ bool QuicTimeWaitListManager::OnProtocolVersionMismatch(
   return false;
 }
 
-bool QuicTimeWaitListManager::OnStreamFrame(const QuicStreamFrame& frame) {
+bool QuicTimeWaitListManager::OnUnauthenticatedHeader(
+    const QuicPacketHeader& header) {
+  // TODO(satyamshekhar): Think about handling packets from different client
+  // addresses.
+  GuidMapIterator it = guid_map_.find(header.public_header.guid);
+  DCHECK(it != guid_map_.end());
+  // Increment the received packet count.
+  ++((it->second).num_packets);
+  if (!ShouldSendResponse((it->second).num_packets)) {
+    return false;
+  }
+  if (it->second.close_packet) {
+     QueuedPacket* queued_packet =
+         new QueuedPacket(server_address_,
+                          client_address_,
+                          it->second.close_packet->Clone());
+     // Takes ownership of the packet.
+     SendOrQueuePacket(queued_packet);
+  } else {
+    // We don't need the packet anymore. Just tell the client what sequence
+    // number we rejected.
+    SendPublicReset(server_address_,
+                    client_address_,
+                    header.public_header.guid,
+                    header.packet_sequence_number);
+  }
+  // Never process the body of the packet in time wait state.
+  return false;
+}
+
+bool QuicTimeWaitListManager::OnPacketHeader(const QuicPacketHeader& header) {
+  DCHECK(false);
+  return false;
+}
+
+void QuicTimeWaitListManager::OnRevivedPacket() {
+  DCHECK(false);
+}
+
+void QuicTimeWaitListManager::OnFecProtectedPayload(StringPiece /*payload*/) {
+  DCHECK(false);
+}
+
+bool QuicTimeWaitListManager::OnStreamFrame(const QuicStreamFrame& /*frame*/) {
+  DCHECK(false);
   return false;
 }
 
-bool QuicTimeWaitListManager::OnAckFrame(const QuicAckFrame& frame) {
+bool QuicTimeWaitListManager::OnAckFrame(const QuicAckFrame& /*frame*/) {
+  DCHECK(false);
   return false;
 }
 
 bool QuicTimeWaitListManager::OnCongestionFeedbackFrame(
-    const QuicCongestionFeedbackFrame& frame) {
+    const QuicCongestionFeedbackFrame& /*frame*/) {
+  DCHECK(false);
   return false;
 }
 
 bool QuicTimeWaitListManager::OnRstStreamFrame(
-    const QuicRstStreamFrame& frame) {
+    const QuicRstStreamFrame& /*frame*/) {
+  DCHECK(false);
   return false;
 }
 
 bool QuicTimeWaitListManager::OnConnectionCloseFrame(
-    const QuicConnectionCloseFrame & frame) {
+    const QuicConnectionCloseFrame & /*frame*/) {
+  DCHECK(false);
   return false;
 }
 
-bool QuicTimeWaitListManager::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
+bool QuicTimeWaitListManager::OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) {
+  DCHECK(false);
   return false;
 }
 
-bool QuicTimeWaitListManager::OnPacketHeader(const QuicPacketHeader& header) {
-  // TODO(satyamshekhar): Think about handling packets from different client
-  // addresses.
-  GuidMapIterator it = guid_map_.find(header.public_header.guid);
-  DCHECK(it != guid_map_.end());
-  // Increment the received packet count.
-  ++((it->second).num_packets);
-  if (ShouldSendPublicReset((it->second).num_packets)) {
-    // We don't need the packet anymore. Just tell the client what sequence
-    // number we rejected.
-    SendPublicReset(server_address_,
-                    client_address_,
-                    header.public_header.guid,
-                    header.packet_sequence_number);
-  }
-  // Never process the body of the packet in time wait state.
-  return false;
+void QuicTimeWaitListManager::OnFecData(const QuicFecData& /*fec*/) {
+  DCHECK(false);
 }
 
 // Returns true if the number of packets received for this guid is a power of 2
 // to throttle the number of public reset packets we send to a client.
-bool QuicTimeWaitListManager::ShouldSendPublicReset(int received_packet_count) {
+bool QuicTimeWaitListManager::ShouldSendResponse(int received_packet_count) {
   return (received_packet_count & (received_packet_count - 1)) == 0;
 }
 
@@ -239,7 +280,7 @@ void QuicTimeWaitListManager::SendPublicReset(
   QueuedPacket* queued_packet = new QueuedPacket(
       server_address,
       client_address,
-      framer_.BuildPublicResetPacket(packet));
+      QuicFramer::BuildPublicResetPacket(packet));
   // Takes ownership of the packet.
   SendOrQueuePacket(queued_packet);
 }
@@ -263,22 +304,19 @@ void QuicTimeWaitListManager::SendOrQueuePacket(QueuedPacket* packet) {
 
 void QuicTimeWaitListManager::WriteToWire(QueuedPacket* queued_packet) {
   DCHECK(!is_write_blocked_);
-  int error;
-  int rc = writer_->WritePacket(queued_packet->packet()->data(),
-                                queued_packet->packet()->length(),
-                                queued_packet->server_address().address(),
-                                queued_packet->client_address(),
-                                this,
-                                &error);
-
-  if (rc == -1) {
-    if (error == EAGAIN || error == EWOULDBLOCK) {
-      is_write_blocked_ = true;
-    } else {
-      LOG(WARNING) << "Received unknown error while sending reset packet to "
-                   << queued_packet->client_address().ToString() << ": "
-                   << strerror(error);
-    }
+  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;
+  } 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);
   }
 }
 
@@ -311,6 +349,9 @@ void QuicTimeWaitListManager::CleanUpOldGuids() {
       break;
     }
     // This guid has lived its age, retire it now.
+    GuidMapIterator it = guid_map_.find(oldest_guid->guid);
+    DCHECK(it != guid_map_.end());
+    delete it->second.close_packet;
     guid_map_.erase(oldest_guid->guid);
     time_ordered_guid_list_.pop_front();
     delete oldest_guid;