Moving overhead counting to bitrate estimators.

webrtc/modules/congestion_controller/congestion_controller_unittest.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
@@ skipping 31 matching lines @@
   return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful;
 }
 
 class MockPacketRouter : public PacketRouter {
  public:
   MOCK_METHOD2(OnReceiveBitrateChanged,
                void(const std::vector<uint32_t>& ssrcs,
                     uint32_t bitrate));
 };
 
-const uint32_t kInitialBitrateBps = 60000;
+constexpr uint32_t kInitialBitrateBps = 60000;
+constexpr size_t kRtpHeadersSize = 12;
+constexpr size_t kTransportHeadersSize = 20;
 
 }  // namespace
 
 namespace test {
 
 class CongestionControllerTest : public ::testing::Test {
  protected:
   CongestionControllerTest() : clock_(123456), target_bitrate_observer_(this) {}
   ~CongestionControllerTest() override {}
 
@@ skipping 20 matching lines @@
   void TargetBitrateTrackingSetup() {
     std::unique_ptr<PacedSender> pacer(new NiceMock<MockPacedSender>());
     controller_.reset(new CongestionController(
         &clock_, &target_bitrate_observer_, &remote_bitrate_observer_,
         &event_log_, &packet_router_, std::move(pacer)));
     controller_->SetBweBitrates(0, kInitialBitrateBps, 5 * kInitialBitrateBps);
   }
 
   void OnSentPacket(const PacketFeedback& packet_feedback) {
     constexpr uint32_t ssrc = 0;
-    controller_->AddPacket(ssrc, packet_feedback.sequence_number,
-                           packet_feedback.payload_size,
-                           packet_feedback.pacing_info);
+    controller_->AddPacket(
+        ssrc, packet_feedback.sequence_number, packet_feedback.payload_size,
+        packet_feedback.rtp_headers_size, packet_feedback.pacing_info);
     controller_->OnSentPacket(rtc::SentPacket(packet_feedback.sequence_number,
                                               packet_feedback.send_time_ms));
   }
 
   // Allows us to track the target bitrate, without prescribing the exact
   // iterations when this would hapen, like a mock would.
   class TargetBitrateObserver : public CongestionController::Observer {
    public:
     explicit TargetBitrateObserver(CongestionControllerTest* owner)
         : owner_(owner) {}
@@ skipping 11 matching lines @@
 
   void PacketTransmissionAndFeedbackBlock(uint16_t* seq_num,
                                           int64_t runtime_ms,
                                           int64_t delay) {
     int64_t delay_buildup = 0;
     int64_t start_time_ms = clock_.TimeInMilliseconds();
     while (clock_.TimeInMilliseconds() - start_time_ms < runtime_ms) {
       constexpr size_t kPayloadSize = 1000;
       PacketFeedback packet(clock_.TimeInMilliseconds() + delay_buildup,
                             clock_.TimeInMilliseconds(), *seq_num, kPayloadSize,
+                            kRtpHeadersSize, kTransportHeadersSize,
                             PacedPacketInfo());
       delay_buildup += delay;  // Delay has to increase, or it's just RTT.
       OnSentPacket(packet);
       // Create expected feedback and send into adapter.
       std::unique_ptr<rtcp::TransportFeedback> feedback(
           new rtcp::TransportFeedback());
       feedback->SetBase(packet.sequence_number, packet.arrival_time_ms * 1000);
       EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number,
                                               packet.arrival_time_ms * 1000));
       rtc::Buffer raw_packet = feedback->Build();
@@ skipping 109 matching lines @@
 }
 
 TEST_F(CongestionControllerTest, OldFeedback) {
   int new_bitrate = 200000;
   testing::Mock::VerifyAndClearExpectations(pacer_);
   EXPECT_CALL(observer_, OnNetworkChanged(new_bitrate, _, _, _));
   EXPECT_CALL(*pacer_, SetEstimatedBitrate(new_bitrate));
 
   // Send a few packets on the first network route.
   std::vector<PacketFeedback> packets;
-  packets.push_back(PacketFeedback(0, 0, 0, 1500, kPacingInfo0));
-  packets.push_back(PacketFeedback(10, 10, 1, 1500, kPacingInfo0));
-  packets.push_back(PacketFeedback(20, 20, 2, 1500, kPacingInfo0));
-  packets.push_back(PacketFeedback(30, 30, 3, 1500, kPacingInfo1));
-  packets.push_back(PacketFeedback(40, 40, 4, 1500, kPacingInfo1));
+  packets.push_back(PacketFeedback(0, 0, 0, 1500, kRtpHeadersSize,
+                                   kTransportHeadersSize, kPacingInfo0));
+  packets.push_back(PacketFeedback(10, 10, 1, 1500, kRtpHeadersSize,
+                                   kTransportHeadersSize, kPacingInfo0));
+  packets.push_back(PacketFeedback(20, 20, 2, 1500, kRtpHeadersSize,
+                                   kTransportHeadersSize, kPacingInfo0));
+  packets.push_back(PacketFeedback(30, 30, 3, 1500, kRtpHeadersSize,
+                                   kTransportHeadersSize, kPacingInfo1));
+  packets.push_back(PacketFeedback(40, 40, 4, 1500, kRtpHeadersSize,
+                                   kTransportHeadersSize, kPacingInfo1));
 
   for (const PacketFeedback& packet : packets)
     OnSentPacket(packet);
 
   // Change route and then insert a number of feedback packets.
   rtc::NetworkRoute route;
   route.local_network_id = 1;
   controller_->OnNetworkRouteChanged(route, new_bitrate, -1, -1);
 
   for (const PacketFeedback& packet : packets) {
@@ skipping 112 matching lines @@
 
 // Estimated bitrate reduced when the feedbacks arrive with such a long delay,
 // that the send-time-history no longer holds the feedbacked packets.
 TEST_F(CongestionControllerTest, LongFeedbackDelays) {
   TargetBitrateTrackingSetup();
 
   const int64_t kFeedbackTimeoutMs = 60001;
   const int kMaxConsecutiveFailedLookups = 5;
   for (int i = 0; i < kMaxConsecutiveFailedLookups; ++i) {
     std::vector<PacketFeedback> packets;
-    packets.push_back(
-        PacketFeedback(i * 100, 2 * i * 100, 0, 1500, kPacingInfo0));
-    packets.push_back(
-        PacketFeedback(i * 100 + 10, 2 * i * 100 + 10, 1, 1500, kPacingInfo0));
-    packets.push_back(
-        PacketFeedback(i * 100 + 20, 2 * i * 100 + 20, 2, 1500, kPacingInfo0));
-    packets.push_back(
-        PacketFeedback(i * 100 + 30, 2 * i * 100 + 30, 3, 1500, kPacingInfo1));
-    packets.push_back(
-        PacketFeedback(i * 100 + 40, 2 * i * 100 + 40, 4, 1500, kPacingInfo1));
+    packets.push_back(PacketFeedback(i * 100, 2 * i * 100, 0, 1500,
+                                     kRtpHeadersSize, kTransportHeadersSize,
+                                     kPacingInfo0));
+    packets.push_back(PacketFeedback(i * 100 + 10, 2 * i * 100 + 10, 1, 1500,
+                                     kRtpHeadersSize, kTransportHeadersSize,
+                                     kPacingInfo0));
+    packets.push_back(PacketFeedback(i * 100 + 20, 2 * i * 100 + 20, 2, 1500,
+                                     kRtpHeadersSize, kTransportHeadersSize,
+                                     kPacingInfo0));
+    packets.push_back(PacketFeedback(i * 100 + 30, 2 * i * 100 + 30, 3, 1500,
+                                     kRtpHeadersSize, kTransportHeadersSize,
+                                     kPacingInfo1));
+    packets.push_back(PacketFeedback(i * 100 + 40, 2 * i * 100 + 40, 4, 1500,
+                                     kRtpHeadersSize, kTransportHeadersSize,
+                                     kPacingInfo1));
 
     for (const PacketFeedback& packet : packets)
       OnSentPacket(packet);
 
     rtcp::TransportFeedback feedback;
     feedback.SetBase(packets[0].sequence_number,
                      packets[0].arrival_time_ms * 1000);
 
     for (const PacketFeedback& packet : packets) {
       EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
                                              packet.arrival_time_ms * 1000));
     }
 
     feedback.Build();
 
     clock_.AdvanceTimeMilliseconds(kFeedbackTimeoutMs);
-    PacketFeedback later_packet(kFeedbackTimeoutMs + i * 100 + 40,
-                                kFeedbackTimeoutMs + i * 200 + 40, 5, 1500,
-                                kPacingInfo1);
+    PacketFeedback later_packet(
+        kFeedbackTimeoutMs + i * 100 + 40, kFeedbackTimeoutMs + i * 200 + 40, 5,
+        1500, kRtpHeadersSize, kTransportHeadersSize, kPacingInfo1);
     OnSentPacket(later_packet);
 
     controller_->OnTransportFeedback(feedback);
 
     // Check that packets have timed out.
     for (PacketFeedback& packet : packets) {
       packet.send_time_ms = -1;
       packet.payload_size = 0;
       packet.pacing_info = PacedPacketInfo();
     }
     ComparePacketFeedbackVectors(packets,
                                  controller_->GetTransportFeedbackVector());
   }
 
   controller_->Process();
 
   EXPECT_EQ(kInitialBitrateBps / 2, target_bitrate_bps_);
 
   // Test with feedback that isn't late enough to time out.
   {
     std::vector<PacketFeedback> packets;
-    packets.push_back(PacketFeedback(100, 200, 0, 1500, kPacingInfo0));
-    packets.push_back(PacketFeedback(110, 210, 1, 1500, kPacingInfo0));
-    packets.push_back(PacketFeedback(120, 220, 2, 1500, kPacingInfo0));
-    packets.push_back(PacketFeedback(130, 230, 3, 1500, kPacingInfo1));
-    packets.push_back(PacketFeedback(140, 240, 4, 1500, kPacingInfo1));
+    packets.push_back(PacketFeedback(100, 200, 0, 1500, kRtpHeadersSize,
+                                     kTransportHeadersSize, kPacingInfo0));
+    packets.push_back(PacketFeedback(110, 210, 1, 1500, kRtpHeadersSize,
+                                     kTransportHeadersSize, kPacingInfo0));
+    packets.push_back(PacketFeedback(120, 220, 2, 1500, kRtpHeadersSize,
+                                     kTransportHeadersSize, kPacingInfo0));
+    packets.push_back(PacketFeedback(130, 230, 3, 1500, kRtpHeadersSize,
+                                     kTransportHeadersSize, kPacingInfo1));
+    packets.push_back(PacketFeedback(140, 240, 4, 1500, kRtpHeadersSize,
+                                     kTransportHeadersSize, kPacingInfo1));
 
     for (const PacketFeedback& packet : packets)
       OnSentPacket(packet);
 
     rtcp::TransportFeedback feedback;
     feedback.SetBase(packets[0].sequence_number,
                      packets[0].arrival_time_ms * 1000);
 
     for (const PacketFeedback& packet : packets) {
       EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
                                              packet.arrival_time_ms * 1000));
     }
 
     feedback.Build();
 
     clock_.AdvanceTimeMilliseconds(kFeedbackTimeoutMs - 1);
-    PacketFeedback later_packet(kFeedbackTimeoutMs + 140,
-                                kFeedbackTimeoutMs + 240, 5, 1500,
-                                kPacingInfo1);
+    PacketFeedback later_packet(
+        kFeedbackTimeoutMs + 140, kFeedbackTimeoutMs + 240, 5, 1500,
+        kRtpHeadersSize, kTransportHeadersSize, kPacingInfo1);
     OnSentPacket(later_packet);
 
     controller_->OnTransportFeedback(feedback);
     ComparePacketFeedbackVectors(packets,
                                  controller_->GetTransportFeedbackVector());
   }
 }
 
 // Bandwidth estimation is updated when feedbacks are received.
 // Feedbacks which show an increasing delay cause the estimation to be reduced.
@@ skipping 10 matching lines @@
   ASSERT_TRUE(target_bitrate_bps_);
 
   // Repeat, but this time with a building delay, and make sure that the
   // estimation is adjusted downwards.
   uint32_t bitrate_before_delay = *target_bitrate_bps_;
   PacketTransmissionAndFeedbackBlock(&seq_num, kRunTimeMs, 50);
   EXPECT_LT(*target_bitrate_bps_, bitrate_before_delay);
 }
 }  // namespace test
 }  // namespace webrtc