zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use std::make_unique instead of absl::make_unique.

Browse Source 
WebRTC is now using C++14 so there is no need to use the Abseil version
of std::make_unique.

This CL has been created with the following steps:

git grep -l absl::make_unique | sort | uniq > /tmp/make_unique.txt
git grep -l absl::WrapUnique | sort | uniq > /tmp/wrap_unique.txt
git grep -l "#include <memory>" | sort | uniq > /tmp/memory.txt

diff --new-line-format="" --unchanged-line-format="" \
  /tmp/make_unique.txt /tmp/wrap_unique.txt | sort | \
  uniq > /tmp/only_make_unique.txt
diff --new-line-format="" --unchanged-line-format="" \
  /tmp/only_make_unique.txt /tmp/memory.txt | \
  xargs grep -l "absl/memory" > /tmp/add-memory.txt

git grep -l "\babsl::make_unique\b" | \
  xargs sed -i "s/\babsl::make_unique\b/std::make_unique/g"

git checkout PRESUBMIT.py abseil-in-webrtc.md

cat /tmp/add-memory.txt | \
  xargs sed -i \
  's/#include "absl\/memory\/memory.h"/#include <memory>/g'
git cl format
# Manual fix order of the new inserted #include <memory>

cat /tmp/only_make_unique | xargs grep -l "#include <memory>" | \
  xargs sed -i '/#include "absl\/memory\/memory.h"/d'

git ls-files | grep BUILD.gn | \
  xargs sed -i '/\/\/third_party\/abseil-cpp\/absl\/memory/d'

python tools_webrtc/gn_check_autofix.py \
  -m tryserver.webrtc -b linux_rel

# Repead the gn_check_autofix step for other platforms

git ls-files | grep BUILD.gn | \
  xargs sed -i 's/absl\/memory:memory/absl\/memory/g'
git cl format

Bug: webrtc:10945
Change-Id: I3fe28ea80f4dd3ba3cf28effd151d5e1f19aff89
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/153221
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Alessio Bazzica <alessiob@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29209}
This commit is contained in:
Mirko Bonadei
2019-09-17 17:06:18 +02:00
committed by Commit Bot
parent 809198edff
commit 317a1f09ed
477 changed files with 1796 additions and 2074 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
modules/rtp_rtcp/source/nack_rtx_unittest.cc
View File

