Revert "Revert of Parse FlexFEC RTP headers in Call and add integration with BWE. (patchset #17 id:460001 of https://codereview.webrtc.org/2553863003/ )"

Problem fixed: RTP header extensions were not properly set in tests.

BUG=webrtc:5654

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

webrtc/call/call.cc

@@ -24,6 +24,7 @@
 #include "webrtc/base/checks.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/optional.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/base/thread_checker.h"
@@ -39,6 +40,8 @@
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.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"
 #include "webrtc/system_wrappers/include/cpu_info.h"
@@ -107,6 +110,8 @@ class Call : public webrtc::Call,
   // Implements RecoveredPacketReceiver.
   bool OnRecoveredPacket(const uint8_t* packet, size_t length) override;
 
+  void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet);
+
   void SetBitrateConfig(
       const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
 
@@ -154,6 +159,11 @@ class Call : public webrtc::Call,
       return nullptr;
   }
 
+  rtc::Optional<RtpPacketReceived> ParseRtpPacket(const uint8_t* packet,
+                                                  size_t length,
+                                                  const PacketTime& packet_time)
+      SHARED_LOCKS_REQUIRED(receive_crit_);
+
   void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
   void UpdateReceiveHistograms();
   void UpdateHistograms();
@@ -192,6 +202,14 @@ class Call : public webrtc::Call,
   std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
       GUARDED_BY(receive_crit_);
 
+  // Registered RTP header extensions for each stream.
+  // Note that RTP header extensions are negotiated per track ("m= line") in the
+  // SDP, but we have no notion of tracks at the Call level. We therefore store
+  // the RTP header extensions per SSRC instead, which leads to some storage
+  // overhead.
+  std::map<uint32_t, RtpHeaderExtensionMap> received_rtp_header_extensions_
+      GUARDED_BY(receive_crit_);
+
   std::unique_ptr<RWLockWrapper> send_crit_;
   // Audio and Video send streams are owned by the client that creates them.
   std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
@@ -345,6 +363,29 @@ Call::~Call() {
   Trace::ReturnTrace();
 }
 
+rtc::Optional<RtpPacketReceived> Call::ParseRtpPacket(
+    const uint8_t* packet,
+    size_t length,
+    const PacketTime& packet_time) {
+  RtpPacketReceived parsed_packet;
+  if (!parsed_packet.Parse(packet, length))
+    return rtc::Optional<RtpPacketReceived>();
+
+  auto it = received_rtp_header_extensions_.find(parsed_packet.Ssrc());
+  if (it != received_rtp_header_extensions_.end())
+    parsed_packet.IdentifyExtensions(it->second);
+
+  int64_t arrival_time_ms;
+  if (packet_time.timestamp != -1) {
+    arrival_time_ms = (packet_time.timestamp + 500) / 1000;
+  } else {
+    arrival_time_ms = clock_->TimeInMilliseconds();
+  }
+  parsed_packet.set_arrival_time_ms(arrival_time_ms);
+
+  return rtc::Optional<RtpPacketReceived>(std::move(parsed_packet));
+}
+
 void Call::UpdateHistograms() {
   RTC_HISTOGRAM_COUNTS_100000(
       "WebRTC.Call.LifetimeInSeconds",
@@ -659,25 +700,40 @@ FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
     const FlexfecReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
+
+  RecoveredPacketReceiver* recovered_packet_receiver = this;
   FlexfecReceiveStreamImpl* receive_stream =
-      new FlexfecReceiveStreamImpl(config, this);
+      new FlexfecReceiveStreamImpl(config, recovered_packet_receiver);
 
   {
     WriteLockScoped write_lock(*receive_crit_);
+
+    RTC_DCHECK(flexfec_receive_streams_.find(receive_stream) ==
+               flexfec_receive_streams_.end());
+    flexfec_receive_streams_.insert(receive_stream);
+
     for (auto ssrc : config.protected_media_ssrcs)
       flexfec_receive_ssrcs_media_.insert(std::make_pair(ssrc, receive_stream));
+
     RTC_DCHECK(flexfec_receive_ssrcs_protection_.find(config.remote_ssrc) ==
                flexfec_receive_ssrcs_protection_.end());
     flexfec_receive_ssrcs_protection_[config.remote_ssrc] = receive_stream;
-    flexfec_receive_streams_.insert(receive_stream);
+
+    RTC_DCHECK(received_rtp_header_extensions_.find(config.remote_ssrc) ==
+               received_rtp_header_extensions_.end());
+    RtpHeaderExtensionMap rtp_header_extensions(config.rtp_header_extensions);
+    received_rtp_header_extensions_[config.remote_ssrc] = rtp_header_extensions;
   }
+
   // TODO(brandtr): Store config in RtcEventLog here.
+
   return receive_stream;
 }
 
 void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
+
   RTC_DCHECK(receive_stream != nullptr);
   // There exist no other derived classes of FlexfecReceiveStream,
   // so this downcast is safe.
@@ -685,15 +741,12 @@ void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) {
       static_cast<FlexfecReceiveStreamImpl*>(receive_stream);
   {
     WriteLockScoped write_lock(*receive_crit_);
+
+    uint32_t ssrc = receive_stream_impl->GetConfig().remote_ssrc;
+    received_rtp_header_extensions_.erase(ssrc);
+
     // Remove all SSRCs pointing to the FlexfecReceiveStreamImpl to be
     // destroyed.
-    auto media_it = flexfec_receive_ssrcs_media_.begin();
-    while (media_it != flexfec_receive_ssrcs_media_.end()) {
-      if (media_it->second == receive_stream_impl)
-        media_it = flexfec_receive_ssrcs_media_.erase(media_it);
-      else
-        ++media_it;
-    }
     auto prot_it = flexfec_receive_ssrcs_protection_.begin();
     while (prot_it != flexfec_receive_ssrcs_protection_.end()) {
       if (prot_it->second == receive_stream_impl)
@@ -701,8 +754,17 @@ void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) {
       else
         ++prot_it;
     }
+    auto media_it = flexfec_receive_ssrcs_media_.begin();
+    while (media_it != flexfec_receive_ssrcs_media_.end()) {
+      if (media_it->second == receive_stream_impl)
+        media_it = flexfec_receive_ssrcs_media_.erase(media_it);
+      else
+        ++media_it;
+    }
+
     flexfec_receive_streams_.erase(receive_stream_impl);
   }
+
   delete receive_stream_impl;
 }
 
