Making RtpSender tests cover BWE with overhead.

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 6539f736dc3e7ef13d02376b185d87f21f80c213..961b53a139c3901984ee907fc10d491a68210b3a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -132,7 +132,12 @@ class MockTransportFeedbackObserver : public TransportFeedbackObserver {
   MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketFeedback>());
 };
 
-class RtpSenderTest : public ::testing::Test {
+class MockOverheadObserver : public OverheadObserver {
+ public:
+  MOCK_METHOD1(OnOverheadChanged, void(size_t overhead_bytes_per_packet));
+};
+
+class RtpSenderTest : public ::testing::TestWithParam<bool> {
  protected:
   RtpSenderTest()
       : fake_clock_(kStartTime),
@@ -142,7 +147,9 @@ class RtpSenderTest : public ::testing::Test {
         rtp_sender_(),
         payload_(kPayload),
         transport_(),
-        kMarkerBit(true) {}
+        kMarkerBit(true),
+        field_trials_(GetParam() ? "WebRTC-SendSideBwe-WithOverhead/Enabled/"
+                                 : "") {}
 
   void SetUp() override { SetUpRtpSender(true); }
 
@@ -169,6 +176,7 @@ class RtpSenderTest : public ::testing::Test {
   int payload_;
   LoopbackTransportTest transport_;
   const bool kMarkerBit;
+  test::ScopedFieldTrials field_trials_;
 
   void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
     VerifyRTPHeaderCommon(rtp_header, kMarkerBit, 0);
@@ -247,7 +255,7 @@ class RtpSenderVideoTest : public RtpSenderTest {
   std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
 };
 
-TEST_F(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
+TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
   // Configure rtp_sender with csrc.
   std::vector<uint32_t> csrcs;
   csrcs.push_back(0x23456789);
@@ -260,7 +268,7 @@ TEST_F(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
   EXPECT_EQ(csrcs, packet->Csrcs());
 }
 
-TEST_F(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
+TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
   // Configure rtp_sender with extensions.
   ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
@@ -288,7 +296,7 @@ TEST_F(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
   EXPECT_FALSE(packet->HasExtension<VideoOrientation>());
 }
 
-TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) {
+TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) {
   auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
   const uint16_t sequence_number = rtp_sender_->SequenceNumber();
@@ -299,7 +307,7 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) {
   EXPECT_EQ(sequence_number + 1, rtp_sender_->SequenceNumber());
 }
 
-TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
+TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
   auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
 
@@ -307,7 +315,7 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
   EXPECT_FALSE(rtp_sender_->AssignSequenceNumber(packet.get()));
 }
 
-TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) {
+TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) {
   constexpr size_t kPaddingSize = 100;
   auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
@@ -324,7 +332,7 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) {
   EXPECT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
 }
 
-TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
+TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
   constexpr size_t kPaddingSize = 100;
   auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
@@ -339,7 +347,37 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
   EXPECT_EQ(kTimestamp, transport_.last_sent_packet().Timestamp());
 }
 
-TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
+TEST_P(RtpSenderTestWithoutPacer,
+       TransportFeedbackObserverGetsCorrectByteCount) {

[minyue-webrtc, 2017/03/29 12:00:39]

Add a reason whey moving this up:

I removed the check of packet size in the next test, see

EXPECT_CALL(feedback_observer_, AddPacket(rtp_sender_->SSRC(),
kTransportSequenceNumber, AddPacket(rtp_sender_->SSRC(),
kTransportSequenceNumber, _, sizeof(kPayloadData) + kGenericHeaderLength,

So I want this test to be placed before it to check the packet size.

+  constexpr int kRtpOverheadBytesPerPacket = 12 + 8;
+  testing::NiceMock<MockOverheadObserver> mock_overhead_observer;
+  rtp_sender_.reset(new RTPSender(
+      false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
+      &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
+      nullptr, &retransmission_rate_limiter_, &mock_overhead_observer));
+  rtp_sender_->SetSSRC(kSsrc);
+  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
+                   kRtpExtensionTransportSequenceNumber,
+                   kTransportSequenceNumberExtensionId));
+  EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
+      .WillOnce(testing::Return(kTransportSequenceNumber));
+
+  const size_t expected_bytes =
+      GetParam() ? sizeof(kPayloadData) + kGenericHeaderLength +
+                       kRtpOverheadBytesPerPacket
+                 : sizeof(kPayloadData) + kGenericHeaderLength;
+
+  EXPECT_CALL(feedback_observer_,
+              AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber,
+                        expected_bytes, PacedPacketInfo()))
+      .Times(1);
+  EXPECT_CALL(mock_overhead_observer,
+              OnOverheadChanged(kRtpOverheadBytesPerPacket))
+      .Times(1);
+  SendGenericPayload();
+}
+
+TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
       &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
@@ -354,10 +392,10 @@ TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
-  EXPECT_CALL(
-      feedback_observer_,
-      AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber,
-                sizeof(kPayloadData) + kGenericHeaderLength, PacedPacketInfo()))
+
+  EXPECT_CALL(feedback_observer_,
+              AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, _,
+                        PacedPacketInfo()))
       .Times(1);
 
   SendGenericPayload();
