diff --git a/webrtc/modules/pacing/include/paced_sender.h b/webrtc/modules/pacing/include/paced_sender.h
index afb196fe45..f142f55173 100644
--- a/webrtc/modules/pacing/include/paced_sender.h
+++ b/webrtc/modules/pacing/include/paced_sender.h
@@ -71,11 +71,6 @@ class PacedSender : public Module, public RtpPacketSender {
 
   virtual ~PacedSender();
 
-  // Enable/disable pacing.
-  void SetStatus(bool enable);
-
-  bool Enabled() const;
-
   // Temporarily pause all sending.
   void Pause();
 
@@ -98,12 +93,12 @@ class PacedSender : public Module, public RtpPacketSender {
 
   // Returns true if we send the packet now, else it will add the packet
   // information to the queue and call TimeToSendPacket when it's time to send.
-  bool SendPacket(RtpPacketSender::Priority priority,
-                  uint32_t ssrc,
-                  uint16_t sequence_number,
-                  int64_t capture_time_ms,
-                  size_t bytes,
-                  bool retransmission) override;
+  void InsertPacket(RtpPacketSender::Priority priority,
+                    uint32_t ssrc,
+                    uint16_t sequence_number,
+                    int64_t capture_time_ms,
+                    size_t bytes,
+                    bool retransmission) override;
 
   // Returns the time since the oldest queued packet was enqueued.
   virtual int64_t QueueInMs() const;
@@ -134,7 +129,6 @@ class PacedSender : public Module, public RtpPacketSender {
   Callback* const callback_;
 
   rtc::scoped_ptr<CriticalSectionWrapper> critsect_;
-  bool enabled_ GUARDED_BY(critsect_);
   bool paused_ GUARDED_BY(critsect_);
   bool probing_enabled_;
   // This is the media budget, keeping track of how many bits of media
diff --git a/webrtc/modules/pacing/paced_sender.cc b/webrtc/modules/pacing/paced_sender.cc
index 55c361b085..6a7d19a251 100644
--- a/webrtc/modules/pacing/paced_sender.cc
+++ b/webrtc/modules/pacing/paced_sender.cc
@@ -219,7 +219,6 @@ PacedSender::PacedSender(Clock* clock,
     : clock_(clock),
       callback_(callback),
       critsect_(CriticalSectionWrapper::CreateCriticalSection()),
-      enabled_(true),
       paused_(false),
       probing_enabled_(true),
       media_budget_(new paced_sender::IntervalBudget(max_bitrate_kbps)),
@@ -249,16 +248,6 @@ void PacedSender::SetProbingEnabled(bool enabled) {
   probing_enabled_ = enabled;
 }
 
-void PacedSender::SetStatus(bool enable) {
-  CriticalSectionScoped cs(critsect_.get());
-  enabled_ = enable;
-}
-
-bool PacedSender::Enabled() const {
-  CriticalSectionScoped cs(critsect_.get());
-  return enabled_;
-}
-
 void PacedSender::UpdateBitrate(int bitrate_kbps,
                                 int max_bitrate_kbps,
                                 int min_bitrate_kbps) {
@@ -268,17 +257,14 @@ void PacedSender::UpdateBitrate(int bitrate_kbps,
   bitrate_bps_ = 1000 * bitrate_kbps;
 }
 
-bool PacedSender::SendPacket(RtpPacketSender::Priority priority,
-                             uint32_t ssrc,
-                             uint16_t sequence_number,
-                             int64_t capture_time_ms,
-                             size_t bytes,
-                             bool retransmission) {
+void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
+                               uint32_t ssrc,
+                               uint16_t sequence_number,
+                               int64_t capture_time_ms,
+                               size_t bytes,
+                               bool retransmission) {
   CriticalSectionScoped cs(critsect_.get());
 
-  if (!enabled_) {
-    return true;  // We can send now.
-  }
   if (probing_enabled_ && !prober_->IsProbing()) {
     prober_->SetEnabled(true);
   }
@@ -291,7 +277,6 @@ bool PacedSender::SendPacket(RtpPacketSender::Priority priority,
   packets_->Push(paced_sender::Packet(
       priority, ssrc, sequence_number, capture_time_ms,
       clock_->TimeInMilliseconds(), bytes, retransmission, packet_counter_++));
-  return false;
 }
 
 int64_t PacedSender::ExpectedQueueTimeMs() const {
@@ -334,48 +319,45 @@ int32_t PacedSender::Process() {
   CriticalSectionScoped cs(critsect_.get());
   int64_t elapsed_time_ms = (now_us - time_last_update_us_ + 500) / 1000;
   time_last_update_us_ = now_us;
-  if (!enabled_) {
+  if (paused_)
     return 0;
+  if (elapsed_time_ms > 0) {
+    int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
+    UpdateBytesPerInterval(delta_time_ms);
   }
-  if (!paused_) {
-    if (elapsed_time_ms > 0) {
-      int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
-      UpdateBytesPerInterval(delta_time_ms);
-    }
-    while (!packets_->Empty()) {
-      if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) {
-        return 0;
-      }
-
-      // Since we need to release the lock in order to send, we first pop the
-      // element from the priority queue but keep it in storage, so that we can
-      // reinsert it if send fails.
-      const paced_sender::Packet& packet = packets_->BeginPop();
-      if (SendPacket(packet)) {
-        // Send succeeded, remove it from the queue.
-        packets_->FinalizePop(packet);
-        if (prober_->IsProbing()) {
-          return 0;
-        }
-      } else {
-        // Send failed, put it back into the queue.
-        packets_->CancelPop(packet);
-        return 0;
-      }
-    }
-
-    if (!packets_->Empty())
+  while (!packets_->Empty()) {
+    if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) {
       return 0;
+    }
 
-    size_t padding_needed;
-    if (prober_->IsProbing())
-      padding_needed = prober_->RecommendedPacketSize();
-    else
-      padding_needed = padding_budget_->bytes_remaining();
-
-    if (padding_needed > 0)
-      SendPadding(static_cast<size_t>(padding_needed));
+    // Since we need to release the lock in order to send, we first pop the
+    // element from the priority queue but keep it in storage, so that we can
+    // reinsert it if send fails.
+    const paced_sender::Packet& packet = packets_->BeginPop();
+    if (SendPacket(packet)) {
+      // Send succeeded, remove it from the queue.
+      packets_->FinalizePop(packet);
+      if (prober_->IsProbing()) {
+        return 0;
+      }
+    } else {
+      // Send failed, put it back into the queue.
+      packets_->CancelPop(packet);
+      return 0;
+    }
   }
+
+  if (!packets_->Empty())
+    return 0;
+
+  size_t padding_needed;
+  if (prober_->IsProbing())
+    padding_needed = prober_->RecommendedPacketSize();
+  else
+    padding_needed = padding_budget_->bytes_remaining();
+
+  if (padding_needed > 0)
+    SendPadding(static_cast<size_t>(padding_needed));
   return 0;
 }
 
diff --git a/webrtc/modules/pacing/paced_sender_unittest.cc b/webrtc/modules/pacing/paced_sender_unittest.cc
index a00b5fa58d..1e701ff8ea 100644
--- a/webrtc/modules/pacing/paced_sender_unittest.cc
+++ b/webrtc/modules/pacing/paced_sender_unittest.cc
@@ -124,8 +124,8 @@ class PacedSenderTest : public ::testing::Test {
                            int64_t capture_time_ms,
                            size_t size,
                            bool retransmission) {
-    EXPECT_FALSE(send_bucket_->SendPacket(priority, ssrc,
-        sequence_number, capture_time_ms, size, retransmission));
+    send_bucket_->InsertPacket(priority, ssrc, sequence_number, capture_time_ms,
+                               size, retransmission);
     EXPECT_CALL(callback_,
                 TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
         .Times(1)
@@ -160,8 +160,9 @@ TEST_F(PacedSenderTest, QueuePacket) {
                       250,
                       false);
   int64_t queued_packet_timestamp = clock_.TimeInMilliseconds();
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number, queued_packet_timestamp, 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number, queued_packet_timestamp, 250,
+                             false);
   send_bucket_->Process();
   EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
@@ -188,8 +189,9 @@ TEST_F(PacedSenderTest, QueuePacket) {
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, clock_.TimeInMilliseconds(),
+                             250, false);
   send_bucket_->Process();
 }
 
@@ -207,8 +209,9 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
                         false);
   }
   for (int j = 0; j < 30; ++j) {
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-        sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               250, false);
   }
   send_bucket_->Process();
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
@@ -243,8 +246,9 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) {
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number, clock_.TimeInMilliseconds(), 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number, clock_.TimeInMilliseconds(), 250,
+                             false);
   send_bucket_->Process();
 }
 
@@ -266,10 +270,12 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
 
   for (int j = 0; j < 30; ++j) {
     // Send in duplicate packets.
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-        sequence_number, clock_.TimeInMilliseconds(), 250, false));
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-        sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number, clock_.TimeInMilliseconds(),
+                               250, false);
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               250, false);
   }
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
   send_bucket_->Process();
