diff --git a/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
index 186e135b34..10c947bd84 100644
--- a/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h
@@ -313,13 +313,6 @@ class RtpRtcp : public Module {
   virtual int32_t SendCompoundRTCP(
       const std::set<RTCPPacketType>& rtcp_packet_types) = 0;
 
-  // Notifies the sender about good state of the RTP receiver.
-  virtual int32_t SendRTCPReferencePictureSelection(uint64_t picture_id) = 0;
-
-  // Send a RTCP Slice Loss Indication (SLI).
-  //   |picture_id| - 6 least significant bits of picture_id.
-  virtual int32_t SendRTCPSliceLossIndication(uint8_t picture_id) = 0;
-
   // Returns statistics of the amount of data sent.
   // Returns -1 on failure else 0.
   virtual int32_t DataCountersRTP(size_t* bytes_sent,
diff --git a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
index cc7058a4e4..e8c6eac000 100644
--- a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
@@ -144,8 +144,6 @@ class MockRtpRtcp : public RtpRtcp {
   MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packet_type));
   MOCK_METHOD1(SendCompoundRTCP,
                int32_t(const std::set<RTCPPacketType>& packet_types));
-  MOCK_METHOD1(SendRTCPReferencePictureSelection, int32_t(uint64_t picture_id));
-  MOCK_METHOD1(SendRTCPSliceLossIndication, int32_t(uint8_t picture_id));
   MOCK_CONST_METHOD2(DataCountersRTP,
                      int32_t(size_t* bytes_sent, uint32_t* packets_sent));
   MOCK_CONST_METHOD2(GetSendStreamDataCounters,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
index 986d51acd4..5f2eb759c9 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -30,10 +30,8 @@
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
-#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
@@ -129,18 +127,15 @@ class RTCPSender::RtcpContext {
   RtcpContext(const FeedbackState& feedback_state,
               int32_t nack_size,
               const uint16_t* nack_list,
-              uint64_t picture_id,
               NtpTime now)
       : feedback_state_(feedback_state),
         nack_size_(nack_size),
         nack_list_(nack_list),
-        picture_id_(picture_id),
         now_(now) {}
 
   const FeedbackState& feedback_state_;
   const int32_t nack_size_;
   const uint16_t* nack_list_;
-  const uint64_t picture_id_;
   const NtpTime now_;
 };
 
@@ -190,8 +185,6 @@ RTCPSender::RTCPSender(
   builders_[kRtcpSdes] = &RTCPSender::BuildSDES;
   builders_[kRtcpPli] = &RTCPSender::BuildPLI;
   builders_[kRtcpFir] = &RTCPSender::BuildFIR;
-  builders_[kRtcpSli] = &RTCPSender::BuildSLI;
-  builders_[kRtcpRpsi] = &RTCPSender::BuildRPSI;
   builders_[kRtcpRemb] = &RTCPSender::BuildREMB;
   builders_[kRtcpBye] = &RTCPSender::BuildBYE;
   builders_[kRtcpApp] = &RTCPSender::BuildAPP;
@@ -516,49 +509,6 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
   return std::unique_ptr<rtcp::RtcpPacket>(fir);
 }
 
-/*
-    0                   1                   2                   3
-    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-   |            First        |        Number           | PictureID |
-   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-*/
-std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) {
-  rtcp::Sli* sli = new rtcp::Sli();
-  sli->SetSenderSsrc(ssrc_);
-  sli->SetMediaSsrc(remote_ssrc_);
-  // Crop picture id to 6 least significant bits.
-  sli->AddPictureId(ctx.picture_id_ & 0x3F);
-
-  return std::unique_ptr<rtcp::RtcpPacket>(sli);
-}
-
-/*
-    0                   1                   2                   3
-    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-   |      PB       |0| Payload Type|    Native RPSI bit string     |
-   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-   |   defined per codec          ...                | Padding (0) |
-   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-*/
-/*
-*    Note: not generic made for VP8
-*/
-std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
-    const RtcpContext& ctx) {
-  if (ctx.feedback_state_.send_payload_type == 0xFF)
-    return nullptr;
-
-  rtcp::Rpsi* rpsi = new rtcp::Rpsi();
-  rpsi->SetSenderSsrc(ssrc_);
-  rpsi->SetMediaSsrc(remote_ssrc_);
-  rpsi->SetPayloadType(ctx.feedback_state_.send_payload_type);
-  rpsi->SetPictureId(ctx.picture_id_);
-
-  return std::unique_ptr<rtcp::RtcpPacket>(rpsi);
-}
-
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
     const RtcpContext& ctx) {
   rtcp::Remb* remb = new rtcp::Remb();
@@ -736,19 +686,17 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildExtendedReports(
 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state,
                              RTCPPacketType packetType,
                              int32_t nack_size,
-                             const uint16_t* nack_list,
-                             uint64_t pictureID) {
+                             const uint16_t* nack_list) {
   return SendCompoundRTCP(
       feedback_state, std::set<RTCPPacketType>(&packetType, &packetType + 1),
-      nack_size, nack_list, pictureID);
+      nack_size, nack_list);
 }
 
 int32_t RTCPSender::SendCompoundRTCP(
     const FeedbackState& feedback_state,
     const std::set<RTCPPacketType>& packet_types,
     int32_t nack_size,
-    const uint16_t* nack_list,
-    uint64_t pictureID) {
+    const uint16_t* nack_list) {
   PacketContainer container(transport_, event_log_);
   size_t max_packet_size;
 
@@ -782,7 +730,7 @@ int32_t RTCPSender::SendCompoundRTCP(
       packet_type_counter_.first_packet_time_ms = clock_->TimeInMilliseconds();
 
     // We need to send our NTP even if we haven't received any reports.
-    RtcpContext context(feedback_state, nack_size, nack_list, pictureID,
+    RtcpContext context(feedback_state, nack_size, nack_list,
                         clock_->CurrentNtpTime());
 
     PrepareReport(feedback_state);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
index 76abf63853..c9088c7b97 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
@@ -112,14 +112,12 @@ class RTCPSender {
   int32_t SendRTCP(const FeedbackState& feedback_state,
                    RTCPPacketType packetType,
                    int32_t nackSize = 0,
-                   const uint16_t* nackList = 0,
-                   uint64_t pictureID = 0);
+                   const uint16_t* nackList = 0);
 
   int32_t SendCompoundRTCP(const FeedbackState& feedback_state,
                            const std::set<RTCPPacketType>& packetTypes,
                            int32_t nackSize = 0,
-                           const uint16_t* nackList = 0,
-                           uint64_t pictureID = 0);
+                           const uint16_t* nackList = 0);
 
   bool REMB() const;
 
@@ -186,10 +184,6 @@ class RTCPSender {
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   std::unique_ptr<rtcp::RtcpPacket> BuildFIR(const RtcpContext& context)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-  std::unique_ptr<rtcp::RtcpPacket> BuildSLI(const RtcpContext& context)
-      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
-  std::unique_ptr<rtcp::RtcpPacket> BuildRPSI(const RtcpContext& context)
-      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
   std::unique_ptr<rtcp::RtcpPacket> BuildNACK(const RtcpContext& context)
       EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
index c15ef8d251..2eccadee84 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender_unittest.cc
@@ -472,35 +472,6 @@ TEST_F(RtcpSenderTest, SendPli) {
   EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc());
 }
 
-TEST_F(RtcpSenderTest, SendRpsi) {
-  const uint64_t kPictureId = 0x41;
-  const int8_t kPayloadType = 100;
-  rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
-  RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
-  feedback_state.send_payload_type = kPayloadType;
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRpsi, 0, nullptr,
-                                      kPictureId));
-  EXPECT_EQ(1, parser()->rpsi()->num_packets());
-  EXPECT_EQ(kPayloadType, parser()->rpsi()->payload_type());
-  EXPECT_EQ(kPictureId, parser()->rpsi()->picture_id());
-}
-
-TEST_F(RtcpSenderTest, SendSli) {
-  const uint16_t kFirstMb = 0;
-  const uint16_t kNumberOfMb = 0x1FFF;
-  const uint8_t kPictureId = 60;
-  rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
-  EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSli, 0, nullptr,
-                                      kPictureId));
-  EXPECT_EQ(1, parser()->sli()->num_packets());
-  EXPECT_EQ(kSenderSsrc, parser()->sli()->sender_ssrc());
-  EXPECT_EQ(kRemoteSsrc, parser()->sli()->media_ssrc());
-  EXPECT_EQ(1U, parser()->sli()->macroblocks().size());
-  EXPECT_EQ(kFirstMb, parser()->sli()->macroblocks()[0].first());
-  EXPECT_EQ(kNumberOfMb, parser()->sli()->macroblocks()[0].number());
-  EXPECT_EQ(kPictureId, parser()->sli()->macroblocks()[0].picture_id());
-}
-
 TEST_F(RtcpSenderTest, SendNack) {
   rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
   const uint16_t kList[] = {0, 1, 16};
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 5410e4bdd6..363526196d 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -754,10 +754,6 @@ int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
   return -1;
 }
 
