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/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.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_header_extension.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.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 ::testing::SaveArg;
 
 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;
 
+template <typename T>
+RtpPacketReceived ParsePacket(const std::unique_ptr<T>& packet) {

[danilchap, 2016/12/13 14:11:24]

probably better to use const reference to object than reference to the smart
pointer

ParsePacket(const T& packet) {
  parsed_packet.Parse(packet.data, packet.length);
}

[brandtr, 2016/12/14 12:55:49]

Done. Could remove the templatization then too :) (std::unique_ptr is not
covariant, so it was needed before.)

+  RtpPacketReceived parsed_packet(nullptr);
+  RTC_DCHECK(parsed_packet.Parse(packet->data, packet->length));
+  return parsed_packet;
+}
+
 }  // namespace
 
 class FlexfecReceiverTest : public ::testing::Test {
  protected:
   FlexfecReceiverTest()
-      : receiver_(kFlexfecSsrc, kMediaSsrc, &recovered_packet_receiver_),
+      : receiver_(kFlexfecSsrc,
+                  kMediaSsrc,
+                  &recovered_packet_receiver_,
+                  &remote_bitrate_estimator_),
         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);
 
   FlexfecReceiver receiver_;
   std::unique_ptr<ForwardErrorCorrection> erasure_code_;
 
   FlexfecPacketGenerator packet_generator_;
   testing::StrictMock<MockRecoveredPacketReceiver> recovered_packet_receiver_;
+  MockRemoteBitrateEstimator remote_bitrate_estimator_;
 };
 
 void FlexfecReceiverTest::PacketizeFrame(size_t num_media_packets,
                                          size_t frame_offset,
                                          PacketList* media_packets) {
   packet_generator_.NewFrame(num_media_packets);
   for (size_t i = 0; i < num_media_packets; ++i) {
     std::unique_ptr<Packet> next_packet(
         packet_generator_.NextPacket(frame_offset + i, kPayloadLength));
     media_packets->push_back(std::move(next_packet));
@@ skipping 14 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,
+       NotifiesBweOfReceivedFecPacketWithTransportSequenceNumberExtension) {
+  // Set up receiver.
+  testing::StrictMock<MockRecoveredPacketReceiver> recovered_packet_receiver;
+  testing::StrictMock<MockRemoteBitrateEstimator> remote_bitrate_estimator;
+  FlexfecReceiver receiver(kFlexfecSsrc, kMediaSsrc, &recovered_packet_receiver,
+                           &remote_bitrate_estimator);
+
+  // Set up RTP header extensions.
+  RtpHeaderExtensionMap rtp_header_extension_map;
+  rtp_header_extension_map.Register<TransportSequenceNumber>(7);
+
+  // Generate media and FEC payloads.
+  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);
+
+  // Add transport-wide sequence numbers to packets.
+  ASSERT_EQ(1u, media_packets.size());
+  auto media_packet_raw = media_packets.front().get();

[danilchap, 2016/12/13 14:11:24]

may be use "auto*" to stress it is a raw pointer

+  RtpPacketReceived media_packet;
+  media_packet.Parse(media_packet_raw->data, media_packet_raw->length);

[danilchap, 2016/12/13 14:11:24]

may be
RtpPacketReceived media_packet = ParsePacket(*media_packets.front());
i.e. reuse ParsePacket helper function introduced in this cl.

+  RtpPacketReceived media_packet_ext(&rtp_header_extension_map);
+  media_packet_ext.CopyHeaderFrom(media_packet);
+  media_packet_ext.SetExtension<TransportSequenceNumber>(1);
+  auto payload = media_packet.payload();
+  uint8_t* ext_payload = media_packet_ext.AllocatePayload(payload.size());
+  memcpy(ext_payload, payload.data(), payload.size());
+
+  ASSERT_EQ(1u, fec_packets.size());
+  auto fec_packet_raw =
+      packet_generator_.BuildFlexfecPacket(*fec_packets.front());
+  RtpPacketReceived fec_packet;

[danilchap, 2016/12/13 14:11:24]

ditto

+  fec_packet.Parse(fec_packet_raw->data, fec_packet_raw->length);
+  RtpPacketReceived fec_packet_ext(&rtp_header_extension_map);
+  fec_packet_ext.CopyHeaderFrom(fec_packet);
+  fec_packet_ext.SetExtension<TransportSequenceNumber>(2);
+  payload = fec_packet.payload();
+  ext_payload = fec_packet_ext.AllocatePayload(payload.size());
+  memcpy(ext_payload, payload.data(), payload.size());
+
+  // Expect BWE notification for FEC packet, but not media packet.
+  RTPHeader reported_header;
+  EXPECT_CALL(remote_bitrate_estimator,
+              IncomingPacket(_, fec_packet_ext.payload_size(), _))
+      .WillOnce(SaveArg<2>(&reported_header));
+
+  // Add packets to receiver.
+  EXPECT_TRUE(receiver.AddAndProcessReceivedPacket(media_packet_ext));
+  EXPECT_TRUE(receiver.AddAndProcessReceivedPacket(fec_packet_ext));
+
+  // Ensure that the BWE was notified of the FlexFEC packet.
+  EXPECT_EQ(kFlexfecSsrc, reported_header.ssrc);
+  EXPECT_EQ(2, reported_header.extension.transportSequenceNumber);
+}
+
 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