A fix to QUIC's test only SendAlgorithmSimulator to ensure it treats

net/quic/congestion_control/send_algorithm_simulator.cc

 // Copyright 2014 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/congestion_control/send_algorithm_simulator.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
@@ skipping 177 matching lines @@
   for (list<SentPacket>::const_iterator it = sent_packets_.begin();
        it != sent_packets_.end(); ++it) {
     if (transfer != it->transfer) {
       continue;
     }
     // Skip over any packets less than or equal to last_acked.
     if (it->sequence_number <= last_acked) {
       continue;
     }
     // Lost packets don't trigger an ack.
-    if (it->ack_time == QuicTime::Zero()) {
+    if (it->lost) {
       continue;
     }
     DCHECK_LT(*next_acked, it->sequence_number);
     // Consider a delayed ack for the current next_acked.
     if (ack_delay < it->ack_time.Subtract(clock_->Now())) {
       break;
     }
     *next_acked = it->sequence_number;
     ack_delay = it->ack_time.Subtract(clock_->Now());
     if (HasRecentLostPackets(transfer, *next_acked) ||
@@ skipping 12 matching lines @@
 
 bool SendAlgorithmSimulator::HasRecentLostPackets(
     const Transfer* transfer, QuicPacketSequenceNumber next_acked) const {
   QuicPacketSequenceNumber last_packet = transfer->sender->last_acked;
   for (list<SentPacket>::const_iterator it = sent_packets_.begin();
        it != sent_packets_.end() && it->sequence_number < next_acked; ++it) {
     if (transfer != it->transfer) {
       continue;
     }
     // Lost packets don't trigger an ack.
-    if (it->ack_time == QuicTime::Zero()) {
+    if (it->lost) {
       return true;
     }
     // Buffer dropped packets are skipped automatically, but still end up
     // being lost and cause acks to be sent immediately.
     if (it->sequence_number > last_packet + 1) {
       return true;
     }
     last_packet = it->sequence_number;
   }
   return false;
 }
 
 void SendAlgorithmSimulator::HandlePendingAck(Transfer* transfer) {
   Sender* sender  = transfer->sender;
   DCHECK_LT(sender->last_acked, sender->next_acked);
   SendAlgorithmInterface::CongestionMap acked_packets;
   SendAlgorithmInterface::CongestionMap lost_packets;
   DVLOG(1) << "Acking packets from:" << sender->last_acked
              << " to " << sender->next_acked
              << " bytes_in_flight:" << transfer->bytes_in_flight
              << " Now():" << (clock_->Now().ToDebuggingValue() / 1000) << "ms";
   // Some entries may be missing from the sent_packets_ array, if they were
   // dropped due to buffer overruns.
-  SentPacket largest_observed(0, QuicTime::Zero(), QuicTime::Zero(), NULL);
+  SentPacket largest_observed;
   list<SentPacket>::iterator it = sent_packets_.begin();
   while (sender->last_acked < sender->next_acked) {
     ++sender->last_acked;
     TransmissionInfo info = TransmissionInfo();
     info.bytes_sent = kPacketSize;
     info.in_flight = true;
     // Find the next SentPacket for this transfer.
     while (it->transfer != transfer) {
       DCHECK(it != sent_packets_.end());
       ++it;
     }
     // If it's missing from the array, it's a loss.
     if (it->sequence_number > sender->last_acked) {
       DVLOG(1) << "Lost packet:" << sender->last_acked
                << " dropped by buffer overflow.";
       lost_packets[sender->last_acked] = info;
       continue;
     }
-    if (it->ack_time.IsInitialized()) {
+    if (it->lost) {
+      lost_packets[sender->last_acked] = info;
+    } else {
       acked_packets[sender->last_acked] = info;
-    } else {
-      lost_packets[sender->last_acked] = info;
     }
     // This packet has been acked or lost, remove it from sent_packets_.
     largest_observed = *it;
     sent_packets_.erase(it++);
   }
 
   DCHECK(largest_observed.ack_time.IsInitialized());
   DVLOG(1) << "Updating RTT from send_time:"
            << largest_observed.send_time.ToDebuggingValue() << " to ack_time:"
            << largest_observed.ack_time.ToDebuggingValue();
@@ skipping 15 matching lines @@
   transfer->bytes_lost += lost_packets.size() * kPacketSize;
   if (transfer->bytes_acked >= transfer->num_bytes) {
     // Remove completed transfers and record transfer bandwidth.
     QuicTime::Delta transfer_time =
         clock_->Now().Subtract(transfer->start_time);
     sender->last_transfer_loss_rate = static_cast<float>(transfer->bytes_lost) /
         (transfer->bytes_lost + transfer->bytes_acked);
     sender->last_transfer_bandwidth =
         QuicBandwidth::FromBytesAndTimeDelta(transfer->num_bytes,
                                              transfer_time);
+    DCHECK_GE(bandwidth_.ToBitsPerSecond(),
+              sender->last_transfer_bandwidth.ToBitsPerSecond());
     for (vector<Transfer>::iterator it = pending_transfers_.begin();
          it != pending_transfers_.end(); ++it) {
       if (transfer == &(*it)) {
         pending_transfers_.erase(it);
         break;
       }
     }
   }
 }
 
 void SendAlgorithmSimulator::SendDataNow(Transfer* transfer) {
   Sender* sender  = transfer->sender;
   ++sender->last_sent;
   DVLOG(1) << "Sending packet:" << sender->last_sent
            << " bytes_in_flight:" << transfer->bytes_in_flight
            << " Now():" << (clock_->Now().ToDebuggingValue() / 1000) << "ms";
   sender->send_algorithm->OnPacketSent(
       clock_->Now(), transfer->bytes_in_flight,
       sender->last_sent, kPacketSize, HAS_RETRANSMITTABLE_DATA);
   // Lose the packet immediately if the buffer is full.
   if (sent_packets_.size() * kPacketSize < buffer_size_) {
     // TODO(ianswett): This buffer simulation is an approximation.
     // An ack time of zero means loss.
     bool packet_lost =
         forward_loss_rate_ * kuint64max > simple_random_.RandUint64();
     // Handle correlated loss.
-    if (!sent_packets_.empty() &&
-        !sent_packets_.back().ack_time.IsInitialized() &&
+    if (!sent_packets_.empty() && sent_packets_.back().lost &&
         loss_correlation_ * kuint64max > simple_random_.RandUint64()) {
       packet_lost = true;
     }
     DVLOG(1) << "losing packet:" << sender->last_sent
              << " due to random loss.";
 
     // If the number of bytes in flight are less than the bdp, there's
     // no buffering delay.  Bytes lost from the buffer are not counted.
     QuicByteCount bdp = bandwidth_.ToBytesPerPeriod(rtt_);
     QuicTime ack_time = clock_->Now().Add(rtt_);
     if (kPacketSize > bdp) {
       ack_time = ack_time.Add(bandwidth_.TransferTime(kPacketSize - bdp));
     }
     QuicTime queue_ack_time = sent_packets_.empty() ? QuicTime::Zero() :
         sent_packets_.back().ack_time.Add(bandwidth_.TransferTime(kPacketSize));
     ack_time = QuicTime::Max(ack_time, queue_ack_time);
-    // If the packet is lost, give it an ack time of Zero.
     sent_packets_.push_back(SentPacket(
-        sender->last_sent, clock_->Now(),
-        packet_lost ? QuicTime::Zero() : ack_time, transfer));
+        sender->last_sent, clock_->Now(), ack_time, packet_lost, transfer));
   } else {
     DVLOG(1) << "losing packet:" << sender->last_sent
              << " because the buffer was full.";
   }
   transfer->bytes_in_flight += kPacketSize;
 }
 
 // Advance the time by |delta| without sending anything.
 void SendAlgorithmSimulator::AdvanceTime(QuicTime::Delta delta) {
   clock_->AdvanceTime(delta);
 }
 
 }  // namespace net