@@ -369,11 +407,11 @@ TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   EXPECT_EQ(transport_.last_packet_id_, transport_seq_no);
 }
 
-TEST_F(RtpSenderTestWithoutPacer, NoAllocationIfNotRegistered) {
+TEST_P(RtpSenderTestWithoutPacer, NoAllocationIfNotRegistered) {
   SendGenericPayload();
 }
 
-TEST_F(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
+TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
@@ -386,7 +424,7 @@ TEST_F(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
   SendGenericPayload();
 }
 
-TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
+TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
       &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
@@ -405,10 +443,9 @@ TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
-  EXPECT_CALL(
-      feedback_observer_,
-      AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber,
-                sizeof(kPayloadData) + kGenericHeaderLength, PacedPacketInfo()))
+  EXPECT_CALL(feedback_observer_,
+              AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, _,
+                        PacedPacketInfo()))
       .Times(1);
 
   SendGenericPayload();
@@ -423,7 +460,7 @@ TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
   EXPECT_EQ(transport_.last_packet_id_, transport_seq_no);
 }
 
-TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
+TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
                                                kSsrc, kSeqNum, _, _, _));
   EXPECT_CALL(mock_rtc_event_log_,
@@ -468,7 +505,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
   EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
 }
 
-TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
+TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
                                                kSsrc, kSeqNum, _, _, _));
   EXPECT_CALL(mock_rtc_event_log_,
@@ -521,7 +558,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
 
 // This test sends 1 regular video packet, then 4 padding packets, and then
 // 1 more regular packet.
-TEST_F(RtpSenderTest, SendPadding) {
+TEST_P(RtpSenderTest, SendPadding) {
   // Make all (non-padding) packets go to send queue.
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
                                                kSsrc, kSeqNum, _, _, _));
@@ -629,7 +666,7 @@ TEST_F(RtpSenderTest, SendPadding) {
   EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
 }
 
-TEST_F(RtpSenderTest, OnSendPacketUpdated) {
+TEST_P(RtpSenderTest, OnSendPacketUpdated) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
@@ -651,7 +688,7 @@ TEST_F(RtpSenderTest, OnSendPacketUpdated) {
   EXPECT_EQ(1, transport_.packets_sent());
 }
 
-TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
+TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
@@ -671,7 +708,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
   EXPECT_EQ(1, transport_.packets_sent());
 }
 
-TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
+TEST_P(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
       nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
@@ -697,7 +734,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
   EXPECT_EQ(1, transport_.packets_sent());
 }
 
-TEST_F(RtpSenderTest, SendRedundantPayloads) {
+TEST_P(RtpSenderTest, SendRedundantPayloads) {
   MockTransport transport;
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
@@ -766,7 +803,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
             rtp_sender_->TimeToSendPadding(999, PacedPacketInfo()));
 }
 
-TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
+TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) {
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
@@ -800,7 +837,7 @@ TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
   EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload));
 }
 