@@ -1076,13 +1138,21 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
     if (it != video_receive_ssrcs_.end()) {
       received_bytes_per_second_counter_.Add(static_cast<int>(length));
       received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
+      // TODO(brandtr): Notify the BWE of received media packets here.
       auto status = it->second->DeliverRtp(packet, length, packet_time)
                         ? DELIVERY_OK
                         : DELIVERY_PACKET_ERROR;
-      // Deliver media packets to FlexFEC subsystem.
-      auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
-      for (auto it = it_bounds.first; it != it_bounds.second; ++it)
-        it->second->AddAndProcessReceivedPacket(packet, length);
+      // Deliver media packets to FlexFEC subsystem. RTP header extensions need
+      // not be parsed, as FlexFEC is oblivious to the semantic meaning of the
+      // packet contents beyond the 12 byte RTP base header. The BWE is fed
+      // information about these media packets from the regular media pipeline.
+      rtc::Optional<RtpPacketReceived> parsed_packet =
+          ParseRtpPacket(packet, length, packet_time);
+      if (parsed_packet) {
+        auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
+        for (auto it = it_bounds.first; it != it_bounds.second; ++it)
+          it->second->AddAndProcessReceivedPacket(*parsed_packet);
+      }
       if (status == DELIVERY_OK)
         event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
       return status;
@@ -1091,12 +1161,18 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     auto it = flexfec_receive_ssrcs_protection_.find(ssrc);
     if (it != flexfec_receive_ssrcs_protection_.end()) {
-      auto status = it->second->AddAndProcessReceivedPacket(packet, length)
-                        ? DELIVERY_OK
-                        : DELIVERY_PACKET_ERROR;
-      if (status == DELIVERY_OK)
-        event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
-      return status;
+      rtc::Optional<RtpPacketReceived> parsed_packet =
+          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;
+        if (status == DELIVERY_OK)
+          event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
+        return status;
+      }
     }
   }
   return DELIVERY_UNKNOWN_SSRC;
@@ -1128,5 +1204,12 @@ bool Call::OnRecoveredPacket(const uint8_t* packet, size_t length) {
   return it->second->OnRecoveredPacket(packet, length);
 }
 
+void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet) {
+  RTPHeader header;
+  packet.GetHeader(&header);
+  congestion_controller_->OnReceivedPacket(packet.arrival_time_ms(),
+                                           packet.payload_size(), header);
+}
+
 }  // namespace internal
 }  // namespace webrtc

webrtc/call/flexfec_receive_stream.h

@@ -59,7 +59,7 @@ class FlexfecReceiveStream {
     bool transport_cc = false;
 
     // RTP header extensions that have been negotiated for this track.
-    std::vector<RtpExtension> extensions;
+    std::vector<RtpExtension> rtp_header_extensions;
   };
 
   // Starts stream activity.

webrtc/call/flexfec_receive_stream_impl.cc

@@ -10,6 +10,8 @@
 
 #include "webrtc/call/flexfec_receive_stream_impl.h"
 
+#include <utility>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 
@@ -34,12 +36,12 @@ std::string FlexfecReceiveStream::Config::ToString() const {
   if (!protected_media_ssrcs.empty())
     ss << protected_media_ssrcs[i];
   ss << "], transport_cc: " << (transport_cc ? "on" : "off");
-  ss << ", extensions: [";
+  ss << ", rtp_header_extensions: [";
   i = 0;
-  for (; i + 1 < extensions.size(); ++i)
-    ss << extensions[i].ToString() << ", ";
-  if (!extensions.empty())
-    ss << extensions[i].ToString();
+  for (; i + 1 < rtp_header_extensions.size(); ++i)
+    ss << rtp_header_extensions[i].ToString() << ", ";
+  if (!rtp_header_extensions.empty())
+    ss << rtp_header_extensions[i].ToString();
   ss << "]}";
   return ss.str();
 }
