Use RtpPacketToSend in RtpSenderVideo

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 <list>
 #include <memory>
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #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/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/mock_transport.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 namespace {
 const int kTransmissionTimeOffsetExtensionId = 1;
 const int kAbsoluteSendTimeExtensionId = 14;
 const int kTransportSequenceNumberExtensionId = 13;
 const int kPayload = 100;
 const int kRtxPayload = 98;
 const uint32_t kTimestamp = 10;
 const uint16_t kSeqNum = 33;
 const int kTimeOffset = 22222;
-const int kMaxPacketLength = 1500;
-const uint32_t kAbsoluteSendTime = 0x00aabbcc;
+const int64_t kAbsoluteSendTimeMs = 1234567890ll;
+const uint32_t kAbsoluteSendTime =
+    AbsoluteSendTime::MsTo24Bits(kAbsoluteSendTimeMs);
 const uint8_t kAudioLevel = 0x5a;
 const uint16_t kTransportSequenceNumber = 0xaabbu;
 const uint8_t kAudioLevelExtensionId = 9;
 const int kAudioPayload = 103;
 const uint64_t kStartTime = 123456789;
 const size_t kMaxPaddingSize = 224u;
 const int kVideoRotationExtensionId = 5;
 const VideoRotation kRotation = kVideoRotation_270;
 
 using testing::_;
@@ skipping 100 matching lines @@
   SimulatedClock fake_clock_;
   testing::NiceMock<MockRtcEventLog> mock_rtc_event_log_;
   MockRtpPacketSender mock_paced_sender_;
   testing::StrictMock<MockTransportSequenceNumberAllocator> seq_num_allocator_;
   testing::StrictMock<MockSendPacketObserver> send_packet_observer_;
   RateLimiter retransmission_rate_limiter_;
   std::unique_ptr<RTPSender> rtp_sender_;
   int payload_;
   LoopbackTransportTest transport_;
   const bool kMarkerBit;
-  uint8_t packet_[kMaxPacketLength];
+  std::unique_ptr<RtpPacketToSend> packet_;
 
   void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
     VerifyRTPHeaderCommon(rtp_header, kMarkerBit, 0);
   }
 
   void VerifyRTPHeaderCommon(const RTPHeader& rtp_header, bool marker_bit) {
     VerifyRTPHeaderCommon(rtp_header, marker_bit, 0);
   }
 
   void VerifyRTPHeaderCommon(const RTPHeader& rtp_header,
                              bool marker_bit,
                              uint8_t number_of_csrcs) {
     EXPECT_EQ(marker_bit, rtp_header.markerBit);
     EXPECT_EQ(payload_, rtp_header.payloadType);
     EXPECT_EQ(kSeqNum, rtp_header.sequenceNumber);
     EXPECT_EQ(kTimestamp, rtp_header.timestamp);
     EXPECT_EQ(rtp_sender_->SSRC(), rtp_header.ssrc);
     EXPECT_EQ(number_of_csrcs, rtp_header.numCSRCs);
     EXPECT_EQ(0U, rtp_header.paddingLength);
   }
 
+  void BuildRtpPacket(uint8_t payload,
+                      bool marker_bit,
+                      uint32_t timestamp,
+                      int64_t capture_time_ms) {
+    packet_ = rtp_sender_->AllocatePacket(false);
+    ASSERT_TRUE(packet_);
+    packet_->SetPayloadType(payload);
+    packet_->SetMarker(marker_bit);
+    packet_->SetTimestamp(timestamp);
+    packet_->set_capture_time_ms(capture_time_ms);
+    ASSERT_TRUE(rtp_sender_->PrepareToSend(packet_.get()));
+  }
+
   void SendPacket(int64_t capture_time_ms, int payload_length) {
     uint32_t timestamp = capture_time_ms * 90;
-    int32_t rtp_length = rtp_sender_->BuildRtpHeader(
-        packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
-    ASSERT_GE(rtp_length, 0);
+    packet_ = rtp_sender_->AllocatePacket(false);
+    ASSERT_TRUE(packet_);
+    packet_->SetPayloadType(kPayload);
+    packet_->SetMarker(kMarkerBit);
+    packet_->SetTimestamp(timestamp);
+    packet_->set_capture_time_ms(capture_time_ms);
+    packet_->AllocatePayload(payload_length);
+    ASSERT_TRUE(rtp_sender_->PrepareToSend(packet_.get()));
 
     // Packet should be stored in a send bucket.
-    EXPECT_TRUE(rtp_sender_->SendToNetwork(
-        packet_, payload_length, rtp_length, capture_time_ms,
-        kAllowRetransmission, RtpPacketSender::kNormalPriority));
+    EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet_),
+                                           kAllowRetransmission,
+                                           RtpPacketSender::kNormalPriority));
   }
 
   void SendGenericPayload() {
     const uint8_t kPayload[] = {47, 11, 32, 93, 89};
     const uint32_t kTimestamp = 1234;
     const uint8_t kPayloadType = 127;
     const int64_t kCaptureTimeMs = fake_clock_.TimeInMilliseconds();
     char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
     EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000,
                                               0, 1500));
