Split out QuicAlarm creation from QuicConnectionHelper to new QuicAlarmFactory.

net/quic/p2p/quic_p2p_session_test.cc

 // Copyright 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/quic/p2p/quic_p2p_session.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/p2p/quic_p2p_crypto_config.h"
 #include "net/quic/p2p/quic_p2p_stream.h"
+#include "net/quic/quic_chromium_alarm_factory.h"
 #include "net/quic/quic_chromium_connection_helper.h"
 #include "net/quic/quic_chromium_packet_writer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/socket/socket.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 158 matching lines @@
 };
 
 }  // namespace
 
 class QuicP2PSessionTest : public ::testing::Test {
  public:
   void OnWriteResult(int result);
 
  protected:
   QuicP2PSessionTest()
-      : quic_helper_(base::ThreadTaskRunnerHandle::Get().get(),
-                     &quic_clock_,
-                     QuicRandom::GetInstance()) {
+      : quic_helper_(&quic_clock_, QuicRandom::GetInstance()),
+        alarm_factory_(base::ThreadTaskRunnerHandle::Get().get(),
+                       &quic_clock_) {
     // Simulate out-of-bound config handshake.
     CryptoHandshakeMessage hello_message;
     config_.ToHandshakeMessage(&hello_message);
     std::string error_detail;
     EXPECT_EQ(QUIC_NO_ERROR,
               config_.ProcessPeerHello(hello_message, CLIENT, &error_detail));
   }
 
   void CreateSessions() {
     std::unique_ptr<FakeP2PDatagramSocket> socket1(new FakeP2PDatagramSocket());
@@ skipping 11 matching lines @@
                                  Perspective::IS_CLIENT);
   }
 
   std::unique_ptr<QuicP2PSession> CreateP2PSession(
       std::unique_ptr<Socket> socket,
       QuicP2PCryptoConfig crypto_config,
       Perspective perspective) {
     QuicChromiumPacketWriter* writer =
         new QuicChromiumPacketWriter(socket.get());
     std::unique_ptr<QuicConnection> quic_connection1(new QuicConnection(
-        0, IPEndPoint(IPAddress::IPv4AllZeros(), 0), &quic_helper_, writer,
-        true /* owns_writer */, perspective, QuicSupportedVersions()));
+        0, IPEndPoint(IPAddress::IPv4AllZeros(), 0), &quic_helper_,
+        &alarm_factory_, writer, true /* owns_writer */, perspective,
+        QuicSupportedVersions()));
     writer->SetConnection(quic_connection1.get());
 
     std::unique_ptr<QuicP2PSession> result(
         new QuicP2PSession(config_, crypto_config, std::move(quic_connection1),
                            std::move(socket)));
     result->Initialize();
     return result;
   }
 
   void TestStreamConnection(QuicP2PSession* from_session,
                             QuicP2PSession* to_session,
                             QuicStreamId expected_stream_id);
 
   QuicClock quic_clock_;
   QuicChromiumConnectionHelper quic_helper_;
+  QuicChromiumAlarmFactory alarm_factory_;
   QuicConfig config_;
 
   base::WeakPtr<FakeP2PDatagramSocket> socket1_;
   std::unique_ptr<QuicP2PSession> session1_;
 
   base::WeakPtr<FakeP2PDatagramSocket> socket2_;
   std::unique_ptr<QuicP2PSession> session2_;
 };
 
 void QuicP2PSessionTest::OnWriteResult(int result) {
@@ skipping 130 matching lines @@
   EXPECT_TRUE(stream_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_READ_ERROR, stream_delegate.error());
   EXPECT_TRUE(session_delegate.is_closed());
   EXPECT_EQ(QUIC_PACKET_READ_ERROR, session_delegate.error());
 
   // Verify that the socket was destroyed.
   EXPECT_FALSE(socket1_);
 }
 
 }  // namespace net