-int32_t ModuleRtpRtcpImpl::SendRTCPSliceLossIndication(uint8_t picture_id) {
-  return rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpSli, 0, 0, picture_id);
-}
-
 void ModuleRtpRtcpImpl::SetUlpfecConfig(int red_payload_type,
                                         int ulpfec_payload_type) {
   rtp_sender_.SetUlpfecConfig(red_payload_type, ulpfec_payload_type);
@@ -789,11 +785,6 @@ void ModuleRtpRtcpImpl::OnRequestSendReport() {
   SendRTCP(kRtcpSr);
 }
 
-int32_t ModuleRtpRtcpImpl::SendRTCPReferencePictureSelection(
-    const uint64_t picture_id) {
-  return rtcp_sender_.SendRTCP(GetFeedbackState(), kRtcpRpsi, 0, 0, picture_id);
-}
-
 void ModuleRtpRtcpImpl::OnReceivedNack(
     const std::vector<uint16_t>& nack_sequence_numbers) {
   for (uint16_t nack_sequence_number : nack_sequence_numbers) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index f286b5e6ee..dfb31c4661 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -269,8 +269,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
 
   // Video part.
 
-  int32_t SendRTCPSliceLossIndication(uint8_t picture_id) override;
-
   // Set method for requesting a new key frame.
   int32_t SetKeyFrameRequestMethod(KeyFrameRequestMethod method) override;
 
@@ -293,9 +291,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
                    uint32_t* fec_rate,
                    uint32_t* nackRate) const override;
 
-  // Good state of RTP receiver inform sender.
-  int32_t SendRTCPReferencePictureSelection(uint64_t picture_id) override;
-
   void RegisterSendChannelRtpStatisticsCallback(
       StreamDataCountersCallback* callback) override;
   StreamDataCountersCallback* GetSendChannelRtpStatisticsCallback()
diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
index 96379283b1..977138e215 100644
--- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
+++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
@@ -191,11 +191,6 @@ class RtpRtcpRtcpTest : public ::testing::Test {
   RateLimiter retransmission_rate_limiter_;
 };
 
-TEST_F(RtpRtcpRtcpTest, RTCP_PLI_RPSI) {
-  EXPECT_EQ(0, module1->SendRTCPReferencePictureSelection(kTestPictureId));
-  EXPECT_EQ(0, module1->SendRTCPSliceLossIndication(kSliPictureId));
-}
-
 TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
   uint32_t testOfCSRC[webrtc::kRtpCsrcSize];
   EXPECT_EQ(2, rtp_receiver2_->CSRCs(testOfCSRC));
diff --git a/webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h b/webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h
index 383798fa15..8a53c1d31a 100644
--- a/webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h
+++ b/webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h
@@ -20,7 +20,6 @@ namespace webrtc {
 class MockVCMFrameTypeCallback : public VCMFrameTypeCallback {
  public:
   MOCK_METHOD0(RequestKeyFrame, int32_t());
-  MOCK_METHOD1(SliceLossIndicationRequest, int32_t(const uint64_t pictureId));
 };
 
 class MockPacketRequestCallback : public VCMPacketRequestCallback {
diff --git a/webrtc/modules/video_coding/include/video_coding_defines.h b/webrtc/modules/video_coding/include/video_coding_defines.h
index 00ad5b66c0..cabe437875 100644
--- a/webrtc/modules/video_coding/include/video_coding_defines.h
+++ b/webrtc/modules/video_coding/include/video_coding_defines.h
@@ -24,7 +24,6 @@ namespace webrtc {
 
 // Error codes
 #define VCM_FRAME_NOT_READY 3
-#define VCM_REQUEST_SLI 2
 #define VCM_MISSING_CALLBACK 1
 #define VCM_OK 0
 #define VCM_GENERAL_ERROR -1
@@ -38,7 +37,6 @@ namespace webrtc {
 #define VCM_JITTER_BUFFER_ERROR -9
 #define VCM_OLD_PACKET_ERROR -10
 #define VCM_NO_FRAME_DECODED -11
-#define VCM_ERROR_REQUEST_SLI -12
 #define VCM_NOT_IMPLEMENTED -20
 
 enum { kDefaultStartBitrateKbps = 300 };
@@ -141,9 +139,6 @@ class VCMProtectionCallback {
 class VCMFrameTypeCallback {
  public:
   virtual int32_t RequestKeyFrame() = 0;
-  virtual int32_t SliceLossIndicationRequest(const uint64_t pictureId) {
-    return -1;
-  }
 
  protected:
   virtual ~VCMFrameTypeCallback() {}
diff --git a/webrtc/modules/video_coding/video_coding_impl.h b/webrtc/modules/video_coding/video_coding_impl.h
index 30641dcf2f..552b613e4d 100644
--- a/webrtc/modules/video_coding/video_coding_impl.h
+++ b/webrtc/modules/video_coding/video_coding_impl.h
@@ -207,7 +207,6 @@ class VideoReceiver : public Module {
   int32_t Decode(const webrtc::VCMEncodedFrame& frame)
       EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
   int32_t RequestKeyFrame();
-  int32_t RequestSliceLossIndication(const uint64_t pictureID) const;
 
  private:
   rtc::ThreadChecker construction_thread_;
diff --git a/webrtc/modules/video_coding/video_receiver.cc b/webrtc/modules/video_coding/video_receiver.cc
index e3f5040cc5..5bd08a129f 100644
--- a/webrtc/modules/video_coding/video_receiver.cc
+++ b/webrtc/modules/video_coding/video_receiver.cc
@@ -306,22 +306,6 @@ void VideoReceiver::DecodingStopped() {
   // TODO(tommi): Make use of this to clarify and check threading model.
 }
 
-int32_t VideoReceiver::RequestSliceLossIndication(
-    const uint64_t pictureID) const {
-  TRACE_EVENT1("webrtc", "RequestSLI", "picture_id", pictureID);
-  rtc::CritScope cs(&process_crit_);
-  if (_frameTypeCallback != nullptr) {
-    const int32_t ret =
-        _frameTypeCallback->SliceLossIndicationRequest(pictureID);
-    if (ret < 0) {
-      return ret;
-    }
-  } else {
-    return VCM_MISSING_CALLBACK;
-  }
-  return VCM_OK;
-}
-
 int32_t VideoReceiver::RequestKeyFrame() {
   TRACE_EVENT0("webrtc", "RequestKeyFrame");
   rtc::CritScope cs(&process_crit_);
@@ -352,16 +336,9 @@ int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
   // Check for failed decoding, run frame type request callback if needed.
   bool request_key_frame = false;
   if (ret < 0) {
-    if (ret == VCM_ERROR_REQUEST_SLI) {
-      return RequestSliceLossIndication(
-          _decodedFrameCallback.LastReceivedPictureID() + 1);
-    } else {
-      request_key_frame = true;
-    }
-  } else if (ret == VCM_REQUEST_SLI) {
-    ret = RequestSliceLossIndication(
-        _decodedFrameCallback.LastReceivedPictureID() + 1);
+    request_key_frame = true;
   }
+
   if (!frame.Complete() || frame.MissingFrame()) {
     request_key_frame = true;
     ret = VCM_OK;
diff --git a/webrtc/video/rtp_stream_receiver.cc b/webrtc/video/rtp_stream_receiver.cc
index b8ef10d549..00f41a29c0 100644
--- a/webrtc/video/rtp_stream_receiver.cc
+++ b/webrtc/video/rtp_stream_receiver.cc
@@ -362,12 +362,6 @@ int32_t RtpStreamReceiver::RequestKeyFrame() {
   return rtp_rtcp_->RequestKeyFrame();
 }
 
-int32_t RtpStreamReceiver::SliceLossIndicationRequest(
-    const uint64_t picture_id) {
-  return rtp_rtcp_->SendRTCPSliceLossIndication(
-      static_cast<uint8_t>(picture_id));
-}
-
 bool RtpStreamReceiver::IsUlpfecEnabled() const {
   return config_.rtp.ulpfec.ulpfec_payload_type != -1;
 }
diff --git a/webrtc/video/rtp_stream_receiver.h b/webrtc/video/rtp_stream_receiver.h
index baae399309..42fa30eed0 100644
--- a/webrtc/video/rtp_stream_receiver.h
+++ b/webrtc/video/rtp_stream_receiver.h
@@ -117,7 +117,6 @@ class RtpStreamReceiver : public RtpData,
 
   // Implements VCMFrameTypeCallback.
   int32_t RequestKeyFrame() override;
-  int32_t SliceLossIndicationRequest(const uint64_t picture_id) override;
 
   bool IsUlpfecEnabled() const;
   bool IsRetransmissionsEnabled() const;