@@ -49,7 +51,7 @@ namespace {
 // TODO(brandtr): Update this function when we support multistream protection.
 std::unique_ptr<FlexfecReceiver> MaybeCreateFlexfecReceiver(
     const FlexfecReceiveStream::Config& config,
-    RecoveredPacketReceiver* recovered_packet_callback) {
+    RecoveredPacketReceiver* recovered_packet_receiver) {
   if (config.payload_type < 0) {
     LOG(LS_WARNING) << "Invalid FlexFEC payload type given. "
                     << "This FlexfecReceiveStream will therefore be useless.";
@@ -79,18 +81,18 @@ std::unique_ptr<FlexfecReceiver> MaybeCreateFlexfecReceiver(
   RTC_DCHECK_EQ(1U, config.protected_media_ssrcs.size());
   return std::unique_ptr<FlexfecReceiver>(
       new FlexfecReceiver(config.remote_ssrc, config.protected_media_ssrcs[0],
-                          recovered_packet_callback));
+                          recovered_packet_receiver));
 }
 
 }  // namespace
 
 FlexfecReceiveStreamImpl::FlexfecReceiveStreamImpl(
     const Config& config,
-    RecoveredPacketReceiver* recovered_packet_callback)
+    RecoveredPacketReceiver* recovered_packet_receiver)
     : started_(false),
       config_(config),
       receiver_(
-          MaybeCreateFlexfecReceiver(config_, recovered_packet_callback)) {
+          MaybeCreateFlexfecReceiver(config_, recovered_packet_receiver)) {
   LOG(LS_INFO) << "FlexfecReceiveStreamImpl: " << config_.ToString();
 }
 
