Merge the QUIC unacked packet map with the unacked fec packet map and

net/quic/quic_connection.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/quic/quic_connection.h"
 
 #include <string.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <iterator>
@@ skipping 83 matching lines @@
 
   virtual QuicTime OnAlarm() OVERRIDE {
     connection_->OnRetransmissionTimeout();
     return QuicTime::Zero();
   }
 
  private:
   QuicConnection* connection_;
 };
 
-// This alarm will be scheduled any time a FEC-bearing packet is sent out.
-// When the alarm goes off, the connection checks to see if the oldest packets
-// have been acked, and removes them from the congestion window if not.
-class AbandonFecAlarm : public QuicAlarm::Delegate {
- public:
-  explicit AbandonFecAlarm(QuicConnection* connection)
-      : connection_(connection) {
-  }
-
-  virtual QuicTime OnAlarm() OVERRIDE {
-    return connection_->OnAbandonFecTimeout();
-  }
-
- private:
-  QuicConnection* connection_;
-};
-
 // An alarm that is scheduled when the sent scheduler requires a
 // a delay before sending packets and fires when the packet may be sent.
 class SendAlarm : public QuicAlarm::Delegate {
  public:
   explicit SendAlarm(QuicConnection* connection)
       : connection_(connection) {
   }
 
   virtual QuicTime OnAlarm() OVERRIDE {
     connection_->WriteIfNotBlocked();
@@ skipping 70 matching lines @@
       clock_(helper->GetClock()),
       random_generator_(helper->GetRandomGenerator()),
       guid_(guid),
       peer_address_(address),
       largest_seen_packet_with_ack_(0),
       pending_version_negotiation_packet_(false),
       write_blocked_(false),
       received_packet_manager_(kTCP),
       ack_alarm_(helper->CreateAlarm(new AckAlarm(this))),
       retransmission_alarm_(helper->CreateAlarm(new RetransmissionAlarm(this))),
-      abandon_fec_alarm_(helper->CreateAlarm(new AbandonFecAlarm(this))),
       send_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       resume_writes_alarm_(helper->CreateAlarm(new SendAlarm(this))),
       timeout_alarm_(helper->CreateAlarm(new TimeoutAlarm(this))),
       debug_visitor_(NULL),
       packet_creator_(guid_, &framer_, random_generator_, is_server),
       packet_generator_(this, NULL, &packet_creator_),
       idle_network_timeout_(
           QuicTime::Delta::FromSeconds(kDefaultInitialTimeoutSecs)),
       overall_connection_timeout_(QuicTime::Delta::Infinite()),
       creation_time_(clock_->ApproximateNow()),
@@ skipping 295 matching lines @@
 
   bool reset_retransmission_alarm =
       sent_packet_manager_.OnIncomingAck(incoming_ack.received_info,
                                          time_of_last_received_packet_);
   if (sent_packet_manager_.HasPendingRetransmissions()) {
     WriteIfNotBlocked();
   }
 
   if (reset_retransmission_alarm) {
     retransmission_alarm_->Cancel();
-    abandon_fec_alarm_->Cancel();
     // Reset the RTO and FEC alarms if the are unacked packets.
-    QuicTime::Delta retransmission_delay =
-        sent_packet_manager_.GetRetransmissionDelay();
     if (sent_packet_manager_.HasUnackedPackets()) {
+      QuicTime::Delta retransmission_delay =
+          sent_packet_manager_.GetRetransmissionDelay();
       retransmission_alarm_->Set(
           clock_->ApproximateNow().Add(retransmission_delay));
     }
-    if (sent_packet_manager_.HasUnackedFecPackets()) {
-      abandon_fec_alarm_->Set(
-          clock_->ApproximateNow().Add(retransmission_delay));
-    }
   }
 }
 
 bool QuicConnection::OnCongestionFeedbackFrame(
     const QuicCongestionFeedbackFrame& feedback) {
   DCHECK(connected_);
   if (debug_visitor_) {
     debug_visitor_->OnCongestionFeedbackFrame(feedback);
   }
   last_congestion_frames_.push_back(feedback);
@@ skipping 552 matching lines @@
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     send_alarm_->Cancel();
     send_alarm_->Set(now.Add(delay));
     DVLOG(1) << "Delaying sending.";
     return false;
   }
   return true;
 }
 
