diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
index 745c90839..e284977d2 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
+++ b/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
diff --git a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
index 859d3e3a3..079f677e9 100644
--- a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
+++ b/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,
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
index b03b68ffe..8e5ac1237 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -62,11 +62,14 @@ RTCPReceiver::~RTCPReceiver() {
   delete _criticalSectionRTCPReceiver;
   delete _criticalSectionFeedbacks;
 
-  while (!_receivedReportBlockMap.empty()) {
-    std::map<uint32_t, RTCPReportBlockInformation*>::iterator first =
-        _receivedReportBlockMap.begin();
-    delete first->second;
-    _receivedReportBlockMap.erase(first);
+  ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
+  for (; it != _receivedReportBlockMap.end(); ++it) {
+    ReportBlockInfoMap* info_map = &(it->second);
+    while (!info_map->empty()) {
+      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);
-
-  std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
-      _receivedReportBlockMap.begin();
-
-  while (it != _receivedReportBlockMap.end()) {
-    receiveBlocks->push_back(it->second->remoteReceiveBlock);
-    it++;
+  ReportBlockMap::const_iterator it = _receivedReportBlockMap.begin();
+  for (; it != _receivedReportBlockMap.end(); ++it) {
+    const ReportBlockInfoMap* info_map = &(it->second);
+    ReportBlockInfoMap::const_iterator it_info = info_map->begin();
+    for (; it_info != info_map->end(); ++it_info) {
+      receiveBlocks->push_back(it_info->second->remoteReceiveBlock);
+    }
   }
   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*
-RTCPReceiver::CreateReportBlockInformation(uint32_t remoteSSRC) {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-
-  std::map<uint32_t, RTCPReportBlockInformation*>::iterator it =
-      _receivedReportBlockMap.find(remoteSSRC);
-
-  RTCPReportBlockInformation* ptrReportBlockInfo = NULL;
+RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation(
+    uint32_t remote_ssrc,
+    uint32_t source_ssrc) {
+  ReportBlockMap::iterator it = _receivedReportBlockMap.find(source_ssrc);
   if (it != _receivedReportBlockMap.end()) {
-    ptrReportBlockInfo = it->second;
-  } else {
-    ptrReportBlockInfo = new RTCPReportBlockInformation;
-    _receivedReportBlockMap[remoteSSRC] = ptrReportBlockInfo;
+    ReportBlockInfoMap* info_map = &(it->second);
+    ReportBlockInfoMap::iterator it_info = info_map->find(remote_ssrc);
+    if (it_info != info_map->end()) {
+      return it_info->second;
+    }
+    RTCPReportBlockInformation* info = new RTCPReportBlockInformation;
+    (*info_map)[remote_ssrc] = info;
+    return info;
   }
-  return ptrReportBlockInfo;
+  RTCPReportBlockInformation* info = new RTCPReportBlockInformation;
+  _receivedReportBlockMap[source_ssrc][remote_ssrc] = info;
+  return info;
 }
 
-RTCPReportBlockInformation*
-RTCPReceiver::GetReportBlockInformation(uint32_t remoteSSRC) const {
-  CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
-
-  std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
-      _receivedReportBlockMap.find(remoteSSRC);
-
+RTCPReportBlockInformation* RTCPReceiver::GetReportBlockInformation(
+    uint32_t remote_ssrc,
+    uint32_t source_ssrc) const {
+  ReportBlockMap::const_iterator it = _receivedReportBlockMap.find(source_ssrc);
   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
-      reportBlockInfoIt = _receivedReportBlockMap.find(
-          rtcpPacket.BYE.SenderSSRC);
-
-  if (reportBlockInfoIt != _receivedReportBlockMap.end()) {
-    delete reportBlockInfoIt->second;
-    _receivedReportBlockMap.erase(reportBlockInfoIt);
+  ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
+  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()) {
+      delete it_info->second;
+      info_map->erase(it_info);
+    }
   }
+
   //  we can't delete it due to TMMBR
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
index ecc5ebed7..b8fcb41e9 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/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,19 +216,32 @@ protected:
  private:
   typedef std::map<uint32_t, RTCPHelp::RTCPReceiveInformation*>
       ReceivedInfoMap;
-  int32_t           _id;
-  Clock*                  _clock;
-  RTCPMethod              _method;
-  int64_t           _lastReceived;
-  ModuleRtpRtcpImpl&      _rtpRtcp;
+  // 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;
+  int64_t _lastReceived;
+  ModuleRtpRtcpImpl& _rtpRtcp;
 
   CriticalSectionWrapper* _criticalSectionFeedbacks;
-  RtcpBandwidthObserver*  _cbRtcpBandwidthObserver;
+  RtcpBandwidthObserver* _cbRtcpBandwidthObserver;
   RtcpIntraFrameObserver* _cbRtcpIntraFrameObserver;
 
   CriticalSectionWrapper* _criticalSectionRTCPReceiver;
-  uint32_t          main_ssrc_;
-  uint32_t          _remoteSSRC;
+  uint32_t main_ssrc_;
+  uint32_t _remoteSSRC;
   std::set<uint32_t> registered_ssrcs_;
 
   // Received send report
@@ -250,18 +259,17 @@ protected:
   uint16_t xr_rr_rtt_ms_;
 
   // Received report blocks.
-  std::map<uint32_t, RTCPHelp::RTCPReportBlockInformation*>
-      _receivedReportBlockMap;
+  ReportBlockMap _receivedReportBlockMap
+      GUARDED_BY(_criticalSectionRTCPReceiver);
   ReceivedInfoMap _receivedInfoMap;
-  std::map<uint32_t, RTCPUtility::RTCPCnameInformation*>
-      _receivedCnameMap;
+  std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _receivedCnameMap;
 
-  uint32_t            _packetTimeOutMS;
+  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;
 
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index f0ffd9ee7..a7d84778e 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/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.WithCumulativeLost(10);
+  rb4.WithFractionLost(kFracLost[1]);
+  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(20, rtcp_packet_info_.report_blocks.back().fractionLost);
+  EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().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;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 6877e830a..642428e1f 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/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();
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index 7e7b0df66..4b1123572 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/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;