Improve QUIC's SendAlgorithmSimulator to allow setting the delayed ack

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 115 matching lines @@
 
   void set_loss_correlation(float loss_correlation) {
     DCHECK_LT(loss_correlation, 1.0f);
     loss_correlation_ = loss_correlation;
   }
 
   void set_buffer_size(size_t buffer_size_bytes) {
     buffer_size_ = buffer_size_bytes;
   }
 
+  void set_delayed_ack_timer(QuicTime::Delta delayed_ack_timer) {
+    delayed_ack_timer_ = delayed_ack_timer;
+  }
+
   // Advance the time by |delta| without sending anything.
   void AdvanceTime(QuicTime::Delta delta);
 
   // Adds a pending sender.  The send will run when TransferBytes is called.
   // Adding two transfers with the same sender is unsupported.
   void AddTransfer(Sender* sender, size_t num_bytes);
 
   // Adds a pending sending to start at the specified time.
   void AddTransfer(Sender* sender, size_t num_bytes, QuicTime start_time);
 
@@ skipping 20 matching lines @@
   // and populates transfer if the send time is not infinite.
   PacketEvent NextSendEvent();
 
   // NextAckTime takes into account packet loss in both forward and reverse
   // direction, as well as delayed ack behavior.
   PacketEvent NextAckEvent();
 
   // Sets the next acked.
   QuicTime::Delta FindNextAcked(Transfer* transfer);
 
+  // Sets the |next_acked| packet for the |transfer| starting at the specified
+  // |last_acked|.  Returns QuicTime::Delta::Infinite and doesn't set
+  // |next_acked| if there is no ack after |last_acked|.
+  QuicTime::Delta FindNextAck(const Transfer* transfer,
+                              QuicPacketSequenceNumber last_acked,
+                              QuicPacketSequenceNumber* next_acked) const;
+
+  // Returns true if any of the packets |transfer| is waiting for less than
+  // next_acked have been lost.
+  bool HasRecentLostPackets(const Transfer* transfer,
+                            QuicPacketSequenceNumber next_acked) const;
+
   // Process all the acks that should have arrived by the current time, and
   // lose any packets that are missing.  Returns the number of bytes acked.
   void HandlePendingAck(Transfer* transfer);
 
   void SendDataNow(Transfer* transfer);
 
   // List of all pending transfers waiting to use the connection.
   std::vector<Transfer> pending_transfers_;
 
   MockClock* clock_;
   // Whether the next ack should be lost.
   bool lose_next_ack_;
   // The times acks are expected, assuming acks are not lost and every packet
   // is acked.
   std::list<SentPacket> sent_packets_;
 
   test::SimpleRandom simple_random_;
   float forward_loss_rate_;  // Loss rate on the forward path.
   float reverse_loss_rate_;  // Loss rate on the reverse path.
   float loss_correlation_;   // Likelihood the subsequent packet is lost.
   QuicBandwidth bandwidth_;
   QuicTime::Delta rtt_;
   size_t buffer_size_;       // In bytes.
+  QuicTime::Delta delayed_ack_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(SendAlgorithmSimulator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CONGESTION_CONTROL_SEND_ALGORITHM_SIMULATOR_H_