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

net/quic/test_tools/quic_test_utils.h

Index: net/quic/test_tools/quic_test_utils.h
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index b770728dd054ac3d79e03b5be9c0bafcc97c1500..606c9fa6057bc8ecce644044dbb2166c6ee1040a 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -900,6 +900,73 @@ class MockReceivedPacketManager : public QuicReceivedPacketManager {
   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.