Added cluster id to PacedSender::Callback::TimeToSendPacket.

webrtc/modules/pacing/paced_sender_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <list>
 #include <memory>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 using testing::_;
 using testing::Return;
 
 namespace webrtc {
 namespace test {
 
 static const int kTargetBitrateBps = 800000;
 
 class MockPacedSenderCallback : public PacedSender::PacketSender {
  public:
-  MOCK_METHOD4(TimeToSendPacket,
+  MOCK_METHOD5(TimeToSendPacket,
                bool(uint32_t ssrc,
                     uint16_t sequence_number,
                     int64_t capture_time_ms,
-                    bool retransmission));
+                    bool retransmission,
+                    int probe_cluster_id));
   MOCK_METHOD1(TimeToSendPadding,
       size_t(size_t bytes));
 };
 
 class PacedSenderPadding : public PacedSender::PacketSender {
  public:
   PacedSenderPadding() : padding_sent_(0) {}
 
   bool TimeToSendPacket(uint32_t ssrc,
                         uint16_t sequence_number,
                         int64_t capture_time_ms,
-                        bool retransmission) {
+                        bool retransmission,
+                        int probe_cluster_id) override {
     return true;
   }
 
-  size_t TimeToSendPadding(size_t bytes) {
+  size_t TimeToSendPadding(size_t bytes) override {
     const size_t kPaddingPacketSize = 224;
     size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
     padding_sent_ += kPaddingPacketSize * num_packets;
     return kPaddingPacketSize * num_packets;
   }
 
   size_t padding_sent() { return padding_sent_; }
 
  private:
   size_t padding_sent_;
 };
 
 class PacedSenderProbing : public PacedSender::PacketSender {
  public:
   PacedSenderProbing(const std::list<int>& expected_deltas, Clock* clock)
       : prev_packet_time_ms_(-1),
         expected_deltas_(expected_deltas),
         packets_sent_(0),
         clock_(clock) {}
 
   bool TimeToSendPacket(uint32_t ssrc,
                         uint16_t sequence_number,
                         int64_t capture_time_ms,
-                        bool retransmission) {
+                        bool retransmission,
+                        int probe_cluster_id) override {
     ExpectAndCountPacket();
     return true;
   }
 
-  size_t TimeToSendPadding(size_t bytes) {
+  size_t TimeToSendPadding(size_t bytes) override {
     ExpectAndCountPacket();
     return bytes;
   }
 
   void ExpectAndCountPacket() {
     ++packets_sent_;
     EXPECT_FALSE(expected_deltas_.empty());
     if (expected_deltas_.empty())
       return;
     int64_t now_ms = clock_->TimeInMilliseconds();
@@ skipping 29 matching lines @@
   }
 
   void SendAndExpectPacket(PacedSender::Priority priority,
                            uint32_t ssrc,
                            uint16_t sequence_number,
                            int64_t capture_time_ms,
                            size_t size,
                            bool retransmission) {
     send_bucket_->InsertPacket(priority, ssrc, sequence_number, capture_time_ms,
                                size, retransmission);
-    EXPECT_CALL(callback_,
-                TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
+    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
+                                            capture_time_ms, false, _))
         .Times(1)
         .WillRepeatedly(Return(true));
   }
 
   SimulatedClock clock_;
   MockPacedSenderCallback callback_;
   std::unique_ptr<PacedSender> send_bucket_;
 };
 
 TEST_F(PacedSenderTest, QueuePacket) {
@@ skipping 15 matching lines @@
                              false);
   EXPECT_EQ(packets_to_send + 1, send_bucket_->QueueSizePackets());
   send_bucket_->Process();
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   clock_.AdvanceTimeMilliseconds(4);
   EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(1);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   EXPECT_EQ(1u, send_bucket_->QueueSizePackets());
-  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
-                                          queued_packet_timestamp, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number++,
+                                          queued_packet_timestamp, false, _))
       .Times(1)
       .WillRepeatedly(Return(true));
   send_bucket_->Process();
   sequence_number++;
   EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
 
   // We can send packets_to_send -1 packets of size 250 during the current
   // interval since one packet has already been sent.
   for (size_t i = 0; i < packets_to_send - 1; ++i) {
     SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
@@ skipping 28 matching lines @@
   }
   EXPECT_EQ(packets_to_send_per_interval + packets_to_send_per_interval * 10,
             send_bucket_->QueueSizePackets());
   send_bucket_->Process();
   EXPECT_EQ(packets_to_send_per_interval * 10,
             send_bucket_->QueueSizePackets());
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   for (int k = 0; k < 10; ++k) {
     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
     clock_.AdvanceTimeMilliseconds(5);
-    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false))
+    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false, _))
         .Times(packets_to_send_per_interval)
         .WillRepeatedly(Return(true));
     EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
     send_bucket_->Process();
   }
   EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
