Make FlexfecReceiver a concrete class.

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.
  */
 
@@ skipping 23 matching lines @@
 
 constexpr size_t kPayloadLength = 500;
 constexpr uint32_t kFlexfecSsrc = 42984;
 constexpr uint32_t kMediaSsrc = 8353;
 
 }  // namespace
 
 class FlexfecReceiverTest : public ::testing::Test {
  protected:
   FlexfecReceiverTest()
-      : receiver_(FlexfecReceiver::Create(kFlexfecSsrc,
-                                          kMediaSsrc,
-                                          &recovered_packet_receiver_)),
+      : receiver_(kFlexfecSsrc, kMediaSsrc, &recovered_packet_receiver_),
         erasure_code_(ForwardErrorCorrection::CreateFlexfec()),
         packet_generator_(kMediaSsrc, kFlexfecSsrc) {}
 
   // Generates |num_media_packets| corresponding to a single frame.
   void PacketizeFrame(size_t num_media_packets,
                       size_t frame_offset,
                       PacketList* media_packets);
 
   // Generates |num_fec_packets| FEC packets, given |media_packets|.
   std::list<Packet*> EncodeFec(const PacketList& media_packets,
                                size_t num_fec_packets);
 
-  std::unique_ptr<FlexfecReceiver> receiver_;
+  FlexfecReceiver receiver_;
   std::unique_ptr<ForwardErrorCorrection> erasure_code_;
 
   FlexfecPacketGenerator packet_generator_;
   testing::StrictMock<MockRecoveredPacketReceiver> recovered_packet_receiver_;
 };
 
 void FlexfecReceiverTest::PacketizeFrame(size_t num_media_packets,
                                          size_t frame_offset,
                                          PacketList* media_packets) {
   packet_generator_.NewFrame(num_media_packets);
@@ skipping 18 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));
+  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_FALSE(receiver_.AddAndProcessReceivedPacket(media_packet->data,
+                                                     media_packet->length));
 }
 
 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();
   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(media_packet->data,
+                                                    media_packet->length));
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
+                                                    fec_packet->length));
 }
 
 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();
   // 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(media_packet->data,
+                                                    media_packet->length));
+  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
+                                                     fec_packet->length));
 }
 
 TEST_F(FlexfecReceiverTest, FailsOnUnknownMediaSsrc) {
   const size_t kNumMediaPackets = 1;
 
   PacketList media_packets;
   PacketizeFrame(kNumMediaPackets, 0, &media_packets);
   auto media_packet = media_packets.front().get();
   // 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(media_packet->data,
+                                                     media_packet->length));
 }
 
 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();
   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(media_packet->data,
+                                                    media_packet->length));
+  EXPECT_FALSE(receiver_.AddAndProcessReceivedPacket(fec_packet->data,
+                                                     fec_packet->length));
 }
 
 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(media_packet->data,
+                                                      media_packet->length));
   }
 
   // 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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 }
 
 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((*media_it)->data,
+                                                    (*media_it)->length));
 
   // 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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 }
 
 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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 
   // 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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 }
 
 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((*media_it)->data,
+                                                    (*media_it)->length));
 
   // 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((*media_it)->data,
+                                                    (*media_it)->length));
 
   // 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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 
   // Receive FEC packet again.
-  EXPECT_TRUE(receiver_->AddAndProcessReceivedPacket(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 
   // 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((*media_it)->data,
+                                                      (*media_it)->length));
     ++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(
+    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
         fec_packet_with_rtp_header->data, fec_packet_with_rtp_header->length));
     ++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((*media_it)->data,
+                                                      (*media_it)->length));
     ++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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 }
 
 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((*media_it)->data,
+                                                      (*media_it)->length));
     ++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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 
   // 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((*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 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(
+    EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
         packet_with_rtp_header->data, packet_with_rtp_header->length));
     ++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((*media_it)->data,
+                                                    (*media_it)->length));
 
   // 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(
+  EXPECT_TRUE(receiver_.AddAndProcessReceivedPacket(
       packet_with_rtp_header->data, packet_with_rtp_header->length));
 
   // Check stats calculations.
-  FecPacketCounter packet_counter = receiver_->GetPacketCounter();
+  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