@@ skipping 20 matching lines @@
         new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
   }
   std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
 
   void VerifyCVOPacket(uint8_t* data,
                        size_t len,
                        bool expect_cvo,
                        RtpHeaderExtensionMap* map,
                        uint16_t seq_num,
                        VideoRotation rotation) {
-    webrtc::RtpUtility::RtpHeaderParser rtp_parser(data, len);
+    RtpPacketReceived rtp_parsed_packet(map);
+    ASSERT_TRUE(rtp_parsed_packet.Parse(data, len));
 
-    webrtc::RTPHeader rtp_header;
-    size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-        packet_, kPayload, expect_cvo /* marker_bit */, kTimestamp, 0));
-    if (expect_cvo) {
-      ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
-                length);
-    } else {
-      ASSERT_EQ(kRtpHeaderSize, length);
-    }
-    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(ConvertVideoRotationToCVOByte(rotation),
-              rtp_header.extension.videoRotation);
+    EXPECT_EQ(payload_, rtp_parsed_packet.PayloadType());
+    EXPECT_EQ(seq_num, rtp_parsed_packet.SequenceNumber());
+    EXPECT_EQ(kTimestamp, rtp_parsed_packet.Timestamp());
+    EXPECT_EQ(rtp_sender_->SSRC(), rtp_parsed_packet.Ssrc());
+    EXPECT_TRUE(rtp_parsed_packet.Csrcs().empty());
+    EXPECT_EQ(0U, rtp_parsed_packet.padding_size());
+    uint8_t cvo = 0;
+    EXPECT_EQ(expect_cvo,
+              rtp_parsed_packet.GetExtension<VideoOrientation>(&cvo));
+    EXPECT_EQ(ConvertVideoRotationToCVOByte(rotation), cvo);
   }
 };
 
 TEST_F(RtpSenderTestWithoutPacer,
        RegisterRtpTransmissionTimeOffsetHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
   EXPECT_EQ(kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength,
@@ skipping 44 matching lines @@
                                     kAbsoluteSendTimeLength),
             rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
                                                        kAudioLevelExtensionId));
   EXPECT_EQ(RtpUtility::Word32Align(
                 kRtpOneByteHeaderLength + kTransmissionTimeOffsetLength +
                 kAbsoluteSendTimeLength + kAudioLevelLength),
             rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
-  EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
   EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
                                     kTransmissionTimeOffsetLength +
                                     kAbsoluteSendTimeLength +
                                     kAudioLevelLength + kVideoRotationLength),
             rtp_sender_->RtpHeaderExtensionLength());
 
   // Deregister starts.
   EXPECT_EQ(0, rtp_sender_->DeregisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset));
   EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +
