Parse FlexFEC RTP headers in Call and add integration with BWE.

webrtc/modules/rtp_rtcp/source/flexfec_receiver_unittest.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <algorithm>
 #include <memory>
 
 #include "webrtc/base/basictypes.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/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"
 
 namespace webrtc {
 
 namespace {
 
 using ::testing::_;
 using ::testing::Args;
 using ::testing::ElementsAreArray;
 using ::testing::Return;
 
 using test::fec::FlexfecPacketGenerator;
 using Packet = ForwardErrorCorrection::Packet;
 using PacketList = ForwardErrorCorrection::PacketList;
 
 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 {
  protected:
   FlexfecReceiverTest()
       : receiver_(kFlexfecSsrc, kMediaSsrc, &recovered_packet_receiver_),
         erasure_code_(ForwardErrorCorrection::CreateFlexfec()),
         packet_generator_(kMediaSsrc, kFlexfecSsrc) {}
 
   // Generates |num_media_packets| corresponding to a single frame.
@@ skipping 37 matching lines @@
                    kUseUnequalProtection, kFecMaskType, &fec_packets));
   EXPECT_EQ(num_fec_packets, fec_packets.size());
   return fec_packets;
 }
 
 TEST_F(FlexfecReceiverTest, ReceivesMediaPacket) {
   packet_generator_.NewFrame(1);
   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) {
   const size_t kNumMediaPackets = 1;
   const size_t kNumFecPackets = 1;
 
   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) {
   const size_t kNumMediaPackets = 1;
   const size_t kNumFecPackets = 1;
 
   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) {
   const size_t kNumMediaPackets = 1;
 
   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) {
   const size_t kNumMediaPackets = 1;
   const size_t kNumFecPackets = 1;
 
   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;
   fec_packet->data[9] = 5;
   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) {
   const size_t kNumMediaPackets = 2;
   const size_t kNumFecPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // 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.
   auto fec_packet = fec_packets.front();
   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) {
   const size_t kNumMediaPackets = 2;
   const size_t kNumFecPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // 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();
   std::unique_ptr<Packet> packet_with_rtp_header =
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
               OnRecoveredPacket(_, (*media_it)->length))
       .With(
           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) {
   const size_t kNumMediaPackets = 2;
   const size_t kNumFecPackets = 2;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // Drop both media packets.
 
   // Receive first FEC packet and recover first lost media packet.
   auto fec_it = fec_packets.begin();
   std::unique_ptr<Packet> packet_with_rtp_header =
       packet_generator_.BuildFlexfecPacket(**fec_it);
   auto media_it = media_packets.begin();
   EXPECT_CALL(recovered_packet_receiver_,
               OnRecoveredPacket(_, (*media_it)->length))
       .With(
           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++;
   packet_with_rtp_header = packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
               OnRecoveredPacket(_, (*media_it)->length))
       .With(
           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) {
   const size_t kNumMediaPackets = 2;
   const size_t kNumFecPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // 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.
 }
 
 TEST_F(FlexfecReceiverTest, DoesNotCallbackTwice) {
   const size_t kNumMediaPackets = 2;
   const size_t kNumFecPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // 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();
   std::unique_ptr<Packet> packet_with_rtp_header =
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
               OnRecoveredPacket(_, (*media_it)->length))
       .With(
           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.
 }
 
 // Here we are implicitly assuming packet masks that are suitable for
 // this type of 50% correlated loss. If we are changing our precomputed
 // packet masks, this test might need to be updated.
 TEST_F(FlexfecReceiverTest, RecoversFrom50PercentLoss) {
   const size_t kNumFecPackets = 5;
   const size_t kNumFrames = 2 * kNumFecPackets;
   const size_t kNumMediaPacketsPerFrame = 1;
 
   PacketList media_packets;
   for (size_t i = 0; i < kNumFrames; ++i) {
     PacketizeFrame(kNumMediaPacketsPerFrame, i, &media_packets);
   }
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // 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;
     }
     ++media_it;
   }
 
   // Receive all FEC packets.
   media_it = media_packets.begin();
   for (const auto& fec_packet : fec_packets) {
     std::unique_ptr<Packet> fec_packet_with_rtp_header =
         packet_generator_.BuildFlexfecPacket(*fec_packet);
     ++media_it;
     if (media_it == media_packets.end()) {
       break;
     }
     EXPECT_CALL(recovered_packet_receiver_,
                 OnRecoveredPacket(_, (*media_it)->length))
         .With(Args<0, 1>(
             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;
   }
 }
 
 TEST_F(FlexfecReceiverTest, DelayedFecPacketDoesHelp) {
   // These values need to be updated if the underlying erasure code
   // implementation changes.
   const size_t kNumFrames = 48;
   const size_t kNumMediaPacketsPerFrame = 1;
   const size_t kNumFecPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPacketsPerFrame, 0, &media_packets);
   PacketizeFrame(kNumMediaPacketsPerFrame, 1, &media_packets);
   // Protect two first frames.
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
   for (size_t i = 2; i < kNumFrames; ++i) {
     PacketizeFrame(kNumMediaPacketsPerFrame, i, &media_packets);
   }
 
   // Drop first media packet and delay FEC packet.
   auto media_it = media_packets.begin();
   ++media_it;
 
   // 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;
   }
 
   // Receive FEC packet and recover first media packet.
   auto fec_it = fec_packets.begin();
   std::unique_ptr<Packet> packet_with_rtp_header =
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it = media_packets.begin();
   EXPECT_CALL(recovered_packet_receiver_,
               OnRecoveredPacket(_, (*media_it)->length))
       .With(
           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) {
   // These values need to be updated if the underlying erasure code
   // implementation changes.
   const size_t kNumFrames = 49;
   const size_t kNumMediaPacketsPerFrame = 1;
   const size_t kNumFecPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPacketsPerFrame, 0, &media_packets);
   PacketizeFrame(kNumMediaPacketsPerFrame, 1, &media_packets);
   // Protect two first frames.
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
   for (size_t i = 2; i < kNumFrames; ++i) {
     PacketizeFrame(kNumMediaPacketsPerFrame, i, &media_packets);
   }
 
   // Drop first media packet and delay FEC packet.
   auto media_it = media_packets.begin();
   ++media_it;
 
   // 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;
   }
 
   // Receive FEC packet.
   auto fec_it = fec_packets.begin();
   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.
 }
 
 TEST_F(FlexfecReceiverTest, RecoversWithMediaPacketsOutOfOrder) {
   const size_t kNumMediaPackets = 6;
   const size_t kNumFecPackets = 2;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // Lose two media packets, and receive the others out of order.
   auto media_it = media_packets.begin();
   auto media_packet0 = media_it++;
   auto media_packet1 = media_it++;
   auto media_packet2 = media_it++;
   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_,
               OnRecoveredPacket(_, (*media_packet1)->length))
       .With(Args<0, 1>(
           ElementsAreArray((*media_packet1)->data, (*media_packet1)->length)))
       .WillOnce(Return(true));
   EXPECT_CALL(recovered_packet_receiver_,
               OnRecoveredPacket(_, (*media_packet4)->length))
       .With(Args<0, 1>(
           ElementsAreArray((*media_packet4)->data, (*media_packet4)->length)))
       .WillOnce(Return(true));
 
   // Add FEC packets.
   auto fec_it = fec_packets.begin();
   std::unique_ptr<Packet> packet_with_rtp_header;
   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;
   }
 }
 
 TEST_F(FlexfecReceiverTest, CalculatesNumberOfPackets) {
   const size_t kNumMediaPackets = 2;
   const size_t kNumFecPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   std::list<Packet*> fec_packets = EncodeFec(media_packets, kNumFecPackets);
 
   // 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();
   std::unique_ptr<Packet> packet_with_rtp_header =
       packet_generator_.BuildFlexfecPacket(**fec_it);
   media_it++;
   EXPECT_CALL(recovered_packet_receiver_,
               OnRecoveredPacket(_, (*media_it)->length))
       .With(
           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();
   EXPECT_EQ(2U, packet_counter.num_packets);
   EXPECT_EQ(1U, packet_counter.num_fec_packets);
   EXPECT_EQ(1U, packet_counter.num_recovered_packets);
 }
 
 }  // namespace webrtc