@@ -100,8 +102,7 @@ FlexfecReceiveStreamImpl::~FlexfecReceiveStreamImpl() {
 }
 
 bool FlexfecReceiveStreamImpl::AddAndProcessReceivedPacket(
-    const uint8_t* packet,
-    size_t packet_length) {
+    RtpPacketReceived packet) {
   {
     rtc::CritScope cs(&crit_);
     if (!started_)
@@ -109,7 +110,7 @@ bool FlexfecReceiveStreamImpl::AddAndProcessReceivedPacket(
   }
   if (!receiver_)
     return false;
-  return receiver_->AddAndProcessReceivedPacket(packet, packet_length);
+  return receiver_->AddAndProcessReceivedPacket(std::move(packet));
 }
 
 void FlexfecReceiveStreamImpl::Start() {

webrtc/call/flexfec_receive_stream_impl.h

@@ -18,16 +18,19 @@
 #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 FlexfecReceiveStreamImpl : public FlexfecReceiveStream {
  public:
   FlexfecReceiveStreamImpl(const Config& config,
-                           RecoveredPacketReceiver* recovered_packet_callback);
+                           RecoveredPacketReceiver* recovered_packet_receiver);
   ~FlexfecReceiveStreamImpl() override;
 
-  bool AddAndProcessReceivedPacket(const uint8_t* packet, size_t length);
+  const Config& GetConfig() const { return config_; }
+
+  bool AddAndProcessReceivedPacket(RtpPacketReceived packet);
 
   // Implements FlexfecReceiveStream.
   void Start() override;

webrtc/call/flexfec_receive_stream_unittest.cc

@@ -8,24 +8,36 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include "webrtc/base/array_view.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/call/flexfec_receive_stream_impl.h"
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 
+namespace {
+
+RtpPacketReceived ParsePacket(rtc::ArrayView<const uint8_t> packet) {
+  RtpPacketReceived parsed_packet(nullptr);
+  EXPECT_TRUE(parsed_packet.Parse(packet));
+  return parsed_packet;
+}
+
+}  // namespace
+
 TEST(FlexfecReceiveStreamTest, ConstructDestruct) {
   FlexfecReceiveStream::Config config;
   config.payload_type = 118;
   config.remote_ssrc = 424223;
   config.protected_media_ssrcs = {912512};
-  MockRecoveredPacketReceiver callback;
+  MockRecoveredPacketReceiver recovered_packet_receiver;
 
-  FlexfecReceiveStreamImpl receive_stream(config, &callback);
+  FlexfecReceiveStreamImpl receive_stream(config, &recovered_packet_receiver);
 }
 
 TEST(FlexfecReceiveStreamTest, StartStop) {
@@ -33,27 +45,13 @@ TEST(FlexfecReceiveStreamTest, StartStop) {
   config.payload_type = 118;
   config.remote_ssrc = 1652392;
   config.protected_media_ssrcs = {23300443};
-  MockRecoveredPacketReceiver callback;
-  FlexfecReceiveStreamImpl receive_stream(config, &callback);
+  MockRecoveredPacketReceiver recovered_packet_receiver;
+  FlexfecReceiveStreamImpl receive_stream(config, &recovered_packet_receiver);
 
   receive_stream.Start();
   receive_stream.Stop();
 }
 
-TEST(FlexfecReceiveStreamTest, DoesNotProcessPacketWhenNoMediaSsrcGiven) {
-  FlexfecReceiveStream::Config config;
-  config.payload_type = 118;
-  config.remote_ssrc = 424223;
-  config.protected_media_ssrcs = {};
-  MockRecoveredPacketReceiver callback;
-  FlexfecReceiveStreamImpl receive_stream(config, &callback);
-  const uint8_t packet[] = {0x00, 0x11, 0x22, 0x33};
-  const size_t packet_length = sizeof(packet);
-
-  EXPECT_FALSE(
-      receive_stream.AddAndProcessReceivedPacket(packet, packet_length));
-}
-
 // Create a FlexFEC packet that protects a single media packet and ensure
 // that the callback is called. Correctness of recovery is checked in the
 // FlexfecReceiver unit tests.
@@ -91,7 +89,6 @@ TEST(FlexfecReceiveStreamTest, RecoversPacketWhenStarted) {
       // FEC payload.
       kPayloadBits,    kPayloadBits,    kPayloadBits,       kPayloadBits};
   // clang-format on
-  constexpr size_t kFlexfecPacketLength = sizeof(kFlexfecPacket);
 
   FlexfecReceiveStream::Config config;
   config.payload_type = kFlexfecPlType;
@@ -102,16 +99,14 @@ TEST(FlexfecReceiveStreamTest, RecoversPacketWhenStarted) {
   FlexfecReceiveStreamImpl receive_stream(config, &recovered_packet_receiver);
 
   // Do not call back before being started.
-  receive_stream.AddAndProcessReceivedPacket(kFlexfecPacket,
-                                             kFlexfecPacketLength);
+  receive_stream.AddAndProcessReceivedPacket(ParsePacket(kFlexfecPacket));
 
   // Call back after being started.
   receive_stream.Start();
   EXPECT_CALL(
       recovered_packet_receiver,
       OnRecoveredPacket(::testing::_, kRtpHeaderSize + kPayloadLength[1]));
-  receive_stream.AddAndProcessReceivedPacket(kFlexfecPacket,
-                                             kFlexfecPacketLength);
+  receive_stream.AddAndProcessReceivedPacket(ParsePacket(kFlexfecPacket));
 }
 
 }  // namespace webrtc

webrtc/media/engine/webrtcvideoengine2.cc

@@ -2349,7 +2349,7 @@ void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() {
     // RTCP messages and RTP header extensions apply to the entire track
     // in the SDP.
     config.transport_cc = config_.rtp.transport_cc;
-    config.extensions = config_.rtp.extensions;
+    config.rtp_header_extensions = config_.rtp.extensions;
     flexfec_stream_ = call_->CreateFlexfecReceiveStream(config);
     flexfec_stream_->Start();
   }

webrtc/modules/congestion_controller/congestion_controller.cc

@@ -197,6 +197,23 @@ CongestionController::CongestionController(
 
 CongestionController::~CongestionController() {}
 
+void CongestionController::OnReceivedPacket(int64_t arrival_time_ms,
+                                            size_t payload_size,
+                                            const RTPHeader& header) {
+  // Send-side BWE.
+  if (header.extension.hasTransportSequenceNumber) {
+    remote_estimator_proxy_.IncomingPacket(arrival_time_ms, payload_size,
+                                           header);
+    return;
+  }
+
+  // Receive-side BWE.
+  if (remote_bitrate_estimator_) {
+    remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
+                                              header);
+  }
+}
+
 void CongestionController::SetBweBitrates(int min_bitrate_bps,
                                           int start_bitrate_bps,
                                           int max_bitrate_bps) {

webrtc/modules/congestion_controller/congestion_controller_unittest.cc

@@ -26,6 +26,18 @@ using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
+namespace {
+
+// Helper to convert some time format to resolution used in absolute send time
+// header extension, rounded upwards. |t| is the time to convert, in some
+// resolution. |denom| is the value to divide |t| by to get whole seconds,
+// e.g. |denom| = 1000 if |t| is in milliseconds.
+uint32_t AbsSendTime(int64_t t, int64_t denom) {
+  return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful;
+}
+
+}  // namespace
+
 namespace webrtc {
 namespace test {
 
@@ -201,5 +213,33 @@ TEST_F(CongestionControllerTest, GetProbingInterval) {
   controller_->Process();
 }
 
+TEST_F(CongestionControllerTest, OnReceivedPacketWithAbsSendTime) {
+  NiceMock<MockCongestionObserver> observer;
+  StrictMock<MockRemoteBitrateObserver> remote_bitrate_observer;
+  std::unique_ptr<PacedSender> pacer(new NiceMock<MockPacedSender>());
+  controller_.reset(
+      new CongestionController(&clock_, &observer, &remote_bitrate_observer,
+                               &event_log_, &packet_router_, std::move(pacer)));
+
+  size_t payload_size = 1000;
+  RTPHeader header;
+  header.ssrc = 0x11eb21c;
+  header.extension.hasAbsoluteSendTime = true;
+
+  std::vector<unsigned int> ssrcs;
+  EXPECT_CALL(remote_bitrate_observer, OnReceiveBitrateChanged(_, _))
+      .WillRepeatedly(SaveArg<0>(&ssrcs));
+
+  for (int i = 0; i < 10; ++i) {
+    clock_.AdvanceTimeMilliseconds((1000 * payload_size) / kInitialBitrateBps);
+    int64_t now_ms = clock_.TimeInMilliseconds();
+    header.extension.absoluteSendTime = AbsSendTime(now_ms, 1000);
+    controller_->OnReceivedPacket(now_ms, payload_size, header);
+  }
+
+  ASSERT_EQ(1u, ssrcs.size());
+  EXPECT_EQ(header.ssrc, ssrcs[0]);
+}
+
 }  // namespace test
 }  // namespace webrtc

webrtc/modules/congestion_controller/include/congestion_controller.h

@@ -68,6 +68,10 @@ class CongestionController : public CallStatsObserver, public Module {
                        std::unique_ptr<PacedSender> pacer);
   virtual ~CongestionController();
 
+  virtual void OnReceivedPacket(int64_t arrival_time_ms,
+                                size_t payload_size,
+                                const RTPHeader& header);
+
   virtual void SetBweBitrates(int min_bitrate_bps,
                               int start_bitrate_bps,
                               int max_bitrate_bps);

webrtc/modules/congestion_controller/include/mock/mock_congestion_controller.h

@@ -13,6 +13,7 @@
 
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/socket.h"
+#include "webrtc/common_types.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/test/gmock.h"
 
@@ -44,6 +45,10 @@ class MockCongestionController : public CongestionController {
                              remote_bitrate_observer,
                              event_log,
                              packet_router) {}
+  MOCK_METHOD3(OnReceivedPacket,
+               void(int64_t arrival_time_ms,
+                    size_t payload_size,
+                    const RTPHeader& header));
   MOCK_METHOD3(SetBweBitrates,
                void(int min_bitrate_bps,
                     int start_bitrate_bps,

webrtc/modules/rtp_rtcp/include/flexfec_receiver.h

@@ -16,9 +16,9 @@
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/sequenced_task_checker.h"
 #include "webrtc/call/call.h"
-#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/ulpfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
@@ -37,19 +37,19 @@ class FlexfecReceiver {
  public:
   FlexfecReceiver(uint32_t ssrc,
                   uint32_t protected_media_ssrc,
-                  RecoveredPacketReceiver* callback);
+                  RecoveredPacketReceiver* recovered_packet_receiver);
   ~FlexfecReceiver();
 
   // Inserts a received packet (can be either media or FlexFEC) into the
   // internal buffer, and sends the received packets to the erasure code.
   // All newly recovered packets are sent back through the callback.
-  bool AddAndProcessReceivedPacket(const uint8_t* packet, size_t packet_length);
+  bool AddAndProcessReceivedPacket(RtpPacketReceived packet);
 
   // Returns a counter describing the added and recovered packets.
   FecPacketCounter GetPacketCounter() const;
 
  private:
-  bool AddReceivedPacket(const uint8_t* packet, size_t packet_length);
+  bool AddReceivedPacket(RtpPacketReceived packet);
   bool ProcessReceivedPackets();
 
   // Config.
@@ -63,7 +63,7 @@ class FlexfecReceiver {
       GUARDED_BY(sequence_checker_);
   ForwardErrorCorrection::RecoveredPacketList recovered_packets_
       GUARDED_BY(sequence_checker_);
-  RecoveredPacketReceiver* const callback_ GUARDED_BY(sequence_checker_);
+  RecoveredPacketReceiver* const recovered_packet_receiver_;
 
   // Logging and stats.
   Clock* const clock_;

webrtc/modules/rtp_rtcp/source/flexfec_receiver.cc

@@ -10,11 +10,8 @@
 
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 
-#include <utility>
-
 #include "webrtc/base/logging.h"
 #include "webrtc/base/scoped_ref_ptr.h"
-#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 
 namespace webrtc {
 
@@ -31,13 +28,14 @@ constexpr int kPacketLogIntervalMs = 10000;
 
 }  // namespace
 
-FlexfecReceiver::FlexfecReceiver(uint32_t ssrc,
-                                 uint32_t protected_media_ssrc,
-                                 RecoveredPacketReceiver* callback)
+FlexfecReceiver::FlexfecReceiver(
+    uint32_t ssrc,
+    uint32_t protected_media_ssrc,
+    RecoveredPacketReceiver* recovered_packet_receiver)
     : ssrc_(ssrc),
       protected_media_ssrc_(protected_media_ssrc),
       erasure_code_(ForwardErrorCorrection::CreateFlexfec()),
-      callback_(callback),
+      recovered_packet_receiver_(recovered_packet_receiver),
       clock_(Clock::GetRealTimeClock()),
       last_recovered_packet_ms_(-1) {
   // It's OK to create this object on a different thread/task queue than
@@ -47,10 +45,9 @@ FlexfecReceiver::FlexfecReceiver(uint32_t ssrc,
 
 FlexfecReceiver::~FlexfecReceiver() = default;
 
-bool FlexfecReceiver::AddAndProcessReceivedPacket(const uint8_t* packet,
-                                                  size_t packet_length) {
+bool FlexfecReceiver::AddAndProcessReceivedPacket(RtpPacketReceived packet) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
-  if (!AddReceivedPacket(packet, packet_length)) {
+  if (!AddReceivedPacket(std::move(packet))) {
     return false;
   }
   return ProcessReceivedPackets();
@@ -61,42 +58,32 @@ FecPacketCounter FlexfecReceiver::GetPacketCounter() const {
   return packet_counter_;
 }
 
-bool FlexfecReceiver::AddReceivedPacket(const uint8_t* packet,
-                                        size_t packet_length) {
+bool FlexfecReceiver::AddReceivedPacket(RtpPacketReceived packet) {
   RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
 
   // RTP packets with a full base header (12 bytes), but without payload,
   // could conceivably be useful in the decoding. Therefore we check
-  // with a strict inequality here.
-  if (packet_length < kRtpHeaderSize) {
-    LOG(LS_WARNING) << "Truncated packet, discarding.";
-    return false;
-  }
-
-  // TODO(brandtr): Consider how to handle received FlexFEC packets and
-  // the bandwidth estimator.
-  RtpPacketReceived parsed_packet;
-  if (!parsed_packet.Parse(packet, packet_length)) {
-    return false;
-  }
+  // with a non-strict inequality here.
+  RTC_DCHECK_GE(packet.size(), kRtpHeaderSize);
 
   // Demultiplex based on SSRC, and insert into erasure code decoder.
   std::unique_ptr<ReceivedPacket> received_packet(new ReceivedPacket());
-  received_packet->seq_num = parsed_packet.SequenceNumber();
-  received_packet->ssrc = parsed_packet.Ssrc();
+  received_packet->seq_num = packet.SequenceNumber();
+  received_packet->ssrc = packet.Ssrc();
   if (received_packet->ssrc == ssrc_) {
-    // This is a FEC packet belonging to this FlexFEC stream.
-    if (parsed_packet.payload_size() < kMinFlexfecHeaderSize) {
+    // This is a FlexFEC packet.
+    if (packet.payload_size() < kMinFlexfecHeaderSize) {
       LOG(LS_WARNING) << "Truncated FlexFEC packet, discarding.";
       return false;
     }
     received_packet->is_fec = true;
     ++packet_counter_.num_fec_packets;
+
     // Insert packet payload into erasure code.
     // TODO(brandtr): Remove this memcpy when the FEC packet classes
     // are using COW buffers internally.
     received_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
-    auto payload = parsed_packet.payload();
+    auto payload = packet.payload();
     memcpy(received_packet->pkt->data, payload.data(), payload.size());
     received_packet->pkt->length = payload.size();
   } else {
@@ -106,13 +93,14 @@ bool FlexfecReceiver::AddReceivedPacket(const uint8_t* packet,
       return false;
     }
     received_packet->is_fec = false;
+
     // Insert entire packet into erasure code.
     // TODO(brandtr): Remove this memcpy too.
     received_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
-    memcpy(received_packet->pkt->data, parsed_packet.data(),
-           parsed_packet.size());
-    received_packet->pkt->length = parsed_packet.size();
+    memcpy(received_packet->pkt->data, packet.data(), packet.size());
+    received_packet->pkt->length = packet.size();
   }
+
   received_packets_.push_back(std::move(received_packet));
   ++packet_counter_.num_packets;
 
@@ -144,8 +132,8 @@ bool FlexfecReceiver::ProcessReceivedPackets() {
       continue;
     }
     ++packet_counter_.num_recovered_packets;
-    if (!callback_->OnRecoveredPacket(recovered_packet->pkt->data,
-                                      recovered_packet->pkt->length)) {
+    if (!recovered_packet_receiver_->OnRecoveredPacket(
+            recovered_packet->pkt->data, recovered_packet->pkt->length)) {
       return false;
     }
     recovered_packet->returned = true;

webrtc/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc

@@ -16,6 +16,7 @@
 #include "webrtc/modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
@@ -36,6 +37,12 @@ constexpr size_t kPayloadLength = 500;
 constexpr uint32_t kFlexfecSsrc = 42984;
 constexpr uint32_t kMediaSsrc = 8353;
 
+RtpPacketReceived ParsePacket(const Packet& packet) {
+  RtpPacketReceived parsed_packet;
+  EXPECT_TRUE(parsed_packet.Parse(packet.data, packet.length));
+  return parsed_packet;
+}
+
 }  // namespace
 
 class FlexfecReceiverTest : public ::testing::Test {
@@ -93,21 +100,8 @@ TEST_F(FlexfecReceiverTest, ReceivesMediaPacket) {
   std::unique_ptr<Packet> media_packet(
       packet_generator_.NextPacket(0, kPayloadLength));
 
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
-                                                    media_packet->length));
-}
-
-TEST_F(FlexfecReceiverTest, FailsOnTruncatedMediaPacket) {
-  const size_t kNoPayload = 0;
-
-  packet_generator_.NewFrame(1);
-  std::unique_ptr<Packet> media_packet(
-      packet_generator_.NextPacket(0, kNoPayload));
-  // Simulate truncated media packet.
-  media_packet->length = kRtpHeaderSize - 1;
-
-  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
-                                                     media_packet->length));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
 }
 
 TEST_F(FlexfecReceiverTest, ReceivesMediaAndFecPackets) {
@@ -117,13 +111,12 @@ TEST_F(FlexfecReceiverTest, ReceivesMediaAndFecPackets) {
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
-  auto media_packet = media_packets.front().get();
+  const auto& media_packet = media_packets.front();
   auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
 
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
-                                                    media_packet->length));
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
-                                                    fec_packet->length));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(*fec_packet)));
 }
 
 TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) {
@@ -133,15 +126,14 @@ TEST_F(FlexfecReceiverTest, FailsOnTruncatedFecPacket) {
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
-  auto media_packet = media_packets.front().get();
+  const auto& media_packet = media_packets.front();
   // Simulate truncated FlexFEC payload.
   fec_packets.front()->length = 1;
   auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
 
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
-                                                    media_packet->length));
-  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
-                                                     fec_packet->length));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
+  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(ParsePacket(*fec_packet)));
 }
 
 TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
