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

net/tools/quic/quic_client_session_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_client_session.h"
 
 #include <vector>
 
 #include "base/strings/stringprintf.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_quic_spdy_client_stream.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/tools/quic/quic_spdy_client_stream.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPrintf;
+using google::protobuf::implicit_cast;
 using net::test::ConstructEncryptedPacket;
 using net::test::ConstructMisFramedEncryptedPacket;
 using net::test::CryptoTestUtils;
 using net::test::DefaultQuicConfig;
-using net::test::MockConnection;
-using net::test::MockConnectionHelper;
+using net::test::MockQuicConnection;
+using net::test::MockQuicConnectionHelper;
 using net::test::MockQuicSpdyClientStream;
 using net::test::PacketSavingConnection;
 using net::test::QuicConnectionPeer;
 using net::test::QuicPacketCreatorPeer;
 using net::test::QuicSpdySessionPeer;
 using net::test::SupportedVersions;
 using net::test::TestPeerIPAddress;
 using net::test::ValueRestore;
 using net::test::kClientDataStreamId1;
 using net::test::kServerDataStreamId1;
@@ skipping 73 matching lines @@
   void CompleteCryptoHandshake() {
     session_->CryptoConnect();
     QuicCryptoClientStream* stream =
         static_cast<QuicCryptoClientStream*>(session_->GetCryptoStream());
     CryptoTestUtils::FakeServerOptions options;
     CryptoTestUtils::HandshakeWithFakeServer(&helper_, &alarm_factory_,
                                              connection_, stream, options);
   }
 
   QuicCryptoClientConfig crypto_config_;
-  MockConnectionHelper helper_;
+  MockQuicConnectionHelper helper_;
   MockAlarmFactory alarm_factory_;
   PacketSavingConnection* connection_;
   std::unique_ptr<TestQuicClientSession> session_;
   QuicClientPushPromiseIndex push_promise_index_;
   SpdyHeaderBlock push_promise_;
   string promise_url_;
   QuicStreamId promised_stream_id_;
   QuicStreamId associated_stream_id_;
 };
 
@@ skipping 104 matching lines @@
 static bool CheckForDecryptionError(QuicFramer* framer) {
   return framer->error() == QUIC_DECRYPTION_FAILURE;
 }
 
 // Regression test for b/17206611.
 TEST_P(QuicClientSessionTest, InvalidPacketReceived) {
   IPEndPoint server_address(TestPeerIPAddress(), kTestPort);
   IPEndPoint client_address(TestPeerIPAddress(), kTestPort);
 
   EXPECT_CALL(*connection_, ProcessUdpPacket(server_address, client_address, _))
-      .WillRepeatedly(Invoke(static_cast<MockConnection*>(connection_),
-                             &MockConnection::ReallyProcessUdpPacket));
+      .WillRepeatedly(Invoke(implicit_cast<MockQuicConnection*>(connection_),
+                             &MockQuicConnection::ReallyProcessUdpPacket));
   EXPECT_CALL(*connection_, OnCanWrite()).Times(AnyNumber());
   EXPECT_CALL(*connection_, OnError(_)).Times(1);
 
   // Verify that empty packets don't close the connection.
   QuicReceivedPacket zero_length_packet(nullptr, 0, QuicTime::Zero(), false);
   EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
   session_->ProcessUdpPacket(client_address, server_address,
                              zero_length_packet);
 
   // Verifiy that small, invalid packets don't close the connection.
@@ skipping 17 matching lines @@
   EXPECT_CALL(*connection_, OnError(Truly(CheckForDecryptionError))).Times(1);
   session_->ProcessUdpPacket(client_address, server_address, *received);
 }
 
 // A packet with invalid framing should cause a connection to be closed.
 TEST_P(QuicClientSessionTest, InvalidFramedPacketReceived) {
   IPEndPoint server_address(TestPeerIPAddress(), kTestPort);
   IPEndPoint client_address(TestPeerIPAddress(), kTestPort);
 
   EXPECT_CALL(*connection_, ProcessUdpPacket(server_address, client_address, _))
-      .WillRepeatedly(Invoke(static_cast<MockConnection*>(connection_),
-                             &MockConnection::ReallyProcessUdpPacket));
+      .WillRepeatedly(Invoke(implicit_cast<MockQuicConnection*>(connection_),
+                             &MockQuicConnection::ReallyProcessUdpPacket));
   EXPECT_CALL(*connection_, OnError(_)).Times(1);
 
   // Verify that a decryptable packet with bad frames does close the connection.
   QuicConnectionId connection_id = session_->connection()->connection_id();
   std::unique_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
       connection_id, false, false, false, kDefaultPathId, 100, "data",
       PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, nullptr,
       Perspective::IS_SERVER));
   std::unique_ptr<QuicReceivedPacket> received(
       ConstructReceivedPacket(*packet, QuicTime::Zero()));
@@ skipping 210 matching lines @@
   QuicClientPromisedInfo* promised =
       session_->GetPromisedById(promised_stream_id_);
   EXPECT_NE(promised, nullptr);
   EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
   EXPECT_EQ(session_->GetPromisedStream(promised_stream_id_), nullptr);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net