Land Recent QUIC Changes.

net/quic/congestion_control/send_algorithm_simulator.h

Index: net/quic/congestion_control/send_algorithm_simulator.h
diff --git a/net/quic/congestion_control/send_algorithm_simulator.h b/net/quic/congestion_control/send_algorithm_simulator.h
new file mode 100644
index 0000000000000000000000000000000000000000..30854d698dcc732a4d133d308e8e871791740a81
--- /dev/null
+++ b/net/quic/congestion_control/send_algorithm_simulator.h
@@ -0,0 +1,133 @@
+// 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>
+
+#include "base/basictypes.h"
+#include "net/quic/congestion_control/send_algorithm_interface.h"
+#include "net/quic/quic_protocol.h"
+#include "net/quic/quic_time.h"
+#include "net/quic/test_tools/mock_clock.h"
+#include "net/quic/test_tools/quic_test_utils.h"
+
+namespace net {
+
+class NET_EXPORT_PRIVATE SendAlgorithmSimulator {
+ public:
+  struct SentPacket {
+    SentPacket(QuicPacketSequenceNumber sequence_number,
+               QuicTime send_time,
+               QuicTime ack_time) :
+        sequence_number(sequence_number),
+        send_time(send_time),
+        ack_time(ack_time) {}
+    QuicPacketSequenceNumber sequence_number;
+    QuicTime send_time;
+    QuicTime ack_time;
+  };
+
+  // |rtt_stats| should be the same RttStats used by the |send_algorithm|.
+  SendAlgorithmSimulator(SendAlgorithmInterface* send_algorithm,
+                         MockClock* clock_,
+                         RttStats* rtt_stats,
+                         QuicBandwidth bandwidth,
+                         QuicTime::Delta rtt);
+  ~SendAlgorithmSimulator();
+
+  void set_forward_loss_rate(float loss_rate) {
+    DCHECK_LT(loss_rate, 1.0f);
+    forward_loss_rate_ = loss_rate;
+  }
+
+  void set_reverse_loss_rate(float loss_rate) {
+    DCHECK_LT(loss_rate, 1.0f);
+    reverse_loss_rate_ = loss_rate;
+  }
+
+  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;
+  }
+
+  // Sends the specified number of bytes as quickly as possible and returns the
+  // average bandwidth in bytes per second.  The time elapsed is based on
+  // waiting for all acks to arrive.
+  QuicBandwidth SendBytes(size_t num_bytes);
+
+  const RttStats* rtt_stats() { return rtt_stats_; }

[wtc, 2014/06/16 22:05:53]

Nit: this getter method should also be const.

[ramant (doing other things), 2014/06/16 23:46:52]

Done.

+
+  QuicByteCount max_cwnd() const { return max_cwnd_; }
+  QuicByteCount min_cwnd() const { return min_cwnd_; }
+  QuicByteCount max_cwnd_drop() const { return max_cwnd_drop_; }
+  QuicByteCount last_cwnd() const { return last_cwnd_; }
+
+ private:
+  // NextAckTime takes into account packet loss in both forward and reverse
+  // direction, as well as delayed ack behavior.
+  QuicTime::Delta NextAckDelta();
+
+  // Whether all packets in sent_packets_ are lost.
+  bool AllPacketsLost();
+
+  // Sets the next acked.
+  void FindNextAcked();
+
+  // 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.
+  int HandlePendingAck();
+
+  void SendDataNow();
+  void RecordStats();
+
+  // Advance the time by |delta| without sending anything.
+  void AdvanceTime(QuicTime::Delta delta);
+
+  // Elapsed time from the start of the connection.
+  QuicTime ElapsedTime();
+
+  SendAlgorithmInterface* send_algorithm_;
+  MockClock* clock_;
+  RttStats* rtt_stats_;
+  // Next packet sequence number to send.
+  QuicPacketSequenceNumber next_sent_;
+  // Last packet sequence number acked.
+  QuicPacketSequenceNumber last_acked_;
+  // Packet sequence number to ack up to.
+  QuicPacketSequenceNumber next_acked_;
+  // Whether the next ack should be lost.
+  bool lose_next_ack_;
+  QuicByteCount bytes_in_flight_;
+  // 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.
+
+  // Stats collected for understanding the congestion control.
+  QuicByteCount max_cwnd_;
+  QuicByteCount min_cwnd_;
+  QuicByteCount max_cwnd_drop_;
+  QuicByteCount last_cwnd_;
+
+  DISALLOW_COPY_AND_ASSIGN(SendAlgorithmSimulator);
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_CONGESTION_CONTROL_SEND_ALGORITHM_SIMULATOR_H_