@@ -149,15 +141,15 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
-  auto media_packet = media_packets.front().get();
+  auto& media_packet = media_packets.front();
   // Corrupt the SSRC.
   media_packet->data[8] = 0;
   media_packet->data[9] = 1;
   media_packet->data[10] = 2;
   media_packet->data[11] = 3;
 
-  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
-                                                     media_packet->length));
+  EXPECT_FALSE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
 }
 
 TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
@@ -167,7 +159,7 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
-  auto media_packet = media_packets.front().get();
+  const auto& media_packet = media_packets.front();
   auto fec_packet = packet_generator_.BuildFlexfecPacket(*fec_packets.front());
   // Corrupt the SSRC.
   fec_packet->data[8] = 4;
@@ -175,10 +167,9 @@ TEST_F(FlexfecReceiverTest, FailsOnUnknownFecSsrc) {
   fec_packet->data[10] = 6;
   fec_packet->data[11] = 7;
 
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
-                                                    media_packet->length));
-  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
-                                                     fec_packet->length));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
+  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(ParsePacket(*fec_packet)));
 }
 
 TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
@@ -191,8 +182,8 @@ TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
 
   // Receive all media packets.
   for (const auto& media_packet : media_packets) {
-    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
-                                                      media_packet->length));
+    EXPECT_TRUE(
+        receiver_.AddAndProcessReceivedPacket(ParsePacket(*media_packet)));
   }
 
   // Receive FEC packet.