@@ -308,8 +314,9 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
                       clock_.TimeInMilliseconds(),
                       250,
                       false);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-      sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, clock_.TimeInMilliseconds(),
+                             250, false);
   send_bucket_->Process();
 }
 
@@ -377,23 +384,6 @@ TEST_F(PacedSenderTest, Padding) {
   EXPECT_EQ(0, send_bucket_->Process());
 }
 
-TEST_F(PacedSenderTest, NoPaddingWhenDisabled) {
-  send_bucket_->SetStatus(false);
-  send_bucket_->UpdateBitrate(
-      kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
-  // No padding is expected since the pacer is disabled.
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
-  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
-  clock_.AdvanceTimeMilliseconds(5);
-  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
-  EXPECT_EQ(0, send_bucket_->Process());
-  EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
-  EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
-  clock_.AdvanceTimeMilliseconds(5);
-  EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
-  EXPECT_EQ(0, send_bucket_->Process());
-}
-
 TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
   uint32_t ssrc = 12345;
   uint16_t sequence_number = 1234;
@@ -433,9 +423,9 @@ TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
   size_t media_bytes = 0;
   while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
     size_t media_payload = rand() % 100 + 200;  // [200, 300] bytes.
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
-                                          sequence_number++, capture_time_ms,
-                                          media_payload, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, capture_time_ms,
+                               media_payload, false);
     media_bytes += media_payload;
     clock_.AdvanceTimeMilliseconds(kTimeStep);
     send_bucket_->Process();