-TEST_F(RtpSenderTest, SendFlexfecPackets) {
+TEST_P(RtpSenderTest, SendFlexfecPackets) {
   constexpr int kMediaPayloadType = 127;
   constexpr int kFlexfecPayloadType = 118;
   constexpr uint32_t kMediaSsrc = 1234;
@@ -855,7 +892,7 @@ TEST_F(RtpSenderTest, SendFlexfecPackets) {
   EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
 }
 
-TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
+TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
   constexpr int kMediaPayloadType = 127;
   constexpr int kFlexfecPayloadType = 118;
   constexpr uint32_t kMediaSsrc = 1234;
@@ -894,7 +931,7 @@ TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
   EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
 }
 
-TEST_F(RtpSenderTest, FecOverheadRate) {
+TEST_P(RtpSenderTest, FecOverheadRate) {
   constexpr int kMediaPayloadType = 127;
   constexpr int kFlexfecPayloadType = 118;
   constexpr uint32_t kMediaSsrc = 1234;
@@ -940,7 +977,7 @@ TEST_F(RtpSenderTest, FecOverheadRate) {
               rtp_sender_->FecOverheadRate(), 500);
 }
 
-TEST_F(RtpSenderTest, FrameCountCallbacks) {
+TEST_P(RtpSenderTest, FrameCountCallbacks) {
   class TestCallback : public FrameCountObserver {
    public:
     TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
@@ -995,7 +1032,7 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) {
   rtp_sender_.reset();
 }
 
-TEST_F(RtpSenderTest, BitrateCallbacks) {
+TEST_P(RtpSenderTest, BitrateCallbacks) {
   class TestCallback : public BitrateStatisticsObserver {
    public:
     TestCallback()
@@ -1088,7 +1125,7 @@ class RtpSenderAudioTest : public RtpSenderTest {
   }
 };
 
-TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
+TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
   class TestCallback : public StreamDataCountersCallback {
    public:
     TestCallback() : StreamDataCountersCallback(), ssrc_(0), counters_() {}
@@ -1186,7 +1223,7 @@ TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
   rtp_sender_->RegisterRtpStatisticsCallback(nullptr);
 }
 
-TEST_F(RtpSenderAudioTest, SendAudio) {
+TEST_P(RtpSenderAudioTest, SendAudio) {
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
@@ -1201,7 +1238,7 @@ TEST_F(RtpSenderAudioTest, SendAudio) {
   EXPECT_THAT(sent_payload, ElementsAreArray(payload));
 }
 
-TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
+TEST_P(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
   EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
                                                        kAudioLevelExtensionId));
@@ -1233,7 +1270,7 @@ TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
 // This test checks the marker bit for the first packet and the consequent
 // packets of the same telephone event. Since it is specifically for DTMF
 // events, ignoring audio packets and sending kEmptyFrame instead of those.
-TEST_F(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
+TEST_P(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
   const char* kDtmfPayloadName = "telephone-event";
   const uint32_t kPayloadFrequency = 8000;
   const uint8_t kPayloadType = 126;
@@ -1271,7 +1308,7 @@ TEST_F(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
   EXPECT_FALSE(transport_.last_sent_packet().Marker());
 }
 
-TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
+TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
   const char* kPayloadName = "GENERIC";
   const uint8_t kPayloadType = 127;
   rtp_sender_->SetSSRC(1234);
@@ -1318,7 +1355,7 @@ TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
       rtp_stats.transmitted.TotalBytes() + rtx_stats.transmitted.TotalBytes());
 }
 
-TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
+TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
   const int32_t kPacketSize = 1400;
   const int32_t kNumPackets = 30;
 
@@ -1350,7 +1387,7 @@ TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
   EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
 }
 
-TEST_F(RtpSenderVideoTest, KeyFrameHasCVO) {
+TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) {
   uint8_t kFrame[kMaxPacketLength];
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -1367,7 +1404,7 @@ TEST_F(RtpSenderVideoTest, KeyFrameHasCVO) {
   EXPECT_EQ(kVideoRotation_0, rotation);
 }
 
-TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
+TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
   uint8_t kFrame[kMaxPacketLength];
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -1389,7 +1426,7 @@ TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
   EXPECT_EQ(kVideoRotation_0, rotation);
 }
 
-TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
+TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
   uint8_t kFrame[kMaxPacketLength];
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -1412,7 +1449,7 @@ TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
 
 // Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits
 // are set in the CVO byte.
-TEST_F(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
+TEST_P(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
   // Test extracting rotation when Camera (C) and Flip (F) bits are zero.
   EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0));
   EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1));
@@ -1431,14 +1468,7 @@ TEST_F(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3));
 }
 
-namespace {
-class MockOverheadObserver : public OverheadObserver {

[danilchap, 2017/03/29 10:49:11]

you already have this Mock defined above.

[minyue-webrtc, 2017/03/29 12:00:39]

I think I just moved it above

[danilchap, 2017/03/29 12:40:59]

oops, sorry, got confused between 'old code' and 'new code'.

[minyue-webrtc, 2017/04/03 07:12:52]

NP, I sometimes get the exactly same confusion.

- public:
-  MOCK_METHOD1(OnOverheadChanged, void(size_t overhead_bytes_per_packet));
-};
-}  // namespace
-
-TEST_F(RtpSenderTest, OnOverheadChanged) {
+TEST_P(RtpSenderTest, OnOverheadChanged) {
   MockOverheadObserver mock_overhead_observer;
   rtp_sender_.reset(
       new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
@@ -1459,7 +1489,7 @@ TEST_F(RtpSenderTest, OnOverheadChanged) {
   SendGenericPayload();
 }
 
-TEST_F(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
+TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
   MockOverheadObserver mock_overhead_observer;
   rtp_sender_.reset(
       new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
@@ -1472,34 +1502,7 @@ TEST_F(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
   SendGenericPayload();
 }
 
-TEST_F(RtpSenderTest, AddOverheadToTransportFeedbackObserver) {
-  constexpr int kRtpOverheadBytesPerPacket = 12 + 8;
-  test::ScopedFieldTrials override_field_trials(
-      "WebRTC-SendSideBwe-WithOverhead/Enabled/");
-  testing::NiceMock<MockOverheadObserver> mock_overhead_observer;
-  rtp_sender_.reset(new RTPSender(
-      false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
-      &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
-      nullptr, &retransmission_rate_limiter_, &mock_overhead_observer));
-  rtp_sender_->SetSSRC(kSsrc);
-  EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
-                   kRtpExtensionTransportSequenceNumber,
-                   kTransportSequenceNumberExtensionId));
-  EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
-      .WillOnce(testing::Return(kTransportSequenceNumber));
-  EXPECT_CALL(feedback_observer_,
-              AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber,
-                        sizeof(kPayloadData) + kGenericHeaderLength +
-                            kRtpOverheadBytesPerPacket,
-                        PacedPacketInfo()))
-      .Times(1);
-  EXPECT_CALL(mock_overhead_observer,
-              OnOverheadChanged(kRtpOverheadBytesPerPacket))
-      .Times(1);
-  SendGenericPayload();
-}
-
-TEST_F(RtpSenderTest, SendAudioPadding) {
+TEST_P(RtpSenderTest, SendAudioPadding) {
   MockTransport transport;
   const bool kEnableAudio = true;
   rtp_sender_.reset(new RTPSender(
@@ -1525,4 +1528,17 @@ TEST_F(RtpSenderTest, SendAudioPadding) {
       kMinPaddingSize,
       rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5, PacedPacketInfo()));
 }
+
+INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
+                        RtpSenderTest,
+                        ::testing::Bool());
+INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
+                        RtpSenderTestWithoutPacer,
+                        ::testing::Bool());
+INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
+                        RtpSenderVideoTest,
+                        ::testing::Bool());
+INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
+                        RtpSenderAudioTest,
+                        ::testing::Bool());
 }  // namespace webrtc