Make QuicDispatcher's helper argument be a unique_ptr to make ownership

net/tools/quic/test_tools/quic_test_server.cc

 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/tools/quic/test_tools/quic_test_server.h"
 
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 58 matching lines @@
  private:
   QuicTestServer::StreamFactory* stream_factory_;               // Not owned.
   QuicTestServer::CryptoStreamFactory* crypto_stream_factory_;  // Not owned.
 };
 
 class QuicTestDispatcher : public QuicDispatcher {
  public:
   QuicTestDispatcher(const QuicConfig& config,
                      const QuicCryptoServerConfig* crypto_config,
                      const QuicVersionVector& versions,
-                     QuicConnectionHelperInterface* helper)
-      : QuicDispatcher(config, crypto_config, versions, helper),
+                     std::unique_ptr<QuicConnectionHelperInterface> helper)
+      : QuicDispatcher(config, crypto_config, versions, std::move(helper)),
         session_factory_(nullptr),
         stream_factory_(nullptr),
         crypto_stream_factory_(nullptr) {}
 
   QuicServerSessionBase* CreateQuicSession(QuicConnectionId id,
                                            const IPEndPoint& client) override {
     base::AutoLock lock(factory_lock_);
     if (session_factory_ == nullptr && stream_factory_ == nullptr &&
         crypto_stream_factory_ == nullptr) {
       return QuicDispatcher::CreateQuicSession(id, client);
@@ skipping 52 matching lines @@
                                const QuicConfig& config,
                                const QuicVersionVector& supported_versions)
     : QuicServer(proof_source,
                  config,
                  QuicCryptoServerConfig::ConfigOptions(),
                  supported_versions) {}
 
 QuicDispatcher* QuicTestServer::CreateQuicDispatcher() {
   return new QuicTestDispatcher(
       config(), &crypto_config(), supported_versions(),
-      new QuicEpollConnectionHelper(epoll_server(),
-                                    QuicAllocator::BUFFER_POOL));
+      std::unique_ptr<QuicEpollConnectionHelper>(new QuicEpollConnectionHelper(
+          epoll_server(), QuicAllocator::BUFFER_POOL)));
 }
 
 void QuicTestServer::SetSessionFactory(SessionFactory* factory) {
   DCHECK(dispatcher());
   static_cast<QuicTestDispatcher*>(dispatcher())->SetSessionFactory(factory);
 }
 
 void QuicTestServer::SetSpdyStreamFactory(StreamFactory* factory) {
   static_cast<QuicTestDispatcher*>(dispatcher())->SetStreamFactory(factory);
 }
@@ skipping 14 matching lines @@
     : QuicSimpleServerSession(config,
                               connection,
                               visitor,
                               crypto_config,
                               compressed_certs_cache) {
   SendGoAway(QUIC_PEER_GOING_AWAY, "");
 }
 
 }  // namespace test
 }  // namespace net