@@ skipping 12 matching lines @@
       rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(
       0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation));
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
 }
 
 TEST_F(RtpSenderTestWithoutPacer, RegisterRtpVideoRotationHeaderExtension) {
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
-  EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
-
-  EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
   EXPECT_EQ(
       RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
       rtp_sender_->RtpHeaderExtensionLength());
   EXPECT_EQ(
       0, rtp_sender_->DeregisterRtpHeaderExtension(kRtpExtensionVideoRotation));
   EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionLength());
 }
 
 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {
-  size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize, length);
+  packet_ = rtp_sender_->AllocatePacket(false);
+  packet_->SetMarker(kMarkerBit);
+  packet_->SetPayloadType(kPayload);
+  packet_->SetTimestamp(kTimestamp);
+  rtp_sender_->PrepareToSend(packet_.get());
+  ASSERT_EQ(kRtpHeaderSize, packet_->size());
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, nullptr);
 
   ASSERT_TRUE(valid_rtp_header);
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_FALSE(rtp_header.extension.hasTransmissionTimeOffset);
   EXPECT_FALSE(rtp_header.extension.hasAbsoluteSendTime);
   EXPECT_FALSE(rtp_header.extension.hasAudioLevel);
   EXPECT_EQ(0, rtp_header.extension.transmissionTimeOffset);
   EXPECT_EQ(0u, rtp_header.extension.absoluteSendTime);
   EXPECT_FALSE(rtp_header.extension.voiceActivity);
   EXPECT_EQ(0u, rtp_header.extension.audioLevel);
   EXPECT_EQ(0u, rtp_header.extension.videoRotation);
 }
 
 TEST_F(RtpSenderTestWithoutPacer,
        BuildRTPPacketWithTransmissionOffsetExtension) {
-  EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
 
-  size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
+  packet_ = rtp_sender_->AllocatePacket(false);
+  packet_->SetPayloadType(kPayload);
+  packet_->SetMarker(kMarkerBit);
+  packet_->SetTimestamp(kTimestamp);
+  rtp_sender_->PrepareToSend(packet_.get());
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
+            packet_->size());
+  EXPECT_TRUE(packet_->SetExtension<TransmissionOffset>(kTimeOffset));
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionTransmissionTimeOffset,
                kTransmissionTimeOffsetExtensionId);
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
 
   ASSERT_TRUE(valid_rtp_header);
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
   EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
 
   // Parse without map extension
   webrtc::RTPHeader rtp_header2;
   const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
 
   ASSERT_TRUE(valid_rtp_header2);
   VerifyRTPHeaderCommon(rtp_header2);
-  EXPECT_EQ(length, rtp_header2.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header2.headerLength);
   EXPECT_FALSE(rtp_header2.extension.hasTransmissionTimeOffset);
   EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
 }
 
 TEST_F(RtpSenderTestWithoutPacer,
        BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
   const int kNegTimeOffset = -500;
-  EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
 
-  size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
+  BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, 0);
+  ASSERT_TRUE(packet_->SetExtension<TransmissionOffset>(kNegTimeOffset));
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
+            packet_->size());
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionTransmissionTimeOffset,
                kTransmissionTimeOffsetExtensionId);
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
 
   ASSERT_TRUE(valid_rtp_header);
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
   EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset);
 }
 
 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {
-  EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
   EXPECT_EQ(
       0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                                  kAbsoluteSendTimeExtensionId));
 
-  size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
+  BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, 0);
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
+            packet_->size());
+  ASSERT_TRUE(packet_->SetExtension<AbsoluteSendTime>(kAbsoluteSendTimeMs));
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
 
   ASSERT_TRUE(valid_rtp_header);
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
   EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
 
   // Parse without map extension
   webrtc::RTPHeader rtp_header2;
   const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
 
   ASSERT_TRUE(valid_rtp_header2);
   VerifyRTPHeaderCommon(rtp_header2);
-  EXPECT_EQ(length, rtp_header2.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header2.headerLength);
   EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime);
   EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
 }
 
 TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
   EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
