Rename various MockConnectionFoo classes to MockQuicConnectionFoo. No behavior change. This is cons…

net/tools/quic/quic_dispatcher_test.cc

Index: net/tools/quic/quic_dispatcher_test.cc
diff --git a/net/tools/quic/quic_dispatcher_test.cc b/net/tools/quic/quic_dispatcher_test.cc
index 9b305696cbef12d6cfbf19917d17a3c2d8a9202d..41d7e560ca18a8705761b2c803f45a309b6490b0 100644
--- a/net/tools/quic/quic_dispatcher_test.cc
+++ b/net/tools/quic/quic_dispatcher_test.cc
@@ -33,8 +33,8 @@ using base::StringPiece;
 using net::EpollServer;
 using net::test::ConstructEncryptedPacket;
 using net::test::CryptoTestUtils;
-using net::test::MockConnection;
-using net::test::MockConnectionHelper;
+using net::test::MockQuicConnection;
+using net::test::MockQuicConnectionHelper;
 using net::test::ValueRestore;
 using std::string;
 using std::vector;
@@ -118,16 +118,16 @@ class TestDispatcher : public QuicDispatcher {
 // 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 {
+class MockServerConnection : public MockQuicConnection {
  public:
   MockServerConnection(QuicConnectionId connection_id,
-                       MockConnectionHelper* helper,
+                       MockQuicConnectionHelper* helper,
                        MockAlarmFactory* alarm_factory,
                        QuicDispatcher* dispatcher)
-      : MockConnection(connection_id,
-                       helper,
-                       alarm_factory,
-                       Perspective::IS_SERVER),
+      : MockQuicConnection(connection_id,
+                           helper,
+                           alarm_factory,
+                           Perspective::IS_SERVER),
         dispatcher_(dispatcher) {}
 
   void UnregisterOnConnectionClosed() {
@@ -145,7 +145,7 @@ QuicServerSessionBase* CreateSession(
     const QuicConfig& config,
     QuicConnectionId connection_id,
     const IPEndPoint& client_address,
-    MockConnectionHelper* helper,
+    MockQuicConnectionHelper* helper,
     MockAlarmFactory* alarm_factory,
     const QuicCryptoServerConfig* crypto_config,
     QuicCompressedCertsCache* compressed_certs_cache,
@@ -158,7 +158,7 @@ QuicServerSessionBase* CreateSession(
   ON_CALL(*connection, CloseConnection(_, _, _))
       .WillByDefault(WithoutArgs(Invoke(
           connection, &MockServerConnection::UnregisterOnConnectionClosed)));
-  EXPECT_CALL(*reinterpret_cast<MockConnection*>((*session)->connection()),
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>((*session)->connection()),
               ProcessUdpPacket(_, client_address, _));
 
   return *session;
@@ -181,12 +181,12 @@ class QuicDispatcherTest : public ::testing::Test {
 
   ~QuicDispatcherTest() override {}
 
-  MockConnection* connection1() {
-    return reinterpret_cast<MockConnection*>(session1_->connection());
+  MockQuicConnection* connection1() {
+    return reinterpret_cast<MockQuicConnection*>(session1_->connection());
   }
 
-  MockConnection* connection2() {
-    return reinterpret_cast<MockConnection*>(session2_->connection());
+  MockQuicConnection* connection2() {
+    return reinterpret_cast<MockQuicConnection*>(session2_->connection());
   }
 
   // Process a packet with an 8 byte connection id,
@@ -268,7 +268,7 @@ class QuicDispatcherTest : public ::testing::Test {
 
   EpollServer eps_;
   QuicEpollConnectionHelper helper_;
-  MockConnectionHelper mock_helper_;
+  MockQuicConnectionHelper mock_helper_;
   QuicEpollAlarmFactory alarm_factory_;
   MockAlarmFactory mock_alarm_factory_;
   QuicConfig config_;
@@ -301,7 +301,7 @@ TEST_F(QuicDispatcherTest, ProcessPackets) {
           QuicDispatcherPeer::GetCache(&dispatcher_), &session2_)));
   ProcessPacket(client_address, 2, true, false, "bar");
 
-  EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .Times(1)
       .WillOnce(testing::WithArgs<2>(
@@ -330,7 +330,7 @@ TEST_F(QuicDispatcherTest, Shutdown) {
 
   ProcessPacket(client_address, 1, true, false, "foo");
 
-  EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               CloseConnection(QUIC_PEER_GOING_AWAY, _, _));
 
   dispatcher_.Shutdown();
@@ -366,11 +366,11 @@ TEST_F(QuicDispatcherTest, TimeWaitListManager) {
       .WillOnce(WithoutArgs(Invoke(
           reinterpret_cast<MockServerConnection*>(session1_->connection()),
           &MockServerConnection::UnregisterOnConnectionClosed)));
-  EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(
-          Invoke(reinterpret_cast<MockConnection*>(session1_->connection()),
-                 &MockConnection::ReallyProcessUdpPacket));
+          Invoke(reinterpret_cast<MockQuicConnection*>(session1_->connection()),
+                 &MockQuicConnection::ReallyProcessUdpPacket));
   dispatcher_.ProcessPacket(IPEndPoint(), client_address, *received);
   EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
 
@@ -602,7 +602,7 @@ TEST_P(QuicDispatcherStatelessRejectTest, ParameterizedBasicTest) {
         .Times(1);
   } else {
     // The second packet will trigger a packet-validation
-    EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
+    EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
                 ProcessUdpPacket(_, _, _))
         .Times(1)
         .WillOnce(testing::WithArgs<2>(
@@ -694,7 +694,7 @@ class QuicDispatcherWriteBlockedListTest : public QuicDispatcherTest {
   }
 
  protected:
-  MockConnectionHelper helper_;
+  MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   BlockingWriter* writer_;
   QuicDispatcher::WriteBlockedList* blocked_list_;