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);