@@ skipping 30 matching lines @@
       .WillOnce(testing::Return(kTransportSequenceNumber));
   EXPECT_CALL(send_packet_observer_,
               OnSendPacket(kTransportSequenceNumber, _, _))
       .Times(1);
 
   SendGenericPayload();
 }
 
 // Test CVO header extension is only set when marker bit is true.
 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) {
-  rtp_sender_->SetVideoRotation(kRotation);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
-  EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
 
-  size_t length = static_cast<size_t>(
-      rtp_sender_->BuildRtpHeader(packet_, kPayload, true, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
+  BuildRtpPacket(kPayload, true, kTimestamp, 0);
+  ASSERT_TRUE(packet_->SetExtension<VideoOrientation>(kRotation));
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
+            packet_->size());
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_TRUE(rtp_header.extension.hasVideoRotation);
   EXPECT_EQ(ConvertVideoRotationToCVOByte(kRotation),
             rtp_header.extension.videoRotation);
 }
 
 // Test CVO header extension is not set when marker bit is false.
 TEST_F(RtpSenderTestWithoutPacer,
        DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
-  rtp_sender_->SetVideoRotation(kRotation);
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
-  EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
 
-  size_t length = static_cast<size_t>(
-      rtp_sender_->BuildRtpHeader(packet_, kPayload, false, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize, length);
+  BuildRtpPacket(kPayload, false, kTimestamp, 0);
+  ASSERT_EQ(kRtpHeaderSize, packet_->size());
+  ASSERT_TRUE(packet_->SetExtension<VideoOrientation>(kRotation));
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   ASSERT_TRUE(rtp_parser.Parse(&rtp_header, &map));
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header, false);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_FALSE(rtp_header.extension.hasVideoRotation);
 }
 
 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
                                                        kAudioLevelExtensionId));
 
-  size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
+  BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, 0);
+  packet_->SetExtension<AudioLevel>(true, kAudioLevel);
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
+            packet_->size());
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   // Updating audio level is done in RTPSenderAudio, so simulate it here.
   rtp_parser.Parse(&rtp_header);
-  rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
 
   ASSERT_TRUE(valid_rtp_header);
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_TRUE(rtp_header.extension.hasAudioLevel);
   EXPECT_TRUE(rtp_header.extension.voiceActivity);
   EXPECT_EQ(kAudioLevel, rtp_header.extension.audioLevel);
 
   // Parse without map extension
   webrtc::RTPHeader rtp_header2;
   const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
 
   ASSERT_TRUE(valid_rtp_header2);
   VerifyRTPHeaderCommon(rtp_header2);
-  EXPECT_EQ(length, rtp_header2.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header2.headerLength);
   EXPECT_FALSE(rtp_header2.extension.hasAudioLevel);
   EXPECT_FALSE(rtp_header2.extension.voiceActivity);
   EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
 }
 
 TEST_F(RtpSenderTestWithoutPacer,
        BuildRTPPacketWithCSRCAndAudioLevelExtension) {
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
                                                        kAudioLevelExtensionId));
   std::vector<uint32_t> csrcs;
   csrcs.push_back(0x23456789);
   rtp_sender_->SetCsrcs(csrcs);
-  size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, 0));
+  BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, 0);
+  EXPECT_TRUE(packet_->SetExtension<AudioLevel>(true, kAudioLevel));
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   // Updating audio level is done in RTPSenderAudio, so simulate it here.
   rtp_parser.Parse(&rtp_header);
-  EXPECT_TRUE(rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true,
-                                            kAudioLevel));
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
 
   ASSERT_TRUE(valid_rtp_header);
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header, kMarkerBit, csrcs.size());
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_TRUE(rtp_header.extension.hasAudioLevel);
   EXPECT_TRUE(rtp_header.extension.voiceActivity);
   EXPECT_EQ(kAudioLevel, rtp_header.extension.audioLevel);
   EXPECT_EQ(1u, rtp_header.numCSRCs);
   EXPECT_EQ(csrcs[0], rtp_header.arrOfCSRCs[0]);
 }
 
 TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {
-  EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
-  EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
-  EXPECT_EQ(0,
-            rtp_sender_->SetTransportSequenceNumber(kTransportSequenceNumber));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransmissionTimeOffset,
                    kTransmissionTimeOffsetExtensionId));
   EXPECT_EQ(
       0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                                  kAbsoluteSendTimeExtensionId));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
                                                        kAudioLevelExtensionId));
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionTransportSequenceNumber,
                    kTransportSequenceNumberExtensionId));
 
-  size_t length = static_cast<size_t>(rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, 0));
-  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(), length);
+  BuildRtpPacket(kPayload, kMarkerBit, kTimestamp, 0);
+  packet_->SetExtension<AudioLevel>(true, kAudioLevel);
+  packet_->SetExtension<TransmissionOffset>(kTimeOffset);
+  packet_->SetExtension<AbsoluteSendTime>(kAbsoluteSendTimeMs);
+  packet_->SetExtension<TransportSequenceNumber>(kTransportSequenceNumber);
+  ASSERT_EQ(kRtpHeaderSize + rtp_sender_->RtpHeaderExtensionLength(),
+            packet_->size());
 
   // Verify
