Minor cleanup of QUIC MockConnection and PacketSavingConnection

net/tools/quic/quic_dispatcher_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 "net/tools/quic/quic_dispatcher.h"
 
 #include <string>
 
 #include "base/strings/string_piece.h"
 #include "net/quic/crypto/crypto_handshake.h"
@@ skipping 40 matching lines @@
   using QuicDispatcher::write_blocked_list;
 };
 
 // A Connection class which unregisters the session from the dispatcher
 // when sending connection close.
 // It'd be slightly more realistic to do this from the Session but it would
 // involve a lot more mocking.
 class MockServerConnection : public MockConnection {
  public:
   MockServerConnection(QuicGuid guid,
-                       IPEndPoint address,
-                       int fd,
-                       EpollServer* eps,
                        QuicDispatcher* dispatcher)
-      : MockConnection(guid, address, fd, eps, true),
+      : MockConnection(guid, true),
         dispatcher_(dispatcher) {
   }
   void UnregisterOnConnectionClosed() {
     LOG(ERROR) << "Unregistering " << guid();
     dispatcher_->OnConnectionClosed(guid(), QUIC_NO_ERROR);
   }
  private:
   QuicDispatcher* dispatcher_;
 };
 
 QuicSession* CreateSession(QuicDispatcher* dispatcher,
                            QuicGuid guid,
                            const IPEndPoint& addr,
-                           MockSession** session,
-                           EpollServer* eps) {
-  MockServerConnection* connection =
-      new MockServerConnection(guid, addr, 0, eps, dispatcher);
+                           MockSession** session) {
+  MockServerConnection* connection = new MockServerConnection(guid, dispatcher);
   *session = new MockSession(connection, true);
   ON_CALL(*connection, SendConnectionClose(_)).WillByDefault(
       WithoutArgs(Invoke(
           connection, &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>((*session)->connection()),
               ProcessUdpPacket(_, addr, _));
 
   return *session;
 }
 
@@ skipping 23 matching lines @@
                      const string& data) {
     dispatcher_.ProcessPacket(
         IPEndPoint(), addr, guid, has_version_flag,
         QuicEncryptedPacket(data.data(), data.length()));
   }
 
   void ValidatePacket(const QuicEncryptedPacket& packet) {
     EXPECT_TRUE(packet.AsStringPiece().find(data_) != StringPiece::npos);
   }
 
-  IPAddressNumber Loopback4() {
-    net::IPAddressNumber addr;
-    CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &addr));
-    return addr;
-  }
-
   EpollServer eps_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   TestDispatcher dispatcher_;
   MockSession* session1_;
   MockSession* session2_;
   string data_;
 };
 
 TEST_F(QuicDispatcherTest, ProcessPackets) {
-  IPEndPoint addr(Loopback4(), 1);
+  IPEndPoint addr(net::test::Loopback4(), 1);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, _, addr))
       .WillOnce(testing::Return(CreateSession(
-          &dispatcher_, 1, addr, &session1_, &eps_)));
+          &dispatcher_, 1, addr, &session1_)));
   ProcessPacket(addr, 1, true, "foo");
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(2, _, addr))
       .WillOnce(testing::Return(CreateSession(
-                    &dispatcher_, 2, addr, &session2_, &eps_)));
+                    &dispatcher_, 2, addr, &session2_)));
   ProcessPacket(addr, 2, true, "bar");
 
   data_ = "eep";
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _)).Times(1).
       WillOnce(testing::WithArgs<2>(Invoke(
           this, &QuicDispatcherTest::ValidatePacket)));
   ProcessPacket(addr, 1, false, "eep");
 }
 
 TEST_F(QuicDispatcherTest, Shutdown) {
-  IPEndPoint addr(Loopback4(), 1);
+  IPEndPoint addr(net::test::Loopback4(), 1);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, addr))
       .WillOnce(testing::Return(CreateSession(
-                    &dispatcher_, 1, addr, &session1_, &eps_)));
+                    &dispatcher_, 1, addr, &session1_)));
 
   ProcessPacket(addr, 1, true, "foo");
 
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               SendConnectionClose(QUIC_PEER_GOING_AWAY));
 
   dispatcher_.Shutdown();
 }
 
 class MockTimeWaitListManager : public QuicTimeWaitListManager {
@@ skipping 10 matching lines @@
 };
 
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
       new MockTimeWaitListManager(
           QuicDispatcherPeer::GetWriter(&dispatcher_), &eps_);
   // dispatcher takes the ownership of time_wait_list_manager.
   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                              time_wait_list_manager);
   // Create a new session.
-  IPEndPoint addr(Loopback4(), 1);
+  IPEndPoint addr(net::test::Loopback4(), 1);
   QuicGuid guid = 1;
   EXPECT_CALL(dispatcher_, CreateQuicSession(guid, _, addr))
       .WillOnce(testing::Return(CreateSession(
-                    &dispatcher_, guid, addr, &session1_, &eps_)));
+                    &dispatcher_, guid, addr, &session1_)));
   ProcessPacket(addr, guid, true, "foo");
 
   // Close the connection by sending public reset packet.
   QuicPublicResetPacket packet;
   packet.public_header.guid = guid;
   packet.public_header.reset_flag = true;
   packet.public_header.version_flag = false;
   packet.rejected_sequence_number = 19191;
   packet.nonce_proof = 132232;
   scoped_ptr<QuicEncryptedPacket> encrypted(
@@ skipping 17 matching lines @@
 }
 
 TEST_F(QuicDispatcherTest, StrayPacketToTimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
       new MockTimeWaitListManager(
           QuicDispatcherPeer::GetWriter(&dispatcher_), &eps_);
   // dispatcher takes the ownership of time_wait_list_manager.
   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                              time_wait_list_manager);
 
-  IPEndPoint addr(Loopback4(), 1);
+  IPEndPoint addr(net::test::Loopback4(), 1);
   QuicGuid guid = 1;
   // Dispatcher forwards all packets for this guid to the time wait list
   // manager.
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, _)).Times(0);
   EXPECT_CALL(*time_wait_list_manager, ProcessPacket(_, _, guid, _)).Times(1);
   string data = "foo";
   ProcessPacket(addr, guid, false, "foo");
 }
 
 class QuicWriteBlockedListTest : public QuicDispatcherTest {
  public:
   virtual void SetUp() {
-    IPEndPoint addr(Loopback4(), 1);
+    IPEndPoint addr(net::test::Loopback4(), 1);
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, addr))
         .WillOnce(testing::Return(CreateSession(
-                      &dispatcher_, 1, addr, &session1_, &eps_)));
+                      &dispatcher_, 1, addr, &session1_)));
     ProcessPacket(addr, 1, true, "foo");
 
     EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, addr))
         .WillOnce(testing::Return(CreateSession(
-                      &dispatcher_, 2, addr, &session2_, &eps_)));
+                      &dispatcher_, 2, addr, &session2_)));
     ProcessPacket(addr, 2, true, "bar");
 
     blocked_list_ = dispatcher_.write_blocked_list();
   }
 
   virtual void TearDown() {
     EXPECT_CALL(*connection1(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
     EXPECT_CALL(*connection2(), SendConnectionClose(QUIC_PEER_GOING_AWAY));
     dispatcher_.Shutdown();
   }
@@ skipping 117 matching lines @@
 
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net