Landing Recent QUIC changes until Sun May 8 00:39:29 2016 +0000

net/quic/test_tools/quic_test_utils.h

 // 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.
 //
 // Common utilities for Quic tests
 
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include <stddef.h>
@@ skipping 293 matching lines @@
   bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
   bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
   bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
   bool OnPathCloseFrame(const QuicPathCloseFrame& frame) override;
   void OnPacketComplete() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
 };
 
-class MockConnectionVisitor : public QuicConnectionVisitorInterface {
+class MockQuicConnectionVisitor : public QuicConnectionVisitorInterface {
  public:
-  MockConnectionVisitor();
-  ~MockConnectionVisitor() override;
+  MockQuicConnectionVisitor();
+  ~MockQuicConnectionVisitor() override;
 
   MOCK_METHOD1(OnStreamFrame, void(const QuicStreamFrame& frame));
   MOCK_METHOD1(OnWindowUpdateFrame, void(const QuicWindowUpdateFrame& frame));
   MOCK_METHOD1(OnBlockedFrame, void(const QuicBlockedFrame& frame));
   MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame));
   MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame));
   MOCK_METHOD3(OnConnectionClosed,
                void(QuicErrorCode error,
                     const std::string& error_details,
                     ConnectionCloseSource source));
   MOCK_METHOD0(OnWriteBlocked, void());
   MOCK_METHOD0(OnCanWrite, void());
   MOCK_METHOD1(OnCongestionWindowChange, void(QuicTime now));
   MOCK_METHOD1(OnConnectionMigration, void(PeerAddressChangeType type));
   MOCK_METHOD0(OnPathDegrading, void());
   MOCK_CONST_METHOD0(WillingAndAbleToWrite, bool());
   MOCK_CONST_METHOD0(HasPendingHandshake, bool());
   MOCK_CONST_METHOD0(HasOpenDynamicStreams, bool());
   MOCK_METHOD1(OnSuccessfulVersionNegotiation,
                void(const QuicVersion& version));
   MOCK_METHOD0(OnConfigNegotiated, void());
   MOCK_METHOD0(PostProcessAfterData, void());
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockConnectionVisitor);
+  DISALLOW_COPY_AND_ASSIGN(MockQuicConnectionVisitor);
 };
 
-class MockConnectionHelper : public QuicConnectionHelperInterface {
+class MockQuicConnectionHelper : public QuicConnectionHelperInterface {
  public:
-  MockConnectionHelper();
-  ~MockConnectionHelper() override;
+  MockQuicConnectionHelper();
+  ~MockQuicConnectionHelper() override;
   const QuicClock* GetClock() const override;
   QuicRandom* GetRandomGenerator() override;
   QuicBufferAllocator* GetBufferAllocator() override;
   void AdvanceTime(QuicTime::Delta delta);
 
  private:
   MockClock clock_;
   MockRandom random_generator_;
   SimpleBufferAllocator buffer_allocator_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockConnectionHelper);
+  DISALLOW_COPY_AND_ASSIGN(MockQuicConnectionHelper);
 };
 
 class MockAlarmFactory : public QuicAlarmFactory {
  public:
   QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
   QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
       QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
       QuicConnectionArena* arena) override;
 
   // No-op alarm implementation
   class TestAlarm : public QuicAlarm {
    public:
     explicit TestAlarm(QuicArenaScopedPtr<QuicAlarm::Delegate> delegate)
         : QuicAlarm(std::move(delegate)) {}
 
     void SetImpl() override {}
     void CancelImpl() override {}
 
     using QuicAlarm::Fire;
   };
 
   void FireAlarm(QuicAlarm* alarm) {
     reinterpret_cast<TestAlarm*>(alarm)->Fire();
   }
 };
 
