Use std::make_unique instead of absl::make_unique.
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}
diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index 75ded56..d9a9209 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -24,7 +24,6 @@
"../rtc_base:checks",
"../rtc_base:rtc_base",
"../rtc_base:rtc_base_approved",
- "//third_party/abseil-cpp/absl/memory",
]
}
@@ -107,6 +106,7 @@
"../logging:ice_log",
"../rtc_base",
"../rtc_base:checks",
+ "//third_party/abseil-cpp/absl/memory",
# Needed by pseudo_tcp, which should move to a separate target.
"../rtc_base:safe_minmax",
@@ -119,7 +119,6 @@
"../system_wrappers:field_trial",
"../system_wrappers:metrics",
"//third_party/abseil-cpp/absl/algorithm:container",
- "//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
@@ -182,7 +181,6 @@
"../rtc_base/third_party/sigslot",
"../test:test_support",
"//third_party/abseil-cpp/absl/algorithm:container",
- "//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
]
}
@@ -261,7 +259,6 @@
"../rtc_base:rtc_base_tests_utils",
"../rtc_base/third_party/sigslot",
"//third_party/abseil-cpp/absl/algorithm:container",
- "//third_party/abseil-cpp/absl/memory",
]
}
diff --git a/p2p/base/connection.cc b/p2p/base/connection.cc
index 8b2c8d9..e50890b 100644
--- a/p2p/base/connection.cc
+++ b/p2p/base/connection.cc
@@ -18,7 +18,6 @@
#include <vector>
#include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "p2p/base/port_allocator.h"
#include "rtc_base/checks.h"
@@ -156,45 +155,45 @@
// receiver side. The attribute is retrieved then by iterating and matching
// over all parsed attributes. See StunMessage::GetAttribute.
request->AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_USERNAME, username));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_USERNAME, username));
// connection_ already holds this ping, so subtract one from count.
if (connection_->port()->send_retransmit_count_attribute()) {
- request->AddAttribute(absl::make_unique<StunUInt32Attribute>(
+ request->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_RETRANSMIT_COUNT,
static_cast<uint32_t>(connection_->pings_since_last_response_.size() -
1)));
}
uint32_t network_info = connection_->port()->Network()->id();
network_info = (network_info << 16) | connection_->port()->network_cost();
- request->AddAttribute(absl::make_unique<StunUInt32Attribute>(
+ request->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_NETWORK_INFO, network_info));
if (webrtc::field_trial::IsEnabled(
"WebRTC-PiggybackIceCheckAcknowledgement") &&
connection_->last_ping_id_received()) {
- request->AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ request->AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_LAST_ICE_CHECK_RECEIVED,
connection_->last_ping_id_received().value()));
}
// Adding ICE_CONTROLLED or ICE_CONTROLLING attribute based on the role.
if (connection_->port()->GetIceRole() == ICEROLE_CONTROLLING) {
- request->AddAttribute(absl::make_unique<StunUInt64Attribute>(
+ request->AddAttribute(std::make_unique<StunUInt64Attribute>(
STUN_ATTR_ICE_CONTROLLING, connection_->port()->IceTiebreaker()));
// We should have either USE_CANDIDATE attribute or ICE_NOMINATION
// attribute but not both. That was enforced in p2ptransportchannel.
if (connection_->use_candidate_attr()) {
request->AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
}
if (connection_->nomination() &&
connection_->nomination() != connection_->acked_nomination()) {
- request->AddAttribute(absl::make_unique<StunUInt32Attribute>(
+ request->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_NOMINATION, connection_->nomination()));
}
} else if (connection_->port()->GetIceRole() == ICEROLE_CONTROLLED) {
- request->AddAttribute(absl::make_unique<StunUInt64Attribute>(
+ request->AddAttribute(std::make_unique<StunUInt64Attribute>(
STUN_ATTR_ICE_CONTROLLED, connection_->port()->IceTiebreaker()));
} else {
RTC_NOTREACHED();
@@ -213,7 +212,7 @@
uint32_t prflx_priority =
type_preference << 24 |
(connection_->local_candidate().priority() & 0x00FFFFFF);
- request->AddAttribute(absl::make_unique<StunUInt32Attribute>(
+ request->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_PRIORITY, prflx_priority));
// Adding Message Integrity attribute.
diff --git a/p2p/base/dtls_transport.cc b/p2p/base/dtls_transport.cc
index ce78361..01cd9f7 100644
--- a/p2p/base/dtls_transport.cc
+++ b/p2p/base/dtls_transport.cc
@@ -14,7 +14,6 @@
#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_dtls_transport_state.h"
#include "logging/rtc_event_log/events/rtc_event_dtls_writable_state.h"
@@ -752,7 +751,7 @@
}
if (event_log_) {
event_log_->Log(
- absl::make_unique<webrtc::RtcEventDtlsWritableState>(writable));
+ std::make_unique<webrtc::RtcEventDtlsWritableState>(writable));
}
RTC_LOG(LS_VERBOSE) << ToString() << ": set_writable to: " << writable;
writable_ = writable;
@@ -767,7 +766,7 @@
return;
}
if (event_log_) {
- event_log_->Log(absl::make_unique<webrtc::RtcEventDtlsTransportState>(
+ event_log_->Log(std::make_unique<webrtc::RtcEventDtlsTransportState>(
ConvertDtlsTransportState(state)));
}
RTC_LOG(LS_VERBOSE) << ToString() << ": set_dtls_state from:" << dtls_state_
diff --git a/p2p/base/dtls_transport_unittest.cc b/p2p/base/dtls_transport_unittest.cc
index 1da486c..287264d 100644
--- a/p2p/base/dtls_transport_unittest.cc
+++ b/p2p/base/dtls_transport_unittest.cc
@@ -15,7 +15,6 @@
#include <set>
#include <utility>
-#include "absl/memory/memory.h"
#include "p2p/base/fake_ice_transport.h"
#include "p2p/base/packet_transport_internal.h"
#include "rtc_base/checks.h"
@@ -88,9 +87,9 @@
fake_ice_transport_->SignalReadPacket.connect(
this, &DtlsTestClient::OnFakeIceTransportReadPacket);
- dtls_transport_ = absl::make_unique<DtlsTransport>(
- fake_ice_transport_.get(), webrtc::CryptoOptions(),
- /*event_log=*/nullptr);
+ dtls_transport_ = std::make_unique<DtlsTransport>(fake_ice_transport_.get(),
+ webrtc::CryptoOptions(),
+ /*event_log=*/nullptr);
dtls_transport_->SetSslMaxProtocolVersion(ssl_max_version_);
// Note: Certificate may be null here if testing passthrough.
dtls_transport_->SetLocalCertificate(certificate_);
diff --git a/p2p/base/fake_dtls_transport.h b/p2p/base/fake_dtls_transport.h
index 841e196..c26cae9 100644
--- a/p2p/base/fake_dtls_transport.h
+++ b/p2p/base/fake_dtls_transport.h
@@ -16,7 +16,6 @@
#include <utility>
#include <vector>
-#include "absl/memory/memory.h"
#include "api/crypto/crypto_options.h"
#include "p2p/base/dtls_transport_internal.h"
#include "p2p/base/fake_ice_transport.h"
@@ -57,8 +56,8 @@
// If this constructor is called, a new fake ICE transport will be created,
// and this FakeDtlsTransport will take the ownership.
explicit FakeDtlsTransport(const std::string& name, int component)
- : FakeDtlsTransport(
- absl::make_unique<FakeIceTransport>(name, component)) {}
+ : FakeDtlsTransport(std::make_unique<FakeIceTransport>(name, component)) {
+ }
~FakeDtlsTransport() override {
if (dest_ && dest_->dest_ == this) {
@@ -195,7 +194,7 @@
if (!remote_cert_) {
return nullptr;
}
- return absl::make_unique<rtc::SSLCertChain>(remote_cert_->Clone());
+ return std::make_unique<rtc::SSLCertChain>(remote_cert_->Clone());
}
bool ExportKeyingMaterial(const std::string& label,
const uint8_t* context,
diff --git a/p2p/base/p2p_transport_channel.cc b/p2p/base/p2p_transport_channel.cc
index 72e36e1..c6f2f20 100644
--- a/p2p/base/p2p_transport_channel.cc
+++ b/p2p/base/p2p_transport_channel.cc
@@ -11,11 +11,11 @@
#include "p2p/base/p2p_transport_channel.h"
#include <iterator>
+#include <memory>
#include <set>
#include <utility>
#include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
#include "api/candidate.h"
#include "logging/rtc_event_log/ice_logger.h"
#include "p2p/base/candidate_pair_interface.h"
@@ -153,7 +153,7 @@
config_.regather_all_networks_interval_range,
config_.regather_on_failed_networks_interval_or_default());
regathering_controller_ =
- absl::make_unique<webrtc::BasicRegatheringController>(
+ std::make_unique<webrtc::BasicRegatheringController>(
regathering_config, this, network_thread_);
// We populate the change in the candidate filter to the session taken by
// the transport.
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index dd48979..46ce535 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -14,7 +14,6 @@
#include <memory>
#include <utility>
-#include "absl/memory/memory.h"
#include "p2p/base/connection.h"
#include "p2p/base/fake_port_allocator.h"
#include "p2p/base/ice_transport_internal.h"
@@ -3314,17 +3313,17 @@
const absl::optional<std::string>& piggyback_ping_id) {
IceMessage msg;
msg.SetType(STUN_BINDING_REQUEST);
- msg.AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ msg.AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME,
conn->local_candidate().username() + ":" + remote_ufrag));
msg.AddAttribute(
- absl::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY, priority));
+ std::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY, priority));
if (nomination != 0) {
- msg.AddAttribute(absl::make_unique<StunUInt32Attribute>(
+ msg.AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_NOMINATION, nomination));
}
if (piggyback_ping_id) {
- msg.AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ msg.AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_LAST_ICE_CHECK_RECEIVED, piggyback_ping_id.value()));
}
msg.SetTransactionID(rtc::CreateRandomString(kStunTransactionIdLength));
@@ -3558,11 +3557,11 @@
// candidate pair while we still don't have remote ICE parameters.
IceMessage request;
request.SetType(STUN_BINDING_REQUEST);
- request.AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ request.AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME, kIceUfrag[1]));
uint32_t prflx_priority = ICE_TYPE_PREFERENCE_PRFLX << 24;
- request.AddAttribute(absl::make_unique<StunUInt32Attribute>(
- STUN_ATTR_PRIORITY, prflx_priority));
+ request.AddAttribute(std::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY,
+ prflx_priority));
Port* port = GetPort(&ch);
ASSERT_NE(nullptr, port);
port->SignalUnknownAddress(port, rtc::SocketAddress("1.1.1.1", 1), PROTO_UDP,
@@ -3727,11 +3726,11 @@
// Create a minimal STUN message with prflx priority.
IceMessage request;
request.SetType(STUN_BINDING_REQUEST);
- request.AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ request.AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME, kIceUfrag[1]));
uint32_t prflx_priority = ICE_TYPE_PREFERENCE_PRFLX << 24;
- request.AddAttribute(absl::make_unique<StunUInt32Attribute>(
- STUN_ATTR_PRIORITY, prflx_priority));
+ request.AddAttribute(std::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY,
+ prflx_priority));
EXPECT_NE(prflx_priority, remote_priority);
Port* port = GetPort(&ch);
@@ -3878,11 +3877,11 @@
// A minimal STUN message with prflx priority.
IceMessage request;
request.SetType(STUN_BINDING_REQUEST);
- request.AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ request.AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME, kIceUfrag[1]));
uint32_t prflx_priority = ICE_TYPE_PREFERENCE_PRFLX << 24;
- request.AddAttribute(absl::make_unique<StunUInt32Attribute>(
- STUN_ATTR_PRIORITY, prflx_priority));
+ request.AddAttribute(std::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY,
+ prflx_priority));
TestUDPPort* port = static_cast<TestUDPPort*>(GetPort(&ch));
port->SignalUnknownAddress(port, rtc::SocketAddress("1.1.1.1", 1), PROTO_UDP,
&request, kIceUfrag[1], false);
@@ -3921,7 +3920,7 @@
// However if the request contains use_candidate attribute, it will be
// selected as the selected connection.
request.AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
port->SignalUnknownAddress(port, rtc::SocketAddress("4.4.4.4", 4), PROTO_UDP,
&request, kIceUfrag[1], false);
Connection* conn4 = WaitForConnectionTo(&ch, "4.4.4.4", 4);
@@ -3976,13 +3975,13 @@
// nominate the selected connection.
IceMessage request;
request.SetType(STUN_BINDING_REQUEST);
- request.AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ request.AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME, kIceUfrag[1]));
uint32_t prflx_priority = ICE_TYPE_PREFERENCE_PRFLX << 24;
- request.AddAttribute(absl::make_unique<StunUInt32Attribute>(
- STUN_ATTR_PRIORITY, prflx_priority));
+ request.AddAttribute(std::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY,
+ prflx_priority));
request.AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
Port* port = GetPort(&ch);
port->SignalUnknownAddress(port, rtc::SocketAddress("3.3.3.3", 3), PROTO_UDP,
&request, kIceUfrag[1], false);
@@ -4785,7 +4784,7 @@
// ICE parameter will be set up when creating the channels.
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
GetEndpoint(0)->network_manager_.set_mdns_responder(
- absl::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
+ std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
CreateChannels();
// Pause sending candidates from both endpoints until we find out what port
@@ -4857,7 +4856,7 @@
// ICE parameter will be set up when creating the channels.
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
GetEndpoint(0)->network_manager_.set_mdns_responder(
- absl::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
+ std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
CreateChannels();
// Pause sending candidates from both endpoints until we find out what port
@@ -4925,7 +4924,7 @@
// ICE parameter will be set up when creating the channels.
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
GetEndpoint(0)->network_manager_.set_mdns_responder(
- absl::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
+ std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
CreateChannels();
// Pause sending candidates from both endpoints until we find out what port
@@ -4982,7 +4981,7 @@
// ICE parameter will be set up when creating the channels.
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
GetEndpoint(0)->network_manager_.set_mdns_responder(
- absl::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
+ std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
CreateChannels();
// Pause sending candidates from both endpoints until we find out what port
@@ -5163,7 +5162,7 @@
// ICE parameter will be set up when creating the channels.
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
GetEndpoint(0)->network_manager_.set_mdns_responder(
- absl::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
+ std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
GetEndpoint(1)->async_resolver_factory_ = &mock_async_resolver_factory;
CreateChannels();
// Pause sending candidates from both endpoints until we find out what port
@@ -5225,7 +5224,7 @@
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
// Use a mock mDNS responder, which does not complete the name registration by
// ignoring the completion callback.
- auto mock_mdns_responder = absl::make_unique<MockMdnsResponder>();
+ auto mock_mdns_responder = std::make_unique<MockMdnsResponder>();
EXPECT_CALL(*mock_mdns_responder, CreateNameForAddress(_, _))
.Times(1)
.WillOnce(Return());
diff --git a/p2p/base/port.cc b/p2p/base/port.cc
index 3582da6..742c15d 100644
--- a/p2p/base/port.cc
+++ b/p2p/base/port.cc
@@ -13,11 +13,11 @@
#include <math.h>
#include <algorithm>
+#include <memory>
#include <utility>
#include <vector>
#include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "p2p/base/connection.h"
#include "p2p/base/port_allocator.h"
@@ -683,7 +683,7 @@
if (retransmit_attr) {
// Inherit the incoming retransmit value in the response so the other side
// can see our view of lost pings.
- response.AddAttribute(absl::make_unique<StunUInt32Attribute>(
+ response.AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_RETRANSMIT_COUNT, retransmit_attr->value()));
if (retransmit_attr->value() > CONNECTION_WRITE_CONNECT_FAILURES) {
@@ -694,7 +694,7 @@
}
}
- response.AddAttribute(absl::make_unique<StunXorAddressAttribute>(
+ response.AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_MAPPED_ADDRESS, addr));
response.AddMessageIntegrity(password_);
response.AddFingerprint();
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index a801f53..3556e31 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -19,7 +19,6 @@
#include <utility>
#include <vector>
-#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "api/candidate.h"
#include "api/packet_socket_factory.h"
@@ -125,7 +124,7 @@
}
std::unique_ptr<IceMessage> CopyStunMessage(const IceMessage& src) {
- auto dst = absl::make_unique<IceMessage>();
+ auto dst = std::make_unique<IceMessage>();
ByteBufferWriter buf;
src.Write(&buf);
ByteBufferReader read_buf(buf);
@@ -222,8 +221,8 @@
const rtc::PacketOptions& options,
bool payload) {
if (!payload) {
- auto msg = absl::make_unique<IceMessage>();
- auto buf = absl::make_unique<rtc::BufferT<uint8_t>>(
+ auto msg = std::make_unique<IceMessage>();
+ auto buf = std::make_unique<rtc::BufferT<uint8_t>>(
static_cast<const char*>(data), size);
ByteBufferReader read_buf(*buf);
if (!msg->Read(&read_buf)) {
@@ -588,8 +587,8 @@
}
std::unique_ptr<rtc::NATServer> CreateNatServer(const SocketAddress& addr,
rtc::NATType type) {
- return absl::make_unique<rtc::NATServer>(type, ss_.get(), addr, addr,
- ss_.get(), addr);
+ return std::make_unique<rtc::NATServer>(type, ss_.get(), addr, addr,
+ ss_.get(), addr);
}
static const char* StunName(NATType type) {
switch (type) {
@@ -783,7 +782,7 @@
}
std::unique_ptr<IceMessage> CreateStunMessage(int type) {
- auto msg = absl::make_unique<IceMessage>();
+ auto msg = std::make_unique<IceMessage>();
msg->SetType(type);
msg->SetTransactionID("TESTTESTTEST");
return msg;
@@ -792,16 +791,16 @@
int type,
const std::string& username) {
std::unique_ptr<IceMessage> msg = CreateStunMessage(type);
- msg->AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ msg->AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME, username));
return msg;
}
std::unique_ptr<TestPort> CreateTestPort(const rtc::SocketAddress& addr,
const std::string& username,
const std::string& password) {
- auto port = absl::make_unique<TestPort>(&main_, "test", &socket_factory_,
- MakeNetwork(addr), 0, 0, username,
- password);
+ auto port =
+ std::make_unique<TestPort>(&main_, "test", &socket_factory_,
+ MakeNetwork(addr), 0, 0, username, password);
port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
return port;
}
@@ -819,8 +818,8 @@
std::unique_ptr<TestPort> CreateTestPort(rtc::Network* network,
const std::string& username,
const std::string& password) {
- auto port = absl::make_unique<TestPort>(&main_, "test", &socket_factory_,
- network, 0, 0, username, password);
+ auto port = std::make_unique<TestPort>(&main_, "test", &socket_factory_,
+ network, 0, 0, username, password);
port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
return port;
}
@@ -1440,17 +1439,17 @@
CreateStunMessage(STUN_BINDING_REQUEST));
const StunByteStringAttribute* username_attr =
msg->GetByteString(STUN_ATTR_USERNAME);
- modified_req->AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ modified_req->AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME, username_attr->GetString()));
// To make sure we receive error response, adding tiebreaker less than
// what's present in request.
- modified_req->AddAttribute(absl::make_unique<StunUInt64Attribute>(
+ modified_req->AddAttribute(std::make_unique<StunUInt64Attribute>(
STUN_ATTR_ICE_CONTROLLING, kTiebreaker1 - 1));
modified_req->AddMessageIntegrity("lpass");
modified_req->AddFingerprint();
lport->Reset();
- auto buf = absl::make_unique<ByteBufferWriter>();
+ auto buf = std::make_unique<ByteBufferWriter>();
WriteStunMessage(*modified_req, buf.get());
conn1->OnReadPacket(buf->Data(), buf->Length(), /* packet_time_us */ -1);
ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
@@ -2052,7 +2051,7 @@
auto port = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
std::unique_ptr<IceMessage> in_msg, out_msg;
- auto buf = absl::make_unique<ByteBufferWriter>();
+ auto buf = std::make_unique<ByteBufferWriter>();
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@@ -2069,7 +2068,7 @@
// BINDING-RESPONSE without username, with MESSAGE-INTEGRITY and FINGERPRINT.
in_msg = CreateStunMessage(STUN_BINDING_RESPONSE);
- in_msg->AddAttribute(absl::make_unique<StunXorAddressAttribute>(
+ in_msg->AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2));
in_msg->AddMessageIntegrity("rpass");
in_msg->AddFingerprint();
@@ -2081,7 +2080,7 @@
// BINDING-ERROR-RESPONSE without username, with error, M-I, and FINGERPRINT.
in_msg = CreateStunMessage(STUN_BINDING_ERROR_RESPONSE);
- in_msg->AddAttribute(absl::make_unique<StunErrorCodeAttribute>(
+ in_msg->AddAttribute(std::make_unique<StunErrorCodeAttribute>(
STUN_ATTR_ERROR_CODE, STUN_ERROR_SERVER_ERROR,
STUN_ERROR_REASON_SERVER_ERROR));
in_msg->AddFingerprint();
@@ -2101,7 +2100,7 @@
auto port = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
std::unique_ptr<IceMessage> in_msg, out_msg;
- auto buf = absl::make_unique<ByteBufferWriter>();
+ auto buf = std::make_unique<ByteBufferWriter>();
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@@ -2167,7 +2166,7 @@
auto port = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
std::unique_ptr<IceMessage> in_msg, out_msg;
- auto buf = absl::make_unique<ByteBufferWriter>();
+ auto buf = std::make_unique<ByteBufferWriter>();
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@@ -2205,7 +2204,7 @@
auto port = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
std::unique_ptr<IceMessage> in_msg, out_msg;
- auto buf = absl::make_unique<ByteBufferWriter>();
+ auto buf = std::make_unique<ByteBufferWriter>();
rtc::SocketAddress addr(kLocalAddr1);
std::string username;
@@ -2228,7 +2227,7 @@
// Valid BINDING-RESPONSE, except no FINGERPRINT.
in_msg = CreateStunMessage(STUN_BINDING_RESPONSE);
- in_msg->AddAttribute(absl::make_unique<StunXorAddressAttribute>(
+ in_msg->AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_MAPPED_ADDRESS, kLocalAddr2));
in_msg->AddMessageIntegrity("rpass");
WriteStunMessage(*in_msg, buf.get());
@@ -2246,7 +2245,7 @@
// Valid BINDING-ERROR-RESPONSE, except no FINGERPRINT.
in_msg = CreateStunMessage(STUN_BINDING_ERROR_RESPONSE);
- in_msg->AddAttribute(absl::make_unique<StunErrorCodeAttribute>(
+ in_msg->AddAttribute(std::make_unique<StunErrorCodeAttribute>(
STUN_ATTR_ERROR_CODE, STUN_ERROR_SERVER_ERROR,
STUN_ERROR_REASON_SERVER_ERROR));
in_msg->AddMessageIntegrity("rpass");
diff --git a/p2p/base/stun.cc b/p2p/base/stun.cc
index f40395b..8809756 100644
--- a/p2p/base/stun.cc
+++ b/p2p/base/stun.cc
@@ -16,7 +16,6 @@
#include <memory>
#include <utility>
-#include "absl/memory/memory.h"
#include "rtc_base/byte_order.h"
#include "rtc_base/checks.h"
#include "rtc_base/crc32.h"
@@ -265,7 +264,7 @@
bool StunMessage::AddMessageIntegrity(const char* key, size_t keylen) {
// Add the attribute with a dummy value. Since this is a known attribute, it
// can't fail.
- auto msg_integrity_attr_ptr = absl::make_unique<StunByteStringAttribute>(
+ auto msg_integrity_attr_ptr = std::make_unique<StunByteStringAttribute>(
STUN_ATTR_MESSAGE_INTEGRITY, std::string(kStunMessageIntegritySize, '0'));
auto* msg_integrity_attr = msg_integrity_attr_ptr.get();
AddAttribute(std::move(msg_integrity_attr_ptr));
@@ -326,7 +325,7 @@
// Add the attribute with a dummy value. Since this is a known attribute,
// it can't fail.
auto fingerprint_attr_ptr =
- absl::make_unique<StunUInt32Attribute>(STUN_ATTR_FINGERPRINT, 0);
+ std::make_unique<StunUInt32Attribute>(STUN_ATTR_FINGERPRINT, 0);
auto* fingerprint_attr = fingerprint_attr_ptr.get();
AddAttribute(std::move(fingerprint_attr_ptr));
@@ -546,38 +545,38 @@
std::unique_ptr<StunAddressAttribute> StunAttribute::CreateAddress(
uint16_t type) {
- return absl::make_unique<StunAddressAttribute>(type, 0);
+ return std::make_unique<StunAddressAttribute>(type, 0);
}
std::unique_ptr<StunXorAddressAttribute> StunAttribute::CreateXorAddress(
uint16_t type) {
- return absl::make_unique<StunXorAddressAttribute>(type, 0, nullptr);
+ return std::make_unique<StunXorAddressAttribute>(type, 0, nullptr);
}
std::unique_ptr<StunUInt64Attribute> StunAttribute::CreateUInt64(
uint16_t type) {
- return absl::make_unique<StunUInt64Attribute>(type);
+ return std::make_unique<StunUInt64Attribute>(type);
}
std::unique_ptr<StunUInt32Attribute> StunAttribute::CreateUInt32(
uint16_t type) {
- return absl::make_unique<StunUInt32Attribute>(type);
+ return std::make_unique<StunUInt32Attribute>(type);
}
std::unique_ptr<StunByteStringAttribute> StunAttribute::CreateByteString(
uint16_t type) {
- return absl::make_unique<StunByteStringAttribute>(type, 0);
+ return std::make_unique<StunByteStringAttribute>(type, 0);
}
std::unique_ptr<StunErrorCodeAttribute> StunAttribute::CreateErrorCode() {
- return absl::make_unique<StunErrorCodeAttribute>(
+ return std::make_unique<StunErrorCodeAttribute>(
STUN_ATTR_ERROR_CODE, StunErrorCodeAttribute::MIN_SIZE);
}
std::unique_ptr<StunUInt16ListAttribute>
StunAttribute::CreateUnknownAttributes() {
- return absl::make_unique<StunUInt16ListAttribute>(
- STUN_ATTR_UNKNOWN_ATTRIBUTES, 0);
+ return std::make_unique<StunUInt16ListAttribute>(STUN_ATTR_UNKNOWN_ATTRIBUTES,
+ 0);
}
StunAddressAttribute::StunAddressAttribute(uint16_t type,
diff --git a/p2p/base/stun_request.cc b/p2p/base/stun_request.cc
index 44aa483..964b80f 100644
--- a/p2p/base/stun_request.cc
+++ b/p2p/base/stun_request.cc
@@ -14,7 +14,6 @@
#include <memory>
#include <vector>
-#include "absl/memory/memory.h"
#include "rtc_base/checks.h"
#include "rtc_base/helpers.h"
#include "rtc_base/logging.h"
@@ -204,8 +203,8 @@
void StunRequest::Construct() {
if (msg_->type() == 0) {
if (!origin_.empty()) {
- msg_->AddAttribute(absl::make_unique<StunByteStringAttribute>(
- STUN_ATTR_ORIGIN, origin_));
+ msg_->AddAttribute(
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_ORIGIN, origin_));
}
Prepare(msg_);
RTC_DCHECK(msg_->type() != 0);
diff --git a/p2p/base/stun_unittest.cc b/p2p/base/stun_unittest.cc
index b7d5f50..69f6f2d 100644
--- a/p2p/base/stun_unittest.cc
+++ b/p2p/base/stun_unittest.cc
@@ -12,10 +12,10 @@
#include <string.h>
+#include <memory>
#include <string>
#include <utility>
-#include "absl/memory/memory.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/byte_buffer.h"
#include "rtc_base/byte_order.h"
@@ -1118,7 +1118,7 @@
std::string(reinterpret_cast<const char*>(kTestTransactionId1),
kStunTransactionIdLength));
auto origin =
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_ORIGIN, kTestOrigin);
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_ORIGIN, kTestOrigin);
msg.AddAttribute(std::move(origin));
rtc::ByteBufferWriter out;
diff --git a/p2p/base/test_turn_customizer.h b/p2p/base/test_turn_customizer.h
index ae8864a..415b13f 100644
--- a/p2p/base/test_turn_customizer.h
+++ b/p2p/base/test_turn_customizer.h
@@ -11,7 +11,8 @@
#ifndef P2P_BASE_TEST_TURN_CUSTOMIZER_H_
#define P2P_BASE_TEST_TURN_CUSTOMIZER_H_
-#include "absl/memory/memory.h"
+#include <memory>
+
#include "api/turn_customizer.h"
#include "rtc_base/gunit.h"
@@ -33,7 +34,7 @@
ASSERT_NE(0, message->type());
if (add_counter_) {
- message->AddAttribute(absl::make_unique<cricket::StunUInt32Attribute>(
+ message->AddAttribute(std::make_unique<cricket::StunUInt32Attribute>(
STUN_ATTR_COUNTER, modify_cnt_));
}
return;
diff --git a/p2p/base/transport_description_factory.cc b/p2p/base/transport_description_factory.cc
index 518a2ac..f417c5a 100644
--- a/p2p/base/transport_description_factory.cc
+++ b/p2p/base/transport_description_factory.cc
@@ -15,7 +15,6 @@
#include <memory>
#include <string>
-#include "absl/memory/memory.h"
#include "p2p/base/transport_description.h"
#include "rtc_base/logging.h"
#include "rtc_base/ssl_fingerprint.h"
@@ -31,7 +30,7 @@
const TransportOptions& options,
const TransportDescription* current_description,
IceCredentialsIterator* ice_credentials) const {
- auto desc = absl::make_unique<TransportDescription>();
+ auto desc = std::make_unique<TransportDescription>();
// Generate the ICE credentials if we don't already have them.
if (!current_description || options.ice_restart) {
@@ -74,7 +73,7 @@
return NULL;
}
- auto desc = absl::make_unique<TransportDescription>();
+ auto desc = std::make_unique<TransportDescription>();
// Generate the ICE credentials if we don't already have them or ice is
// being restarted.
if (!current_description || options.ice_restart) {
diff --git a/p2p/base/turn_port.cc b/p2p/base/turn_port.cc
index e86bf09..68535b7 100644
--- a/p2p/base/turn_port.cc
+++ b/p2p/base/turn_port.cc
@@ -11,11 +11,11 @@
#include "p2p/base/turn_port.h"
#include <functional>
+#include <memory>
#include <utility>
#include <vector>
#include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "p2p/base/connection.h"
#include "p2p/base/stun.h"
@@ -1107,12 +1107,12 @@
void TurnPort::AddRequestAuthInfo(StunMessage* msg) {
// If we've gotten the necessary data from the server, add it to our request.
RTC_DCHECK(!hash_.empty());
- msg->AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ msg->AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_USERNAME, credentials_.username));
msg->AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_REALM, realm_));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_REALM, realm_));
msg->AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_NONCE, nonce_));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_NONCE, nonce_));
const bool success = msg->AddMessageIntegrity(hash());
RTC_DCHECK(success);
}
@@ -1325,7 +1325,7 @@
void TurnPort::MaybeAddTurnLoggingId(StunMessage* msg) {
if (!turn_logging_id_.empty()) {
- msg->AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ msg->AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_TURN_LOGGING_ID, turn_logging_id_));
}
}
@@ -1527,7 +1527,7 @@
request->SetType(TURN_REFRESH_REQUEST);
if (lifetime_ > -1) {
request->AddAttribute(
- absl::make_unique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_));
+ std::make_unique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_));
}
port_->AddRequestAuthInfo(request);
@@ -1612,10 +1612,10 @@
void TurnCreatePermissionRequest::Prepare(StunMessage* request) {
// Create the request as indicated in RFC5766, Section 9.1.
request->SetType(TURN_CREATE_PERMISSION_REQUEST);
- request->AddAttribute(absl::make_unique<StunXorAddressAttribute>(
+ request->AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
if (webrtc::field_trial::IsEnabled("WebRTC-TurnAddMultiMapping")) {
- request->AddAttribute(absl::make_unique<cricket::StunByteStringAttribute>(
+ request->AddAttribute(std::make_unique<cricket::StunByteStringAttribute>(
STUN_ATTR_MULTI_MAPPING, remote_ufrag_));
}
port_->AddRequestAuthInfo(request);
@@ -1684,9 +1684,9 @@
void TurnChannelBindRequest::Prepare(StunMessage* request) {
// Create the request as indicated in RFC5766, Section 11.1.
request->SetType(TURN_CHANNEL_BIND_REQUEST);
- request->AddAttribute(absl::make_unique<StunUInt32Attribute>(
+ request->AddAttribute(std::make_unique<StunUInt32Attribute>(
STUN_ATTR_CHANNEL_NUMBER, channel_id_ << 16));
- request->AddAttribute(absl::make_unique<StunXorAddressAttribute>(
+ request->AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
port_->AddRequestAuthInfo(request);
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(request);
@@ -1780,10 +1780,10 @@
TurnMessage msg;
msg.SetType(TURN_SEND_INDICATION);
msg.SetTransactionID(rtc::CreateRandomString(kStunTransactionIdLength));
- msg.AddAttribute(absl::make_unique<StunXorAddressAttribute>(
+ msg.AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_PEER_ADDRESS, ext_addr_));
msg.AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_DATA, data, size));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_DATA, data, size));
port_->TurnCustomizerMaybeModifyOutgoingStunMessage(&msg);
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index 73dadb6..f9e0205 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -16,7 +16,6 @@
#include <utility>
#include <vector>
-#include "absl/memory/memory.h"
#include "absl/types/optional.h"
#include "api/units/time_delta.h"
#include "p2p/base/basic_packet_socket_factory.h"
@@ -838,7 +837,7 @@
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
turn_port_->SetTurnLoggingId("KESO");
turn_server_.server()->SetStunMessageObserver(
- absl::make_unique<TurnLoggingIdValidator>("KESO"));
+ std::make_unique<TurnLoggingIdValidator>("KESO"));
turn_port_->PrepareAddress();
EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
ASSERT_EQ(1U, turn_port_->Candidates().size());
@@ -850,7 +849,7 @@
TEST_F(TurnPortTest, TestTurnAllocateWithoutLoggingId) {
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
turn_server_.server()->SetStunMessageObserver(
- absl::make_unique<TurnLoggingIdValidator>(nullptr));
+ std::make_unique<TurnLoggingIdValidator>(nullptr));
turn_port_->PrepareAddress();
EXPECT_TRUE_SIMULATED_WAIT(turn_ready_, kSimulatedRtt * 2, fake_clock_);
ASSERT_EQ(1U, turn_port_->Candidates().size());
diff --git a/p2p/base/turn_server.cc b/p2p/base/turn_server.cc
index 2892d75..3869213 100644
--- a/p2p/base/turn_server.cc
+++ b/p2p/base/turn_server.cc
@@ -10,11 +10,11 @@
#include "p2p/base/turn_server.h"
+#include <memory>
#include <tuple> // for std::tie
#include <utility>
#include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
#include "api/packet_socket_factory.h"
#include "p2p/base/async_stun_tcp_socket.h"
#include "p2p/base/stun.h"
@@ -116,7 +116,7 @@
return false;
resp->SetType(resp_type);
resp->SetTransactionID(req->transaction_id());
- resp->AddAttribute(absl::make_unique<cricket::StunErrorCodeAttribute>(
+ resp->AddAttribute(std::make_unique<cricket::StunErrorCodeAttribute>(
STUN_ATTR_ERROR_CODE, code, reason));
return true;
}
@@ -375,7 +375,7 @@
InitResponse(req, &response);
// Tell the user the address that we received their request from.
- auto mapped_addr_attr = absl::make_unique<StunXorAddressAttribute>(
+ auto mapped_addr_attr = std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_MAPPED_ADDRESS, conn->src());
response.AddAttribute(std::move(mapped_addr_attr));
@@ -503,10 +503,10 @@
timestamp = ts_for_next_nonce_;
ts_for_next_nonce_ = 0;
}
- resp.AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ resp.AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_NONCE, GenerateNonce(timestamp)));
resp.AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_REALM, realm_));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_REALM, realm_));
SendStun(conn, &resp);
}
@@ -518,8 +518,8 @@
TurnMessage resp;
InitErrorResponse(msg, STUN_ERROR_TRY_ALTERNATE,
STUN_ERROR_REASON_TRY_ALTERNATE_SERVER, &resp);
- resp.AddAttribute(absl::make_unique<StunAddressAttribute>(
- STUN_ATTR_ALTERNATE_SERVER, addr));
+ resp.AddAttribute(
+ std::make_unique<StunAddressAttribute>(STUN_ATTR_ALTERNATE_SERVER, addr));
SendStun(conn, &resp);
}
@@ -528,7 +528,7 @@
rtc::ByteBufferWriter buf;
// Add a SOFTWARE attribute if one is set.
if (!software_.empty()) {
- msg->AddAttribute(absl::make_unique<StunByteStringAttribute>(
+ msg->AddAttribute(std::make_unique<StunByteStringAttribute>(
STUN_ATTR_SOFTWARE, software_));
}
msg->Write(&buf);
@@ -691,12 +691,12 @@
TurnMessage response;
InitResponse(msg, &response);
- auto mapped_addr_attr = absl::make_unique<StunXorAddressAttribute>(
+ auto mapped_addr_attr = std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_MAPPED_ADDRESS, conn_.src());
- auto relayed_addr_attr = absl::make_unique<StunXorAddressAttribute>(
+ auto relayed_addr_attr = std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_RELAYED_ADDRESS, external_socket_->GetLocalAddress());
auto lifetime_attr =
- absl::make_unique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_secs);
+ std::make_unique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_secs);
response.AddAttribute(std::move(mapped_addr_attr));
response.AddAttribute(std::move(relayed_addr_attr));
response.AddAttribute(std::move(lifetime_attr));
@@ -721,7 +721,7 @@
InitResponse(msg, &response);
auto lifetime_attr =
- absl::make_unique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_secs);
+ std::make_unique<StunUInt32Attribute>(STUN_ATTR_LIFETIME, lifetime_secs);
response.AddAttribute(std::move(lifetime_attr));
SendResponse(&response);
@@ -862,10 +862,10 @@
TurnMessage msg;
msg.SetType(TURN_DATA_INDICATION);
msg.SetTransactionID(rtc::CreateRandomString(kStunTransactionIdLength));
- msg.AddAttribute(absl::make_unique<StunXorAddressAttribute>(
+ msg.AddAttribute(std::make_unique<StunXorAddressAttribute>(
STUN_ATTR_XOR_PEER_ADDRESS, addr));
msg.AddAttribute(
- absl::make_unique<StunByteStringAttribute>(STUN_ATTR_DATA, data, size));
+ std::make_unique<StunByteStringAttribute>(STUN_ATTR_DATA, data, size));
server_->SendStun(&conn_, &msg);
} else {
RTC_LOG(LS_WARNING)
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index 86544c8..4b7c084 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -14,7 +14,6 @@
#include <ostream> // no-presubmit-check TODO(webrtc:8982)
#include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
#include "p2p/base/basic_packet_socket_factory.h"
#include "p2p/base/p2p_constants.h"
#include "p2p/base/stun_port.h"
@@ -2399,7 +2398,7 @@
ASSERT_EQ(&network_manager_, allocator().network_manager());
network_manager_.set_mdns_responder(
- absl::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
+ std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();