Store the received report blocks map (mapped per remote ssrc) in a map per source ssrc.

When using rtx, receiver reports with two report blocks are received. The report blocks have the same remote ssrc and therefore the first report block was overwritten by the second report block when stored in the ReportBlockInfoMap.

Removed unused function ResetRTT.

BUG=4114
R=mflodman@webrtc.org, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/33659005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@7952 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h

@@ -397,13 +397,6 @@ class RtpRtcp : public Module {
                         uint16_t* minRTT,
                         uint16_t* maxRTT) const = 0 ;
 
-    /*
-    *   Reset RoundTripTime statistics
-    *
-    *   return -1 on failure else 0
-    */
-    virtual int32_t ResetRTT(const uint32_t remoteSSRC)= 0 ;
-
     /*
     *   Force a send of a RTCP packet
     *   normal SR and RR are triggered via the process function

webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h

@@ -160,8 +160,6 @@ class MockRtpRtcp : public RtpRtcp {
       int32_t(const uint32_t SSRC));
   MOCK_CONST_METHOD5(RTT,
       int32_t(const uint32_t remoteSSRC, uint16_t* RTT, uint16_t* avgRTT, uint16_t* minRTT, uint16_t* maxRTT));
-  MOCK_METHOD1(ResetRTT,
-      int32_t(const uint32_t remoteSSRC));
   MOCK_METHOD1(SendRTCP,
       int32_t(uint32_t rtcpPacketType));
   MOCK_METHOD1(SendRTCPReferencePictureSelection,

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

@@ -62,11 +62,14 @@ RTCPReceiver::~RTCPReceiver() {
   delete _criticalSectionRTCPReceiver;
   delete _criticalSectionFeedbacks;
 
-  while (!_receivedReportBlockMap.empty()) {
+  ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
-    std::map<uint32_t, RTCPReportBlockInformation*>::iterator first =
+  for (; it != _receivedReportBlockMap.end(); ++it) {
-        _receivedReportBlockMap.begin();
+    ReportBlockInfoMap* info_map = &(it->second);
-    delete first->second;
+    while (!info_map->empty()) {
-    _receivedReportBlockMap.erase(first);
+      ReportBlockInfoMap::iterator it_info = info_map->begin();
+      delete it_info->second;
+      info_map->erase(it_info);
+    }
   }
   while (!_receivedInfoMap.empty()) {
     std::map<uint32_t, RTCPReceiveInformation*>::iterator first =
@@ -167,21 +170,6 @@ void RTCPReceiver::SetSsrcs(uint32_t main_ssrc,
   }
 }
 
-int32_t RTCPReceiver::ResetRTT(const uint32_t remoteSSRC) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-  RTCPReportBlockInformation* reportBlock =
-      GetReportBlockInformation(remoteSSRC);
-  if (reportBlock == NULL) {
-    LOG(LS_WARNING) << "Failed to reset rtt for ssrc " << remoteSSRC;
-    return -1;
-  }
-  reportBlock->RTT = 0;
-  reportBlock->avgRTT = 0;
-  reportBlock->minRTT = 0;
-  reportBlock->maxRTT = 0;
-  return 0;
-}
-
 int32_t RTCPReceiver::RTT(uint32_t remoteSSRC,
                           uint16_t* RTT,
                           uint16_t* avgRTT,
@@ -190,7 +178,7 @@ int32_t RTCPReceiver::RTT(uint32_t remoteSSRC,
   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
 
   RTCPReportBlockInformation* reportBlock =
-      GetReportBlockInformation(remoteSSRC);
+      GetReportBlockInformation(remoteSSRC, main_ssrc_);
 
   if (reportBlock == NULL) {
     return -1;
@@ -291,13 +279,13 @@ int32_t RTCPReceiver::StatisticsReceived(
     std::vector<RTCPReportBlock>* receiveBlocks) const {
   assert(receiveBlocks);
   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-
+  ReportBlockMap::const_iterator it = _receivedReportBlockMap.begin();
-  std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
+  for (; it != _receivedReportBlockMap.end(); ++it) {
-      _receivedReportBlockMap.begin();
+    const ReportBlockInfoMap* info_map = &(it->second);
-
+    ReportBlockInfoMap::const_iterator it_info = info_map->begin();
-  while (it != _receivedReportBlockMap.end()) {
+    for (; it_info != info_map->end(); ++it_info) {
-    receiveBlocks->push_back(it->second->remoteReceiveBlock);
+      receiveBlocks->push_back(it_info->second->remoteReceiveBlock);
-    it++;
+    }
   }
   return 0;
 }
@@ -505,7 +493,8 @@ void RTCPReceiver::HandleReportBlock(
   _criticalSectionRTCPReceiver->Enter();
 
   RTCPReportBlockInformation* reportBlock =
-      CreateReportBlockInformation(remoteSSRC);
+      CreateOrGetReportBlockInformation(remoteSSRC,
+                                        rtcpPacket.ReportBlockItem.SSRC);
   if (reportBlock == NULL) {
     LOG(LS_WARNING) << "Failed to CreateReportBlockInformation("
                     << remoteSSRC << ")";
@@ -592,34 +581,38 @@ void RTCPReceiver::HandleReportBlock(
   rtcpPacketInformation.AddReportInfo(*reportBlock);
 }
 
-RTCPReportBlockInformation*
+RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation(
-RTCPReceiver::CreateReportBlockInformation(uint32_t remoteSSRC) {
+    uint32_t remote_ssrc,
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+    uint32_t source_ssrc) {
-
+  ReportBlockMap::iterator it = _receivedReportBlockMap.find(source_ssrc);
-  std::map<uint32_t, RTCPReportBlockInformation*>::iterator it =
-      _receivedReportBlockMap.find(remoteSSRC);
-
-  RTCPReportBlockInformation* ptrReportBlockInfo = NULL;
   if (it != _receivedReportBlockMap.end()) {
-    ptrReportBlockInfo = it->second;
+    ReportBlockInfoMap* info_map = &(it->second);
-  } else {
+    ReportBlockInfoMap::iterator it_info = info_map->find(remote_ssrc);
-    ptrReportBlockInfo = new RTCPReportBlockInformation;
+    if (it_info != info_map->end()) {
-    _receivedReportBlockMap[remoteSSRC] = ptrReportBlockInfo;
+      return it_info->second;
     }
-  return ptrReportBlockInfo;
+    RTCPReportBlockInformation* info = new RTCPReportBlockInformation;
+    (*info_map)[remote_ssrc] = info;
+    return info;
+  }
+  RTCPReportBlockInformation* info = new RTCPReportBlockInformation;
+  _receivedReportBlockMap[source_ssrc][remote_ssrc] = info;
+  return info;
 }
 
-RTCPReportBlockInformation*
+RTCPReportBlockInformation* RTCPReceiver::GetReportBlockInformation(
-RTCPReceiver::GetReportBlockInformation(uint32_t remoteSSRC) const {
+    uint32_t remote_ssrc,
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
+    uint32_t source_ssrc) const {
-
+  ReportBlockMap::const_iterator it = _receivedReportBlockMap.find(source_ssrc);
-  std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
-      _receivedReportBlockMap.find(remoteSSRC);
-
   if (it == _receivedReportBlockMap.end()) {
     return NULL;
   }
-  return it->second;
+  const ReportBlockInfoMap* info_map = &(it->second);
+  ReportBlockInfoMap::const_iterator it_info = info_map->find(remote_ssrc);
+  if (it_info == info_map->end()) {
+    return NULL;
+  }
+  return it_info->second;
 }
 
 RTCPCnameInformation*
@@ -874,14 +867,17 @@ void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
 
   // clear our lists
   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-  std::map<uint32_t, RTCPReportBlockInformation*>::iterator
+  ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
-      reportBlockInfoIt = _receivedReportBlockMap.find(
+  for (; it != _receivedReportBlockMap.end(); ++it) {
+    ReportBlockInfoMap* info_map = &(it->second);
+    ReportBlockInfoMap::iterator it_info = info_map->find(
         rtcpPacket.BYE.SenderSSRC);
-
+    if (it_info != info_map->end()) {
-  if (reportBlockInfoIt != _receivedReportBlockMap.end()) {
+      delete it_info->second;
-    delete reportBlockInfoIt->second;
+      info_map->erase(it_info);
-    _receivedReportBlockMap.erase(reportBlockInfoIt);
     }
+  }
+
   //  we can't delete it due to TMMBR
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC);

webrtc/modules/rtp_rtcp/source/rtcp_receiver.h

@@ -15,6 +15,7 @@
 #include <vector>
 #include <set>
 
+#include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
@@ -77,8 +78,6 @@ public:
                 uint16_t* minRTT,
                 uint16_t* maxRTT) const;
 
-    int32_t ResetRTT(const uint32_t remoteSSRC);
-
     int32_t SenderInfoReceived(RTCPSenderInfo* senderInfo) const;
 
     bool GetAndResetXrRrRtt(uint16_t* rtt_ms);
@@ -114,9 +113,6 @@ public:
     RtcpStatisticsCallback* GetRtcpStatisticsCallback();
 
 protected:
-    RTCPHelp::RTCPReportBlockInformation* CreateReportBlockInformation(const uint32_t remoteSSRC);
-    RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(const uint32_t remoteSSRC) const;
-
     RTCPUtility::RTCPCnameInformation* CreateCnameInformation(const uint32_t remoteSSRC);
     RTCPUtility::RTCPCnameInformation* GetCnameInformation(const uint32_t remoteSSRC) const;
 
@@ -220,6 +216,19 @@ protected:
  private:
   typedef std::map<uint32_t, RTCPHelp::RTCPReceiveInformation*>
       ReceivedInfoMap;
+  // RTCP report block information mapped by remote SSRC.
+  typedef std::map<uint32_t, RTCPHelp::RTCPReportBlockInformation*>
+      ReportBlockInfoMap;
+  // RTCP report block information map mapped by source SSRC.
+  typedef std::map<uint32_t, ReportBlockInfoMap> ReportBlockMap;
+
+  RTCPHelp::RTCPReportBlockInformation* CreateOrGetReportBlockInformation(
+      uint32_t remote_ssrc, uint32_t source_ssrc)
+          EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+  RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(
+      uint32_t remote_ssrc, uint32_t source_ssrc) const
+          EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
+
   int32_t _id;
   Clock* _clock;
   RTCPMethod _method;
@@ -250,18 +259,17 @@ protected:
   uint16_t xr_rr_rtt_ms_;
 
   // Received report blocks.
-  std::map<uint32_t, RTCPHelp::RTCPReportBlockInformation*>
+  ReportBlockMap _receivedReportBlockMap
-      _receivedReportBlockMap;
+      GUARDED_BY(_criticalSectionRTCPReceiver);
   ReceivedInfoMap _receivedInfoMap;
-  std::map<uint32_t, RTCPUtility::RTCPCnameInformation*>
+  std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _receivedCnameMap;
-      _receivedCnameMap;
 
   uint32_t _packetTimeOutMS;
 
   // The last time we received an RTCP RR.
   int64_t _lastReceivedRrMs;
 
-  // The time we last received an RTCP RR telling we have ssuccessfully
+  // The time we last received an RTCP RR telling we have successfully
   // delivered RTP packet to the remote side.
   int64_t _lastIncreasedSequenceNumberMs;
 

webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc

@@ -204,6 +204,10 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size());
+
+  std::vector<RTCPReportBlock> received_blocks;
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  EXPECT_TRUE(received_blocks.empty());
 }
 
 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
@@ -223,12 +227,18 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
   EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
   EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
   ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
+
+  std::vector<RTCPReportBlock> received_blocks;
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  EXPECT_EQ(1u, received_blocks.size());
 }
 
 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
   const uint32_t kSenderSsrc = 0x10203;
   const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
   const uint16_t kSequenceNumbers[] = {10, 12423};
+  const uint32_t kCumLost[] = {13, 555};
+  const uint8_t kFracLost[] = {20, 11};
   const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
 
   std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
@@ -258,12 +268,14 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
   rtcp::ReportBlock rb3;
   rb3.To(kSourceSsrcs[0]);
   rb3.WithExtHighestSeqNum(kSequenceNumbers[0]);
+  rb3.WithFractionLost(kFracLost[0]);
+  rb3.WithCumulativeLost(kCumLost[0]);
 
   rtcp::ReportBlock rb4;
   rb4.To(kSourceSsrcs[1]);
   rb4.WithExtHighestSeqNum(kSequenceNumbers[1]);
-  rb4.WithFractionLost(20);
+  rb4.WithFractionLost(kFracLost[1]);
-  rb4.WithCumulativeLost(10);
+  rb4.WithCumulativeLost(kCumLost[1]);
 
   rtcp::ReceiverReport rr2;
   rr2.From(kSenderSsrc);
@@ -273,8 +285,106 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
   rtcp::RawPacket p2 = rr2.Build();
   EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
   ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
-  EXPECT_EQ(0, rtcp_packet_info_.report_blocks.front().fractionLost);
+  EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost);
-  EXPECT_EQ(20, rtcp_packet_info_.report_blocks.back().fractionLost);
+  EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.back().fractionLost);
+
+  std::vector<RTCPReportBlock> received_blocks;
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  EXPECT_EQ(2u, received_blocks.size());
+  for (size_t i = 0; i < received_blocks.size(); ++i) {
+    EXPECT_EQ(kSenderSsrc, received_blocks[i].remoteSSRC);
+    EXPECT_EQ(kSourceSsrcs[i], received_blocks[i].sourceSSRC);
+    EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost);
+    EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost);
+    EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum);
+  }
+}
+
+TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
+  const uint32_t kSenderSsrc1 = 0x10203;
+  const uint32_t kSenderSsrc2 = 0x20304;
+  const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
+  const uint16_t kSequenceNumbers[] = {10, 12423};
+  const uint32_t kCumLost[] = {13, 555};
+  const uint8_t kFracLost[] = {20, 11};
+  const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
+
+  std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
+  rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
+
+  rtcp::ReportBlock rb1;
+  rb1.To(kSourceSsrcs[0]);
+  rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
+  rb1.WithFractionLost(kFracLost[0]);
+  rb1.WithCumulativeLost(kCumLost[0]);
+  rtcp::ReceiverReport rr1;
+  rr1.From(kSenderSsrc1);
+  rr1.WithReportBlock(&rb1);
+
+  rtcp::RawPacket p1 = rr1.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
+  ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
+  EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost);
+
+  std::vector<RTCPReportBlock> received_blocks;
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  EXPECT_EQ(1u, received_blocks.size());
+  EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC);
+  EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC);
+  EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost);
+  EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost);
+  EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum);
+
+  rtcp::ReportBlock rb2;
+  rb2.To(kSourceSsrcs[0]);
+  rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
+  rb2.WithFractionLost(kFracLost[1]);
+  rb2.WithCumulativeLost(kCumLost[1]);
+  rtcp::ReceiverReport rr2;
+  rr2.From(kSenderSsrc2);
+  rr2.WithReportBlock(&rb2);
+  rtcp::RawPacket p2 = rr2.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
+  ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
+  EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.front().fractionLost);
+
+  received_blocks.clear();
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  ASSERT_EQ(2u, received_blocks.size());
+  EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC);
+  EXPECT_EQ(kSenderSsrc2, received_blocks[1].remoteSSRC);
+  for (size_t i = 0; i < received_blocks.size(); ++i) {
+    EXPECT_EQ(kSourceSsrcs[0], received_blocks[i].sourceSSRC);
+    EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost);
+    EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost);
+    EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum);
+  }
+}
+
+TEST_F(RtcpReceiverTest, GetRtt) {
+  const uint32_t kSenderSsrc = 0x10203;
+  const uint32_t kSourceSsrc = 0x123456;
+  std::set<uint32_t> ssrcs;
+  ssrcs.insert(kSourceSsrc);
+  rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
+
+  // No report block received.
+  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
+
+  rtcp::ReportBlock rb;
+  rb.To(kSourceSsrc);
+  rtcp::ReceiverReport rr;
+  rr.From(kSenderSsrc);
+  rr.WithReportBlock(&rb);
+  rtcp::RawPacket p = rr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
+  EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
+  EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
+  EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size());
+  EXPECT_EQ(0, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
+
+  // Report block not received.
+  EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, NULL, NULL, NULL, NULL));
 }
 
 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
@@ -343,7 +453,7 @@ TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
   EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE));
 }
 
-TEST_F(RtcpReceiverTest, InjectByePacket) {
+TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
   const uint32_t kSenderSsrc = 0x123456;
   rtcp::Sdes sdes;
   sdes.WithCName(kSenderSsrc, "alice@host");
@@ -361,6 +471,47 @@ TEST_F(RtcpReceiverTest, InjectByePacket) {
   EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName));
 }
 
+TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
+  const uint32_t kSenderSsrc = 0x10203;
+  const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
+  const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
+
+  std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
+  rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
+
+  rtcp::ReportBlock rb1;
+  rb1.To(kSourceSsrcs[0]);
+  rtcp::ReportBlock rb2;
+  rb2.To(kSourceSsrcs[1]);
+  rtcp::ReceiverReport rr;
+  rr.From(kSenderSsrc);
+  rr.WithReportBlock(&rb1);
+  rr.WithReportBlock(&rb2);
+
+  rtcp::RawPacket p1 = rr.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
+  ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
+  std::vector<RTCPReportBlock> received_blocks;
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  EXPECT_EQ(2u, received_blocks.size());
+
+  // Verify that BYE removes the report blocks.
+  rtcp::Bye bye;
+  bye.From(kSenderSsrc);
+  rtcp::RawPacket p2 = bye.Build();
+  EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
+  received_blocks.clear();
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  EXPECT_TRUE(received_blocks.empty());
+
+  // Inject packet.
+  EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
+  ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
+  received_blocks.clear();
+  rtcp_receiver_->StatisticsReceived(&received_blocks);
+  EXPECT_EQ(2u, received_blocks.size());
+}
+
 TEST_F(RtcpReceiverTest, InjectPliPacket) {
   const uint32_t kSourceSsrc = 0x123456;
   std::set<uint32_t> ssrcs;

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc

@@ -767,11 +767,6 @@ int32_t ModuleRtpRtcpImpl::RTT(const uint32_t remote_ssrc,
   return ret;
 }
 
-// Reset RoundTripTime statistics.
-int32_t ModuleRtpRtcpImpl::ResetRTT(const uint32_t remote_ssrc) {
-  return rtcp_receiver_.ResetRTT(remote_ssrc);
-}
-
 // Reset RTP data counters for the sending side.
 int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
   rtp_sender_.ResetDataCounters();

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h

@@ -164,9 +164,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
                       uint16_t* min_rtt,
                       uint16_t* max_rtt) const OVERRIDE;
 
-  // Reset RoundTripTime statistics.
-  virtual int32_t ResetRTT(const uint32_t remote_ssrc) OVERRIDE;
-
   // Force a send of an RTCP packet.
   // Normal SR and RR are triggered via the process function.
   virtual int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) OVERRIDE;