Propagate probing cluster id to SendTimeHistory.

webrtc/modules/pacing/paced_sender_unittest.cc

Index: webrtc/modules/pacing/paced_sender_unittest.cc
diff --git a/webrtc/modules/pacing/paced_sender_unittest.cc b/webrtc/modules/pacing/paced_sender_unittest.cc
index 6a0a006c32600f5bfe0489da183d3957d45b9e34..af32532142841c8cde245664a90c085145805fab 100644
--- a/webrtc/modules/pacing/paced_sender_unittest.cc
+++ b/webrtc/modules/pacing/paced_sender_unittest.cc
@@ -32,8 +32,7 @@ class MockPacedSenderCallback : public PacedSender::PacketSender {
                     int64_t capture_time_ms,
                     bool retransmission,
                     int probe_cluster_id));
-  MOCK_METHOD1(TimeToSendPadding,
-      size_t(size_t bytes));
+  MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id));
 };
 
 class PacedSenderPadding : public PacedSender::PacketSender {
@@ -48,7 +47,7 @@ class PacedSenderPadding : public PacedSender::PacketSender {
     return true;
   }
 
-  size_t TimeToSendPadding(size_t bytes) override {
+  size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
     const size_t kPaddingPacketSize = 224;
     size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
     padding_sent_ += kPaddingPacketSize * num_packets;
@@ -78,7 +77,7 @@ class PacedSenderProbing : public PacedSender::PacketSender {
     return true;
   }
 
-  size_t TimeToSendPadding(size_t bytes) override {
+  size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
     ExpectAndCountPacket();
     return bytes;
   }
@@ -159,7 +158,7 @@ TEST_F(PacedSenderTest, QueuePacket) {
   EXPECT_EQ(packets_to_send + 1, send_bucket_->QueueSizePackets());
   send_bucket_->Process();
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
   clock_.AdvanceTimeMilliseconds(4);
   EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(1);
@@ -211,7 +210,7 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
   send_bucket_->Process();
   EXPECT_EQ(packets_to_send_per_interval * 10,
             send_bucket_->QueueSizePackets());
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
   for (int k = 0; k < 10; ++k) {
     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
     clock_.AdvanceTimeMilliseconds(5);
@@ -264,7 +263,7 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
                                sequence_number++, clock_.TimeInMilliseconds(),
                                250, false);
   }
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
   send_bucket_->Process();
   for (int k = 0; k < 10; ++k) {
     EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
@@ -335,22 +334,23 @@ TEST_F(PacedSenderTest, Padding) {
                         clock_.TimeInMilliseconds(), 250, false);
   }
   // No padding is expected since we have sent too much already.
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   send_bucket_->Process();
   EXPECT_EQ(0u, send_bucket_->QueueSizePackets());
 
   // 5 milliseconds later should not send padding since we filled the buffers
   // initially.
-  EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPadding(250, _)).Times(0);
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
   send_bucket_->Process();
 
   // 5 milliseconds later we have enough budget to send some padding.
-  EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
-      WillOnce(Return(250));
+  EXPECT_CALL(callback_, TimeToSendPadding(250, _))
+      .Times(1)
+      .WillOnce(Return(250));
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   clock_.AdvanceTimeMilliseconds(5);
   EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
@@ -374,8 +374,9 @@ TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
                         capture_time_ms,
                         250,
                         false);
-    EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
-        WillOnce(Return(250));
+    EXPECT_CALL(callback_, TimeToSendPadding(250, _))
+        .Times(1)
+        .WillOnce(Return(250));
     send_bucket_->Process();
     clock_.AdvanceTimeMilliseconds(kTimeStep);
   }
@@ -443,7 +444,7 @@ TEST_F(PacedSenderTest, Priority) {
                              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_, TimeToSendPadding(_, _)).Times(0);
   EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false, _))
       .Times(packets_to_send_per_interval + 1)
       .WillRepeatedly(Return(true));
@@ -545,7 +546,7 @@ TEST_F(PacedSenderTest, Pause) {
             send_bucket_->QueueInMs());
 
   // Expect no packet to come out while paused.
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
   EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, _)).Times(0);
 
   for (int i = 0; i < 10; ++i) {
@@ -820,7 +821,7 @@ TEST_F(PacedSenderTest, PaddingOveruse) {
                       clock_.TimeInMilliseconds(), kPacketSize, false);
   EXPECT_LT(5u, send_bucket_->ExpectedQueueTimeMs());
   // Don't send padding if queue is non-empty, even if padding budget > 0.
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
+  EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0);
   send_bucket_->Process();
 }
 
@@ -874,6 +875,7 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
   uint16_t sequence_number = 1234;
   const size_t kPacketSize = 1200;
 
+  send_bucket_->SetAllocatedSendBitrate(kTargetBitrateBps, kTargetBitrateBps);
   send_bucket_->SetProbingEnabled(true);
   for (int i = 0; i < 11; ++i) {
     send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
@@ -885,19 +887,24 @@ TEST_F(PacedSenderTest, ProbeClusterId) {
   EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 0))
       .Times(6)
       .WillRepeatedly(Return(true));
-  for (int i = 0; i < 6; ++i)
+  for (int i = 0; i < 6; ++i) {
+    clock_.AdvanceTimeMilliseconds(20);
     send_bucket_->Process();
+  }
 
   // Second probing cluster.
   EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 1))
       .Times(5)
       .WillRepeatedly(Return(true));
-  for (int i = 0; i < 5; ++i)
+  for (int i = 0; i < 5; ++i) {
+    clock_.AdvanceTimeMilliseconds(20);
     send_bucket_->Process();
+  }
 
   // No more probing packets.
-  EXPECT_CALL(callback_, TimeToSendPadding(_))
-      .Times(1);
+  EXPECT_CALL(callback_, TimeToSendPadding(_, PacketInfo::kNotAProbe))
+      .Times(1)
+      .WillRepeatedly(Return(500));
   send_bucket_->Process();
 }