-class MockConnection : public QuicConnection {
+class MockQuicConnection : public QuicConnection {
  public:
   // Uses a ConnectionId of 42 and 127.0.0.1:123.
-  MockConnection(MockConnectionHelper* helper,
-                 MockAlarmFactory* alarm_factory,
-                 Perspective perspective);
+  MockQuicConnection(MockQuicConnectionHelper* helper,
+                     MockAlarmFactory* alarm_factory,
+                     Perspective perspective);
 
   // Uses a ConnectionId of 42.
-  MockConnection(IPEndPoint address,
-                 MockConnectionHelper* helper,
-                 MockAlarmFactory* alarm_factory,
-                 Perspective perspective);
+  MockQuicConnection(IPEndPoint address,
+                     MockQuicConnectionHelper* helper,
+                     MockAlarmFactory* alarm_factory,
+                     Perspective perspective);
 
   // Uses 127.0.0.1:123.
-  MockConnection(QuicConnectionId connection_id,
-                 MockConnectionHelper* helper,
-                 MockAlarmFactory* alarm_factory,
-                 Perspective perspective);
+  MockQuicConnection(QuicConnectionId connection_id,
+                     MockQuicConnectionHelper* helper,
+                     MockAlarmFactory* alarm_factory,
+                     Perspective perspective);
 
   // Uses a ConnectionId of 42, and 127.0.0.1:123.
-  MockConnection(MockConnectionHelper* helper,
-                 MockAlarmFactory* alarm_factory,
-                 Perspective perspective,
-                 const QuicVersionVector& supported_versions);
+  MockQuicConnection(MockQuicConnectionHelper* helper,
+                     MockAlarmFactory* alarm_factory,
+                     Perspective perspective,
+                     const QuicVersionVector& supported_versions);
 
-  MockConnection(QuicConnectionId connection_id,
-                 IPEndPoint address,
-                 MockConnectionHelper* helper,
-                 MockAlarmFactory* alarm_factory,
-                 Perspective perspective,
-                 const QuicVersionVector& supported_versions);
+  MockQuicConnection(QuicConnectionId connection_id,
+                     IPEndPoint address,
+                     MockQuicConnectionHelper* helper,
+                     MockAlarmFactory* alarm_factory,
+                     Perspective perspective,
+                     const QuicVersionVector& supported_versions);
 
-  ~MockConnection() override;
+  ~MockQuicConnection() override;
 
-  // If the constructor that uses a MockConnectionHelper has been used then
+  // If the constructor that uses a MockQuicConnectionHelper has been used then
   // this method
   // will advance the time of the MockClock.
   void AdvanceTime(QuicTime::Delta delta);
 
   MOCK_METHOD3(ProcessUdpPacket,
                void(const IPEndPoint& self_address,
                     const IPEndPoint& peer_address,
                     const QuicReceivedPacket& packet));
   MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error));
   MOCK_METHOD3(CloseConnection,
@@ skipping 33 matching lines @@
 
   bool OnProtocolVersionMismatch(QuicVersion version) override { return false; }
 
   void ReallySendGoAway(QuicErrorCode error,
                         QuicStreamId last_good_stream_id,
                         const std::string& reason) {
     QuicConnection::SendGoAway(error, last_good_stream_id, reason);
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(MockConnection);
+  DISALLOW_COPY_AND_ASSIGN(MockQuicConnection);
 };
 
-class PacketSavingConnection : public MockConnection {
+class PacketSavingConnection : public MockQuicConnection {
  public:
-  PacketSavingConnection(MockConnectionHelper* helper,
+  PacketSavingConnection(MockQuicConnectionHelper* helper,
                          MockAlarmFactory* alarm_factory,
                          Perspective perspective);
 
-  PacketSavingConnection(MockConnectionHelper* helper,
+  PacketSavingConnection(MockQuicConnectionHelper* helper,
                          MockAlarmFactory* alarm_factory,
                          Perspective perspective,
                          const QuicVersionVector& supported_versions);
 
   ~PacketSavingConnection() override;
 
   void SendOrQueuePacket(SerializedPacket* packet) override;
 
   std::vector<QuicEncryptedPacket*> encrypted_packets_;
 
@@ skipping 312 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAckListener);
 };
 
 class MockNetworkChangeVisitor
     : public QuicSentPacketManager::NetworkChangeVisitor {
  public:
   MockNetworkChangeVisitor();
   ~MockNetworkChangeVisitor() override;
 
-  MOCK_METHOD0(OnCongestionWindowChange, void());
-  MOCK_METHOD0(OnRttChange, void());
+  MOCK_METHOD0(OnCongestionChange, void());
   MOCK_METHOD0(OnPathDegrading, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockNetworkChangeVisitor);
 };
 
 class MockQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor {
  public:
   MockQuicConnectionDebugVisitor();
   ~MockQuicConnectionDebugVisitor() override;
 
   MOCK_METHOD1(OnFrameAddedToPacket, void(const QuicFrame&));
 
-  MOCK_METHOD4(OnPacketSent,
+  MOCK_METHOD5(OnPacketSent,
                void(const SerializedPacket&,
+                    QuicPathId,
                     QuicPacketNumber,
                     TransmissionType,
                     QuicTime));
 
   MOCK_METHOD3(OnPacketReceived,
                void(const IPEndPoint&,
                     const IPEndPoint&,
                     const QuicEncryptedPacket&));
 
   MOCK_METHOD1(OnIncorrectConnectionId, void(QuicConnectionId));
@@ skipping 39 matching lines @@
 
 // Creates a client session for testing.
 //
 // server_id: The server id associated with this stream.
 // supports_stateless_rejects:  Does this client support stateless rejects.
 // connection_start_time: The time to set for the connection clock.
 //   Needed for strike-register nonce verification.  The client
 //   connection_start_time should be synchronized witht the server
 //   start time, otherwise nonce verification will fail.
 // supported_versions: Set of QUIC versions this client supports.
-// helper: Pointer to the MockConnectionHelper to use for the session.
+// helper: Pointer to the MockQuicConnectionHelper to use for the session.
 // crypto_client_config: Pointer to the crypto client config.
 // client_connection: Pointer reference for newly created
 //   connection.  This object will be owned by the
 //   client_session.
 // client_session: Pointer reference for the newly created client
 //   session.  The new object will be owned by the caller.
 void CreateClientSessionForTest(QuicServerId server_id,
                                 bool supports_stateless_rejects,
                                 QuicTime::Delta connection_start_time,
                                 QuicVersionVector supported_versions,
-                                MockConnectionHelper* helper,
+                                MockQuicConnectionHelper* helper,
                                 MockAlarmFactory* alarm_factory,
                                 QuicCryptoClientConfig* crypto_client_config,
                                 PacketSavingConnection** client_connection,
                                 TestQuicSpdyClientSession** client_session);
 
 // Creates a server session for testing.
 //
 // server_id: The server id associated with this stream.
 // connection_start_time: The time to set for the connection clock.
 //   Needed for strike-register nonce verification.  The server
 //   connection_start_time should be synchronized witht the client
 //   start time, otherwise nonce verification will fail.
 // supported_versions: Set of QUIC versions this server supports.
-// helper: Pointer to the MockConnectionHelper to use for the session.
+// helper: Pointer to the MockQuicConnectionHelper to use for the session.
 // crypto_server_config: Pointer to the crypto server config.
 // server_connection: Pointer reference for newly created
 //   connection.  This object will be owned by the
 //   server_session.
 // server_session: Pointer reference for the newly created server
 //   session.  The new object will be owned by the caller.
 void CreateServerSessionForTest(
     QuicServerId server_id,
     QuicTime::Delta connection_start_time,
     QuicVersionVector supported_versions,
-    MockConnectionHelper* helper,
+    MockQuicConnectionHelper* helper,
     MockAlarmFactory* alarm_factory,
     QuicCryptoServerConfig* crypto_server_config,
     QuicCompressedCertsCache* compressed_certs_cache,
     PacketSavingConnection** server_connection,
     TestQuicSpdyServerSession** server_session);
 
 // Helper to generate client side stream ids, generalizes
 // kClientDataStreamId1 etc. above.
 QuicStreamId QuicClientDataStreamId(int i);
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_