-void QuicConnection::SetupRetransmission(
-    QuicPacketSequenceNumber sequence_number,
-    EncryptionLevel level) {
+void QuicConnection::SetupRetransmissionAlarm(
+    QuicPacketSequenceNumber sequence_number) {
   if (!sent_packet_manager_.HasRetransmittableFrames(sequence_number)) {
     DVLOG(1) << ENDPOINT << "Will not retransmit packet " << sequence_number;
     return;
   }
 
   // Do not set the retransmission alarm if we're already handling one, since
   // it will be reset when OnRetransmissionTimeout completes.
   if (retransmission_alarm_->IsSet()) {
     return;
   }
 
   QuicTime::Delta retransmission_delay =
       sent_packet_manager_.GetRetransmissionDelay();
   retransmission_alarm_->Set(
       clock_->ApproximateNow().Add(retransmission_delay));
 }
 
-void QuicConnection::SetupAbandonFecTimer(
-    QuicPacketSequenceNumber sequence_number) {
-  if (abandon_fec_alarm_->IsSet()) {
-    return;
-  }
-  QuicTime::Delta retransmission_delay =
-      sent_packet_manager_.GetRetransmissionDelay();
-  abandon_fec_alarm_->Set(clock_->ApproximateNow().Add(retransmission_delay));
-}
-
 bool QuicConnection::WritePacket(EncryptionLevel level,
                                  QuicPacketSequenceNumber sequence_number,
                                  QuicPacket* packet,
                                  TransmissionType transmission_type,
                                  HasRetransmittableData retransmittable,
                                  IsHandshake handshake,
                                  Force forced) {
   if (ShouldDiscardPacket(level, sequence_number, retransmittable)) {
     delete packet;
     return true;
@@ skipping 156 matching lines @@
 bool QuicConnection::OnPacketSent(WriteResult result) {
   DCHECK_NE(WRITE_STATUS_BLOCKED, result.status);
   if (pending_write_.get() == NULL) {
     LOG(DFATAL) << "OnPacketSent called without a pending write.";
     return false;
   }
 
   QuicPacketSequenceNumber sequence_number = pending_write_->sequence_number;
   TransmissionType transmission_type  = pending_write_->transmission_type;
   HasRetransmittableData retransmittable = pending_write_->retransmittable;
-  EncryptionLevel level = pending_write_->level;
   bool is_fec_packet = pending_write_->is_fec_packet;
   size_t length = pending_write_->length;
   pending_write_.reset();
 
   if (result.status == WRITE_STATUS_ERROR) {
     DVLOG(1) << "Write failed with error code: " << result.error_code;
     // We can't send an error as the socket is presumably borked.
     CloseConnection(QUIC_PACKET_WRITE_ERROR, false);
     return false;
   }
 
   QuicTime now = clock_->Now();
   if (transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_packet_ = now;
   }
   DVLOG(1) << ENDPOINT << "time of last sent packet: "
            << now.ToDebuggingValue();
 
   // Set the retransmit alarm only when we have sent the packet to the client
   // and not when it goes to the pending queue, otherwise we will end up adding
   // an entry to retransmission_timeout_ every time we attempt a write.
-  if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
-    SetupRetransmission(sequence_number, level);
-  } else if (is_fec_packet) {
-    SetupAbandonFecTimer(sequence_number);
+  if (retransmittable == HAS_RETRANSMITTABLE_DATA || is_fec_packet) {
+    SetupRetransmissionAlarm(sequence_number);
   }
 
   // TODO(ianswett): Change the sequence number length and other packet creator
   // options by a more explicit API than setting a struct value directly.
   packet_creator_.UpdateSequenceNumberLength(
       received_packet_manager_.least_packet_awaited_by_peer(),
       sent_packet_manager_.BandwidthEstimate().ToBytesPerPeriod(
           sent_packet_manager_.SmoothedRtt()));
 
   sent_packet_manager_.OnPacketSent(sequence_number, now, length,
-                                   transmission_type, retransmittable);
+                                    transmission_type, retransmittable);
 
   stats_.bytes_sent += result.bytes_written;
   ++stats_.packets_sent;
 
   if (transmission_type == NACK_RETRANSMISSION ||
       transmission_type == RTO_RETRANSMISSION) {
     stats_.bytes_retransmitted += result.bytes_written;
     ++stats_.packets_retransmitted;
   }
 
   return true;
 }
 
 bool QuicConnection::OnSerializedPacket(
     const SerializedPacket& serialized_packet) {
   if (serialized_packet.retransmittable_frames) {
     serialized_packet.retransmittable_frames->
         set_encryption_level(encryption_level_);
   }
-  sent_packet_manager_.OnSerializedPacket(serialized_packet,
-                                          clock_->ApproximateNow());
+  sent_packet_manager_.OnSerializedPacket(serialized_packet);
   // The TransmissionType is NOT_RETRANSMISSION because all retransmissions
   // serialize packets and invoke SendOrQueuePacket directly.
   return SendOrQueuePacket(encryption_level_,
                            serialized_packet,
                            NOT_RETRANSMISSION);
 }
 
 QuicPacketSequenceNumber QuicConnection::GetNextPacketSequenceNumber() {
   return packet_creator_.sequence_number() + 1;
 }
@@ skipping 44 matching lines @@
 void QuicConnection::OnRetransmissionTimeout() {
   if (!sent_packet_manager_.HasUnackedPackets()) {
     return;
   }
 
   ++stats_.rto_count;
 
   sent_packet_manager_.OnRetransmissionTimeout();
 
   WriteIfNotBlocked();
-}
 
-QuicTime QuicConnection::OnAbandonFecTimeout() {
-  QuicTime fec_timeout = sent_packet_manager_.OnAbandonFecTimeout();
-
-  // If a packet was abandoned, then the congestion window may have
-  // opened up, so attempt to write.
-  WriteIfNotBlocked();
-
-  return fec_timeout;
+  // Ensure the retransmission alarm is always set if there are unacked packets.
+  if (sent_packet_manager_.HasUnackedPackets() && !HasQueuedData() &&
+      !retransmission_alarm_->IsSet()) {
+    QuicTime rto_timeout = clock_->ApproximateNow().Add(
+        sent_packet_manager_.GetRetransmissionDelay());
+    retransmission_alarm_->Set(rto_timeout);
+  }
 }
 
 void QuicConnection::SetEncrypter(EncryptionLevel level,
                                   QuicEncrypter* encrypter) {
   framer_.SetEncrypter(level, encrypter);
 }
 
 const QuicEncrypter* QuicConnection::encrypter(EncryptionLevel level) const {
   return framer_.encrypter(level);
 }
@@ skipping 270 matching lines @@
   // If we changed the generator's batch state, restore original batch state.
   if (!already_in_batch_mode_) {
     DVLOG(1) << "Leaving Batch Mode.";
     connection_->packet_generator_.FinishBatchOperations();
   }
   DCHECK_EQ(already_in_batch_mode_,
             connection_->packet_generator_.InBatchMode());
 }
 
 }  // namespace net