@@ -474,15 +464,15 @@ TEST_F(PacedSenderTest, Priority) {
   send_bucket_->Process();
 
   // Expect normal and low priority to be queued and high to pass through.
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
-      ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250,
-      false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
+  send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
+                             sequence_number++, capture_time_ms_low_priority,
+                             250, false);
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
 
   // Expect all high and normal priority to be sent out first.
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
@@ -538,20 +528,20 @@ TEST_F(PacedSenderTest, Pause) {
 
   send_bucket_->Pause();
 
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
-      ssrc, sequence_number++, capture_time_ms, 250, false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number++, capture_time_ms, 250, false);
 
   clock_.AdvanceTimeMilliseconds(10000);
   int64_t second_capture_time_ms = clock_.TimeInMilliseconds();
 
   // Expect everything to be queued.
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
-      ssrc_low_priority, sequence_number++, second_capture_time_ms, 250,
-      false));
+  send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
+                             sequence_number++, second_capture_time_ms, 250,
+                             false);
 
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
             send_bucket_->QueueInMs());
@@ -593,19 +583,12 @@ TEST_F(PacedSenderTest, ResendPacket) {
   int64_t capture_time_ms = clock_.TimeInMilliseconds();
   EXPECT_EQ(0, send_bucket_->QueueInMs());
 
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-                                        ssrc,
-                                        sequence_number,
-                                        capture_time_ms,
-                                        250,
-                                        false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number, capture_time_ms, 250, false);
   clock_.AdvanceTimeMilliseconds(1);
-  EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-                                        ssrc,
-                                        sequence_number + 1,
-                                        capture_time_ms + 1,
-                                        250,
-                                        false));
+  send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                             sequence_number + 1, capture_time_ms + 1, 250,
+                             false);
   clock_.AdvanceTimeMilliseconds(9999);
   EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
             send_bucket_->QueueInMs());
