Switch QuicMakeUnique to std::make_unique, part 1: //third_party/quic
gfe-relnote: n/a (no functional change)
PiperOrigin-RevId: 267662077
Change-Id: Ic63023042eafb77aa80d88749845f841b3078c57
diff --git a/quic/qbone/bonnet/tun_device_packet_exchanger.cc b/quic/qbone/bonnet/tun_device_packet_exchanger.cc
index 1d246a2..94aeba1 100644
--- a/quic/qbone/bonnet/tun_device_packet_exchanger.cc
+++ b/quic/qbone/bonnet/tun_device_packet_exchanger.cc
@@ -14,7 +14,8 @@
size_t mtu,
KernelInterface* kernel,
QbonePacketExchanger::Visitor* visitor,
- size_t max_pending_packets, StatsInterface* stats)
+ size_t max_pending_packets,
+ StatsInterface* stats)
: QbonePacketExchanger(visitor, max_pending_packets),
fd_(fd),
mtu_(mtu),
@@ -59,7 +60,7 @@
}
// Reading on a TUN device returns a packet at a time. If the packet is longer
// than the buffer, it's truncated.
- auto read_buffer = QuicMakeUnique<char[]>(mtu_);
+ auto read_buffer = std::make_unique<char[]>(mtu_);
int result = kernel_->read(fd_, read_buffer.get(), mtu_);
// Note that 0 means end of file, but we're talking about a TUN device - there
// is no end of file. Therefore 0 also indicates error.
@@ -72,7 +73,7 @@
return nullptr;
}
stats_->OnPacketRead();
- return QuicMakeUnique<QuicData>(read_buffer.release(), result, true);
+ return std::make_unique<QuicData>(read_buffer.release(), result, true);
}
int TunDevicePacketExchanger::file_descriptor() const {
diff --git a/quic/qbone/platform/netlink.cc b/quic/qbone/platform/netlink.cc
index 1a4270e..6553417 100644
--- a/quic/qbone/platform/netlink.cc
+++ b/quic/qbone/platform/netlink.cc
@@ -27,7 +27,7 @@
void Netlink::ResetRecvBuf(size_t size) {
if (size != 0) {
- recvbuf_ = QuicMakeUnique<char[]>(size);
+ recvbuf_ = std::make_unique<char[]>(size);
} else {
recvbuf_ = nullptr;
}
diff --git a/quic/qbone/platform/netlink_test.cc b/quic/qbone/platform/netlink_test.cc
index 024e0fb..144e5d5 100644
--- a/quic/qbone/platform/netlink_test.cc
+++ b/quic/qbone/platform/netlink_test.cc
@@ -243,7 +243,7 @@
}
TEST_F(NetlinkTest, GetLinkInfoWorks) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
uint8_t hwaddr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
uint8_t bcaddr[] = {'c', 'b', 'a', 'f', 'e', 'd'};
@@ -283,7 +283,7 @@
}
TEST_F(NetlinkTest, GetAddressesWorks) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
QuicUnorderedSet<std::string> addresses = {QuicIpAddress::Any4().ToString(),
QuicIpAddress::Any6().ToString()};
@@ -350,7 +350,7 @@
}
TEST_F(NetlinkTest, ChangeLocalAddressAdd) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
QuicIpAddress ip = QuicIpAddress::Any6();
ExpectNetlinkPacket(
@@ -427,7 +427,7 @@
}
TEST_F(NetlinkTest, ChangeLocalAddressRemove) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
QuicIpAddress ip = QuicIpAddress::Any4();
ExpectNetlinkPacket(
@@ -480,7 +480,7 @@
}
TEST_F(NetlinkTest, GetRouteInfoWorks) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
QuicIpAddress destination;
ASSERT_TRUE(destination.FromString("f800::2"));
@@ -514,7 +514,7 @@
}
TEST_F(NetlinkTest, ChangeRouteAdd) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
QuicIpAddress preferred_ip;
preferred_ip.FromString("ff80:dead:beef::1");
@@ -596,7 +596,7 @@
}
TEST_F(NetlinkTest, ChangeRouteRemove) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
QuicIpAddress preferred_ip;
preferred_ip.FromString("ff80:dead:beef::1");
@@ -678,7 +678,7 @@
}
TEST_F(NetlinkTest, ChangeRouteReplace) {
- auto netlink = QuicMakeUnique<Netlink>(&mock_kernel_);
+ auto netlink = std::make_unique<Netlink>(&mock_kernel_);
QuicIpAddress preferred_ip;
preferred_ip.FromString("ff80:dead:beef::1");
diff --git a/quic/qbone/platform/rtnetlink_message.cc b/quic/qbone/platform/rtnetlink_message.cc
index f35628a..5febbd7 100644
--- a/quic/qbone/platform/rtnetlink_message.cc
+++ b/quic/qbone/platform/rtnetlink_message.cc
@@ -57,7 +57,7 @@
}
std::unique_ptr<struct iovec[]> RtnetlinkMessage::BuildIoVec() const {
- auto message = QuicMakeUnique<struct iovec[]>(message_.size());
+ auto message = std::make_unique<struct iovec[]>(message_.size());
int idx = 0;
for (const auto& vec : message_) {
message[idx++] = vec;
diff --git a/quic/qbone/qbone_client.cc b/quic/qbone/qbone_client.cc
index f062d3f..86bd477 100644
--- a/quic/qbone/qbone_client.cc
+++ b/quic/qbone/qbone_client.cc
@@ -17,7 +17,7 @@
QuicEpollServer* epoll_server,
QboneClient* client) {
std::unique_ptr<QuicClientBase::NetworkHelper> helper =
- QuicMakeUnique<QuicClientEpollNetworkHelper>(epoll_server, client);
+ std::make_unique<QuicClientEpollNetworkHelper>(epoll_server, client);
testing::testvalue::Adjust("QboneClient/network_helper", &helper);
return helper;
}
@@ -90,7 +90,7 @@
std::unique_ptr<QuicSession> QboneClient::CreateQuicClientSession(
const ParsedQuicVersionVector& supported_versions,
QuicConnection* connection) {
- return QuicMakeUnique<QboneClientSessionWithConnection>(
+ return std::make_unique<QboneClientSessionWithConnection>(
connection, crypto_config(), session_owner(), *config(),
supported_versions, server_id(), qbone_writer_, qbone_handler_);
}
diff --git a/quic/qbone/qbone_client_session.cc b/quic/qbone/qbone_client_session.cc
index c07bdf6..5f82570 100644
--- a/quic/qbone/qbone_client_session.cc
+++ b/quic/qbone/qbone_client_session.cc
@@ -27,7 +27,7 @@
QboneClientSession::~QboneClientSession() {}
std::unique_ptr<QuicCryptoStream> QboneClientSession::CreateCryptoStream() {
- return QuicMakeUnique<QuicCryptoClientStream>(
+ return std::make_unique<QuicCryptoClientStream>(
server_id_, this, nullptr, quic_crypto_client_config_, this);
}
@@ -41,7 +41,7 @@
QuicStreamId next_id = GetNextOutgoingBidirectionalStreamId();
DCHECK_EQ(next_id, QboneConstants::GetControlStreamId(transport_version()));
auto control_stream =
- QuicMakeUnique<QboneClientControlStream>(this, handler_);
+ std::make_unique<QboneClientControlStream>(this, handler_);
control_stream_ = control_stream.get();
ActivateStream(std::move(control_stream));
}
diff --git a/quic/qbone/qbone_packet_exchanger.cc b/quic/qbone/qbone_packet_exchanger.cc
index 3f3a5f9..c8dcffa 100644
--- a/quic/qbone/qbone_packet_exchanger.cc
+++ b/quic/qbone/qbone_packet_exchanger.cc
@@ -46,7 +46,7 @@
auto data_copy = new char[size];
memcpy(data_copy, packet, size);
packet_queue_.push_back(
- QuicMakeUnique<QuicData>(data_copy, size, /* owns_buffer = */ true));
+ std::make_unique<QuicData>(data_copy, size, /* owns_buffer = */ true));
}
void QbonePacketExchanger::SetWritable() {
diff --git a/quic/qbone/qbone_packet_exchanger_test.cc b/quic/qbone/qbone_packet_exchanger_test.cc
index 4e63b99..e507a1d 100644
--- a/quic/qbone/qbone_packet_exchanger_test.cc
+++ b/quic/qbone/qbone_packet_exchanger_test.cc
@@ -99,7 +99,7 @@
string packet = "data";
exchanger.AddPacketToBeRead(
- QuicMakeUnique<QuicData>(packet.data(), packet.length()));
+ std::make_unique<QuicData>(packet.data(), packet.length()));
EXPECT_CALL(client, ProcessPacketFromNetwork(StrEq("data")));
EXPECT_TRUE(exchanger.ReadAndDeliverPacket(&client));
diff --git a/quic/qbone/qbone_packet_processor_test.cc b/quic/qbone/qbone_packet_processor_test.cc
index 256f5b0..2e1b4de 100644
--- a/quic/qbone/qbone_packet_processor_test.cc
+++ b/quic/qbone/qbone_packet_processor_test.cc
@@ -138,7 +138,7 @@
CHECK(self_ip_.FromString("fd00:0:0:4::1"));
CHECK(network_ip_.FromString("fd00:0:0:5::1"));
- processor_ = QuicMakeUnique<QbonePacketProcessor>(
+ processor_ = std::make_unique<QbonePacketProcessor>(
self_ip_, client_ip_, /*client_ip_subnet_length=*/62, &output_,
&stats_);
}
@@ -231,7 +231,7 @@
}
TEST_F(QbonePacketProcessorTest, FilterFromClient) {
- auto filter = QuicMakeUnique<MockPacketFilter>();
+ auto filter = std::make_unique<MockPacketFilter>();
EXPECT_CALL(*filter, FilterPacket(_, _, _, _, _))
.WillRepeatedly(Return(ProcessingResult::SILENT_DROP));
processor_->set_filter(std::move(filter));
@@ -270,7 +270,7 @@
// Verify that the parameters are passed correctly into the filter, and that the
// helper functions of the filter class work.
TEST_F(QbonePacketProcessorTest, FilterHelperFunctions) {
- auto filter_owned = QuicMakeUnique<TestFilter>(client_ip_, network_ip_);
+ auto filter_owned = std::make_unique<TestFilter>(client_ip_, network_ip_);
TestFilter* filter = filter_owned.get();
processor_->set_filter(std::move(filter_owned));
diff --git a/quic/qbone/qbone_server_session.cc b/quic/qbone/qbone_server_session.cc
index 49f84eb..e9515c2 100644
--- a/quic/qbone/qbone_server_session.cc
+++ b/quic/qbone/qbone_server_session.cc
@@ -48,16 +48,16 @@
QboneServerSession::~QboneServerSession() {}
std::unique_ptr<QuicCryptoStream> QboneServerSession::CreateCryptoStream() {
- return QuicMakeUnique<QuicCryptoServerStream>(quic_crypto_server_config_,
- compressed_certs_cache_, this,
- &stream_helper_);
+ return std::make_unique<QuicCryptoServerStream>(quic_crypto_server_config_,
+ compressed_certs_cache_, this,
+ &stream_helper_);
}
void QboneServerSession::Initialize() {
QboneSessionBase::Initialize();
// Register the reserved control stream.
auto control_stream =
- QuicMakeUnique<QboneServerControlStream>(this, handler_);
+ std::make_unique<QboneServerControlStream>(this, handler_);
control_stream_ = control_stream.get();
ActivateStream(std::move(control_stream));
}
diff --git a/quic/qbone/qbone_session_base.cc b/quic/qbone/qbone_session_base.cc
index d881975..23b29d2 100644
--- a/quic/qbone/qbone_session_base.cc
+++ b/quic/qbone/qbone_session_base.cc
@@ -104,10 +104,10 @@
if (IsIncomingStream(id)) {
++num_streamed_packets_;
- return QuicMakeUnique<QboneReadOnlyStream>(id, this);
+ return std::make_unique<QboneReadOnlyStream>(id, this);
}
- return QuicMakeUnique<QboneWriteOnlyStream>(id, this);
+ return std::make_unique<QboneWriteOnlyStream>(id, this);
}
QuicStream* QboneSessionBase::ActivateDataStream(
diff --git a/quic/qbone/qbone_session_test.cc b/quic/qbone/qbone_session_test.cc
index be598a9..016b2f3 100644
--- a/quic/qbone/qbone_session_test.cc
+++ b/quic/qbone/qbone_session_test.cc
@@ -244,13 +244,13 @@
bool send_qbone_alpn = true) {
// Quic crashes if packets are sent at time 0, and the clock defaults to 0.
helper_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
- alarm_factory_ = QuicMakeUnique<QuicEpollAlarmFactory>(&epoll_server_);
- client_writer_ = QuicMakeUnique<DataSavingQbonePacketWriter>();
- server_writer_ = QuicMakeUnique<DataSavingQbonePacketWriter>();
+ alarm_factory_ = std::make_unique<QuicEpollAlarmFactory>(&epoll_server_);
+ client_writer_ = std::make_unique<DataSavingQbonePacketWriter>();
+ server_writer_ = std::make_unique<DataSavingQbonePacketWriter>();
client_handler_ =
- QuicMakeUnique<DataSavingQboneControlHandler<QboneClientRequest>>();
+ std::make_unique<DataSavingQboneControlHandler<QboneClientRequest>>();
server_handler_ =
- QuicMakeUnique<DataSavingQboneControlHandler<QboneServerRequest>>();
+ std::make_unique<DataSavingQboneControlHandler<QboneServerRequest>>();
QuicSocketAddress server_address(TestLoopback(),
QuicPickServerPortForTestsOrDie());
QuicSocketAddress client_address;
@@ -267,12 +267,12 @@
ParsedVersionOfIndex(AllSupportedVersions(), 0));
client_connection_->SetSelfAddress(client_address);
QuicConfig config;
- client_crypto_config_ = QuicMakeUnique<QuicCryptoClientConfig>(
- QuicMakeUnique<FakeProofVerifier>(client_handshake_success));
+ client_crypto_config_ = std::make_unique<QuicCryptoClientConfig>(
+ std::make_unique<FakeProofVerifier>(client_handshake_success));
if (send_qbone_alpn) {
client_crypto_config_->set_alpn("qbone");
}
- client_peer_ = QuicMakeUnique<QboneClientSession>(
+ client_peer_ = std::make_unique<QboneClientSession>(
client_connection_, client_crypto_config_.get(),
/*owner=*/nullptr, config,
ParsedVersionOfIndex(AllSupportedVersions(), 0),
@@ -287,7 +287,7 @@
ParsedVersionOfIndex(AllSupportedVersions(), 0));
server_connection_->SetSelfAddress(server_address);
QuicConfig config;
- server_crypto_config_ = QuicMakeUnique<QuicCryptoServerConfig>(
+ server_crypto_config_ = std::make_unique<QuicCryptoServerConfig>(
"TESTING", QuicRandom::GetInstance(),
std::unique_ptr<FakeProofSource>(
new FakeProofSource(server_handshake_success)),
@@ -300,7 +300,7 @@
server_crypto_config_->AddConfig(std::move(primary_config),
GetClock()->WallNow()));
- server_peer_ = QuicMakeUnique<QboneServerSession>(
+ server_peer_ = std::make_unique<QboneServerSession>(
AllSupportedVersions(), server_connection_, nullptr, config,
server_crypto_config_.get(), &compressed_certs_cache_,
server_writer_.get(), TestLoopback6(), TestLoopback6(), 64,
diff --git a/quic/qbone/qbone_stream_test.cc b/quic/qbone/qbone_stream_test.cc
index 1920aa5..344387f 100644
--- a/quic/qbone/qbone_stream_test.cc
+++ b/quic/qbone/qbone_stream_test.cc
@@ -135,7 +135,7 @@
Perspective perspective = Perspective::IS_SERVER;
bool owns_writer = true;
- alarm_factory_ = QuicMakeUnique<test::MockAlarmFactory>();
+ alarm_factory_ = std::make_unique<test::MockAlarmFactory>();
connection_.reset(new QuicConnection(
test::TestConnectionId(0), QuicSocketAddress(TestLoopback(), 0),
@@ -143,8 +143,8 @@
new DummyPacketWriter(), owns_writer, perspective,
ParsedVersionOfIndex(CurrentSupportedVersions(), 0)));
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
- session_ = QuicMakeUnique<StrictMock<MockQuicSession>>(connection_.get(),
- QuicConfig());
+ session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_.get(),
+ QuicConfig());
stream_ = new QboneReadOnlyStream(kStreamId, session_.get());
session_->ActivateReliableStream(
std::unique_ptr<QboneReadOnlyStream>(stream_));
