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/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index cc9a1d2..0aacb18 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -99,7 +99,7 @@
framer.EncryptPayload(ENCRYPTION_INITIAL, header_.packet_number,
*packet, buffer_, QUIC_ARRAYSIZE(buffer_));
ASSERT_NE(0u, encrypted_length);
- packet_ = QuicMakeUnique<QuicEncryptedPacket>(buffer_, encrypted_length);
+ packet_ = std::make_unique<QuicEncryptedPacket>(buffer_, encrypted_length);
EXPECT_TRUE(packet_ != nullptr);
DeleteFrames(&frames);
}
diff --git a/quic/core/congestion_control/bbr2_simulator_test.cc b/quic/core/congestion_control/bbr2_simulator_test.cc
index ab4b67b..d941476 100644
--- a/quic/core/congestion_control/bbr2_simulator_test.cc
+++ b/quic/core/congestion_control/bbr2_simulator_test.cc
@@ -145,20 +145,20 @@
void CreateNetwork(const DefaultTopologyParams& params) {
QUIC_LOG(INFO) << "CreateNetwork with parameters: " << params.ToString();
- switch_ = QuicMakeUnique<simulator::Switch>(&simulator_, "Switch",
- params.switch_port_count,
- params.SwitchQueueCapacity());
+ switch_ = std::make_unique<simulator::Switch>(&simulator_, "Switch",
+ params.switch_port_count,
+ params.SwitchQueueCapacity());
// WARNING: The order to add links to network_links_ matters, because some
// tests adjusts the link bandwidth on the fly.
// Local link connects sender and port 1.
- network_links_.push_back(QuicMakeUnique<simulator::SymmetricLink>(
+ network_links_.push_back(std::make_unique<simulator::SymmetricLink>(
&sender_endpoint_, switch_->port(1), params.local_link.bandwidth,
params.local_link.delay));
// Test link connects receiver and port 2.
- network_links_.push_back(QuicMakeUnique<simulator::SymmetricLink>(
+ network_links_.push_back(std::make_unique<simulator::SymmetricLink>(
&receiver_endpoint_, switch_->port(2), params.test_link.bandwidth,
params.test_link.delay));
}
@@ -702,16 +702,17 @@
for (size_t i = 0; i < MultiSenderTopologyParams::kNumLocalLinks; ++i) {
std::string sender_name = QuicStrCat("Sender", i + 1);
std::string receiver_name = QuicStrCat("Receiver", i + 1);
- sender_endpoints_.push_back(QuicMakeUnique<simulator::QuicEndpoint>(
+ sender_endpoints_.push_back(std::make_unique<simulator::QuicEndpoint>(
&simulator_, sender_name, receiver_name, Perspective::IS_CLIENT,
TestConnectionId(first_connection_id + i)));
- receiver_endpoints_.push_back(QuicMakeUnique<simulator::QuicEndpoint>(
+ receiver_endpoints_.push_back(std::make_unique<simulator::QuicEndpoint>(
&simulator_, receiver_name, sender_name, Perspective::IS_SERVER,
TestConnectionId(first_connection_id + i)));
receiver_endpoint_pointers.push_back(receiver_endpoints_.back().get());
}
- receiver_multiplexer_ = QuicMakeUnique<simulator::QuicEndpointMultiplexer>(
- "Receiver multiplexer", receiver_endpoint_pointers);
+ receiver_multiplexer_ =
+ std::make_unique<simulator::QuicEndpointMultiplexer>(
+ "Receiver multiplexer", receiver_endpoint_pointers);
sender_1_ = SetupBbr2Sender(sender_endpoints_[0].get());
uint64_t seed = QuicRandom::GetInstance()->RandUint64();
@@ -773,16 +774,16 @@
void CreateNetwork(const MultiSenderTopologyParams& params) {
QUIC_LOG(INFO) << "CreateNetwork with parameters: " << params.ToString();
- switch_ = QuicMakeUnique<simulator::Switch>(&simulator_, "Switch",
- params.switch_port_count,
- params.SwitchQueueCapacity());
+ switch_ = std::make_unique<simulator::Switch>(&simulator_, "Switch",
+ params.switch_port_count,
+ params.SwitchQueueCapacity());
- network_links_.push_back(QuicMakeUnique<simulator::SymmetricLink>(
+ network_links_.push_back(std::make_unique<simulator::SymmetricLink>(
receiver_multiplexer_.get(), switch_->port(1),
params.test_link.bandwidth, params.test_link.delay));
for (size_t i = 0; i < MultiSenderTopologyParams::kNumLocalLinks; ++i) {
simulator::SwitchPortNumber port_number = i + 2;
- network_links_.push_back(QuicMakeUnique<simulator::SymmetricLink>(
+ network_links_.push_back(std::make_unique<simulator::SymmetricLink>(
sender_endpoints_[i].get(), switch_->port(port_number),
params.local_links[i].bandwidth, params.local_links[i].delay));
}
diff --git a/quic/core/congestion_control/bbr_sender_test.cc b/quic/core/congestion_control/bbr_sender_test.cc
index d175bdf..909107b 100644
--- a/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quic/core/congestion_control/bbr_sender_test.cc
@@ -146,24 +146,24 @@
// receiver and the switch. The switch has the buffers four times larger than
// the bottleneck BDP, which should guarantee a lack of losses.
void CreateDefaultSetup() {
- switch_ = QuicMakeUnique<simulator::Switch>(&simulator_, "Switch", 8,
- 2 * kTestBdp);
- bbr_sender_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ switch_ = std::make_unique<simulator::Switch>(&simulator_, "Switch", 8,
+ 2 * kTestBdp);
+ bbr_sender_link_ = std::make_unique<simulator::SymmetricLink>(
&bbr_sender_, switch_->port(1), kLocalLinkBandwidth,
kLocalPropagationDelay);
- receiver_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ receiver_link_ = std::make_unique<simulator::SymmetricLink>(
&receiver_, switch_->port(2), kTestLinkBandwidth,
kTestPropagationDelay);
}
// Same as the default setup, except the buffer now is half of the BDP.
void CreateSmallBufferSetup() {
- switch_ = QuicMakeUnique<simulator::Switch>(&simulator_, "Switch", 8,
- 0.5 * kTestBdp);
- bbr_sender_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ switch_ = std::make_unique<simulator::Switch>(&simulator_, "Switch", 8,
+ 0.5 * kTestBdp);
+ bbr_sender_link_ = std::make_unique<simulator::SymmetricLink>(
&bbr_sender_, switch_->port(1), kLocalLinkBandwidth,
kLocalPropagationDelay);
- receiver_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ receiver_link_ = std::make_unique<simulator::SymmetricLink>(
&receiver_, switch_->port(2), kTestLinkBandwidth,
kTestPropagationDelay);
}
@@ -171,19 +171,19 @@
// Creates the variation of the default setup in which there is another sender
// that competes for the same bottleneck link.
void CreateCompetitionSetup() {
- switch_ = QuicMakeUnique<simulator::Switch>(&simulator_, "Switch", 8,
- 2 * kTestBdp);
+ switch_ = std::make_unique<simulator::Switch>(&simulator_, "Switch", 8,
+ 2 * kTestBdp);
// Add a small offset to the competing link in order to avoid
// synchronization effects.
const QuicTime::Delta small_offset = QuicTime::Delta::FromMicroseconds(3);
- bbr_sender_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ bbr_sender_link_ = std::make_unique<simulator::SymmetricLink>(
&bbr_sender_, switch_->port(1), kLocalLinkBandwidth,
kLocalPropagationDelay);
- competing_sender_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ competing_sender_link_ = std::make_unique<simulator::SymmetricLink>(
&competing_sender_, switch_->port(3), kLocalLinkBandwidth,
kLocalPropagationDelay + small_offset);
- receiver_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ receiver_link_ = std::make_unique<simulator::SymmetricLink>(
&receiver_multiplexer_, switch_->port(2), kTestLinkBandwidth,
kTestPropagationDelay);
}
diff --git a/quic/core/congestion_control/hybrid_slow_start_test.cc b/quic/core/congestion_control/hybrid_slow_start_test.cc
index aa2f849..d17c7cc 100644
--- a/quic/core/congestion_control/hybrid_slow_start_test.cc
+++ b/quic/core/congestion_control/hybrid_slow_start_test.cc
@@ -17,7 +17,7 @@
HybridSlowStartTest()
: one_ms_(QuicTime::Delta::FromMilliseconds(1)),
rtt_(QuicTime::Delta::FromMilliseconds(60)) {}
- void SetUp() override { slow_start_ = QuicMakeUnique<HybridSlowStart>(); }
+ void SetUp() override { slow_start_ = std::make_unique<HybridSlowStart>(); }
const QuicTime::Delta one_ms_;
const QuicTime::Delta rtt_;
std::unique_ptr<HybridSlowStart> slow_start_;
diff --git a/quic/core/congestion_control/pacing_sender_test.cc b/quic/core/congestion_control/pacing_sender_test.cc
index 066a3b5..e54cbae 100644
--- a/quic/core/congestion_control/pacing_sender_test.cc
+++ b/quic/core/congestion_control/pacing_sender_test.cc
@@ -43,8 +43,8 @@
~PacingSenderTest() override {}
void InitPacingRate(QuicPacketCount burst_size, QuicBandwidth bandwidth) {
- mock_sender_ = QuicMakeUnique<StrictMock<MockSendAlgorithm>>();
- pacing_sender_ = QuicMakeUnique<PacingSender>();
+ mock_sender_ = std::make_unique<StrictMock<MockSendAlgorithm>>();
+ pacing_sender_ = std::make_unique<PacingSender>();
pacing_sender_->set_sender(mock_sender_.get());
EXPECT_CALL(*mock_sender_, PacingRate(_)).WillRepeatedly(Return(bandwidth));
EXPECT_CALL(*mock_sender_, BandwidthEstimate())
diff --git a/quic/core/congestion_control/send_algorithm_test.cc b/quic/core/congestion_control/send_algorithm_test.cc
index c07508c..b676899 100644
--- a/quic/core/congestion_control/send_algorithm_test.cc
+++ b/quic/core/congestion_control/send_algorithm_test.cc
@@ -189,12 +189,12 @@
void CreateSetup(const QuicBandwidth& test_bandwidth,
const QuicTime::Delta& test_link_delay,
QuicByteCount bottleneck_queue_length) {
- switch_ = QuicMakeUnique<simulator::Switch>(&simulator_, "Switch", 8,
- bottleneck_queue_length);
- quic_sender_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ switch_ = std::make_unique<simulator::Switch>(&simulator_, "Switch", 8,
+ bottleneck_queue_length);
+ quic_sender_link_ = std::make_unique<simulator::SymmetricLink>(
&quic_sender_, switch_->port(1), kLocalLinkBandwidth,
kLocalPropagationDelay);
- receiver_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+ receiver_link_ = std::make_unique<simulator::SymmetricLink>(
&receiver_, switch_->port(2), test_bandwidth, test_link_delay);
}
diff --git a/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc b/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
index 2d27896..11b9660 100644
--- a/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
+++ b/quic/core/congestion_control/tcp_cubic_sender_bytes_test.cc
@@ -794,7 +794,7 @@
TEST_F(TcpCubicSenderBytesTest, LimitCwndIncreaseInCongestionAvoidance) {
// Enable Cubic.
- sender_ = QuicMakeUnique<TcpCubicSenderBytesPeer>(&clock_, false);
+ sender_ = std::make_unique<TcpCubicSenderBytesPeer>(&clock_, false);
int num_sent = SendAvailableSendWindow();
diff --git a/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quic/core/congestion_control/uber_loss_algorithm_test.cc
index 84b9c99..a63c3f7 100644
--- a/quic/core/congestion_control/uber_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -22,7 +22,7 @@
protected:
UberLossAlgorithmTest() {
unacked_packets_ =
- QuicMakeUnique<QuicUnackedPacketMap>(Perspective::IS_CLIENT);
+ std::make_unique<QuicUnackedPacketMap>(Perspective::IS_CLIENT);
rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
QuicTime::Delta::Zero(), clock_.Now());
EXPECT_LT(0, rtt_stats_.smoothed_rtt().ToMicroseconds());
diff --git a/quic/core/crypto/cert_compressor.cc b/quic/core/crypto/cert_compressor.cc
index 9ad2fc8..09973dd 100644
--- a/quic/core/crypto/cert_compressor.cc
+++ b/quic/core/crypto/cert_compressor.cc
@@ -577,7 +577,7 @@
return false;
}
- uncompressed_data = QuicMakeUnique<uint8_t[]>(uncompressed_size);
+ uncompressed_data = std::make_unique<uint8_t[]>(uncompressed_size);
z_stream z;
ScopedZLib scoped_z(ScopedZLib::INFLATE);
diff --git a/quic/core/crypto/crypto_framer.cc b/quic/core/crypto/crypto_framer.cc
index 931ac99..ffddb81 100644
--- a/quic/core/crypto/crypto_framer.cc
+++ b/quic/core/crypto/crypto_framer.cc
@@ -32,7 +32,7 @@
void OnError(CryptoFramer* /*framer*/) override { error_ = true; }
void OnHandshakeMessage(const CryptoHandshakeMessage& message) override {
- out_ = QuicMakeUnique<CryptoHandshakeMessage>(message);
+ out_ = std::make_unique<CryptoHandshakeMessage>(message);
}
bool error() const { return error_; }
@@ -230,7 +230,7 @@
}
}
- return QuicMakeUnique<QuicData>(buffer.release(), len, true);
+ return std::make_unique<QuicData>(buffer.release(), len, true);
}
void CryptoFramer::Clear() {
diff --git a/quic/core/crypto/crypto_server_test.cc b/quic/core/crypto/crypto_server_test.cc
index 3216ea8..c3ca92c 100644
--- a/quic/core/crypto/crypto_server_test.cc
+++ b/quic/core/crypto/crypto_server_test.cc
@@ -218,7 +218,7 @@
config_.ValidateClientHello(
message, client_address_.host(), server_address,
supported_versions_.front().transport_version, &clock_, signed_config_,
- QuicMakeUnique<ValidateCallback>(this, true, "", &called));
+ std::make_unique<ValidateCallback>(this, true, "", &called));
EXPECT_TRUE(called);
}
@@ -236,7 +236,7 @@
config_.ValidateClientHello(
message, client_address_.host(), server_address,
supported_versions_.front().transport_version, &clock_, signed_config_,
- QuicMakeUnique<ValidateCallback>(this, false, error_substr, called));
+ std::make_unique<ValidateCallback>(this, false, error_substr, called));
}
class ProcessCallback : public ProcessClientHelloResultCallback {
@@ -297,8 +297,8 @@
supported_versions_.front(), supported_versions_, &clock_, rand_,
&compressed_certs_cache_, params_, signed_config_,
/*total_framing_overhead=*/50, chlo_packet_size_,
- QuicMakeUnique<ProcessCallback>(result, should_succeed, error_substr,
- &called, &out_));
+ std::make_unique<ProcessCallback>(result, should_succeed, error_substr,
+ &called, &out_));
EXPECT_TRUE(called);
}
diff --git a/quic/core/crypto/crypto_utils.cc b/quic/core/crypto/crypto_utils.cc
index 642799e..89d5379 100644
--- a/quic/core/crypto/crypto_utils.cc
+++ b/quic/core/crypto/crypto_utils.cc
@@ -134,12 +134,12 @@
encryption_label = server_label;
decryption_label = client_label;
}
- crypters->encrypter = QuicMakeUnique<Aes128GcmEncrypter>();
+ crypters->encrypter = std::make_unique<Aes128GcmEncrypter>();
std::vector<uint8_t> encryption_secret = HkdfExpandLabel(
hash, handshake_secret, encryption_label, EVP_MD_size(hash));
SetKeyAndIV(hash, encryption_secret, crypters->encrypter.get());
- crypters->decrypter = QuicMakeUnique<Aes128GcmDecrypter>();
+ crypters->decrypter = std::make_unique<Aes128GcmDecrypter>();
std::vector<uint8_t> decryption_secret = HkdfExpandLabel(
hash, handshake_secret, decryption_label, EVP_MD_size(hash));
SetKeyAndIV(hash, decryption_secret, crypters->decrypter.get());
@@ -191,7 +191,7 @@
pre_shared_key.size() + 8 +
premaster_secret.size() + 8;
- psk_premaster_secret = QuicMakeUnique<char[]>(psk_premaster_secret_size);
+ psk_premaster_secret = std::make_unique<char[]>(psk_premaster_secret_size);
QuicDataWriter writer(psk_premaster_secret_size, psk_premaster_secret.get(),
HOST_BYTE_ORDER);
diff --git a/quic/core/crypto/curve25519_key_exchange_test.cc b/quic/core/crypto/curve25519_key_exchange_test.cc
index 93aa298..aeaf52f 100644
--- a/quic/core/crypto/curve25519_key_exchange_test.cc
+++ b/quic/core/crypto/curve25519_key_exchange_test.cc
@@ -84,13 +84,14 @@
std::string alice_shared, bob_shared;
TestCallbackResult alice_result;
ASSERT_FALSE(alice_result.ok());
- alice->CalculateSharedKeyAsync(bob_public, &alice_shared,
- QuicMakeUnique<TestCallback>(&alice_result));
+ alice->CalculateSharedKeyAsync(
+ bob_public, &alice_shared,
+ std::make_unique<TestCallback>(&alice_result));
ASSERT_TRUE(alice_result.ok());
TestCallbackResult bob_result;
ASSERT_FALSE(bob_result.ok());
bob->CalculateSharedKeyAsync(alice_public, &bob_shared,
- QuicMakeUnique<TestCallback>(&bob_result));
+ std::make_unique<TestCallback>(&bob_result));
ASSERT_TRUE(bob_result.ok());
ASSERT_EQ(alice_shared, bob_shared);
ASSERT_NE(0u, alice_shared.length());
diff --git a/quic/core/crypto/p256_key_exchange_test.cc b/quic/core/crypto/p256_key_exchange_test.cc
index 34a4993..694fb62 100644
--- a/quic/core/crypto/p256_key_exchange_test.cc
+++ b/quic/core/crypto/p256_key_exchange_test.cc
@@ -89,13 +89,14 @@
std::string alice_shared, bob_shared;
TestCallbackResult alice_result;
ASSERT_FALSE(alice_result.ok());
- alice->CalculateSharedKeyAsync(bob_public, &alice_shared,
- QuicMakeUnique<TestCallback>(&alice_result));
+ alice->CalculateSharedKeyAsync(
+ bob_public, &alice_shared,
+ std::make_unique<TestCallback>(&alice_result));
ASSERT_TRUE(alice_result.ok());
TestCallbackResult bob_result;
ASSERT_FALSE(bob_result.ok());
bob->CalculateSharedKeyAsync(alice_public, &bob_shared,
- QuicMakeUnique<TestCallback>(&bob_result));
+ std::make_unique<TestCallback>(&bob_result));
ASSERT_TRUE(bob_result.ok());
ASSERT_EQ(alice_shared, bob_shared);
ASSERT_NE(0u, alice_shared.length());
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 862dc62..95705e5 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -118,7 +118,7 @@
// static
std::unique_ptr<KeyExchangeSource> KeyExchangeSource::Default() {
- return QuicMakeUnique<DefaultKeyExchangeSource>();
+ return std::make_unique<DefaultKeyExchangeSource>();
}
class ValidateClientHelloHelper {
@@ -665,7 +665,7 @@
QuicByteCount chlo_packet_size,
std::unique_ptr<ProcessClientHelloResultCallback> done_cb) const {
DCHECK(done_cb);
- auto context = QuicMakeUnique<ProcessClientHelloContext>(
+ auto context = std::make_unique<ProcessClientHelloContext>(
validate_chlo_result, reject_only, connection_id, server_address,
client_address, version, supported_versions, clock, rand,
compressed_certs_cache, params, signed_config, total_framing_overhead,
@@ -709,7 +709,7 @@
const std::string sni = std::string(context->info().sni);
const QuicTransportVersion transport_version = context->transport_version();
- auto cb = QuicMakeUnique<ProcessClientHelloCallback>(
+ auto cb = std::make_unique<ProcessClientHelloCallback>(
this, std::move(context), configs);
DCHECK(proof_source_.get());
@@ -739,7 +739,7 @@
return;
}
- auto out_diversification_nonce = QuicMakeUnique<DiversificationNonce>();
+ auto out_diversification_nonce = std::make_unique<DiversificationNonce>();
QuicStringPiece cert_sct;
if (context->client_hello().GetStringPiece(kCertificateSCTTag, &cert_sct) &&
@@ -747,7 +747,7 @@
context->params()->sct_supported_by_client = true;
}
- auto out = QuicMakeUnique<CryptoHandshakeMessage>();
+ auto out = std::make_unique<CryptoHandshakeMessage>();
if (!context->info().reject_reasons.empty() || !configs.requested) {
BuildRejectionAndRecordStats(*context, *configs.primary,
context->info().reject_reasons, out.get());
@@ -795,7 +795,7 @@
configs.requested->key_exchanges[key_exchange_index].get();
std::string* initial_premaster_secret =
&context->params()->initial_premaster_secret;
- auto cb = QuicMakeUnique<ProcessClientHelloAfterGetProofCallback>(
+ auto cb = std::make_unique<ProcessClientHelloAfterGetProofCallback>(
this, std::move(proof_source_details), key_exchange->type(),
std::move(out), public_value, std::move(context), configs);
key_exchange->CalculateSharedKeyAsync(public_value, initial_premaster_secret,
@@ -920,7 +920,7 @@
hkdf_input.append(QuicCryptoConfig::kInitialLabel, label_len);
hkdf_input.append(hkdf_suffix);
- auto out_diversification_nonce = QuicMakeUnique<DiversificationNonce>();
+ auto out_diversification_nonce = std::make_unique<DiversificationNonce>();
context->rand()->RandBytes(out_diversification_nonce->data(),
out_diversification_nonce->size());
CryptoUtils::Diversification diversification =
@@ -1009,7 +1009,7 @@
const std::string sni(context->info().sni);
const QuicTransportVersion transport_version = context->transport_version();
- auto cb = QuicMakeUnique<SendRejectWithFallbackConfigCallback>(
+ auto cb = std::make_unique<SendRejectWithFallbackConfigCallback>(
this, std::move(context), fallback_config);
proof_source_->GetProof(server_address, sni, fallback_config->serialized,
transport_version, chlo_hash, std::move(cb));
@@ -1025,12 +1025,12 @@
return;
}
- auto out = QuicMakeUnique<CryptoHandshakeMessage>();
+ auto out = std::make_unique<CryptoHandshakeMessage>();
BuildRejectionAndRecordStats(*context, *fallback_config,
{SERVER_CONFIG_UNKNOWN_CONFIG_FAILURE},
out.get());
- context->Succeed(std::move(out), QuicMakeUnique<DiversificationNonce>(),
+ context->Succeed(std::move(out), std::make_unique<DiversificationNonce>(),
std::move(proof_source_details));
}
@@ -1320,7 +1320,7 @@
message.SetStringPiece(kSourceAddressTokenTag, source_address_token);
auto proof_source_cb =
- QuicMakeUnique<BuildServerConfigUpdateMessageProofSourceCallback>(
+ std::make_unique<BuildServerConfigUpdateMessageProofSourceCallback>(
this, compressed_certs_cache, common_cert_sets, params,
std::move(message), std::move(cb));
diff --git a/quic/core/crypto/quic_decrypter.cc b/quic/core/crypto/quic_decrypter.cc
index 79369f0..2fb1deb 100644
--- a/quic/core/crypto/quic_decrypter.cc
+++ b/quic/core/crypto/quic_decrypter.cc
@@ -25,9 +25,9 @@
std::unique_ptr<QuicDecrypter> QuicDecrypter::Create(QuicTag algorithm) {
switch (algorithm) {
case kAESG:
- return QuicMakeUnique<Aes128Gcm12Decrypter>();
+ return std::make_unique<Aes128Gcm12Decrypter>();
case kCC20:
- return QuicMakeUnique<ChaCha20Poly1305Decrypter>();
+ return std::make_unique<ChaCha20Poly1305Decrypter>();
default:
QUIC_LOG(FATAL) << "Unsupported algorithm: " << algorithm;
return nullptr;
@@ -39,11 +39,11 @@
uint32_t cipher_suite) {
switch (cipher_suite) {
case TLS1_CK_AES_128_GCM_SHA256:
- return QuicMakeUnique<Aes128GcmDecrypter>();
+ return std::make_unique<Aes128GcmDecrypter>();
case TLS1_CK_AES_256_GCM_SHA384:
- return QuicMakeUnique<Aes256GcmDecrypter>();
+ return std::make_unique<Aes256GcmDecrypter>();
case TLS1_CK_CHACHA20_POLY1305_SHA256:
- return QuicMakeUnique<ChaCha20Poly1305TlsDecrypter>();
+ return std::make_unique<ChaCha20Poly1305TlsDecrypter>();
default:
QUIC_BUG << "TLS cipher suite is unknown to QUIC";
return nullptr;
diff --git a/quic/core/crypto/quic_encrypter.cc b/quic/core/crypto/quic_encrypter.cc
index f264bfd..f6b2490 100644
--- a/quic/core/crypto/quic_encrypter.cc
+++ b/quic/core/crypto/quic_encrypter.cc
@@ -22,9 +22,9 @@
std::unique_ptr<QuicEncrypter> QuicEncrypter::Create(QuicTag algorithm) {
switch (algorithm) {
case kAESG:
- return QuicMakeUnique<Aes128Gcm12Encrypter>();
+ return std::make_unique<Aes128Gcm12Encrypter>();
case kCC20:
- return QuicMakeUnique<ChaCha20Poly1305Encrypter>();
+ return std::make_unique<ChaCha20Poly1305Encrypter>();
default:
QUIC_LOG(FATAL) << "Unsupported algorithm: " << algorithm;
return nullptr;
@@ -36,11 +36,11 @@
uint32_t cipher_suite) {
switch (cipher_suite) {
case TLS1_CK_AES_128_GCM_SHA256:
- return QuicMakeUnique<Aes128GcmEncrypter>();
+ return std::make_unique<Aes128GcmEncrypter>();
case TLS1_CK_AES_256_GCM_SHA384:
- return QuicMakeUnique<Aes256GcmEncrypter>();
+ return std::make_unique<Aes256GcmEncrypter>();
case TLS1_CK_CHACHA20_POLY1305_SHA256:
- return QuicMakeUnique<ChaCha20Poly1305TlsEncrypter>();
+ return std::make_unique<ChaCha20Poly1305TlsEncrypter>();
default:
QUIC_BUG << "TLS cipher suite is unknown to QUIC";
return nullptr;
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index 8f2349c..8e4fa40 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -706,7 +706,7 @@
preferred_address.stateless_reset_token.assign(
CBS_data(&value), CBS_data(&value) + CBS_len(&value));
out->preferred_address =
- QuicMakeUnique<TransportParameters::PreferredAddress>(
+ std::make_unique<TransportParameters::PreferredAddress>(
preferred_address);
} break;
case TransportParameters::kActiveConnectionIdLimit:
diff --git a/quic/core/crypto/transport_parameters_test.cc b/quic/core/crypto/transport_parameters_test.cc
index 7379224..e782c38 100644
--- a/quic/core/crypto/transport_parameters_test.cc
+++ b/quic/core/crypto/transport_parameters_test.cc
@@ -73,7 +73,7 @@
preferred_address.ipv6_socket_address = CreateFakeV6SocketAddress();
preferred_address.connection_id = kFakePreferredConnectionId;
preferred_address.stateless_reset_token = kFakePreferredStatelessResetToken;
- return QuicMakeUnique<TransportParameters::PreferredAddress>(
+ return std::make_unique<TransportParameters::PreferredAddress>(
preferred_address);
}
@@ -594,7 +594,7 @@
orig_params.version = kFakeVersionLabel;
orig_params.max_packet_size.set_value(kFakeMaxPacketSize);
- orig_params.google_quic_params = QuicMakeUnique<CryptoHandshakeMessage>();
+ orig_params.google_quic_params = std::make_unique<CryptoHandshakeMessage>();
const std::string kTestString = "test string";
orig_params.google_quic_params->SetStringPiece(42, kTestString);
const uint32_t kTestValue = 12;
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 3a6d514..a59100a 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -385,7 +385,7 @@
client_writer_->Initialize(
QuicConnectionPeer::GetHelper(GetClientConnection()),
QuicConnectionPeer::GetAlarmFactory(GetClientConnection()),
- QuicMakeUnique<ClientDelegate>(client_->client()));
+ std::make_unique<ClientDelegate>(client_->client()));
}
initialized_ = true;
return client_->client()->connected();
@@ -409,7 +409,8 @@
crypto_test_utils::ProofSourceForTesting(), server_config_,
server_supported_versions_, &memory_cache_backend_,
expected_server_connection_id_length_);
- server_thread_ = QuicMakeUnique<ServerThread>(test_server, server_address_);
+ server_thread_ =
+ std::make_unique<ServerThread>(test_server, server_address_);
if (chlo_multiplier_ != 0) {
server_thread_->server()->SetChloMultiplier(chlo_multiplier_);
}
@@ -425,7 +426,7 @@
server_writer_->Initialize(QuicDispatcherPeer::GetHelper(dispatcher),
QuicDispatcherPeer::GetAlarmFactory(dispatcher),
- QuicMakeUnique<ServerDelegate>(dispatcher));
+ std::make_unique<ServerDelegate>(dispatcher));
if (stream_factory_ != nullptr) {
static_cast<QuicTestServer*>(server_thread_->server())
->SetSpdyStreamFactory(stream_factory_);
@@ -3406,7 +3407,7 @@
client_writer_->Initialize(
QuicConnectionPeer::GetHelper(GetClientConnection()),
QuicConnectionPeer::GetAlarmFactory(GetClientConnection()),
- QuicMakeUnique<ClientDelegate>(client_->client()));
+ std::make_unique<ClientDelegate>(client_->client()));
initialized_ = true;
ASSERT_TRUE(client_->client()->connected());
diff --git a/quic/core/http/http_decoder_test.cc b/quic/core/http/http_decoder_test.cc
index 6090cad..0323319 100644
--- a/quic/core/http/http_decoder_test.cc
+++ b/quic/core/http/http_decoder_test.cc
@@ -148,7 +148,7 @@
const QuicByteCount total_length =
QuicDataWriter::GetVarInt62Len(frame_type) +
QuicDataWriter::GetVarInt62Len(payload_length) + payload_length;
- input = QuicMakeUnique<char[]>(total_length);
+ input = std::make_unique<char[]>(total_length);
QuicDataWriter writer(total_length, input.get());
writer.WriteVarInt62(frame_type);
@@ -615,7 +615,7 @@
QuicDataWriter::GetVarInt62Len(frame_type) +
QuicDataWriter::GetVarInt62Len(payload_length);
- auto input = QuicMakeUnique<char[]>(header_length);
+ auto input = std::make_unique<char[]>(header_length);
QuicDataWriter writer(header_length, input.get());
writer.WriteVarInt62(frame_type);
writer.WriteVarInt62(payload_length);
diff --git a/quic/core/http/quic_client_promised_info.cc b/quic/core/http/quic_client_promised_info.cc
index 6af35d5..34ea5fd 100644
--- a/quic/core/http/quic_client_promised_info.cc
+++ b/quic/core/http/quic_client_promised_info.cc
@@ -72,7 +72,7 @@
}
void QuicClientPromisedInfo::OnResponseHeaders(const SpdyHeaderBlock& headers) {
- response_headers_ = QuicMakeUnique<SpdyHeaderBlock>(headers.Clone());
+ response_headers_ = std::make_unique<SpdyHeaderBlock>(headers.Clone());
if (client_request_delegate_) {
// We already have a client request waiting.
FinalValidation();
diff --git a/quic/core/http/quic_client_promised_info_test.cc b/quic/core/http/quic_client_promised_info_test.cc
index cd54dde..83c4988 100644
--- a/quic/core/http/quic_client_promised_info_test.cc
+++ b/quic/core/http/quic_client_promised_info_test.cc
@@ -80,11 +80,11 @@
headers_[":status"] = "200";
headers_["content-length"] = "11";
- stream_ = QuicMakeUnique<QuicSpdyClientStream>(
+ stream_ = std::make_unique<QuicSpdyClientStream>(
GetNthClientInitiatedBidirectionalStreamId(
connection_->transport_version(), 0),
&session_, BIDIRECTIONAL);
- stream_visitor_ = QuicMakeUnique<StreamVisitor>();
+ stream_visitor_ = std::make_unique<StreamVisitor>();
stream_->set_visitor(stream_visitor_.get());
push_promise_[":path"] = "/bar";
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index cfc5381..b5385b7 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -258,7 +258,7 @@
}
void SaveToHandler(size_t size, const QuicHeaderList& header_list) {
- headers_handler_ = QuicMakeUnique<TestHeadersHandler>();
+ headers_handler_ = std::make_unique<TestHeadersHandler>();
headers_handler_->OnHeaderBlockStart();
for (const auto& p : header_list) {
headers_handler_->OnHeader(p.first, p.second);
@@ -304,7 +304,7 @@
/*parent_stream_id=*/0,
/*exclusive=*/false, fin, kFrameComplete));
}
- headers_handler_ = QuicMakeUnique<TestHeadersHandler>();
+ headers_handler_ = std::make_unique<TestHeadersHandler>();
EXPECT_CALL(visitor_, OnHeaderFrameStart(stream_id))
.WillOnce(Return(headers_handler_.get()));
EXPECT_CALL(visitor_, OnHeaderFrameEnd(stream_id)).Times(1);
@@ -415,7 +415,7 @@
// Parse the outgoing data and check that it matches was was written.
EXPECT_CALL(visitor_,
OnPushPromise(stream_id, promised_stream_id, kFrameComplete));
- headers_handler_ = QuicMakeUnique<TestHeadersHandler>();
+ headers_handler_ = std::make_unique<TestHeadersHandler>();
EXPECT_CALL(visitor_, OnHeaderFrameStart(stream_id))
.WillOnce(Return(headers_handler_.get()));
EXPECT_CALL(visitor_, OnHeaderFrameEnd(stream_id)).Times(1);
@@ -734,7 +734,7 @@
TEST_P(QuicHeadersStreamTest, HpackDecoderDebugVisitor) {
auto hpack_decoder_visitor =
- QuicMakeUnique<StrictMock<MockQuicHpackDebugVisitor>>();
+ std::make_unique<StrictMock<MockQuicHpackDebugVisitor>>();
{
InSequence seq;
// Number of indexed representations generated in headers below.
@@ -787,7 +787,7 @@
TEST_P(QuicHeadersStreamTest, HpackEncoderDebugVisitor) {
auto hpack_encoder_visitor =
- QuicMakeUnique<StrictMock<MockQuicHpackDebugVisitor>>();
+ std::make_unique<StrictMock<MockQuicHpackDebugVisitor>>();
if (perspective() == Perspective::IS_SERVER) {
InSequence seq;
for (int i = 1; i < 4; i++) {
diff --git a/quic/core/http/quic_receive_control_stream.cc b/quic/core/http/quic_receive_control_stream.cc
index 0ff9e38..746efdb 100644
--- a/quic/core/http/quic_receive_control_stream.cc
+++ b/quic/core/http/quic_receive_control_stream.cc
@@ -159,7 +159,7 @@
QuicReceiveControlStream::QuicReceiveControlStream(PendingStream* pending)
: QuicStream(pending, READ_UNIDIRECTIONAL, /*is_static=*/true),
settings_frame_received_(false),
- http_decoder_visitor_(QuicMakeUnique<HttpDecoderVisitor>(this)),
+ http_decoder_visitor_(std::make_unique<HttpDecoderVisitor>(this)),
decoder_(http_decoder_visitor_.get()) {
sequencer()->set_level_triggered(true);
}
diff --git a/quic/core/http/quic_send_control_stream_test.cc b/quic/core/http/quic_send_control_stream_test.cc
index 49cc0ed..6ee06bd 100644
--- a/quic/core/http/quic_send_control_stream_test.cc
+++ b/quic/core/http/quic_send_control_stream_test.cc
@@ -100,7 +100,7 @@
"06" // SETTINGS_MAX_HEADER_LIST_SIZE
"4400"); // 1024
- auto buffer = QuicMakeUnique<char[]>(expected_write_data.size());
+ auto buffer = std::make_unique<char[]>(expected_write_data.size());
QuicDataWriter writer(expected_write_data.size(), buffer.get());
// A lambda to save and consume stream data when QuicSession::WritevData() is
diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 2236d42..616da68 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -142,7 +142,7 @@
connection_ = new StrictMock<MockQuicConnection>(
&helper_, &alarm_factory_, Perspective::IS_SERVER, supported_versions);
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
- session_ = QuicMakeUnique<TestServerSession>(
+ session_ = std::make_unique<TestServerSession>(
config_, connection_, &owner_, &stream_helper_, &crypto_config_,
&compressed_certs_cache_, &memory_cache_backend_);
MockClock clock;
diff --git a/quic/core/http/quic_spdy_client_session.cc b/quic/core/http/quic_spdy_client_session.cc
index ef9f2e2..ac4f041 100644
--- a/quic/core/http/quic_spdy_client_session.cc
+++ b/quic/core/http/quic_spdy_client_session.cc
@@ -100,7 +100,7 @@
std::unique_ptr<QuicSpdyClientStream>
QuicSpdyClientSession::CreateClientStream() {
- return QuicMakeUnique<QuicSpdyClientStream>(
+ return std::make_unique<QuicSpdyClientStream>(
GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL);
}
@@ -169,7 +169,7 @@
std::unique_ptr<QuicCryptoClientStreamBase>
QuicSpdyClientSession::CreateQuicCryptoStream() {
- return QuicMakeUnique<QuicCryptoClientStream>(
+ return std::make_unique<QuicCryptoClientStream>(
server_id_, this,
crypto_config_->proof_verifier()->CreateDefaultContext(), crypto_config_,
this);
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index 3601873..4291763 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -59,7 +59,7 @@
push_promise_index) {}
std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override {
- return QuicMakeUnique<MockQuicSpdyClientStream>(
+ return std::make_unique<MockQuicSpdyClientStream>(
GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL);
}
@@ -98,7 +98,7 @@
connection_ = new PacketSavingConnection(&helper_, &alarm_factory_,
Perspective::IS_CLIENT,
SupportedVersions(GetParam()));
- session_ = QuicMakeUnique<TestQuicSpdyClientSession>(
+ session_ = std::make_unique<TestQuicSpdyClientSession>(
DefaultQuicConfig(), SupportedVersions(GetParam()), connection_,
QuicServerId(kServerHostname, kPort, false), &crypto_config_,
&push_promise_index_);
@@ -539,11 +539,11 @@
if (GetParam().KnowsWhichDecrypterToUse()) {
connection_->InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
+ std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
} else {
connection_->SetDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
+ std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
}
EXPECT_CALL(*connection_, ProcessUdpPacket(server_address, client_address, _))
@@ -596,7 +596,7 @@
QuicStreamId stream_id =
QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(session_.get());
QuicSessionPeer::ActivateStream(
- session_.get(), QuicMakeUnique<QuicSpdyClientStream>(
+ session_.get(), std::make_unique<QuicSpdyClientStream>(
stream_id, session_.get(), BIDIRECTIONAL));
session_->set_max_allowed_push_id(GetNthServerInitiatedUnidirectionalStreamId(
@@ -906,7 +906,7 @@
QuicStreamId stream_id =
QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(session_.get());
QuicSessionPeer::ActivateStream(
- session_.get(), QuicMakeUnique<QuicSpdyClientStream>(
+ session_.get(), std::make_unique<QuicSpdyClientStream>(
stream_id, session_.get(), BIDIRECTIONAL));
session_->set_max_allowed_push_id(kMaxQuicStreamId);
diff --git a/quic/core/http/quic_spdy_client_stream_test.cc b/quic/core/http/quic_spdy_client_stream_test.cc
index 4354a2f..0397bdb 100644
--- a/quic/core/http/quic_spdy_client_stream_test.cc
+++ b/quic/core/http/quic_spdy_client_stream_test.cc
@@ -72,11 +72,11 @@
headers_[":status"] = "200";
headers_["content-length"] = "11";
- stream_ = QuicMakeUnique<QuicSpdyClientStream>(
+ stream_ = std::make_unique<QuicSpdyClientStream>(
GetNthClientInitiatedBidirectionalStreamId(
connection_->transport_version(), 0),
&session_, BIDIRECTIONAL);
- stream_visitor_ = QuicMakeUnique<StreamVisitor>();
+ stream_visitor_ = std::make_unique<StreamVisitor>();
stream_->set_visitor(stream_visitor_.get());
}
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index b789857..32984ca 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -377,7 +377,7 @@
DCHECK_EQ(headers_stream_id,
QuicUtils::GetHeadersStreamId(transport_version()));
}
- auto headers_stream = QuicMakeUnique<QuicHeadersStream>((this));
+ auto headers_stream = std::make_unique<QuicHeadersStream>((this));
DCHECK_EQ(QuicUtils::GetHeadersStreamId(transport_version()),
headers_stream->id());
@@ -386,10 +386,10 @@
} else {
ConfigureMaxIncomingDynamicStreamsToSend(
config()->GetMaxIncomingUnidirectionalStreamsToSend());
- qpack_encoder_ = QuicMakeUnique<QpackEncoder>(this);
+ qpack_encoder_ = std::make_unique<QpackEncoder>(this);
qpack_decoder_ =
- QuicMakeUnique<QpackDecoder>(qpack_maximum_dynamic_table_capacity_,
- qpack_maximum_blocked_streams_, this);
+ std::make_unique<QpackDecoder>(qpack_maximum_dynamic_table_capacity_,
+ qpack_maximum_blocked_streams_, this);
MaybeInitializeHttp3UnidirectionalStreams();
// TODO(b/112770235): Send SETTINGS_QPACK_BLOCKED_STREAMS with value
// qpack_maximum_blocked_streams_.
@@ -862,7 +862,7 @@
void QuicSpdySession::SetHpackDecoderDebugVisitor(
std::unique_ptr<QuicHpackDebugVisitor> visitor) {
h2_deframer_.SetDecoderHeaderTableDebugVisitor(
- QuicMakeUnique<HeaderTableDebugVisitor>(
+ std::make_unique<HeaderTableDebugVisitor>(
connection()->helper()->GetClock(), std::move(visitor)));
}
@@ -919,7 +919,7 @@
CloseConnectionOnDuplicateHttp3UnidirectionalStreams("Control");
return false;
}
- auto receive_stream = QuicMakeUnique<QuicReceiveControlStream>(pending);
+ auto receive_stream = std::make_unique<QuicReceiveControlStream>(pending);
receive_control_stream_ = receive_stream.get();
ActivateStream(std::move(receive_stream));
receive_control_stream_->SetUnblocked();
@@ -936,7 +936,7 @@
CloseConnectionOnDuplicateHttp3UnidirectionalStreams("QPACK encoder");
return false;
}
- auto encoder_receive = QuicMakeUnique<QpackReceiveStream>(
+ auto encoder_receive = std::make_unique<QpackReceiveStream>(
pending, qpack_decoder_->encoder_stream_receiver());
qpack_encoder_receive_stream_ = encoder_receive.get();
ActivateStream(std::move(encoder_receive));
@@ -949,7 +949,7 @@
CloseConnectionOnDuplicateHttp3UnidirectionalStreams("QPACK decoder");
return false;
}
- auto decoder_receive = QuicMakeUnique<QpackReceiveStream>(
+ auto decoder_receive = std::make_unique<QpackReceiveStream>(
pending, qpack_encoder_->decoder_stream_receiver());
qpack_decoder_receive_stream_ = decoder_receive.get();
ActivateStream(std::move(decoder_receive));
@@ -967,7 +967,7 @@
void QuicSpdySession::MaybeInitializeHttp3UnidirectionalStreams() {
DCHECK(VersionHasStreamType(transport_version()));
if (!send_control_stream_ && CanOpenNextOutgoingUnidirectionalStream()) {
- auto send_control = QuicMakeUnique<QuicSendControlStream>(
+ auto send_control = std::make_unique<QuicSendControlStream>(
GetNextOutgoingUnidirectionalStreamId(), this,
qpack_maximum_dynamic_table_capacity_, max_inbound_header_list_size_);
send_control_stream_ = send_control.get();
@@ -976,7 +976,7 @@
if (!qpack_decoder_send_stream_ &&
CanOpenNextOutgoingUnidirectionalStream()) {
- auto decoder_send = QuicMakeUnique<QpackSendStream>(
+ auto decoder_send = std::make_unique<QpackSendStream>(
GetNextOutgoingUnidirectionalStreamId(), this, kQpackDecoderStream);
qpack_decoder_send_stream_ = decoder_send.get();
ActivateStream(std::move(decoder_send));
@@ -986,7 +986,7 @@
if (!qpack_encoder_send_stream_ &&
CanOpenNextOutgoingUnidirectionalStream()) {
- auto encoder_send = QuicMakeUnique<QpackSendStream>(
+ auto encoder_send = std::make_unique<QpackSendStream>(
GetNextOutgoingUnidirectionalStreamId(), this, kQpackEncoderStream);
qpack_encoder_send_stream_ = encoder_send.get();
ActivateStream(std::move(encoder_send));
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 4b14600..e5d50b2 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -158,7 +158,7 @@
Initialize();
this->connection()->SetEncrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullEncrypter>(connection->perspective()));
+ std::make_unique<NullEncrypter>(connection->perspective()));
}
~TestSession() override { delete connection(); }
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index d77cfef..223442c 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -193,7 +193,7 @@
trailers_decompressed_(false),
trailers_consumed_(false),
priority_sent_(false),
- http_decoder_visitor_(QuicMakeUnique<HttpDecoderVisitor>(this)),
+ http_decoder_visitor_(std::make_unique<HttpDecoderVisitor>(this)),
decoder_(http_decoder_visitor_.get()),
sequencer_offset_(0),
is_decoder_processing_input_(false),
@@ -227,7 +227,7 @@
trailers_decompressed_(false),
trailers_consumed_(false),
priority_sent_(false),
- http_decoder_visitor_(QuicMakeUnique<HttpDecoderVisitor>(this)),
+ http_decoder_visitor_(std::make_unique<HttpDecoderVisitor>(this)),
decoder_(http_decoder_visitor_.get()),
sequencer_offset_(sequencer()->NumBytesConsumed()),
is_decoder_processing_input_(false),
@@ -871,7 +871,7 @@
sequencer()->MarkConsumed(body_manager_.OnNonBody(header_length));
qpack_decoded_headers_accumulator_ =
- QuicMakeUnique<QpackDecodedHeadersAccumulator>(
+ std::make_unique<QpackDecodedHeadersAccumulator>(
id(), spdy_session_->qpack_decoder(), this,
spdy_session_->max_inbound_header_list_size());
@@ -939,7 +939,7 @@
body_manager_.OnNonBody(header_length + push_id_length));
qpack_decoded_headers_accumulator_ =
- QuicMakeUnique<QpackDecodedHeadersAccumulator>(
+ std::make_unique<QpackDecodedHeadersAccumulator>(
id(), spdy_session_->qpack_decoder(), this,
spdy_session_->max_inbound_header_list_size());
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 572ba5c..3fcf853 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -179,7 +179,7 @@
// Return QPACK-encoded header block without using the dynamic table.
std::string EncodeQpackHeaders(const SpdyHeaderBlock& header) {
NoopQpackStreamSenderDelegate encoder_stream_sender_delegate;
- auto qpack_encoder = QuicMakeUnique<QpackEncoder>(session_.get());
+ auto qpack_encoder = std::make_unique<QpackEncoder>(session_.get());
qpack_encoder->set_qpack_stream_sender_delegate(
&encoder_stream_sender_delegate);
// QpackEncoder does not use the dynamic table by default,
@@ -196,7 +196,7 @@
Perspective perspective) {
connection_ = new StrictMock<MockQuicConnection>(
&helper_, &alarm_factory_, perspective, SupportedVersions(GetParam()));
- session_ = QuicMakeUnique<StrictMock<MockQuicSpdySession>>(connection_);
+ session_ = std::make_unique<StrictMock<MockQuicSpdySession>>(connection_);
session_->Initialize();
ON_CALL(*session_, WritevData(_, _, _, _, _))
.WillByDefault(Invoke(MockQuicSession::ConsumeData));
diff --git a/quic/core/legacy_quic_stream_id_manager_test.cc b/quic/core/legacy_quic_stream_id_manager_test.cc
index ca4491a..9b73519 100644
--- a/quic/core/legacy_quic_stream_id_manager_test.cc
+++ b/quic/core/legacy_quic_stream_id_manager_test.cc
@@ -22,7 +22,7 @@
connection_ = new MockQuicConnection(
&helper_, &alarm_factory_, perspective,
ParsedVersionOfIndex(CurrentSupportedVersions(), 0));
- session_ = QuicMakeUnique<StrictMock<MockQuicSession>>(connection_);
+ session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
manager_ = QuicSessionPeer::GetStreamIdManager(session_.get());
session_->Initialize();
}
diff --git a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
index a26a6c3..8527483 100644
--- a/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
+++ b/quic/core/qpack/fuzzer/qpack_round_trip_fuzzer.cc
@@ -369,7 +369,7 @@
expected_header_lists_.erase(it);
}
- auto verifying_decoder = QuicMakeUnique<VerifyingDecoder>(
+ auto verifying_decoder = std::make_unique<VerifyingDecoder>(
stream_id, this, &decoder_, std::move(expected_header_list));
auto result =
verifying_decoders_.insert({stream_id, std::move(verifying_decoder)});
diff --git a/quic/core/qpack/offline/qpack_offline_decoder.cc b/quic/core/qpack/offline/qpack_offline_decoder.cc
index dc2d864..c958725 100644
--- a/quic/core/qpack/offline/qpack_offline_decoder.cc
+++ b/quic/core/qpack/offline/qpack_offline_decoder.cc
@@ -19,8 +19,7 @@
namespace quic {
QpackOfflineDecoder::QpackOfflineDecoder()
- : encoder_stream_error_detected_(false),
- max_blocked_streams_(0) {}
+ : encoder_stream_error_detected_(false), max_blocked_streams_(0) {}
bool QpackOfflineDecoder::DecodeAndVerifyOfflineData(
QuicStringPiece input_filename,
@@ -92,8 +91,8 @@
<< "\" as an integer.";
return false;
}
- qpack_decoder_ = QuicMakeUnique<QpackDecoder>(maximum_dynamic_table_capacity,
- max_blocked_streams_, this);
+ qpack_decoder_ = std::make_unique<QpackDecoder>(
+ maximum_dynamic_table_capacity, max_blocked_streams_, this);
qpack_decoder_->set_qpack_stream_sender_delegate(
&decoder_stream_sender_delegate_);
@@ -141,7 +140,7 @@
return false;
}
} else {
- auto headers_handler = QuicMakeUnique<test::TestHeadersHandler>();
+ auto headers_handler = std::make_unique<test::TestHeadersHandler>();
auto progressive_decoder = qpack_decoder_->CreateProgressiveDecoder(
stream_id, headers_handler.get());
diff --git a/quic/core/qpack/qpack_decoder.cc b/quic/core/qpack/qpack_decoder.cc
index b20cbdf..e2e9d28 100644
--- a/quic/core/qpack/qpack_decoder.cc
+++ b/quic/core/qpack/qpack_decoder.cc
@@ -128,7 +128,7 @@
std::unique_ptr<QpackProgressiveDecoder> QpackDecoder::CreateProgressiveDecoder(
QuicStreamId stream_id,
QpackProgressiveDecoder::HeadersHandlerInterface* handler) {
- return QuicMakeUnique<QpackProgressiveDecoder>(
+ return std::make_unique<QpackProgressiveDecoder>(
stream_id, this, &header_table_, &decoder_stream_sender_, handler);
}
diff --git a/quic/core/qpack/qpack_progressive_decoder.cc b/quic/core/qpack/qpack_progressive_decoder.cc
index 51d98ff..5ce0612 100644
--- a/quic/core/qpack/qpack_progressive_decoder.cc
+++ b/quic/core/qpack/qpack_progressive_decoder.cc
@@ -23,7 +23,8 @@
HeadersHandlerInterface* handler)
: stream_id_(stream_id),
prefix_decoder_(
- QuicMakeUnique<QpackInstructionDecoder>(QpackPrefixLanguage(), this)),
+ std::make_unique<QpackInstructionDecoder>(QpackPrefixLanguage(),
+ this)),
instruction_decoder_(QpackRequestStreamLanguage(), this),
enforcer_(enforcer),
header_table_(header_table),
diff --git a/quic/core/quic_config.cc b/quic/core/quic_config.cc
index 22aef80..c62a00a 100644
--- a/quic/core/quic_config.cc
+++ b/quic/core/quic_config.cc
@@ -875,12 +875,12 @@
preferred_address.ipv4_socket_address = socket_address;
}
params->preferred_address =
- QuicMakeUnique<TransportParameters::PreferredAddress>(
+ std::make_unique<TransportParameters::PreferredAddress>(
preferred_address);
}
if (!params->google_quic_params) {
- params->google_quic_params = QuicMakeUnique<CryptoHandshakeMessage>();
+ params->google_quic_params = std::make_unique<CryptoHandshakeMessage>();
}
silent_close_.ToHandshakeMessage(params->google_quic_params.get());
initial_round_trip_time_us_.ToHandshakeMessage(
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 52b5f70..fce6b42 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -3322,7 +3322,7 @@
} else {
// Request using IETF QUIC PATH_CHALLENGE frame
transmitted_connectivity_probe_payload_ =
- QuicMakeUnique<QuicPathFrameBuffer>();
+ std::make_unique<QuicPathFrameBuffer>();
probing_packet =
packet_generator_.SerializePathChallengeConnectivityProbingPacket(
transmitted_connectivity_probe_payload_.get());
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 6df0f7d..31986f0 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -365,20 +365,20 @@
if (use_tagging_decrypter_) {
if (framer_.framer()->version().KnowsWhichDecrypterToUse()) {
- framer_.framer()->InstallDecrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingDecrypter>());
- framer_.framer()->InstallDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingDecrypter>());
- framer_.framer()->InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TaggingDecrypter>());
+ framer_.framer()->InstallDecrypter(
+ ENCRYPTION_INITIAL, std::make_unique<TaggingDecrypter>());
+ framer_.framer()->InstallDecrypter(
+ ENCRYPTION_ZERO_RTT, std::make_unique<TaggingDecrypter>());
+ framer_.framer()->InstallDecrypter(
+ ENCRYPTION_FORWARD_SECURE, std::make_unique<TaggingDecrypter>());
} else {
framer_.framer()->SetDecrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingDecrypter>());
+ std::make_unique<TaggingDecrypter>());
}
} else if (framer_.framer()->version().KnowsWhichDecrypterToUse()) {
framer_.framer()->InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_SERVER));
+ std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
}
EXPECT_TRUE(framer_.ProcessPacket(packet));
if (block_on_next_write_) {
@@ -610,7 +610,7 @@
notifier_(nullptr) {
writer->set_perspective(perspective);
SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullEncrypter>(perspective));
+ std::make_unique<NullEncrypter>(perspective));
SetDataProducer(&producer_);
}
TestConnection(const TestConnection&) = delete;
@@ -686,7 +686,7 @@
StreamSendingState state) {
ScopedPacketFlusher flusher(this);
DCHECK(encryption_level >= ENCRYPTION_ZERO_RTT);
- SetEncrypter(encryption_level, QuicMakeUnique<TaggingEncrypter>(0x01));
+ SetEncrypter(encryption_level, std::make_unique<TaggingEncrypter>(0x01));
SetDefaultEncryptionLevel(encryption_level);
struct iovec iov;
MakeIOVector(data, &iov);
@@ -826,7 +826,7 @@
void set_notifier(SimpleSessionNotifier* notifier) { notifier_ = notifier; }
void ReturnEffectivePeerAddressForNextPacket(const QuicSocketAddress& addr) {
- next_effective_peer_addr_ = QuicMakeUnique<QuicSocketAddress>(addr);
+ next_effective_peer_addr_ = std::make_unique<QuicSocketAddress>(addr);
}
bool PtoEnabled() {
@@ -968,15 +968,15 @@
for (EncryptionLevel level :
{ENCRYPTION_ZERO_RTT, ENCRYPTION_FORWARD_SECURE}) {
peer_creator_.SetEncrypter(
- level, QuicMakeUnique<NullEncrypter>(peer_framer_.perspective()));
+ level, std::make_unique<NullEncrypter>(peer_framer_.perspective()));
}
if (version().handshake_protocol == PROTOCOL_TLS1_3) {
connection_.SetEncrypter(
ENCRYPTION_INITIAL,
- QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT));
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
connection_.InstallDecrypter(
ENCRYPTION_INITIAL,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
+ std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
}
QuicFramerPeer::SetLastSerializedServerConnectionId(
QuicConnectionPeer::GetFramer(&connection_), connection_id_);
@@ -1040,7 +1040,7 @@
if (connection_.version().KnowsWhichDecrypterToUse()) {
connection_.InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
+ std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
}
}
@@ -1179,17 +1179,17 @@
ENCRYPTION_INITIAL) {
peer_framer_.SetEncrypter(
QuicPacketCreatorPeer::GetEncryptionLevel(&peer_creator_),
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
// Set the corresponding decrypter.
if (connection_.version().KnowsWhichDecrypterToUse()) {
connection_.InstallDecrypter(
QuicPacketCreatorPeer::GetEncryptionLevel(&peer_creator_),
- QuicMakeUnique<StrictTaggingDecrypter>(0x01));
+ std::make_unique<StrictTaggingDecrypter>(0x01));
connection_.RemoveDecrypter(ENCRYPTION_INITIAL);
} else {
connection_.SetDecrypter(
QuicPacketCreatorPeer::GetEncryptionLevel(&peer_creator_),
- QuicMakeUnique<StrictTaggingDecrypter>(0x01));
+ std::make_unique<StrictTaggingDecrypter>(0x01));
}
}
@@ -1315,7 +1315,7 @@
return;
}
std::unique_ptr<QuicRstStreamFrame> rst_stream =
- QuicMakeUnique<QuicRstStreamFrame>(1, id, error, bytes_written);
+ std::make_unique<QuicRstStreamFrame>(1, id, error, bytes_written);
if (connection_.SendControlFrame(QuicFrame(rst_stream.get()))) {
rst_stream.release();
}
@@ -3111,9 +3111,9 @@
// Process a data packet to cause the visitor's OnCanWrite to be invoked.
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
peer_framer_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
SetDecrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<StrictTaggingDecrypter>(0x01));
+ std::make_unique<StrictTaggingDecrypter>(0x01));
ProcessDataPacket(2);
EXPECT_EQ(0u, connection_.NumQueuedPackets());
@@ -4210,7 +4210,7 @@
// A TaggingEncrypter puts kTagSize copies of the given byte (0x01 here) at
// the end of the packet. We can test this to check which encrypter was used.
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
QuicByteCount packet_size;
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
.WillOnce(SaveArg<3>(&packet_size));
@@ -4219,7 +4219,7 @@
EXPECT_EQ(0x01010101u, writer_->final_bytes_of_last_packet());
connection_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
SendStreamDataToPeer(3, "foo", 0, NO_FIN, nullptr);
EXPECT_EQ(0x02020202u, writer_->final_bytes_of_last_packet());
@@ -4247,7 +4247,7 @@
// A TaggingEncrypter puts kTagSize copies of the given byte (0x01 here) at
// the end of the packet. We can test this to check which encrypter was used.
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
// Attempt to send a handshake message and have the socket block.
EXPECT_CALL(*send_algorithm_, CanSend(_)).WillRepeatedly(Return(true));
@@ -4258,7 +4258,7 @@
// Switch to the new encrypter.
connection_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
// Now become writeable and flush the packets.
@@ -4275,7 +4275,7 @@
DropRetransmitsForNullEncryptedPacketAfterForwardSecure) {
use_tagging_decrypter();
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
QuicPacketNumber packet_number;
connection_.SendCryptoStreamData();
@@ -4286,7 +4286,7 @@
// Go forward secure.
connection_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
connection_.SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
notifier_.NeuterUnencryptedData();
connection_.NeuterUnencryptedPackets();
@@ -4301,13 +4301,13 @@
TEST_P(QuicConnectionTest, RetransmitPacketsWithInitialEncryption) {
use_tagging_decrypter();
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
connection_.SendCryptoDataWithString("foo", 0);
connection_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
SendStreamDataToPeer(2, "bar", 0, NO_FIN, nullptr);
@@ -4329,7 +4329,7 @@
const uint8_t tag = 0x07;
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process an encrypted packet which can not yet be decrypted which should
// result in the packet being buffered.
@@ -4338,10 +4338,10 @@
// Transition to the new encryption state and process another encrypted packet
// which should result in the original packet being processed.
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
connection_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(2);
ProcessDataPacketAtLevel(2, !kHasStopWaiting, ENCRYPTION_ZERO_RTT);
@@ -4400,7 +4400,7 @@
const uint8_t tag = 0x07;
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process an encrypted packet which can not yet be decrypted which should
// result in the packet being buffered.
@@ -4412,11 +4412,11 @@
// which should result in the original packets being processed.
EXPECT_FALSE(connection_.GetProcessUndecryptablePacketsAlarm()->IsSet());
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
EXPECT_TRUE(connection_.GetProcessUndecryptablePacketsAlarm()->IsSet());
connection_.SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
connection_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(100);
connection_.GetProcessUndecryptablePacketsAlarm()->Fire();
@@ -5676,9 +5676,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -5716,9 +5716,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -5796,9 +5796,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -5855,9 +5855,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -5992,9 +5992,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -6045,9 +6045,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -6103,9 +6103,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -6167,9 +6167,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -6251,9 +6251,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -6319,9 +6319,9 @@
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
const uint8_t tag = 0x07;
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(tag));
+ std::make_unique<StrictTaggingDecrypter>(tag));
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(tag));
+ std::make_unique<TaggingEncrypter>(tag));
// Process a packet from the non-crypto stream.
frame1_.stream_id = 3;
@@ -6460,9 +6460,9 @@
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
EXPECT_CALL(visitor_, OnStreamFrame(_));
peer_framer_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
SetDecrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<StrictTaggingDecrypter>(0x01));
+ std::make_unique<StrictTaggingDecrypter>(0x01));
ProcessDataPacket(1);
connection_.SendStreamDataWithString(
GetNthClientInitiatedStreamId(1, connection_.transport_version()), "foo",
@@ -8409,7 +8409,7 @@
}
use_tagging_decrypter();
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
connection_.SendCryptoStreamData();
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ -8447,7 +8447,7 @@
}
use_tagging_decrypter();
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x01));
+ std::make_unique<TaggingEncrypter>(0x01));
connection_.SendCryptoStreamData();
EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ -8488,11 +8488,11 @@
ProcessCryptoPacketAtLevel(1000, ENCRYPTION_INITIAL);
EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(0x02));
+ std::make_unique<StrictTaggingDecrypter>(0x02));
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
// Receives packet 1000 in application data.
ProcessDataPacketAtLevel(1000, false, ENCRYPTION_ZERO_RTT);
EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
@@ -8508,7 +8508,7 @@
// Simulates ACK alarm fires and verify two ACKs are flushed.
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
connection_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
connection_.GetAckAlarm()->Fire();
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
// Receives more packets in application data.
@@ -8516,9 +8516,9 @@
EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
peer_framer_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
SetDecrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<StrictTaggingDecrypter>(0x02));
+ std::make_unique<StrictTaggingDecrypter>(0x02));
// Verify zero rtt and forward secure packets get acked in the same packet.
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
ProcessDataPacket(1003);
@@ -8539,11 +8539,11 @@
ProcessCryptoPacketAtLevel(1000, ENCRYPTION_INITIAL);
EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
peer_framer_.SetEncrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
SetDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<StrictTaggingDecrypter>(0x02));
+ std::make_unique<StrictTaggingDecrypter>(0x02));
connection_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
// Receives packet 1000 in application data.
ProcessDataPacketAtLevel(1000, false, ENCRYPTION_ZERO_RTT);
EXPECT_TRUE(connection_.GetAckAlarm()->IsSet());
@@ -8555,7 +8555,7 @@
clock_.AdvanceTime(DefaultDelayedAckTime());
EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
connection_.SetEncrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TaggingEncrypter>(0x02));
+ std::make_unique<TaggingEncrypter>(0x02));
connection_.GetAckAlarm()->Fire();
// Verify ACK alarm is not set.
EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
diff --git a/quic/core/quic_control_frame_manager_test.cc b/quic/core/quic_control_frame_manager_test.cc
index 8059ff6..5fe5de6 100644
--- a/quic/core/quic_control_frame_manager_test.cc
+++ b/quic/core/quic_control_frame_manager_test.cc
@@ -50,8 +50,8 @@
void Initialize() {
connection_ = new MockQuicConnection(&helper_, &alarm_factory_,
Perspective::IS_SERVER);
- session_ = QuicMakeUnique<StrictMock<MockQuicSession>>(connection_);
- manager_ = QuicMakeUnique<QuicControlFrameManager>(session_.get());
+ session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
+ manager_ = std::make_unique<QuicControlFrameManager>(session_.get());
EXPECT_EQ(0u, QuicControlFrameManagerPeer::QueueSize(manager_.get()));
EXPECT_FALSE(manager_->HasPendingRetransmission());
EXPECT_FALSE(manager_->WillingToWrite());
diff --git a/quic/core/quic_crypto_client_handshaker_test.cc b/quic/core/quic_crypto_client_handshaker_test.cc
index db6b181..b70ccb6 100644
--- a/quic/core/quic_crypto_client_handshaker_test.cc
+++ b/quic/core/quic_crypto_client_handshaker_test.cc
@@ -131,7 +131,7 @@
&alarm_factory_,
Perspective::IS_CLIENT)),
session_(connection_, false),
- crypto_client_config_(QuicMakeUnique<InsecureProofVerifier>()),
+ crypto_client_config_(std::make_unique<InsecureProofVerifier>()),
client_stream_(new QuicCryptoClientStream(server_id_,
&session_,
nullptr,
diff --git a/quic/core/quic_crypto_client_stream.cc b/quic/core/quic_crypto_client_stream.cc
index 8f89e9a..a05caee 100644
--- a/quic/core/quic_crypto_client_stream.cc
+++ b/quic/core/quic_crypto_client_stream.cc
@@ -37,12 +37,12 @@
DCHECK_EQ(Perspective::IS_CLIENT, session->connection()->perspective());
switch (session->connection()->version().handshake_protocol) {
case PROTOCOL_QUIC_CRYPTO:
- handshaker_ = QuicMakeUnique<QuicCryptoClientHandshaker>(
+ handshaker_ = std::make_unique<QuicCryptoClientHandshaker>(
server_id, this, session, std::move(verify_context), crypto_config,
proof_handler);
break;
case PROTOCOL_TLS1_3:
- handshaker_ = QuicMakeUnique<TlsClientHandshaker>(
+ handshaker_ = std::make_unique<TlsClientHandshaker>(
this, session, server_id, crypto_config->proof_verifier(),
crypto_config->ssl_ctx(), std::move(verify_context),
crypto_config->user_agent_id());
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index e9d0267..10b121a 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -48,7 +48,7 @@
// Advance the time, because timers do not like uninitialized times.
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
- session_ = QuicMakeUnique<TestQuicSpdyClientSession>(
+ session_ = std::make_unique<TestQuicSpdyClientSession>(
connection_, DefaultQuicConfig(), supported_versions_, server_id_,
&crypto_config_);
}
@@ -323,7 +323,7 @@
ParsedVersionOfIndex(supported_versions_, 1));
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
- session_ = QuicMakeUnique<TestQuicSpdyClientSession>(
+ session_ = std::make_unique<TestQuicSpdyClientSession>(
connection_, DefaultQuicConfig(), supported_versions_, server_id_,
&crypto_config_);
CompleteCryptoHandshake();
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index 353de98..266bb90 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -122,11 +122,11 @@
CHECK(!handshaker_);
switch (session()->connection()->version().handshake_protocol) {
case PROTOCOL_QUIC_CRYPTO:
- handshaker_ = QuicMakeUnique<QuicCryptoServerHandshaker>(
+ handshaker_ = std::make_unique<QuicCryptoServerHandshaker>(
crypto_config_, this, compressed_certs_cache_, session(), helper_);
break;
case PROTOCOL_TLS1_3:
- handshaker_ = QuicMakeUnique<TlsServerHandshaker>(
+ handshaker_ = std::make_unique<TlsServerHandshaker>(
this, session(), crypto_config_->ssl_ctx(),
crypto_config_->proof_source());
break;
diff --git a/quic/core/quic_crypto_server_stream_test.cc b/quic/core/quic_crypto_server_stream_test.cc
index b58d987..a4cc69e 100644
--- a/quic/core/quic_crypto_server_stream_test.cc
+++ b/quic/core/quic_crypto_server_stream_test.cc
@@ -79,8 +79,8 @@
// called multiple times.
void InitializeServer() {
TestQuicSpdyServerSession* server_session = nullptr;
- helpers_.push_back(QuicMakeUnique<NiceMock<MockQuicConnectionHelper>>());
- alarm_factories_.push_back(QuicMakeUnique<MockAlarmFactory>());
+ helpers_.push_back(std::make_unique<NiceMock<MockQuicConnectionHelper>>());
+ alarm_factories_.push_back(std::make_unique<MockAlarmFactory>());
CreateServerSessionForTest(
server_id_, QuicTime::Delta::FromSeconds(100000), supported_versions_,
helpers_.back().get(), alarm_factories_.back().get(),
@@ -109,8 +109,8 @@
// testing. May be called multiple times.
void InitializeFakeClient() {
TestQuicSpdyClientSession* client_session = nullptr;
- helpers_.push_back(QuicMakeUnique<NiceMock<MockQuicConnectionHelper>>());
- alarm_factories_.push_back(QuicMakeUnique<MockAlarmFactory>());
+ helpers_.push_back(std::make_unique<NiceMock<MockQuicConnectionHelper>>());
+ alarm_factories_.push_back(std::make_unique<MockAlarmFactory>());
CreateClientSessionForTest(
server_id_, QuicTime::Delta::FromSeconds(100000), supported_versions_,
helpers_.back().get(), alarm_factories_.back().get(),
diff --git a/quic/core/quic_crypto_stream_test.cc b/quic/core/quic_crypto_stream_test.cc
index af5a8cc..0661c19 100644
--- a/quic/core/quic_crypto_stream_test.cc
+++ b/quic/core/quic_crypto_stream_test.cc
@@ -217,7 +217,7 @@
// Send [1350, 2700) in ENCRYPTION_ZERO_RTT.
connection_->SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
std::unique_ptr<NullEncrypter> encrypter =
- QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT);
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT);
connection_->SetEncrypter(ENCRYPTION_ZERO_RTT, std::move(encrypter));
EXPECT_EQ(ENCRYPTION_ZERO_RTT, connection_->encryption_level());
EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 1350, 0))
@@ -309,7 +309,7 @@
// Send [1350, 2700) in ENCRYPTION_ZERO_RTT.
connection_->SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
std::unique_ptr<NullEncrypter> encrypter =
- QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT);
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT);
connection_->SetEncrypter(ENCRYPTION_ZERO_RTT, std::move(encrypter));
EXPECT_EQ(ENCRYPTION_ZERO_RTT, connection_->encryption_level());
EXPECT_CALL(*connection_, SendCryptoData(_, _, _)).Times(0);
@@ -426,7 +426,7 @@
// Send [1350, 2700) in ENCRYPTION_ZERO_RTT.
connection_->SetDefaultEncryptionLevel(ENCRYPTION_ZERO_RTT);
std::unique_ptr<NullEncrypter> encrypter =
- QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT);
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT);
connection_->SetEncrypter(ENCRYPTION_ZERO_RTT, std::move(encrypter));
EXPECT_EQ(ENCRYPTION_ZERO_RTT, connection_->encryption_level());
EXPECT_CALL(*connection_, SendCryptoData(ENCRYPTION_ZERO_RTT, 1350, 0))
diff --git a/quic/core/quic_dispatcher_test.cc b/quic/core/quic_dispatcher_test.cc
index d0e5092..144bffb 100644
--- a/quic/core/quic_dispatcher_test.cc
+++ b/quic/core/quic_dispatcher_test.cc
@@ -116,10 +116,10 @@
: QuicDispatcher(config,
crypto_config,
version_manager,
- QuicMakeUnique<MockQuicConnectionHelper>(),
+ std::make_unique<MockQuicConnectionHelper>(),
std::unique_ptr<QuicCryptoServerStream::Helper>(
new QuicSimpleCryptoServerStreamHelper()),
- QuicMakeUnique<MockAlarmFactory>(),
+ std::make_unique<MockAlarmFactory>(),
kQuicDefaultConnectionIdLength),
random_(random) {}
@@ -137,7 +137,7 @@
};
std::unique_ptr<QuicPerPacketContext> GetPerPacketContext() const override {
- auto test_context = QuicMakeUnique<TestQuicPerPacketContext>();
+ auto test_context = std::make_unique<TestQuicPerPacketContext>();
test_context->custom_packet_context = custom_packet_context_;
return std::move(test_context);
}
diff --git a/quic/core/quic_flow_controller_test.cc b/quic/core/quic_flow_controller_test.cc
index 299f922..0908246 100644
--- a/quic/core/quic_flow_controller_test.cc
+++ b/quic/core/quic_flow_controller_test.cc
@@ -39,8 +39,8 @@
void Initialize() {
connection_ = new MockQuicConnection(&helper_, &alarm_factory_,
Perspective::IS_CLIENT);
- session_ = QuicMakeUnique<MockQuicSession>(connection_);
- flow_controller_ = QuicMakeUnique<QuicFlowController>(
+ session_ = std::make_unique<MockQuicSession>(connection_);
+ flow_controller_ = std::make_unique<QuicFlowController>(
session_.get(), stream_id_, /*is_connection_flow_controller*/ false,
send_window_, receive_window_, kStreamReceiveWindowLimit,
should_auto_tune_receive_window_, &session_flow_controller_);
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 3a1be5e..727917b 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -430,8 +430,8 @@
current_received_frame_type_(0) {
DCHECK(!supported_versions.empty());
version_ = supported_versions_[0];
- decrypter_[ENCRYPTION_INITIAL] = QuicMakeUnique<NullDecrypter>(perspective);
- encrypter_[ENCRYPTION_INITIAL] = QuicMakeUnique<NullEncrypter>(perspective);
+ decrypter_[ENCRYPTION_INITIAL] = std::make_unique<NullDecrypter>(perspective);
+ encrypter_[ENCRYPTION_INITIAL] = std::make_unique<NullEncrypter>(perspective);
}
QuicFramer::~QuicFramer() {}
@@ -1239,7 +1239,7 @@
for (const QuicPathFrameBuffer& payload : payloads) {
// Note that the control frame ID can be 0 since this is not retransmitted.
path_response_frames.push_back(
- QuicMakeUnique<QuicPathResponseFrame>(0, payload));
+ std::make_unique<QuicPathResponseFrame>(0, payload));
}
QuicFrames frames;
@@ -1300,7 +1300,7 @@
return nullptr;
}
- return QuicMakeUnique<QuicEncryptedPacket>(buffer.release(), len, true);
+ return std::make_unique<QuicEncryptedPacket>(buffer.release(), len, true);
}
// static
@@ -1334,7 +1334,7 @@
sizeof(stateless_reset_token))) {
return nullptr;
}
- return QuicMakeUnique<QuicEncryptedPacket>(buffer.release(), len, true);
+ return std::make_unique<QuicEncryptedPacket>(buffer.release(), len, true);
}
// static
@@ -1408,7 +1408,7 @@
}
}
- return QuicMakeUnique<QuicEncryptedPacket>(buffer.release(), len, true);
+ return std::make_unique<QuicEncryptedPacket>(buffer.release(), len, true);
}
// static
@@ -1457,7 +1457,7 @@
}
}
- return QuicMakeUnique<QuicEncryptedPacket>(buffer.release(), len, true);
+ return std::make_unique<QuicEncryptedPacket>(buffer.release(), len, true);
}
bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index bcb717f..f288441 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -196,14 +196,14 @@
void OnPacket() override {}
void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
- public_reset_packet_ = QuicMakeUnique<QuicPublicResetPacket>((packet));
+ public_reset_packet_ = std::make_unique<QuicPublicResetPacket>((packet));
EXPECT_EQ(0u, framer_->current_received_frame_type());
}
void OnVersionNegotiationPacket(
const QuicVersionNegotiationPacket& packet) override {
version_negotiation_packet_ =
- QuicMakeUnique<QuicVersionNegotiationPacket>((packet));
+ std::make_unique<QuicVersionNegotiationPacket>((packet));
EXPECT_EQ(0u, framer_->current_received_frame_type());
}
@@ -211,10 +211,10 @@
QuicConnectionId new_connection_id,
QuicStringPiece retry_token) override {
retry_original_connection_id_ =
- QuicMakeUnique<QuicConnectionId>(original_connection_id);
+ std::make_unique<QuicConnectionId>(original_connection_id);
retry_new_connection_id_ =
- QuicMakeUnique<QuicConnectionId>(new_connection_id);
- retry_token_ = QuicMakeUnique<std::string>(std::string(retry_token));
+ std::make_unique<QuicConnectionId>(new_connection_id);
+ retry_token_ = std::make_unique<std::string>(std::string(retry_token));
EXPECT_EQ(0u, framer_->current_received_frame_type());
}
@@ -227,7 +227,7 @@
}
bool OnUnauthenticatedPublicHeader(const QuicPacketHeader& header) override {
- header_ = QuicMakeUnique<QuicPacketHeader>((header));
+ header_ = std::make_unique<QuicPacketHeader>((header));
EXPECT_EQ(0u, framer_->current_received_frame_type());
return accept_public_header_;
}
@@ -243,7 +243,7 @@
bool OnPacketHeader(const QuicPacketHeader& header) override {
++packet_count_;
- header_ = QuicMakeUnique<QuicPacketHeader>((header));
+ header_ = std::make_unique<QuicPacketHeader>((header));
EXPECT_EQ(0u, framer_->current_received_frame_type());
return accept_packet_;
}
@@ -266,7 +266,7 @@
std::string* string_data =
new std::string(frame.data_buffer, frame.data_length);
stream_data_.push_back(QuicWrapUnique(string_data));
- stream_frames_.push_back(QuicMakeUnique<QuicStreamFrame>(
+ stream_frames_.push_back(std::make_unique<QuicStreamFrame>(
frame.stream_id, frame.fin, frame.offset, *string_data));
if (VersionHasIetfQuicFrames(transport_version_)) {
// Low order bits of type encode flags, ignore them for this test.
@@ -283,7 +283,7 @@
std::string* string_data =
new std::string(frame.data_buffer, frame.data_length);
crypto_data_.push_back(QuicWrapUnique(string_data));
- crypto_frames_.push_back(QuicMakeUnique<QuicCryptoFrame>(
+ crypto_frames_.push_back(std::make_unique<QuicCryptoFrame>(
ENCRYPTION_INITIAL, frame.offset, *string_data));
if (VersionHasIetfQuicFrames(transport_version_)) {
EXPECT_EQ(IETF_CRYPTO, framer_->current_received_frame_type());
@@ -299,7 +299,7 @@
QuicAckFrame ack_frame;
ack_frame.largest_acked = largest_acked;
ack_frame.ack_delay_time = ack_delay_time;
- ack_frames_.push_back(QuicMakeUnique<QuicAckFrame>(ack_frame));
+ ack_frames_.push_back(std::make_unique<QuicAckFrame>(ack_frame));
if (VersionHasIetfQuicFrames(transport_version_)) {
EXPECT_EQ(IETF_ACK, framer_->current_received_frame_type());
} else {
@@ -331,13 +331,14 @@
bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
++frame_count_;
- stop_waiting_frames_.push_back(QuicMakeUnique<QuicStopWaitingFrame>(frame));
+ stop_waiting_frames_.push_back(
+ std::make_unique<QuicStopWaitingFrame>(frame));
EXPECT_EQ(0u, framer_->current_received_frame_type());
return true;
}
bool OnPaddingFrame(const QuicPaddingFrame& frame) override {
- padding_frames_.push_back(QuicMakeUnique<QuicPaddingFrame>(frame));
+ padding_frames_.push_back(std::make_unique<QuicPaddingFrame>(frame));
if (VersionHasIetfQuicFrames(transport_version_)) {
EXPECT_EQ(IETF_PADDING, framer_->current_received_frame_type());
} else {
@@ -348,7 +349,7 @@
bool OnPingFrame(const QuicPingFrame& frame) override {
++frame_count_;
- ping_frames_.push_back(QuicMakeUnique<QuicPingFrame>(frame));
+ ping_frames_.push_back(std::make_unique<QuicPingFrame>(frame));
if (VersionHasIetfQuicFrames(transport_version_)) {
EXPECT_EQ(IETF_PING, framer_->current_received_frame_type());
} else {
@@ -360,7 +361,7 @@
bool OnMessageFrame(const QuicMessageFrame& frame) override {
++frame_count_;
message_frames_.push_back(
- QuicMakeUnique<QuicMessageFrame>(frame.data, frame.message_length));
+ std::make_unique<QuicMessageFrame>(frame.data, frame.message_length));
if (VersionHasIetfQuicFrames(transport_version_)) {
EXPECT_TRUE(IETF_EXTENSION_MESSAGE_NO_LENGTH ==
framer_->current_received_frame_type() ||
@@ -504,7 +505,7 @@
void OnAuthenticatedIetfStatelessResetPacket(
const QuicIetfStatelessResetPacket& packet) override {
stateless_reset_packet_ =
- QuicMakeUnique<QuicIetfStatelessResetPacket>(packet);
+ std::make_unique<QuicIetfStatelessResetPacket>(packet);
EXPECT_EQ(0u, framer_->current_received_frame_type());
}
@@ -703,7 +704,7 @@
memcpy(buffer + len, fragment.fragment.data(), fragment.fragment.size());
len += fragment.fragment.size();
}
- return QuicMakeUnique<QuicEncryptedPacket>(buffer, len, true);
+ return std::make_unique<QuicEncryptedPacket>(buffer, len, true);
}
void CheckFramingBoundaries(const PacketFragments& fragments,
@@ -2213,13 +2214,14 @@
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
decrypter_ = new test::TestDecrypter();
if (framer_.version().KnowsWhichDecrypterToUse()) {
- framer_.InstallDecrypter(ENCRYPTION_INITIAL, QuicMakeUnique<NullDecrypter>(
- Perspective::IS_CLIENT));
+ framer_.InstallDecrypter(
+ ENCRYPTION_INITIAL,
+ std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
framer_.InstallDecrypter(ENCRYPTION_ZERO_RTT,
std::unique_ptr<QuicDecrypter>(decrypter_));
} else {
- framer_.SetDecrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
+ framer_.SetDecrypter(ENCRYPTION_INITIAL, std::make_unique<NullDecrypter>(
+ Perspective::IS_CLIENT));
framer_.SetAlternativeDecrypter(
ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
}
@@ -5230,13 +5232,14 @@
TestConnectionId(0x33));
decrypter_ = new test::TestDecrypter();
if (framer_.version().KnowsWhichDecrypterToUse()) {
- framer_.InstallDecrypter(ENCRYPTION_INITIAL, QuicMakeUnique<NullDecrypter>(
- Perspective::IS_CLIENT));
+ framer_.InstallDecrypter(
+ ENCRYPTION_INITIAL,
+ std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
framer_.InstallDecrypter(ENCRYPTION_ZERO_RTT,
std::unique_ptr<QuicDecrypter>(decrypter_));
} else {
- framer_.SetDecrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
+ framer_.SetDecrypter(ENCRYPTION_INITIAL, std::make_unique<NullDecrypter>(
+ Perspective::IS_CLIENT));
framer_.SetAlternativeDecrypter(
ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
}
@@ -5272,13 +5275,14 @@
QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
decrypter_ = new test::TestDecrypter();
if (framer_.version().KnowsWhichDecrypterToUse()) {
- framer_.InstallDecrypter(ENCRYPTION_INITIAL, QuicMakeUnique<NullDecrypter>(
- Perspective::IS_CLIENT));
+ framer_.InstallDecrypter(
+ ENCRYPTION_INITIAL,
+ std::make_unique<NullDecrypter>(Perspective::IS_CLIENT));
framer_.InstallDecrypter(ENCRYPTION_ZERO_RTT,
std::unique_ptr<QuicDecrypter>(decrypter_));
} else {
- framer_.SetDecrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
+ framer_.SetDecrypter(ENCRYPTION_INITIAL, std::make_unique<NullDecrypter>(
+ Perspective::IS_CLIENT));
framer_.SetAlternativeDecrypter(
ENCRYPTION_ZERO_RTT, std::unique_ptr<QuicDecrypter>(decrypter_), false);
}
@@ -9394,10 +9398,10 @@
if (framer_.version().KnowsWhichDecrypterToUse()) {
framer_.InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(framer_.perspective()));
+ std::make_unique<NullDecrypter>(framer_.perspective()));
} else {
- framer_.SetDecrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<NullDecrypter>(framer_.perspective()));
+ framer_.SetDecrypter(ENCRYPTION_INITIAL, std::make_unique<NullDecrypter>(
+ framer_.perspective()));
}
ParsedQuicVersionVector versions;
versions.push_back(framer_.version());
@@ -9438,13 +9442,13 @@
if (framer_.version().KnowsWhichDecrypterToUse()) {
framer_.InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(framer_.perspective()));
+ std::make_unique<NullDecrypter>(framer_.perspective()));
} else {
- framer_.SetDecrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<NullDecrypter>(framer_.perspective()));
+ framer_.SetDecrypter(ENCRYPTION_INITIAL, std::make_unique<NullDecrypter>(
+ framer_.perspective()));
}
framer_.SetEncrypter(ENCRYPTION_INITIAL,
- QuicMakeUnique<NullEncrypter>(framer_.perspective()));
+ std::make_unique<NullEncrypter>(framer_.perspective()));
ParsedQuicVersionVector versions;
versions.push_back(framer_.version());
std::unique_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
@@ -12891,10 +12895,11 @@
if (framer_.version().KnowsWhichDecrypterToUse()) {
framer_.InstallDecrypter(ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<TestDecrypter>());
+ std::make_unique<TestDecrypter>());
framer_.RemoveDecrypter(ENCRYPTION_INITIAL);
} else {
- framer_.SetDecrypter(ENCRYPTION_ZERO_RTT, QuicMakeUnique<TestDecrypter>());
+ framer_.SetDecrypter(ENCRYPTION_ZERO_RTT,
+ std::make_unique<TestDecrypter>());
}
if (!QuicVersionHasLongHeaderLengths(framer_.transport_version())) {
EXPECT_TRUE(framer_.ProcessPacket(
@@ -12933,11 +12938,11 @@
AsChars(short_header_packet), QUIC_ARRAYSIZE(short_header_packet), false);
if (framer_.version().KnowsWhichDecrypterToUse()) {
framer_.InstallDecrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TestDecrypter>());
+ std::make_unique<TestDecrypter>());
framer_.RemoveDecrypter(ENCRYPTION_ZERO_RTT);
} else {
framer_.SetDecrypter(ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<TestDecrypter>());
+ std::make_unique<TestDecrypter>());
}
EXPECT_TRUE(framer_.ProcessPacket(short_header_encrypted));
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 1da89ba..5b58b5f 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -156,26 +156,26 @@
serialized_packet_(creator_.NoPacket()) {
QuicPacketCreatorPeer::EnableGetPacketHeaderSizeBugFix(&creator_);
EXPECT_CALL(delegate_, GetPacketBuffer()).WillRepeatedly(Return(nullptr));
- creator_.SetEncrypter(ENCRYPTION_HANDSHAKE, QuicMakeUnique<NullEncrypter>(
+ creator_.SetEncrypter(ENCRYPTION_HANDSHAKE, std::make_unique<NullEncrypter>(
Perspective::IS_CLIENT));
- creator_.SetEncrypter(ENCRYPTION_ZERO_RTT, QuicMakeUnique<NullEncrypter>(
+ creator_.SetEncrypter(ENCRYPTION_ZERO_RTT, std::make_unique<NullEncrypter>(
Perspective::IS_CLIENT));
creator_.SetEncrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT));
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
client_framer_.set_visitor(&framer_visitor_);
server_framer_.set_visitor(&framer_visitor_);
client_framer_.set_data_producer(&producer_);
if (server_framer_.version().KnowsWhichDecrypterToUse()) {
server_framer_.InstallDecrypter(
ENCRYPTION_ZERO_RTT,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_SERVER));
+ std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
server_framer_.InstallDecrypter(
ENCRYPTION_HANDSHAKE,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_SERVER));
+ std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
server_framer_.InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_SERVER));
+ std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
}
}
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index c60bac2..d1edfcb 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -207,13 +207,13 @@
EXPECT_CALL(delegate_, GetPacketBuffer()).WillRepeatedly(Return(nullptr));
creator_->SetEncrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT));
+ std::make_unique<NullEncrypter>(Perspective::IS_CLIENT));
creator_->set_encryption_level(ENCRYPTION_FORWARD_SECURE);
framer_.set_data_producer(&producer_);
if (simple_framer_.framer()->version().KnowsWhichDecrypterToUse()) {
simple_framer_.framer()->InstallDecrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullDecrypter>(Perspective::IS_SERVER));
+ std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
}
generator_.AttachPacketFlusher();
}
diff --git a/quic/core/quic_packets.cc b/quic/core/quic_packets.cc
index 2d6d0c9..c4ef81a 100644
--- a/quic/core/quic_packets.cc
+++ b/quic/core/quic_packets.cc
@@ -339,7 +339,7 @@
std::unique_ptr<QuicEncryptedPacket> QuicEncryptedPacket::Clone() const {
char* buffer = new char[this->length()];
memcpy(buffer, this->data(), this->length());
- return QuicMakeUnique<QuicEncryptedPacket>(buffer, this->length(), true);
+ return std::make_unique<QuicEncryptedPacket>(buffer, this->length(), true);
}
std::ostream& operator<<(std::ostream& os, const QuicEncryptedPacket& s) {
@@ -410,12 +410,12 @@
if (this->packet_headers()) {
char* headers_buffer = new char[this->headers_length()];
memcpy(headers_buffer, this->packet_headers(), this->headers_length());
- return QuicMakeUnique<QuicReceivedPacket>(
+ return std::make_unique<QuicReceivedPacket>(
buffer, this->length(), receipt_time(), true, ttl(), ttl() >= 0,
headers_buffer, this->headers_length(), true);
}
- return QuicMakeUnique<QuicReceivedPacket>(
+ return std::make_unique<QuicReceivedPacket>(
buffer, this->length(), receipt_time(), true, ttl(), ttl() >= 0);
}
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 50ecd9d..8fe02a7 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -734,7 +734,7 @@
}
TEST_P(QuicSentPacketManagerTest, AckOriginalTransmission) {
- auto loss_algorithm = QuicMakeUnique<MockLossAlgorithm>();
+ auto loss_algorithm = std::make_unique<MockLossAlgorithm>();
QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
SendDataPacket(1);
@@ -2108,7 +2108,7 @@
}
TEST_P(QuicSentPacketManagerTest, GetLossDelay) {
- auto loss_algorithm = QuicMakeUnique<MockLossAlgorithm>();
+ auto loss_algorithm = std::make_unique<MockLossAlgorithm>();
QuicSentPacketManagerPeer::SetLossAlgorithm(&manager_, loss_algorithm.get());
EXPECT_CALL(*loss_algorithm, GetLossTimeout())
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index b342e3d..619840b 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -1327,7 +1327,7 @@
return nullptr;
}
- auto pending = QuicMakeUnique<PendingStream>(stream_id, this);
+ auto pending = std::make_unique<PendingStream>(stream_id, this);
PendingStream* unowned_pending = pending.get();
pending_stream_map_[stream_id] = std::move(pending);
return unowned_pending;
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 4e419da..a75d948 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -151,7 +151,7 @@
Initialize();
this->connection()->SetEncrypter(
ENCRYPTION_FORWARD_SECURE,
- QuicMakeUnique<NullEncrypter>(connection->perspective()));
+ std::make_unique<NullEncrypter>(connection->perspective()));
}
~TestSession() override {
@@ -1386,8 +1386,9 @@
}
QuicStreamId headers_stream_id =
QuicUtils::GetHeadersStreamId(connection_->transport_version());
- std::unique_ptr<TestStream> fake_headers_stream = QuicMakeUnique<TestStream>(
- headers_stream_id, &session_, /*is_static*/ true, BIDIRECTIONAL);
+ std::unique_ptr<TestStream> fake_headers_stream =
+ std::make_unique<TestStream>(headers_stream_id, &session_,
+ /*is_static*/ true, BIDIRECTIONAL);
QuicSessionPeer::ActivateStream(&session_, std::move(fake_headers_stream));
// Send two bytes of payload.
QuicStreamFrame data1(headers_stream_id, true, 0, QuicStringPiece("HT"));
@@ -1404,8 +1405,9 @@
}
QuicStreamId headers_stream_id =
QuicUtils::GetHeadersStreamId(connection_->transport_version());
- std::unique_ptr<TestStream> fake_headers_stream = QuicMakeUnique<TestStream>(
- headers_stream_id, &session_, /*is_static*/ true, BIDIRECTIONAL);
+ std::unique_ptr<TestStream> fake_headers_stream =
+ std::make_unique<TestStream>(headers_stream_id, &session_,
+ /*is_static*/ true, BIDIRECTIONAL);
QuicSessionPeer::ActivateStream(&session_, std::move(fake_headers_stream));
// Send two bytes of payload.
QuicRstStreamFrame rst1(kInvalidControlFrameId, headers_stream_id,
@@ -2612,7 +2614,7 @@
return;
}
QuicStreamId stream_id = 0;
- std::unique_ptr<TestStream> fake_static_stream = QuicMakeUnique<TestStream>(
+ std::unique_ptr<TestStream> fake_static_stream = std::make_unique<TestStream>(
stream_id, &session_, /*is_static*/ true, BIDIRECTIONAL);
QuicSessionPeer::ActivateStream(&session_, std::move(fake_static_stream));
// Check that a stream id in the static stream map is ignored.
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index d8e1b78..06eb141 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -110,7 +110,7 @@
ParsedQuicVersionVector(
{{PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99}}))) {
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
- session_ = QuicMakeUnique<TestQuicSession>(connection_);
+ session_ = std::make_unique<TestQuicSession>(connection_);
stream_id_manager_ =
IsBidi() ? QuicSessionPeer::v99_bidirectional_stream_id_manager(
session_.get())
diff --git a/quic/core/quic_stream_sequencer_buffer_test.cc b/quic/core/quic_stream_sequencer_buffer_test.cc
index a7872dd..80d6309 100644
--- a/quic/core/quic_stream_sequencer_buffer_test.cc
+++ b/quic/core/quic_stream_sequencer_buffer_test.cc
@@ -67,8 +67,9 @@
protected:
void Initialize() {
- buffer_ = QuicMakeUnique<QuicStreamSequencerBuffer>((max_capacity_bytes_));
- helper_ = QuicMakeUnique<QuicStreamSequencerBufferPeer>((buffer_.get()));
+ buffer_ =
+ std::make_unique<QuicStreamSequencerBuffer>((max_capacity_bytes_));
+ helper_ = std::make_unique<QuicStreamSequencerBufferPeer>((buffer_.get()));
}
// Use 2.5 here to make sure the buffer has more than one block and its end
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index d371866..ff65db3 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -82,7 +82,7 @@
connection_ = new StrictMock<MockQuicConnection>(
&helper_, &alarm_factory_, Perspective::IS_SERVER, version_vector);
connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
- session_ = QuicMakeUnique<StrictMock<MockQuicSession>>(connection_);
+ session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
// New streams rely on having the peer's flow control receive window
// negotiated in the config.
diff --git a/quic/core/quic_time_wait_list_manager.cc b/quic/core/quic_time_wait_list_manager.cc
index f4a4f89..b163185 100644
--- a/quic/core/quic_time_wait_list_manager.cc
+++ b/quic/core/quic_time_wait_list_manager.cc
@@ -184,7 +184,7 @@
}
for (const auto& packet : connection_data->termination_packets) {
- SendOrQueuePacket(QuicMakeUnique<QueuedPacket>(
+ SendOrQueuePacket(std::make_unique<QueuedPacket>(
self_address, peer_address, packet->Clone()),
packet_context.get());
}
@@ -222,8 +222,8 @@
<< "use_length_prefix:" << std::endl
<< QuicTextUtils::HexDump(QuicStringPiece(
version_packet->data(), version_packet->length()));
- SendOrQueuePacket(QuicMakeUnique<QueuedPacket>(self_address, peer_address,
- std::move(version_packet)),
+ SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address,
+ std::move(version_packet)),
packet_context.get());
}
@@ -248,8 +248,8 @@
QuicStringPiece(ietf_reset_packet->data(),
ietf_reset_packet->length()));
SendOrQueuePacket(
- QuicMakeUnique<QueuedPacket>(self_address, peer_address,
- std::move(ietf_reset_packet)),
+ std::make_unique<QueuedPacket>(self_address, peer_address,
+ std::move(ietf_reset_packet)),
packet_context.get());
return;
}
@@ -266,8 +266,8 @@
<< std::endl
<< QuicTextUtils::HexDump(QuicStringPiece(
reset_packet->data(), reset_packet->length()));
- SendOrQueuePacket(QuicMakeUnique<QueuedPacket>(self_address, peer_address,
- std::move(reset_packet)),
+ SendOrQueuePacket(std::make_unique<QueuedPacket>(self_address, peer_address,
+ std::move(reset_packet)),
packet_context.get());
}
diff --git a/quic/core/quic_time_wait_list_manager_test.cc b/quic/core/quic_time_wait_list_manager_test.cc
index 4caae88..57541ee 100644
--- a/quic/core/quic_time_wait_list_manager_test.cc
+++ b/quic/core/quic_time_wait_list_manager_test.cc
@@ -174,7 +174,7 @@
void ProcessPacket(QuicConnectionId connection_id) {
time_wait_list_manager_.ProcessPacket(
self_address_, peer_address_, connection_id, GOOGLE_QUIC_PACKET,
- QuicMakeUnique<QuicPerPacketContext>());
+ std::make_unique<QuicPerPacketContext>());
}
QuicEncryptedPacket* ConstructEncryptedPacket(
@@ -261,7 +261,7 @@
time_wait_list_manager_.SendVersionNegotiationPacket(
connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/false,
/*use_length_prefix=*/false, AllSupportedVersions(), self_address_,
- peer_address_, QuicMakeUnique<QuicPerPacketContext>());
+ peer_address_, std::make_unique<QuicPerPacketContext>());
EXPECT_EQ(0u, time_wait_list_manager_.num_connections());
}
@@ -278,7 +278,7 @@
time_wait_list_manager_.SendVersionNegotiationPacket(
connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
/*use_length_prefix=*/false, AllSupportedVersions(), self_address_,
- peer_address_, QuicMakeUnique<QuicPerPacketContext>());
+ peer_address_, std::make_unique<QuicPerPacketContext>());
EXPECT_EQ(0u, time_wait_list_manager_.num_connections());
}
@@ -294,7 +294,7 @@
time_wait_list_manager_.SendVersionNegotiationPacket(
connection_id_, EmptyQuicConnectionId(), /*ietf_quic=*/true,
/*use_length_prefix=*/true, AllSupportedVersions(), self_address_,
- peer_address_, QuicMakeUnique<QuicPerPacketContext>());
+ peer_address_, std::make_unique<QuicPerPacketContext>());
EXPECT_EQ(0u, time_wait_list_manager_.num_connections());
}
@@ -311,7 +311,7 @@
time_wait_list_manager_.SendVersionNegotiationPacket(
connection_id_, TestConnectionId(0x33), /*ietf_quic=*/true,
/*use_length_prefix=*/true, AllSupportedVersions(), self_address_,
- peer_address_, QuicMakeUnique<QuicPerPacketContext>());
+ peer_address_, std::make_unique<QuicPerPacketContext>());
EXPECT_EQ(0u, time_wait_list_manager_.num_connections());
}
@@ -643,7 +643,7 @@
// Processes IETF short header packet.
time_wait_list_manager_.ProcessPacket(
self_address_, peer_address_, connection_id_,
- IETF_QUIC_SHORT_HEADER_PACKET, QuicMakeUnique<QuicPerPacketContext>());
+ IETF_QUIC_SHORT_HEADER_PACKET, std::make_unique<QuicPerPacketContext>());
}
} // namespace
diff --git a/quic/core/quic_write_blocked_list.cc b/quic/core/quic_write_blocked_list.cc
index 8e4bcf1..123a963 100644
--- a/quic/core/quic_write_blocked_list.cc
+++ b/quic/core/quic_write_blocked_list.cc
@@ -11,7 +11,7 @@
QuicWriteBlockedList::QuicWriteBlockedList(QuicTransportVersion version)
: priority_write_scheduler_(
- QuicMakeUnique<spdy::PriorityWriteScheduler<QuicStreamId>>(
+ std::make_unique<spdy::PriorityWriteScheduler<QuicStreamId>>(
QuicVersionUsesCryptoFrames(version)
? std::numeric_limits<QuicStreamId>::max()
: 0)),
diff --git a/quic/core/tls_handshaker_test.cc b/quic/core/tls_handshaker_test.cc
index a298089..6b7633f 100644
--- a/quic/core/tls_handshaker_test.cc
+++ b/quic/core/tls_handshaker_test.cc
@@ -63,7 +63,7 @@
cert_sct, context, error_details,
details, std::move(callback));
}
- pending_ops_.push_back(QuicMakeUnique<VerifyChainPendingOp>(
+ pending_ops_.push_back(std::make_unique<VerifyChainPendingOp>(
hostname, certs, ocsp_response, cert_sct, context, error_details,
details, std::move(callback), verifier_.get()));
return QUIC_PENDING;
@@ -125,7 +125,7 @@
QuicAsyncStatus status = delegate_->VerifyCertChain(
hostname_, certs_, ocsp_response_, cert_sct_, context_,
error_details_, details_,
- QuicMakeUnique<FailingProofVerifierCallback>());
+ std::make_unique<FailingProofVerifierCallback>());
ASSERT_NE(status, QUIC_PENDING);
callback_->Run(status == QUIC_SUCCESS, *error_details_, details_);
}
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index 6f5d34e..6d4990e 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -32,7 +32,7 @@
GetParam(),
ParsedQuicVersionVector(
{{PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99}}))) {
- session_ = QuicMakeUnique<StrictMock<MockQuicSession>>(connection_);
+ session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
manager_ = QuicSessionPeer::v99_streamid_manager(session_.get());
}
diff --git a/quic/core/uber_received_packet_manager_test.cc b/quic/core/uber_received_packet_manager_test.cc
index 9372da8..eecc98b 100644
--- a/quic/core/uber_received_packet_manager_test.cc
+++ b/quic/core/uber_received_packet_manager_test.cc
@@ -49,7 +49,7 @@
class UberReceivedPacketManagerTest : public QuicTest {
protected:
UberReceivedPacketManagerTest() {
- manager_ = QuicMakeUnique<UberReceivedPacketManager>(&stats_);
+ manager_ = std::make_unique<UberReceivedPacketManager>(&stats_);
clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
rtt_stats_.UpdateRtt(kMinRttMs, QuicTime::Delta::Zero(), QuicTime::Zero());
manager_->set_save_timestamps(true);