@@ -200,7 +191,7 @@ TEST_F(FlexfecReceiverTest, ReceivesMultiplePackets) {
   std::unique_ptr<Packet> packet_with_rtp_header =
       packet_generator_.BuildFlexfecPacket(*fec_packet);
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 }
 
 TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) {
@@ -213,8 +204,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) {
 
   // Receive first media packet but drop second.
   auto media_it = media_packets.begin();
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
-                                                    (*media_it)->length));
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
 
   // Receive FEC packet and ensure recovery of lost media packet.
   auto fec_it = fec_packets.begin();
@@ -227,7 +217,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromSingleMediaLoss) {
           Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
       .WillOnce(Return(true));
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 }
 
 TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
@@ -251,7 +241,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
           Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
       .WillOnce(Return(true));
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 
   // Receive second FEC packet and recover second lost media packet.
   fec_it++;
@@ -263,7 +253,7 @@ TEST_F(FlexfecReceiverTest, RecoversFromDoubleMediaLoss) {
           Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
       .WillOnce(Return(true));
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 }
 
 TEST_F(FlexfecReceiverTest, DoesNotRecoverFromMediaAndFecLoss) {
@@ -276,8 +266,7 @@ TEST_F(FlexfecReceiverTest, DoesNotRecoverFromMediaAndFecLoss) {
 
   // Receive first media packet.
   auto media_it = media_packets.begin();
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
-                                                    (*media_it)->length));
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
 
   // Drop second media packet and FEC packet. Do not expect call back.
 }
