Minor change of QUIC's RTO behavior to not change the congestion window

net/quic/quic_sent_packet_manager.cc

 // Copyright 2013 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_sent_packet_manager.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/congestion_control/pacing_sender.h"
 #include "net/quic/quic_ack_notifier_manager.h"
@@ skipping 549 matching lines @@
                                      has_retransmittable_data)) {
     return;
   }
   packet_history_map_[sequence_number] = new SendAlgorithmInterface::SentPacket(
       bytes, sent_time, has_retransmittable_data);
   pending_packets_.insert(sequence_number);
   CleanupPacketHistory();
 }
 
 void QuicSentPacketManager::OnRetransmissionTimeout() {
-  ++consecutive_rto_count_;
-  send_algorithm_->OnRetransmissionTimeout();
   // Abandon all pending packets to ensure the congestion window
   // opens up before we attempt to retransmit packets.
   for (SequenceNumberSet::const_iterator it = pending_packets_.begin();
        it != pending_packets_.end(); ++it) {
     QuicPacketSequenceNumber sequence_number = *it;
     DCHECK(ContainsKey(packet_history_map_, sequence_number));
     send_algorithm_->OnPacketAbandoned(
         sequence_number, packet_history_map_[sequence_number]->bytes_sent());
   }
   pending_packets_.clear();
 
   // Attempt to send all the unacked packets when the RTO fires, let the
   // congestion manager decide how many to send immediately and the remaining
   // packets will be queued for future sending.
   DVLOG(1) << "OnRetransmissionTimeout() fired with "
            << unacked_packets_.size() << " unacked packets.";
 
   // Retransmit any packet with retransmittable frames.
+  bool packets_retransmitted = false;
   for (UnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it) {
     if (it->second.retransmittable_frames != NULL) {
+      packets_retransmitted = true;
       MarkForRetransmission(it->first, RTO_RETRANSMISSION);
     }
   }
+
+  // Only inform the sent packet manager of an RTO if data was retransmitted.
+  if (packets_retransmitted) {
+    ++consecutive_rto_count_;
+    send_algorithm_->OnRetransmissionTimeout();
+  }
 }
 
 QuicTime QuicSentPacketManager::OnAbandonFecTimeout() {
   // Abandon all the FEC packets older than the current RTO, then reschedule
   // the alarm if there are more pending fec packets.
   QuicTime::Delta retransmission_delay = GetRetransmissionDelay();
   QuicTime max_send_time =
       clock_->ApproximateNow().Subtract(retransmission_delay);
   while (!unacked_fec_packets_.empty()) {
     UnackedFecPacketMap::iterator it = unacked_fec_packets_.begin();
@@ skipping 243 matching lines @@
     return;
   }
 
   using_pacing_ = true;
   send_algorithm_.reset(
       new PacingSender(send_algorithm_.release(),
                        QuicTime::Delta::FromMicroseconds(1)));
 }
 
 }  // namespace net