Add a merely pass-through QuicMultipathSentPacketManager. Protected behind blocked flag FLAGS_quic_…

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 882 matching lines @@
                     const QuicPacketHeader& header,
                     QuicTime receipt_time));
   MOCK_METHOD1(IsMissing, bool(QuicPacketNumber packet_number));
   MOCK_METHOD1(IsAwaitingPacket, bool(QuicPacketNumber packet_number));
   MOCK_METHOD1(UpdatePacketInformationSentByPeer,
                void(const QuicStopWaitingFrame& stop_waiting));
   MOCK_CONST_METHOD0(HasNewMissingPackets, bool(void));
   MOCK_CONST_METHOD0(ack_frame_updated, bool(void));
 };
 
+class MockSentPacketManager : public QuicSentPacketManagerInterface {
+ public:
+  MockSentPacketManager();
+  ~MockSentPacketManager() override;
+
+  MOCK_METHOD1(SetFromConfig, void(const QuicConfig&));
+  MOCK_METHOD2(ResumeConnectionState,
+               void(const CachedNetworkParameters&, bool));
+  MOCK_METHOD1(SetNumOpenStreams, void(size_t));
+  MOCK_METHOD1(SetMaxPacingRate, void(QuicBandwidth));
+  MOCK_METHOD0(SetHandshakeConfirmed, void(void));
+  MOCK_METHOD2(OnIncomingAck, void(const QuicAckFrame&, QuicTime));
+  MOCK_CONST_METHOD2(IsUnacked, bool(QuicPathId, QuicPacketNumber));
+  MOCK_CONST_METHOD2(HasRetransmittableFrames,
+                     bool(QuicPathId, QuicPacketNumber));
+  MOCK_METHOD1(RetransmitUnackedPackets, void(TransmissionType));
+  MOCK_METHOD0(MaybeRetransmitTailLossProbe, bool(void));
+  MOCK_METHOD0(NeuterUnencryptedPackets, void(void));
+  MOCK_CONST_METHOD0(HasPendingRetransmissions, bool(void));
+  MOCK_METHOD0(NextPendingRetransmission, PendingRetransmission(void));
+  MOCK_CONST_METHOD0(HasUnackedPackets, bool(void));
+  MOCK_CONST_METHOD1(GetLeastUnacked, QuicPacketNumber(QuicPathId));
+  MOCK_METHOD6(OnPacketSent,
+               bool(SerializedPacket*,
+                    QuicPathId,
+                    QuicPacketNumber,
+                    QuicTime,
+                    TransmissionType,
+                    HasRetransmittableData));
+  MOCK_METHOD0(OnRetransmissionTimeout, void(void));
+  MOCK_METHOD3(TimeUntilSend,
+               QuicTime::Delta(QuicTime, HasRetransmittableData, QuicPathId*));
+  MOCK_CONST_METHOD0(GetRetransmissionTime, const QuicTime(void));
+  MOCK_CONST_METHOD0(GetRttStats, const RttStats*(void));
+  MOCK_CONST_METHOD0(BandwidthEstimate, QuicBandwidth(void));
+  MOCK_CONST_METHOD0(SustainedBandwidthRecorder,
+                     const QuicSustainedBandwidthRecorder*(void));
+  MOCK_CONST_METHOD0(GetCongestionWindowInTcpMss, QuicPacketCount(void));
+  MOCK_CONST_METHOD1(EstimateMaxPacketsInFlight,
+                     QuicPacketCount(QuicByteCount));
+  MOCK_CONST_METHOD0(GetCongestionWindowInBytes, QuicByteCount(void));
+  MOCK_CONST_METHOD0(GetSlowStartThresholdInTcpMss, QuicPacketCount(void));
+  MOCK_METHOD1(CancelRetransmissionsForStream, void(QuicStreamId));
+  MOCK_METHOD2(OnConnectionMigration, void(QuicPathId, PeerAddressChangeType));
+  MOCK_CONST_METHOD0(IsHandshakeConfirmed, bool(void));
+  MOCK_METHOD1(SetDebugDelegate, void(DebugDelegate*));
+  MOCK_CONST_METHOD1(GetLargestObserved, QuicPacketNumber(QuicPathId));
+  MOCK_CONST_METHOD1(GetLargestSentPacket, QuicPacketNumber(QuicPathId));
+  MOCK_CONST_METHOD1(GetLeastPacketAwaitedByPeer, QuicPacketNumber(QuicPathId));
+  MOCK_METHOD1(SetNetworkChangeVisitor, void(NetworkChangeVisitor*));
+  MOCK_CONST_METHOD0(InSlowStart, bool(void));
+  MOCK_CONST_METHOD0(GetConsecutiveRtoCount, size_t(void));
+  MOCK_CONST_METHOD0(GetConsecutiveTlpCount, size_t(void));
+};
+
+class MockConnectionCloseDelegate
+    : public QuicConnectionCloseDelegateInterface {
+ public:
+  MockConnectionCloseDelegate();
+  ~MockConnectionCloseDelegate() override;
+
+  MOCK_METHOD3(OnUnrecoverableError,
+               void(QuicErrorCode,
+                    const std::string&,
+                    ConnectionCloseSource source));
+};
+
 // 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 MockQuicConnectionHelper to use for the session.
@@ skipping 40 matching lines @@
     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_