Disable pacer disabling.

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 305ea132e27b9a37e452f46b3167d5c5a715604f..b30274a093697c3a913815578fa694811b9c7e06 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -107,8 +107,8 @@ class MockRtpPacketSender : public RtpPacketSender {
   MockRtpPacketSender() {}
   virtual ~MockRtpPacketSender() {}
 
-  MOCK_METHOD6(SendPacket,
-               bool(Priority priority,
+  MOCK_METHOD6(InsertPacket,
+               void(Priority priority,
                     uint32_t ssrc,
                     uint16_t sequence_number,
                     int64_t capture_time_ms,
@@ -125,16 +125,12 @@ class RtpSenderTest : public ::testing::Test {
         payload_(kPayload),
         transport_(),
         kMarkerBit(true) {
-    EXPECT_CALL(mock_paced_sender_,
-        SendPacket(_, _, _, _, _, _)).WillRepeatedly(testing::Return(true));
+    EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
+        .WillRepeatedly(testing::Return());
   }
 
-  void SetUp() override {
-    rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
-                                    &mock_paced_sender_, nullptr, nullptr,
-                                    nullptr, nullptr, nullptr));
-    rtp_sender_->SetSequenceNumber(kSeqNum);
-  }
+  void SetUp() override { SetUpRtpSender(false); }
+  void SetUpWithPacer() { SetUpRtpSender(true); }

[stefan-webrtc, 2015/10/06 14:32:33]

A nicer way would be to inherit from RtpSenderTest and have a
RtpSenderWithoutPacerTest. WDYT?

[pbos-webrtc, 2015/10/06 14:58:26]

Done.

 
   SimulatedClock fake_clock_;
   MockRtpPacketSender mock_paced_sender_;
@@ -172,6 +168,14 @@ class RtpSenderTest : public ::testing::Test {
                      packet_, payload_length, rtp_length, capture_time_ms,
                      kAllowRetransmission, RtpPacketSender::kNormalPriority));
   }
+ private:
+  void SetUpRtpSender(bool pacer) {
+    rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
+                                    pacer ? &mock_paced_sender_ : nullptr,
+                                    nullptr, nullptr, nullptr, nullptr,
+                                    nullptr));
+    rtp_sender_->SetSequenceNumber(kSeqNum);
+  }
 };
 
 class RtpSenderVideoTest : public RtpSenderTest {
@@ -605,9 +609,10 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
 }
 
 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
-  EXPECT_CALL(mock_paced_sender_,
-              SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
-      .WillOnce(testing::Return(false));
+  SetUpWithPacer();
+  EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
+                                               _, kSeqNum, _, _, _))
+      .WillRepeatedly(testing::Return());
 
   rtp_sender_->SetStorePacketsStatus(true, 10);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -655,9 +660,10 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
 }
 
 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
-  EXPECT_CALL(mock_paced_sender_,
-              SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
-      .WillOnce(testing::Return(false));
+  SetUpWithPacer();
+  EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
+                                               _, kSeqNum, _, _, _))
+      .WillRepeatedly(testing::Return());
 
   rtp_sender_->SetStorePacketsStatus(true, 10);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -679,8 +685,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
   EXPECT_EQ(0, transport_.packets_sent_);
 
   EXPECT_CALL(mock_paced_sender_,
-              SendPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _))
-      .WillOnce(testing::Return(false));
+              InsertPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _))
+      .WillRepeatedly(testing::Return());
 
   const int kStoredTimeInMs = 100;
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
@@ -716,9 +722,10 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
 // 1 more regular packet.
 TEST_F(RtpSenderTest, SendPadding) {
   // Make all (non-padding) packets go to send queue.
+  SetUpWithPacer();
   EXPECT_CALL(mock_paced_sender_,
-              SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
-      .WillRepeatedly(testing::Return(false));
+              InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
+      .WillRepeatedly(testing::Return());
 
   uint16_t seq_num = kSeqNum;
   uint32_t timestamp = kTimestamp;
@@ -837,8 +844,8 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
   rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
   // Make all packets go through the pacer.
   EXPECT_CALL(mock_paced_sender_,
-              SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
-      .WillRepeatedly(testing::Return(false));
+              InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
+      .WillRepeatedly(testing::Return());
 
   uint16_t seq_num = kSeqNum;
   rtp_sender_->SetStorePacketsStatus(true, 10);
@@ -1017,8 +1024,8 @@ TEST_F(RtpSenderTest, BitrateCallbacks) {
     BitrateStatistics retransmit_stats_;
   } callback;
   rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
-                                  &mock_paced_sender_, nullptr, nullptr,
-                                  &callback, nullptr, nullptr));
+                                  nullptr, nullptr, nullptr, &callback, nullptr,
+                                  nullptr));
 
   // Simulate kNumPackets sent with kPacketInterval ms intervals.
   const uint32_t kNumPackets = 15;
@@ -1076,8 +1083,8 @@ class RtpSenderAudioTest : public RtpSenderTest {
   void SetUp() override {
     payload_ = kAudioPayload;
     rtp_sender_.reset(new RTPSender(true, &fake_clock_, &transport_, nullptr,
-                                    &mock_paced_sender_, nullptr, nullptr,
-                                    nullptr, nullptr, nullptr));
+                                    nullptr, nullptr, nullptr, nullptr, nullptr,
+                                    nullptr));
     rtp_sender_->SetSequenceNumber(kSeqNum);
   }
 };