Let FlexfecReceiveStreamImpl send RTCP RRs.

This CL adds an RTP module to FlexfecReceiveStreamImpl, and wires it up
to send RTCP RRs. It further makes some methods take const refs instead
of values, to make it more clear where packet copies are made. This
change reduces the number of copies by one, for the case when media
packets are added to the FlexFEC receiver.

The end-to-end test is modified to check for RTCP RRs being sent.
Part of this modification involves some indentation changes, and the
diff thus looks bigger than it logically is.

BUG=webrtc:5654

Review-Url: https://codereview.webrtc.org/2625633003
Cr-Commit-Position: refs/heads/master@{#16106}

webrtc/call/call.cc

@@ -702,8 +702,9 @@ FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
 
   RecoveredPacketReceiver* recovered_packet_receiver = this;
-  FlexfecReceiveStreamImpl* receive_stream =
-      new FlexfecReceiveStreamImpl(config, recovered_packet_receiver);
+  FlexfecReceiveStreamImpl* receive_stream = new FlexfecReceiveStreamImpl(
+      config, recovered_packet_receiver, call_stats_->rtcp_rtt_stats(),
+      module_process_thread_.get());
 
   {
     WriteLockScoped write_lock(*receive_crit_);
@@ -1165,10 +1166,9 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
           ParseRtpPacket(packet, length, packet_time);
       if (parsed_packet) {
         NotifyBweOfReceivedPacket(*parsed_packet);
-        auto status =
-            it->second->AddAndProcessReceivedPacket(std::move(*parsed_packet))
-                ? DELIVERY_OK
-                : DELIVERY_PACKET_ERROR;
+        auto status = it->second->AddAndProcessReceivedPacket(*parsed_packet)
+                          ? DELIVERY_OK
+                          : DELIVERY_PACKET_ERROR;
         if (status == DELIVERY_OK)
           event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
         return status;

webrtc/call/flexfec_receive_stream_impl.cc

@@ -10,10 +10,16 @@
 
 #include "webrtc/call/flexfec_receive_stream_impl.h"
 
-#include <utility>
+#include <string>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
+#include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "webrtc/modules/utility/include/process_thread.h"
+#include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
@@ -97,33 +103,77 @@ std::unique_ptr<FlexfecReceiver> MaybeCreateFlexfecReceiver(
                           recovered_packet_receiver));
 }
 
+std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
+    ReceiveStatistics* receive_statistics,
+    Transport* rtcp_send_transport,
+    RtcpRttStats* rtt_stats) {
+  RtpRtcp::Configuration configuration;
+  configuration.audio = false;
+  configuration.receiver_only = true;
+  configuration.clock = Clock::GetRealTimeClock();
+  configuration.receive_statistics = receive_statistics;
+  configuration.outgoing_transport = rtcp_send_transport;
+  configuration.rtt_stats = rtt_stats;
+  std::unique_ptr<RtpRtcp> rtp_rtcp(RtpRtcp::CreateRtpRtcp(configuration));
+  return rtp_rtcp;
+}
+
 }  // namespace
 
 FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
     const Config& config,