@@ skipping 36 matching lines @@
                                250, false);
   }
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   send_bucket_->Process();
   for (int k = 0; k < 10; ++k) {
     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
     clock_.AdvanceTimeMilliseconds(5);
 
     for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
       EXPECT_CALL(callback_,
-                  TimeToSendPacket(ssrc, queued_sequence_number++, _, false))
+                  TimeToSendPacket(ssrc, queued_sequence_number++, _, false, _))
           .Times(1)
           .WillRepeatedly(Return(true));
     }
     EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
     send_bucket_->Process();
   }
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   send_bucket_->Process();
@@ skipping 151 matching lines @@
 
   for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
     send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
                                sequence_number++, capture_time_ms, 250, false);
   }
   send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
                              sequence_number++, capture_time_ms, 250, false);
 
   // Expect all high and normal priority to be sent out first.
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
-  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false, _))
       .Times(packets_to_send_per_interval + 1)
       .WillRepeatedly(Return(true));
 
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   send_bucket_->Process();
   EXPECT_EQ(1u, send_bucket_->QueueSizePackets());
 
   EXPECT_CALL(callback_,
-              TimeToSendPacket(
-                  ssrc_low_priority, _, capture_time_ms_low_priority, false))
+              TimeToSendPacket(ssrc_low_priority, _,
+                               capture_time_ms_low_priority, false, _))
       .Times(1)
       .WillRepeatedly(Return(true));
 
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   send_bucket_->Process();
 }
 
 TEST_F(PacedSenderTest, HighPrioDoesntAffectBudget) {
@@ skipping 17 matching lines @@
   for (size_t i = 0; i < packets_to_send_per_interval; ++i) {
     SendAndExpectPacket(PacedSender::kLowPriority, ssrc, sequence_number++,
                         clock_.TimeInMilliseconds(), 250, false);
   }
   send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc, sequence_number,
                              capture_time_ms, 250, false);
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   send_bucket_->Process();
   EXPECT_EQ(1u, send_bucket_->QueueSizePackets());
-  EXPECT_CALL(callback_,
-              TimeToSendPacket(ssrc, sequence_number++, capture_time_ms, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number++,
+                                          capture_time_ms, false, _))
       .Times(1)
       .WillRepeatedly(Return(true));
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   send_bucket_->Process();
   EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
 }
 
 TEST_F(PacedSenderTest, Pause) {
   uint32_t ssrc_low_priority = 12345;
@@ skipping 30 matching lines @@
   // Expect everything to be queued.
   send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
                              sequence_number++, second_capture_time_ms, 250,
                              false);
 
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
             send_bucket_->QueueInMs());
 
   // Expect no packet to come out while paused.
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
-  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, _)).Times(0);
 
   for (int i = 0; i < 10; ++i) {
     clock_.AdvanceTimeMilliseconds(5);
     EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
     send_bucket_->Process();
   }
   // Expect high prio packets to come out first followed by all packets in the
   // way they were added.
-  EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false, _))
       .Times(3)
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(callback_, TimeToSendPacket(_, _, second_capture_time_ms, false))
+  EXPECT_CALL(callback_,
+              TimeToSendPacket(_, _, second_capture_time_ms, false, _))
       .Times(1)
       .WillRepeatedly(Return(true));
   send_bucket_->Resume();
 
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   send_bucket_->Process();
 
   EXPECT_EQ(0, send_bucket_->QueueInMs());
 }
 
 TEST_F(PacedSenderTest, ResendPacket) {
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
   int64_t capture_time_ms = clock_.TimeInMilliseconds();
   EXPECT_EQ(0, send_bucket_->QueueInMs());
 
   send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
                              sequence_number, capture_time_ms, 250, false);
   clock_.AdvanceTimeMilliseconds(1);
   send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
                              sequence_number + 1, capture_time_ms + 1, 250,
                              false);
   clock_.AdvanceTimeMilliseconds(9999);
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
             send_bucket_->QueueInMs());
   // Fails to send first packet so only one call.
-  EXPECT_CALL(callback_,
-              TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
+                                          capture_time_ms, false, _))
       .Times(1)
       .WillOnce(Return(false));
   clock_.AdvanceTimeMilliseconds(10000);
   send_bucket_->Process();
 
   // Queue remains unchanged.
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
             send_bucket_->QueueInMs());
 
   // Fails to send second packet.
-  EXPECT_CALL(callback_,
-              TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
+                                          capture_time_ms, false, _))
       .Times(1)
       .WillOnce(Return(true));
-  EXPECT_CALL(
-      callback_,
-      TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
+                                          capture_time_ms + 1, false, _))
       .Times(1)
       .WillOnce(Return(false));
   clock_.AdvanceTimeMilliseconds(10000);
   send_bucket_->Process();
 
   // Queue is reduced by 1 packet.
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms - 1,
             send_bucket_->QueueInMs());
 
   // Send second packet and queue becomes empty.
