Propagate packet pacing information to SenTimeHistory

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 "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 using testing::_;
+using testing::Field;
 using testing::Return;
 
 namespace {
 constexpr unsigned kFirstClusterBps = 900000;
 constexpr unsigned kSecondClusterBps = 1800000;
 
 // The error stems from truncating the time interval of probe packets to integer
 // values. This results in probing slightly higher than the target bitrate.
 // For 1.8 Mbps, this comes to be about 120 kbps with 1200 probe packets.
 constexpr int kBitrateProbingError = 150000;
 }  // namespace
 
 namespace webrtc {
 namespace test {
 
 static const int kTargetBitrateBps = 800000;
 
 class MockPacedSenderCallback : public PacedSender::PacketSender {
  public:
   MOCK_METHOD5(TimeToSendPacket,
                bool(uint32_t ssrc,
                     uint16_t sequence_number,
                     int64_t capture_time_ms,
                     bool retransmission,
-                    int probe_cluster_id));
-  MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id));
+                    const PacedPacketInfo& pacing_info));
+  MOCK_METHOD2(TimeToSendPadding,
+               size_t(size_t bytes, const PacedPacketInfo& pacing_info));
 };
 
 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,
-                        int probe_cluster_id) override {
+                        const PacedPacketInfo& pacing_info) override {
     return true;
   }
 
-  size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
+  size_t TimeToSendPadding(size_t bytes,
+                           const PacedPacketInfo& pacing_info) 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() : packets_sent_(0), padding_sent_(0) {}
 
   bool TimeToSendPacket(uint32_t ssrc,
                         uint16_t sequence_number,
                         int64_t capture_time_ms,
                         bool retransmission,
-                        int probe_cluster_id) override {
+                        const PacedPacketInfo& pacing_info) override {
     packets_sent_++;
     return true;
   }
 
-  size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override {
+  size_t TimeToSendPadding(size_t bytes,
+                           const PacedPacketInfo& pacing_info) override {
     padding_sent_ += bytes;
     return padding_sent_;
   }
 
   int packets_sent() const { return packets_sent_; }
 
   int padding_sent() const { return padding_sent_; }
 
  private:
   int packets_sent_;
@@ skipping 23 matching lines @@
                            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, retransmission, _))
         .Times(1)
         .WillRepeatedly(Return(true));
   }
-
   SimulatedClock clock_;
   MockPacedSenderCallback callback_;
   std::unique_ptr<PacedSender> send_bucket_;
 };
 
 TEST_F(PacedSenderTest, QueuePacket) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
   // Due to the multiplicative factor we can send 5 packets during a send
   // interval. (network capacity * multiplier / (8 bits per byte *
@@ skipping 863 matching lines @@
 
   send_bucket_->SetSendBitrateLimits(kTargetBitrateBps, kTargetBitrateBps);
   send_bucket_->SetProbingEnabled(true);
   for (int i = 0; i < 10; ++i) {
     send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
                                sequence_number + i, clock_.TimeInMilliseconds(),
                                kPacketSize, false);
   }
 
   // First probing cluster.
-  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 0))
+  EXPECT_CALL(callback_,
+              TimeToSendPacket(_, _, _, _,
+                               Field(&PacedPacketInfo::probe_cluster_id, 0)))
       .Times(5)
       .WillRepeatedly(Return(true));
   for (int i = 0; i < 5; ++i) {
     clock_.AdvanceTimeMilliseconds(20);
     send_bucket_->Process();
   }
 
   // Second probing cluster.
-  EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, 1))
+  EXPECT_CALL(callback_,
+              TimeToSendPacket(_, _, _, _,
+                               Field(&PacedPacketInfo::probe_cluster_id, 1)))
       .Times(5)
       .WillRepeatedly(Return(true));
   for (int i = 0; i < 5; ++i) {
     clock_.AdvanceTimeMilliseconds(20);
     send_bucket_->Process();
   }
 
+  // Needed for the Field comparer below.
+  const int kNotAProbe = PacedPacketInfo::kNotAProbe;
   // No more probing packets.
-  EXPECT_CALL(callback_, TimeToSendPadding(_, PacketInfo::kNotAProbe))
-        .Times(1)
-        .WillRepeatedly(Return(500));
+  EXPECT_CALL(callback_,
+              TimeToSendPadding(
+                  _, Field(&PacedPacketInfo::probe_cluster_id, kNotAProbe)))
+      .Times(1)
+      .WillRepeatedly(Return(500));
   send_bucket_->Process();
 }
 
 }  // namespace test
 }  // namespace webrtc