QUIC test only change to add track the observed loss rate in

net/quic/congestion_control/send_algorithm_simulator.h

 // 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.
 
 // A test only class to enable simulations of send algorithms.
 
 #ifndef NET_QUIC_CONGESTION_CONTROL_SEND_ALGORITHM_SIMULATOR_H_
 #define NET_QUIC_CONGESTION_CONTROL_SEND_ALGORITHM_SIMULATOR_H_
 
 #include <algorithm>
@@ skipping 22 matching lines @@
       QuicByteCount cwnd = send_algorithm->GetCongestionWindow();
       max_cwnd = std::max(max_cwnd, cwnd);
       min_cwnd = std::min(min_cwnd, cwnd);
       if (last_cwnd > cwnd) {
         max_cwnd_drop = std::max(max_cwnd_drop, last_cwnd - cwnd);
       }
       last_cwnd = cwnd;
     }
 
     std::string DebugString() {
-      return StringPrintf("observed goodput(bytes/s):%" PRId64 " cwnd:%" PRIu64
+      return StringPrintf("observed goodput(bytes/s):%" PRId64
+                          " loss rate:%f"
+                          " cwnd:%" PRIu64
                           " max_cwnd:%" PRIu64 " min_cwnd:%" PRIu64
                           " max_cwnd_drop:%" PRIu64,
                           last_transfer_bandwidth.ToBytesPerSecond(),
+                          last_transfer_loss_rate,
                           send_algorithm->GetCongestionWindow(),
                           max_cwnd, min_cwnd, max_cwnd_drop);
     }
 
     SendAlgorithmInterface* send_algorithm;
     RttStats* rtt_stats;
 
     // Last sequence number the sender sent.
     QuicPacketSequenceNumber last_sent;
     // Last packet sequence number acked.
     QuicPacketSequenceNumber last_acked;
     // Packet sequence number to ack up to.
     QuicPacketSequenceNumber next_acked;
 
     // Stats collected for understanding the congestion control.
     QuicByteCount max_cwnd;
     QuicByteCount min_cwnd;
     QuicByteCount max_cwnd_drop;
     QuicByteCount last_cwnd;
 
     QuicBandwidth last_transfer_bandwidth;
+    float last_transfer_loss_rate;
   };
 
   struct Transfer {
     Transfer(Sender* sender, QuicByteCount num_bytes, QuicTime start_time)
         : sender(sender),
           num_bytes(num_bytes),
           bytes_acked(0),
+          bytes_lost(0),
           bytes_in_flight(0),
           start_time(start_time) {}
 
     Sender* sender;
     QuicByteCount num_bytes;
     QuicByteCount bytes_acked;
+    QuicByteCount bytes_lost;
     QuicByteCount bytes_in_flight;
     QuicTime start_time;
   };
 
   struct SentPacket {
     SentPacket(QuicPacketSequenceNumber sequence_number,
                QuicTime send_time,
                QuicTime ack_time,
                Transfer* transfer)
         : sequence_number(sequence_number),
@@ skipping 99 matching lines @@
   QuicBandwidth bandwidth_;
   QuicTime::Delta rtt_;
   size_t buffer_size_;       // In bytes.
 
   DISALLOW_COPY_AND_ASSIGN(SendAlgorithmSimulator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CONGESTION_CONTROL_SEND_ALGORITHM_SIMULATOR_H_