@@ -292,8 +281,7 @@ TEST_F(FlexfecReceiverTest, DoesNotCallbackTwice) {
 
   // Receive first media packet but drop second.
   auto media_it = media_packets.begin();
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
-                                                    (*media_it)->length));
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
 
   // Receive FEC packet and ensure recovery of lost media packet.
   auto fec_it = fec_packets.begin();
@@ -306,11 +294,11 @@ TEST_F(FlexfecReceiverTest, DoesNotCallbackTwice) {
           Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
       .WillOnce(Return(true));
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 
   // Receive FEC packet again.
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 
   // Do not call back again.
 }
@@ -332,8 +320,7 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) {
   // Drop every second media packet.
   auto media_it = media_packets.begin();
   while (media_it != media_packets.end()) {
-    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
-                                                      (*media_it)->length));
+    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
     ++media_it;
     if (media_it == media_packets.end()) {
       break;
@@ -356,7 +343,7 @@ TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) {
             ElementsAreArray((*media_it)->data, (*media_it)->length)))
         .WillOnce(Return(true));
     EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-        fec_packet_with_rtp_header->data, fec_packet_with_rtp_header->length));
+        ParsePacket(*fec_packet_with_rtp_header)));
     ++media_it;
   }
 }
@@ -383,8 +370,7 @@ TEST_F(FlexfecReceiverTest, DelayedFecPacketDoesHelp) {
 
   // Receive all other media packets.
   while (media_it != media_packets.end()) {
-    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
-                                                      (*media_it)->length));
+    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
     ++media_it;
   }
 
@@ -399,7 +385,7 @@ TEST_F(FlexfecReceiverTest, DelayedFecPacketDoesHelp) {
           Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
       .WillOnce(Return(true));
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 }
 
 TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
@@ -424,8 +410,7 @@ TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
 
   // Receive all other media packets.
   while (media_it != media_packets.end()) {
-    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
-                                                      (*media_it)->length));
+    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
     ++media_it;
   }
 
@@ -434,7 +419,7 @@ TEST_F(FlexfecReceiverTest, TooDelayedFecPacketDoesNotHelp) {
   std::unique_ptr<Packet> packet_with_rtp_header =
       packet_generator_.BuildFlexfecPacket(**fec_it);
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 
   // Do not expect a call back.
 }
