diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc
index e2891a9..ded3d87 100644
--- a/quiche/quic/core/http/end_to_end_test.cc
+++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -444,12 +444,12 @@
   }
 
   void StartServer() {
-    auto* test_server = new QuicTestServer(
+    auto test_server = std::make_unique<QuicTestServer>(
         crypto_test_utils::ProofSourceForTesting(), server_config_,
         server_supported_versions_, &memory_cache_backend_,
         expected_server_connection_id_length_);
     server_thread_ =
-        std::make_unique<ServerThread>(test_server, server_address_);
+        std::make_unique<ServerThread>(std::move(test_server), server_address_);
     if (chlo_multiplier_ != 0) {
       server_thread_->server()->SetChloMultiplier(chlo_multiplier_);
     }
diff --git a/quiche/quic/qbone/qbone_client_test.cc b/quiche/quic/qbone/qbone_client_test.cc
index f796c46..dee4d96 100644
--- a/quiche/quic/qbone/qbone_client_test.cc
+++ b/quiche/quic/qbone/qbone_client_test.cc
@@ -206,9 +206,11 @@
                          ::testing::PrintToStringParamName());
 
 TEST_P(QboneClientTest, SendDataFromClient) {
-  auto server = new QboneTestServer(crypto_test_utils::ProofSourceForTesting());
+  auto server = std::make_unique<QboneTestServer>(
+      crypto_test_utils::ProofSourceForTesting());
+  QboneTestServer* server_ptr = server.get();
   QuicSocketAddress server_address(TestLoopback(), 0);
-  ServerThread server_thread(server, server_address);
+  ServerThread server_thread(std::move(server), server_address);
   server_thread.Initialize();
   server_address =
       QuicSocketAddress(server_address.host(), server_thread.GetPort());
@@ -229,19 +231,19 @@
 
   // Wait until the server has received at least two packets, timeout after 5s.
   ASSERT_TRUE(
-      server_thread.WaitUntil([&] { return server->data().size() >= 2; },
+      server_thread.WaitUntil([&] { return server_ptr->data().size() >= 2; },
                               QuicTime::Delta::FromSeconds(5)));
 
   std::string long_data(
       QboneConstants::kMaxQbonePacketBytes - sizeof(ip6_hdr) - 1, 'A');
 
   // Pretend the server gets data.
-  server_thread.Schedule([&server, &long_data]() {
-    EXPECT_THAT(server->data()[0], testing::Eq(TestPacketOut("hello")));
-    EXPECT_THAT(server->data()[1], testing::Eq(TestPacketOut("world")));
+  server_thread.Schedule([server_ptr, &long_data]() {
+    EXPECT_THAT(server_ptr->data()[0], testing::Eq(TestPacketOut("hello")));
+    EXPECT_THAT(server_ptr->data()[1], testing::Eq(TestPacketOut("world")));
     auto server_session = static_cast<QboneServerSession*>(
         QuicDispatcherPeer::GetFirstSessionIfAny(
-            QuicServerPeer::GetDispatcher(server)));
+            QuicServerPeer::GetDispatcher(server_ptr)));
     server_session->ProcessPacketFromNetwork(
         TestPacketIn("Somethingsomething"));
     server_session->ProcessPacketFromNetwork(TestPacketIn(long_data));
diff --git a/quiche/quic/test_tools/server_thread.cc b/quiche/quic/test_tools/server_thread.cc
index 12d2fc2..1a4ae06 100644
--- a/quiche/quic/test_tools/server_thread.cc
+++ b/quiche/quic/test_tools/server_thread.cc
@@ -13,10 +13,11 @@
 namespace quic {
 namespace test {
 
-ServerThread::ServerThread(QuicServer* server, const QuicSocketAddress& address)
+ServerThread::ServerThread(std::unique_ptr<QuicServer> server,
+                           const QuicSocketAddress& address)
     : QuicThread("server_thread"),
-      server_(server),
-      clock_(server->epoll_server()),
+      server_(std::move(server)),
+      clock_(server_->epoll_server()),
       address_(address),
       port_(0),
       initialized_(false) {}
diff --git a/quiche/quic/test_tools/server_thread.h b/quiche/quic/test_tools/server_thread.h
index 7f5d45a..11c8fe1 100644
--- a/quiche/quic/test_tools/server_thread.h
+++ b/quiche/quic/test_tools/server_thread.h
@@ -21,7 +21,8 @@
 // Simple wrapper class to run QuicServer in a dedicated thread.
 class ServerThread : public QuicThread {
  public:
-  ServerThread(QuicServer* server, const QuicSocketAddress& address);
+  ServerThread(std::unique_ptr<QuicServer> server,
+               const QuicSocketAddress& address);
   ServerThread(const ServerThread&) = delete;
   ServerThread& operator=(const ServerThread&) = delete;