webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc - Issue 2217383002: Use RtpPacketToSend in RtpSenderVideo

Unified Diff: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

Issue 2217383002: Use RtpPacketToSend in RtpSenderVideo (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: Rebase Created 4 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« webrtc/modules/rtp_rtcp/source/producer_fec.h ('K') | « webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc ('k') | webrtc/modules/rtp_rtcp/source/rtp_sender_video.h » ('j') | webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

index cabd411abf1f521217cad6d6a2fc02262bd1bf1f..67716457be34b494e34fc3781e648fbd6b1380ad 100644

--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

@@ -22,6 +22,9 @@

#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"

@@ -40,8 +43,9 @@ 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;

@@ -162,7 +166,7 @@ class RtpSenderTest : public ::testing::Test {

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);

@@ -184,16 +188,34 @@ class RtpSenderTest : public ::testing::Test {

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() {

@@ -234,27 +256,19 @@ class RtpSenderVideoTest : public RtpSenderTest {

RtpHeaderExtensionMap* map,

uint16_t seq_num,

VideoRotation rotation) {

- webrtc::RtpUtility::RtpHeaderParser rtp_parser(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);

+ RtpPacketReceived rtp_parsed_packet(map);

+ ASSERT_TRUE(rtp_parsed_packet.Parse(data, len));

+ 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);

}

};

@@ -319,7 +333,6 @@ TEST_F(RtpSenderTestWithoutPacer, RegisterRtpHeaderExtensions) {

rtp_sender_->RtpHeaderExtensionLength());

EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(

kRtpExtensionVideoRotation, kVideoRotationExtensionId));

- EXPECT_TRUE(rtp_sender_->ActivateCVORtpHeaderExtension());

EXPECT_EQ(RtpUtility::Word32Align(kRtpOneByteHeaderLength +

kTransmissionTimeOffsetLength +

kAbsoluteSendTimeLength +

@@ -352,9 +365,6 @@ 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());

@@ -364,12 +374,16 @@ TEST_F(RtpSenderTestWithoutPacer, RegisterRtpVideoRotationHeaderExtension) {

}

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);

@@ -377,7 +391,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {

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);

@@ -390,17 +404,22 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {

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;

@@ -411,7 +430,7 @@ TEST_F(RtpSenderTestWithoutPacer,

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);

@@ -421,7 +440,7 @@ TEST_F(RtpSenderTestWithoutPacer,

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);

}

@@ -429,17 +448,18 @@ TEST_F(RtpSenderTestWithoutPacer,

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;

@@ -450,23 +470,24 @@ TEST_F(RtpSenderTestWithoutPacer,

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;

@@ -476,7 +497,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {

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);

@@ -486,7 +507,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {

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);

}

@@ -537,26 +558,26 @@ TEST_F(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {

// 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);

@@ -565,26 +586,25 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) {

// 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);

}

@@ -592,17 +612,18 @@ 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);

@@ -611,7 +632,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {

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);

@@ -622,7 +643,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {

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);

@@ -635,17 +656,16 @@ TEST_F(RtpSenderTestWithoutPacer,

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);

@@ -654,7 +674,7 @@ TEST_F(RtpSenderTestWithoutPacer,

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);

@@ -663,10 +683,6 @@ TEST_F(RtpSenderTestWithoutPacer,

}

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));

@@ -679,17 +695,21 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {

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,

@@ -703,7 +723,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {

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);

@@ -721,7 +741,7 @@ TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {

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);

@@ -748,14 +768,12 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {

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_);

@@ -768,10 +786,10 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {

// 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,

@@ -801,14 +819,12 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {

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_);

@@ -819,7 +835,8 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {

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,

@@ -827,11 +844,11 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {

// 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,

@@ -882,15 +899,12 @@ TEST_F(RtpSenderTest, SendPadding) {

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;

@@ -940,27 +954,25 @@ TEST_F(RtpSenderTest, SendPadding) {

// 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);

@@ -1604,15 +1616,11 @@ TEST_F(RtpSenderVideoTest, SendVideoWithCVO) {

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);