@@ -455,14 +440,14 @@ TEST_F(FlexfecReceiverTest, RecoversWithMediaPacketsOutOfOrder) {
   auto media_packet3 = media_it++;
   auto media_packet4 = media_it++;
   auto media_packet5 = media_it++;
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet5)->data,
-                                                    (*media_packet5)->length));
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet2)->data,
-                                                    (*media_packet2)->length));
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet3)->data,
-                                                    (*media_packet3)->length));
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_packet0)->data,
-                                                    (*media_packet0)->length));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_packet5)));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_packet2)));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_packet3)));
+  EXPECT_TRUE(
+      receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_packet0)));
 
   // Expect to recover lost media packets.
   EXPECT_CALL(recovered_packet_receiver_,
@@ -482,7 +467,7 @@ TEST_F(FlexfecReceiverTest, RecoversWithMediaPacketsOutOfOrder) {
   while (fec_it != fec_packets.end()) {
     packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(**fec_it);
     EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-        packet_with_rtp_header->data, packet_with_rtp_header->length));
+        ParsePacket(*packet_with_rtp_header)));
     ++fec_it;
   }
 }
@@ -497,8 +482,7 @@ TEST_F(FlexfecReceiverTest, CalculatesNumberOfPackets) {
 
   // Receive first media packet but drop second.
   auto media_it = media_packets.begin();
-  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket((*media_it)->data,
-                                                    (*media_it)->length));
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(ParsePacket(**media_it)));
 
   // Receive FEC packet and ensure recovery of lost media packet.
   auto fec_it = fec_packets.begin();
@@ -511,7 +495,7 @@ TEST_F(FlexfecReceiverTest, CalculatesNumberOfPackets) {
           Args<0, 1>(ElementsAreArray((*media_it)->data, (*media_it)->length)))
       .WillOnce(Return(true));
   EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
-      packet_with_rtp_header->data, packet_with_rtp_header->length));
+      ParsePacket(*packet_with_rtp_header)));
 
   // Check stats calculations.
   FecPacketCounter packet_counter = receiver_.GetPacketCounter();

webrtc/modules/rtp_rtcp/source/rtp_packet.cc

@@ -86,6 +86,10 @@ bool Packet::Parse(const uint8_t* buffer, size_t buffer_size) {
   return true;
 }
 
+bool Packet::Parse(rtc::ArrayView<const uint8_t> packet) {
+  return Parse(packet.data(), packet.size());
+}
+
 bool Packet::Parse(rtc::CopyOnWriteBuffer buffer) {
   if (!ParseBuffer(buffer.cdata(), buffer.size())) {
     Clear();

webrtc/modules/rtp_rtcp/source/rtp_packet.h

@@ -31,6 +31,7 @@ class Packet {
 
   // Parse and copy given buffer into Packet.
   bool Parse(const uint8_t* buffer, size_t size);
+  bool Parse(rtc::ArrayView<const uint8_t> packet);
 
   // Parse and move given buffer into Packet.
   bool Parse(rtc::CopyOnWriteBuffer packet);

webrtc/test/call_test.cc

@@ -279,6 +279,8 @@ void CallTest::CreateMatchingReceiveConfigs(Transport* rtcp_send_transport) {
     config.payload_type = kFlexfecPayloadType;
     config.remote_ssrc = kFlexfecSendSsrc;
     config.protected_media_ssrcs = {kVideoSendSsrcs[0]};
+    for (const RtpExtension& extension : video_send_config_.rtp.extensions)
+      config.rtp_header_extensions.push_back(extension);
     flexfec_receive_configs_.push_back(config);
   }
 }

webrtc/test/fuzzers/flexfec_receiver_fuzzer.cc

@@ -14,6 +14,7 @@
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 
 namespace webrtc {
 
@@ -61,7 +62,10 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
       ByteWriter<uint16_t>::WriteBigEndian(packet.get() + 2, media_seq_num++);
       ByteWriter<uint32_t>::WriteBigEndian(packet.get() + 8, media_ssrc);
     }
-    receiver.AddAndProcessReceivedPacket(packet.get(), packet_length);
+    RtpPacketReceived parsed_packet;
+    if (parsed_packet.Parse(packet.get(), packet_length)) {
+      receiver.AddAndProcessReceivedPacket(parsed_packet);
+    }
   }
 }
 

webrtc/video/video_quality_test.cc

@@ -1119,6 +1119,15 @@ void VideoQualityTest::SetupVideo(Transport* send_transport,
         video_send_config_.rtp.flexfec.flexfec_ssrc;
     flexfec_receive_config.protected_media_ssrcs =
         video_send_config_.rtp.flexfec.protected_media_ssrcs;
+    flexfec_receive_config.transport_cc = params_.call.send_side_bwe;
+    if (params_.call.send_side_bwe) {
+      flexfec_receive_config.rtp_header_extensions.push_back(
+          RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                       test::kTransportSequenceNumberExtensionId));
+    } else {
+      flexfec_receive_config.rtp_header_extensions.push_back(RtpExtension(
+          RtpExtension::kAbsSendTimeUri, test::kAbsSendTimeExtensionId));
+    }
     flexfec_receive_configs_.push_back(flexfec_receive_config);
   }