-  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_, length);
+  webrtc::RtpUtility::RtpHeaderParser rtp_parser(packet_->data(),
+                                                 packet_->size());
   webrtc::RTPHeader rtp_header;
 
   // Updating audio level is done in RTPSenderAudio, so simulate it here.
   rtp_parser.Parse(&rtp_header);
-  rtp_sender_->UpdateAudioLevel(packet_, length, rtp_header, true, kAudioLevel);
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionTransmissionTimeOffset,
                kTransmissionTimeOffsetExtensionId);
   map.Register(kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId);
   map.Register(kRtpExtensionAudioLevel, kAudioLevelExtensionId);
   map.Register(kRtpExtensionTransportSequenceNumber,
                kTransportSequenceNumberExtensionId);
   const bool valid_rtp_header = rtp_parser.Parse(&rtp_header, &map);
 
   ASSERT_TRUE(valid_rtp_header);
   ASSERT_FALSE(rtp_parser.RTCP());
   VerifyRTPHeaderCommon(rtp_header);
-  EXPECT_EQ(length, rtp_header.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header.headerLength);
   EXPECT_TRUE(rtp_header.extension.hasTransmissionTimeOffset);
   EXPECT_TRUE(rtp_header.extension.hasAbsoluteSendTime);
   EXPECT_TRUE(rtp_header.extension.hasAudioLevel);
   EXPECT_TRUE(rtp_header.extension.hasTransportSequenceNumber);
   EXPECT_EQ(kTimeOffset, rtp_header.extension.transmissionTimeOffset);
   EXPECT_EQ(kAbsoluteSendTime, rtp_header.extension.absoluteSendTime);
   EXPECT_TRUE(rtp_header.extension.voiceActivity);
   EXPECT_EQ(kAudioLevel, rtp_header.extension.audioLevel);
   EXPECT_EQ(kTransportSequenceNumber,
             rtp_header.extension.transportSequenceNumber);
 
   // Parse without map extension
   webrtc::RTPHeader rtp_header2;
   const bool valid_rtp_header2 = rtp_parser.Parse(&rtp_header2, nullptr);
 
   ASSERT_TRUE(valid_rtp_header2);
   VerifyRTPHeaderCommon(rtp_header2);
-  EXPECT_EQ(length, rtp_header2.headerLength);
+  EXPECT_EQ(packet_->size(), rtp_header2.headerLength);
   EXPECT_FALSE(rtp_header2.extension.hasTransmissionTimeOffset);
   EXPECT_FALSE(rtp_header2.extension.hasAbsoluteSendTime);
   EXPECT_FALSE(rtp_header2.extension.hasAudioLevel);
   EXPECT_FALSE(rtp_header2.extension.hasTransportSequenceNumber);
 
   EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
   EXPECT_EQ(0u, rtp_header2.extension.absoluteSendTime);
   EXPECT_FALSE(rtp_header2.extension.voiceActivity);
   EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
   EXPECT_EQ(0u, rtp_header2.extension.transportSequenceNumber);
 }
 
 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();
-  int rtp_length_int = rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
-  ASSERT_NE(-1, rtp_length_int);
-  size_t rtp_length = static_cast<size_t>(rtp_length_int);
+  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(packet_, 0, rtp_length,
-                                         capture_time_ms, kAllowRetransmission,
+  EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet_),
+                                         kAllowRetransmission,
                                          RtpPacketSender::kNormalPriority));
 
   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(rtp_length, transport_.last_sent_packet_len_);
+  EXPECT_EQ(packet_size, transport_.last_sent_packet_len_);
   // Parse sent packet.
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                                 rtp_length);
+                                                 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);
 
   // 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,
                                                _, 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();
-  int rtp_length_int = rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, kTimestamp, capture_time_ms);
-  ASSERT_NE(-1, rtp_length_int);
-  size_t rtp_length = static_cast<size_t>(rtp_length_int);
+  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(packet_, 0, rtp_length,
-                                         capture_time_ms, kAllowRetransmission,
+  EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet_),
+                                         kAllowRetransmission,
                                          RtpPacketSender::kNormalPriority));
 
   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(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum));
