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

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 <memory>
 #include <ostream>
 #include <string>
 
@@ skipping 15 matching lines @@
 #include "net/tools/quic/quic_time_wait_list_manager.h"
 #include "net/tools/quic/test_tools/mock_quic_time_wait_list_manager.h"
 #include "net/tools/quic/test_tools/quic_dispatcher_peer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 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;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Invoke;
 using testing::WithoutArgs;
 using testing::_;
 
 namespace net {
@@ skipping 63 matching lines @@
                                       const IPEndPoint& client_address));
 
   using QuicDispatcher::current_server_address;
   using QuicDispatcher::current_client_address;
 };
 
 // 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 {
+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() {
     LOG(ERROR) << "Unregistering " << connection_id();
     dispatcher_->OnConnectionClosed(connection_id(), QUIC_NO_ERROR,
                                     "Unregistering.");
   }
 
  private:
   QuicDispatcher* dispatcher_;
 };
 
 QuicServerSessionBase* CreateSession(
     QuicDispatcher* dispatcher,
     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,
     TestQuicSpdyServerSession** session) {
   MockServerConnection* connection = new MockServerConnection(
       connection_id, helper, alarm_factory, dispatcher);
   *session = new TestQuicSpdyServerSession(config, connection, crypto_config,
                                            compressed_certs_cache);
   connection->set_visitor(*session);
   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;
 }
 
 class QuicDispatcherTest : public ::testing::Test {
  public:
   QuicDispatcherTest()
       : helper_(&eps_, QuicAllocator::BUFFER_POOL),
         alarm_factory_(&eps_),
         crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance(),
                        CryptoTestUtils::ProofSourceForTesting()),
         dispatcher_(config_, &crypto_config_, &eps_),
         time_wait_list_manager_(nullptr),
         session1_(nullptr),
         session2_(nullptr) {
     dispatcher_.InitializeWithWriter(new QuicDefaultPacketWriter(1));
   }
 
   ~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,
   // 6 byte packet number, default path id, and packet number 1,
   // using the first supported version.
   void ProcessPacket(IPEndPoint client_address,
                      QuicConnectionId connection_id,
                      bool has_version_flag,
                      bool has_multipath_flag,
                      const string& data) {
@@ skipping 61 matching lines @@
     time_wait_list_manager_ =
         new MockTimeWaitListManager(QuicDispatcherPeer::GetWriter(&dispatcher_),
                                     &dispatcher_, &helper_, &alarm_factory_);
     // dispatcher_ takes the ownership of time_wait_list_manager_.
     QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                                time_wait_list_manager_);
   }
 
   EpollServer eps_;
   QuicEpollConnectionHelper helper_;
-  MockConnectionHelper mock_helper_;
+  MockQuicConnectionHelper mock_helper_;
   QuicEpollAlarmFactory alarm_factory_;
   MockAlarmFactory mock_alarm_factory_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   IPEndPoint server_address_;
   TestDispatcher dispatcher_;
   MockTimeWaitListManager* time_wait_list_manager_;
   TestQuicSpdyServerSession* session1_;
   TestQuicSpdyServerSession* session2_;
   string data_;
@@ skipping 12 matching lines @@
   EXPECT_EQ(client_address, dispatcher_.current_client_address());
   EXPECT_EQ(server_address_, dispatcher_.current_server_address());
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(2, client_address))
       .WillOnce(testing::Return(CreateSession(
           &dispatcher_, config_, 2, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           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>(
           Invoke(this, &QuicDispatcherTest::ValidatePacket)));
   ProcessPacket(client_address, 1, false, false, "eep");
 }
 
 TEST_F(QuicDispatcherTest, StatelessVersionNegotiation) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
   server_address_ = IPEndPoint(net::test::Any4(), 5);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, client_address)).Times(0);
   QuicVersion version = static_cast<QuicVersion>(QuicVersionMin() - 1);
   ProcessPacket(client_address, 1, true, version, "foo",
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, 1);
 }
 
 TEST_F(QuicDispatcherTest, Shutdown) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, client_address))
       .WillOnce(testing::Return(CreateSession(
           &dispatcher_, config_, 1, client_address, &mock_helper_,
           &mock_alarm_factory_, &crypto_config_,
           QuicDispatcherPeer::GetCache(&dispatcher_), &session1_)));
 
   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();
 }
 
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
   CreateTimeWaitListManager();
 
   // Create a new session.
   IPEndPoint client_address(net::test::Loopback4(), 1);
@@ skipping 15 matching lines @@
   std::unique_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildPublicResetPacket(packet));
   std::unique_ptr<QuicReceivedPacket> received(
       ConstructReceivedPacket(*encrypted, helper_.GetClock()->Now()));
   EXPECT_CALL(*session1_, OnConnectionClosed(QUIC_PUBLIC_RESET, _,
                                              ConnectionCloseSource::FROM_PEER))
       .Times(1)
       .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));
 
   // Dispatcher forwards subsequent packets for this connection_id to the time
   // wait list manager.
   EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _))
       .Times(1);
   EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _, _, _))
       .Times(0);
@@ skipping 211 matching lines @@
   // the existing connection_id will go on the time-wait list.
   EXPECT_EQ(ExpectStatelessReject(),
             time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
   if (ExpectStatelessReject()) {
     // The second packet will be processed on the time-wait list.
     EXPECT_CALL(*time_wait_list_manager_,
                 ProcessPacket(_, _, connection_id, _, _))
         .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>(
             Invoke(this, &QuicDispatcherTest::ValidatePacket)));
   }
   ProcessPacket(client_address, connection_id, true, false, "foo");
 }
 
 // Verify the stopgap test: Packets with truncated connection IDs should be
 // dropped.
@@ skipping 71 matching lines @@
   }
 
   void SetBlocked() { writer_->write_blocked_ = true; }
 
   void BlockConnection2() {
     writer_->write_blocked_ = true;
     dispatcher_.OnWriteBlocked(connection2());
   }
 
  protected:
-  MockConnectionHelper helper_;
+  MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   BlockingWriter* writer_;
   QuicDispatcher::WriteBlockedList* blocked_list_;
 };
 
 TEST_F(QuicDispatcherWriteBlockedListTest, BasicOnCanWrite) {
   // No OnCanWrite calls because no connections are blocked.
   dispatcher_.OnCanWrite();
 
   // Register connection 1 for events, and make sure it's notified.
@@ skipping 119 matching lines @@
 
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
   EXPECT_FALSE(dispatcher_.HasPendingWrites());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net