Make QuicDispatcher's helper and alarm factory arguments unique_ptrs to make ownership clear.

net/tools/quic/end_to_end_test.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <sys/epoll.h>
 
 #include <list>
 #include <string>
 #include <vector>
@@ skipping 336 matching lines @@
     if (GetParam().client_supports_stateless_rejects) {
       copt.push_back(kSREJ);
     }
     client_config_.SetConnectionOptionsToSend(copt);
 
     // Start the server first, because CreateQuicClient() attempts
     // to connect to the server.
     StartServer();
 
     client_.reset(CreateQuicClient(client_writer_));
-    static EpollEvent event(EPOLLOUT, false);
     client_writer_->Initialize(
         reinterpret_cast<QuicEpollConnectionHelper*>(
             QuicConnectionPeer::GetHelper(
                 client_->client()->session()->connection())),
+        reinterpret_cast<QuicEpollAlarmFactory*>(
+            QuicConnectionPeer::GetAlarmFactory(
+                client_->client()->session()->connection())),
         new ClientDelegate(client_->client()));
     initialized_ = true;
     return client_->client()->connected();
   }
 
   void SetUp() override {
     // The ownership of these gets transferred to the QuicPacketWriterWrapper
     // when Initialize() is executed.
     client_writer_ = new PacketDroppingTestWriter();
     server_writer_ = new PacketDroppingTestWriter();
@@ skipping 17 matching lines @@
     server_address_ =
         IPEndPoint(server_address_.address(), server_thread_->GetPort());
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
 
     FLAGS_enable_quic_stateless_reject_support =
         GetParam().server_uses_stateless_rejects_if_peer_supported;
 
     server_writer_->Initialize(QuicDispatcherPeer::GetHelper(dispatcher),
+                               QuicDispatcherPeer::GetAlarmFactory(dispatcher),
                                new ServerDelegate(dispatcher));
     if (stream_factory_ != nullptr) {
       static_cast<QuicTestServer*>(server_thread_->server())
           ->SetSpdyStreamFactory(stream_factory_);
     }
 
     server_thread_->Start();
     server_started_ = true;
   }
 
@@ skipping 2186 matching lines @@
   // Use a quic client that drops received body.
   QuicTestClient* client = new QuicTestClientThatDropsBody(
       server_address_, server_hostname_, client_config_,
       client_supported_versions_);
   client->UseWriter(client_writer_);
   client->Connect();
   client_.reset(client);
   static EpollEvent event(EPOLLOUT, false);
   client_writer_->Initialize(
       QuicConnectionPeer::GetHelper(client_->client()->session()->connection()),
+      QuicConnectionPeer::GetAlarmFactory(
+          client_->client()->session()->connection()),
       new ClientDelegate(client_->client()));
   initialized_ = true;
   ASSERT_TRUE(client_->client()->connected());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
   SetPacketLossPercentage(1);
   client_->SendRequest("/huge_response");
   client_->WaitForResponse();
   VerifyCleanConnection(false);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net