@@ -726,12 +709,9 @@ TEST_F(PacedSenderTest, ProbingWithInitialFrame) {
                       0));
 
   for (int i = 0; i < kNumPackets; ++i) {
-    EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
-                                          ssrc,
-                                          sequence_number++,
-                                          clock_.TimeInMilliseconds(),
-                                          kPacketSize,
-                                          false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               kPacketSize, false);
   }
   while (callback.packets_sent() < kNumPackets) {
     int time_until_process = send_bucket_->TimeUntilNextProcess();
@@ -758,9 +738,9 @@ TEST_F(PacedSenderTest, ProbingWithTooSmallInitialFrame) {
                                      kPaceMultiplier * kInitialBitrateKbps, 0));
 
   for (int i = 0; i < kNumPackets - 5; ++i) {
-    EXPECT_FALSE(send_bucket_->SendPacket(
-        PacedSender::kNormalPriority, ssrc, sequence_number++,
-        clock_.TimeInMilliseconds(), kPacketSize, false));
+    send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+                               sequence_number++, clock_.TimeInMilliseconds(),
+                               kPacketSize, false);
   }
   while (callback.packets_sent() < kNumPackets) {
     int time_until_process = send_bucket_->TimeUntilNextProcess();
@@ -783,21 +763,20 @@ TEST_F(PacedSenderTest, PriorityInversion) {
   uint16_t sequence_number = 1234;
   const size_t kPacketSize = 1200;
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
+  send_bucket_->InsertPacket(
       PacedSender::kHighPriority, ssrc, sequence_number + 3,
-      clock_.TimeInMilliseconds() + 33, kPacketSize, true));
+      clock_.TimeInMilliseconds() + 33, kPacketSize, true);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
+  send_bucket_->InsertPacket(
       PacedSender::kHighPriority, ssrc, sequence_number + 2,
-      clock_.TimeInMilliseconds() + 33, kPacketSize, true));
+      clock_.TimeInMilliseconds() + 33, kPacketSize, true);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
-      PacedSender::kHighPriority, ssrc, sequence_number,
-      clock_.TimeInMilliseconds(), kPacketSize, true));
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number,
+                             clock_.TimeInMilliseconds(), kPacketSize, true);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
-      PacedSender::kHighPriority, ssrc, sequence_number + 1,
-      clock_.TimeInMilliseconds(), kPacketSize, true));
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number + 1, clock_.TimeInMilliseconds(),
+                             kPacketSize, true);
 
   // Packets from earlier frames should be sent first.
   {
@@ -842,9 +821,9 @@ TEST_F(PacedSenderTest, PaddingOveruse) {
   clock_.AdvanceTimeMilliseconds(5);
   send_bucket_->UpdateBitrate(60, 90, 30);
 
-  EXPECT_FALSE(send_bucket_->SendPacket(
-      PacedSender::kHighPriority, ssrc, sequence_number++,
-      clock_.TimeInMilliseconds(), kPacketSize, false));
+  send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+                             sequence_number++, clock_.TimeInMilliseconds(),
+                             kPacketSize, false);
 
   // Don't send padding if queue is non-empty, even if padding budget > 0.
   EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
index 21c2f365ae..f1faa49d7e 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
+++ b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
@@ -209,7 +209,7 @@ void PacedVideoSender::RunFor(int64_t time_ms, Packets* in_out) {
     if (!generated_packets.empty()) {
       for (Packet* packet : generated_packets) {
         MediaPacket* media_packet = static_cast<MediaPacket*>(packet);
-        pacer_.SendPacket(
+        pacer_.InsertPacket(
             PacedSender::kNormalPriority, media_packet->header().ssrc,
             media_packet->header().sequenceNumber, media_packet->send_time_ms(),
             media_packet->payload_size(), false);
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index fdca434ca4..a262a07b62 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -65,7 +65,6 @@ enum ProtectionType {
 };
 
 enum StorageType {
-  kDontStore,
   kDontRetransmit,
   kAllowRetransmission
 };
@@ -108,12 +107,7 @@ enum RTCPPacketType : uint32_t {
   kRtcpTransportFeedback = 0x100000,
 };
 
-enum KeyFrameRequestMethod
-{
-    kKeyFrameReqFirRtp    = 1,
-    kKeyFrameReqPliRtcp   = 2,
-    kKeyFrameReqFirRtcp   = 3
-};
+enum KeyFrameRequestMethod { kKeyFrameReqPliRtcp, kKeyFrameReqFirRtcp };
 
 enum RtpRtcpPacketType
 {
@@ -404,12 +398,12 @@ class RtpPacketSender {
 
   // Returns true if we send the packet now, else it will add the packet
   // information to the queue and call TimeToSendPacket when it's time to send.
-  virtual bool SendPacket(Priority priority,
-                          uint32_t ssrc,
-                          uint16_t sequence_number,
-                          int64_t capture_time_ms,
-                          size_t bytes,
-                          bool retransmission) = 0;
+  virtual void InsertPacket(Priority priority,
+                            uint32_t ssrc,
+                            uint16_t sequence_number,
+                            int64_t capture_time_ms,
+                            size_t bytes,
+                            bool retransmission) = 0;
 };
 
 class TransportSequenceNumberAllocator {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
index cc0cc83bb4..e1d6d4852c 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
@@ -75,10 +75,6 @@ int32_t RTPPacketHistory::PutRTPPacket(const uint8_t* packet,
                                        size_t packet_length,
                                        int64_t capture_time_ms,
                                        StorageType type) {
-  if (type == kDontStore) {
-    return 0;
-  }
-
   CriticalSectionScoped cs(critsect_.get());
   if (!store_) {
     return 0;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
index 4a99e16977..d128494383 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
@@ -93,7 +93,7 @@ class RTPPacketHistory {
     uint16_t sequence_number = 0;
     int64_t time_ms = 0;
     int64_t send_time = 0;
-    StorageType storage_type = kDontStore;
+    StorageType storage_type = kDontRetransmit;
 
     uint8_t data[IP_PACKET_SIZE];
     size_t length = 0;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
index f3b5556a97..a30753adf9 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
@@ -79,20 +79,6 @@ TEST_F(RtpPacketHistoryTest, NoStoreStatus) {
                                               &time));
 }
 
-TEST_F(RtpPacketHistoryTest, DontStore) {
-  hist_->SetStorePacketsStatus(true, 10);
-  size_t len = 0;
-  int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
-  CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
-  EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, capture_time_ms, kDontStore));
-
-  // Packet should not be stored.
-  len = kMaxPacketLength;
-  int64_t time;
-  EXPECT_FALSE(hist_->GetPacketAndSetSendTime(kSeqNum, 0, false, packet_, &len,
-                                              &time));
-}
-
 TEST_F(RtpPacketHistoryTest, PutRtpPacket_TooLargePacketLength) {
   hist_->SetStorePacketsStatus(true, 10);
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 6840d81e3e..29954e2df5 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -93,7 +93,7 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
       nack_last_time_sent_full_(0),
       nack_last_time_sent_full_prev_(0),
       nack_last_seq_number_sent_(0),
-      key_frame_req_method_(kKeyFrameReqFirRtp),
+      key_frame_req_method_(kKeyFrameReqPliRtcp),
       remote_bitrate_(configuration.remote_bitrate_estimator),
       rtt_stats_(configuration.rtt_stats),
       critical_section_rtt_(CriticalSectionWrapper::CreateCriticalSection()),
@@ -811,8 +811,6 @@ int32_t ModuleRtpRtcpImpl::SetKeyFrameRequestMethod(
 
 int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
   switch (key_frame_req_method_) {
-    case kKeyFrameReqFirRtp:
-      return rtp_sender_.SendRTPIntraRequest();
     case kKeyFrameReqPliRtcp:
       return SendRTCP(kRtcpPli);
     case kKeyFrameReqFirRtcp:
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 252ffb2a3e..0c67c6920f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -712,13 +712,11 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) {
     // Convert from TickTime to Clock since capture_time_ms is based on
     // TickTime.
     int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_;
-    if (!paced_sender_->SendPacket(
-            RtpPacketSender::kHighPriority, header.ssrc, header.sequenceNumber,
-            corrected_capture_tims_ms, length - header.headerLength, true)) {
-      // We can't send the packet right now.
-      // We will be called when it is time.
-      return length;
-    }
+    paced_sender_->InsertPacket(
+        RtpPacketSender::kHighPriority, header.ssrc, header.sequenceNumber,
+        corrected_capture_tims_ms, length - header.headerLength, true);
+
+    return length;
   }
   int rtx = kRtxOff;
   {
@@ -1037,24 +1035,21 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer,
     return -1;
   }
 
-  if (paced_sender_ && storage != kDontStore) {
+  if (paced_sender_) {
     // Correct offset between implementations of millisecond time stamps in
     // TickTime and Clock.
     int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_;
-    if (!paced_sender_->SendPacket(priority, rtp_header.ssrc,
-                                   rtp_header.sequenceNumber, corrected_time_ms,
-                                   payload_length, false)) {
-      if (last_capture_time_ms_sent_ == 0 ||
-          corrected_time_ms > last_capture_time_ms_sent_) {
-        last_capture_time_ms_sent_ = corrected_time_ms;
-        TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
-                                 "PacedSend", corrected_time_ms,
-                                 "capture_time_ms", corrected_time_ms);
-      }
-      // We can't send the packet right now.
-      // We will be called when it is time.
-      return 0;
+    paced_sender_->InsertPacket(priority, rtp_header.ssrc,
+                                rtp_header.sequenceNumber, corrected_time_ms,
+                                payload_length, false);
+    if (last_capture_time_ms_sent_ == 0 ||
+        corrected_time_ms > last_capture_time_ms_sent_) {
+      last_capture_time_ms_sent_ = corrected_time_ms;
+      TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                               "PacedSend", corrected_time_ms,
+                               "capture_time_ms", corrected_time_ms);
     }
+    return 0;
   }
   if (capture_time_ms > 0) {
     UpdateDelayStatistics(capture_time_ms, now_ms);
@@ -1063,12 +1058,11 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer,
   size_t length = payload_length + rtp_header_length;
   bool sent = SendPacketToNetwork(buffer, length, PacketOptions());
 
-  if (storage != kDontStore) {
-    // Mark the packet as sent in the history even if send failed. Dropping a
-    // packet here should be treated as any other packet drop so we should be
-    // ready for a retransmission.
-    packet_history_.SetSent(rtp_header.sequenceNumber);
-  }
+  // Mark the packet as sent in the history even if send failed. Dropping a
+  // packet here should be treated as any other packet drop so we should be
+  // ready for a retransmission.
+  packet_history_.SetSent(rtp_header.sequenceNumber);
+
   if (!sent)
     return -1;
 
@@ -1784,13 +1778,6 @@ uint32_t RTPSender::MaxConfiguredBitrateVideo() const {
   return video_->MaxConfiguredBitrateVideo();
 }
 
-int32_t RTPSender::SendRTPIntraRequest() {
-  if (audio_configured_) {
-    return -1;
-  }
-  return video_->SendRTPIntraRequest();
-}
-
 void RTPSender::SetGenericFECStatus(bool enable,
                                     uint8_t payload_type_red,
                                     uint8_t payload_type_fec) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
index 57516f8fe4..a134370c76 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
@@ -283,8 +283,6 @@ class RTPSender : public RTPSenderInterface {
 
   uint32_t MaxConfiguredBitrateVideo() const;
 
-  int32_t SendRTPIntraRequest();
-
   // FEC.
   void SetGenericFECStatus(bool enable,
                            uint8_t payload_type_red,
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 305ea132e2..6d30263fe7 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,14 +125,17 @@ 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 {
+  void SetUp() override { SetUpRtpSender(true); }
+
+  void SetUpRtpSender(bool pacer) {
     rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
-                                    &mock_paced_sender_, nullptr, nullptr,
-                                    nullptr, nullptr, nullptr));
+                                    pacer ? &mock_paced_sender_ : nullptr,
+                                    nullptr, nullptr, nullptr, nullptr,
+                                    nullptr));
     rtp_sender_->SetSequenceNumber(kSeqNum);
   }
 
@@ -174,10 +177,18 @@ class RtpSenderTest : public ::testing::Test {
   }
 };
 
+// TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our
+// default code path.
+class RtpSenderTestWithoutPacer : public RtpSenderTest {
+ public:
+  void SetUp() override { SetUpRtpSender(false); }
+};
+
 class RtpSenderVideoTest : public RtpSenderTest {
  protected:
   virtual void SetUp() override {
-    RtpSenderTest::SetUp();
+    // TODO(pbos): Set up to use pacer.
+    SetUpRtpSender(false);
     rtp_sender_video_.reset(
         new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
   }
@@ -213,7 +224,8 @@ class RtpSenderVideoTest : public RtpSenderTest {
   }
 };
 
-TEST_F(RtpSenderTest, RegisterRtpTransmissionTimeOffsetHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer,
+       RegisterRtpTransmissionTimeOffsetHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
@@ -224,7 +236,7 @@ TEST_F(RtpSenderTest, RegisterRtpTransmissionTimeOffsetHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
-TEST_F(RtpSenderTest, RegisterRtpAbsoluteSendTimeHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAbsoluteSendTimeHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
@@ -236,7 +248,7 @@ TEST_F(RtpSenderTest, RegisterRtpAbsoluteSendTimeHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
-TEST_F(RtpSenderTest, RegisterRtpAudioLevelHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAudioLevelHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAudioLevel, kAudioLevelExtensionId));
@@ -248,7 +260,7 @@ TEST_F(RtpSenderTest, RegisterRtpAudioLevelHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
-TEST_F(RtpSenderTest, RegisterRtpHeaderExtensions) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpHeaderExtensions) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
@@ -298,7 +310,7 @@ TEST_F(RtpSenderTest, RegisterRtpHeaderExtensions) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
-TEST_F(RtpSenderTest, RegisterRtpVideoRotationHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpVideoRotationHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -313,7 +325,7 @@ TEST_F(RtpSenderTest, RegisterRtpVideoRotationHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
 }
 
-TEST_F(RtpSenderTest, BuildRTPPacket) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {
   size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
       packet_, kPayload, kMarkerBit, kTimestamp, 0));
   ASSERT_EQ(kRtpHeaderSize, length);
@@ -338,7 +350,8 @@ TEST_F(RtpSenderTest, BuildRTPPacket) {
   EXPECT_EQ(0u, rtp_header.extension.videoRotation);
 }
 
-TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) {
+TEST_F(RtpSenderTestWithoutPacer,
+       BuildRTPPacketWithTransmissionOffsetExtension) {
   EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
@@ -375,7 +388,8 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) {
   EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
 }
 
-TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
+TEST_F(RtpSenderTestWithoutPacer,
+       BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
   const int kNegTimeOffset = -500;
   EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -403,7 +417,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
   EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset);
 }
 
-TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {
   EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
@@ -440,7 +454,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) {
 }
 
 // Test CVO header extension is only set when marker bit is true.
-TEST_F(RtpSenderTest, BuildRTPPacketWithVideoRotation_MarkerBit) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) {
   rtp_sender_->SetVideoRotation(kRotation);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -468,7 +482,8 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithVideoRotation_MarkerBit) {
 }
 
 // Test CVO header extension is not set when marker bit is false.
-TEST_F(RtpSenderTest, DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
+TEST_F(RtpSenderTestWithoutPacer,
+       DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
   rtp_sender_->SetVideoRotation(kRotation);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -492,7 +507,7 @@ TEST_F(RtpSenderTest, DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
   EXPECT_FALSE(rtp_header.extension.hasVideoRotation);
 }
 
-TEST_F(RtpSenderTest, BuildRTPPacketWithAudioLevelExtension) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
       kRtpExtensionAudioLevel, kAudioLevelExtensionId));
 
@@ -533,7 +548,7 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithAudioLevelExtension) {
   EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
 }
 
-TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {
   EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
   EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
   EXPECT_EQ(0,
@@ -605,9 +620,9 @@ TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
 }
 
 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
-  EXPECT_CALL(mock_paced_sender_,
-              SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
-      .WillOnce(testing::Return(false));
+  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 +670,9 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
 }
 
 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
-  EXPECT_CALL(mock_paced_sender_,
-              SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
-      .WillOnce(testing::Return(false));
+  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 +694,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);
@@ -717,8 +732,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
 TEST_F(RtpSenderTest, SendPadding) {
   // Make all (non-padding) packets go to send queue.
   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 +852,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);
@@ -891,7 +906,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
             rtp_sender_->TimeToSendPadding(999));
 }
 
-TEST_F(RtpSenderTest, SendGenericVideo) {
+TEST_F(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,
@@ -1017,8 +1032,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,13 +1091,13 @@ 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);
   }
 };
 
-TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
+TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
   class TestCallback : public StreamDataCountersCallback {
    public:
     TestCallback()
@@ -1298,7 +1313,7 @@ TEST_F(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
   EXPECT_FALSE(rtp_header.markerBit);
 }
 
-TEST_F(RtpSenderTest, BytesReportedCorrectly) {
+TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
   const char* kPayloadName = "GENERIC";
   const uint8_t kPayloadType = 127;
   rtp_sender_->SetSSRC(1234);
@@ -1351,7 +1366,7 @@ TEST_F(RtpSenderTest, BytesReportedCorrectly) {
             rtx_stats.transmitted.TotalBytes());
 }
 
-TEST_F(RtpSenderTest, RespectsNackBitrateLimit) {
+TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
   const int32_t kPacketSize = 1400;
   const int32_t kNumPackets = 30;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
index a2008bf168..0c7f41a17d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -176,26 +176,6 @@ void RTPSenderVideo::SendVideoPacketAsRed(uint8_t* data_buffer,
   }
 }
 
-int32_t RTPSenderVideo::SendRTPIntraRequest() {
-  // RFC 2032
-  // 5.2.1.  Full intra-frame Request (FIR) packet
-
-  size_t length = 8;
-  uint8_t data[8];
-  data[0] = 0x80;
-  data[1] = 192;
-  data[2] = 0;
-  data[3] = 1;  // length
-
-  ByteWriter<uint32_t>::WriteBigEndian(data + 4, _rtpSender.SSRC());
-
-  TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
-                       "Video::IntraRequest", "seqnum",
-                       _rtpSender.SequenceNumber());
-  return _rtpSender.SendToNetwork(data, 0, length, -1, kDontStore,
-                                  RtpPacketSender::kNormalPriority);
-}
-
 void RTPSenderVideo::SetGenericFECStatus(const bool enable,
                                          const uint8_t payloadTypeRED,
                                          const uint8_t payloadTypeFEC) {
@@ -259,8 +239,8 @@ int32_t RTPSenderVideo::SendVideo(const RtpVideoCodecTypes videoType,
       RtpPacketizer::Create(videoType, _rtpSender.MaxDataPayloadLength(),
                             &(rtpHdr->codecHeader), frameType));
 
-  StorageType storage = kDontStore;
-  bool fec_enabled = false;
+  StorageType storage;
+  bool fec_enabled;
   {
     CriticalSectionScoped cs(crit_.get());
     FecProtectionParams* fec_params =
diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc
index d50bb228f8..018da738fa 100644
--- a/webrtc/video/video_receive_stream.cc
+++ b/webrtc/video/video_receive_stream.cc
@@ -147,7 +147,6 @@ VideoReceiveStream::VideoReceiveStream(int num_cpu_cores,
   // TODO(pbos): This is not fine grained enough...
   vie_channel_->SetProtectionMode(config_.rtp.nack.rtp_history_ms > 0, false,
                                   -1, -1);
-  vie_channel_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
   RTC_DCHECK(config_.rtp.rtcp_mode != RtcpMode::kOff)
       << "A stream should not be configured with RTCP disabled. This value is "
          "reserved for internal usage.";
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 953aa35a6c..d55adf0125 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -183,14 +183,8 @@ VideoSendStream::VideoSendStream(
   if (config_.post_encode_callback)
     vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
 
-  if (config_.suspend_below_min_bitrate) {
+  if (config_.suspend_below_min_bitrate)
     vie_encoder_->SuspendBelowMinBitrate();
-    // Must enable pacing when enabling SuspendBelowMinBitrate. Otherwise, no
-    // padding will be sent when the video is suspended so the video will be
-    // unable to recover.
-    // TODO(pbos): Pacing should probably be enabled outside of VideoSendStream.
-    vie_channel_->SetTransmissionSmoothingStatus(true);
-  }
 
   vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
   vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
diff --git a/webrtc/video_engine/vie_channel.cc b/webrtc/video_engine/vie_channel.cc
index 264964dcbe..84a86f8735 100644
--- a/webrtc/video_engine/vie_channel.cc
+++ b/webrtc/video_engine/vie_channel.cc
@@ -144,7 +144,7 @@ int32_t ViEChannel::Init() {
   // RTP/RTCP initialization.
   module_process_thread_->RegisterModule(rtp_rtcp_modules_[0]);
 
-  rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqFirRtp);
+  rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
   if (paced_sender_) {
     for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
       rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
@@ -609,11 +609,6 @@ int ViEChannel::GetRequiredNackListSize(int target_delay_ms) {
   return target_delay_ms * 40 * 30 / 1000;
 }
 
-int32_t ViEChannel::SetKeyFrameRequestMethod(
-    const KeyFrameRequestMethod method) {
-  return rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(method);
-}
-
 void ViEChannel::EnableRemb(bool enable) {
   rtp_rtcp_modules_[0]->SetREMBStatus(enable);
 }
@@ -702,11 +697,6 @@ void ViEChannel::SetRtcpXrRrtrStatus(bool enable) {
   rtp_rtcp_modules_[0]->SetRtcpXrRrtrStatus(enable);
 }
 
-void ViEChannel::SetTransmissionSmoothingStatus(bool enable) {
-  RTC_DCHECK(paced_sender_ && "No paced sender registered.");
-  paced_sender_->SetStatus(enable);
-}
-
 void ViEChannel::EnableTMMBR(bool enable) {
   rtp_rtcp_modules_[0]->SetTMMBRStatus(enable);
 }
diff --git a/webrtc/video_engine/vie_channel.h b/webrtc/video_engine/vie_channel.h
index cc61080772..ed6521c20d 100644
--- a/webrtc/video_engine/vie_channel.h
+++ b/webrtc/video_engine/vie_channel.h
@@ -109,7 +109,6 @@ class ViEChannel : public VCMFrameTypeCallback,
   bool IsSendingFecEnabled();
   int SetSenderBufferingMode(int target_delay_ms);
   int SetReceiverBufferingMode(int target_delay_ms);
-  int32_t SetKeyFrameRequestMethod(const KeyFrameRequestMethod method);
   void EnableRemb(bool enable);
   int SetSendTimestampOffsetStatus(bool enable, int id);
   int SetReceiveTimestampOffsetStatus(bool enable, int id);
@@ -120,7 +119,6 @@ class ViEChannel : public VCMFrameTypeCallback,
   int SetSendTransportSequenceNumber(bool enable, int id);
   int SetReceiveTransportSequenceNumber(bool enable, int id);
   void SetRtcpXrRrtrStatus(bool enable);
-  void SetTransmissionSmoothingStatus(bool enable);
   void EnableTMMBR(bool enable);
 
   // Sets SSRC for outgoing stream.