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

6
modules/audio_coding/neteq/delay_manager.cc
View File

@ -15,10 +15,10 @@
#include <stdlib.h>
#include <algorithm>
#include <memory>
#include <numeric>
#include <string>
#include "absl/memory/memory.h"
#include "modules/audio_coding/neteq/delay_peak_detector.h"
#include "modules/audio_coding/neteq/histogram.h"
#include "modules/audio_coding/neteq/statistics_calculator.h"
@ -149,9 +149,9 @@ std::unique_ptr<DelayManager> DelayManager::Create(
const HistogramMode mode = RELATIVE_ARRIVAL_DELAY;
DelayHistogramConfig config = GetDelayHistogramConfig();
const int quantile = config.quantile;
std::unique_ptr<Histogram> histogram = absl::make_unique<Histogram>(
std::unique_ptr<Histogram> histogram = std::make_unique<Histogram>(
kDelayBuckets, config.forget_factor, config.start_forget_weight);
return absl::make_unique<DelayManager>(
return std::make_unique<DelayManager>(
max_packets_in_buffer, base_minimum_delay_ms, quantile, mode,
enable_rtx_handling, peak_detector, tick_timer, statistics,
std::move(histogram));

5
modules/audio_coding/neteq/delay_manager_unittest.cc
View File

@ -14,7 +14,8 @@
#include <math.h>
#include "absl/memory/memory.h"
#include <memory>
#include "modules/audio_coding/neteq/histogram.h"
#include "modules/audio_coding/neteq/mock/mock_delay_peak_detector.h"
#include "modules/audio_coding/neteq/mock/mock_histogram.h"
@ -80,7 +81,7 @@ void DelayManagerTest::RecreateDelayManager() {
if (use_mock_histogram_) {
mock_histogram_ = new MockHistogram(kMaxIat, kForgetFactor);
std::unique_ptr<Histogram> histogram(mock_histogram_);
dm_ = absl::make_unique<DelayManager>(
dm_ = std::make_unique<DelayManager>(
kMaxNumberOfPackets, kMinDelayMs, kDefaultHistogramQuantile,
histogram_mode_, enable_rtx_handling_, &detector_, &tick_timer_,
&stats_, std::move(histogram));

14
modules/audio_coding/neteq/neteq_decoder_plc_unittest.cc
View File

@ -11,10 +11,10 @@
// Test to verify correct operation when using the decoder-internal PLC.
#include <algorithm>
#include <memory>
#include <utility>
#include <vector>
#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h"
#include "modules/audio_coding/neteq/tools/audio_checksum.h"
@ -156,31 +156,31 @@ NetEqNetworkStatistics RunTest(int loss_cadence, std::string* checksum) {
// The input is mostly useless. It sends zero-samples to a PCM16b encoder,
// but the actual encoded samples will never be used by the decoder in the
// test. See below about the decoder.
auto generator = absl::make_unique<ZeroSampleGenerator>();
auto generator = std::make_unique<ZeroSampleGenerator>();
constexpr int kSampleRateHz = 32000;
constexpr int kPayloadType = 100;
AudioEncoderPcm16B::Config encoder_config;
encoder_config.sample_rate_hz = kSampleRateHz;
encoder_config.payload_type = kPayloadType;
auto encoder = absl::make_unique<AudioEncoderPcm16B>(encoder_config);
auto encoder = std::make_unique<AudioEncoderPcm16B>(encoder_config);
constexpr int kRunTimeMs = 10000;
auto input = absl::make_unique<EncodeNetEqInput>(
auto input = std::make_unique<EncodeNetEqInput>(
std::move(generator), std::move(encoder), kRunTimeMs);
// Wrap the input in a loss function.
auto lossy_input =
absl::make_unique<LossyInput>(loss_cadence, std::move(input));
std::make_unique<LossyInput>(loss_cadence, std::move(input));
// Settinng up decoders.
NetEqTest::DecoderMap decoders;
// Using a fake decoder which simply reads the output audio from a file.
auto input_file = absl::make_unique<InputAudioFile>(
auto input_file = std::make_unique<InputAudioFile>(
webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm"));
AudioDecoderPlc dec(std::move(input_file), kSampleRateHz);
// Masquerading as a PCM16b decoder.
decoders.emplace(kPayloadType, SdpAudioFormat("l16", 32000, 1));
// Output is simply a checksum calculator.
auto output = absl::make_unique<AudioChecksumWithOutput>(checksum);
auto output = std::make_unique<AudioChecksumWithOutput>(checksum);
// No callback objects.
NetEqTest::Callbacks callbacks;

5
modules/audio_coding/neteq/neteq_impl_unittest.cc
View File

@ -14,7 +14,6 @@
#include <utility>
#include <vector>
#include "absl/memory/memory.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "modules/audio_coding/neteq/accelerate.h"
#include "modules/audio_coding/neteq/expand.h"
@ -109,7 +108,7 @@ class NetEqImplTest : public ::testing::Test {
config_.max_packets_in_buffer, config_.min_delay_ms, 1020054733,
DelayManager::HistogramMode::INTER_ARRIVAL_TIME,
config_.enable_rtx_handling, delay_peak_detector_, tick_timer_,
deps.stats.get(), absl::make_unique<Histogram>(50, 32745)));
deps.stats.get(), std::make_unique<Histogram>(50, 32745)));
mock_delay_manager_ = mock.get();
deps.delay_manager = std::move(mock);
}
@ -1567,7 +1566,7 @@ class NetEqImplTest120ms : public NetEqImplTest {
new rtc::RefCountedObject<test::FunctionAudioDecoderFactory>(
[sampling_freq, speech_type]() {
std::unique_ptr<AudioDecoder> decoder =
absl::make_unique<Decoder120ms>(sampling_freq, speech_type);
std::make_unique<Decoder120ms>(sampling_freq, speech_type);
RTC_CHECK_EQ(2, decoder->Channels());
return decoder;
});

5
modules/audio_coding/neteq/packet_buffer_unittest.cc
View File

@ -12,7 +12,8 @@
#include "modules/audio_coding/neteq/packet_buffer.h"
#include "absl/memory/memory.h"
#include <memory>
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "modules/audio_coding/neteq/mock/mock_decoder_database.h"
#include "modules/audio_coding/neteq/mock/mock_statistics_calculator.h"
@ -704,7 +705,7 @@ TEST(PacketBuffer, GetSpanSamples) {
Packet packet_1 = gen.NextPacket(kPayloadSizeBytes, nullptr);
std::unique_ptr<MockEncodedAudioFrame> mock_audio_frame =
absl::make_unique<MockEncodedAudioFrame>();
std::make_unique<MockEncodedAudioFrame>();
EXPECT_CALL(*mock_audio_frame, Duration())
.WillRepeatedly(Return(kFrameSizeSamples));
Packet packet_2 =

24
modules/audio_coding/neteq/tools/neteq_test_factory.cc
View File

@ -22,7 +22,6 @@
#include <string>
#include <utility>
#include "absl/memory/memory.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "modules/audio_coding/neteq/include/neteq.h"
#include "modules/audio_coding/neteq/tools/audio_sink.h"
@ -194,19 +193,19 @@ std::unique_ptr<NetEqTest> NetEqTestFactory::InitializeTest(
// If an output file is requested, open it.
std::unique_ptr<AudioSink> output;
if (!config.output_audio_filename.has_value()) {
output = absl::make_unique<VoidAudioSink>();
output = std::make_unique<VoidAudioSink>();
std::cout << "No output audio file" << std::endl;
} else if (config.output_audio_filename->size() >= 4 &&
config.output_audio_filename->substr(
config.output_audio_filename->size() - 4) == ".wav") {
// Open a wav file with the known sample rate.
output = absl::make_unique<OutputWavFile>(*config.output_audio_filename,
*sample_rate_hz);
output = std::make_unique<OutputWavFile>(*config.output_audio_filename,
*sample_rate_hz);
std::cout << "Output WAV file: " << *config.output_audio_filename
<< std::endl;
} else {
// Open a pcm file.
output = absl::make_unique<OutputAudioFile>(*config.output_audio_filename);
output = std::make_unique<OutputAudioFile>(*config.output_audio_filename);
std::cout << "Output PCM file: " << *config.output_audio_filename
<< std::endl;
}
@ -254,9 +253,8 @@ std::unique_ptr<NetEqTest> NetEqTestFactory::InitializeTest(
std::unique_ptr<AudioDecoder> decoder =
decoder_factory->MakeAudioDecoder(format, codec_pair_id);
if (!decoder && format.name == "replacement") {
decoder = absl::make_unique<FakeDecodeFromFile>(
absl::make_unique<InputAudioFile>(
config.replacement_audio_file),
decoder = std::make_unique<FakeDecodeFromFile>(
std::make_unique<InputAudioFile>(config.replacement_audio_file),
format.clockrate_hz, format.num_channels > 1);
}
return decoder;
@ -274,11 +272,11 @@ std::unique_ptr<NetEqTest> NetEqTestFactory::InitializeTest(
// Create a text log file if needed.
std::unique_ptr<std::ofstream> text_log;
if (config.textlog_filename.has_value()) {
text_log = absl::make_unique<std::ofstream>(*config.textlog_filename);
text_log = std::make_unique<std::ofstream>(*config.textlog_filename);
}
NetEqTest::Callbacks callbacks;
stats_plotter_ = absl::make_unique<NetEqStatsPlotter>(
stats_plotter_ = std::make_unique<NetEqStatsPlotter>(
config.matlabplot, config.pythonplot, config.concealment_events,
config.plot_scripts_basename.value_or(""));
@ -291,9 +289,9 @@ std::unique_ptr<NetEqTest> NetEqTestFactory::InitializeTest(
neteq_config.sample_rate_hz = *sample_rate_hz;
neteq_config.max_packets_in_buffer = config.max_nr_packets_in_buffer;
neteq_config.enable_fast_accelerate = config.enable_fast_accelerate;
return absl::make_unique<NetEqTest>(neteq_config, decoder_factory, codecs,
std::move(text_log), std::move(input),
std::move(output), callbacks);
return std::make_unique<NetEqTest>(neteq_config, decoder_factory, codecs,
std::move(text_log), std::move(input),
std::move(output), callbacks);
}
} // namespace test

4
modules/audio_coding/neteq/tools/rtc_event_log_source.cc
View File

@ -14,10 +14,10 @@
#include <iostream>
#include <limits>
#include <memory>
#include <set>
#include <utility>
#include "absl/memory/memory.h"
#include "logging/rtc_event_log/rtc_event_processor.h"
#include "modules/audio_coding/neteq/tools/packet.h"
#include "rtc_base/checks.h"
@ -96,7 +96,7 @@ bool RtcEventLogSource::Initialize(const ParsedRtcEventLog& parsed_log,
&packet_ssrcs](const webrtc::LoggedRtpPacketIncoming& incoming) {
if (!filter_.test(incoming.rtp.header.payloadType) &&
incoming.log_time_us() < first_log_end_time_us) {
rtp_packets_.emplace_back(absl::make_unique<Packet>(
rtp_packets_.emplace_back(std::make_unique<Packet>(
incoming.rtp.header, incoming.rtp.total_length,
incoming.rtp.total_length - incoming.rtp.header_length,
static_cast<double>(incoming.log_time_ms())));

3
modules/audio_coding/neteq/tools/rtp_file_source.cc
View File

@ -18,7 +18,6 @@
#include <memory>
#include "absl/memory/memory.h"
#include "modules/audio_coding/neteq/tools/packet.h"
#include "rtc_base/checks.h"
#include "test/rtp_file_reader.h"
@ -66,7 +65,7 @@ std::unique_ptr<Packet> RtpFileSource::NextPacket() {
std::unique_ptr<uint8_t[]> packet_memory(new uint8_t[temp_packet.length]);
memcpy(packet_memory.get(), temp_packet.data, temp_packet.length);
RtpUtility::RtpHeaderParser parser(packet_memory.get(), temp_packet.length);
auto packet = absl::make_unique<Packet>(
auto packet = std::make_unique<Packet>(
packet_memory.release(), temp_packet.length,
temp_packet.original_length, temp_packet.time_ms, parser,
&rtp_header_extension_map_);