4 files changed, 101 insertions, 39 deletions

diff --git a/net/quic/test_tools/quic_connection_peer.cc b/net/quic/test_tools/quic_connection_peer.cc
index 1411e5b..7befa32 100644
--- a/net/quic/test_tools/quic_connection_peer.cc
+++ b/net/quic/test_tools/quic_connection_peer.cc
@@ -4,9 +4,10 @@
 
 #include "net/quic/test_tools/quic_connection_peer.h"
 
+#include "base/stl_util.h"
 #include "net/quic/congestion_control/quic_congestion_manager.h"
-#include "net/quic/congestion_control/quic_receipt_metrics_collector.h"
-#include "net/quic/congestion_control/quic_send_scheduler.h"
+#include "net/quic/congestion_control/receive_algorithm_interface.h"
+#include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/quic_connection.h"
 
 namespace net {
@@ -18,15 +19,17 @@ void QuicConnectionPeer::SendAck(QuicConnection* connection) {
 }
 
 // static
-void QuicConnectionPeer::SetCollector(QuicConnection* connection,
-                                      QuicReceiptMetricsCollector* collector) {
-  connection->congestion_manager_.collector_.reset(collector);
+void QuicConnectionPeer::SetReceiveAlgorithm(
+    QuicConnection* connection,
+    ReceiveAlgorithmInterface* receive_algorithm) {
+  connection->congestion_manager_.receive_algorithm_.reset(receive_algorithm);
 }
 
 // static
-void QuicConnectionPeer::SetScheduler(QuicConnection* connection,
-                                      QuicSendScheduler* scheduler) {
-  connection->congestion_manager_.scheduler_.reset(scheduler);
+void QuicConnectionPeer::SetSendAlgorithm(
+    QuicConnection* connection,
+    SendAlgorithmInterface* send_algorithm) {
+  connection->congestion_manager_.send_algorithm_.reset(send_algorithm);
 }
 
 // static
@@ -50,5 +53,27 @@ bool QuicConnectionPeer::GetReceivedTruncatedAck(QuicConnection* connection) {
     return connection->received_truncated_ack_;
 }
 
+// static
+size_t QuicConnectionPeer::GetNumRetransmissionTimeouts(
+    QuicConnection* connection) {
+  return connection->retransmission_timeouts_.size();
+}
+
+// static
+bool QuicConnectionPeer::IsSavedForRetransmission(
+    QuicConnection* connection,
+    QuicPacketSequenceNumber sequence_number) {
+  return ContainsKey(connection->retransmission_map_, sequence_number);
+}
+
+// static
+size_t QuicConnectionPeer::GetRetransmissionCount(
+    QuicConnection* connection,
+    QuicPacketSequenceNumber sequence_number) {
+  QuicConnection::RetransmissionMap::iterator it =
+      connection->retransmission_map_.find(sequence_number);
+  return it->second.number_retransmissions;
+}
+
 }  // namespace test
 }  // namespace net
diff --git a/net/quic/test_tools/quic_connection_peer.h b/net/quic/test_tools/quic_connection_peer.h
index 46b20929..deb313e0 100644
--- a/net/quic/test_tools/quic_connection_peer.h
+++ b/net/quic/test_tools/quic_connection_peer.h
@@ -6,6 +6,7 @@
 #define NET_QUIC_TEST_TOOLS_QUIC_CONNECTION_PEER_H_
 
 #include "base/basictypes.h"
+#include "net/quic/quic_protocol.h"
 
 namespace net {
 
@@ -13,8 +14,8 @@ struct QuicAckFrame;
 class QuicConnection;
 class QuicConnectionVisitorInterface;
 class QuicPacketCreator;
-class QuicReceiptMetricsCollector;
-class QuicSendScheduler;
+class ReceiveAlgorithmInterface;
+class SendAlgorithmInterface;
 
 namespace test {
 
@@ -23,11 +24,11 @@ class QuicConnectionPeer {
  public:
   static void SendAck(QuicConnection* connection);
 
-  static void SetCollector(QuicConnection* connection,
-                           QuicReceiptMetricsCollector* collector);
+  static void SetReceiveAlgorithm(QuicConnection* connection,
+                                  ReceiveAlgorithmInterface* receive_algorithm);
 
-  static void SetScheduler(QuicConnection* connection,
-                           QuicSendScheduler* scheduler);
+  static void SetSendAlgorithm(QuicConnection* connection,
+                               SendAlgorithmInterface* send_algorithm);
 
   static QuicAckFrame* GetOutgoingAck(QuicConnection* connection);
 
@@ -38,6 +39,16 @@ class QuicConnectionPeer {
 
   static bool GetReceivedTruncatedAck(QuicConnection* connection);
 
+  static size_t GetNumRetransmissionTimeouts(QuicConnection* connection);
+
+  static bool IsSavedForRetransmission(
+      QuicConnection* connection,
+      QuicPacketSequenceNumber sequence_number);
+
+  static size_t GetRetransmissionCount(
+      QuicConnection* connection,
+      QuicPacketSequenceNumber sequence_number);
+
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicConnectionPeer);
 };
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index 634218f..c53f797 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -50,6 +50,17 @@ void FramerVisitorCapturingAcks::OnCongestionFeedbackFrame(
   feedback_.reset(new QuicCongestionFeedbackFrame(frame));
 }
 
+FramerVisitorCapturingPublicReset::FramerVisitorCapturingPublicReset() {
+}
+
+FramerVisitorCapturingPublicReset::~FramerVisitorCapturingPublicReset() {
+}
+
+void FramerVisitorCapturingPublicReset::OnPublicResetPacket(
+    const QuicPublicResetPacket& public_reset) {
+  public_reset_packet_ = public_reset;
+}
+
 MockConnectionVisitor::MockConnectionVisitor() {
 }
 
@@ -94,11 +105,10 @@ PacketSavingConnection::~PacketSavingConnection() {
   STLDeleteElements(&packets_);
 }
 
-bool PacketSavingConnection::SendPacket(QuicPacketSequenceNumber number,
-                                        QuicPacket* packet,
-                                        bool should_retransmit,
-                                        bool force,
-                                        bool is_retransmission) {
+bool PacketSavingConnection::SendOrQueuePacket(
+    QuicPacketSequenceNumber sequence_number,
+    QuicPacket* packet,
+    bool force) {
   packets_.push_back(packet);
   return true;
 }
@@ -112,11 +122,10 @@ MockSession::MockSession(QuicConnection* connection, bool is_server)
 MockSession::~MockSession() {
 }
 
-MockScheduler::MockScheduler()
-    : QuicSendScheduler(NULL, kFixRate) {
+MockSendAlgorithm::MockSendAlgorithm() {
 }
 
-MockScheduler::~MockScheduler() {
+MockSendAlgorithm::~MockSendAlgorithm() {
 }
 
 namespace {
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index 0b2a67a..a269693 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -7,7 +7,7 @@
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
-#include "net/quic/congestion_control/quic_send_scheduler.h"
+#include "net/quic/congestion_control/send_algorithm_interface.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_session.h"
@@ -49,8 +49,7 @@ class MockFramerVisitor : public QuicFramerVisitorInterface {
   ~MockFramerVisitor();
 
   MOCK_METHOD1(OnError, void(QuicFramer* framer));
-  MOCK_METHOD2(OnPacket, void(const IPEndPoint& self_address,
-                              const IPEndPoint& peer_address));
+  MOCK_METHOD0(OnPacket, void());
   MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header));
   MOCK_METHOD0(OnRevivedPacket, void());
   // The constructor set this up to return true by default.
@@ -75,8 +74,7 @@ class NoOpFramerVisitor : public QuicFramerVisitorInterface {
   NoOpFramerVisitor() {}
 
   virtual void OnError(QuicFramer* framer) OVERRIDE {}
-  virtual void OnPacket(const IPEndPoint& self_address,
-                        const IPEndPoint& peer_address) OVERRIDE {}
+  virtual void OnPacket() OVERRIDE {}
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) OVERRIDE {}
   virtual void OnRevivedPacket() OVERRIDE {}
@@ -120,6 +118,22 @@ class FramerVisitorCapturingAcks : public NoOpFramerVisitor {
   DISALLOW_COPY_AND_ASSIGN(FramerVisitorCapturingAcks);
 };
 
+class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
+ public:
+  FramerVisitorCapturingPublicReset();
+  virtual ~FramerVisitorCapturingPublicReset();
+
+  virtual void OnPublicResetPacket(
+      const QuicPublicResetPacket& packet) OVERRIDE;
+
+  const QuicPublicResetPacket public_reset_packet() {
+    return public_reset_packet_;
+  }
+
+ private:
+  QuicPublicResetPacket public_reset_packet_;
+};
+
 class MockConnectionVisitor : public QuicConnectionVisitorInterface {
  public:
   MockConnectionVisitor();
@@ -190,11 +204,9 @@ class PacketSavingConnection : public MockConnection {
   PacketSavingConnection(QuicGuid guid, IPEndPoint address);
   virtual ~PacketSavingConnection();
 
-  virtual bool SendPacket(QuicPacketSequenceNumber number,
-                          QuicPacket* packet,
-                          bool should_retransmit,
-                          bool force,
-                          bool is_retransmission) OVERRIDE;
+  virtual bool SendOrQueuePacket(QuicPacketSequenceNumber sequence_number,
+                                 QuicPacket* packet,
+                                 bool force) OVERRIDE;
 
   std::vector<QuicPacket*> packets_;
 
@@ -226,17 +238,22 @@ class MockSession : public QuicSession {
   DISALLOW_COPY_AND_ASSIGN(MockSession);
 };
 
-class MockScheduler : public QuicSendScheduler {
+class MockSendAlgorithm : public SendAlgorithmInterface {
  public:
-  MockScheduler();
-  virtual ~MockScheduler();
-
+  MockSendAlgorithm();
+  virtual ~MockSendAlgorithm();
+
+  MOCK_METHOD2(OnIncomingQuicCongestionFeedbackFrame,
+               void(const QuicCongestionFeedbackFrame&, const SentPacketsMap&));
+  MOCK_METHOD3(OnIncomingAck,
+               void(QuicPacketSequenceNumber, QuicByteCount, QuicTime::Delta));
+  MOCK_METHOD1(OnIncomingLoss, void(int number_of_lost_packets));
+  MOCK_METHOD3(SentPacket, void(QuicPacketSequenceNumber, QuicByteCount, bool));
   MOCK_METHOD1(TimeUntilSend, QuicTime::Delta(bool));
-  MOCK_METHOD1(OnIncomingAckFrame, void(const QuicAckFrame&));
-  MOCK_METHOD3(SentPacket, void(QuicPacketSequenceNumber, size_t, bool));
+  MOCK_METHOD0(BandwidthEstimate, QuicBandwidth(void));
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockScheduler);
+  DISALLOW_COPY_AND_ASSIGN(MockSendAlgorithm);
 };
 
 }  // namespace test