Change from re-transmitting an packet with a retransmit number to sending a new packet with a new s…

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 <algorithm>
+
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/quic_receipt_metrics_collector.h"
 #include "net/quic/congestion_control/quic_send_scheduler.h"
 #include "net/quic/quic_utils.h"
 
 using base::hash_map;
 using base::hash_set;
 using base::StringPiece;
 using std::list;
+using std::min;
 using std::vector;
 using std::set;
 
 /*
 DEFINE_int32(fake_packet_loss_percentage, 0,
             "The percentage of packets to drop.");
 DEFINE_int32(negotiated_timeout_us, net::kDefaultTimeout,
              "The default timeout for connections being closed");
 */
 
@@ skipping 154 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void QuicConnection::UpdatePacketInformationReceivedByPeer(
     const QuicAckFrame& incoming_ack) {
   QuicConnectionVisitorInterface::AckedPackets acked_packets;
 
-  // For tracking the lowest unacked packet, pick one we have not sent yet.
-  QuicPacketSequenceNumber lowest_unacked =
-      packet_creator_.sequence_number() + 1;
-
-  // If there's a packet between the next one we're sending and the
-  // highest one the peer has seen, that's our new lowest unacked.
-  if (incoming_ack.received_info.largest_received + 1 < lowest_unacked) {
-    lowest_unacked = incoming_ack.received_info.largest_received + 1;
-  }
+  // Initialize the lowest unacked packet to the lower of the next outgoing
+  // sequence number and the largest received packed in the incoming ack.
+  QuicPacketSequenceNumber lowest_unacked = min(
+      packet_creator_.sequence_number() + 1,
+      incoming_ack.received_info.largest_received + 1);
 
   // Go through the packets we have not received an ack for and see if this
   // incoming_ack shows they've been seen by the peer.
   UnackedPacketMap::iterator it = unacked_packets_.begin();
   while (it != unacked_packets_.end()) {
     if ((it->first < incoming_ack.received_info.largest_received &&
-         incoming_ack.received_info.missing_packets.find(it->first) ==
-         incoming_ack.received_info.missing_packets.end()) ||
+         !ContainsKey(incoming_ack.received_info.missing_packets, it->first)) ||
         it->first == incoming_ack.received_info.largest_received) {
       // This was either explicitly or implicitly acked.  Remove it from our
       // unacked packet list.
       DVLOG(1) << "Got an ack for " << it->first;
       // TODO(rch): This is inefficient and should be sped up.
       // The acked packet might be queued (if a resend had been attempted).
       for (QueuedPacketList::iterator q = queued_packets_.begin();
            q != queued_packets_.end(); ++q) {
         if (q->sequence_number == it->first) {
           queued_packets_.erase(q);
           break;
         }
       }
+      acked_packets.insert(it->first);
       delete it->second;
-      UnackedPacketMap::iterator tmp_it = it;
-      acked_packets.insert(it->first);
-      ++tmp_it;
-      unacked_packets_.erase(it);
-      it = tmp_it;
+      UnackedPacketMap::iterator it_tmp = it;
+      ++it;
+      unacked_packets_.erase(it_tmp);
     } else {
       // This is a packet which we planned on resending and has not been
       // seen at the time of this ack being sent out.  See if it's our new
       // lowest unacked packet.
       DVLOG(1) << "still missing " << it->first;
       if (it->first < lowest_unacked) {
         lowest_unacked = it->first;
       }
       ++it;
     }
@@ skipping 18 matching lines @@
       DCHECK_EQ(0u, non_retrans->size());
     }
     outgoing_ack_.sent_info.least_unacked = lowest_unacked;
   }
 }
 
 void QuicConnection::UpdatePacketInformationSentByPeer(
     const QuicAckFrame& incoming_ack) {
   // Iteratate through the packets which will the peer will not resend and
   // remove them from our missing list.
-  hash_set<QuicPacketSequenceNumber>::const_iterator it =
-      incoming_ack.sent_info.non_retransmiting.begin();
-  while (it != incoming_ack.sent_info.non_retransmiting.end()) {
-    outgoing_ack_.received_info.missing_packets.erase(*it);
-    DVLOG(1) << "no longer expecting " << *it;
-    ++it;
+  for (hash_set<QuicPacketSequenceNumber>::const_iterator it =
+           incoming_ack.sent_info.non_retransmiting.begin();
+       it != incoming_ack.sent_info.non_retransmiting.end(); ++it) {
+     DVLOG(1) << "no longer expecting " << *it;
+     outgoing_ack_.received_info.missing_packets.erase(*it);
   }
 
   // Make sure we also don't expect any packets lower than the peer's
   // last-packet-awaiting-ack
   if (incoming_ack.sent_info.least_unacked >
       largest_seen_least_packet_awaiting_ack_) {
     for (QuicPacketSequenceNumber i = largest_seen_least_packet_awaiting_ack_;
-         i < incoming_ack.sent_info.least_unacked;
-         ++i) {
+         i < incoming_ack.sent_info.least_unacked; ++i) {
       outgoing_ack_.received_info.missing_packets.erase(i);
     }
     largest_seen_least_packet_awaiting_ack_ =
         incoming_ack.sent_info.least_unacked;
   }
 
   // Possibly close any FecGroups which are now irrelevant
   CloseFecGroupsBefore(incoming_ack.sent_info.least_unacked + 1);
 }
 
@@ skipping 50 matching lines @@
     QuicStreamId id,
     StringPiece data,
     QuicStreamOffset offset,
     bool fin,
     QuicPacketSequenceNumber* last_packet) {
   vector<PacketPair> packets;
   packet_creator_.DataToStream(id, data, offset, fin, &packets);
   DCHECK_LT(0u, packets.size());
 
   for (size_t i = 0; i < packets.size(); ++i) {
-    SendPacket(packets[i].first, packets[i].second, true, false);
+    // Resend is false for FEC packets.
+    SendPacket(packets[i].first,
+               packets[i].second,
+               !packets[i].second->IsFecPacket(),
+               false,
+               false);
     // TODO(alyssar) either only buffer this up if we send successfully,
     // and make the upper levels deal with backup, or handle backup here.
     unacked_packets_.insert(packets[i]);
   }
 
   if (last_packet != NULL) {
     *last_packet = packets[packets.size() - 1].first;
   }
   return data.size();
 }
 
 void QuicConnection::SendRstStream(QuicStreamId id,
                                    QuicErrorCode error,
                                    QuicStreamOffset offset) {
   PacketPair packetpair = packet_creator_.ResetStream(id, offset, error);
 
-  SendPacket(packetpair.first, packetpair.second, true, false);
+  SendPacket(packetpair.first, packetpair.second, true, false, false);
   unacked_packets_.insert(packetpair);
 }
 
 void QuicConnection::ProcessUdpPacket(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet) {
   last_packet_revived_ = false;
   last_size_ = packet.length();
   framer_.ProcessPacket(self_address, peer_address, packet);
 
   MaybeProcessRevivedPacket();
 }
 
 bool QuicConnection::OnCanWrite() {
   write_blocked_ = false;
   size_t num_queued_packets = queued_packets_.size() + 1;
   while (!write_blocked_ && !helper_->IsSendAlarmSet() &&
          !queued_packets_.empty()) {
     // Ensure that from one iteration of this loop to the next we
     // succeeded in sending a packet so we don't infinitely loop.
     // TODO(rch): clean up and close the connection if we really hit this.
     DCHECK_LT(queued_packets_.size(), num_queued_packets);
     num_queued_packets = queued_packets_.size();
     QueuedPacket p = queued_packets_.front();
     queued_packets_.pop_front();
-    SendPacket(p.sequence_number, p.packet, p.resend, false);
+    SendPacket(p.sequence_number, p.packet, p.resend, false, p.retransmit);
   }
   return !write_blocked_;
 }
 
 void QuicConnection::AckPacket(const QuicPacketHeader& header) {
   QuicPacketSequenceNumber sequence_number = header.packet_sequence_number;
   if (sequence_number > outgoing_ack_.received_info.largest_received) {
     // We've got a new high sequence number.  Note any new intermediate missing
     // packets, and update the last_ack data.
     for (QuicPacketSequenceNumber i =
@@ skipping 15 matching lines @@
     SendAck();
   }
 }
 
 void QuicConnection::MaybeResendPacket(
     QuicPacketSequenceNumber sequence_number) {
   UnackedPacketMap::iterator it = unacked_packets_.find(sequence_number);
 
   if (it != unacked_packets_.end()) {
     DVLOG(1) << "Resending unacked packet " << sequence_number;
-    framer_.IncrementRetransmitCount(it->second);
-    SendPacket(sequence_number, it->second, true, false);
+    QuicPacket* packet = it->second;
+    unacked_packets_.erase(it);
+    // Re-frame the packet with a new sequence number for resend.
+    QuicPacketSequenceNumber new_sequence_number  =
+        packet_creator_.SetNewSequenceNumber(packet);
+    // Clear the FEC group.
+    framer_.WriteFecGroup(0u, packet);
+    unacked_packets_[new_sequence_number] = packet;
+    SendPacket(new_sequence_number, packet, true, false, true);
   } else {
     DVLOG(2) << "alarm fired for " << sequence_number
              << " but it has been acked";
   }
 }
 
 bool QuicConnection::SendPacket(QuicPacketSequenceNumber sequence_number,
                                 QuicPacket* packet,
-                                bool resend,
-                                bool force) {
+                                bool should_resend,
+                                bool force,
+                                bool is_retransmit) {
   // If this packet is being forced, don't bother checking to see if we should
   // write, just write.
   if (!force) {
     // If we can't write, then simply queue the packet.
     if (write_blocked_ || helper_->IsSendAlarmSet()) {
-      queued_packets_.push_back(QueuedPacket(sequence_number, packet, resend));
+      queued_packets_.push_back(
+          QueuedPacket(sequence_number, packet, should_resend, is_retransmit));
       return false;
     }
 
-    int delay = scheduler_->TimeUntilSend(resend);
+    int delay = scheduler_->TimeUntilSend(should_resend);
     // If the scheduler requires a delay, then we can not send this packet now.
     if (delay > 0) {
       helper_->SetSendAlarm(delay);
-      queued_packets_.push_back(QueuedPacket(sequence_number, packet, resend));
+      queued_packets_.push_back(
+          QueuedPacket(sequence_number, packet, should_resend, is_retransmit));
       return false;
     }
   }
-  if (resend) {
+  if (should_resend) {
     helper_->SetResendAlarm(sequence_number, kDefaultResendTimeMs * 1000);
     // The second case should never happen in the real world, but does here
     // because we sometimes send out of order to validate corner cases.
     if (outgoing_ack_.sent_info.least_unacked == 0 ||
         sequence_number < outgoing_ack_.sent_info.least_unacked) {
       outgoing_ack_.sent_info.least_unacked = sequence_number;
     }
   } else {
     if (outgoing_ack_.sent_info.least_unacked!= 0 &&
         sequence_number > outgoing_ack_.sent_info.least_unacked) {
       outgoing_ack_.sent_info.non_retransmiting.insert(sequence_number);
     }
   }
 
   // Just before we send the packet to the wire, update the transmission time.
   framer_.WriteTransmissionTime(clock_->NowInUsec(), packet);
 
   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPacket(*packet));
   int error;
-  int rv = helper_->WritePacketToWire(sequence_number, *encrypted, resend,
-                                      &error);
+  int rv = helper_->WritePacketToWire(sequence_number, *encrypted,
+                                      should_resend, &error);
+  DLOG(INFO) << "Sending packet : "
+             << (should_resend ? "data bearing " : " ack only ")
+             << "packet " << sequence_number;
   if (rv == -1) {
     if (error == ERR_IO_PENDING) {
       write_blocked_ = true;
-      queued_packets_.push_front(QueuedPacket(sequence_number, packet, resend));
+      queued_packets_.push_front(
+          QueuedPacket(sequence_number, packet, should_resend, is_retransmit));
       return false;
     }
   }
 
   time_of_last_packet_us_ = clock_->NowInUsec();
   DVLOG(1) << "last packet: " << time_of_last_packet_us_;
 
-  scheduler_->SentPacket(sequence_number, packet->length(),
-                         framer_.GetRetransmitCount(packet) != 0);
-  if (!resend) delete packet;
+  scheduler_->SentPacket(sequence_number, packet->length(), is_retransmit);
+  if (!should_resend) delete packet;
   return true;
 }
 
 bool QuicConnection::ShouldSimulateLostPacket() {
   // TODO(rch): enable this
   return false;
   /*
   return FLAGS_fake_packet_loss_percentage > 0 &&
       random_->Rand32() % 100 < FLAGS_fake_packet_loss_percentage;
   */
 }
 
 void QuicConnection::SendAck() {
   if (!collector_->GenerateCongestionInfo(&outgoing_ack_.congestion_info)) {
     outgoing_ack_.congestion_info.type = kNone;
   }
   DVLOG(1) << "Sending ack " << outgoing_ack_;
 
   PacketPair packetpair = packet_creator_.AckPacket(&outgoing_ack_);
-  SendPacket(packetpair.first, packetpair.second, false, false);
+  SendPacket(packetpair.first, packetpair.second, false, false, false);
 }
 
 void QuicConnection::MaybeProcessRevivedPacket() {
   QuicFecGroup* group = GetFecGroup();
   if (group == NULL || !group->CanRevive()) {
     return;
   }
   DCHECK(!revived_payload_.get());
   revived_payload_.reset(new char[kMaxPacketSize]);
   size_t len = group->Revive(&revived_header_, revived_payload_.get(),
@@ skipping 21 matching lines @@
 
 void QuicConnection::SendConnectionClose(QuicErrorCode error) {
   DLOG(INFO) << "Force closing with error " << QuicUtils::ErrorToString(error)
              << " (" << error << ")";
   QuicConnectionCloseFrame frame;
   frame.error_code = error;
   frame.ack_frame = outgoing_ack_;
 
   PacketPair packetpair = packet_creator_.CloseConnection(&frame);
   // There's no point in resending this: we're closing the connection.
-  SendPacket(packetpair.first, packetpair.second, false, true);
+  SendPacket(packetpair.first, packetpair.second, false, true, false);
   connected_ = false;
   visitor_->ConnectionClose(error, false);
 }
 
 void QuicConnection::CloseFecGroupsBefore(
     QuicPacketSequenceNumber sequence_number) {
   FecGroupMap::iterator it = group_map_.begin();
   while (it != group_map_.end()) {
     // If this is the current group or the group doesn't protect this packet
     // we can ignore it.
@@ skipping 20 matching lines @@
            << " delta:" << delta_in_us;
   if (delta_in_us >= timeout_us_) {
     SendConnectionClose(QUIC_CONNECTION_TIMED_OUT);
     return true;
   }
   helper_->SetTimeoutAlarm(timeout_us_ - delta_in_us);
   return false;
 }
 
 }  // namespace net