+  EXPECT_EQ(static_cast<int32_t>(packet_size),
+            rtp_sender_->ReSendPacket(kSeqNum));
   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(rtp_length, transport_.last_sent_packet_len_);
+  EXPECT_EQ(packet_size, transport_.last_sent_packet_len_);
 
   // Parse sent packet.
   webrtc::RtpUtility::RtpHeaderParser rtp_parser(transport_.last_sent_packet_,
-                                                 rtp_length);
+                                                 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);
 
   // Verify transmission time offset.
   EXPECT_EQ(kStoredTimeInMs * 90, rtp_header.extension.transmissionTimeOffset);
@@ skipping 30 matching lines @@
   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();
-  int rtp_length_int = rtp_sender_->BuildRtpHeader(
-      packet_, kPayload, kMarkerBit, timestamp, capture_time_ms);
+  BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
   const uint32_t media_packet_timestamp = timestamp;
-  ASSERT_NE(-1, rtp_length_int);
-  size_t rtp_length = static_cast<size_t>(rtp_length_int);
 
   // Packet should be stored in a send bucket.
-  EXPECT_TRUE(rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
-                                         capture_time_ms, kAllowRetransmission,
+  EXPECT_TRUE(rtp_sender_->SendToNetwork(std::move(packet_),
+                                         kAllowRetransmission,
                                          RtpPacketSender::kNormalPriority));
 
   int total_packets_sent = 0;
   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
@@ skipping 29 matching lines @@
     EXPECT_EQ(offset, rtp_header.extension.transmissionTimeOffset);
     uint64_t expected_send_time =
         ConvertMsToAbsSendTime(fake_clock_.TimeInMilliseconds());
     EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
     fake_clock_.AdvanceTimeMilliseconds(kPaddingPeriodMs);
     timestamp += 90 * kPaddingPeriodMs;
   }
 
   // Send a regular video packet again.
   capture_time_ms = fake_clock_.TimeInMilliseconds();
-  rtp_length_int = rtp_sender_->BuildRtpHeader(packet_, kPayload, kMarkerBit,
-                                               timestamp, capture_time_ms);
-  ASSERT_NE(-1, rtp_length_int);
-  rtp_length = static_cast<size_t>(rtp_length_int);
+  BuildRtpPacket(kPayload, kMarkerBit, timestamp, capture_time_ms);
+  size_t packet_size = packet_->size();
 
   EXPECT_CALL(mock_paced_sender_,
               InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _));
 
   // Packet should be stored in a send bucket.
-  EXPECT_TRUE(rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
-                                         capture_time_ms, kAllowRetransmission,
+  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(rtp_length, transport_.last_sent_packet_len_);
+  EXPECT_EQ(packet_size, transport_.last_sent_packet_len_);
   // Parse sent packet.
-  ASSERT_TRUE(
-      rtp_parser->Parse(transport_.last_sent_packet_, rtp_length, &rtp_header));
+  ASSERT_TRUE(rtp_parser->Parse(transport_.last_sent_packet_, packet_size,
+                                &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);
 }
@@ skipping 623 matching lines @@
   EXPECT_EQ(kNumPackets * 2, transport_.packets_sent_);
 }
 
 // Verify that all packets of a frame have CVO byte set.
 TEST_F(RtpSenderVideoTest, SendVideoWithCVO) {
   RTPVideoHeader hdr = {0};
   hdr.rotation = kVideoRotation_90;
 
   EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
                    kRtpExtensionVideoRotation, kVideoRotationExtensionId));
-  EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());
 
-  EXPECT_EQ(
-      RtpUtility::Word32Align(kRtpOneByteHeaderLength + kVideoRotationLength),
-      rtp_sender_->RtpHeaderExtensionLength());
-
+  const uint8_t kPayloadData[1500] = {0};
   rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload,
-                               kTimestamp, 0, packet_, sizeof(packet_), nullptr,
-                               &hdr);
+                               kTimestamp, 0, kPayloadData,
+                               sizeof(kPayloadData), nullptr, &hdr);
 
   RtpHeaderExtensionMap map;
   map.Register(kRtpExtensionVideoRotation, kVideoRotationExtensionId);
 
   // 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);
 }
 }  // namespace webrtc