-    RecoveredPacketReceiver* recovered_packet_receiver)
-    : started_(false),
-      config_(config),
-      receiver_(
-          MaybeCreateFlexfecReceiver(config_, recovered_packet_receiver)) {
+    RecoveredPacketReceiver* recovered_packet_receiver,
+    RtcpRttStats* rtt_stats,
+    ProcessThread* process_thread)
+    : config_(config),
+      started_(false),
+      receiver_(MaybeCreateFlexfecReceiver(config_, recovered_packet_receiver)),
+      rtp_receive_statistics_(
+          ReceiveStatistics::Create(Clock::GetRealTimeClock())),
+      rtp_rtcp_(CreateRtpRtcpModule(rtp_receive_statistics_.get(),
+                                    config_.rtcp_send_transport,
+                                    rtt_stats)),
+      process_thread_(process_thread) {
   LOG(LS_INFO) << "FlexfecReceiveStreamImpl: " << config_.ToString();
+
+  // RTCP reporting.
+  rtp_rtcp_->SetSendingMediaStatus(false);
+  rtp_rtcp_->SetRTCPStatus(config_.rtcp_mode);
+  rtp_rtcp_->SetSSRC(config_.local_ssrc);
+  process_thread_->RegisterModule(rtp_rtcp_.get());
 }
 
 FlexfecReceiveStreamImpl::~FlexfecReceiveStreamImpl() {
   LOG(LS_INFO) << "~FlexfecReceiveStreamImpl: " << config_.ToString();
   Stop();
+  process_thread_->DeRegisterModule(rtp_rtcp_.get());
 }
 
 bool FlexfecReceiveStreamImpl::AddAndProcessReceivedPacket(
-    RtpPacketReceived packet) {
+    const RtpPacketReceived& packet) {
   {
     rtc::CritScope cs(&crit_);
     if (!started_)
       return false;
   }
+
   if (!receiver_)
     return false;
-  return receiver_->AddAndProcessReceivedPacket(std::move(packet));
+
+  if (!receiver_->AddAndProcessReceivedPacket(packet))
+    return false;
+
+  // Do not report media packets in the RTCP RRs generated by |rtp_rtcp_|.
+  if (packet.Ssrc() == config_.remote_ssrc) {
+    RTPHeader header;
+    packet.GetHeader(&header);
+    // FlexFEC packets are never retransmitted.
+    const bool kNotRetransmitted = false;
+    rtp_receive_statistics_->IncomingPacket(header, packet.size(),
+                                            kNotRetransmitted);
+  }
+
+  return true;
 }
 
 void FlexfecReceiveStreamImpl::Start() {

webrtc/call/flexfec_receive_stream_impl.h

@@ -12,25 +12,31 @@
 #define WEBRTC_CALL_FLEXFEC_RECEIVE_STREAM_IMPL_H_
 
 #include <memory>
-#include <string>
 
-#include "webrtc/base/basictypes.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/call/flexfec_receive_stream.h"
-#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 
 namespace webrtc {
 
+class FlexfecReceiver;
+class ProcessThread;
+class ReceiveStatistics;
+class RecoveredPacketReceiver;
+class RtcpRttStats;
+class RtpPacketReceived;
+class RtpRtcp;
+
 class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
  public:
   FlexfecReceiveStreamImpl(const Config& config,
-                           RecoveredPacketReceiver* recovered_packet_receiver);
+                           RecoveredPacketReceiver* recovered_packet_receiver,
+                           RtcpRttStats* rtt_stats,
+                           ProcessThread* process_thread);
   ~FlexfecReceiveStreamImpl() override;
 
   const Config& GetConfig() const { return config_; }
 
-  bool AddAndProcessReceivedPacket(RtpPacketReceived packet);
+  bool AddAndProcessReceivedPacket(const RtpPacketReceived& packet);
 
   // Implements FlexfecReceiveStream.
   void Start() override;
@@ -38,11 +44,18 @@ class FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
   Stats GetStats() const override;
 
  private:
-  rtc::CriticalSection crit_;
-  bool started_ GUARDED_BY(crit_);
-
+  // Config.
   const Config config_;
+  bool started_ GUARDED_BY(crit_);
+  rtc::CriticalSection crit_;
+
+  // Erasure code interfacing.
   const std::unique_ptr<FlexfecReceiver> receiver_;
+
+  // RTCP reporting.
+  const std::unique_ptr<ReceiveStatistics> rtp_receive_statistics_;
+  const std::unique_ptr<RtpRtcp> rtp_rtcp_;
+  ProcessThread* process_thread_;
 };
 
 }  // namespace webrtc

webrtc/call/flexfec_receive_stream_unittest.cc

@@ -12,10 +12,13 @@
 
 #include "webrtc/base/array_view.h"
 #include "webrtc/call/flexfec_receive_stream_impl.h"
+#include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h"
+#include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "webrtc/modules/utility/include/mock/mock_process_thread.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/mock_transport.h"
@@ -74,11 +77,16 @@ class FlexfecReceiveStreamTest : public ::testing::Test {
  protected:
   FlexfecReceiveStreamTest()
       : config_(CreateDefaultConfig(&rtcp_send_transport_)),
-        receive_stream_(config_, &recovered_packet_receiver_) {}
+        receive_stream_(config_,
+                        &recovered_packet_receiver_,
+                        &rtt_stats_,
+                        &process_thread_) {}
 
+  MockTransport rtcp_send_transport_;
   FlexfecReceiveStream::Config config_;
   MockRecoveredPacketReceiver recovered_packet_receiver_;
-  MockTransport rtcp_send_transport_;
+  MockRtcpRttStats rtt_stats_;
+  MockProcessThread process_thread_;
 
   FlexfecReceiveStreamImpl receive_stream_;
 };
@@ -126,7 +134,8 @@ TEST_F(FlexfecReceiveStreamTest, RecoversPacketWhenStarted) {
   // clang-format on
 
   testing::StrictMock<MockRecoveredPacketReceiver> recovered_packet_receiver;
-  FlexfecReceiveStreamImpl receive_stream(config_, &recovered_packet_receiver);
+  FlexfecReceiveStreamImpl receive_stream(config_, &recovered_packet_receiver,
+                                          &rtt_stats_, &process_thread_);
 
   // Do not call back before being started.
   receive_stream.AddAndProcessReceivedPacket(ParsePacket(kFlexfecPacket));