Move parsing from tests to TestTransport in RTPSenderTests

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

 /*
  *  Copyright (c) 2012 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 <memory>
 #include <vector>
 
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/rate_limiter.h"
 #include "webrtc/call/mock/mock_rtc_event_log.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_video_generic.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/modules/rtp_rtcp/source/rtp_packet_to_send.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_sender_video.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h"
 #include "webrtc/system_wrappers/include/stl_util.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/mock_transport.h"
 #include "webrtc/typedefs.h"
 
@@ skipping 14 matching lines @@
 const int kAudioPayload = 103;
 const uint64_t kStartTime = 123456789;
 const size_t kMaxPaddingSize = 224u;
 const int kVideoRotationExtensionId = 5;
 const size_t kGenericHeaderLength = 1;
 const uint8_t kPayloadData[] = {47, 11, 32, 93, 89};
 
 using ::testing::_;
 using ::testing::ElementsAreArray;
 
-const uint8_t* GetPayloadData(const RTPHeader& rtp_header,
-                              const uint8_t* packet) {
-  return packet + rtp_header.headerLength;
-}
-
-size_t GetPayloadDataLength(const RTPHeader& rtp_header,
-                            const size_t packet_length) {
-  return packet_length - rtp_header.headerLength - rtp_header.paddingLength;
-}
-
 uint64_t ConvertMsToAbsSendTime(int64_t time_ms) {
   return (((time_ms << 18) + 500) / 1000) & 0x00ffffff;
 }
 
 class LoopbackTransportTest : public webrtc::Transport {
  public:
-  LoopbackTransportTest()
-      : packets_sent_(0),
-        last_sent_packet_len_(0),
-        total_bytes_sent_(0),
-        last_sent_packet_(nullptr),
-        last_packet_id_(-1) {}
+  LoopbackTransportTest() : total_bytes_sent_(0), last_packet_id_(-1) {
+    receivers_extensions_.Register(kRtpExtensionTransmissionTimeOffset,
+                                   kTransmissionTimeOffsetExtensionId);
+    receivers_extensions_.Register(kRtpExtensionAbsoluteSendTime,
+                                   kAbsoluteSendTimeExtensionId);
+    receivers_extensions_.Register(kRtpExtensionTransportSequenceNumber,
+                                   kTransportSequenceNumberExtensionId);
+    receivers_extensions_.Register(kRtpExtensionVideoRotation,
+                                   kVideoRotationExtensionId);
+    receivers_extensions_.Register(kRtpExtensionAudioLevel,
+                                   kAudioLevelExtensionId);
+  }
 
-  ~LoopbackTransportTest() {
-    STLDeleteContainerPointers(sent_packets_.begin(), sent_packets_.end());
-  }
   bool SendRtp(const uint8_t* data,
                size_t len,
                const PacketOptions& options) override {
-    packets_sent_++;
-    rtc::Buffer* buffer =
-        new rtc::Buffer(reinterpret_cast<const uint8_t*>(data), len);
-    last_sent_packet_ = buffer->data();
-    last_sent_packet_len_ = len;
     last_packet_id_ = options.packet_id;
     total_bytes_sent_ += len;
-    sent_packets_.push_back(buffer);
+    sent_packets_.push_back(RtpPacketReceived(&receivers_extensions_));
+    EXPECT_TRUE(sent_packets_.back().Parse(data, len));
     return true;
   }
   bool SendRtcp(const uint8_t* data, size_t len) override { return false; }
-  int packets_sent_;
-  size_t last_sent_packet_len_;
+  const RtpPacketReceived& last_sent_packet() { return sent_packets_.back(); }
+  int packets_sent() { return sent_packets_.size(); }
+
   size_t total_bytes_sent_;
-  uint8_t* last_sent_packet_;
   int last_packet_id_;
-  std::vector<rtc::Buffer*> sent_packets_;
+  std::vector<RtpPacketReceived> sent_packets_;
+
+ private:
+  RtpHeaderExtensionMap receivers_extensions_;
 };
 
 }  // namespace
 
 class MockRtpPacketSender : public RtpPacketSender {
  public:
   MockRtpPacketSender() {}
   virtual ~MockRtpPacketSender() {}
 
   MOCK_METHOD6(InsertPacket,
@@ skipping 129 matching lines @@
 class RtpSenderVideoTest : public RtpSenderTest {
  protected:
   void SetUp() override {
     // TODO(pbos): Set up to use pacer.
     SetUpRtpSender(false);
     rtp_sender_video_.reset(
         new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
   }
   std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
 
-  void VerifyCVOPacket(uint8_t* data,
-                       size_t len,
+  void VerifyCVOPacket(const RtpPacketReceived& rtp_packet,
                        bool expect_cvo,
-                       RtpHeaderExtensionMap* map,
                        uint16_t seq_num,
-                       VideoRotation rotation) {
-    webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len);
-
-    webrtc::RTPHeader rtp_header;
-    ASSERT_TRUE(rtp_parser.Parse(&rtp_header, map));
-    ASSERT_FALSE(rtp_parser.RTCP());
-    EXPECT_EQ(payload_, rtp_header.payloadType);
-    EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
-    EXPECT_EQ(kTimestamp, rtp_header.timestamp);
-    EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
-    EXPECT_EQ(0, rtp_header.numCSRCs);
-    EXPECT_EQ(0U, rtp_header.paddingLength);
-    EXPECT_EQ(rotation, rtp_header.extension.videoRotation);
+                       VideoRotation expected_rotation) {
+    EXPECT_EQ(payload_, rtp_packet.PayloadType());
+    EXPECT_EQ(seq_num, rtp_packet.SequenceNumber());
+    EXPECT_EQ(kTimestamp, rtp_packet.Timestamp());
+    EXPECT_EQ(rtp_sender_->SSRC(), rtp_packet.Ssrc());
+    EXPECT_EQ(0U, rtp_packet.Csrcs().size());
+    EXPECT_EQ(0U, rtp_packet.padding_size());
+    VideoRotation actual_rotation;
+    EXPECT_TRUE(rtp_packet.GetExtension<VideoOrientation>(&actual_rotation));
+    EXPECT_EQ(expected_rotation, actual_rotation);
   }
 };
 
 TEST_F(RtpSenderTestWithoutPacer,
        RegisterRtpTransmissionTimeOffsetHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
@@ skipping 173 matching lines @@
   constexpr size_t kPaddingSize = 100;
   auto packet = rtp_sender_->AllocatePacket();
   ASSERT_TRUE(packet);
   packet->SetMarker(true);
   packet->SetTimestamp(kTimestamp);
 
   ASSERT_TRUE(rtp_sender_->AssignSequenceNumber(packet.get()));
   ASSERT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, -1));
 
   ASSERT_EQ(1u, transport_.sent_packets_.size());
-  // Parse the padding packet and verify its timestamp.
-  RtpPacketToSend padding_packet(nullptr);
-  ASSERT_TRUE(padding_packet.Parse(transport_.sent_packets_[0]->data(),
-                                   transport_.sent_packets_[0]->size()));
-  EXPECT_EQ(kTimestamp, padding_packet.Timestamp());
+  // Verify padding packet timestamp.
+  EXPECT_EQ(kTimestamp, transport_.last_sent_packet().Timestamp());
 }
 
 TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, nullptr,
       &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
       &mock_rtc_event_log_, &send_packet_observer_,
       &retransmission_rate_limiter_));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
   EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
       .WillOnce(testing::Return(kTransportSequenceNumber));
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
   EXPECT_CALL(feedback_observer_,
               AddPacket(kTransportSequenceNumber,
                         sizeof(kPayloadData) + kGenericHeaderLength,
                         PacketInfo::kNotAProbe))
       .Times(1);
 
   SendGenericPayload();
 
-  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                         transport_.last_sent_packet_len_);
-  webrtc::RTPHeader rtp_header;
-  RtpHeaderExtensionMap map;
-  map.Register(kRtpExtensionTransportSequenceNumber,
-               kTransportSequenceNumberExtensionId);
-  EXPECT_TRUE(rtp_parser.Parse(&rtp_header, &map));
-  EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
-  EXPECT_EQ(kTransportSequenceNumber,
-            rtp_header.extension.transportSequenceNumber);
-  EXPECT_EQ(transport_.last_packet_id_,
-            rtp_header.extension.transportSequenceNumber);
+  const auto& packet = transport_.last_sent_packet();
+  uint16_t transport_seq_no;
+  ASSERT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no));
+  EXPECT_EQ(kTransportSequenceNumber, transport_seq_no);
+  EXPECT_EQ(transport_.last_packet_id_, transport_seq_no);
 }
 
 TEST_F(RtpSenderTestWithoutPacer, NoAllocationIfNotRegistered) {
   SendGenericPayload();
 }
 
 TEST_F(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
@@ skipping 29 matching lines @@
   EXPECT_CALL(
       feedback_observer_,
       AddPacket(kTransportSequenceNumber,
                 sizeof(kPayloadData) + kGenericHeaderLength, kProbeClusterId))
       .Times(1);
 
   SendGenericPayload();
   rtp_sender_->TimeToSendPacket(seq_num, fake_clock_.TimeInMilliseconds(),
                                 false, kProbeClusterId);
 
-  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                         transport_.last_sent_packet_len_);
-  webrtc::RTPHeader rtp_header;
-  RtpHeaderExtensionMap map;
-  map.Register(kRtpExtensionTransportSequenceNumber,
-               kTransportSequenceNumberExtensionId);
-  EXPECT_TRUE(rtp_parser.Parse(&rtp_header, &map));
-  EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
-  EXPECT_EQ(kTransportSequenceNumber,
-            rtp_header.extension.transportSequenceNumber);
-  EXPECT_EQ(transport_.last_packet_id_,
-            rtp_header.extension.transportSequenceNumber);
+  const auto& packet = transport_.last_sent_packet();
+  uint16_t transport_seq_no;
+  EXPECT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no));
+  EXPECT_EQ(kTransportSequenceNumber, transport_seq_no);
+  EXPECT_EQ(transport_.last_packet_id_, transport_seq_no);
 }
 
 TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
                                                _, kSeqNum, _, _, _));
   EXPECT_CALL(mock_rtc_event_log_,
               LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _));
 
   rtp_sender_->SetStorePacketsStatus(true, 10);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
   EXPECT_EQ(
       0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                                  kAbsoluteSendTimeExtensionId));
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   auto packet =
       BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
   size_t packet_size = packet->size();
 
   // Packet should be stored in a send bucket.
   EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
                                          kAllowRetransmission,
                                          RtpPacketSender::kNormalPriority));
 
-  EXPECT_EQ(0, transport_.packets_sent_);
+  EXPECT_EQ(0, transport_.packets_sent());
 
   const int kStoredTimeInMs = 100;
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
 
   rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false,
                                 PacketInfo::kNotAProbe);
 
   // Process send bucket. Packet should now be sent.
-  EXPECT_EQ(1, transport_.packets_sent_);
-  EXPECT_EQ(packet_size, transport_.last_sent_packet_len_);
-  // Parse sent packet.
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                                 packet_size);
+  EXPECT_EQ(1, transport_.packets_sent());
+  EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
+
   webrtc::RTPHeader rtp_header;
-  RtpHeaderExtensionMap map;
-  map.Register(kRtpExtensionTransmissionTimeOffset,
-               kTransmissionTimeOffsetExtensionId);
-  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
-  const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
-  ASSERT_TRUE(valid_rtp_header);
+  transport_.last_sent_packet().GetHeader(&rtp_header);
 
   // Verify transmission time offset.
   EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
   uint64_t expected_send_time =
       ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
   EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
 }
 
 TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
@@ skipping 11 matching lines @@
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   auto packet =
       BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, capture_time_ms);
   size_t packet_size = packet->size();
 
   // Packet should be stored in a send bucket.
   EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
                                          kAllowRetransmission,
                                          RtpPacketSender::kNormalPriority));
 
-  EXPECT_EQ(0, transport_.packets_sent_);
+  EXPECT_EQ(0, transport_.packets_sent());
 
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
                                                _, kSeqNum, _, _, _));
 
   const int kStoredTimeInMs = 100;
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
 
   EXPECT_EQ(static_cast<int>(packet_size), rtp_sender_->ReSendPacket(kSeqNum));
-  EXPECT_EQ(0, transport_.packets_sent_);
+  EXPECT_EQ(0, transport_.packets_sent());
 
   rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false,
                                 PacketInfo::kNotAProbe);
 
   // Process send bucket. Packet should now be sent.
-  EXPECT_EQ(1, transport_.packets_sent_);
-  EXPECT_EQ(packet_size, transport_.last_sent_packet_len_);
+  EXPECT_EQ(1, transport_.packets_sent());
+  EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
 
-  // Parse sent packet.
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                                 packet_size);
   webrtc::RTPHeader rtp_header;
-  RtpHeaderExtensionMap map;
-  map.Register(kRtpExtensionTransmissionTimeOffset,
-               kTransmissionTimeOffsetExtensionId);
-  map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
-  const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
-  ASSERT_TRUE(valid_rtp_header);
+  transport_.last_sent_packet().GetHeader(&rtp_header);
 
   // Verify transmission time offset.
   EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
   uint64_t expected_send_time =
       ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
   EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
 }
 
 // This test sends 1 regular video packet, then 4 padding packets, and then
 // 1 more regular packet.
@@ skipping 12 matching lines @@
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
   EXPECT_EQ(
       0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                                  kAbsoluteSendTimeExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
   rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
 
-  // Create and set up parser.
-  std::unique_ptr<webrtc::RtpHeaderParser> rtp_parser(
-      webrtc::RtpHeaderParser::Create());
-  ASSERT_TRUE(rtp_parser.get() != nullptr);
-  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
-                                         kTransmissionTimeOffsetExtensionId);
-  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
-                                         kAbsoluteSendTimeExtensionId);
   webrtc::RTPHeader rtp_header;
 
   int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
   auto packet =
       BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
   const uint32_t media_packet_timestamp = timestamp;
   size_t packet_size = packet->size();
 
   // Packet should be stored in a send bucket.
   EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
                                          kAllowRetransmission,
                                          RtpPacketSender::kNormalPriority));
 
   int total_packets_sent = 0;
-  EXPECT_EQ(total_packets_sent, transport_.packets_sent_);
+  EXPECT_EQ(total_packets_sent, transport_.packets_sent());
 
   const int kStoredTimeInMs = 100;
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
   rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false,
                                 PacketInfo::kNotAProbe);
   // Packet should now be sent. This test doesn't verify the regular video
   // packet, since it is tested in another test.
-  EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
+  EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
   timestamp += 90 * kStoredTimeInMs;
 
   // Send padding 4 times, waiting 50 ms between each.
   for (int i = 0; i < 4; ++i) {
     const int kPaddingPeriodMs = 50;
     const size_t kPaddingBytes = 100;
     const size_t kMaxPaddingLength = 224;  // Value taken from rtp_sender.cc.
     // Padding will be forced to full packets.
     EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding(
                                      kPaddingBytes, PacketInfo::kNotAProbe));
 
     // Process send bucket. Padding should now be sent.
-    EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
+    EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
     EXPECT_EQ(kMaxPaddingLength + rtp_header_len,
-              transport_.last_sent_packet_len_);
-    // Parse sent packet.
-    ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
-                                  transport_.last_sent_packet_len_,
-                                  &rtp_header));
+              transport_.last_sent_packet().size());
+
+    transport_.last_sent_packet().GetHeader(&rtp_header);
     EXPECT_EQ(kMaxPaddingLength, rtp_header.paddingLength);
 
     // Verify sequence number and timestamp. The timestamp should be the same
     // as the last media packet.
     EXPECT_EQ(seq_num++, rtp_header.sequenceNumber);
     EXPECT_EQ(media_packet_timestamp, rtp_header.timestamp);
     // Verify transmission time offset.
     int offset = timestamp - media_packet_timestamp;
     EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset);
     uint64_t expected_send_time =
@@ skipping 12 matching lines @@
               InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _));
 
   // Packet should be stored in a send bucket.
   EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet),
                                          kAllowRetransmission,
                                          RtpPacketSender::kNormalPriority));
 
   rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false,
                                 PacketInfo::kNotAProbe);
   // Process send bucket.
-  EXPECT_EQ(++total_packets_sent, transport_.packets_sent_);
-  EXPECT_EQ(packet_size, transport_.last_sent_packet_len_);
-  // Parse sent packet.
-  ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, packet_size,
-                                &rtp_header));
+  EXPECT_EQ(++total_packets_sent, transport_.packets_sent());
+  EXPECT_EQ(packet_size, transport_.last_sent_packet().size());
+  transport_.last_sent_packet().GetHeader(&rtp_header);
 
   // Verify sequence number and timestamp.
   EXPECT_EQ(seq_num, rtp_header.sequenceNumber);
   EXPECT_EQ(timestamp, rtp_header.timestamp);
   // Verify transmission time offset. This packet is sent without delay.
   EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
   uint64_t expected_send_time =
       ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
   EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
 }
 
 TEST_F(RtpSenderTest, OnSendPacketUpdated) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
   rtp_sender_->SetStorePacketsStatus(true, 10);
 
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
   EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
       .WillOnce(testing::Return(kTransportSequenceNumber));
   EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1);
 
   SendGenericPayload();  // Packet passed to pacer.
   const bool kIsRetransmit = false;
   rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
                                 kIsRetransmit, PacketInfo::kNotAProbe);
-  EXPECT_EQ(1, transport_.packets_sent_);
+  EXPECT_EQ(1, transport_.packets_sent());
 }
 
 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
   rtp_sender_->SetStorePacketsStatus(true, 10);
 
   EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
   EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
       .WillOnce(testing::Return(kTransportSequenceNumber));
   EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1);
 
   SendGenericPayload();  // Packet passed to pacer.
   const bool kIsRetransmit = true;
   rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
                                 kIsRetransmit, PacketInfo::kNotAProbe);
-  EXPECT_EQ(1, transport_.packets_sent_);
+  EXPECT_EQ(1, transport_.packets_sent());
 }
 
 TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport_, &mock_paced_sender_,
       nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
       nullptr, nullptr, &send_packet_observer_, &retransmission_rate_limiter_));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetStorePacketsStatus(true, 10);
 
   EXPECT_CALL(send_packet_observer_, OnSendPacket(_, _, _)).Times(0);
   EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _)).Times(1);
 
   SendGenericPayload();  // Packet passed to pacer.
   const bool kIsRetransmit = false;
   rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(),
                                 kIsRetransmit, PacketInfo::kNotAProbe);
-  EXPECT_EQ(1, transport_.packets_sent_);
+  EXPECT_EQ(1, transport_.packets_sent());
 }
 
 TEST_F(RtpSenderTest, SendRedundantPayloads) {
   MockTransport transport;
   rtp_sender_.reset(new RTPSender(
       false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
       nullptr, nullptr, nullptr, &mock_rtc_event_log_, nullptr,
       &retransmission_rate_limiter_));
 
   rtp_sender_->SetSequenceNumber(kSeqNum);
   rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
 
   uint16_t seq_num = kSeqNum;
   rtp_sender_->SetStorePacketsStatus(true, 10);
   int32_t rtp_header_len = kRtpHeaderSize;
   EXPECT_EQ(
       0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                                  kAbsoluteSendTimeExtensionId));
   rtp_header_len += 4;  // 4 bytes extension.
   rtp_header_len += 4;  // 4 extra bytes common to all extension headers.
 
   rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
   rtp_sender_->SetRtxSsrc(1234);
 
-  // Create and set up parser.
-  std::unique_ptr<webrtc::RtpHeaderParser> rtp_parser(
-      webrtc::RtpHeaderParser::Create());
-  ASSERT_TRUE(rtp_parser.get() != nullptr);
-  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
-                                         kTransmissionTimeOffsetExtensionId);
-  rtp_parser->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
-                                         kAbsoluteSendTimeExtensionId);
   const size_t kNumPayloadSizes = 10;
   const size_t kPayloadSizes[kNumPayloadSizes] = {500, 550, 600, 650, 700,
                                                   750, 800, 850, 900, 950};
   // Expect all packets go through the pacer.
   EXPECT_CALL(mock_paced_sender_,
               InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
       .Times(kNumPayloadSizes);
   EXPECT_CALL(mock_rtc_event_log_,
               LogRtpHeader(PacketDirection::kOutgoingPacket, _, _, _))
       .Times(kNumPayloadSizes);
@@ skipping 39 matching lines @@
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
 
   // Send keyframe
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
                                             4321, payload, sizeof(payload),
                                             nullptr, nullptr, nullptr));
 
-  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                         transport_.last_sent_packet_len_);
-  webrtc::RTPHeader rtp_header;
-  ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
-
-  const uint8_t* payload_data =
-      GetPayloadData(rtp_header, transport_.last_sent_packet_);
+  const uint8_t* payload_data = transport_.last_sent_packet().payload();
   uint8_t generic_header = *payload_data++;
 
   ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
-            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
+            transport_.last_sent_packet().payload_size());
 
   EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
   EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
 
   EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
 
   // Send delta frame
   payload[0] = 13;
   payload[1] = 42;
   payload[4] = 13;
 
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
       kVideoFrameDelta, payload_type, 1234, 4321, payload, sizeof(payload),
       nullptr, nullptr, nullptr));
 
-  RtpUtility::RtpHeaderParser rtp_parser2(transport_.last_sent_packet_,
-                                          transport_.last_sent_packet_len_);
-  ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
-
-  payload_data = GetPayloadData(rtp_header, transport_.last_sent_packet_);
+  payload_data = transport_.last_sent_packet().payload();
   generic_header = *payload_data++;
 
   EXPECT_FALSE(generic_header & RtpFormatVideoGeneric::kKeyFrameBit);
   EXPECT_TRUE(generic_header & RtpFormatVideoGeneric::kFirstPacketBit);
 
   ASSERT_EQ(sizeof(payload) + sizeof(generic_header),
-            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
+            transport_.last_sent_packet().payload_size());
 
   EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
 }
 
 TEST_F(RtpSenderTest, FrameCountCallbacks) {
   class TestCallback : public FrameCountObserver {
    public:
     TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
     virtual ~TestCallback() {}
 
@@ skipping 237 matching lines @@
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
 
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
                       kAudioFrameCN, payload_type, 1234, 4321, payload,
                       sizeof(payload), nullptr, nullptr, nullptr));
 
-  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                         transport_.last_sent_packet_len_);
-  webrtc::RTPHeader rtp_header;
-  ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
+  const uint8_t* payload_data = transport_.last_sent_packet().payload();
 
-  const uint8_t* payload_data =
-      GetPayloadData(rtp_header, transport_.last_sent_packet_);
-
-  ASSERT_EQ(sizeof(payload),
-            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
-
+  ASSERT_EQ(sizeof(payload), transport_.last_sent_packet().payload_size());
   EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
 }
 
 TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
   EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
                                                        kAudioLevelExtensionId));
 
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
 
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
                       kAudioFrameCN, payload_type, 1234, 4321, payload,
                       sizeof(payload), nullptr, nullptr, nullptr));
 
-  RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                         transport_.last_sent_packet_len_);
-  webrtc::RTPHeader rtp_header;
-  ASSERT_TRUE(rtp_parser.Parse(&rtp_header));
+  const uint8_t* payload_data = transport_.last_sent_packet().payload();
 
-  const uint8_t* payload_data =
-      GetPayloadData(rtp_header, transport_.last_sent_packet_);
-
-  ASSERT_EQ(sizeof(payload),
-            GetPayloadDataLength(rtp_header, transport_.last_sent_packet_len_));
-
+  ASSERT_EQ(sizeof(payload), transport_.last_sent_packet().payload_size());
   EXPECT_EQ(0, memcmp(payload, payload_data, sizeof(payload)));
-
-  uint8_t extension[] = {
-      0xbe, 0xde, 0x00, 0x01,
-      (kAudioLevelExtensionId << 4) + 0,  // ID + length.
-      kAudioLevel,                        // Data.
-      0x00, 0x00                          // Padding.
-  };
-
-  EXPECT_EQ(0, memcmp(extension, payload_data - sizeof(extension),
-                      sizeof(extension)));
+  // Verify AudioLevel extension.
+  bool voice_activity;
+  uint8_t audio_level;
+  EXPECT_TRUE(transport_.last_sent_packet().GetExtension<AudioLevel>(
+      &voice_activity, &audio_level));
+  EXPECT_EQ(kAudioLevel, audio_level);
+  EXPECT_FALSE(voice_activity);
 }
 
 // As RFC4733, named telephone events are carried as part of the audio stream
 // and must use the same sequence number and timestamp base as the regular
 // audio channel.
 // This test checks the marker bit for the first packet and the consequent
 // packets of the same telephone event. Since it is specifically for DTMF
 // events, ignoring audio packets and sending kEmptyFrame instead of those.
 TEST_F(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "telephone-event";
@@ skipping 14 matching lines @@
   // timestamp. So for first call it will skip since the duration is zero.
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(kEmptyFrame, payload_type,
                                                 capture_time_ms, 0, nullptr, 0,
                                                 nullptr, nullptr, nullptr));
   // DTMF Sample Length is (Frequency/1000) * Duration.
   // So in this case, it is (8000/1000) * 500 = 4000.
   // Sending it as two packets.
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
                       kEmptyFrame, payload_type, capture_time_ms + 2000, 0,
                       nullptr, 0, nullptr, nullptr, nullptr));
-  std::unique_ptr<webrtc::RtpHeaderParser> rtp_parser(
-      webrtc::RtpHeaderParser::Create());
-  ASSERT_TRUE(rtp_parser.get() != nullptr);
-  webrtc::RTPHeader rtp_header;
-  ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
-                                transport_.last_sent_packet_len_, &rtp_header));
+
   // Marker Bit should be set to 1 for first packet.
-  EXPECT_TRUE(rtp_header.markerBit);
+  EXPECT_TRUE(transport_.last_sent_packet().Marker());
 
   ASSERT_TRUE(rtp_sender_->SendOutgoingData(
                       kEmptyFrame, payload_type, capture_time_ms + 4000, 0,
                       nullptr, 0, nullptr, nullptr, nullptr));
-  ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_,
-                                transport_.last_sent_packet_len_, &rtp_header));
   // Marker Bit should be set to 0 for rest of the packets.
-  EXPECT_FALSE(rtp_header.markerBit);
+  EXPECT_FALSE(transport_.last_sent_packet().Marker());
 }
 
 TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
   const char* kPayloadName = "GENERIC";
   const uint8_t kPayloadType = 127;
   rtp_sender_->SetSSRC(1234);
   rtp_sender_->SetRtxSsrc(4321);
   rtp_sender_->SetRtxPayloadType(kPayloadType - 1, kPayloadType);
   rtp_sender_->SetRtxStatus(kRtxRetransmitted | kRtxRedundantPayloads);
 
@@ skipping 43 matching lines @@
   retransmission_rate_limiter_.SetMaxRate(kPacketSize * kNumPackets * 8);
 
   rtp_sender_->SetStorePacketsStatus(true, kNumPackets);
   const uint16_t kStartSequenceNumber = rtp_sender_->SequenceNumber();
   std::vector<uint16_t> sequence_numbers;
   for (int32_t i = 0; i < kNumPackets; ++i) {
     sequence_numbers.push_back(kStartSequenceNumber + i);
     fake_clock_.AdvanceTimeMilliseconds(1);
     SendPacket(fake_clock_.TimeInMilliseconds(), kPacketSize);
   }
-  EXPECT_EQ(kNumPackets, transport_.packets_sent_);
+  EXPECT_EQ(kNumPackets, transport_.packets_sent());
 
   fake_clock_.AdvanceTimeMilliseconds(1000 - kNumPackets);
 
   // Resending should work - brings the bandwidth up to the limit.
   // NACK bitrate is capped to the same bitrate as the encoder, since the max
   // protection overhead is 50% (see MediaOptimization::SetTargetRates).
   rtp_sender_->OnReceivedNack(sequence_numbers, 0);
-  EXPECT_EQ(kNumPackets * 2, transport_.packets_sent_);
+  EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
 
   // Must be at least 5ms in between retransmission attempts.
   fake_clock_.AdvanceTimeMilliseconds(5);
 
   // Resending should not work, bandwidth exceeded.
   rtp_sender_->OnReceivedNack(sequence_numbers, 0);
-  EXPECT_EQ(kNumPackets * 2, transport_.packets_sent_);
+  EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
 }
 
 // Verify that all packets of a frame have CVO byte set.
 TEST_F(RtpSenderVideoTest, SendVideoWithCVO) {
   uint8_t kFrame[kMaxPacketLength];
   RTPVideoHeader hdr = {0};
   hdr.rotation = kVideoRotation_90;
 
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
   EXPECT_EQ(
       RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
       rtp_sender_->RtpHeaderExtensionLength());
 
   rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload,
                                kTimestamp, 0, kFrame, sizeof(kFrame), nullptr,
                                &hdr);
 
-  RtpHeaderExtensionMap map;
-  map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
+  // Verify that this packet does have CVO byte.
+  VerifyCVOPacket(transport_.sent_packets_[0], true, kSeqNum, hdr.rotation);
 
   // Verify that this packet does have CVO byte.
-  VerifyCVOPacket(
-      reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()),
-      transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation);
-
-  // Verify that this packet does have CVO byte.
-  VerifyCVOPacket(
-      reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()),
-      transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1,
-      hdr.rotation);
+  VerifyCVOPacket(transport_.sent_packets_[1], true, kSeqNum + 1, hdr.rotation);
 }
 
 // Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits
 // are set in the CVO byte.
 TEST_F(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
   // Test extracting rotation when Camera (C) and Flip (F) bits are zero.
   EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0));
   EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1));
   EXPECT_EQ(kVideoRotation_180, ConvertCVOByteToVideoRotation(2));
   EXPECT_EQ(kVideoRotation_270, ConvertCVOByteToVideoRotation(3));
   // Test extracting rotation when Camera (C) and Flip (F) bits are set.
   const int flip_bit = 1 << 2;
   const int camera_bit = 1 << 3;
   EXPECT_EQ(kVideoRotation_0,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 0));
   EXPECT_EQ(kVideoRotation_90,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 1));
   EXPECT_EQ(kVideoRotation_180,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 2));
   EXPECT_EQ(kVideoRotation_270,
             ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3));
 }
 
 }  // namespace webrtc