-  EXPECT_CALL(
-      callback_,
-      TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
+  EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
+                                          capture_time_ms + 1, false, _))
       .Times(1)
       .WillOnce(Return(true));
   clock_.AdvanceTimeMilliseconds(10000);
   send_bucket_->Process();
   EXPECT_EQ(0, send_bucket_->QueueInMs());
 }
 
 TEST_F(PacedSenderTest, ExpectedQueueTimeMs) {
   uint32_t ssrc = 12346;
   uint16_t sequence_number = 1234;
@@ skipping 132 matching lines @@
   send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number,
                              clock_.TimeInMilliseconds(), kPacketSize, true);
 
   send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
                              sequence_number + 1, clock_.TimeInMilliseconds(),
                              kPacketSize, true);
 
   // Packets from earlier frames should be sent first.
   {
     ::testing::InSequence sequence;
-    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
-                                            clock_.TimeInMilliseconds(), true))
+    EXPECT_CALL(callback_,
+                TimeToSendPacket(ssrc, sequence_number,
+                                 clock_.TimeInMilliseconds(), true, _))
         .WillOnce(Return(true));
-    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
-                                            clock_.TimeInMilliseconds(), true))
+    EXPECT_CALL(callback_,
+                TimeToSendPacket(ssrc, sequence_number + 1,
+                                 clock_.TimeInMilliseconds(), true, _))
         .WillOnce(Return(true));
-    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 3,
-                                            clock_.TimeInMilliseconds() + 33,
-                                            true)).WillOnce(Return(true));
-    EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 2,
-                                            clock_.TimeInMilliseconds() + 33,
-                                            true)).WillOnce(Return(true));
+    EXPECT_CALL(callback_,
+                TimeToSendPacket(ssrc, sequence_number + 3,
+                                 clock_.TimeInMilliseconds() + 33, true, _))
+        .WillOnce(Return(true));
+    EXPECT_CALL(callback_,
+                TimeToSendPacket(ssrc, sequence_number + 2,
+                                 clock_.TimeInMilliseconds() + 33, true, _))
+        .WillOnce(Return(true));
 
     while (send_bucket_->QueueSizePackets() > 0) {
       int time_until_process = send_bucket_->TimeUntilNextProcess();
       if (time_until_process <= 0) {
         send_bucket_->Process();
       } else {
         clock_.AdvanceTimeMilliseconds(time_until_process);
       }
     }
   }
@@ skipping 43 matching lines @@
   send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
                              sequence_number + 1, clock_.TimeInMilliseconds(),
                              kPacketSize, false);
   clock_.AdvanceTimeMilliseconds(10);
 
   EXPECT_EQ((20 + 10) / 2, send_bucket_->AverageQueueTimeMs());
 
   // Only first packet (queued for 20ms) should be removed, leave the second
   // packet (queued for 10ms) alone in the queue.
   EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
-                                          first_capture_time, false))
+                                          first_capture_time, false, _))
       .Times(1)
       .WillRepeatedly(Return(true));
   send_bucket_->Process();
 
   EXPECT_EQ(10, send_bucket_->AverageQueueTimeMs());
 
   clock_.AdvanceTimeMilliseconds(10);
   EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
-                                          first_capture_time + 10, false))
+                                          first_capture_time + 10, false, _))
       .Times(1)
       .WillRepeatedly(Return(true));
   for (int i = 0; i < 3; ++i) {
     clock_.AdvanceTimeMilliseconds(30);  // Max delta.
     send_bucket_->Process();
   }
 
   EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs());
 }
 
+TEST_F(PacedSenderTest, ProbeClusterId) {
+  uint32_t ssrc = 12346;
+  uint16_t sequence_number = 1234;
+  const size_t kPacketSize = 1200;
+
+  send_bucket_->SetProbingEnabled(true);
+  for (int i = 0; i < 11; ++i) {
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number + i, clock_.TimeInMilliseconds(),
+                               kPacketSize, false);
+  }
+
+  // First probing cluster.
+  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 0))
+      .Times(6)
+      .WillRepeatedly(Return(true));
+  for (int i = 0; i < 6; ++i)
+    send_bucket_->Process();
+
+  // Second probing cluster.
+  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 1))
+      .Times(5)
+      .WillRepeatedly(Return(true));
+  for (int i = 0; i < 5; ++i)
+    send_bucket_->Process();
+
+  // No more probing packets.
+  EXPECT_CALL(callback_, TimeToSendPadding(_))
+      .Times(1);
+  send_bucket_->Process();
+}
+
 }  // namespace test
 }  // namespace webrtc