@ -14,7 +14,6 @@
#include <set>
#include "absl/algorithm/container.h"
#include "absl/memory/memory.h"
#include "api/call/transport.h"
#include "api/transport/field_trial_based_config.h"
#include "call/rtp_stream_receiver_controller.h"
@ -137,7 +136,7 @@ class RtpRtcpRtxNackTest : public ::testing::Test {
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
configuration.local_media_ssrc = kTestSsrc;
rtp_rtcp_module_ = RtpRtcp::Create(configuration);
rtp_sender_video_ = absl::make_unique<RTPSenderVideo>(
rtp_sender_video_ = std::make_unique<RTPSenderVideo>(
&fake_clock, rtp_rtcp_module_->RtpSender(), nullptr,
&playout_delay_oracle_, nullptr, false, false, false,
FieldTrialBasedConfig());

3
modules/rtp_rtcp/source/receive_statistics_impl.cc
View File

@ -15,7 +15,6 @@
#include <memory>
#include <vector>
#include "absl/memory/memory.h"
#include "modules/remote_bitrate_estimator/test/bwe_test_logging.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
@ -296,7 +295,7 @@ bool StreamStatisticianImpl::IsRetransmitOfOldPacket(
}
std::unique_ptr<ReceiveStatistics> ReceiveStatistics::Create(Clock* clock) {
return absl::make_unique<ReceiveStatisticsImpl>(clock);
return std::make_unique<ReceiveStatisticsImpl>(clock);
}
ReceiveStatisticsImpl::ReceiveStatisticsImpl(Clock* clock)

3
modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -18,7 +18,6 @@
#include <utility>
#include <vector>
#include "absl/memory/memory.h"
#include "api/video/video_bitrate_allocation.h"
#include "api/video/video_bitrate_allocator.h"
#include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
@ -911,7 +910,7 @@ void RTCPReceiver::HandlePsfbApp(const CommonHeader& rtcp_block,
}
{
auto loss_notification = absl::make_unique<rtcp::LossNotification>();
auto loss_notification = std::make_unique<rtcp::LossNotification>();
if (loss_notification->Parse(rtcp_block)) {
packet_information->packet_type_flags |= kRtcpLossNotification;
packet_information->loss_notification = std::move(loss_notification);

9
modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -13,9 +13,9 @@
#include <string.h> // memcpy
#include <algorithm> // std::min
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "api/rtc_event_log/rtc_event_log.h"
#include "logging/rtc_event_log/events/rtc_event_rtcp_packet_outgoing.h"
#include "modules/rtp_rtcp/source/rtcp_packet/app.h"
@ -82,8 +82,7 @@ class PacketContainer : public rtcp::CompoundPacket {
if (transport_->SendRtcp(packet.data(), packet.size())) {
bytes_sent += packet.size();
if (event_log_) {
event_log_->Log(
absl::make_unique<RtcEventRtcpPacketOutgoing>(packet));
event_log_->Log(std::make_unique<RtcEventRtcpPacketOutgoing>(packet));
}
}
});
@ -606,7 +605,7 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildLossNotification(
const RtcpContext& ctx) {
auto loss_notification = absl::make_unique<rtcp::LossNotification>(
auto loss_notification = std::make_unique<rtcp::LossNotification>(
loss_notification_state_.last_decoded_seq_num,
loss_notification_state_.last_received_seq_num,
loss_notification_state_.decodability_flag);
@ -989,7 +988,7 @@ bool RTCPSender::SendFeedbackPacket(const rtcp::TransportFeedback& packet) {
auto callback = [&](rtc::ArrayView<const uint8_t> packet) {
if (transport_->SendRtcp(packet.data(), packet.size())) {
if (event_log_)
event_log_->Log(absl::make_unique<RtcEventRtcpPacketOutgoing>(packet));
event_log_->Log(std::make_unique<RtcEventRtcpPacketOutgoing>(packet));
} else {
send_failure = true;
}

4
modules/rtp_rtcp/source/rtcp_transceiver.cc
View File

@ -10,9 +10,9 @@
#include "modules/rtp_rtcp/source/rtcp_transceiver.h"
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
@ -23,7 +23,7 @@ namespace webrtc {
RtcpTransceiver::RtcpTransceiver(const RtcpTransceiverConfig& config)
: task_queue_(config.task_queue),
rtcp_transceiver_(absl::make_unique<RtcpTransceiverImpl>(config)) {
rtcp_transceiver_(std::make_unique<RtcpTransceiverImpl>(config)) {
RTC_DCHECK(task_queue_);
}

11
modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
View File

@ -12,7 +12,6 @@
#include <memory>
#include "absl/memory/memory.h"
#include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "rtc_base/event.h"
@ -79,7 +78,7 @@ TEST(RtcpTransceiverTest, SendsRtcpOnTaskQueueWhenCreatedOnTaskQueue) {
std::unique_ptr<RtcpTransceiver> rtcp_transceiver;
queue.PostTask([&] {
rtcp_transceiver = absl::make_unique<RtcpTransceiver>(config);
rtcp_transceiver = std::make_unique<RtcpTransceiver>(config);
rtcp_transceiver->SendCompoundPacket();
});
WaitPostedTasks(&queue);
@ -91,7 +90,7 @@ TEST(RtcpTransceiverTest, CanBeDestroyedOnTaskQueue) {
RtcpTransceiverConfig config;
config.outgoing_transport = &outgoing_transport;
config.task_queue = &queue;
auto rtcp_transceiver = absl::make_unique<RtcpTransceiver>(config);
auto rtcp_transceiver = std::make_unique<RtcpTransceiver>(config);
queue.PostTask([&] {
// Insert a packet just before destruction to test for races.
@ -162,7 +161,7 @@ TEST(RtcpTransceiverTest, DoesntPostToRtcpObserverAfterCallToRemove) {
RtcpTransceiver rtcp_transceiver(config);
rtc::Event observer_deleted;
auto observer = absl::make_unique<MockMediaReceiverRtcpObserver>();
auto observer = std::make_unique<MockMediaReceiverRtcpObserver>();
EXPECT_CALL(*observer, OnSenderReport(kRemoteSsrc, _, 1));
EXPECT_CALL(*observer, OnSenderReport(kRemoteSsrc, _, 2)).Times(0);
@ -187,7 +186,7 @@ TEST(RtcpTransceiverTest, RemoveMediaReceiverRtcpObserverIsNonBlocking) {
config.outgoing_transport = &null_transport;
config.task_queue = &queue;
RtcpTransceiver rtcp_transceiver(config);
auto observer = absl::make_unique<MockMediaReceiverRtcpObserver>();
auto observer = std::make_unique<MockMediaReceiverRtcpObserver>();
rtcp_transceiver.AddMediaReceiverRtcpObserver(kRemoteSsrc, observer.get());
rtc::Event queue_blocker;
@ -241,7 +240,7 @@ TEST(RtcpTransceiverTest, DoesntSendPacketsAfterStopCallback) {
config.task_queue = &queue;
config.schedule_periodic_compound_packets = true;
auto rtcp_transceiver = absl::make_unique<RtcpTransceiver>(config);
auto rtcp_transceiver = std::make_unique<RtcpTransceiver>(config);
rtc::Event done;
rtcp_transceiver->SendCompoundPacket();
rtcp_transceiver->Stop([&] {

3
modules/rtp_rtcp/source/rtp_dependency_descriptor_reader.cc
View File

@ -13,7 +13,6 @@
#include <utility>
#include <vector>
#include "absl/memory/memory.h"
#include "rtc_base/bit_buffer.h"
#include "rtc_base/checks.h"
@ -65,7 +64,7 @@ uint32_t RtpDependencyDescriptorReader::ReadNonSymmetric(size_t num_values) {
void RtpDependencyDescriptorReader::ReadTemplateDependencyStructure() {
descriptor_->attached_structure =
absl::make_unique<FrameDependencyStructure>();
std::make_unique<FrameDependencyStructure>();
descriptor_->attached_structure->structure_id = ReadBits(6);
descriptor_->attached_structure->num_decode_targets = ReadBits(5) + 1;

13
modules/rtp_rtcp/source/rtp_format.cc
View File

@ -10,7 +10,8 @@
#include "modules/rtp_rtcp/source/rtp_format.h"
#include "absl/memory/memory.h"
#include <memory>
#include "absl/types/variant.h"
#include "modules/rtp_rtcp/source/rtp_format_h264.h"
#include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
@ -33,7 +34,7 @@ std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(
const RTPFragmentationHeader* fragmentation) {
if (!type) {
// Use raw packetizer.
return absl::make_unique<RtpPacketizerGeneric>(payload, limits);
return std::make_unique<RtpPacketizerGeneric>(payload, limits);
}
switch (*type) {
@ -41,21 +42,21 @@ std::unique_ptr<RtpPacketizer> RtpPacketizer::Create(
RTC_CHECK(fragmentation);
const auto& h264 =
absl::get<RTPVideoHeaderH264>(rtp_video_header.video_type_header);
return absl::make_unique<RtpPacketizerH264>(
return std::make_unique<RtpPacketizerH264>(
payload, limits, h264.packetization_mode, *fragmentation);
}
case kVideoCodecVP8: {
const auto& vp8 =
absl::get<RTPVideoHeaderVP8>(rtp_video_header.video_type_header);
return absl::make_unique<RtpPacketizerVp8>(payload, limits, vp8);
return std::make_unique<RtpPacketizerVp8>(payload, limits, vp8);
}
case kVideoCodecVP9: {
const auto& vp9 =
absl::get<RTPVideoHeaderVP9>(rtp_video_header.video_type_header);
return absl::make_unique<RtpPacketizerVp9>(payload, limits, vp9);
return std::make_unique<RtpPacketizerVp9>(payload, limits, vp9);
}
default: {
return absl::make_unique<RtpPacketizerGeneric>(
return std::make_unique<RtpPacketizerGeneric>(
payload, limits, rtp_video_header, frame_type);
}
}

8
modules/rtp_rtcp/source/rtp_packet_history.cc
View File

@ -12,9 +12,9 @@
#include <algorithm>
#include <limits>
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
@ -190,14 +190,14 @@ std::unique_ptr<RtpPacketToSend> RtpPacketHistory::GetPacketAndSetSendTime(
packet->pending_transmission_ = false;
// Return copy of packet instance since it may need to be retransmitted.
return absl::make_unique<RtpPacketToSend>(*packet->packet_);
return std::make_unique<RtpPacketToSend>(*packet->packet_);
}
std::unique_ptr<RtpPacketToSend> RtpPacketHistory::GetPacketAndMarkAsPending(
uint16_t sequence_number) {
return GetPacketAndMarkAsPending(
sequence_number, [](const RtpPacketToSend& packet) {
return absl::make_unique<RtpPacketToSend>(packet);
return std::make_unique<RtpPacketToSend>(packet);
});
}
@ -298,7 +298,7 @@ bool RtpPacketHistory::VerifyRtt(const RtpPacketHistory::StoredPacket& packet,
std::unique_ptr<RtpPacketToSend> RtpPacketHistory::GetPayloadPaddingPacket() {
// Default implementation always just returns a copy of the packet.
return GetPayloadPaddingPacket([](const RtpPacketToSend& packet) {
return absl::make_unique<RtpPacketToSend>(packet);
return std::make_unique<RtpPacketToSend>(packet);
});
}

5
modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
View File

@ -13,7 +13,6 @@
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "system_wrappers/include/clock.h"
@ -600,7 +599,7 @@ TEST_F(RtpPacketHistoryTest, GetPacketWithEncapsulation) {
hist_.GetPacketAndMarkAsPending(
kStartSeqNum, [](const RtpPacketToSend& packet) {
auto encapsulated_packet =
absl::make_unique<RtpPacketToSend>(packet);
std::make_unique<RtpPacketToSend>(packet);
encapsulated_packet->SetSsrc(packet.Ssrc() + 1);
return encapsulated_packet;
});
@ -728,7 +727,7 @@ TEST_F(RtpPacketHistoryTest, PayloadPaddingWithEncapsulation) {
// Get copy of packet, but with sequence number modified.
auto padding_packet =
hist_.GetPayloadPaddingPacket([&](const RtpPacketToSend& packet) {
auto encapsulated_packet = absl::make_unique<RtpPacketToSend>(packet);
auto encapsulated_packet = std::make_unique<RtpPacketToSend>(packet);
encapsulated_packet->SetSequenceNumber(kStartSeqNum + 1);
return encapsulated_packet;
});

4
modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -14,11 +14,11 @@
#include <algorithm>
#include <cstdint>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include "absl/memory/memory.h"
#include "api/transport/field_trial_based_config.h"
#include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_config.h"
@ -43,7 +43,7 @@ RtpRtcp::Configuration::Configuration(Configuration&& rhs) = default;
std::unique_ptr<RtpRtcp> RtpRtcp::Create(const Configuration& configuration) {
RTC_DCHECK(configuration.clock);
return absl::make_unique<ModuleRtpRtcpImpl>(configuration);
return std::make_unique<ModuleRtpRtcpImpl>(configuration);
}
ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)

3
modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -14,7 +14,6 @@
#include <memory>
#include <set>
#include "absl/memory/memory.h"
#include "api/transport/field_trial_based_config.h"
#include "api/video_codecs/video_codec.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@ -179,7 +178,7 @@ class RtpRtcpImplTest : public ::testing::Test {
sender_.impl_->SetSequenceNumber(kSequenceNumber);
sender_.impl_->SetStorePacketsStatus(true, 100);
sender_video_ = absl::make_unique<RTPSenderVideo>(
sender_video_ = std::make_unique<RTPSenderVideo>(
&clock_, sender_.impl_->RtpSender(), nullptr, &playout_delay_oracle_,
nullptr, false, false, false, FieldTrialBasedConfig());

16
modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -12,10 +12,10 @@
#include <algorithm>
#include <limits>
#include <memory>
#include <string>
#include <utility>
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "api/array_view.h"
#include "api/rtc_event_log/rtc_event_log.h"
@ -329,7 +329,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id) {
retransmit_packet = BuildRtxPacket(stored_packet);
} else {
retransmit_packet =
absl::make_unique<RtpPacketToSend>(stored_packet);
std::make_unique<RtpPacketToSend>(stored_packet);
}
if (retransmit_packet) {
retransmit_packet->set_retransmitted_sequence_number(
@ -367,7 +367,7 @@ bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
? static_cast<int>(packet.size())
: -1;
if (event_log_ && bytes_sent > 0) {
event_log_->Log(absl::make_unique<RtcEventRtpPacketOutgoing>(
event_log_->Log(std::make_unique<RtcEventRtpPacketOutgoing>(
packet, pacing_info.probe_cluster_id));
}
}
@ -492,7 +492,7 @@ bool RTPSender::TrySendPacket(RtpPacketToSend* packet,
// Put packet in retransmission history or update pending status even if
// actual sending fails.
if (is_media && packet->allow_retransmission()) {
packet_history_.PutRtpPacket(absl::make_unique<RtpPacketToSend>(*packet),
packet_history_.PutRtpPacket(std::make_unique<RtpPacketToSend>(*packet),
now_ms);
} else if (packet->retransmitted_sequence_number()) {
packet_history_.MarkPacketAsSent(*packet->retransmitted_sequence_number());
@ -599,7 +599,7 @@ std::vector<std::unique_ptr<RtpPacketToSend>> RTPSender::GeneratePadding(
while (bytes_left > 0) {
auto padding_packet =
absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_);
std::make_unique<RtpPacketToSend>(&rtp_header_extension_map_);
padding_packet->set_packet_type(RtpPacketToSend::Type::kPadding);
padding_packet->SetMarker(false);
padding_packet->SetTimestamp(last_rtp_timestamp_);
@ -825,7 +825,7 @@ std::unique_ptr<RtpPacketToSend> RTPSender::AllocatePacket() const {
// While sending slightly oversized packet increase chance of dropped packet,
// it is better than crash on drop packet without trying to send it.
static constexpr int kExtraCapacity = 16;
auto packet = absl::make_unique<RtpPacketToSend>(
auto packet = std::make_unique<RtpPacketToSend>(
&rtp_header_extension_map_, max_packet_size_ + kExtraCapacity);
RTC_DCHECK(ssrc_);
packet->SetSsrc(*ssrc_);
@ -1037,8 +1037,8 @@ std::unique_ptr<RtpPacketToSend> RTPSender::BuildRtxPacket(
if (kv == rtx_payload_type_map_.end())
return nullptr;
rtx_packet = absl::make_unique<RtpPacketToSend>(&rtp_header_extension_map_,
max_packet_size_);
rtx_packet = std::make_unique<RtpPacketToSend>(&rtp_header_extension_map_,
max_packet_size_);
rtx_packet->SetPayloadType(kv->second);

55
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -13,7 +13,6 @@
#include <memory>
#include <vector>
#include "absl/memory/memory.h"
#include "api/rtc_event_log/rtc_event.h"
#include "api/transport/field_trial_based_config.h"
#include "api/video/video_codec_constants.h"
@ -262,8 +261,8 @@ class RtpSenderTest : public ::testing::TestWithParam<TestConfig> {
packet->set_allow_retransmission(true);
// Packet should be stored in a send bucket.
EXPECT_TRUE(rtp_sender_->SendToNetwork(
absl::make_unique<RtpPacketToSend>(*packet)));
EXPECT_TRUE(
rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
return packet;
}
@ -406,7 +405,7 @@ TEST_P(RtpSenderTest, AssignSequenceNumberAllowsPaddingOnAudio) {
config.local_media_ssrc = kSsrc;
config.event_log = &mock_rtc_event_log_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
rtp_sender_->SetTimestampOffset(0);
@ -456,7 +455,7 @@ TEST_P(RtpSenderTestWithoutPacer,
config.event_log = &mock_rtc_event_log_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.overhead_observer = &mock_overhead_observer;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
@ -492,7 +491,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
@ -531,7 +530,7 @@ TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
SendGenericPacket();
@ -584,7 +583,7 @@ TEST_P(RtpSenderTestWithoutPacer, OnSendSideDelayUpdated) {
config.local_media_ssrc = kSsrc;
config.send_side_delay_observer = &send_side_delay_observer_;
config.event_log = &mock_rtc_event_log_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
PlayoutDelayOracle playout_delay_oracle;
RTPSenderVideo rtp_sender_video(&fake_clock_, rtp_sender_.get(), nullptr,
@ -674,7 +673,7 @@ TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
rtp_sender_->SetSequenceNumber(kSeqNum);
rtp_sender_->SetStorePacketsStatus(true, 10);
@ -735,7 +734,7 @@ TEST_P(RtpSenderTest, WritesPacerExitToTimingExtension) {
EXPECT_CALL(mock_paced_sender_,
EnqueuePacket(Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc))));
EXPECT_TRUE(
rtp_sender_->SendToNetwork(absl::make_unique<RtpPacketToSend>(*packet)));
rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
EXPECT_EQ(1, transport_.packets_sent());
@ -771,8 +770,8 @@ TEST_P(RtpSenderTest, WritesNetwork2ToTimingExtensionWithPacer) {
EXPECT_CALL(
mock_paced_sender_,
EnqueuePacket(Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc))));
EXPECT_TRUE(rtp_sender_->SendToNetwork(
absl::make_unique<RtpPacketToSend>(*packet)));
EXPECT_TRUE(
rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
@ -835,8 +834,8 @@ TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))));
packet->set_packet_type(RtpPacketToSend::Type::kVideo);
packet->set_allow_retransmission(true);
EXPECT_TRUE(rtp_sender_->SendToNetwork(
absl::make_unique<RtpPacketToSend>(*packet)));
EXPECT_TRUE(
rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
EXPECT_EQ(0, transport_.packets_sent());
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
@ -879,8 +878,8 @@ TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))));
packet->set_packet_type(RtpPacketToSend::Type::kVideo);
packet->set_allow_retransmission(true);
EXPECT_TRUE(rtp_sender_->SendToNetwork(
absl::make_unique<RtpPacketToSend>(*packet)));
EXPECT_TRUE(
rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
// Immediately process send bucket and send packet.
rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
@ -958,8 +957,8 @@ TEST_P(RtpSenderTest, SendPadding) {
Pointee(Property(&RtpPacketToSend::SequenceNumber, kSeqNum)))));
packet->set_packet_type(RtpPacketToSend::Type::kVideo);
packet->set_allow_retransmission(true);
EXPECT_TRUE(rtp_sender_->SendToNetwork(
absl::make_unique<RtpPacketToSend>(*packet)));
EXPECT_TRUE(
rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
EXPECT_EQ(total_packets_sent, transport_.packets_sent());
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
@ -1012,8 +1011,8 @@ TEST_P(RtpSenderTest, SendPadding) {
EnqueuePacket(AllOf(
Pointee(Property(&RtpPacketToSend::Ssrc, kSsrc)),
Pointee(Property(&RtpPacketToSend::SequenceNumber, seq_num)))));
EXPECT_TRUE(rtp_sender_->SendToNetwork(
absl::make_unique<RtpPacketToSend>(*packet)));
EXPECT_TRUE(
rtp_sender_->SendToNetwork(std::make_unique<RtpPacketToSend>(*packet)));
rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo());
// Process send bucket.
@ -1160,7 +1159,7 @@ TEST_P(RtpSenderTest, SendFlexfecPackets) {
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
rtp_sender_->SetSequenceNumber(kSeqNum);
rtp_sender_->SetStorePacketsStatus(true, 10);
@ -1246,7 +1245,7 @@ TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) {
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.local_media_ssrc = kSsrc;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
rtp_sender_->SetSequenceNumber(kSeqNum);
rtp_sender_->SetStorePacketsStatus(true, 10);
@ -1370,7 +1369,7 @@ TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
rtp_sender_->SetSequenceNumber(kSeqNum);
@ -1638,7 +1637,7 @@ TEST_P(RtpSenderTest, FecOverheadRate) {
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
rtp_sender_->SetSequenceNumber(kSeqNum);
@ -1713,7 +1712,7 @@ TEST_P(RtpSenderTest, BitrateCallbacks) {
config.local_media_ssrc = kSsrc;
config.send_bitrate_observer = &callback;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
PlayoutDelayOracle playout_delay_oracle;
RTPSenderVideo rtp_sender_video(&fake_clock_, rtp_sender_.get(), nullptr,
@ -1952,7 +1951,7 @@ TEST_P(RtpSenderTest, OnOverheadChanged) {
config.local_media_ssrc = kSsrc;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.overhead_observer = &mock_overhead_observer;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
// RTP overhead is 12B.
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(12)).Times(1);
@ -1975,7 +1974,7 @@ TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
config.local_media_ssrc = kSsrc;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
config.overhead_observer = &mock_overhead_observer;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
EXPECT_CALL(mock_overhead_observer, OnOverheadChanged(_)).Times(1);
SendGenericPacket();
@ -2201,7 +2200,7 @@ TEST_P(RtpSenderTest, TrySendPacketUpdatesStats) {
config.send_side_delay_observer = &send_side_delay_observer;
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
rtp_sender_ = absl::make_unique<RTPSender>(config);
rtp_sender_ = std::make_unique<RTPSender>(config);
ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId));

11
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -18,7 +18,6 @@
#include <string>
#include <utility>
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "api/crypto/frame_encryptor_interface.h"
#include "modules/remote_bitrate_estimator/test/bwe_test_logging.h"
@ -216,7 +215,7 @@ RTPSenderVideo::RTPSenderVideo(Clock* clock,
transmit_color_space_next_frame_(false),
playout_delay_oracle_(playout_delay_oracle),
rtp_sequence_number_map_(need_rtp_packet_infos
? absl::make_unique<RtpSequenceNumberMap>(
? std::make_unique<RtpSequenceNumberMap>(
kRtpSequenceNumberMapMaxEntries)
: nullptr),
red_payload_type_(-1),
@ -552,9 +551,9 @@ bool RTPSenderVideo::SendVideo(
single_packet->SetTimestamp(rtp_timestamp);
single_packet->set_capture_time_ms(capture_time_ms);
auto first_packet = absl::make_unique<RtpPacketToSend>(*single_packet);
auto middle_packet = absl::make_unique<RtpPacketToSend>(*single_packet);
auto last_packet = absl::make_unique<RtpPacketToSend>(*single_packet);
auto first_packet = std::make_unique<RtpPacketToSend>(*single_packet);
auto middle_packet = std::make_unique<RtpPacketToSend>(*single_packet);
auto last_packet = std::make_unique<RtpPacketToSend>(*single_packet);
// Simplest way to estimate how much extensions would occupy is to set them.
AddRtpHeaderExtensions(*video_header, playout_delay, frame_type,
set_video_rotation, set_color_space, set_frame_marking,
@ -706,7 +705,7 @@ bool RTPSenderVideo::SendVideo(
expected_payload_capacity =
limits.max_payload_len - limits.last_packet_reduction_len;
} else {
packet = absl::make_unique<RtpPacketToSend>(*middle_packet);
packet = std::make_unique<RtpPacketToSend>(*middle_packet);
expected_payload_capacity = limits.max_payload_len;
}

3
modules/rtp_rtcp/source/ulpfec_receiver_impl.cc
View File

@ -15,7 +15,6 @@
#include <memory>
#include <utility>
#include "absl/memory/memory.h"
#include "api/scoped_refptr.h"
#include "modules/rtp_rtcp/source/byte_io.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
@ -28,7 +27,7 @@ std::unique_ptr<UlpfecReceiver> UlpfecReceiver::Create(
uint32_t ssrc,
RecoveredPacketReceiver* callback,
rtc::ArrayView<const RtpExtension> extensions) {
return absl::make_unique<UlpfecReceiverImpl>(ssrc, callback, extensions);
return std::make_unique<UlpfecReceiverImpl>(ssrc, callback, extensions);
}
UlpfecReceiverImpl::UlpfecReceiverImpl(